【最終版 & 總結】自實現(xiàn)自旋鎖 與 mutex，spinlock比較（結果令人吃驚）

ydfgic

總結一下：
最后修改了一下測試代碼，比較方便的設置線程數(shù)，選擇測試對象，設置delay的參數(shù)。
經(jīng)過測試發(fā)現(xiàn)我的實現(xiàn)測試的結果時間非常穩(wěn)定，2個，10個，20個乃至40個線程的差別很小，幾乎達到了與線程數(shù)無關，同樣mutex也是和線程數(shù)關系不大，但是pthread_spinlock_t對線程數(shù)敏感，線程多的情況下，效率會降低很多。
同樣增加加鎖的粒度，對測試結果也有影響，當粒度很小的情況下，我的實現(xiàn)是mutex的4-5倍快，但是粒度很大的情況，比如我設置到delay的循環(huán)次數(shù)為1000時，效率是mutex的兩倍多快，但是cpu更忙些。spinlock的速度就不提了，很低。
結論：
如果是比較大粒度的加鎖肯定是mutex首選，雖然性能中庸，但是它因為會休眠掛起，不占用cpu，對系統(tǒng)影響小。
如果是比較細粒度的加鎖可以用我實現(xiàn)的lock，對線程數(shù)量幾乎無關，效率極高，可能是因為實現(xiàn)簡單，最大效率的做到了切換cpu，保證一個線程執(zhí)行，減少了多余環(huán)節(jié)。
pthread_spinlock_t的局限性太大，如果線程多的情況下，會造成性能的很大程度的損失。同時還僅限于小粒度的加鎖情況。

給出測試數(shù)據(jù)：
1）20線程，0delay
我的：time ./myspinlock_O3.out 20 0 0
real    0m0.323s
user    0m0.364s
sys     0m0.276s

mutex：time ./myspinlock_O3.out 20 1 0
real    0m1.634s
user    0m1.972s
sys     0m1.264s

spinlock: time ./myspinlock_O3.out 20 2 0
real    0m6.259s
user    0m12.477s
sys     0m0.004s

2）20線程，100 delay
我的：time ./myspinlock_O3.out 20 0 100
real    0m2.965s
user    0m3.268s
sys     0m2.636s

mutex：time ./myspinlock_O3.out 20 1 100
real    0m6.493s
user    0m6.344s
sys     0m6.604s

spinlock： time ./myspinlock_O3.out 20 2 100
real    0m15.760s
user    0m31.378s
sys     0m0.004s

3）10線程，0delay
我的：time ./myspinlock_O3.out 10 0 0
real    0m0.318s
user    0m0.372s
sys     0m0.248s
mutex：time ./myspinlock_O3.out 10 1 0
real    0m1.511s
user    0m1.808s
sys     0m1.200s
spinlock：time ./myspinlock_O3.out 10 2 0
real    0m3.625s
user    0m7.224s
sys     0m0.004s

4）2線程，0delay
我的：time ./myspinlock_O3.out 2 0 0
real    0m0.323s
user    0m0.376s
sys     0m0.184s
mutex：time ./myspinlock_O3.out 2 1 0
real    0m1.453s
user    0m1.688s
sys     0m1.136s
spinlock：time ./myspinlock_O3.out 2 2 0
real    0m0.819s
user    0m1.624s
sys     0m0.004s


最終版的實現(xiàn)

1. #include<stdint.h>
   
2. #include<unistd.h>
   
3. 
   
4. typedef volatile uint32_t spinlock_t;
   
5. 
   
6. #define MY_SPINLOCK_INITIALIZER 0
   
7. 
   
8. #define spinlock_lock(lock) do{  \
   
9.     while(!__sync_bool_compare_and_swap(lock, 0, 1))    \
   
10.         sched_yield();  \
    
11. }while(0)
    
12. 
    
13. #define spinlock_unlock(lock) do{    \
    
14.     *lock = 0;  \
    
15. }while(0)

復制代碼

最終版的測試代碼

1. #include"myspinlock.h"
   
2. 
   
3. // gcc -Wall -g -O3 -o myspinlock.out myspinlock.c -lpthread
   
4. 
   
5. 
   
6. /////////////////////////                test  
   
7. 
   
8. my_spinlock_t lock =  MY_SPINLOCK_INITIALIZER;
   
9. volatile int cnt = 0;
   
10. 
    
11. #include<pthread.h>
    
12. #include<stdio.h>
    
13. #include <stdlib.h>
    
14. 
    
