[转] 多线程下变量-gcc原子操作 __sync_fetch_and_add等

http://blog.sina.com.cn/s/blog_6f5b220601013zw3.html

非常好的原子操作，不用加锁：__sync_fetch_and_add

GCC 提供的原子操作

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

示例程序：

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>

static int count = 0;

void *test_func(void *arg)
{
        int i=0;

for(i=0;i<20000;++i){

__sync_fetch_and_add(&count,1);

}

return NULL;

}

int main(int argc, const char *argv[])

{
        pthread_t id[20];

int i = 0;

for(i=0;i<20;++i){

pthread_create(&id[i],NULL,test_func,NULL);

}

for(i=0;i<20;++i){

pthread_join(id[i],NULL);

}

printf("%d\n",count);

return 0;

}

参考：

1.
http://refspecs.freestandards.org/elf/IA64-SysV-psABI.pdf  
section 7.4

2.
http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Atomic-Builtins.html#Atomic-Builtins

感谢作者：http://blog.csdn.net/i_am_jojo/article/details/7591743

最近编码需要实现多线程环境下的计数器操作，统计相关事件的次数。下面是一些学习心得和体会。不敢妄称原创，基本是学习笔记。遇到相关的引用，我会致谢。

当然我们知道，count++这种操作不是原子的。一个自加操作，本质是分成三步的：
    
1 从缓存取到寄存器
    
2 在寄存器加1
    
3 存入缓存。
   
由于时序的因素，多个线程操作同一个全局变量，会出现问题。这也是并发编程的难点。在目前多核条件下，这种困境会越来越彰显出来。
   
最简单的处理办法就是加锁保护，这也是我最初的解决方案。看下面的代码：
     
pthread_mutex_t count_lock = PTHREAD_MUTEX_INITIALIZER;

pthread_mutex_lock(&count_lock);
     
global_int++;
     
pthread_mutex_unlock(&count_lock);
   
后来在网上查找资料，找到了__sync_fetch_and_add系列的命令，发现这个系列命令讲的最好的一篇文章，英文好的同学可以直接去看原文。Multithreaded
simple data type access and atomic variables

__sync_fetch_and_add系列一共有十二个函数，有加/减/与/或/异或/等函数的原子性操作函数,__sync_fetch_and_add,顾名思义，现fetch，然后自加，返回的是自加以前的值。以count
=
4为例，调用__sync_fetch_and_add(&count,1),之后，返回值是4，然后，count变成了5.

有__sync_fetch_and_add,自然也就有__sync_add_and_fetch，呵呵这个的意思就很清楚了，先自加，在返回。他们哥俩的关系与i++和++i的关系是一样的。被谭浩强他老人家收过保护费的都会清楚了。

有了这个宝贝函数，我们就有新的解决办法了。对于多线程对全局变量进行自加，我们就再也不用理线程锁了。下面这行代码，和上面被pthread_mutex保护的那行代码作用是一样的，而且也是线程安全的。

__sync_fetch_and_add( &global_int, 1 );
   
下面是这群函数的全家福，大家看名字就知道是这些函数是干啥的了。

在用gcc编译的时候要加上选项
-march=i686
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不能够瞎搞。下面看下__sync_fetch_and_add反汇编出来的指令，
804889d: f0 83 05 50 a0 04 08 lock addl $0x1,0x804a050
   
我们看到了，addl前面有个lock，这行汇编指令码前面是f0开头，f0叫做指令前缀，Richard Blum
老爷子将指令前缀分成了四类，有兴趣的同学可以看下。其实我也没看懂，intel的指令集太厚了，没空看。总之老爷子解释了，lock前缀的意思是对内存区域的排他性访问。

? Lock and repeat prefixes
? Segment override and branch hint prefixes
? Operand size override prefix
? Address size override prefix

前文提到，lock是锁FSB，前端串行总线，front serial
bus,这个FSB是处理器和RAM之间的总线，锁住了它，就能阻止其他处理器或者core从RAM获取数据。当然这种操作是比较费的，只能操作小的内存可以这样做，想想我们有memcpy
，如果操作一大片内存，锁内存，那么代价就太昂贵了。所以前文提到的_sync_fetch_add_add家族，type只能是int
long  ，long long（及对应unsigned类型）。

下面提供了函数，是改造的Alexander
Sundler的原文，荣誉属于他，我只是学习他的代码，稍微改动了一点点。比较了两种方式的耗时情况。呵呵咱是菜鸟，不敢枉自剽窃大师作品。向大师致敬。

#define _GNU_SOURCE

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <stdlib.h>
#include <sched.h>
#include <linux/unistd.h>
#include <sys/syscall.h>
#include <errno.h>
#include<linux/types.h>
#include<time.h>

#define INC_TO 1000000 // one million...

__u64 rdtsc()
{
  __u32 lo,hi;

__asm__
__volatile__
    (
    
"rdtsc":"=a"(lo),"=d"(hi)
    );

return
(__u64)hi<<32|lo;
}

int global_int = 0;
pthread_mutex_t count_lock = PTHREAD_MUTEX_INITIALIZER;

