原子性操作atomic_t

最新推荐文章于 2024-07-17 10:37:42 发布
最新推荐文章于 2024-07-17 10:37:42 发布
阅读量9.2k 收藏 16
点赞数 2
分类专栏： linux内核分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a775992553/article/details/8797474
版权

 

内核定义了atomic_t 数据类型，作为对整数计数器的原子操作的基础。 各个CPU平台有各自的原子操作实现方式，基本都是通过汇编实现的。

 原子操作
原子操作是Linux中提供的一种实现同步的方法，所谓原子操作是指某一操作在执行过程中是不可以被打断的，它要么全部执行完毕，要么就一点也不执行。也就是说原子操作是绝对不会出现该操作执行了一半，内核又去执行其他操作的情况。
原子操作分为原子位操作和原子整形操作。

a.整型原子操作
原子操作主要用于实现资源计数，很多引用计数(refcnt)就是通过原子操作实现的。原子类型定义如下：

typedef struct  {  volatile int counter;  }  atomic_t;　

volatile修饰字段告诉gcc不要对该类型的数据做优化处理，对它的访问都是对内存的访问，而不是对寄存器的访问。
原子操作API：

#define ATOMIC_INIT(i) { (i) }

功能：用于在定义原子变量时，初始化为指定的值。

用法：static atomic_t count = ATOMIC_INIT⑴;//定义atomic_t变量y并将它初始化为10。

#define atomic_read(v) ((v)->counter)

功能：该函数读取v指向的原子变量的值。由于该操作本身就是原子的，只需要一次内存访问就能完成，因此定义为一个宏，并用C代码实现。

用法：atomic_read(&v);//原子地读取变量v的值

#define atomic_set(v,i) (((v)->counter) = (i))

功能：设置v指向的原子变量的值为i。由于该操作本身就是原子的，只需要一次内存访问就能完成，因此定义为一个宏，并用C代码实现。

用法：atomic_set(&v,1);//原子地设置变量v的值为1

  1. void atomic_add(int i, atomic_t *v);


    　　该函数给原子类型的变量v增加值i。

    atomic_sub(int i, atomic_t *v);


    　　该函数从原子类型的变量v中减去i。

    int atomic_sub_and_test(int i, atomic_t *v);


    　　该函数从原子类型的变量v中减去i，并判断结果是否为0，如果为0，返回真，否则返回假。

    void atomic_inc(atomic_t *v);


    　　该函数对原子类型变量v原子地增加1。

    void atomic_dec(atomic_t *v);


    　　该函数对原子类型的变量v原子地减1。

    int atomic_dec_and_test(atomic_t *v);


    　　该函数对原子类型的变量v原子地减1，并判断结果是否为0，如果为0，返回真，否则返回假。

    int atomic_inc_and_test(atomic_t *v);


    　　该函数对原子类型的变量v原子地增加1，并判断结果是否为0，如果为0，返回真，否则返回假。

    int atomic_add_negative(int i, atomic_t *v);


    　　该函数对原子类型的变量v原子地增加I，并判断结果是否为负数，如果是，返回真，否则返回假。

    int atomic_add_return(int i, atomic_t *v);


    　　该函数对原子类型的变量v原子地增加i，并且返回指向v的指针。

    int atomic_sub_return(int i, atomic_t *v);


    　　该函数从原子类型的变量v中减去i，并且返回指向v的指针。

    int atomic_inc_return(atomic_t * v);


    　　该函数对原子类型的变量v原子地增加1并且返回指向v的指针。

    int atomic_dec_return(atomic_t * v);

    　　该函数对原子类型的变量v原子地减1并且返回指向v的指针。

    　　原子操作通常用于实现资源的引用计数，在TCP/IP协议栈的IP碎片处理中，就使用了引用计数，碎片队列结构struct ipq描述了一个IP碎片，字段refcnt就是引用计数器，它的类型为atomic_t，当创建IP碎片时（在函数ip_frag_create中），使用atomic_set函数把它设置为1，当引用该IP碎片时，就使用函数atomic_inc把引用计数加1。

    　　当不需要引用该IP碎片时，就使用函数ipq_put来释放该IP碎片，ipq_put使用函数atomic_dec_and_test把引用计数减1并判断引用计数是否为0，如果是就释放IP碎片。函数ipq_kill把IP碎片从ipq队列中删除，并把该删除的IP碎片的引用计数减1（通过使用函数atomic_dec实现）。

     
    b.位原子操作
    原子位操作API简介：
    void set_bit(int nr, void *addr)        原子设置addr所指的第nr位

    void clear_bit(int nr, void *addr)      原子的清空所指对象的第nr位

    void change_bit(nr, void *addr) 原子的翻转addr所指的第nr位

    int test_bit(nr, void *addr) 原子的返回addr位所指对象nr位

    int test_and_set_bit(nr, void *addr)    原子设置addr所指对象的第nr位，并返回原先的值

    int test_and_clear_bit(nr, void *addr)  原子清空addr所指对象的第nr位，并返回原先的值

    int test_and_change_bit(nr, void *addr) 原子翻转addr所指对象的第nr位，并返回原先的值

    如：标志寄存器EFLSGS的系统标志，用于控制I/O访问，可屏蔽硬件中断。共32位，不同的位代表不同的信息，
    对其中信息改变都是通过位操作实现的。

 以下原文：http://blog.csdn.net/qb_2008/article/details/6840808

