• Physical Package: The physical package is a microprocessor. For each physical package, it plugs into a physical socket on a mainboard, and may contain one or more processor cores.
• Processor Core: The circuitry that provides ability to decode and execute instructions. A processor core may contain one or more logical processors.
• Logical Processor: The basic unit of processor hardware that allows the software executive in the operating system to dispatch a task or execute a thread context. Each logical processor can execute only one thread context at a time.
• Hyper-Threading: A feature within the IA-32 family of processors, where each processor core provides the functionality of more than one logical processor.
• Multi-Core Processor: A physical package that contains more than one processor core.

(The above definitions come from Intel’s website, it would be decent to identify what we’re talking.)

As we know, on a running Linux/UNIX system, a detailed information of CPU can be retrieved from /proc/cpuinfo, but how can we identify the logical processors and the physical cores smartly?  Basically, there are two rules that will help you achieve these info.

1. Any CPU with the same “core id” are hyperthreads in the same processor core, which means this process core has Hyper-Threading enabled.
2. The “physical id” identifies physical package. Any cpu with the same physical id are threads or cores in the same physical socket.

Let me take Dell PowerEdge 2950 as an example, we’re running Red Hat Enterprise Linux AS release 4 Update 7 on this server.

$ cat /proc/cpuinfo
processor       : 0
vendor_id       : GenuineIntel
cpu family      : 6
model           : 23
model name      : Intel(R) Xeon(R) CPU           E5405  @ 2.00GHz
stepping        : 10
cpu MHz         : 1995.005
cache size      : 6144 KB
physical id     : 0
siblings        : 4
core id         : 0
cpu cores       : 4
fpu             : yes
fpu_exception   : yes
cpuid level     : 13
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx lm pni monitor ds_cpl tm2 cx16 xtpr lahf_lm
bogomips        : 3992.87
clflush size    : 64
cache_alignment : 64
address sizes   : 38 bits physical, 48 bits virtual
power management:                                                                   

processor       : 1
vendor_id       : GenuineIntel
cpu family      : 6
model           : 23
model name      : Intel(R) Xeon(R) CPU           E5405  @ 2.00GHz
stepping        : 10
cpu MHz         : 1995.005
cache size      : 6144 KB
physical id     : 1
siblings        : 4
core id         : 4
cpu cores       : 4
fpu             : yes
fpu_exception   : yes
cpuid level     : 13
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx lm pni monitor ds_cpl tm2 cx16 xtpr lahf_lm
bogomips        : 3990.03
clflush size    : 64
cache_alignment : 64
address sizes   : 38 bits physical, 48 bits virtual
power management:                                                                   

processor       : 2
vendor_id       : GenuineIntel
cpu family      : 6
model           : 23
model name      : Intel(R) Xeon(R) CPU           E5405  @ 2.00GHz
stepping        : 10
cpu MHz         : 1995.005
cache size      : 6144 KB
physical id     : 0
siblings        : 4
core id         : 2
cpu cores       : 4
fpu             : yes
fpu_exception   : yes
cpuid level     : 13
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx lm pni monitor ds_cpl tm2 cx16 xtpr lahf_lm
bogomips        : 3990.01
clflush size    : 64
cache_alignment : 64
address sizes   : 38 bits physical, 48 bits virtual
power management:                                                                   

processor       : 3
vendor_id       : GenuineIntel
cpu family      : 6
model           : 23
model name      : Intel(R) Xeon(R) CPU           E5405  @ 2.00GHz
stepping        : 10
cpu MHz         : 1995.005
cache size      : 6144 KB
physical id     : 1
siblings        : 4
core id         : 6
cpu cores       : 4
fpu             : yes
fpu_exception   : yes
cpuid level     : 13
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx lm pni monitor ds_cpl tm2 cx16 xtpr lahf_lm
bogomips        : 3990.03
clflush size    : 64
cache_alignment : 64
address sizes   : 38 bits physical, 48 bits virtual
power management:                                                                   

