atomic.h

Go to the documentation of this file.

#pragma once
 
/*
________________________________________________________________________
 
 (C) dGB Beheer B.V.; (LICENSE) http://opendtect.org/OpendTect_license.txt
 Author:        K. Tingdahl
 Date:          9-3-1999
________________________________________________________________________
 
*/
 
#include "gendefs.h"
#include "odversion.h"
 
#ifdef __win__
# include "windows.h"
#endif
 
# include <atomic>
 
namespace Threads
{
 
template <class T>
mClass(Basic) Atomic : public std::atomic<T>
{
public:
                                Atomic(T val=0);
                                Atomic(const Atomic<T>&);
                                ~Atomic();
 
    Atomic<T>&                  operator=(T nv);
    Atomic<T>&                  operator=(const Atomic<T>&);
 
    mDeprecated("Use load") inline T get() const
                                { return std::atomic<T>::load(); }
 
    inline void                 setIfLarger(T newval);
    inline void                 setIfSmaller(T newval);
    inline bool                 setIfValueIs(T curval,T newval,
                                             T* actualvalptr = 0);
};
 
 
mGlobal(Basic) bool atomicSetIfValueIs(volatile int& val,int curval,int newval,
                                        int* actualvalptr);
 
 
template <class T>
mClass(Basic) AtomicPointer : public std::atomic<T*>
{
public:
    inline      AtomicPointer(T* newptr = 0);
 
    inline bool setIfEqual(const T* curptr, T* newptr);
    bool                operator!() const { return !std::atomic<T*>::load();  }
                        operator bool() const { return std::atomic<T*>::load();}
 
    T*                  operator->() { return std::atomic<T*>::load(); }
    const T*            operator->() const { return std::atomic<T*>::load(); }
 
    AtomicPointer<T>&   operator=(T* ptr);
    AtomicPointer<T>&   operator=(const AtomicPointer<T>&);
 
    inline T*   setToNull();
    inline      AtomicPointer(const AtomicPointer<T>&) = delete;
};
 
 
mExpClass(Basic) SpinLock
{
public:
                SpinLock(bool recursive = false);
                /*\If recursive, mutex can be locked
                   multiple times from the same thread without deadlock.
                   It will be unlock when unLock has been called the same
                   number of times as lock(). */
                SpinLock(const SpinLock&);
                ~SpinLock();
 
    SpinLock&   operator=(const SpinLock& b)
                { recursive_ = b.recursive_; return *this; }
 
    void        lock();
    void        unLock();
    bool        tryLock();
 
protected:
    Atomic<void*>               lockingthread_;
    Atomic<int>                 count_;
    bool                        recursive_;
 
public:
    int                         count() const   { return count_; }
};
 
 
mExpClass(Basic) SpinRWLock
{
public:
                        SpinRWLock();
                        /*\If recursive, mutex can be locked
                         multiple times from the same thread without deadlock.
                         It will be unlock when unLock has been called the same
                         number of times as lock(). */
                        SpinRWLock(const SpinRWLock&);
                        ~SpinRWLock();
 
 
    void                readLock();
    void                readUnlock();
    void                writeLock();
    void                writeUnlock();
 
protected:
    Atomic<int>         count_;
 
public:
    int                 count() const   { return count_; }
};
 
 
//Implementations
 
 
template <class T>
void Atomic<T>::setIfLarger( T newval )
{
    T oldval = *this;
    do
    {
        if ( oldval>=newval )
            return;
    }
    while ( !setIfValueIs( oldval, newval, &oldval ) );
}
 
template <class T>
void Atomic<T>::setIfSmaller( T newval )
{
    T oldval = *this;
    do
    {
        if ( oldval<=newval )
            return;
    }
    while ( !setIfValueIs( oldval, newval, &oldval ) );
}
 
 
template <class T> inline
Atomic<T>::Atomic( T val )
    : std::atomic<T>( val )
{}
 
 
template <class T> inline
Atomic<T>::Atomic( const Atomic<T>& val )
    : std::atomic<T>( sCast(T,val) )
{}
 
 
template <class T> inline
Threads::Atomic<T>::~Atomic()
{}
 
 
template <class T> inline
Threads::Atomic<T>& Threads::Atomic<T>::operator=(T nv)
{ std::atomic<T>::store(nv); return *this; }
 
 
template <class T> inline
Threads::Atomic<T>& Threads::Atomic<T>::operator=(const Threads::Atomic<T>& nv)
{ std::atomic<T>::store(nv); return *this; }
 
 
template <class T> inline
bool Atomic<T>::setIfValueIs( T curval, T newval, T* actualvalptr )
{
    T presumedval = curval;
    if ( !this->compare_exchange_strong(presumedval,newval) )
    {
        if ( actualvalptr )
            *actualvalptr = presumedval;
        return false;
    }
 
    return true;
}
 
 
 
/* AtomicPointer implementations. */
template <class T> inline
AtomicPointer<T>::AtomicPointer(T* newptr )
    : std::atomic<T*>( newptr )
{}
 
 
template <class T> inline
bool AtomicPointer<T>::setIfEqual( const T* oldptr, T* newptr )
{
    T* curval = const_cast<T*>( oldptr );
    return this->compare_exchange_strong( curval, newptr );
}
 
 
template <class T> inline
T* AtomicPointer<T>::setToNull()
{
    return std::atomic<T*>::exchange( 0 );
}
 
 
template <class T> inline
AtomicPointer<T>& AtomicPointer<T>::operator=(T* ptr)
{
    std::atomic<T*>::store( ptr );
    return *this;
}
 
 
template <class T> inline
AtomicPointer<T>& AtomicPointer<T>::operator=(const AtomicPointer<T>& ptr)
{
    return operator=( sCast(T*,ptr) );
}
 
} //namespace Threads
 
 
typedef Threads::Atomic<DirtyCountType>     DirtyCounter;