GCC __sync_*系列的built-in函数,无锁化编程

gcc从4.1.2提供了__sync_*系列的built-in函数,用于提供加减和逻辑运算的原子操作。

其声明如下:

type __sync_fetch_and_add (type  * ptr, type value, ...)
type __sync_fetch_and_sub (type 
* ptr, type value, ...)
type __sync_fetch_and_or (type 
* ptr, type value, ...)
type __sync_fetch_and_and (type 
* ptr, type value, ...)
type __sync_fetch_and_xor (type 
* ptr, type value, ...)
type __sync_fetch_and_nand (type 
* ptr, type value, ...)


type __sync_add_and_fetch (type 
* ptr, type value, ...)
type __sync_sub_and_fetch (type 
* ptr, type value, ...)
type __sync_or_and_fetch (type 
* ptr, type value, ...)
type __sync_and_and_fetch (type 
* ptr, type value, ...)
type __sync_xor_and_fetch (type 
* ptr, type value, ...)
type __sync_nand_and_fetch (type 
* ptr, type value, ...)
这两组函数的区别在于第一组返回更新前的值,第二组返回更新后的值。 type可以是1,2,4或8字节长度的int类型,即:
int8_t  /  uint8_t
int16_t 
/  uint16_t
int32_t 
/  uint32_t
int64_t 
/  uint64_t

后面的可扩展参数(...)用来指出哪些变量需要memory barrier,因为目前gcc实现的是full barrier(类似于linux kernel 中的mb(),表示这个操作之前的所有内存操作不会被重排序到这个操作之后),所以可以略掉这个参数。


bool  __sync_bool_compare_and_swap (type  * ptr, type oldval type newval, ...)
type __sync_val_compare_and_swap (type 
* ptr, type oldval type newval, ...)
这两个函数提供原子的比较和交换,如果*ptr == oldval,就将newval写入*ptr, 第一个函数在相等并写入的情况下返回true. 第二个函数在返回操作之前的值。

__sync_synchronize (...)  发出一个full barrier.
关于memory barrier,cpu会对我们的指令进行排序,一般说来会提高程序的效率,但有时候可能造成我们不希望得到的结果,举一个例子,比如我们有一个硬件设备,它有4个寄存器,当你发出一个操作指令的时候,一个寄存器存的是你的操作指令(比如READ),两个寄存器存的是参数(比如是地址和size),最后一个寄存器是控制寄存器,在所有的参数都设置好之后向其发出指令,设备开始读取参数,执行命令,程序可能如下:
    write1(dev.register_size,size);
    write1(dev.register_addr,addr);
    write1(dev.register_cmd,READ);
    write1(dev.register_control,GO);

如果最后一条write1被换到了前几条语句之前,那么肯定不是我们所期望的,这时候我们可以在最后一条语句之前加入一个memory barrier,强制cpu执行完前面的写入以后再执行最后一条:
    write1(dev.register_size,size);
    write1(dev.register_addr,addr);
    write1(dev.register_cmd,READ);
    __sync_synchronize();
    write1(dev.register_control,GO);

memory barrier有几种类型:
    acquire barrier : 不允许将barrier之后的内存读取指令移到barrier之前(linux kernel中的wmb())。
    release barrier : 不允许将barrier之前的内存读取指令移到barrier之后 (linux kernel中的rmb())。
    full barrier    : 以上两种barrier的合集(linux kernel中的mb())。
还有两个函数:
type __sync_lock_test_and_set (type *ptr, type value, ...)  将*ptr设为value并返回*ptr操作之前的值。

void __sync_lock_release (type *ptr, ...)  将*ptr置0


测试场景:假设有一个应用:现在有一个全局变量,用来计数,再创建10个线程并发执行,每个线程中循环对这个全局变量进行++操作(i++),循环加2000000次。

所以很容易知道,这必然会涉及到并发互斥操作。下面通过三种方式来实现这种并发操作。并对比出其在效率上的不同之处。

这里先贴上代码,共5个文件:2个用于做时间统计的文件:timer.h  timer.cpp。这两个文件是临时封装的,只用来计时,可以不必细看。

 timer.h

