linux 内核的同步机制-凯发app官方网站

凯发app官方网站-凯发k8官网下载客户端中心 | | 凯发app官方网站-凯发k8官网下载客户端中心

迟来的互联网从业者

凯发app官方网站首页　| 　博文目录　| 　关于我

yuyunliuhen

  • 博客访问： 684159
  • 博文数量： 26
  • 博客积分： 10
  • 博客等级： 民兵
  • 技术积分： 3182
  • 用 户 组： 普通用户
  • 注册时间： 2011-02-23 14:29
个人简介

7年游戏服务器开发,擅长c/c ,javesript,php;熟悉linux,mysql/redis,elasticsearch;开源爱好者.github : https://github.com/yuyunliuhen

文章分类

全部博文（26）

文章存档

2016年（1）

2015年（3）

2014年（3）

2013年（19）

我的朋友
最近访客
推荐博文
相关博文
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
  • ·
linux 内核的同步机制--原子操作

分类： linux

2013-04-29 15:20:50

    一 原子操作
    所谓原子操作，就是该操作绝不会在执行完毕前被任何其他任务或者事件打断，也就所说，它是最小的执行单元，不可能有更小的执行单元，因此这里的原子实际是使用了物理学里面道物质微粒的概念。
    原子操作需要硬件的支持，因此是架构相关的，其api和原子类型道定义都定义在内核源码树的include\asm-x86_64\atomic.h,下面仅仅正对x86-64处理器类型进行举例说明。其由汇编实现，因为c语言并不能实现这样的操作。    
    我们通过分析其具体实现来了解其功能。在进行源码分析之前，可以先了解内联汇编的使用，这样有助于理解源代码。 
    下面对具体代码进行分析：
 

