Horizon » Horizon Simulation Framework

//==========================================================================

//   CATOMICOPSDEBUG.H  -  header for

//                     Horizon/OMNeT++/OMNEST

//            Discrete System Simulation in C++

//

// Simple lock-based re-implementation of the atomic operations provided by

// libatomic-ops for debugging purposes.

//

//==========================================================================

/*--------------------------------------------------------------*

  Copyright (C) 2009 Georg Kunz

  This file is distributed WITHOUT ANY WARRANTY. See the file

  `license' for details on this and other legal matters.

*--------------------------------------------------------------*/

/*

 * This file provides a simple replacement for the libatomic-ops functions

 * used in Horizon. The implementation is based on s single global mutex lock

 * to emulate atomic behavior. This replacement is not intended to be used in

 * production code, but it merely used for debugging purposes in relation with

 * the Intel Thread Checker tool that does not correctly handle libatomic-ops.

 */

#ifndef __CATOMICOPSDEBUG_H

#define __CATOMICOPSDEBUG_H

#include <pthread.h>

//

// completely disable locking and atomic operations

//

#ifdef ATOMIC_OPS_DEBUG_PLAIN

    #define _lock(a)

    #define _unlock(a)

#else

    #define _lock(a) pthread_mutex_lock(a)

    #define _unlock(a) pthread_mutex_unlock(a)

#endif

//

// matching typedef to replace the original AO_t type

//

typedef size_t AO_t;

extern "C" pthread_mutex_t global_atomic_ops_debug_mutex;

inline AO_t AO_load(const volatile AO_t* addr)

{

        _lock(&global_atomic_ops_debug_mutex);

        AO_t tmp = *addr;

        _unlock(&global_atomic_ops_debug_mutex);

        return tmp;

}

inline AO_t AO_load_acquire(const volatile AO_t* addr)

{

        return AO_load(addr);

}

inline AO_t AO_load_read(const volatile AO_t* addr)

{

        return AO_load(addr);

}

inline AO_t AO_load_full(const volatile AO_t* addr)

{

    return AO_load(addr);

}

inline void AO_store(volatile AO_t* addr, AO_t value)

{

        _lock(&global_atomic_ops_debug_mutex);

        *addr = value;

        _unlock(&global_atomic_ops_debug_mutex);

}

inline void AO_store_write(volatile AO_t* addr, AO_t value)

{

        AO_store(addr, value);

}

inline void AO_store_full(volatile AO_t* addr, AO_t value)

{

    AO_store(addr, value);

}

inline void AO_store_release(volatile AO_t* addr, AO_t value)

{

        AO_store(addr, value);

}

inline AO_t AO_fetch_and_add1(volatile AO_t *addr)

{

        _lock(&global_atomic_ops_debug_mutex);

        AO_t tmp = *addr;

        (*addr)++;

        _unlock(&global_atomic_ops_debug_mutex);

        return tmp;

}

inline AO_t AO_fetch_and_sub1(volatile AO_t *addr)

{

        _lock(&global_atomic_ops_debug_mutex);

        AO_t tmp = *addr;

        (*addr)--;

        _unlock(&global_atomic_ops_debug_mutex);

        return tmp;

}

inline int AO_compare_and_swap_full(volatile AO_t *addr, AO_t old_val, AO_t new_val)

{

        AO_t ret = 0;

        _lock(&global_atomic_ops_debug_mutex);

        if (*addr == old_val)

        {

                *addr = new_val;

                ret = 1;

        }

        _unlock(&global_atomic_ops_debug_mutex);

        return ret;

}

#endif /* __CATOMICOPSDEBUG_H */