15. #define  TOTAL 1000000 * 20
    
16. int NR;
    
17. int DELAY_CNT = 100;
    
18. 
    
19. void * fun1(void * arg)
    
20. {
    
21.         int i = 0, id = *(int*)arg;
    
22.         printf("thread:%d\n",id);
    
23.         for(; i < NR; i++)
    
24.         {
    
25.                 spinlock_lock(&lock);
    
26.                 cnt++;
    
27.                 int j = 0;
    
28.                 for (; j < DELAY_CNT; j++) {
    
29.                         *foo = (*foo * 33) + 17;
    
30.                 }
    
31.                 spinlock_unlock(&lock);
    
32.         }
    
33.         printf("thread:%d over, lock:%d\n",id, lock);
    
34.         return 0;
    
35. }
    
36. 
    
37. pthread_mutex_t mlock = PTHREAD_MUTEX_INITIALIZER;
    
38. 
    
39. void * fun2(void * arg)
    
40. {
    
41.         int i = 0, id = *(int*)arg;
    
42.         printf("thread:%d\n",id);
    
43.         for(; i < NR; i++)
    
44.         {
    
45.                 pthread_mutex_lock(&mlock);
    
46.                 cnt++;
    
47.                 int j = 0;
    
48.                 for (; j < DELAY_CNT; j++) {
    
49.                         *foo = (*foo * 33) + 17;
    
50.                 }
    
51.                 pthread_mutex_unlock(&mlock);
    
52.         }
    
53.         printf("thread:%d over, lock:%d\n",id, lock);
    
54.         return 0;
    
55. }
    
56. 
    
57. pthread_spinlock_t splock;
    
58. 
    
59. void * fun3(void * arg)
    
60. {
    
61.         int i = 0, id = *(int*)arg;
    
62.         printf("thread:%d\n",id);
    
63.         for(; i < NR; i++)
    
64.         {
    
65.                 pthread_spin_lock(&splock);
    
66.                 cnt++;
    
67.                 int j = 0;
    
68.                 for (; j < DELAY_CNT; j++) {
    
69.                         *foo = (*foo * 33) + 17;
    
70.                 }
    
71.                 pthread_spin_unlock(&splock);
    
72.         }
    
73.         printf("thread:%d over, lock:%d\n",id, lock);
    
74.         return 0;
    
75. }
    
76. 
    
77. int N = 20;
    
78. int main(int c, char * s[])
    
79. {
    
80.         int which = 0;
    
81.         if(c > 1)
    
82.         {
    
83.                 //線程數(shù)
    
84.                 N = atoi(s[1]);
    
85.                 if(N > 20 || N <= 1) N = 10;
    
86.         }
    
87.         if(c > 2)
    
88.         {
    
89.                 //which func?
    
90.                 which = atoi(s[2]);
    
91.                 if(which > 2 || which < 0) which = 0;
    
92.         }
    
93.         if(c > 3)
    
94.         {
    
95.                 //delay param
    
96.                 DELAY_CNT = atoi(s[3]);
    
97.                 if(DELAY_CNT > 10000 || DELAY_CNT < 0) DELAY_CNT= 100;
    
98.         }
    
99. 
    
100.         pthread_t id[N];
     
101.         int args[N];
     
102.         int i = 0;
     
103.         void * (*fun[])(void*) = { fun1,fun2,fun3};
     
104.         pthread_spin_init(&splock,0);
     
105.         NR = TOTAL / N;
     
106. 
     
107.         for(;i<N;++i){
     
108.                 args[i] = i;
     
109.                 pthread_create(&id[i],NULL,fun[which],&args[i]);
     
110.         }
     
111. 
     
112.         for(i=0;i<N;++i){
     
113.                 printf("join thread:%d\n", i);
     
114.                 pthread_join(id[i],NULL);
     
115.                 printf("join thread:%d done\n", i);
     
116.         }
     
117. 
     
118.         printf("cnt = %d, should be %d\n",cnt, N * NR);
     
119.         return 0;
     
120. }
     

復制代碼

===============================================
先前的更新僅僅做為參考

更新
重新修改了我的實現(xiàn)，加入了放棄時間片的情況，測試結果，幾乎是mutex的2-3倍效率
real    0m0.431s
user    0m0.604s
sys     0m0.240s

我想這個應該就會是我理想中的最終版本了，起碼可以拋棄 pthread 庫的mutex實現(xiàn)一些簡單的加鎖的功能。

代碼：

1. #ifndef MY_SPINLOCK_H
   