点击(此处)折叠或打开

  1. #ifdef config_smp
  2. #define lock "lock ; "
  3. #else
  4. #define lock ""
  5. #endif
  6. config_smp 配置选项控制内核是否支持smp，针对指定机器进行内核裁剪只用。

  8. /*
  9.  * make sure gcc doesn't try to be clever and move things around
  10.  * on us. we need to use _exactly_ the address the user gave us,
  11.  * not some alias that contains the same information.
  12.  */
  13. typedef struct { volatile int counter; } atomic_t;
  14. 定义atomic_t结构，实际上包含一个整形的变量，使用volatile 修饰，告诉gcc不要对该类型的数据进行优化处理，对它的访问都是对内存访问，而不是对寄存器的访问；

  16. #define atomic_init(i)    { (i) }
  17. 初始化atomic_t

  19. /**
  20.  * atomic_read - read atomic variable
  21.  * @v: pointer of type atomic_t
  22.  *
  23.  * atomically reads the value of @v.
  24.  */
  25. #define atomic_read(v)        ((v)->counter)
  26. 对原子类型的变量进行原子操作，它返回原子类型的变量v的值；

  28. /**
  29.  * atomic_set - set atomic variable
  30.  * @v: pointer of type atomic_t
  31.  * @i: required value
  32.  *
  33.  * atomically sets the value of @v to @i.
  34.  */
  35. #define atomic_set(v,i)        (((v)->counter) = (i))
  36. 设置原子类型的变量v值为i;

  38. /**
  39.  * atomic_add - add integer to atomic variable
  40.  * @i: integer value to add
  41.  * @v: pointer of type atomic_t
  42.  *
  43.  * atomically adds @i to @v.
  44.  */
  45. static __inline__ void atomic_add(int i, atomic_t *v)
  46. {
  47.     __asm__ __volatile__(
  48.         lock "addl %1,%0"
  49.         :"=m" (v->counter)
  50.         :"ir" (i), "m" (v->counter));
  51. }
  52. 原子类型的变量v增加值i, addl %1,%0 即实现了此原子的增加，如果了解了内联汇编，理解这段代码就很容易了；

  54. /**
  55.  * atomic_sub - subtract the atomic variable
  56.  * @i: integer value to subtract
  57.  * @v: pointer of type atomic_t
  58.  *
  59.  * atomically subtracts @i from @v.
  60.  */
  61. static __inline__ void atomic_sub(int i, atomic_t *v)
  62. {
  63.     __asm__ __volatile__(
  64.         lock "subl %1,%0"
  65.         :"=m" (v->counter)
  66.         :"ir" (i), "m" (v->counter));
  67. }
  68. 原子类型的变量v减去值i；

  70. /**
  71.  * atomic_sub_and_test - subtract value from variable and test result
  72.  * @i: integer value to subtract
  73.  * @v: pointer of type atomic_t
  74.  *
  75.  * atomically subtracts @i from @v and returns
  76.  * true if the result is zero, or false for all
  77.  * other cases.
  78.  */
  79. static __inline__ int atomic_sub_and_test(int i, atomic_t *v)
  80. {
  81.     unsigned char c;

  83.     __asm__ __volatile__(
  84.         lock "subl %2,%0; sete %1"
  85.         :"=m" (v->counter), "=qm" (c)
  86.         :"ir" (i), "m" (v->counter) : "memory");
  87.     return c;
  88. }
  89. 该函数从原子类型的变量v中减去i，并判断结果是否为0，如果为0，返回真，否则返回假；

  91. /**

  93.  * atomic_inc - increment atomic variable

  95.  * @v: pointer of type atomic_t

  97.  *

  99.  * atomically increments @v by 1.

  101.  */

  103. static __inline__ void atomic_inc(atomic_t *v)

  105. {

  107.     __asm__ __volatile__(

  109.         lock "incl %0"

  111.         :"=m" (v->counter)

  113.         :"m" (v->counter));

  115. }


  118. 原子类型的变量v自增1；

  120. /**
  121.  * atomic_dec - decrement atomic variable
  122.  * @v: pointer of type atomic_t
  123.  *
  124.  * atomically decrements @v by 1.
  125.  */
  126. static __inline__ void atomic_dec(atomic_t *v)
  127. {
  128.     __asm__ __volatile__(
  129.         lock "decl %0"
  130.         :"=m" (v->counter)
  131.         :"m" (v->counter));
  132. }
  133. 原子类型的变量v自减1；

  135. /**
  136.  * atomic_dec_and_test - decrement and test
  137.  * @v: pointer of type atomic_t
  138.  *
  139.  * atomically decrements @v by 1 and
  140.  * returns true if the result is 0, or false for all other
  141.  * cases.
  142.  */
  143. static __inline__ int atomic_dec_and_test(atomic_t *v)
  144. {
  145.     unsigned char c;

  147.     __asm__ __volatile__(
  148.         lock "decl %0; sete %1"
  149.         :"=m" (v->counter), "=qm" (c)
  150.         :"m" (v->counter) : "memory");
  151.     return c != 0;
  152. }
  153. 对原子类型的变量v原子地减1，并判断结果是否为0，如果为0，返回真，否则返回假；

  155. /**
  156.  * atomic_inc_and_test - increment and test
  157.  * @v: pointer of type atomic_t
  158.  *
  159.  * atomically increments @v by 1
  160.  * and returns true if the result is zero, or false for all
  161.  * other cases.
  162.  */
  163. static __inline__ int atomic_inc_and_test(atomic_t *v)
  164. {
  165.     unsigned char c;

  167.     __asm__ __volatile__(
  168.         lock "incl %0; sete %1"
  169.         :"=m" (v->counter), "=qm" (c)
  170.         :"m" (v->counter) : "memory");
  171.     return c != 0;
  172. }
  173. 对原子类型的变量v原子地增加1，并判断结果是否为0，如果为0，返回真，否则返回假；

  175. /**
  176.  * atomic_add_negative - add and test if negative
  177.  * @v: pointer of type atomic_t
  178.  * @i: integer value to add
  179.  *
  180.  * atomically adds @i to @v and returns true
  181.  * if the result is negative, or false when
  182.  * result is greater than or equal to zero.
  183.  */
  184. static __inline__ int atomic_add_negative(int i, atomic_t *v)
  185. {
  186.     unsigned char c;

  188.     __asm__ __volatile__(
  189.         lock "addl %2,%0; sets %1"
  190.         :"=m" (v->counter), "=qm" (c)
  191.         :"ir" (i), "m" (v->counter) : "memory");
  192.     return c;
  193. }
  194. 对原子类型的变量v原子地增加i，并判断结果是否为负数，如果是，返回真，否则返回假；

      原子操作通常用于实现资源的引用计数，在编写代码的时候，能使用原子操作的时候，就尽量不要使用复杂的锁机制。对于多数体系结构来说，原子与更复杂的同步方法相比较，给系统带来的开销小，对高速缓存行的影响也小。
 
    除原子整形操作外，内核还提供了一组针对这一级数据进行操作的函数，其定义在include\asm-x86_64\bitops.h中，位操作函数是对普通的内存地址进行操作的。参数为一个指针和一个位号，第0位是给定地址的最低有效位。32位机上，第31位是给定地址的最高有效位，而第32位是下一个字节的最低有效位。

