Thread-bound CPU core-sched_setaffinity

CPU affinity refers to the ability to bind one or more processes to one or more processors on a Linux system. The CPU affinity mask for a process determines which CPU or CPUs the process will run on. In a multiprocessor system, a mask that sets the affinity of the CPU may achieve better performance.

A CPU affinity mask uses a cpu_set_t struct to represent a collection of CPUs, and several of the following macros operate on the mask set individually: • Cpu_zero () clears a collection ·   Cpu_set () and CPU_CLR () each add a given CPU number to a set or remove it from a collection. · Cpu_isset () checks if a CPU number is in this collection.

The following two functions are used to set the get thread CPU affinity State:
sched_setaffinity (pid_t pid, unsigned int cpusetsize, cpu_set_t *mask)
This function sets the process to PID and lets it run on the CPU set by mask. If the PID has a value of 0, it indicates that the current process is specified. Causes the current process to run on those CPUs set by mask. The second parameter, Cpusetsize, is the length of the number specified by mask. Usually set to sizeof (cpu_set_t). If the process specified by the current PID is not running at this time on any of the CPUs specified by mask, the specified process will be migrated from the other CPU to the specified CPU on mask.
sched_getaffinity (pid_t pid, unsigned int cpusetsize, cpu_set_t *mask)
The function obtains the CPU bit mask of the process indicated by the PID and returns the mask to the structure that the mask points to. That is, which CPUs the specified PID can currently run on. Similarly, if the PID has a value of 0. Also indicates that the current process

2. definition of cpu_set_t
6. # Define __cpu_setsize 1024x768
8. # Define __ncpubits (8 * sizeof (__CPU_MASK))
10. typedef unsigned long int __cpu_mask;
12. # define __cpuelt (CPU) (CPU)/__ncpubits
14. # define __cpumask (CPU) ((__cpu_mask) 1 << ((CPU)% __ncpubits))
16. typedef struct
18. {
20. __cpu_mask __bits[__cpu_setsize/__ncpubits];
22. } cpu_set_t;
26. # define __cpu_zero (CPUSETP) \
28. Do {\
30. unsigned int __i; \
32. cpu_set_t *__arr = (CPUSETP); \
34. For (__i = 0; __i < sizeof (cpu_set_t)/sizeof (__cpu_mask); ++__i) \
36. __arr->__bits[__i] = 0; \
38. } while (0)
40. # define __cpu_set (CPU, cpusetp) \
42. ((CPUSETP)->__bits[__cpuelt (CPU)] |= __cpumask (CPU))
44. # define __CPU_CLR (CPU, cpusetp) \
46. ((CPUSETP)->__bits[__cpuelt (CPU)] &= ~__cpumask (CPU))
48. # define __cpu_isset (CPU, cpusetp) \
50. (((CPUSETP)->__bits[__cpuelt (CPU)] & __cpumask (CPU))! = 0)

Test code:

2. #include<stdlib.h>
4. #include<stdio.h>
6. #include<sys/types.h>
8. #include<sys/sysinfo.h>
10. #include<unistd.h>
14. #define __USE_GNU
16. #include<sched.h>
18. #include<ctype.h>
20. #include<string.h>
22. #include<pthread.h>
24. #Define Thread_max_num //1 CPUs up to the maximum number of processes
28. int num=0; number of cores in//cpu
30. void* threadfun(void* Arg) //arg pass thread designator (self-defined)
32. {
34. cpu_set_t Mask; the collection of//cpu nuclei
36. cpu_set_t get; //Gets the CPU in the collection
38. int *a = (int *) arg;
40. printf ("The A is:%d\n", *a); //Display is the first few threads
42. Cpu_zero (&mask); //Empty
44. Cpu_set (*a,&mask); //Set affinity value
46. if (sched_setaffinity (0, sizeof (mask), &mask) = = -1)//Set Thread CPU affinity
48. {
50. printf ("warning:could not set CPU affinity, continuing...\n");
52. }
54. While (1)
56. {
58. Cpu_zero (&get);
60. if (sched_getaffinity (0, sizeof (GET), &get) = = -1)//Get thread CPU affinity
62. {
64. printf ("Warning:cound not get thread affinity, continuing...\n");
66. }
68. int i;
70. For (i = 0; i < num; i++)
72. {
74. if (Cpu_isset (i, &get))//Determine which CPU the thread is affinity with
76. {
78. printf ("This thread%d is running processor:%d\n", i,i);
80. }
82. }
84. }
88. return NULL;
90. }
94. int main(int argc, char* argv[])
96. {
98. num = sysconf (_sc_nprocessors_conf); //Get the number of cores
100. pthread_t Thread[thread_max_num];
102. printf ("System has%i processor (s). \ n ", num);
104. int tid[thread_max_num];
106. int i;
108. For (i=0;i<num;i++)
110. {
112. Tid[i] = i; //Each thread must have a tid[i]
114. Pthread_create (&thread[0],null,threadfun, (void*) &tid[i]);
116. }
118. For (i=0; i< num; i++)
120. {
122. Pthread_join (Thread[i],NULL); Wait for all threads to end, thread is dead loop so Ctrl + C ends
124. }
126. return 0;
128. }

Compile command: gcc bind.c-o bind-lpthread

Execution:./bind

Output result: slightly

Special attention:

#define __USE_GNU Don't write a # define _use_gnu

#include <pthread.h> must be written after the # define __USE_GNU, or the compilation will error

View your thread condition you can use top-h in another window to view the threads at execution time, and view the situation on each core using the top command and then the number "1".

Thread-bound CPU core-sched_setaffinity