在任何处理器平台下，都会有一些原子性操作，供操作系统使用，我们这里只讲x86下面的。在单处理器情况下，每条指令的执行都是原子性的，但在多处理器情况下，只有那些单独的读操作或写操作才是原子性的。为了弥补这一缺点，x86提供了附加的lock前缀，使带lock前缀的读修改写指令也能原子性执行。带lock前缀的指令在操作时会锁住总线，使自身的执行即使在多处理器间也是原子性执行的。xchg指令不带lock前缀也是原子性执行，也就是说xchg执行时默认会锁内存总线。原子性操作是线程间同步的基础，linux专门定义了一种只进行原子操作的类型atomic_t，并提供相关的原子读写调用API。本节就来分析这些原子操作在x86下的实现。

[cpp] view plain copy print ?
  1. typedef struct { 
  2.     volatile int counter; 
  3. } atomic_t;  
typedef struct {
	volatile int counter;
} atomic_t;

原子类型其实是int类型，只是禁止寄存器对其暂存。

[cpp] view plain copy print ?
  1. #define ATOMIC_INIT(i)  { (i) } 
#define ATOMIC_INIT(i)	{ (i) }

原子类型的初始化。32位x86平台下atomic API在arch/x86/include/asm/atomic_32.h中实现。

[cpp] view plain copy print ?
  1. static inlineint atomic_read(const atomic_t *v) 
  2. { 
  3.     return v->counter; 
  4. } 
  5.  
  6. static inlinevoid atomic_set(atomic_t *v,int i) 
  7. { 
  8.     v->counter = i; 
  9. }  
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;
}

单独的读操作或者写操作，在x86下都是原子性的。

[cpp] view plain copy print ?
  1. static inlinevoid atomic_add(int i, atomic_t *v) 
  2. { 
  3.     asm volatile(LOCK_PREFIX"addl %1,%0" 
  4.              : "+m" (v->counter) 
  5.              : "ir" (i)); 
  6. } 
  7.  
  8. static inlinevoid atomic_sub(int i, atomic_t *v) 
  9. { 
  10.     asm volatile(LOCK_PREFIX "subl %1,%0" 
  11.              : "+m" (v->counter) 
  12.              : "ir" (i)); 
  13. }  
static inline void atomic_add(int i, atomic_t *v)
{
	asm volatile(LOCK_PREFIX "addl %1,%0"
		     : "+m" (v->counter)
		     : "ir" (i));
}

static inline void atomic_sub(int i, atomic_t *v)
{
	asm volatile(LOCK_PREFIX "subl %1,%0"
		     : "+m" (v->counter)
		     : "ir" (i));
}

atomic_add和atomic_sub属于读修改写操作，实现时需要加lock前缀。

