SyncUtils.h

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

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

#ifndef CNTM_SYNCUTILS_H
#define CNTM_SYNCUTILS_H
#include <sched.h>
#include <unistd.h>
#include <Cntm/SystemUtils/AtomicUtils.h>

namespace Cntm
{
        namespace SpecUtils
        {
                
                /**
                 * Класс быстрого нерекурсивного мьютекса. Используется для коротких критических секций.
                 * @author Овсеевич Р.
                 * \ingroup SystemUtils
                 */
                class FastMutex
                {
                public:
                        
                        /**
                         * Класс блокировки для быстрого мьютекса.
                         * @author Овсеевич Р.
                         */
                        class Lock
                        {
                        public:
                                
                                /**
                                 * Конструктор. Захватывает мьютекс.
                                 */
                                Lock(FastMutex& Mutex): mutex(&Mutex) { mutex->Enter(); }
                                
                                /**
                                 * Конструктор. Захватывает мьютекс.
                                 */
                                Lock(FastMutex* Mutex): mutex(Mutex) { mutex->Enter(); }
                                
                                /**
                                 * Деструктор. Освобождает мьютекс.
                                 */
                                ~Lock() { mutex->Leave(); }
                                
                        private:
                        
                                /**
                                 * Указатель на мьютекс.
                                 */
                                FastMutex* mutex;
                        };
                        
                        /**
                         * Конструктор.
                         */
                        FastMutex(): flag(-1) {}
                        
                        /**
                         * Войти в критическую секцию. Если критеческая сеция занята, то производит ожидание ее освобождения. Повторный вызов из того же потока приведет к зависанию.
                         */
                        void Enter() 
                        { 
                                // Пока после увеличения флаг не примет значение 0,
                                // перевести его в предыдущее состояние и ожидать.
                                while (!flag.IncAndTest())
                                {
                                        flag.Dec();
                                        sched_yield(); 
                                }
                        }
                        
                        /**
                         * Выйти из критической секции.
                         */
                        void Leave() { flag.Dec(); }
                        
                private:
                        
                        /**
                         * Флаг занятости критической секции. -1 - свободна, >= 0 - занята.
                         */
                        AtomicVariable flag;
                };
                
                /**
                 * Функция ожидания момента, когда занчение переменной Variable перестанет равняться BadValue.
                 * \ingroup SystemUtils
                 */
                template < typename T >
                inline void FastWaitNoEqual(volatile const T* Variable, T BadValue)
                {
                        while (*Variable == BadValue)
                                sched_yield();
                }

                /**
                 * Функция ожидания момента, когда занчение переменной Variable перестанет равняться Value. В этот момент она атомарно опять устанавливает Value и возвращает то значение, которое было до установки Value.
                 * \ingroup SystemUtils
                 */
                template < typename T >
                inline T* FastWaitPtrNoEqualAndSet(T*volatile* Variable, T* Value)
                {
                        T* res;
                        while ((res = AtomicSwapPtr(Variable, Value)) == Value)
                                sched_yield();
                        return res;
                }

                /**
                 * Функция ожидания момента, когда занчение переменной Variable станет равной NeedValue.
                 * \ingroup SystemUtils
                 */
                template < typename T >
                inline void FastWaitEqual(volatile const T* Variable, T NeedValue)
                {
                        while (*Variable != NeedValue)
                                sched_yield();
                }

                /**
                 * Функция ожидания момента, когда занчение атомарной переменной станет равной NeedValue.
                 * \ingroup SystemUtils
                 */
                inline void FastWaitEqual(const AtomicVariable& Variable,
                        AtomicVariable::Type NeedValue)
                {
                        while (Variable.Value() != NeedValue)
                                sched_yield();
                }

        }
}

#endif //CNTM_SYNCUTILS_H

---