正文

pthread_setaffinity_np2011-11-19 09:32:00

【评论】 【打印】 【字体：大 中 小】 本文链接：http://blog.pfan.cn/lqf110/52954.html

分享到：

http://www.thinkingparallel.com/2006/08/18/more-information-on-pthread_setaffinity_np-and-sched_setaffinity/

 

More information on pthread_setaffinity_np and sched_setaffinity

If you're new here and like what you read, you may want to subscribe to my RSS blog feed or free email updates. Thanks for visiting!

Skimming through the activity logs of this blog, I can see that many people come here looking for information about pthread_setaffinity_np. I mentioned it briefly in my article about Opteron NUMA-effects, but barely touched it because I had found a more satisfying solution for my personal use (taskset). And while I do not have in depth knowledge of the function, maybe the test programs I wrote will be of some help to someone to understand the function better. I will also post my test program for sched_setaffinity here while I am at it, simply because the two offer similar functionality.

Problem description

Short recap: The problem both functions are trying to solve is to bind a thread (pthread_setaffinity_np) or process (sched_setaffinity) to one or more user-defined processors. You may want to do this because the scheduler is doing something stupid or because you want to keep your caches hot at all costs in a multithreaded program. More information about affinity on Linux can be found in this article on CPU affinity by Robert Love.

sched_setaffinity example

Here it goes. Not much left for me to explain, as it is documented.

PLAIN TEXT
C:
  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 -lm
  5. * Usage: ./sched_setaffinity_test
  6. *
  7. * Open a "top"-window at the same time and see all the work
  8. * being done on CPU 0 first and after a short wait on CPU 1.
  9. * Repeat with different numbers to make sure, it is not a
  10. * coincidence.
  11. */
  12.  
  13. #include <stdio.h>
  14. #include <math.h>
  15. #include <sched.h>
  16.  
  17. double waste_time(long n)
  18. {
  19.     double res = 0;
  20.     long i = 0;
  21.     while(i <n * 200000) {
  22.         i++;
  23.         res += sqrt (i);
  24.     }
  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) {
  34.         perror("sched_setaffinity");
  35.     }
  36.  
  37.     /* waste some time so the work is visible with "top" */
  38.     printf ("result: %f\n", waste_time (2000));
  39.  
  40.     mask = 2; /* process switches to processor 1 now */
  41.     if (sched_setaffinity(0, sizeof(mask), &mask) <0) {
  42.         perror("sched_setaffinity");
  43.     }
  44.  
  45.     /* waste some more time to see the processor switch */
  46.     printf ("result: %f\n", waste_time (2000));
  47. }

The waste_time function does nothing meaningful at all, but is merely there to crank up the CPU. It returns a result and that result is printed out so the compiler cannot optimize out the whole calculation. You may have to adjust the parameter for the function if the program executes too fast and you don't see the results with top. Also do not forget to press the "1"-key once while watching the output of top to see the CPU usage split by CPU.

pthread_setaffinity_np example

This is almost the same program, except adapted to use a thread doing all the work. Documentation included again. Beware that you need the NPTL-version of the pthreads library for this to work (if you do not have it installed, the compiler will complain that it does not know the pthread_setaffinity_np function).

PLAIN TEXT
C:
  1. /* Short test program to test the pthread_setaffinity_np
  2. * (which sets the affinity of threads to processors).
  3. * Compile: gcc pthread_setaffinity_np_test.c
  4. *              -o pthread_setaffinity_np_test -lm -lpthread
  5. * Usage: ./pthread_setaffinity_test
  6. *
  7. * Open a "top"-window at the same time and see all the work
  8. * being done on CPU 0 first and after a short wait on CPU 1.
  9. * Repeat with different numbers to make sure, it is not a
  10. * coincidence.
  11. */
  12.  
  13. #include <stdio.h>
  14. #include <math.h>
  15. #include <pthread.h>
  16.  
  17. double waste_time(long n)
  18. {
  19.     double res = 0;
  20.     long i = 0;
  21.     while (i <n * 200000) {
  22.         i++;
  23.         res += sqrt(i);
  24.     }
  25.     return res;
  26. }
  27.  
  28. void *thread_func(void *param)
  29. {
  30.     unsigned long mask = 1; /* processor 0 */
  31.  
  32.     /* bind process to processor 0 */
  33.     if (pthread_setaffinity_np(pthread_self(), sizeof(mask),
  34.         &mask) <0) {
  35.         perror("pthread_setaffinity_np");
  36.     }
  37.  
  38.     /* waste some time so the work is visible with "top" */
  39.     printf("result: %f\n", waste_time(2000));
  40.  
  41.     mask = 2;   /* process switches to processor 1 now */
  42.     if (pthread_setaffinity_np(pthread_self(), sizeof(mask),
  43.         &mask) <0) {
  44.         perror("pthread_setaffinity_np");
  45.     }
  46.  
  47.     /* waste some more time to see the processor switch */
  48.     printf("result: %f\n", waste_time(2000));
  49. }
  50.  
  51. int main(int argc, char *argv[])
  52. {
  53.     pthread_t my_thread;
  54.  
  55.     if (pthread_create(&my_thread, NULL, thread_func,
  56.         NULL) != 0) {
  57.         perror("pthread_create");
  58.     }
  59.     pthread_exit(NULL);
  60. }

So much for my short trip into the world of CPU-affinity on Linux, hope you enjoyed the ride...

阅读(5165) | 评论(0)


版权声明：编程爱好者网站为此博客服务提供商，如本文牵涉到版权问题，编程爱好者网站不承担相关责任，如有版权问题请直接与本文作者联系解决。谢谢！

评论

暂无评论
您需要登录后才能评论，请 登录 或者 注册