[cpp] view plain copy print ?
  1. static inlineint atomic_sub_and_test(int i, atomic_t *v) 
  2. { 
  3.     unsigned char c; 
  4.  
  5.     asm volatile(LOCK_PREFIX"subl %2,%0; sete %1" 
  6.              : "+m" (v->counter), "=qm" (c) 
  7.              : "ir" (i) :"memory"); 
  8.     return c; 
  9. }  
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) : "memory");
	return c;
}

atomic_sub_and_test执行完减操作后检查结果是否为0。

[cpp] view plain copy print ?
  1. static inlinevoid atomic_inc(atomic_t *v) 
  2. { 
  3.     asm volatile(LOCK_PREFIX"incl %0" 
  4.              : "+m" (v->counter)); 
  5. } 
  6.  
  7. static inlinevoid atomic_dec(atomic_t *v) 
  8. { 
  9.     asm volatile(LOCK_PREFIX"decl %0" 
  10.              : "+m" (v->counter)); 
  11. }  
static inline void atomic_inc(atomic_t *v)
{
	asm volatile(LOCK_PREFIX "incl %0"
		     : "+m" (v->counter));
}

static inline void atomic_dec(atomic_t *v)
{
	asm volatile(LOCK_PREFIX "decl %0"
		     : "+m" (v->counter));
}

atomic_inc和atomic_dec是递增递减操作。

[cpp] view plain copy print ?
  1. static inlineint atomic_dec_and_test(atomic_t *v) 
  2. { 
  3.     unsigned char c; 
  4.  
  5.     asm volatile(LOCK_PREFIX"decl %0; sete %1" 
  6.              : "+m" (v->counter), "=qm" (c) 
  7.              : : "memory"); 
  8.     return c != 0; 
  9. }  
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)
		     : : "memory");
	return c != 0;
}

atomic_dec_and_test在递减后检查结果是否为0。

[cpp] view plain copy print ?
  1. static inlineint atomic_inc_and_test(atomic_t *v) 
  2. { 
  3.     unsigned char c; 
  4.  
  5.     asm volatile(LOCK_PREFIX"incl %0; sete %1" 
  6.              : "+m" (v->counter), "=qm" (c) 
  7.              : : "memory"); 
  8.     return c != 0; 
  9. }  
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)
		     : : "memory");
	return c != 0;
}

atomic_inc_and_test在递增后检查结果是否为0。

[cpp] view plain copy print ?
  1. static inlineint atomic_add_negative(int i, atomic_t *v) 
  2. { 
  3.     unsigned char c; 
  4.  
  5.     asm volatile(LOCK_PREFIX"addl %2,%0; sets %1" 
  6.              : "+m" (v->counter), "=qm" (c) 
  7.              : "ir" (i) :"memory"); 
  8.     return c; 
  9. }  
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) : "memory");
	return c;
}

atomic_add_negative在加操作后检查结果是否为负数。

[cpp] view plain copy print ?
  1. static inlineint atomic_add_return(int i, atomic_t *v) 
  2. { 
  3.     int __i; 
  4. #ifdef CONFIG_M386 
  5.     unsigned long flags; 
  6.     if (unlikely(boot_cpu_data.x86 <= 3)) 
  7.         goto no_xadd; 
  8. #endif 
  9.     /* Modern 486+ processor */ 
  10.     __i = i; 
  11.     asm volatile(LOCK_PREFIX"xaddl %0, %1" 
  12.              : "+r" (i), "+m" (v->counter) 
  13.              : : "memory"); 
  14.     return i + __i; 
  15.  
  16. #ifdef CONFIG_M386 
  17. no_xadd: /* Legacy 386 processor */ 
  18.     local_irq_save(flags); 
  19.     __i = atomic_read(v); 
  20.     atomic_set(v, i + __i); 
  21.     local_irq_restore(flags); 
  22.     return i + __i; 
  23. #endif 
  24. }  