[html]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. #ifndef TIMER_H  
  2. #define TIMER_H  
  3.   
  4. #include <sys/time.h>  
  5. class Timer  
  6. {  
  7. public:   
  8.     Timer();  
  9.     // 开始计时时间  
  10.     void Start();  
  11.     // 终止计时时间  
  12.     void Stop();  
  13.     // 重新设定  
  14.     void Reset();  
  15.     // 耗时时间  
  16.     void Cost_time();  
  17. private:  
  18.     struct timeval t1;  
  19.     struct timeval t2;  
  20.     bool b1,b2;  
  21. };  
  22. #endif  


timer.cpp

[html]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. #include "timer.h"  
  2. #include <stdio.h>  
  3.   
  4. Timer::Timer()  
  5. {  
  6.     b1 = false;  
  7.     b2 = false;  
  8. }  
  9. void Timer::Start()  
  10. {  
  11.     gettimeofday(&t1,NULL);    
  12.     b1 = true;  
  13.     b2 = false;  
  14. }  
  15.   
  16. void Timer::Stop()  
  17. {     
  18.     if (b1 == true)  
  19.     {  
  20.         gettimeofday(&t2,NULL);    
  21.         b2 = true;  
  22.     }  
  23. }  
  24.   
  25. void Timer::Reset()  
  26. {     
  27.     b1 = false;  
  28.     b2 = false;  
  29. }  
  30.   
  31. void Timer::Cost_time()  
  32. {  
  33.     if (b1 == false)  
  34.     {  
  35.         printf("计时出错,应该先执行Start(),然后执行Stop(),再来执行Cost_time()");  
  36.         return ;  
  37.     }  
  38.     else if (b2 == false)  
  39.     {  
  40.         printf("计时出错,应该执行完Stop(),再来执行Cost_time()");  
  41.         return ;  
  42.     }  
  43.     else  
  44.     {  
  45.         int usec,sec;  
  46.         bool borrow = false;  
  47.         if (t2.tv_usec > t1.tv_usec)  
  48.         {  
  49.             usec = t2.tv_usec - t1.tv_usec;  
  50.         }  
  51.         else  
  52.         {  
  53.             borrow = true;  
  54.             usec = t2.tv_usec+1000000 - t1.tv_usec;  
  55.         }  
  56.   
  57.         if (borrow)  
  58.         {  
  59.             sec = t2.tv_sec-1 - t1.tv_sec;  
  60.         }  
  61.         else  
  62.         {  
  63.             sec = t2.tv_sec - t1.tv_sec;  
  64.         }  
  65.         printf("花费时间:%d秒 %d微秒\n",sec,usec);  
  66.     }  
  67. }  


传统互斥量加锁方式 lock.cpp

[html]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <pthread.h>  
  4. #include <time.h>  
  5. #include "timer.h"  
  6.   
  7. pthread_mutex_t mutex_lock;  
  8. static volatile int count = 0;  
  9. void *test_func(void *arg)  
  10. {  
  11.         int i = 0;  
  12.         for(i = 0; i < 2000000; i++)  
  13.         {  
  14.                 pthread_mutex_lock(&mutex_lock);  
  15.                 count++;  
  16.                 pthread_mutex_unlock(&mutex_lock);  
  17.         }  
  18.         return NULL;  
  19. }  
  20.   
  21. int main(int argc, const char *argv[])  
  22. {  
  23.     Timer timer; // 为了计时,临时封装的一个类Timer。  
  24.     timer.Start();  // 计时开始  
  25.     pthread_mutex_init(&mutex_lock, NULL);  
  26.     pthread_t thread_ids[10];  
  27.     int i = 0;  
  28.     for(i = 0; i < sizeof(thread_ids)/sizeof(pthread_t); i++)  
  29.     {  
  30.         pthread_create(&thread_ids[i], NULL, test_func, NULL);  
  31.     }  
  32.   
  33.     for(i = 0; i < sizeof(thread_ids)/sizeof(pthread_t); i++)  
  34.     {  
  35.         pthread_join(thread_ids[i], NULL);  
  36.     }  
  37.   
  38.     timer.Stop();// 计时结束  
  39.     timer.Cost_time();// 打印花费时间  
  40.     printf("结果:count = %d\n",count);  
  41.   
  42.     return 0;  
  43. }  

no lock 不加锁的形式 nolock.cpp

