原子操作

╰半橙微兮° 2022-08-04 13:49 242阅读 0赞

原子操作

在多线程编程中，访问同一个变量时需要利用锁来限制同一个时刻只有一个线程访问，否则会遇到未知的错误，最常用的锁有信号量、线程锁。系统也提供了一些原子操作来实现多个线程对同个变量的访问。它们的性能参照另外篇文章[锁性能][Link 1]，从该文章中可知。原子操作比锁性能高，下面介绍系统所自带的几种原子操作

头文件atomic.h

typedef struct \{   
    int counter;   
\} atomic\_t;

初始化值为i  
\#define ATOMIC\_INIT(i)  \{ (i) \}

原子读  
static inline int atomic\_read(const atomic\_t \*v)  
\{  
        return v->counter;  
\}

原子设置值  
static inline void atomic\_set(atomic\_t \*v, int i)  
\{  
        v->counter = i;  
\}

相加  
static inline void atomic\_add(int i, atomic\_t \*v)  
\{  
        asm volatile(LOCK\_PREFIX "addl %1,%0"  
                     : "=m" (v->counter)  
                     : "ir" (i), "m" (v->counter));  
\}

减去  
static inline void atomic\_sub(int i, atomic\_t \*v)  
\{  
        asm volatile(LOCK\_PREFIX "subl %1,%0"  
                     : "=m" (v->counter)  
                     : "ir" (i), "m" (v->counter));  
\}

测试两个变量是否相等，相等则返回0，不等返回-1  
static inline int atomic\_sub\_and\_test(int i, atomic\_t \*v)  
\{  
        unsigned char c;

asm volatile(LOCK\_PREFIX "subl %2,%0; sete %1"  
                     : "=m" (v->counter), "=qm" (c)  
                     : "ir" (i), "m" (v->counter) : "memory");  
        return c;  
\}

自增1  
static inline void atomic\_inc(atomic\_t \*v)  
\{  
        asm volatile(LOCK\_PREFIX "incl %0"  
                     : "=m" (v->counter)  
                     : "m" (v->counter));  
\}

递减1  
static inline void atomic\_dec(atomic\_t \*v)  
\{  
        asm volatile(LOCK\_PREFIX "decl %0"  
                     : "=m" (v->counter)  
                     : "m" (v->counter));  
\}

测试是否等于1，等于则返回0，不等于返回-1  
static inline int atomic\_dec\_and\_test(atomic\_t \*v)  
\{  
        unsigned char c;

asm volatile(LOCK\_PREFIX "decl %0; sete %1"  
                     : "=m" (v->counter), "=qm" (c)  
                     : "m" (v->counter) : "memory");  
        return c != 0;  
\}

测试变量是否等于-1，等于则返回0，不等于返回-1  
static inline int atomic\_inc\_and\_test(atomic\_t \*v)  
\{  
        unsigned char c;

asm volatile(LOCK\_PREFIX "incl %0; sete %1"  
                     : "=m" (v->counter), "=qm" (c)  
                     : "m" (v->counter) : "memory");  
        return c != 0;  
\}

相加，测试结果是否为负，负数返回0，非负返回-1  
static inline int atomic\_add\_negative(int i, atomic\_t \*v)  
\{  
        unsigned char c;

asm volatile(LOCK\_PREFIX "addl %2,%0; sets %1"  
                     : "=m" (v->counter), "=qm" (c)  
                     : "ir" (i), "m" (v->counter) : "memory");  
        return c;  
\}

相加，并返回结果  
static inline int atomic\_add\_return(int i, atomic\_t \*v)  
\{  
        int \_\_i = i;  
        asm volatile(LOCK\_PREFIX "xaddl %0, %1"  
                     : "+r" (i), "+m" (v->counter)  
                     : : "memory");  
        return i + \_\_i;  
\}

相减并返回结果  
static inline int atomic\_sub\_return(int i, atomic\_t \*v)  
\{  
        return atomic\_add\_return(-i, v);  
\}

宏定义  
\#define atomic\_inc\_return(v)  (atomic\_add\_return(1, v))  
\#define atomic\_dec\_return(v)  (atomic\_sub\_return(1, v))

如果v不等于u则v加上a，返回非0.否则返回0  
static inline int atomic\_add\_unless(atomic\_t \*v, int a, int u)  
\{  
        int c, old;  
        c = atomic\_read(v);  
        for (;;) \{  
                if (unlikely(c == (u)))  
                        break;  
                old = atomic\_cmpxchg((v), c, c + (a));  
                if (likely(old == c))  
                        break;  
                c = old;  
        \}  
        return c != (u);  
\}

\#define atomic\_inc\_not\_zero(v) atomic\_add\_unless((v), 1, 0)

对短整形变量进行递增1，并返回结果  
static inline short int atomic\_inc\_short(short int \*v)  
\{  
        asm(LOCK\_PREFIX "addw $1, %0" : "+m" (\*v));  
        return \*v;  
\}

对两个无符号长整形进行或操作，并返回结果  
static inline void atomic\_or\_long(unsigned long \*v1, unsigned long v2)  
\{  
        asm(LOCK\_PREFIX "orq %1, %0" : "+m" (\*v1) : "r" (v2));  
\}

[Link 1]: http://blog.csdn.net/a1009563517/article/details/47802651