原子操作(1) - 用汇编实现原子操作

女爷i 2022-08-05 15:17 207阅读 0赞

“最轻量级的锁”,通常也叫”原子操作”,之所以加引号是因为他们在汇编级别并不是原子操作,是用多条指令完成的,这些操作大多都是利用CPU支持的汇编指令.在某些构架过时的CPU体系结构上,它们应该是用比较重量级的线程内锁实现的吧(我的猜测).

最常见的原子操作有Compare and Exchange,Self Increase/Decrease等等

**80486 CPU相关指令：**

LOCK:这是一个指令前缀，在所对应的指令操作期间使此指令的目标操作数指定的存储区域锁定，以得到保护。

XADD:先交换两个操作数的值，再进行算术加法操作。多处理器安全，在80486及以上CPU中支持。

CMPXCHG:比较交换指令，第一操作数先和AL/AX/EAX比较，如果相等ZF置1，第二操作数赋给第一操作数，否则ZF清0，第一操作数赋给AL/AX/EAX。多处理器安全，在80486及以上CPU中支持。

XCHG:交换两个操作数,其中至少有一个是寄存器寻址.其他寄存器和标志位不受影响.

80486以上都支持这四个操作,因此当今几乎100%CPU都支持这两个指令,也能由此用标准C和C++写出一系列几乎可以跨平台的”原子操作”函数和Lock-Free数据结构和算法.

64位平台也有一系列的相关指令,当然他们也有以上提到的指令,其下的64位原子操作函数应该和32位的分开(要问为什么?我现在告诉你恐怕你印象不深,接着看这一系列吧),而道理完全一样.因此,不存在跨CPU体系结构的问题)

**“原子操作”函数:**

由以上提供的几个汇编指令,我们可以做出以下实现,这些都是最常用的原语.

比较后交换

long** **\_\_stdcall** CompareExchange**(long** **volatile\***Destination**,long** Exchange**,long** Comperand**)

**   **\_\_asm

**   \{**

**      mov     ecx**, **Destination**;

**      mov     edx**, **Exchange**;

**      mov     eax**, **Comperand**;

**      lock cmpxchg \[ecx**\], **edx**;

**   \}**

交换

long** **\_\_stdcall** Exchange**(long** **volatile\* **Target**,long** Value**)

**   **\_\_asm

**   \{**

**      mov      ecx**, **Target**;

**      mov      edx**, **Value**;

**label**:

**      lock cmpxchg \[ecx**\], **edx**;//加

**      jnz      **short** label**;

**   \}**

自减

long** **\_\_stdcall** Decrement**(long** **volatile\* **Addend**)

**   **\_\_asm

**   \{**

**      mov     ecx**, **Addend**;

**      mov     eax**, 0FFFFFFFFh;//-1

**      lock xadd \[ecx**\], **eax**; //加-1

**      dec     eax**;

**   \}**

自增

long** **\_\_stdcall** Increment**(long** **volatile\* **Addend**)

**   **\_\_asm

**   \{**

**      mov      ecx**, **Addend**;

**      mov      eax**, 1;

**      lock xadd \[ecx**\], **eax**; //加

**      inc      eax**;

**   \}**

相加后交换

long** **\_\_stdcall** ExchangeAdd**(long** **volatile\* **Addend**,long** Value**)

**   **\_\_asm

**   \{**

**      mov      ecx**, **Addend**;

**      mov      eax**, **Value**;

**      lock xadd \[ecx**\], **eax**;

**   \}**

原子操作(2) - 泛型后的原子操作

32 位的数据类型有4种,但是上面的只支持long,怎么办?手工hack?太土了,当然是C++的大规模杀伤性武器template了.

同时把几个不跨平台的地方抽出来用macro表示.

目前模板还没有得到concept的支持,所以只能用boost.type\_traits低级的手动判断,要求只有32位的整数类型才能实例化这些函数.

\#include

\#define** CALL\_METHOD **\_\_stdcall

\#define** VOLATILE **volatile

template<typename** T**>

**T CALL\_METHOD compare\_exchange32**(**T VOLATILE**\***Destination**,**T exchange32**,**T Comperand**)

**   BOOST\_STATIC\_ASSERT**(sizeof(**T**) == 4 && **boost**::**is\_integral**<**T**>::**value**);

**   **\_\_asm

**   \{**

**      mov     ecx**, **Destination**;

**      mov     edx**, **exchange32**;

**      mov     eax**, **Comperand**;

**      lock cmpxchg \[ecx**\], **edx**;

**   \}**

template<typename** T**>

**T CALL\_METHOD exchange32**(**T VOLATILE**\* **Target**,**T Value**)

**   BOOST\_STATIC\_ASSERT**(sizeof(**T**) == 4 && **boost**::**is\_integral**<**T**>::**value**);

**   **\_\_asm

**   \{**

**      **//     mov    ecx, Target;

**      **//     mov    edx, Value;

**      **//label:

**      **//     lock   cmpxchg \[ecx\], edx;//加

**      **//     jnz    short label;

**      mov      ecx**, **Target**;

**      mov      eax**, **Value**;

**      xchg \[ecx**\],**eax**;

**   \}**

template<typename** T**>

**T CALL\_METHOD decrement32**(**T VOLATILE**\* **Addend**)

**   BOOST\_STATIC\_ASSERT**(sizeof(**T**) == 4 && **boost**::**is\_integral**<**T**>::**value**);

**   **\_\_asm

**   \{**

**      mov     ecx**, **Addend**;

**      mov    eax**, 0FFFFFFFFh;//-1

**      lock xadd \[ecx**\], **eax**; //加-1

**      dec     eax**;

**   \}**

template<typename** T**>