processor       : 4
vendor_id       : GenuineIntel
cpu family      : 6
model           : 23
model name      : Intel(R) Xeon(R) CPU           E5405  @ 2.00GHz
stepping        : 10
cpu MHz         : 1995.005
cache size      : 6144 KB
physical id     : 0
siblings        : 4
core id         : 1
cpu cores       : 4
fpu             : yes
fpu_exception   : yes
cpuid level     : 13
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx lm pni monitor ds_cpl tm2 cx16 xtpr lahf_lm
bogomips        : 3989.99
clflush size    : 64
cache_alignment : 64
address sizes   : 38 bits physical, 48 bits virtual
power management:                                                                   

processor       : 5
vendor_id       : GenuineIntel
cpu family      : 6
model           : 23
model name      : Intel(R) Xeon(R) CPU           E5405  @ 2.00GHz
stepping        : 10
cpu MHz         : 1995.005
cache size      : 6144 KB
physical id     : 1
siblings        : 4
core id         : 5
cpu cores       : 4
fpu             : yes
fpu_exception   : yes
cpuid level     : 13
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx lm pni monitor ds_cpl tm2 cx16 xtpr lahf_lm
bogomips        : 3990.02
clflush size    : 64
cache_alignment : 64
address sizes   : 38 bits physical, 48 bits virtual
power management:                                                                   

processor       : 6
vendor_id       : GenuineIntel
cpu family      : 6
model           : 23
model name      : Intel(R) Xeon(R) CPU           E5405  @ 2.00GHz
stepping        : 10
cpu MHz         : 1995.005
cache size      : 6144 KB
physical id     : 0
siblings        : 4
core id         : 3
cpu cores       : 4
fpu             : yes
fpu_exception   : yes
cpuid level     : 13
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx lm pni monitor ds_cpl tm2 cx16 xtpr lahf_lm
bogomips        : 3990.01
clflush size    : 64
cache_alignment : 64
address sizes   : 38 bits physical, 48 bits virtual
power management:                                                                   

processor       : 7
vendor_id       : GenuineIntel
cpu family      : 6
model           : 23
model name      : Intel(R) Xeon(R) CPU           E5405  @ 2.00GHz
stepping        : 10
cpu MHz         : 1995.005
cache size      : 6144 KB
physical id     : 1
siblings        : 4
core id         : 7
cpu cores       : 4
fpu             : yes
fpu_exception   : yes
cpuid level     : 13
wp              : yes
flags           : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush dts acpi mmx fxsr sse sse2 ss ht tm syscall nx lm pni monitor ds_cpl tm2 cx16 xtpr lahf_lm
bogomips        : 3990.03
clflush size    : 64
cache_alignment : 64
address sizes   : 38 bits physical, 48 bits virtual
power management:

From the outputs, we can see that, there’re 8 processor-cores in 2 physical packages (in other words, there’re two quad-cores CPU on this server), and none of them has Hyper-Threading enabled. Here’s a quick explanation for some keywords that listed above:

• The processor entry contains a unique identifier for this logical processor.
• The physical id entry contains a unique identifier for each physical package.
• The core id entry holds a unique identifier for each core.
• The siblings entry lists the number of logical processors that exist on the same physical package.
• The cpu cores entry contains the number of cores that exist on the same physical package.
• The vendor id entry holds the string. GenuineIntel if the processor is an Intel processor, and AuthenticAMD if it’s an AMD processor.

There are some commands here to help identify these type of information quickly on a running Linux:

1. Total amount of processors including the logical ones:

   # cat /proc/cpuinfo | grep "processor"| wc -l

2. Total amount of CPU package:

   # cat /proc/cpuinfo | grep "physical id" | sort | uniq | wc -l

3. How many cores for each CPU. (Here we should call CPU as physical package as we mentioned above):

   # cat /proc/cpuinfo | grep "cpu cores" | wc -l

4. For each physical CPU, the amount of Logical CPU (the logical CPU can be physical cores, soft cores like threaded, or both).

   # cat /proc/cpuinfo | grep "siblings"

Finally, please note that the msg from /proc/cpuinfo depends on your operating systems, which means it’s not always right or up-to-date. If you faced any issues, please create a thread at our support forum, thanks!