pid_t gettid( void )
{
    return
syscall( __NR_gettid );
}

void *thread_routine( void *arg )
{
    int i;
    int proc_num
= (int)(long)arg;
    __u64 begin,
end;
    struct
timeval tv_begin,tv_end;
    __u64
timeinterval;
    cpu_set_t
set;

CPU_ZERO(
&set );
    CPU_SET(
proc_num, &set );

if
(sched_setaffinity( gettid(), sizeof( cpu_set_t ),
&set ))
    {
       
perror( "sched_setaffinity" );
       
return NULL;
    }

begin =
rdtsc();
   
gettimeofday(&tv_begin,NULL);
    for (i = 0;
i < INC_TO; i++)
    {
//    
global_int++;
       
__sync_fetch_and_add( &global_int, 1 );
    }
   
gettimeofday(&tv_end,NULL);
    end =
rdtsc();
    timeinterval
=(tv_end.tv_sec -
tv_begin.tv_sec)*1000000                   
+(tv_end.tv_usec - tv_begin.tv_usec);
   
fprintf(stderr,"proc_num :%d,__sync_fetch_and_add
cost            
%llu CPU cycle,cost %llu
us\n",                            
proc_num,end-begin,timeinterval);

return
NULL;
}

void *thread_routine2( void *arg )
{
    int i;
    int proc_num
= (int)(long)arg;
    __u64 begin,
end;

struct
timeval tv_begin,tv_end;
    __u64
timeinterval;
    cpu_set_t
set;

CPU_ZERO(
&set );
    CPU_SET(
proc_num, &set );

if
(sched_setaffinity( gettid(), sizeof( cpu_set_t ),
&set ))
    {
       
perror( "sched_setaffinity" );
       
return NULL;
    }

begin =
rdtsc();
   
gettimeofday(&tv_begin,NULL);

for(i =
0;i<INC_TO;i++)
    {
       
pthread_mutex_lock(&count_lock);
       
global_int++;
       
pthread_mutex_unlock(&count_lock);
    }

gettimeofday(&tv_end,NULL);
    end =
rdtsc();

timeinterval
=(tv_end.tv_sec -
tv_begin.tv_sec)*1000000                  
+(tv_end.tv_usec - tv_begin.tv_usec);
   
fprintf(stderr,"proc_num :%d,pthread lock cost %llu
CPU                   
cycle,cost %llu
us\n",proc_num,end-begin                   
,timeinterval);

return
NULL;
}
int main()
{
    int procs =
0;
    int i;
    pthread_t
*thrs;

//
Getting number of CPUs
    procs =
(int)sysconf( _SC_NPROCESSORS_ONLN );
    if (procs
< 0)
    {
       
perror( "sysconf" );
       
return -1;
    }

thrs =
malloc( sizeof( pthread_t ) * procs );
    if (thrs ==
NULL)
    {
       
perror( "malloc" );
       
return -1;
    }

printf(
"Starting %d threads...\n", procs );

for (i =
0; i < procs; i++)
    {
       
if (pthread_create( &thrs[i], NULL,
thread_routine,
           
(void *)(long)i ))
       
{
           
perror( "pthread_create" );
           
procs = i;
           
break;
       
}
    }

for (i =
0; i < procs; i++)
       
pthread_join( thrs[i], NULL );

free(
thrs );

printf(
"After doing all the math, global_int value
is:             
%d\n", global_int );
    printf(
"Expected value is: %d\n", INC_TO * procs );

return
0;
}
    
通过我的测试发现：

Starting 4 threads...
proc_num :2,no locker cost 27049544 CPU cycle,cost 12712 us
proc_num :0,no locker cost 27506750 CPU cycle,cost 12120 us
proc_num :1,no locker cost 28499000 CPU cycle,cost 13365 us
proc_num :3,no locker cost 27193093 CPU cycle,cost 12780 us
After doing all the math, global_int value is: 1169911
Expected value is: 4000000
Starting 4 threads...
proc_num :2,__sync_fetch_and_add cost 156602056 CPU cycle,cost
73603 us
proc_num :1,__sync_fetch_and_add cost 158414764 CPU cycle,cost
74456 us
proc_num :3,__sync_fetch_and_add cost 159065888 CPU cycle,cost
74763 us
proc_num :0,__sync_fetch_and_add cost 162621399 CPU cycle,cost
76426 us
After doing all the math, global_int value is: 4000000
Expected value is: 4000000

Starting 4 threads...
proc_num :1,pthread lock cost 992586450 CPU cycle,cost 466518
us
proc_num :3,pthread lock cost 1008482114 CPU cycle,cost 473998
us
proc_num :0,pthread lock cost 1018798886 CPU cycle,cost 478840
us
proc_num :2,pthread lock cost 1019083986 CPU cycle,cost 478980
us
After doing all the math, global_int value is: 4000000
Expected value is: 4000000
1 不加锁的情况下，不能返回正确的结果
  测试程序结果显示，正确结果为400万，实际为1169911.

2 线程锁和原子性自加都能返回正确的结果。

3 性能上__sync_fetch_and_add,完爆线程锁。
  从测试结果上看， __sync_fetch_and_add,速度是线程锁的6～7倍

时间： 2024-10-10 08:00:05

[转] 多线程下变量-gcc原子操作 __sync_fetch_and_add等的相关文章

Java并发——原子变量和原子操作

很多情况下我们只是需要一个简单的.高效的.线程安全的递增递减方案.注意,这里有三个条件:简单,意味着程序员尽可能少的操作底层或者实现起来要比较容易:高效意味着耗用资源要少,程序处理速度要快:线程安全也非常重要,这个在多线程下能保证数据的正确性.这三个条件看起来比较简单,但是实现起来却难以令人满意. 通常情况下,在Java里面,++i或者--i不是线程安全的,这里面有三个独立的操作:获得变量当前值,为该值+1/-1,然后写回新的值.在没有额外资源可以利用的情况下,只能使用加锁才能保证读-改-写这三

Java并发——原子变量和原子操作与阻塞算法

十五年前,多处理器系统是高度专用系统,要花费数十万美元(大多数具有两个到四个处理器).现在,多处理器系统很便宜,而且数量很多,几乎每个主要微处理器都内置了多处理支持,其中许多系统支持数十个或数百个处理器. 要使用多处理器系统的功能,通常需要使用多线程构造应用程序.但是正如任何编写并发应用程序的人可以告诉你的那样,要获得好的硬件利用率,只是简单地在多个线程中分割工作是不够的,还必须确保线程确实大部分时间都在工作,而不是在等待更多的工作,或等待锁定共享数据结构. 问题:线程之间的协调 如果线程之间 

多线程下解决资源竞争的7种方法

前言 一般情况下,只要涉及到多线程编程,程序的复杂性就会显著上升,性能显著下降,BUG出现的概率大大提升. 多线程编程本意是将一段程序并行运行,提升数据处理能力,但是由于大部分情况下都涉及到共有资源的竞争,所以修改资源 对象时必须加锁处理.但是锁的实现有很多种方法,下面就来一起了解一下在C#语言中几种锁的实现与其性能表现. 一.c#下的几种锁的运用方式 1.临界区,通过对多线程的串行化来访问公共资源或一段代码,速度快,适合控制数据访问. 1 private static object obj =

学习C语言第一天：在windows下使用gcc的条件

在windows下使用gcc的条件1,必须是提前安装了gcc这个程序 2,在windows系统path的环境变量中,代表windows从哪里寻找程序和相关的库,path中不同的路径用";"分割 在PATH中添加:C:\Qt\Qt5.3.0\Tools\mingw482_32\bin\C:\Qt\Qt5.3.0\5.3\mingw482_32\bin 3,打开命令窗口,输入gcc -v,如果看到gcc版本提示代表gcc配置成功4,打开qt生成一个空的项目,编译后,如果在我的电脑中双击生成

Java多线程21：多线程下的其他组件之CyclicBarrier、Callable、Future和FutureTask

CyclicBarrier 接着讲多线程下的其他组件,第一个要讲的就是CyclicBarrier.CyclicBarrier从字面理解是指循环屏障,它可以协同多个线程,让多个线程在这个屏障前等待,直到所有线程都达到了这个屏障时,再一起继续执行后面的动作.看一下CyclicBarrier的使用实例: public static class CyclicBarrierThread extends Thread { private CyclicBarrier cb; private int sleep

各种Windows下面的gcc native build环境的比较

http://i.rexdf.org/blog/2015/04/04/fa-xian-ge-xin-huan-jing-msys2/ 最近注意到了一个新的Windows上面的模拟Linux的项目.一般来说两大主流阵营MingW与Cygwin,这两个思路各不相同.相对来说 MingW性能比较好,尽可能用WinAPI替代实现.Cygwin则是添加了一个层,利用很多dll来模拟Linux的那些syscall(典型的如 fork).所以cygwin程序一般都是需要有cygwin的dll在path里面才可

基于Linux下的GCC编译器的内部预宏定义与__attribute__属性

***************************************************************************************************************************** 作者:EasyWave                                                                                    时间:2015.02.20 类别:Linux应用-GCC编

普通int值在多线程下的递增操作

Java针对多线程下的数值安全计数器设计了一些类,这些类叫做原子类,其中一部分如下:  java.util.concurrent.atomic.AtomicBoolean;  java.util.concurrent.atomic.AtomicInteger;  java.util.concurrent.atomic.AtomicLong;  java.util.concurrent.atomic.AtomicReference;  下面是一个对比 AtomicInteger 与 普通 int

多线程下C#如何保证线程安全?

多线程编程相对于单线程会出现一个特有的问题,就是线程安全的问题.所谓的线程安全,就是如果你的代码所在的进程中有多个线程在同时运行,而这些线程可能会同时运行这段代码.如果每次运行结果和单线程运行的结果是一样的,而且其他的变量的值也和预期的是一样的. 线程安全问题都是由全局变量及静态变量引起的. 为了保证多线程情况下,访问静态变量的安全,可以用锁机制来保证,如下所示: 1 //需要加锁的静态全局变量 2 private static bool _isOK = false; 3 //lock只能锁定一