一点测试数据

zylthinking

测试了高并发， 低并发下几种锁的性能差异：

1. #define _GNU_SOURCE
   
2. 
   
3. #include <stdint.h>
   
4. #include <stdio.h>
   
5. #include "lkf.h"
   
6. #include <pthread.h>
   
7. #include <unistd.h>
   
8. #include <assert.h>
   
9. #include <time.h>
   
10. #include <sys/time.h>
    
11. 
    
12. struct timespec base;
    
13. int timer_init(){
    
14.     int n = clock_gettime(CLOCK_MONOTONIC,  &base);
    
15.     if(0 != n){
    
16.         return -1;
    
17.     }
    
18.     return 0;
    
19. }
    
20. 
    
21. unsigned int now(){
    
22.     struct timespec tp;
    
23.     int n = clock_gettime(CLOCK_MONOTONIC,  &tp);
    
24.     if(0 != n){
    
25.         assert(0);
    
26.     }
    
27.     uint64_t ms = (tp.tv_sec - base.tv_sec) * 1000 + 1e-6 * (tp.tv_nsec - base.tv_nsec);
    
28.     return (unsigned int) ms;
    
29. }
    
30. 
    
31. 
    
32. static LKF_LIST(head);
    
33. 
    
34. struct ctx {
    
35.     struct lkf_node entry;
    
36.     int n;
    
37. };
    
38. 
    
39. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    
40. 
    
41. #define lock1(lkp) do{  \
    
42.     while(!__sync_bool_compare_and_swap(lkp, 0, 1)){    \
    
43.         sched_yield(); \
    
44.     }   \
    
45. }while(0)
    
46. 
    
47. #define lock2(lkp) do{  \
    
48.     while(!__sync_bool_compare_and_swap(lkp, 0, 1)){    \
    
49.         continue; \
    
50.     }   \
    
51. }while(0)
    
52. 
    
53. #define unlock(lkp) do{    \
    
54.     *(lkp) = 0;  \
    
55. }while(0)
    
56. 
    
57. int lck = 0;
    
58. 
    
59. void* thread_func(void* any)
    
60. {
    
61.     int n2 = 0;
    
62.     int n3 = 0;
    
63.     unsigned t1, t2 = now();
    
64.     while (1) {
    
65.         struct ctx* ctx = NULL;
    
66. #if 1
    
67.         struct lkf_node* node = lkf_node_get(&head);
    
68.         if (node == NULL) {
    
69.             __sync_add_and_fetch(&n2, 1);
    
70.             continue;
    
71.         }
    
72. 
    
73.         struct lkf_node* nd = NULL;
    
74.         do {
    
75.             nd = lkf_node_next(node);
    
76.             if (nd == NULL) {
    
77.                 continue;
    
78.             }
    
79. 
    
80.             __sync_add_and_fetch(&n3, 1);
    
81.             lkf_node_put(&head, nd);
    
82.             if (n3 % 10000 == 0) {
    
83.                 t1 = now();
    
84.                 printf("%d, %d \n", n2, t1 - t2);
    
85.                 t2 = t1;
    
86.             }
    
87.         } while (nd != node);
    
88. #else
    
89.         //lock1(&lck);
    
90.         // lock2(&lck);
    
91.         pthread_mutex_lock(&mutex);
    
92.         struct lkf_node* node = lkf_node_get_one(&head);
    
93.         pthread_mutex_unlock(&mutex);
    
94.         //unlock(&lck);
    
95.         if (node == NULL) {
    
96.             __sync_add_and_fetch(&n2, 1);
    
97.             continue;
    
98.         }
    
99. 
    
100.         struct lkf_node* nd = node;
     
101.         __sync_add_and_fetch(&n3, 1);
     
102.         lkf_node_put(&head, nd);
     
103.         if (n3 % 10000 == 0) {
     
104.             t1 = now();
     
105.             printf("%d, %d \n", n2, t1 - t2);
     
106.             t2 = t1;
     
107.         }
     
108. #endif
     
109.         n2 = 0;
     
110.     }
     
111.     return NULL;
     
112. }
     
