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 "basicmod.h"
#include "commondefs.h"
#include "plftypes.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>&);

    inline mDeprecated 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);
};


inline bool atomicSetIfValueIs( volatile int& val, int curval, int newval,
                               int* actualvalptr = 0 )
{
# ifdef __win__
    const int oldval =InterlockedCompareExchange( (volatile long*) &val, newval,
                                                 curval );
    if ( oldval!=curval )
    {
        if ( actualvalptr ) *actualvalptr = oldval;
        return false;
    }

    return true;

# else
    const int old = __sync_val_compare_and_swap( &val, curval, newval );
    if ( old!=curval )
    {
        if ( actualvalptr ) *actualvalptr = old;
        return false;
    }

    return true;
#endif
}


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>( (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=((T*)ptr);
}

} //namespace