AtomicUtils.h

См. документацию.

/*
 * CntmLib - Подсчет ссылок, потоки, синхронизация, асинхронные процедуры, события
 * Copyright (c) 2005, Овсеевич Роман, CntmLib@mail.ru
 * _______________________________________________________________________________
 * Разрешено свободное использование, копирование, распространение, изменение
 * (изменение сведений об авторских правах запрещено). Запрещена продажа и 
 * включение всей библиотеки или ее частей в другие библиотеки. В сведениях об
 * авторских правах на программу (или сведениях о программе, об авторах, 
 * использованных средствах разработки и т.д.) должна быть указана информация
 * о библиотеке CntmLib, ее авторе и, возможно, сайте или email'е.
 * Библиотека поставляется "как есть", без каких-либо гарантий со стороны автора.
 */ 

#ifndef CNTM_ATOMICUTILS_H
#define CNTM_ATOMICUTILS_H
#include <cstddef>
#include <Cntm/Utils/IntTypes.h>

#if !defined(__linux__)
#error Atomic operations not support this OS.
#endif

#if !defined(__GNUC__)
#error Atomic operations not support this compiler.
#endif

#if !(defined(__i386__) || defined(__x86_64__) || defined(__arm__) || defined(__arm))
#error Atomic operations not support this processor.
#endif

namespace Cntm
{
        namespace SpecUtils
        {

#if defined(__i386__)

                /**
                 * Тип целой атомарной переменной.
                 */
                typedef int AtomicIntType;
                
                /**
                 * Устанавливает новое значение, возвращает старое. Операция чтения старого значения и записи нового выполняется атомарно.
                 */
                template <typename T>
                static inline T* AtomicSwapPtr(T*volatile* Variable, T* NewValue)
                {
                        asm volatile(
                                "xchgl %0,%1"
                                        :"=r" (NewValue)
                                        :"m" (*Variable), "0" (NewValue)
                                        :"memory");
                        return NewValue;
                }

                /**
                 * Считать значение переменной.
                 */
                static inline AtomicIntType AtomicGet(volatile const AtomicIntType* Variable)
                {
                        return *Variable;
                }
                
                /**
                 * Установить значение переменной.
                 */
                static inline void AtomicSet(volatile AtomicIntType* Variable, AtomicIntType val)
                {
                        *Variable = val;
                }
                
                /**
                 * Прибавить к переменной v значение 1.
                 */
                static inline void AtomicInc(volatile AtomicIntType* Variable)
                {
                        asm volatile(
                                "lock ; " "incl %0"
                                        :"=m" (*Variable)
                                        :"m" (*Variable));
                }

                /**
                 * Отнять от переменной v значение 1.
                 */
                static inline void AtomicDec(volatile AtomicIntType* Variable)
                {
                        asm volatile(
                                "lock ; " "decl %0"
                                        :"=m" (*Variable)
                                        :"m" (*Variable));
                }

                /**
                 * Прибавить к переменной значение 1. Возвращает true, если при сложении текущее значение установилось в 0, иначе - false.
                 */
                static inline bool AtomicIncAndTest(volatile AtomicIntType* Variable)
                {
                        unsigned char res;
                
                        asm volatile(
                                "lock ; " "incl %0; sete %1"
                                        :"=m" (*Variable), "=qm" (res)
                                        :"m" (*Variable) : "memory");
                        return res != 0;
                }

                /**
                 * Отнять от переменной значение 1. Возвращает true, если при вычитании текущее значение установилось в 0, иначе - false.
                 */
                static inline bool AtomicDecAndTest(volatile AtomicIntType* Variable)
                {
                        unsigned char res;

                        asm volatile(
                                "lock ; " "decl %0; sete %1"
                                        :"=m" (*Variable), "=qm" (res)
                                        :"m" (*Variable) : "memory");
                        return res != 0;
                }
                
#endif // defined(__i386__)
                
#if defined(__x86_64__)

                /**
                 * Тип целой атомарной переменной.
                 */
                typedef int AtomicIntType;
                
                /**
                 * Устанавливает новое значение, возвращает старое. Операция чтения старого значения и записи нового выполняется атомарно.
                 */
                template <typename T>
                static inline T* AtomicSwapPtr(T*volatile* Variable, T* NewValue)
                {
                        asm volatile(
                                "xchgq %0,%1"
                                        :"=r" (NewValue)
                                        :"m" (*Variable), "0" (NewValue)
                                        :"memory");
                        return NewValue;
                }

                /**
                 * Считать значение переменной.
                 */
                static inline AtomicIntType AtomicGet(volatile const AtomicIntType* Variable)
                {
                        return *Variable;
                }
                
                /**
                 * Установить значение переменной.
                 */
                static inline void AtomicSet(volatile AtomicIntType* Variable, AtomicIntType val)
                {
                        *Variable = val;
                }
                
                /**
                 * Прибавить к переменной v значение 1.
                 */
                static inline void AtomicInc(volatile AtomicIntType* Variable)
                {
                        asm volatile(
                                "lock ; " "incl %0"
                                        :"=m" (*Variable)
                                        :"m" (*Variable));
                }

                /**
                 * Отнять от переменной v значение 1.
                 */
                static inline void AtomicDec(volatile AtomicIntType* Variable)
                {
                        asm volatile(
                                "lock ; " "decl %0"
                                        :"=m" (*Variable)
                                        :"m" (*Variable));
                }

