Number of engines
ASE creates an OS-level process for each engine you define. You can change the number of engines by using the following command:
sp_configure "engine", N
(replace N by the number of engines you want to configure).
Usually, if you server is almost exclusively used for ASE and you have X CPU cores available, you will want to configure X-1 engines. So assuming you have a dedicated server with 4 CPU cores, you’ll want to configure 3 engines.
You can change this setting also in the SYBASE.cfg:
[Processors] max online engines = 3 number of engines at startup = 3
The first line defines that there will be 3 engines and the second one that all 3 engines will be started by default.
Even though in many cases, it makes sense to set the same value to both parameters so that you automatically use all available engines. You can also set the second one to a lower value and benchmark the system with less engines and then bring one additional engine online after another.
Increasing the max number of online engines to higher number than the number of available logical CPU’s makes no sense. So I’d always recommend setting it to the total number of logical CPU’s or this number minus 1. Whether you bring them all online at startup or not depends on what else is running on the system and the specific workload you have on this server.
If you configure too many ASE engines for the underlying CPU’s, you will observe some significant loss of throughput. It is due to the high number of involuntary context switches.
Hyper-Threading creates “virtual CPU’s”. So an application running on a system where Hyper-Threading is enabled will think that there are twice as many CPUs as physically available. ASE will not make any difference between virtual CPU’s and real CPU’s.
Although Hyper-Threading provides the ability run two ASE engines for one physical processor, you need to keep in mind that it is still not equivalent to running two engines with two physical processors.
In many cases, you should consider switching off Hyper-Threading. Except if you actually only have very few physical CPU cores available, HT will probably not bring you the expected benefits. You might run into problems because ASE doesn’t see that two CPU’s are basically running on the same physical CPU and it should rather distribute the load between physical CPU’s instead of distributing two queries to the 2 CPU’s running on same physical CPU. Also ASE could schedule queries run at the same time to run only on the virtual CPU’s while it would be better to run them on the real CPU’s (although theoretically, there should be no difference in performance between a virtual CPU and a real one).
But keep in mind that whether HT will bring performance benefits or on the contrary make you system slower really depends on the system itself. It highly depends on your actual hardware and workload. So benchmarking it on the specific system might still be a good idea.
ASE 15.7 comes with a threaded kernel. It takes advantage of threaded CPU architectures. It can thus reduce context switching to threads instead of processes, which brings a performance boost. But this is not related to Hyper-Threading.
Using the default kernel for ASE 15.7, each engine is a thread which lives in a thread pool instead of being an OS process (which was already the case for ASE on Windows even before ASE 15.7).
The processes for the different ASE engines have by default no affinity to the physical or virtual processors. Usually, it is not required to force any CPU affinity as ASE will handle it properly.
Here’s an example with 3 engines running and 3 heavy queries running in parallel:
Here you see that there are 4 CPUs and 3 engines running using CPU0, CPU1 and CPU3. You can also press “f”, “j” and return in top to have an additional column displayed which will explicitely show which engine is using which CPU:
The column “p” shows that the 3 dataserver processes use the CPUs 0,1 and 3.
In some cases (not sure when or why this happens), you will see that all dataserver processes will be using the same CPU even though they are processing different queries. Since multiple tasks have to be handled by the same CPU, this will make each task slower and also cause alot of overhead due to task switching.
If this happens, you can use the a “dbcc tune” command to configure a CPU affinity. This can be done by using the following command:
dbcc tune(cpuaffinity, -1, "on")
The -1 parameter is the start CPU. This one will always be skipped. So setting it to -1 means that:
- The first engine will be bound to CPU0
- The second one to CPU1
- The third one to CPU2
If you want to keep CPU0 for other processes, you’d use:
dbcc tune(cpuaffinity, 0, "on")
This will do the following:
- The first engine will be bound to CPU1
- The second one to CPU2
- The third one to CPU3
After that you should see that all dataserver processes are using different CPUs.
Note: The setting will be active only until the ASE server is restarted. So the dbcc tune command must be reissued each time ASE is restarted.
Also note that some operating systems do not support CPU affinity. In this case, the dbcc tune command will be silently ignored.