static inline int atomic_add_return(int i, atomic_t *v)
{
	int __i;
#ifdef CONFIG_M386
	unsigned long flags;
	if (unlikely(boot_cpu_data.x86 <= 3))
		goto no_xadd;
#endif
	/* Modern 486+ processor */
	__i = i;
	asm volatile(LOCK_PREFIX "xaddl %0, %1"
		     : "+r" (i), "+m" (v->counter)
		     : : "memory");
	return i + __i;

#ifdef CONFIG_M386
no_xadd: /* Legacy 386 processor */
	local_irq_save(flags);
	__i = atomic_read(v);
	atomic_set(v, i + __i);
	local_irq_restore(flags);
	return i + __i;
#endif
}

atomic_add_return 不仅执行加操作，而且把相加的结果返回。它是通过xadd这一指令实现的。

[cpp] view plain copy print ?
  1. static inlineint atomic_sub_return(int i, atomic_t *v) 
  2. { 
  3.     return atomic_add_return(-i, v); 
  4. }  
static inline int atomic_sub_return(int i, atomic_t *v)
{
	return atomic_add_return(-i, v);
}

atomic_sub_return 不仅执行减操作，而且把相减的结果返回。它是通过atomic_add_return实现的。

[cpp] view plain copy print ?
  1. static inlineint atomic_cmpxchg(atomic_t *v,int old,intnew) 
  2. { 
  3.     return cmpxchg(&v->counter, old,new); 
  4. } 
  5.  
  6. #define cmpxchg(ptr, o, n)                      \ 
  7.     ((__typeof__(*(ptr)))__cmpxchg((ptr), (unsigned long)(o),   \ 
  8.                        (unsigned long)(n),      \ 
  9.                        sizeof(*(ptr)))) 
  10.  
  11. static inline unsignedlong __cmpxchg(volatilevoid *ptr, unsigned long old, 
  12.                       unsigned longnew,int size) 
  13. { 
  14.     unsigned long prev; 
  15.     switch (size) { 
  16.     case 1: 
  17.         asm volatile(LOCK_PREFIX"cmpxchgb %b1,%2" 
  18.                  : "=a"(prev) 
  19.                  : "q"(new),"m"(*__xg(ptr)),"0"(old) 
  20.                  : "memory"); 
  21.         return prev; 
  22.     case 2: 
  23.         asm volatile(LOCK_PREFIX"cmpxchgw %w1,%2" 
  24.                  : "=a"(prev) 
  25.                  : "r"(new),"m"(*__xg(ptr)),"0"(old) 
  26.                  : "memory"); 
  27.         return prev; 
  28.     case 4: 
  29.         asm volatile(LOCK_PREFIX"cmpxchgl %k1,%2" 
  30.                  : "=a"(prev) 
  31.                  : "r"(new),"m"(*__xg(ptr)),"0"(old) 
  32.                  : "memory"); 
  33.         return prev; 
  34.     case 8: 
  35.         asm volatile(LOCK_PREFIX"cmpxchgq %1,%2" 
  36.                  : "=a"(prev) 
  37.                  : "r"(new),"m"(*__xg(ptr)),"0"(old) 
  38.                  : "memory"); 
  39.         return prev; 
  40.     } 
  41.     return old; 
  42. }  
static inline int atomic_cmpxchg(atomic_t *v, int old, int new)
{
	return cmpxchg(&v->counter, old, new);
}

#define cmpxchg(ptr, o, n)						\
	((__typeof__(*(ptr)))__cmpxchg((ptr), (unsigned long)(o),	\
				       (unsigned long)(n),		\
				       sizeof(*(ptr))))

static inline unsigned long __cmpxchg(volatile void *ptr, unsigned long old,
				      unsigned long new, int size)
{
	unsigned long prev;
	switch (size) {
	case 1:
		asm volatile(LOCK_PREFIX "cmpxchgb %b1,%2"
			     : "=a"(prev)
			     : "q"(new), "m"(*__xg(ptr)), "0"(old)
			     : "memory");
		return prev;
	case 2:
		asm volatile(LOCK_PREFIX "cmpxchgw %w1,%2"
			     : "=a"(prev)
			     : "r"(new), "m"(*__xg(ptr)), "0"(old)
			     : "memory");
		return prev;
	case 4:
		asm volatile(LOCK_PREFIX "cmpxchgl %k1,%2"
			     : "=a"(prev)
			     : "r"(new), "m"(*__xg(ptr)), "0"(old)
			     : "memory");
		return prev;
	case 8:
		asm volatile(LOCK_PREFIX "cmpxchgq %1,%2"
			     : "=a"(prev)
			     : "r"(new), "m"(*__xg(ptr)), "0"(old)
			     : "memory");
		return prev;
	}
	return old;
}