Cpulimit is a simple program that attempts to limit the CPU usage of a process. It’s expressed in percentage, not in cpu time.

This is useful to control batch jobs, when you don’t want them to eat too much CPU resource. It does not act on the nice value or other scheduling priority stuff, but on the real CPU usage. Also, it is able to adapt itself to the overall system load, dynamically and quickly.

If your machine has one processor you can limit the percentage from 0% to 100%, which means that if you set for example 50%, your process cannot use more than 500 ms of cpu time for each second. But if your machine has four processors, percentage may vary from 0% to 400%, so setting the limit to 200% means to use no more than half of the available power. In any case, the percentage is the same of what you see when you run top.

Cpulimit should run at least with the same user running the controlled process. It’s much better if you run cpulimit as root, in order to have a higher priority and a more precise control.

Installation of CPUlimit

CPUlimit is available for Debian and Ubuntu, so it can be installed by “aptitude install cpulimit“. If you’re running CentOS or other system, you might need to compile it from source code by yourself.

After the installation, let’s take a look at the cpulimit man page to learn how to use it:

cpulimit TARGET [OPTIONS...]

TARGET must be exactly one of these:

-p, --pid=N              pid of the process
-e, --exe=FILE           name of the executable program file
-P, --path=PATH          absolute path name of the executable program file

OPTIONS
-l, --limit=N            percentage of CPU allowed from 0 to 100 (mandatory)
-v, --verbose            show control statistics
-z, --lazy               exit if there is no suitable target process, or if it dies
-h, --help               display this help and exit

Usage of CPUlimit

These examples are from CPUlimit man page as well:

Assuming  you  have  started "foo --bar" and you find out with top(1) or ps(1) that this process uses all your CPU time you can either

# cpulimit -e foo -l 50
limits the CPU usage of the process by acting on the executable program file. Note: the argument "--bar" is omitted.

# cpulimit -p 1234 -l 50
limits the CPU usage of the process by acting on its PID, as shown by ps(1)

# cpulimit -P /usr/bin/foo -l 50
same as -e but uses the absolute path name

Now let’s assume that we want to limit the process httpd to 45%. This is how we do it:

cpulimit -e httpd -l 45

The -e switch takes the name of the executable program file. You can take that name from the output of the top command.

Instead of using the name of the executable program file, we can use the process ID with the -p switch. You can find out the process ID of the httpd process as follows:

ps aux | grep httpd

Let’s assume the httpd process ID is 13500; we can then limit that process to 45% CPU usage as follows:

cpulimit -p 13500 -l 45

Instead of using the name of the executable file (-e) of the process ID (-p), we can also pass the absolute path name of the executable program file to cpulimit with the -P switch.

The absolute path name of the httpd executable is /usr/sbin/httpd so we’d use the following command:

cpulimit -P /usr/sbin/httpd -l 45

Please note that cpulimit will run in the foreground of your terminal until you terminate it with CTRL+C – terminating it will also remove any CPU limits.

Further Readings

CPUlimit Homepage:  http://cpulimit.sourceforge.net/

AND Homepage:  http://and.sourceforge.net/

Taskset is used to set or retrieve the CPU affinity of a running process given its PID or to launch a new COMMAND with a given CPU affinity. Under latest version of Debian / Ubuntu / Redhat Linux taskset is installed by default with util-linux package.

The CPU affinity is represented as bitmask, with the lowest order bit corresponding to the first logical CPU and the highest order bit corresponding to the last logical CPU. For example:

* 0×00000001 is processor (1st processor)
* 0×00000003 is processors and #1
* 0×00000004 is processors (3rd processor)

To set the processor affinity of process 13545 to processor (1st processor) type following command:

# taskset 0×00000001 -p 13545
If you find a bitmask hard to use, then you can specify a numerical list of processors instead of a bitmask using -c flag:
# taskset -c 1 -p 13545
# taskset -c 3,4 -p 13545

Where,
* -p : Operate on an existing PID and not launch a new task (default is to launch a new task) ]]> http://www.admon.org/how-to-bind-a-certain-process-to-specified-core/feed/ 0