2. #define MY_SPINLOCK_H
   
3. 
   
4. #include<stdint.h>
   
5. #include<unistd.h>
   
6. 
   
7. typedef volatile uint32_t my_spinlock_t;
   
8. 
   
9. #define MY_SPINLOCK_INITIALIZER 0
   
10. #define DELAY_NR 10000
    
11. 
    
12. static uint32_t bar = 13;
    
13. static uint32_t *foo = &bar;
    
14. 
    
15. #define do_hash(a) do{  \
    
16. (a) = ((a)+0x7ed55d16) + ((a)<<12); \
    
17. (a) = ((a)^0xc761c23c) ^ ((a)>>19); \
    
18. (a) = ((a)+0x165667b1) + ((a)<<5);  \
    
19. (a) = ((a)+0xd3a2646c) ^ ((a)<<9);  \
    
20. (a) = ((a)+0xfd7046c5) + ((a)<<3);  \
    
21. (a) = ((a)^0xb55a4f09) ^ ((a)>>16); \
    
22. }while(0)
    
23. 
    
24. #define my_spinlock_lock(lock) do{  \
    
25.     while(!__sync_bool_compare_and_swap(lock, 0, 1))    \
    
26.     {   \
    
27.         while(*lock)    \
    
28.         {   \
    
29.             do_hash(*foo);  \
    
30.             if((*foo % 11) == 1)    \
    
31.                 sched_yield();  \
    
32.         }   \
    
33.     }   \
    
34. }while(0)
    
35. 
    
36. #define my_spinlock_unlock(lock) do{    \
    
37.     *lock = 0;  \
    
38. }while(0)
    
39. 
    
40. #endif

復制代碼

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

最近在研究原子操作，按網(wǎng)上一些資料實現(xiàn)了個自旋鎖
拿來和 posix 的mutex，spinlock 一起測，結果出乎我意料。
mutex的成績非常好，我自己實現(xiàn)的稍微差點，posix 的pthread_spinlock_t的結果比較差。
這個真沒想到，mutex的效率這么高，看到這個結果我都覺得不相信自己的眼睛了
還是印證了，不要靠自己感覺，實際數(shù)據(jù)才是最真實的。

誰能解釋一下，謝謝~

環(huán)境：
uname -a
Linux bsd02 2.6.35.9 #1 SMP Tue Jan 11 02:09:50 EST 2011 x86_64 GNU/Linux
雙核 Pentium(R) Dual-Core  CPU      E5400  @ 2.70GHz

并發(fā)20個線程測試，結果:
我的實現(xiàn)：
real    0m1.659s
user    0m3.276s
sys     0m0.000s

mutex：
real    0m1.481s
user    0m1.164s
sys     0m1.764s

pthread spinlock:
real    0m6.171s
user    0m12.301s
sys     0m0.004s

int-main

spinlock有這么差嗎？是不是沒用對

ydfgic

這是最原始版本的代碼，最終代碼1樓以更新
======
附上代碼:

1. #ifndef MY_SPINLOCK_H
   
2. #define MY_SPINLOCK_H
   
3. 
   
4. #include<stdint.h>
   
5. 
   
6. typedef volatile uint32_t my_spinlock_t;
   
7. 
   
8. #define MY_SPINLOCK_INITIALIZER 0
   
9. #define DELAY_NR 10000
   
10. 
    
11. static uint32_t bar = 13;
    
12. static uint32_t *foo = &bar;
    
13. 
    
14. #define my_spinlock_lock(lock) do{  \
    
15.     int i;  \
    
16.     while(!__sync_bool_compare_and_swap(lock, 0, 1))    \
    
17.     {   \
    
18.         i = 0;  \
    
19.         while(i++ < DELAY_NR)   \
    
20.             *foo = (*foo * 33) + 17;    \
    
21.     }   \
    
22. }while(0)
    
23. 
    
24. #define my_spinlock_unlock(lock) do{    \
    
25.     *lock = 0;  \
    
26. }while(0)
    
27. 
    
28. 
    
29. #endif

復制代碼

1. #include"myspinlock.h"
   
2. my_spinlock_t lock =  MY_SPINLOCK_INITIALIZER;
   
3. volatile int cnt = 0;
   
4. 
   
5. #include<pthread.h>
   
6. #include<stdio.h>
   
7. // gcc -Wall -g -o myspinlock.out myspinlock.c -lpthread
   
8. 
   
9. #define  NR 1000000
   
10. 
    
11. void * fun1(void * arg)
    