atomic_cmpxchg是由cmpxchg指令完成的。它把旧值同atomic_t类型的值相比较，如果相同，就把新值存入atomic_t类型的值中，返回atomic_t类型变量中原有的值。

[cpp] view plain copy print ?
  1. static inlineint atomic_xchg(atomic_t *v,intnew) 
  2. { 
  3.     return xchg(&v->counter,new); 
  4. } 
  5.  
  6. #define xchg(ptr, v)                            \ 
  7.     ((__typeof__(*(ptr)))__xchg((unsigned long)(v), (ptr), sizeof(*(ptr)))) 
  8.  
  9. static inline unsignedlong __xchg(unsignedlong x,volatilevoid *ptr, 
  10.                    int size) 
  11. { 
  12.     switch (size) { 
  13.     case 1: 
  14.         asm volatile("xchgb %b0,%1" 
  15.                  : "=q" (x) 
  16.                  : "m" (*__xg(ptr)), "0" (x) 
  17.                  : "memory"); 
  18.         break; 
  19.     case 2: 
  20.         asm volatile("xchgw %w0,%1" 
  21.                  : "=r" (x) 
  22.                  : "m" (*__xg(ptr)), "0" (x) 
  23.                  : "memory"); 
  24.         break; 
  25.     case 4: 
  26.         asm volatile("xchgl %k0,%1" 
  27.                  : "=r" (x) 
  28.                  : "m" (*__xg(ptr)), "0" (x) 
  29.                  : "memory"); 
  30.         break; 
  31.     case 8: 
  32.         asm volatile("xchgq %0,%1" 
  33.                  : "=r" (x) 
  34.                  : "m" (*__xg(ptr)), "0" (x) 
  35.                  : "memory"); 
  36.         break; 
  37.     } 
  38.     return x; 
  39. }  
static inline int atomic_xchg(atomic_t *v, int new)
{
	return xchg(&v->counter, new);
}

#define xchg(ptr, v)							\
	((__typeof__(*(ptr)))__xchg((unsigned long)(v), (ptr), sizeof(*(ptr))))

static inline unsigned long __xchg(unsigned long x, volatile void *ptr,
				   int size)
{
	switch (size) {
	case 1:
		asm volatile("xchgb %b0,%1"
			     : "=q" (x)
			     : "m" (*__xg(ptr)), "0" (x)
			     : "memory");
		break;
	case 2:
		asm volatile("xchgw %w0,%1"
			     : "=r" (x)
			     : "m" (*__xg(ptr)), "0" (x)
			     : "memory");
		break;
	case 4:
		asm volatile("xchgl %k0,%1"
			     : "=r" (x)
			     : "m" (*__xg(ptr)), "0" (x)
			     : "memory");
		break;
	case 8:
		asm volatile("xchgq %0,%1"
			     : "=r" (x)
			     : "m" (*__xg(ptr)), "0" (x)
			     : "memory");
		break;
	}
	return x;
}


atomic_xchg则是将新值存入atomic_t类型的变量，并将变量的旧值返回。它使用xchg指令实现。

[cpp] view plain copy print ?
  1. /**
  2. * atomic_add_unless - add unless the number is already a given value
  3. * @v: pointer of type atomic_t
  4. * @a: the amount to add to v...
  5. * @u: ...unless v is equal to u.
  6. *
  7. * Atomically adds @a to @v, so long as @v was not already @u.
  8. * Returns non-zero if @v was not @u, and zero otherwise.
  9. */ 
  10. static inlineint atomic_add_unless(atomic_t *v,int a,int u) 
  11. { 
  12.     int c, old; 
  13.     c = atomic_read(v); 
  14.     for (;;) { 
  15.         if (unlikely(c == (u))) 
  16.             break; 
  17.         old = atomic_cmpxchg((v), c, c + (a)); 
  18.         if (likely(old == c)) 
  19.             break; 
  20.         c = old; 
  21.     } 
  22.     return c != (u); 
  23. }  