                /**
                 * Прибавить к переменной значение 1. Возвращает true, если при сложении текущее значение установилось в 0, иначе - false.
                 */
                static inline bool AtomicIncAndTest(volatile AtomicIntType* Variable)
                {
                        unsigned char res;
                
                        asm volatile(
                                "lock ; " "incl %0; sete %1"
                                        :"=m" (*Variable), "=qm" (res)
                                        :"m" (*Variable) : "memory");
                        return res != 0;
                }

                /**
                 * Отнять от переменной значение 1. Возвращает true, если при вычитании текущее значение установилось в 0, иначе - false.
                 */
                static inline bool AtomicDecAndTest(volatile AtomicIntType* Variable)
                {
                        unsigned char res;

                        asm volatile(
                                "lock ; " "decl %0; sete %1"
                                        :"=m" (*Variable), "=qm" (res)
                                        :"m" (*Variable) : "memory");
                        return res != 0;
                }
                
#endif // defined(__x86_64__)
                
#if defined(__arm__) || defined(__arm)

                /**
                 * Тип целой атомарной переменной.
                 */
                typedef int AtomicIntType;
                
                /**
                 * Устанавливает новое значение, возвращает старое. Операция чтения старого значения и записи нового выполняется атомарно.
                 */
                template < typename T >
                static inline T* AtomicSwapPtr(T*volatile* Variable, T* NewValue)
                {
                        T* res;
                        asm volatile(
                                "swp %0, %2, [%1]"
                                        : "=&r" (res)
                                        : "r" (Variable), "r" (NewValue));
                        return res;
                }
        
                /**
                 * Считать значение переменной.
                 */
                static inline AtomicIntType AtomicGet(volatile const AtomicIntType* Variable)
                {
                        return *Variable;
                }
                
                /**
                 * Установить значение переменной.
                 */
                static inline void AtomicSet(volatile AtomicIntType* Variable, AtomicIntType val)
                {
                        *Variable = val;
                }

                /**
                 * Прибавить к переменной значение 1. Возвращает true, если при сложении текущее значение установилось в 0, иначе - false.
                 */
                static inline bool AtomicIncAndTest(volatile AtomicIntType* Variable)
                {
                int a, b, c;

                asm volatile (
                                "0:\n"
                                "ldr %0, [%3]\n"
                                "add %1, %0, %4\n"
                                "swp %2, %1, [%3]\n"
                                "cmp %0, %2\n"
                                "swpne %1, %2, [%3]\n"
                                "bne 0b"
                                : "=&r" (a), "=&r" (b), "=&r" (c)
                                : "r" (Variable), "r" (1)
                                : "cc", "memory");

                return b == 0;
                }
                
                /**
                 * Отнять от переменной значение 1. Возвращает true, если при вычитании текущее значение установилось в 0, иначе - false.
                 */
                static inline bool AtomicDecAndTest(volatile AtomicIntType* Variable)
                {
                        int a, b, c;

                        asm volatile (
                                "0:\n"
                                "ldr %0, [%3]\n"
                                "add %1, %0, %4\n"
                                "swp %2, %1, [%3]\n"
                                "cmp %0, %2\n"
                                "swpne %1, %2, [%3]\n"
                                "bne 0b"
                                        : "=&r" (a), "=&r" (b), "=&r" (c)
                                        : "r" (Variable), "r" (-1)
                                        : "cc", "memory");

                        return b == 0;
                }
                
                /**
                 * Прибавить к переменной v значение 1.
                 */
                static inline void AtomicInc(volatile AtomicIntType* Variable)
                {
                        AtomicIncAndTest(Variable);
                }

                /**
                 * Отнять от переменной v значение 1.
                 */
                static inline void AtomicDec(volatile AtomicIntType* Variable)
                {
                        AtomicDecAndTest(Variable);
                }

#endif // defined(__arm__) || defined(__arm)
                
                /**
                 * Класс атомарной переменной. Все операции над атомарной переменной выполняются без прерывания другими потоками, т.е они потокобезопасны.
                 * 
                 * Тип числового значения атомарной переменной - AtomicVariable::Type.
                 * \ingroup SystemUtils         
                 */
                class AtomicVariable
                {
                public:
                
                        typedef AtomicIntType Type;

                        /**
                         * Конструктор инициализации.
                         */
                        AtomicVariable(Type Init = 0) { var = Init; }

                        /**
                         * Текущее значение переменной.
                         */
                        Type Value() volatile const { return AtomicGet(&var); }

                        /**
                         * Установить новое значение переменной.
                         */
                        void SetValue(Type Value) { AtomicSet(&var, Value); }
                        
                        /**
                         * Прибавить к переменной значение 1.
                         */
                        void Inc() { AtomicInc(&var); }

                        /**
                         * Отнять от переменной значение 1.
                         */
                        void Dec() { AtomicDec(&var); }

                        /**
                         * Прибавить к переменной значение 1. Возвращает true, если при сложении текущее значение установилось в 0, иначе - false.
                         */
                        bool IncAndTest() { return AtomicIncAndTest(&var); }

                        /**
                         * Отнять от переменной значение 1. Возвращает true, если при вычитании текущее значение установилось в 0, иначе - false.
                         */
                        bool DecAndTest() { return AtomicDecAndTest(&var); }

                private:

                        /**
                         * Переменная.
                         */
                        volatile Type var;
                };

        }
}

#endif //CNTM_ATOMICUTILS_H

---