atomic_sync.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2016 Zhao DAI <daidodo@gmail.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or any
 * later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see accompanying file LICENSE.txt
 * or <http://www.gnu.org/licenses/>.
 */

#ifndef DOZERG_ATOMIC_SYNC_H_20130117
#define DOZERG_ATOMIC_SYNC_H_20130117

#include <cassert>
#include <cstddef>  //NULL
#include "impl/environment.hh"

NS_SERVER_BEGIN

template<typename T>
class CAtomicSync
{
    typedef CAtomicSync<T>  __Myt;
public:
    typedef T   value_type;
    explicit CAtomicSync(value_type c = value_type()):v_(c){}
    CAtomicSync(const __Myt & c):v_(c.load()){}
    value_type load() const volatile{
        return const_cast<__Myt *>(this)->add_fetch(0);
    }
    static value_type load(const value_type * v){
        assert(v);
        return add_fetch(const_cast<value_type *>(v), 0);
    }
    void store(value_type c) volatile{swap(c);}
    static void store(value_type * v, value_type c){
        assert(v);
        swap(v, c);
    }
    value_type fetch_add(value_type c) volatile{return __sync_fetch_and_add(&v_, c);}
    static value_type fetch_add(value_type * v, value_type c){
        assert(v);
        return __sync_fetch_and_add(v, c);
    }
    value_type add_fetch(value_type c) volatile{return __sync_add_and_fetch(&v_, c);}
    static value_type add_fetch(value_type * v, value_type c){
        assert(v);
        return __sync_add_and_fetch (v, c);
    }
    value_type fetch_sub(value_type c) volatile{return __sync_fetch_and_sub(&v_, c);}
    static value_type fetch_sub(value_type * v, value_type c){
        assert(v);
        return __sync_fetch_and_sub(v, c);
    }
    value_type sub_fetch(value_type c) volatile{return __sync_sub_and_fetch(&v_, c);}
    static value_type sub_fetch(value_type * v, value_type c){
        assert(v);
        return __sync_sub_and_fetch (v, c);
    }
    value_type fetch_or(value_type c) volatile{return __sync_fetch_and_or(&v_, c);}
    static value_type fetch_or(value_type * v, value_type c){
        assert(v);
        return __sync_fetch_and_or(v, c);
    }
    value_type or_fetch(value_type c) volatile{return __sync_or_and_fetch(&v_, c);}
    static value_type or_fetch(value_type * v, value_type c){
        assert(v);
        return __sync_or_and_fetch (v, c);
    }
    value_type fetch_and(value_type c) volatile{return __sync_fetch_and_and(&v_, c);}
    static value_type fetch_and(value_type * v, value_type c){
        assert(v);
        return __sync_fetch_and_and(v, c);
    }
    value_type and_fetch(value_type c) volatile{return __sync_and_and_fetch(&v_, c);}
    static value_type and_fetch(value_type * v, value_type c){
        assert(v);
        return __sync_and_and_fetch (v, c);
    }
    value_type fetch_xor(value_type c) volatile{return __sync_fetch_and_xor(&v_, c);}
    static value_type fetch_xor(value_type * v, value_type c){
        assert(v);
        return __sync_fetch_and_xor(v, c);
    }
    value_type xor_fetch(value_type c) volatile{return __sync_xor_and_fetch(&v_, c);}
    static value_type xor_fetch(value_type * v, value_type c){
        assert(v);
        return __sync_xor_and_fetch (v, c);
    }
    value_type swap(value_type c) volatile{return __sync_lock_test_and_set(&v_, c);}
    static value_type swap(value_type * v, value_type c){
        assert(v);
        return __sync_lock_test_and_set(v, c);
    }
    bool compare_swap(value_type expval, value_type newval, value_type * oldval = NULL) volatile{
        if(NULL == oldval)
            return __sync_bool_compare_and_swap(&v_, expval, newval);
        *oldval = __sync_val_compare_and_swap(&v_, expval, newval);
        return (*oldval == expval);
    }
    static bool compare_swap(value_type * val, value_type expval, value_type newval, value_type * oldval){
        assert(val);
        if(NULL == oldval)
            return __sync_bool_compare_and_swap(val, expval, newval);
        *oldval = __sync_val_compare_and_swap(val, expval, newval);
        return (*oldval == expval);
    }
    value_type operator =(const __Myt & c) volatile{return (v_ = c.load());}
    value_type operator =(value_type c) volatile{return (v_ = c);}
    operator value_type() const volatile{return load();}
    value_type operator ++() volatile{return add_fetch(1);}
    value_type operator --() volatile{return sub_fetch(1);}
    value_type operator ++(int) volatile{return fetch_add(1);}
    value_type operator --(int) volatile{return fetch_sub(1);}
    value_type operator +=(value_type c) volatile{return add_fetch(c);}
    value_type operator -=(value_type c) volatile{return sub_fetch(c);}
    value_type operator |=(value_type c) volatile{return or_fetch(c);}
    value_type operator &=(value_type c) volatile{return and_fetch(c);}
    value_type operator ^=(value_type c) volatile{return xor_fetch(c);}
private:
    value_type v_;
};

NS_SERVER_END

#endif