/**
 * atomic_add_unless - add unless the number is already a given value
 * @v: pointer of type atomic_t
 * @a: the amount to add to v...
 * @u: ...unless v is equal to u.
 *
 * Atomically adds @a to @v, so long as @v was not already @u.
 * Returns non-zero if @v was not @u, and zero otherwise.
 */
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);
}


atomic_add_unless的功能比较特殊。它检查v是否等于u，如果不是则把v的值加上a，返回值表示相加前v是否等于u。因为在atomic_read和atomic_cmpxchg中间可能有其它的写操作，所以要循环检查自己的值是否被写进去。

[cpp] view plain copy print ?
  1. #define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0) 
  2.  
  3. #define atomic_inc_return(v)  (atomic_add_return(1, v)) 
  4. #define atomic_dec_return(v)  (atomic_sub_return(1, v)) 
#define atomic_inc_not_zero(v) atomic_add_unless((v), 1, 0)

#define atomic_inc_return(v)  (atomic_add_return(1, v))
#define atomic_dec_return(v)  (atomic_sub_return(1, v))


atomic_inc_not_zero在v值不是0时加1。

atomic_inc_return对v值加1，并返回相加结果。

atomic_dec_return对v值减1，并返回相减结果。

[cpp] view plain copy print ?
  1. #define atomic_clear_mask(mask, addr)               \ 
  2.     asm volatile(LOCK_PREFIX "andl %0,%1"           \ 
  3.              : : "r" (~(mask)),"m" (*(addr)) :"memory") 
#define atomic_clear_mask(mask, addr)				\
	asm volatile(LOCK_PREFIX "andl %0,%1"			\
		     : : "r" (~(mask)), "m" (*(addr)) : "memory")

atomic_clear_mask清除变量某些位。

[cpp] view plain copy print ?
  1. #define atomic_set_mask(mask, addr)             \ 
  2.     asm volatile(LOCK_PREFIX "orl %0,%1"                \ 
  3.              : : "r" (mask),"m" (*(addr)) :"memory") 
#define atomic_set_mask(mask, addr)				\
	asm volatile(LOCK_PREFIX "orl %0,%1"				\
		     : : "r" (mask), "m" (*(addr)) : "memory")


atomic_set_mask将变量的某些位置位。

[cpp] view plain copy print ?
  1. /* Atomic operations are already serializing on x86 */ 
  2. #define smp_mb__before_atomic_dec() barrier() 
  3. #define smp_mb__after_atomic_dec()  barrier() 
  4. #define smp_mb__before_atomic_inc() barrier() 
  5. #define smp_mb__after_atomic_inc()  barrier() 
/* Atomic operations are already serializing on x86 */
#define smp_mb__before_atomic_dec()	barrier()
#define smp_mb__after_atomic_dec()	barrier()
#define smp_mb__before_atomic_inc()	barrier()
#define smp_mb__after_atomic_inc()	barrier()

因为x86的atomic操作大多使用原子指令或者带lock前缀的指令。带lock前缀的指令执行前会完成之前的读写操作，对于原子操作来说不会受之前对同一位置的读写操作，所以这里只是用空操作barrier()代替。barrier()的作用相当于告诉编译器这里有一个内存屏障，放弃在寄存器中的暂存值，重新从内存中读入。

本节的atomic_t类型操作是最基础的，为了介绍下面的内容，必须先介绍它。如果可以使用atomic_t类型代替临界区操作，也可以加快不少速度。

