• <ins id="pjuwb"></ins>
    <blockquote id="pjuwb"><pre id="pjuwb"></pre></blockquote>
    <noscript id="pjuwb"></noscript>
          <sup id="pjuwb"><pre id="pjuwb"></pre></sup>
            <dd id="pjuwb"></dd>
            <abbr id="pjuwb"></abbr>

            woaidongmao

            文章均收錄自他人博客,但不喜標題前加-[轉貼],因其丑陋,見諒!~
            隨筆 - 1469, 文章 - 0, 評論 - 661, 引用 - 0
            數據加載中……

            用匯編實現原子操作

             

            原子操作(1) - 用匯編實現原子操作

            最輕量級的鎖”,通常也叫原子操作”,之所以加引號是因為他們在匯編級別并不是原子操作,是用多條指令完成的,這些操作大多都是利用CPU支持的匯編指令.在某些構架過時的CPU體系結構上,它們應該是用比較重量級的線程內鎖實現的吧(我的猜測).

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

            80486 CPU相關指令:

            LOCK:這是一個指令前綴,在所對應的指令操作期間使此指令的目標操作數指定的存儲區域鎖定,以得到保護。

            XADD:先交換兩個操作數的值,再進行算術加法操作。多處理器安全,在80486及以上CPU中支持。

            CMPXCHG:比較交換指令,第一操作數先和AL/AX/EAX比較,如果相等ZF1,第二操作數賦給第一操作數,否則ZF0,第一操作數賦給AL/AX/EAX。多處理器安全,在80486及以上CPU中支持。

            XCHG:交換兩個操作數,其中至少有一個是寄存器尋址.其他寄存器和標志位不受影響.

            80486以上都支持這四個操作,因此當今幾乎100%CPU都支持這兩個指令,也能由此用標準CC++寫出一系列幾乎可以跨平臺的原子操作函數和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

            #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__

            posted on 2009-10-19 18:45 肥仔 閱讀(8367) 評論(1)  編輯 收藏 引用 所屬分類: C++ 基礎

            評論

            # re: 用匯編實現原子操作  回復  更多評論   

            推薦文章:[url=http://cjjjs.cn/windows/12342320121020.aspx]原子操作與互斥訪問關系分析 [/url]
            推薦理由:主要講解原子操作的原理和實現過程,借鑒了數據庫系統的事務來分析。
            2014-12-23 15:00 | wd
            色婷婷噜噜久久国产精品12p| 久久棈精品久久久久久噜噜| 人妻无码中文久久久久专区| 伊人久久大香线蕉综合5g| 久久久久国产一级毛片高清板 | 精品无码久久久久久尤物| 伊人久久大香线蕉成人| 区久久AAA片69亚洲| 无码伊人66久久大杳蕉网站谷歌| 少妇熟女久久综合网色欲| 精品综合久久久久久97| 亚洲AV日韩AV天堂久久| 久久综合亚洲欧美成人| 久久国产乱子精品免费女| 91性高湖久久久久| 久久精品桃花综合| 国产成人精品综合久久久久| 久久久无码人妻精品无码| 国内精品久久九九国产精品| 国产69精品久久久久9999| 久久久久久久91精品免费观看| 精品国产99久久久久久麻豆| 久久久久久亚洲Av无码精品专口| 久久se精品一区精品二区| 久久这里只有精品视频99| 一本一本久久a久久综合精品蜜桃 一本一道久久综合狠狠老 | 久久综合久久美利坚合众国| 亚洲AV日韩精品久久久久久| 久久国产一区二区| 久久天天躁夜夜躁狠狠| 国产91色综合久久免费| 久久国产综合精品五月天| 无码人妻精品一区二区三区久久久| 久久精品国产秦先生| 伊人久久亚洲综合影院| 国产精品久久精品| 热久久视久久精品18| 久久综合九色综合久99| 婷婷伊人久久大香线蕉AV | 婷婷综合久久中文字幕蜜桃三电影| 久久夜色精品国产亚洲|