113. 
     
114. int main(void)
     
115. {
     
116.     timer_init();
     
117. 
     
118.     for (int i = 0; i < 2000; ++i) {
     
119.         struct ctx* ctx =  malloc(sizeof(struct ctx));
     
120.         ctx->entry.next = NULL;
     
121.         lkf_node_put(&head, &ctx->entry);
     
122.     }
     
123. 
     
124.     pthread_t tid;
     
125.     for (int i = 0; i < 8; ++i) {
     
126.         pthread_create(&tid, NULL, thread_func, NULL);
     
127.     }
     
128. 
     
129.     pause();
     
130.     return 0;
     
131. }
     

复制代码

得到数据如下：
800 threads:
lock less batch  2,30 seconds
lock less single 80.x --- 100.x seconds
spin lock        infinite
yield lock       1.x seconds
mutex            5.x seconds


4 threads:
lockless batch   3ms
lock less single 12ms
yield lock       11ms
spin lock        16ms
mutex            3,40 ms

8 threads:
lockless batch   20% 15ms,  80% 5ms
lock less batch  20% 140s,  80% 60ms
spin lock        3%  120ms, 97%  50ms
yield lock       20ms
mutex            60ms

机器是 azure 上的一台 a3 4 核 的虚拟机
无锁使用的是之前我发的那份
基本结论如下：

线程数小于或接近 cpu 个数的情况下， 我的自己那个无锁链表 批取模式性能最高， 单取性能还算可以， 但与 shedu_yield 锁稍差那么一点， 比 spin lock 锁高那么一点， 但到了 8 线程， 就已经被 spin lock 锁超越了
高并发下， 还是 同步锁性能最高， spin lock 是找死， 用无锁也是脑残的行为

在任何负载下， 通过CAS加轻量的 shed_yield 实现的 yield 锁性能都高于 mutex,  futex 没测试， 估计性能位于 yield 锁和 mutex 之间
mutex 基本上似乎都表现中庸， 似乎在任何情况下， 都是第二选择

zylthinking

加上了 futex, 表明确实如猜测;
在这个测试中所有线程都没有阻塞情况， 因此 futex 比较吃亏， 若存在大量阻塞， 估计 futex 表现会超过 yiled 锁

1.     #define lock(lkp) \
   
2.     do {  \
   
3.         if (!__sync_bool_compare_and_swap(lkp, 0, 1)) {    \
   
4.             if (*lkp == 2) { \
   
5.                 syscall(__NR_futex, lkp, FUTEX_WAIT, 2, NULL, NULL, 0); \
   
6.             } \
   
7.             \
   
8.             while (0 != __sync_lock_test_and_set(lkp, 2)) { \
   
9.                 syscall(__NR_futex, lkp, FUTEX_WAIT, 2, NULL, NULL, 0); \
   
10.             } \
    
11.         } \
    
12.     } while (0)
    
13. 
    
14.     #define unlock(lkp) \
    
15.     do { \
    
16.         wmb(); \
    
17.         if (2 == __sync_lock_test_and_set(lkp, 0)) { \
    
18.             while (-1 == syscall(__NR_futex, lkp, FUTEX_WAKE, 1, NULL, NULL, 0)); \
    
19.         } \
    
20.     } while (0)

复制代码

800 threads:
lock less batch  2,30 seconds
lock less single 80.x --- 100.x seconds
spin lock        infinite
yield lock       1.x seconds
futex            4.x
mutex            5.x seconds


4 threads:
lockless batch   3ms
lock less single 12ms
yield lock       11ms
spin lock        16ms
futex            20ms
mutex            3,40 ms

8 threads:
lockless batch   20% 15ms,  80% 5ms
lock less batch  20% 140s,  80% 60ms
spin lock        3%  120ms, 97%  50ms
yield lock       20ms
futex            40ms
mutex            60ms

folklore

找工作，  linux 系统编程， 服务器编程
35K 左右

cokeboL

找工作，  linux 系统编程， 服务器编程
5K 左右

cokeboL

劳动节还在奉献，楼主劳模真汉子！