土贼他哥土匪
关注
  • 2
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux内核部件分析（二）——原子性操作atomic_t
qb_2008的专栏
10-02 2万+
在任何处理器平台下，都会有一些原子性操作，供操作系统使用，我们这里只讲x86下面的。在单处理器情况下，每条指令的执行都是原子性的，但在多处理器情况下，只有那些单独的读操作或写操作才是原子性的。为了弥补这一缺点，x86提供了附加的lock前缀，使带lock前缀的读修改写指令也能原子
原子操作 atomic_t
06-14 2513
1. atomic_t 定义及其原因： 内核定义了atomic_t 数据类型，作为对整数计数器的原子操作的基础。 typedef struct { int counter; } atomic_t;这里引入了一个特殊的数据类型，而不是直接使用int类型，原因如下： a. 让原子操作函数只接收 atomic_t 类型的操作数，可以确保原子操作只与这种特殊类型数据一起使用，进而保证了该类型数据不
Linux 原子操作
weixin_30443731的博客
11-16 418
所谓原子操作，就是该操作绝不会在执行完毕前被任何其他任务或事件打断，也就说，它的最小的执行单位，不可能有比它更小的执行单位，因此这里的原子实际是使用了物理学里的物质微粒的概念。 　　原子操作需要硬件的支持，因此是架构相关的，其API和原子类型的定义都定义在内核源码树的include/asm/atomic.h文件中，它们都使用汇编语言实现，因为C语言并不能实现这样的操作。 　　原子操作...
Linux 内核编程第二部分（四）
最新发布
龙哥盟
07-17 1479
最后但同样重要的是，让我们简要讨论另一个问题 -内存屏障。这是什么意思？有时，程序流对人类程序员来说变得不可知，因为微处理器、内存控制器和编译器可以重新排序内存读取和写入。在大多数情况下，这些“技巧”保持良性并且被优化。但是有些情况 - 通常跨硬件边界，例如多核系统上的 CPU 核心、CPU 到外围设备，以及反之亦然的UP） - 在这些情况下，这种重新排序不应该发生；必须遵守原始和预期的内存加载和存储顺序。内存屏障（通常是嵌入在*mb*()宏中的机器级指令）是一种抑制这种重新排序的方法；
多线程基础之四：Linux提供的原子锁类型atomic_t
热门推荐
墨篙和小奶猫
11-15 1万+
在x86体系下，任何处理器平台下都会有一些原子性操作，在单处理器情况下，单步指令的原子性容易实现。但是在SMP多处理器情况下，只有那些单字的读（将变量读进寄存器）或写（从寄存器写入到变量地址）才是原子性的。故而在SMP下，要保证特定指令集合的原子性即不被中断，x86提供lock前缀用来在执行被lock修饰的指令期间锁住总线，从而实现了“禁止中断”的效果。事实上，Linux操作系统便根据这种针对特殊数
atomic_t
07-09 750
typedef struct { volatile int counter; } atomic_t;  把整型套在结构体中，大概目的为： 定义结构体一般是： 1)与普通的int类型区分开.防止程序员直接赋值给int或者直接当int参与其他运算等 2)方便以后扩展,结构体里添加成员很方便 是unix特色之一。不少unix类型如此定义的，page table 有关的一些类型就这
linux 原子性操作atomic_t
晴天的专栏
09-03 5041
在任何处理器平台下，都会有一些原子性操作，供操作系统使用，我们这里只讲x86下面的。在单处理器情况下，每条指令的执行都是原子性的，但在多处理器情况下，只有那些单独的读操作或写操作才是原子性的。为了弥补这一缺点，x86提供了附加的lock前缀，使带lock前缀的读修改写指令也能原子性执行。带lock前缀的指令在操作时会锁住总线，使自身的执行即使在多处理器间也是原子性执行的。xchg指令不带lock前
linux中原子操作atomic_read、atomic_set、atomic_add、atomic_sub
Tianqf505的博客
04-06 5796
原子操作 所谓原子操作，就是该操作绝不会在执行完毕前被任何其他任务或事件打断，也就说，它的最小的执行单位，不可能有比它更小的执行单位。因此这里的原子实际是使用了物理学里的物质微粒的概念。 原子操作需要硬件的支持，因此是架构相关的，其API和原子类型的定义都定义在内核源码树的include/asm/atomic.h文件中，它们都使用汇编语言实现，因为C语言并不能实现这样的操作。 原子操作主要用于实现资源计数，很多引用计数(refcnt)就是通过原子操作实现的。原子类型定义如下： typedef str
atomic_ops原子操作1
08-03
atomic_t 是一种原子类型，用于实现原子操作。它应该被定义为一个带符号的整数类型，并且应该是 opaque 的，这样任何类型的转换到 normal C 整数类型都会失败。典型的定义如下： ```c typedef struct { volatile int...
C++ 11 开发中的 Atomic 原子操作.rar_C++11、原子_atomic c++_c++ atomic使用_c++
09-23
这些变量在多线程环境中可以保证其基本操作（如读取、写入或更新）的原子性，即这些操作不会被其他线程打断。例如： ```cpp std::atomic<int> atomic_value; ``` 2. **原子操作（Atomic Operations）** `std::...
Linux原子操作 atomic_cmpxchg()/Atomic_read()/Atomic_set()/Atomic_add()/Atomic_sub()
兰宝的专栏
09-25 4571
所谓原子操作，就是该操作绝不会在执行完毕前被任何其他任务或事件打断，也就说，它的最小的执行单位，不可能有比它更小的执行单位。因此这里的原子实际是使用了物理学里的物质微粒的概念。 原子操作需要硬件的支持，因此是架构相关的，其API和原子类型的定义都定义在内核源码树的include/asm/atomic.h文件中，它们都使用汇编语言实现，因为C语言并不能实现这样的操作。 原子操作主要用于实
atomic_t原子操作
process的专栏
06-02 1040
<br />　　所谓原子操作，就是该操作绝不会在执行完毕前被任何其他任务或事件打断，也就说，它的最小的执行单位，不可能有比它更小的执行单位，因此这里的原子实际是使用了物理学里的物质微粒的概念。　　原子操作需要硬件的支持，因此是架构相关的，其API和原子类型的定义都定义在内核源码树的include/asm/atomic.h文件中，它们都使用汇编语言实现，因为C语言并不能实现这样的操作。　　原子操作主要用于实现资源计数，很多引用计数(refcnt)就是通过原子操作实现的。原子类型定义如下：typedef str
sig_automic_t
Riak, Spark, Golang, Erlang, 云存储, 云计算, 数据挖掘
03-08 978
目录 Linux内核中的原子操作 atomic_t 当把变量声明为该类型会保证该变量在使用或赋值时， 无论是在32位还是64位的机器上都能保证操作是原子的， 它会根据机器的类型自动适应。 这个类型是定义在signal.h文件中。下面来说说这个类型。 在处理信号(signal)的时候，有时对于一些变量的访问希望不会被中断，无论是硬件中断还是软件中断，这就要求访问或改变这些变量需要在计算机
atomic_t原子变量操作
qq_35399548的博客
08-31 238
原子类型参数定义的典型使用场景便是多进程中共享资源的计数加减，如信号量semaphores中的资源总数便是经典的使用场景。所以atomic_t原子锁支持的便是声明了一个具有原子操作特性的整数。 typedef struct{ volatile int counter; //volatile修饰符高速gcc不要对该类型数据进行优化处理，即对它的访问都是对 //内存的访问，而不是对寄存器的访问。即要读，必须重新找个寄存器载入该参数，而不是直接利用该参数 //此刻
Linux内核之原子操作atomic_t用法实例(三十九)
Android系统攻城狮
04-10 1296
本篇目的：Linux内核之atomic_t用法实例Linux内核中的atomic_t是一个原子操作的计数器类型，它被广泛用于多线程环境中，确保对计数器的操作是线程安全的。在Linux内核中，许多场合需要对某些值进行原子操作，例如，进程计数、互斥锁的计数器等。atomic_t提供了对这些值进行增加、减少和获取当前值的原子操作，避免了在多线程环境中由于竞态条件引起的并发问题。atomic_t的定义在头文件中，它是一个简单的整数类型（通常是32位），并提供了以下几个主要的操作函数：：初始化一个。
关于Linux系统的 atomic_t 、 atomic64_t 和 atomic_long_t类型
duanlove（技术路途）专栏
11-25 1万+
实际上 atomic_t  和 atomic64_t 这两个类型 是linux 头文件（"kernel/include/linux/types.h"）里定义。   typedef unsigned long irq_hw_number_t; typedef struct {     int counter; } atomic_t; #ifdef CONFIG_64BIT typede
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值