Linux binds different threads to different cores and CPUs--PTHREAD_SETAFFINITY_NP

===============================================================

Linux single-process multithreaded program, to achieve the average allocation of each thread to the multicore CPU, there are 2 main methods

1: Using the Linux system's own thread switching mechanism, Linux has a service called irqbalance, this service is the Linux system comes with, the default will start, the role of the service is to distribute multithreading evenly on each core of the CPU, as long as the service does not stop, Multi-threaded allocations can be implemented on their own. Note, however, that if there is a loop inside the thread function and there are no system calls within that loop, it can cause the CPU time of the thread to not be switched out. That is, the CPU is full, at this time add a system call, such as sleep, the CPU time of the thread can be switched out.

2: Use the Pthread Library's own thread affinity setting function to set the thread to run on a CPU core, which needs to be implemented inside the program. Also, be careful not to confuse the process affinity setting.

12345678910111213

intpthread_setaffinity_np(pthread_t thread, size_t cpusetsize，constcpu_set_t *cpuset);intpthread_getaffinity_np(pthread_t thread, size_tcpusetsize, cpu_set_t *cpuset);从函数名以及参数名都很明了，唯一需要点解释下的可能就是cpu_set_t这个结构体了。这个结构体的理解类似于select中的fd_set，可以理解为cpu集，也是通过约定好的宏来进行清除、设置以及判断：//初始化，设为空void CPU_ZERO (cpu_set_t *set); //将某个cpu加入cpu集中 voidCPU_SET (intcpu, cpu_set_t *set); //将某个cpu从cpu集中移出 voidCPU_CLR (intcpu, cpu_set_t *set); //判断某个cpu是否已在cpu集中设置了 int CPU_ISSET (intcpu, constcpu_set_t *set);

=================================================================

Transferred from: http://blog.csdn.net/sprintfwater/article/details/39203049

To bind a thread to a different processor:

There are two CPUs, one CPU and five cores.

[HTML]View PlainCopyprint?

2. #define  _GNU_SOURCE                                                                                                                                                      
4. #include <stdio.h>
6. #include <string.h>
8. #include <stdlib.h>
10. #include <stdint.h>
12. #include <sched.h>
16. inline int set_cpu (int i)
18. {
20. cpu_set_t Mask;
22. Cpu_zero (&mask);
26. Cpu_set (I,&mask);
30. printf ("Thread%u, i =%d\n", pthread_self (), i);
32. if (-1 = = PTHREAD_SETAFFINITY_NP (pthread_self (), sizeof (mask), &mask))
34. {
36. fprintf (stderr, "pthread_setaffinity_np erro\n");
38. return-1;
40. }
42. return 0;
44. }
46. void *thread_ip_bitmap_set (void *p)
48. {
50. uint32_t i, IP;
52. struct Id_ipmap *entry;
54. thread_info_t *info = (thread_info_t *) p;
58. if (Set_cpu (info->id))
60. {
62. return NULL;
64. }
68. printf ("info->id =%d;  info->start =%d; info->end =%d, sub =%d\n ", info->id, info->start, info->end, info->start-  info->end);
70. for (i = info->start; i < info->end; ++i) {
72. entry = &ipmap_queue[i];
74. for (IP = entry->ip_start; IP < entry->ip_end; ip++) {
76. Ip_bitmap_set (Adns_htobe32 (IP), entry->id);
78. }
80. }
82. printf ("info->id =%d finished\n", info->id);
84. return NULL;
86. }
94. int main ()
96. {
98. For (thread_index=0; Thread_index < thread_index++)
100. Pthread_create (&thread_id[thread_index],null, Thread_ip_bitmap_set, &thread_info[thread_index]);
102. }

[CPP]View PlainCopyprint?

2. #define _gnu_source
4. #include <sched.h>
6. #include <unistd.h>
8. #include <sys/types.h>
10. #include <string.h>
12. #include <stdio.h>
14. #include <errno.h>
16. #include <pthread.h>
22. inline int set_cpu (int i)
24. {
26. cpu_set_t Mask;
28. Cpu_zero (&mask);
32. Cpu_set (I,&mask);
36. printf ("thread%u, i =%d\n", pthread_self (), i);
38. if ( -1 = = PTHREAD_SETAFFINITY_NP (Pthread_self (),sizeof (mask), &mask))
40. {
42. return-1;
44. }
46. return 0;
48. }
50. void *fun (void *i)
52. {
54. if (set_cpu (* (int *) i))
56. {
58. printf ("Set CPU erro\n");
60. }
62. a long long a = 0;
64. While (1)
66. {
68. A + = rand ();
70. }
72. return NULL;
74. }
78. int main (int argc, const char * argv[]) {
80. int i;
82. int cpu_nums = sysconf (_sc_nprocessors_conf);
86. printf ("cpu_numbs =%d\n", cpu_nums);
88. pthread_t THREAD[10];
90. int tmp[10];
94. For (i = 0; i <; ++i)
96. {
98. Tmp[i] = i;
100. Pthread_create (&thread[i],null,fun, &tmp[i]);
102. }
108. For (i = 0; i <; ++i)
110. {
112. Pthread_join (Thread[i],null);
114. }
118. return 0;
120. }