点击(此处)折叠或打开

  1. #define addr (*(volatile long *) addr)
  2. 把addr强制转换为(volatile long ) 类型的指针，即对指针的操作范围是addr开始的4个字节(long 型),暂时记作p,那么就是
  3. #define addr *p,即为p指针指向位置的内容。这里可以通过内存寻址访问到寄存器addr,可以进行读写操作。
  4. 假设内存0xaaaaaaaa是一个寄存器，如果要访问它，可以这样：
  5. #define addr (*(volatile long *) 0xaaaaaaaa )
  6. 读：tmp = addr;
  7. 写：addr = 0xaabbccdd;

  9. /**
  10.  * set_bit - atomically set a bit in memory
  11.  * @nr: the bit to set
  12.  * @addr: the address to start counting from
  13.  *
  14.  * this function is atomic and may not be reordered. see __set_bit()
  15.  * if you do not require the atomic guarantees.
  16.  * note that @nr may be almost arbitrarily large; this function is not
  17.  * restricted to acting on a single-word quantity.
  18.  */
  19. static __inline__ void set_bit(long nr, volatile void * addr)
  20. {
  21.     __asm__ __volatile__( lock_prefix
  22.         "btsq %1,%0"
  23.         :"=m" (addr)
  24.         :"dir" (nr) : "memory");
  25. }
  26. bts( bit test and set),bts oprd1, oprd2 : 即位测试并置位,被测试位送cf并且被测试位置1；上面的内联汇编代码即将addr指向的内容第nr位置1；
  27. 此为原子操作，而且是不可重新排序的；@nr 可以很大，并非只能是单个word的数量的限制。

  29. /**
  30.  * __set_bit - set a bit in memory
  31.  * @nr: the bit to set
  32.  * @addr: the address to start counting from
  33.  *
  34.  * unlike set_bit(), this function is non-atomic and may be reordered.
  35.  * if it's called on the same region of memory simultaneously, the effect
  36.  * may be that only one operation succeeds.
  37.  */
  38. static __inline__ void __set_bit(int nr, volatile void * addr)
  39. {
  40.     __asm__ volatile(
  41.         "btsl %1,%0"
  42.         :"=m" (addr)
  43.         :"dir" (nr) : "memory");
  44. }
  45. 非原子位操作函数，与set_bit对应，__set_bit不保证原子性,内核对每个操作都提供了原子位操作数的版本，以及非原子位操作的版本，其操作完全相同，只是后者名字前缀多两个下划线，以下仅对原子位操作进行说明。

  47. /**
  48.  * clear_bit - clears a bit in memory
  49.  * @nr: bit to clear
  50.  * @addr: address to start counting from
  51.  *
  52.  * clear_bit() is atomic and may not be reordered. however, it does
  53.  * not contain a memory barrier, so if it is used for locking purposes,
  54.  * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
  55.  * in order to ensure changes are visible on other processors.
  56.  */
  57. static __inline__ void clear_bit(int nr, volatile void * addr)
  58. {
  59.     __asm__ __volatile__( lock_prefix
  60.         "btrl %1,%0"
  61.         :"=m" (addr)
  62.         :"dir" (nr));
  63. }

  65. static __inline__ void __clear_bit(int nr, volatile void * addr)
  66. {
  67.     __asm__ __volatile__(
  68.         "btrl %1,%0"
  69.         :"=m" (addr)
  70.         :"dir" (nr));
  71. }
  72. #define smp_mb__before_clear_bit()    barrier()
  73. #define smp_mb__after_clear_bit()    barrier()

  75. bts( bit test and reset), btr oprd1,oprd2 位测试并复位指令，被测试位送cf并且被测试位清0；上面的内联汇编代码原子地清除addr所指对象的第nr位。它不包含内存屏障（当多个cpu同时访问一块内存，或者cpu和设备同时访问一块内存，为了实现访问的一致性，需要内存屏障），因此只是用于锁，为了确保在其他的进程中可见，你应该先调用 smp_mb__before_clear_bit()， smp_mb__after_clear_bit()；

  77. /**
  78.  * __change_bit - toggle a bit in memory
  79.  * @nr: the bit to change
  80.  * @addr: the address to start counting from
  81.  *
  82.  * unlike change_bit(), this function is non-atomic and may be reordered.
  83.  * if it's called on the same region of memory simultaneously, the effect
  84.  * may be that only one operation succeeds.
  85.  */
  86. static __inline__ void __change_bit(int nr, volatile void * addr)
  87. {
  88.     __asm__ __volatile__(
  89.         "btcl %1,%0"
  90.         :"=m" (addr)
  91.         :"dir" (nr));
  92. }

  94. /**
  95.  * change_bit - toggle a bit in memory
  96.  * @nr: bit to change
  97.  * @addr: address to start counting from
  98.  *
  99.  * change_bit() is atomic and may not be reordered.
  100.  * note that @nr may be almost arbitrarily large; this function is not
  101.  * restricted to acting on a single-word quantity.
  102.  */
  103. static __inline__ void change_bit(int nr, volatile void * addr)
  104. {
  105.     __asm__ __volatile__( lock_prefix
  106.         "btcl %1,%0"
  107.         :"=m" (addr)
  108.         :"dir" (nr));
  109. }
  110. 原子的翻转addr所指对象的第nr位；

  112. /**
  113.  * test_and_set_bit - set a bit and return its old value
  114.  * @nr: bit to set
  115.  * @addr: address to count from
  116.  *
  117.  * this operation is atomic and cannot be reordered.
  118.  * it also implies a memory barrier.
  119.  */
  120. static __inline__ int test_and_set_bit(int nr, volatile void * addr)
  121. {
  122.     int oldbit;

  124.     __asm__ __volatile__( lock_prefix
  125.         "btsl %2,%1\n\tsbbl %0,%0"
  126.         :"=r" (oldbit),"=m" (addr)
  127.         :"dir" (nr) : "memory");
  128.     return oldbit;
  129. }

  131. /**
  132.  * __test_and_set_bit - set a bit and return its old value
  133.  * @nr: bit to set
  134.  * @addr: address to count from
  135.  *
  136.  * this operation is non-atomic and can be reordered.
  137.  * if two examples of this operation race, one can appear to succeed
  138.  * but actually fail. you must protect multiple accesses with a lock.
  139.  */
  140. static __inline__ int __test_and_set_bit(int nr, volatile void * addr)
  141. {
  142.     int oldbit;

  144.     __asm__(
  145.         "btsl %2,%1\n\tsbbl %0,%0"
  146.         :"=r" (oldbit),"=m" (addr)
  147.         :"dir" (nr));
  148.     return oldbit;
  149. }
  150. 原子的设置addr所指对象的第nr位，并返回原先的值；

  152. /**
  153.  * test_and_clear_bit - clear a bit and return its old value
  154.  * @nr: bit to clear
  155.  * @addr: address to count from
  156.  *
  157.  * this operation is atomic and cannot be reordered.
  158.  * it also implies a memory barrier.
  159.  */
  160. static __inline__ int test_and_clear_bit(int nr, volatile void * addr)
  161. {
  162.     int oldbit;

  164.     __asm__ __volatile__( lock_prefix
  165.         "btrl %2,%1\n\tsbbl %0,%0"
  166.         :"=r" (oldbit),"=m" (addr)
  167.         :"dir" (nr) : "memory");
  168.     return oldbit;
  169. }

  171. /**
  172.  * __test_and_clear_bit - clear a bit and return its old value
  173.  * @nr: bit to clear
  174.  * @addr: address to count from
  175.  *
  176.  * this operation is non-atomic and can be reordered.
  177.  * if two examples of this operation race, one can appear to succeed
  178.  * but actually fail. you must protect multiple accesses with a lock.
  179.  */
  180. static __inline__ int __test_and_clear_bit(int nr, volatile void * addr)
  181. {
  182.     int oldbit;

  184.     __asm__(
  185.         "btrl %2,%1\n\tsbbl %0,%0"
  186.         :"=r" (oldbit),"=m" (addr)
  187.         :"dir" (nr));
  188.     return oldbit;
  189. }
  190. 原子的清空addr所指对象的第nr位，并返回原先的值；

  192. /* warning: non atomic and it can be */
  193. static __inline__ int __test_and_change_bit(int nr, volatile void * addr)
  194. {
  195.     int oldbit;

  197.     __asm__ __volatile__(
  198.         "btcl %2,%1\n\tsbbl %0,%0"
  199.         :"=r" (oldbit),"=m" (addr)
  200.         :"dir" (nr) : "memory");
  201.     return oldbit;
  202. }

  204. /**
  205.  * test_and_change_bit - change a bit and return its old value
  206.  * @nr: bit to change
  207.  * @addr: address to count from
  208.  *
  209.  * this operation is atomic and cannot be reordered.
  210.  * it also implies a memory barrier.
  211.  */
  212. static __inline__ int test_and_change_bit(int nr, volatile void * addr)
  213. {
  214.     int oldbit;

  216.     __asm__ __volatile__( lock_prefix
  217.         "btcl %2,%1\n\tsbbl %0,%0"
  218.         :"=r" (oldbit),"=m" (addr)
  219.         :"dir" (nr) : "memory");
  220.     return oldbit;
  221. }
  222. 原子的翻转addr所指对象的第nr位，并返回原先的值；

  224. to be continue ......

参考：
   《汇编语言程序设计》
   《linux内核设计实现》
    linux 内核的同步机制，第 1 ，2部分
   
  
   linux内存屏障浅析
    

 
阅读(4016) | 评论(0) | 转发(5) |
1

上一篇：linux下使用读写锁

下一篇：linux 内核的同步机制--自旋锁

给主人留下些什么吧！~~
| | | | |

凯发app官方网站 copyright 2001-2010 chinaunix.net all rights reserved 北京皓辰网域网络信息技术有限公司. 凯发k8官网下载客户端中心的版权所有

感谢所有关心和支持过chinaunix的朋友们
")); function link(t){ var href= $(t).attr('href'); href ="?url=" encodeuricomponent(location.href); $(t).attr('href',href); //setcookie("returnouturl", location.href, 60, "/"); }
网站地图