**T CALL\_METHOD increment32**(**T VOLATILE**\* **Addend**)

**   BOOST\_STATIC\_ASSERT**(sizeof(**T**) == 4 && **boost**::**is\_integral**<**T**>::**value**);

**   **\_\_asm

**   \{**

**      mov      ecx**, **Addend**;

**      mov      eax**, 1;

**      lock xadd \[ecx**\], **eax**; //加

**      inc      eax**;

**   \}**

template<typename** T**>

**T CALL\_METHOD exchange\_add32**(**T VOLATILE**\* **Addend**,**T Value**)

**   BOOST\_STATIC\_ASSERT**(sizeof(**T**) == 4 && **boost**::**is\_integral**<**T**>::**value**);

**   **\_\_asm

**   \{**

**      mov      ecx**, **Addend**;

**      mov      eax**, **Value**;

**      lock xadd \[ecx**\], **eax**;

**   \}**

原子操作(3) - 原子数类

根据上面的5个函数就能做出一个原子操作的整数数字类,这将是下一节中,我的最轻量级锁的基础和原型,他不依赖于操作系统,当然,所以你也可以不叫他是锁,只是一种类似锁的机制.

一切细节看源码中穿插的注释.

\#ifndef** \_\_ATOM\_VALUE\_H\_\_**

\#define** \_\_ATOM\_VALUE\_H\_\_**

\#include** **"atom.hpp"

\#include** **<boost/static\_assert.hpp>

\#include** **<boost/type\_traits.hpp>

template<typename** T**>

class** atomic\_value32**

**   **//恩,用boost.type\_traits来保证是位的整数类型

**   BOOST\_STATIC\_ASSERT**(sizeof(**T**) == 4 && **boost**::**is\_integral**<**T**>::**value**);

private:

**   **volatile** T value\_**;

public:

**   atomic\_value32**(**T v = 0)**

**      :value\_**(**v**)\{\}

**   atomic\_value32**(**atomic\_value32**& **v**)\{ //??? 这里留给大家,我不给出源码了

**   \}**

**   **//需要这么一个转型符号,因为大部分时候我们将atomic\_value32<T>当作一个T使用

**   **operator** T**()\{ return** exchange\_add32**(&**value\_**,0);\}

**   **//赋值

**   atomic\_value32**& operator=(**T v**)\{ **exchange32**(&**value\_**, **v**);return** \***this;\}

**   atomic\_value32**& operator=(**atomic\_value32**& **v**)\{ **exchange32**(&**value\_**, **v**);return** \***this;\}

**   **//比较并交换,好像没有什么operator与之对应,就直接拿出来了

**   T compare\_exchange**(**T to\_exchange**, **T to\_compare**)

**   \{** return** compare\_exchange32**<**T**>(&**value\_**, **to\_exchange**, **to\_compare**);\}

**   **//只提供前置,后置似乎没什么必要,我也懒得去实现了:)

**   T **operator\++()\{ return** increment32**(&**value\_**);\}

**   T **operator\--()\{ return** decrement32**(&**value\_**);\}

**   **//千万不能返回引用,因为线程安全考虑,

**   T **operator\+=(**T add**)\{ return** exchange\_add32**(&**value\_**,**add**);\}

**   T **operator\+=(**atomic\_value32**& **add**)\{ return** exchange\_add32**(&**value\_**,**add**);\}

**   T **operator\-=(**T add**)\{ return** exchange\_add32**(&**value\_**,-**add**);\}

**   T **operator\-=(**atomic\_value32**& **add**)\{ return** exchange\_add32**(&**value\_**,-**add**);\}

**   **//6个比较符号

**   **bool** **operator==(**T rhs**)\{ return** **operator** T**()==**rhs**;\}

**   **bool** **operator==(**atomic\_value32**& **rhs**)\{ return** **operator** T**()==**rhs**.operator** T**();\}

**   **bool** **operator<(**T rhs**)\{ return** **operator** T**()<**rhs**;\}

**   **bool** **operator<(**atomic\_value32**& **rhs**)\{ return** **operator** T**()<**rhs**.operator** T**();\}

**   **bool** **operator!=(**T rhs**)\{ return** !**this\->operator** ==(rhs**);\}

**   **bool** **operator!=(**atomic\_value32**& **rhs**)\{ return** !**this\->operator** ==(rhs**);\}

**   **bool** **operator>=(**T rhs**)\{ return** !**this\->operator** <(rhs**);\}

**   **bool** **operator>=(**atomic\_value32**& **rhs**)\{ return** !**this\->operator** <(rhs**);\}

**   **bool** **operator>(**T rhs**)\{ return** ((\***this)!=(**rhs**)) && !((\*this)<(**rhs**));\}

**   **bool** **operator>(**atomic\_value32**& **rhs**)\{ return** ((\***this)!=(**rhs**)) && !((\*this)<(**rhs**));\}

**   **bool** **operator<=(**T rhs**)\{ return** !((\***this)>(**rhs**));\}

**   **bool** **operator<=(**atomic\_value32**& **rhs**)\{ return** !((\***this)>(**rhs**));\}

\};

\#endif//\_\_ATOM\_VALUE\_H\_\_

转帖：http://www.cppblog.com/woaidongmao/archive/2014/12/23/98965.html

原子操作(1) - 用汇编实现原子操作

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关原子操作实现原理

相关 Java多线程原子操作加上原子操作不等于原子操作

相关【Java并发编程】原子操作（一）：计算机如何实现原子操作

相关原子操作类

相关原子操作(1) - 用汇编实现原子操作

相关原子操作实现

相关原子操作

相关原子操作

相关 java 原子操作的实现原理(1)

相关 CAS原子操作、原子操作类