[html]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <pthread.h>  
  4. #include <unistd.h>  
  5. #include <time.h>  
  6. #include "timer.h"  
  7.   
  8. int mutex = 0;  
  9. int lock = 0;  
  10. int unlock = 1;  
  11.   
  12. static volatile int count = 0;  
  13. void *test_func(void *arg)  
  14. {  
  15.         int i = 0;  
  16.         for(i = 0; i < 2000000; i++)  
  17.     {  
  18.         while (!(__sync_bool_compare_and_swap (&mutex,lock, 1) ))usleep(100000);  
  19.          count++;  
  20.          __sync_bool_compare_and_swap (&mutex, unlock, 0);  
  21.         }  
  22.         return NULL;  
  23. }  
  24.   
  25. int main(int argc, const char *argv[])  
  26. {  
  27.     Timer timer;  
  28.     timer.Start();  
  29.     pthread_t thread_ids[10];  
  30.     int i = 0;  
  31.   
  32.     for(i = 0; i < sizeof(thread_ids)/sizeof(pthread_t); i++)  
  33.     {  
  34.             pthread_create(&thread_ids[i], NULL, test_func, NULL);  
  35.     }  
  36.   
  37.     for(i = 0; i < sizeof(thread_ids)/sizeof(pthread_t); i++)  
  38.     {  
  39.             pthread_join(thread_ids[i], NULL);  
  40.     }  
  41.   
  42.     timer.Stop();  
  43.     timer.Cost_time();  
  44.     printf("结果:count = %d\n",count);  
  45.   
  46.     return 0;  
  47. }  


原子函数进行统计方式 atomic.cpp

[html]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <pthread.h>  
  4. #include <unistd.h>  
  5. #include <time.h>  
  6. #include "timer.h"  
  7.   
  8. static volatile int count = 0;  
  9. void *test_func(void *arg)  
  10. {  
  11.         int i = 0;  
  12.         for(i = 0; i < 2000000; i++)  
  13.         {  
  14.             __sync_fetch_and_add(&count, 1);  
  15.         }  
  16.         return NULL;  
  17. }  
  18.   
  19. int main(int argc, const char *argv[])  
  20. {  
  21.     Timer timer;  
  22.     timer.Start();  
  23.     pthread_t thread_ids[10];  
  24.     int i = 0;  
  25.   
  26.     for(i = 0; i < sizeof(thread_ids)/sizeof(pthread_t); i++){  
  27.             pthread_create(&thread_ids[i], NULL, test_func, NULL);  
  28.     }  
  29.   
  30.     for(i = 0; i < sizeof(thread_ids)/sizeof(pthread_t); i++){  
  31.             pthread_join(thread_ids[i], NULL);  
  32.     }  
  33.   
  34.     timer.Stop();  
  35.     timer.Cost_time();  
  36.     printf("结果:count = %d\n",count);  
  37.     return 0;  
  38. }  


#################################################################3

好,代码粘贴完毕。下面进入测试环节:

编译:

[adapter@ZHEJIANG test3]$ g++ lock.cpp ./timer.cpp  -lpthread -o lock ;
[adapter@ZHEJIANG test3]$ g++ nolock.cpp ./timer.cpp  -lpthread -o nolock ;
[adapter@ZHEJIANG test3]$  g++ atomic.cpp ./timer.cpp  -lpthread -o atomic ;

 

每一个线程循环加2000000次。
第一组测验
[adapter@ZHEJIANG test3]$ ./lock
花费时间:3秒 109807微秒
结果:count = 20000000
[adapter@ZHEJIANG test3]$ ./nolock
花费时间:7秒 595784微秒
结果:count = 20000000
[adapter@ZHEJIANG test3]$ ./atomic
花费时间:0秒 381022微秒
结果:count = 20000000

结论:
可以看出,原子操作函数的速度是最快的,其他两种方式根本就没法比。而无锁操作是在原子操作函数的基础上形成的。
为什么无锁操作的效率会这么低?如果效率低的话,那还有什么意义,为什么现在大家都提倡无锁编程呢?为什么?咱先不
解释,先用数据说话。

第二组测验:
原子操作代码不变,加锁操作代码不变。改动一下无锁操作的代码。
将如下代码更改
while (!(__sync_bool_compare_and_swap (&mutex,lock, 1) ));
更改后:while (!(__sync_bool_compare_and_swap (&mutex,lock, 1) )) usleep(1);
让他睡一微秒。
为什么要这样改代码?这样启不是会更慢?你的猜测是不无道理的,但是一个不休息的人干的活未必比有休息的人干的活多。