12. {
    
13.     int i = 0, id = *(int*)arg;
    
14.     printf("thread:%d\n",id);
    
15.     for(; i < NR; i++)
    
16.     {
    
17.         my_spinlock_lock(&lock);
    
18.         cnt++;
    
19.         my_spinlock_unlock(&lock);
    
20.     }
    
21.     printf("thread:%d over, lock:%d\n",id, lock);
    
22.     return 0;
    
23. }
    
24. 
    
25. pthread_mutex_t mlock = PTHREAD_MUTEX_INITIALIZER;
    
26. 
    
27. void * fun2(void * arg)
    
28. {
    
29.     int i = 0, id = *(int*)arg;
    
30.     printf("thread:%d\n",id);
    
31.     for(; i < NR; i++)
    
32.     {
    
33.         pthread_mutex_lock(&mlock);
    
34.         cnt++;
    
35.         pthread_mutex_unlock(&mlock);
    
36.     }
    
37.     printf("thread:%d over, lock:%d\n",id, lock);
    
38.     return 0;
    
39. }
    
40. pthread_spinlock_t splock;
    
41. 
    
42. void * fun3(void * arg)
    
43. {
    
44.     int i = 0, id = *(int*)arg;
    
45.     printf("thread:%d\n",id);
    
46.     for(; i < NR; i++)
    
47.     {
    
48.         pthread_spin_lock(&splock);
    
49.         cnt++;
    
50.         pthread_spin_unlock(&splock);
    
51.     }
    
52.     printf("thread:%d over, lock:%d\n",id, lock);
    
53.     return 0;
    
54. }
    
55. 
    
56. int N = 20;
    
57. int main(int c, char * s[])
    
58. {
    
59.     pthread_t id[N];
    
60.     int args[N];
    
61.     int i = 0;
    
62.     void * (*fun[])(void*) = { fun1,fun2,fun3};
    
63.     if(--c > 2) c = 0;
    
64.     printf("c:%d\n",c);
    
65.     pthread_spin_init(&splock,0);
    
66. 
    
67.     for(;i<N;++i){
    
68.         args[i] = i;
    
69.         pthread_create(&id[i],NULL,fun[c],&args[i]);
    
70.     }
    
71. 
    
72.     for(i=0;i<N;++i){
    
73.         printf("join thread:%d\n", i);
    
74.         pthread_join(id[i],NULL);
    
75.         printf("join thread:%d done\n", i);
    
76.     }
    
77. 
    
78.     printf("%d\n",cnt);
    
79.     return 0;
    
80. }

復制代碼

ydfgic

回復 2# int-main
我貼代碼了。
spinlock真的很差，這是個奇跡，它就是發(fā)生了。

deadlylight

最關鍵的__sync_bool_compare_and_swap是什么

你這是每次都lock成功的例子，測試結果沒代表性

群雄逐鹿中原

spin lock， 翻譯自選鎖不好，要翻譯成 “忙等鎖”，
忙等，必然用在非常變態(tài)的場合。

ydfgic

最關鍵的__sync_bool_compare_and_swap是什么

你這是每次都lock成功的例子，測試結果沒代表性
deadlylight 發(fā)表于 2011-07-29 11:58

    __sync_bool_compare_and_swap  是 GCC 內建的原子操作函數(shù)， 執(zhí)行CAS 操作，也就是 比較如果相等就swap，并且返回true，否則返回false。所以失敗的線程都會進入while循環(huán)里去，忙等。

還有個你注意到?jīng)]，posix 的spinlock效率還低下些。

ydfgic

spin lock， 翻譯自選鎖不好，要翻譯成 “忙等鎖”，
忙等，必然用在非常變態(tài)的場合。
群雄逐鹿中原 發(fā)表于 2011-07-29 13:05

    我覺得我在這里測試的情況也屬于變態(tài)，呵呵，就是一個 計數(shù)累加 就放鎖了，按常規(guī)邏輯，這就是用spinlock的場景，防止線程陷落到內核態(tài)，應該效率比mutex高很多。但是事實卻相反...所以很不解啊

群雄逐鹿中原

回復 8# ydfgic


    你的線程，在 while(i++ < DELAY_NR)  時，
被切換掉，然后另一個線程開始自旋，不是要等出人命？

ydfgic

回復 9# 群雄逐鹿中原


    好像自旋鎖是這個概念吧，不放cpu在那里忙等，我已經(jīng)調整了DELAY_NR的值了
網(wǎng)上還有個變態(tài)的版本就是 while(*lock);  我試過了效率要低些。