Reprint: http://blog.csdn.net/xluren/article/details/43202201

Coolshell's latest article, "Performance Tuning Strategy", in the "Multicore CPU Tuning" section, mentions that "we can't load balance the operating system because we know our own programs better, so we can manually allocate CPU cores for them without too much CPU0." or let our critical processes and a bunch of other processes squeeze together. ”。 The article mentions a tool under Linux, Taskset, which can set the CPU for a single process to run.

At the same time, because of the recent data on Redis, Redis is a single-process model that, in order to take full advantage of multicore CPUs, often launches multiple instances on one server. To reduce the overhead of switching, it is necessary to specify the CPU on which each instance runs.

The following describes the Taskset command and the sched_setaffinity system call, both of which can specify the CPU instances that the process runs.

1.taskset

Taskset is a command provided by Linux (Ubuntu system may need to install itself, Schedutils package). He can have a program run on some (or) of the CPUs.

The following are examples of redis-server.

1) shows the CPU the process is running on

Command Taskset-p 21184

Show Results:

PID 21184 ' s current affinity mask:ffffff

Note: 21184 is redis-server running PID

The ffffff of the result is actually a binary 24 low 1 bitmask, each 1 corresponds to 1 CPUs, indicating that the process runs on 24 CPUs

2) Specify that the process is running on a specific CPU

Command TASKSET-PC 3 21184

Show Results:

PID 21184 ' s current affinity list:0-23
PID 21184 ' s new affinity List:3

Note: 3 means that the CPU will only run on the 4th CPU (counting from 0).

3) Specify CPU when process starts

Command taskset-c 1./redis-server. /redis.conf

Combined with the above three examples, and then look at the Taskset manual, it is more clear.

OPTIONS
-P,--pid
operate on the existing PID and not launch a new task

-C,--cpu-list
Specify a numerical list of processors instead of a bitmask. The list may contain multiple items, separated by comma, and ranges. For example, 0,5,7,9-11.

2.sched_setaffinity system Call

The following article is partly translated from: http://www.thinkingparallel.com/2006/08/18/more-information-on-pthread_setaffinity_np-and-sched_setaffinity/

Problem description

Sched_setaffinity can bind a process to a specific CPU. You know your program better than the operating system, and you might want to do this to avoid the scheduler's foolish scheduling of your programs, or to avoid the overhead of caching failures in multithreaded programs. The following is an example of sched_setaffinity, whose function manual can be consulted (http://www.linuxmanpages.com/man2/sched_getaffinity.2.php):

 1/* Short test program to test sched_setaffinity 2 * (which sets the affinity of processes to processors). 3 * COMPILE:GCC sched_setaffinity_test.c 4 *             -O sched_setaffinity_test-l M 5 * Usage:./sched_setaffinity_test 6 * 7 * Open a "top"-window at the same time and see all the work 8 * being do on CPU 0 First and after a short wait on CPU 1. 9 * Repeat with different numbers to make sure, it's not A10 * coincidence.11 */12  13 #include <stdio.h>14 #i Nclude <math.h>15 #include <sched.h>16  17 double waste_time (long N) * {    Double res = 0;2 0     Long i = 0;21     while (i <n * 200000) {$         i++;23     & nbsp    Res + = sqrt (i),    }25     return res;26}27  28 int main (int argc, char **argv) 29 {30     unsigned long mask = 1; /* Processor 0 */31  32    /* bind process to processor 0 */33     if (sched_setaffinity (0, sizeof (mask), &mask) <0) {$         perror ("s Ched_setaffinity ")    }36  37    /* Waste some time so the work is visible with" top "*/38 & nbsp   printf ("Result:%f\n", Waste_time),  40     mask = 2; /* Process switches to processor 1 now */41     if (sched_setaffinity (0, sizeof (mask), &mask) <0) {&NB Sp       perror ("sched_setaffinity"),    }44  45    /* Waste some more time to SE E The processor switch */46     printf ("Result:%f\n", Waste_time (2000)); 47}

Adjust the waste_time parameters according to the speed of your CPU. You can then use the top command to see the process switching between different CPUs. (press "1" after starting the top command to see the individual CPUs).

The settings for affinity are inherited between the parent and child processes. So, with a bold guess, Taskset is actually first executing the sched_setaffinity system call and then fork+exec the user-specified process.

Linux binds different threads to different cores and CPUs--PTHREAD_SETAFFINITY_NP