[adapter@ZHEJIANG test3]$ ./lock
花费时间:2秒 970773微秒
结果:count = 20000000
[adapter@ZHEJIANG test3]$ ./nolock
花费时间:0秒 685404微秒
结果:count = 20000000
[adapter@ZHEJIANG test3]$ ./atomic
花费时间:0秒 380675微秒
结果:count = 20000000

结论:
不用明说,大家看到的结果是不是很诧异?是不是!有木有!怎么会是这样。无锁加上usleep(1),睡一会,反而会变得这么快。
虽和原子操作相比次了一点,但已经甩开有锁同步好几条街了,无锁比有锁快是应该的,但为什么睡一会会更快,不睡就比有锁
还慢那么多呢?怎么回事。是不是这个测试的时候cpu出现了不稳定的事情。
那好,那再测试几次。
[adapter@ZHEJIANG test3]$ ./nolock
花费时间:0秒 684938微秒
结果:count = 20000000
[adapter@ZHEJIANG test3]$ ./nolock
花费时间:0秒 686039微秒
结果:count = 20000000
[adapter@ZHEJIANG test3]$ ./nolock
花费时间:0秒 685928微秒
结果:count = 20000000

现在总没话可说了,这是事实!但为什么,我也不会解释。

很好奇,为什么越休息,效率越高。电脑是机器,它可不是人。怎么会这样?
那我就让它多休息一会:
 while (!(__sync_bool_compare_and_swap (&mutex,lock, 1) ))usleep(10); //之前是1,现在改成10了。
 下面就再单独对比一个nolock无锁方式。
[adapter@ZHEJIANG test3]$ ./nolock //usleep(1);
花费时间:0秒 686039微秒
结果:count = 20000000
[adapter@ZHEJIANG test3]$ ./nolock //usleep(10);
花费时间:0秒 680307微秒
结果:count = 20000000
nolock,结果usleep(10)居然比uleep(1)还要快一点。

那么这样呢:
while (!(__sync_bool_compare_and_swap (&mutex,lock, 1) ))usleep(100); //之前是10,现在改成100了。
[adapter@ZHEJIANG test3]$ ./nolock //usleep(100)
花费时间:0秒 661935微秒
结果:count = 20000000
还是睡的越久,效率越高。

那我再试一下usleep(1000)
while (!(__sync_bool_compare_and_swap (&mutex,lock, 1) ))usleep(1000); //之前是100,现在改成1000了。
[adapter@ZHEJIANG test3]$ ./nolock // usleep(1000);
花费时间:0秒 652411微秒
结果:count = 20000000
还是睡的越久,效率越高。

那我再试一下usleep(10000)
while (!(__sync_bool_compare_and_swap (&mutex,lock, 1) ))usleep(10000); //之前是1000,现在改成10000了。
[adapter@ZHEJIANG test3]$ ./nolock
花费时间:0秒 626267微秒
结果:count = 20000000
还是睡的越久,效率越高。

那我再试一下usleep(100000)
while (!(__sync_bool_compare_and_swap (&mutex,lock, 1) ))usleep(100000); //之前是10000,现在改成100000了,也就是0.1秒。
[adapter@ZHEJIANG test3]$ ./nolock
花费时间:0秒 942445微秒
结果:count = 20000000
哦,现在开始速度慢了。

执行环境:
gcc版本信息:
[adapter@ZHEJIANG test3]$ g++ -v
Using built-in specs.
Target: x86_64-redhat-linux
gcc version 4.4.5 20110214 (Red Hat 4.4.5-6) (GCC)

cpu信息:
[adapter@ZHEJIANG test3]$ cat /proc/cpuinfo | grep name | cut -f2 -d: | uniq -c
      4  Intel(R) Core(TM) i5-3470 CPU @ 3.20GHz

通过编程测试及测试得出结论:
1、如果是想用全局变量来做统计操作。而又不得不考虑多线程间的互斥访问的话,最好使用编译器支持的原子操作函数。
再满足互斥访问的前提下,编程最简单,效率最高。
2、lock-free,无锁编程方式确实能够比传统加锁方式效率高,经上面测试可以发现,可以快到5倍左右。所以在高并发程序中
采用无锁编程的方式可以进一步提高程序效率。
3、但是,得对无锁方式有足够熟悉的了解,不然效率反而会更低。而且容易出错。
4、没想明白的疑问:为什么上面的循环检测时,加uleep比不加,效率更高。为什么在一定程度上,usleep越久效率越高?
请高手路过的时候,为小弟解答一下。谢谢。



评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值