AtomicList.h

Go to the documentation of this file.

#ifndef included_AMP_AtomicList
#define included_AMP_AtomicList
 
#include <atomic>
#include <csignal>
#include <functional>
 
 
namespace AMP {
 
 
template<class TYPE, class COMPARE = std::less<TYPE>>
class AtomicList final
{
public:
    AtomicList( size_t capacity           = 1024,
                const TYPE &default_value = TYPE(),
                const COMPARE &comp       = COMPARE() );
 
    ~AtomicList();
 
    template<typename Compare, class... Args>
    inline TYPE remove( Compare compare, const Args &...args );
 
    inline TYPE remove_first();
 
    inline void insert( const TYPE &x );
 
    inline size_t size() const { return d_N.load(); }
 
    inline bool empty() const { return d_N.load() == 0; }
 
    inline void clear()
    {
        while ( !empty() )
            remove_first();
    }
 
    inline constexpr size_t capacity() const { return d_capacity; }
 
    inline constexpr size_t available() const { return d_capacity - size(); }
 
 
    inline bool check();
 
 
    inline size_t N_insert() const { return d_N_insert.load(); }
 
 
    inline size_t N_remove() const { return d_N_remove.load(); }
 
private:
    // Data members
    COMPARE d_compare;
    const size_t d_capacity;
    volatile TYPE d_default;
    volatile TYPE *d_objects;
    volatile std::atomic_int32_t d_N;
    volatile std::atomic_int32_t *d_next;
    volatile std::atomic_int32_t d_unused;
    volatile std::atomic_int64_t d_N_insert;
    volatile std::atomic_int64_t d_N_remove;
 
private:
    inline int lock( int i )
    {
        if ( i == -1 )
            return -1;
        int tmp = 0;
        do {
            tmp = d_next[i].fetch_and( 0 );
        } while ( tmp == 0 );
        return tmp;
    }
    inline void unlock( int i, int value )
    {
        if ( i != -1 )
            d_next[i].fetch_or( value );
    }
    inline int get_unused()
    {
        int i = 0;
        do {
            i = d_unused.fetch_and( 0 );
        } while ( i == 0 );
        d_unused.fetch_or( -( d_next[i] + 4 ) + 1 );
        d_next[i] = -3;
        return i;
    }
    inline void put_unused( int i )
    {
        int j = 0;
        do {
            j = d_unused.exchange( j );
        } while ( j == 0 );
        d_next[i] = -3 - j;
        d_unused.fetch_or( i );
    }
 
 
public:
    AtomicList( const AtomicList & ) = delete;
    AtomicList &operator=( const AtomicList & ) = delete;
};
 
 
} // namespace AMP
 
#include "AMP/utils/threadpool/AtomicList.hpp"
 
#endif