include/boost/container/detail/mutex.hpp - RealtimeRoboticsGroup/test - Gitiles

 //////////////////////////////////////////////////////////////////////////////
 //
 // (C) Copyright Stephen Cleary 2000
 // (C) Copyright Ion Gaztanaga  2015-2017.
 //
 // Distributed under the Boost
 // Software License, Version 1.0. (See accompanying file
 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 // See http://www.boost.org/libs/container for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////

 #ifndef BOOST_CONTAINER_MUTEX_HPP
 #define BOOST_CONTAINER_MUTEX_HPP

 #ifndef BOOST_CONFIG_HPP
 #  include <boost/config.hpp>
 #endif

 #if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
 #endif

 //#define BOOST_CONTAINER_NO_MT
 //#define BOOST_CONTAINER_NO_SPINLOCKS

 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>

 // Extremely Light-Weight wrapper classes for OS thread synchronization

 #define BOOST_MUTEX_HELPER_NONE         0
 #define BOOST_MUTEX_HELPER_WIN32        1
 #define BOOST_MUTEX_HELPER_PTHREAD      2
 #define BOOST_MUTEX_HELPER_SPINLOCKS    3

 #if !defined(BOOST_HAS_THREADS) && !defined(BOOST_NO_MT)
 # define BOOST_NO_MT
 #endif

 #if defined(BOOST_NO_MT) || defined(BOOST_CONTAINER_NO_MT)
   // No multithreading -> make locks into no-ops
   #define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_NONE
 #else
    //Taken from dlmalloc
    #if !defined(BOOST_CONTAINER_NO_SPINLOCKS) &&                           \
          ((defined(__GNUC__) &&                                            \
          ((__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) ||      \
          defined(__i386__) || defined(__x86_64__))) ||                     \
       (defined(_MSC_VER) && _MSC_VER>=1310))
       #define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_SPINLOCKS
    #endif

    #if defined(BOOST_WINDOWS)
       #include <windows.h>
       #ifndef BOOST_MUTEX_HELPER
          #define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_WIN32
       #endif
    #elif defined(BOOST_HAS_UNISTD_H)
       #include <unistd.h>
       #if !defined(BOOST_MUTEX_HELPER) && (defined(_POSIX_THREADS) || defined(BOOST_HAS_PTHREADS))
          #define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_PTHREAD
       #endif
    #endif
 #endif

 #ifndef BOOST_MUTEX_HELPER
   #error Unable to determine platform mutex type; #define BOOST_NO_MT to assume single-threaded
 #endif

 #if BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_NONE
    //...
 #elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_SPINLOCKS
    #if defined(_MSC_VER)
       #ifndef _M_AMD64
          /* These are already defined on AMD64 builds */
          #ifdef __cplusplus
             extern "C" {
          #endif /* __cplusplus */
             long __cdecl _InterlockedCompareExchange(long volatile *Dest, long Exchange, long Comp);
             long __cdecl _InterlockedExchange(long volatile *Target, long Value);
          #ifdef __cplusplus
             }
          #endif /* __cplusplus */
       #endif /* _M_AMD64 */
       #pragma intrinsic (_InterlockedCompareExchange)
       #pragma intrinsic (_InterlockedExchange)
       #define interlockedcompareexchange _InterlockedCompareExchange
       #define interlockedexchange        _InterlockedExchange
    #elif defined(WIN32) && defined(__GNUC__)
       #define interlockedcompareexchange(a, b, c) __sync_val_compare_and_swap(a, c, b)
       #define interlockedexchange                 __sync_lock_test_and_set
    #endif /* Win32 */

    /* First, define CAS_LOCK and CLEAR_LOCK on ints */
    /* Note CAS_LOCK defined to return 0 on success */

    #if defined(__GNUC__)&& (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1))
       #define BOOST_CONTAINER_CAS_LOCK(sl)     __sync_lock_test_and_set(sl, 1)
       #define BOOST_CONTAINER_CLEAR_LOCK(sl)   __sync_lock_release(sl)

    #elif (defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)))
       /* Custom spin locks for older gcc on x86 */
       static inline int boost_container_x86_cas_lock(int *sl) {
          int ret;
          int val = 1;
          int cmp = 0;
          __asm__ __volatile__  ("lock; cmpxchgl %1, %2"
                                  : "=a" (ret)
                                  : "r" (val), "m" (*(sl)), "0"(cmp)
                                  : "memory", "cc");
          return ret;
       }

       static inline void boost_container_x86_clear_lock(int* sl) {
          assert(*sl != 0);
          int prev = 0;
          int ret;
          __asm__ __volatile__ ("lock; xchgl %0, %1"
                                  : "=r" (ret)
                                  : "m" (*(sl)), "0"(prev)
                                  : "memory");
       }

       #define BOOST_CONTAINER_CAS_LOCK(sl)     boost_container_x86_cas_lock(sl)
       #define BOOST_CONTAINER_CLEAR_LOCK(sl)   boost_container_x86_clear_lock(sl)

    #else /* Win32 MSC */
       #define BOOST_CONTAINER_CAS_LOCK(sl)     interlockedexchange((long volatile*)sl, (long)1)
       #define BOOST_CONTAINER_CLEAR_LOCK(sl)   interlockedexchange((long volatile*)sl, (long)0)
    #endif

    /* How to yield for a spin lock */
    #define SPINS_PER_YIELD       63
    #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
       #define SLEEP_EX_DURATION     50 /* delay for yield/sleep */
       #define SPIN_LOCK_YIELD  SleepEx(SLEEP_EX_DURATION, FALSE)
    #elif defined (__SVR4) && defined (__sun) /* solaris */
       #include <thread.h>
       #define SPIN_LOCK_YIELD   thr_yield();
    #elif !defined(LACKS_SCHED_H)
       #include <sched.h>
       #define SPIN_LOCK_YIELD   sched_yield();
    #else
       #define SPIN_LOCK_YIELD
    #endif /* ... yield ... */

    #define BOOST_CONTAINER_SPINS_PER_YIELD       63
    inline int boost_interprocess_spin_acquire_lock(int *sl) {
       int spins = 0;
       while (*(volatile int *)sl != 0 ||
          BOOST_CONTAINER_CAS_LOCK(sl)) {
          if ((++spins & BOOST_CONTAINER_SPINS_PER_YIELD) == 0) {
             SPIN_LOCK_YIELD;
          }
       }
       return 0;
    }
    #define BOOST_CONTAINER_MLOCK_T               int
    #define BOOST_CONTAINER_TRY_LOCK(sl)          !BOOST_CONTAINER_CAS_LOCK(sl)
    #define BOOST_CONTAINER_RELEASE_LOCK(sl)      BOOST_CONTAINER_CLEAR_LOCK(sl)
    #define BOOST_CONTAINER_ACQUIRE_LOCK(sl)      (BOOST_CONTAINER_CAS_LOCK(sl)? boost_interprocess_spin_acquire_lock(sl) : 0)
    #define BOOST_MOVE_INITIAL_LOCK(sl)      (*sl = 0)
    #define BOOST_CONTAINER_DESTROY_LOCK(sl)      (0)
 #elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_WIN32
    //
 #elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_PTHREAD
    #include <pthread.h>
 #endif

 namespace boost {
 namespace container {
 namespace dtl {

 #if BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_NONE
    class null_mutex
    {
    private:
       null_mutex(const null_mutex &);
       void operator=(const null_mutex &);

    public:
       null_mutex() { }

       static void lock() { }
       static void unlock() { }
    };

   typedef null_mutex default_mutex;
 #elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_SPINLOCKS

    class spin_mutex
    {
    private:
       BOOST_CONTAINER_MLOCK_T sl;
       spin_mutex(const spin_mutex &);
       void operator=(const spin_mutex &);

    public:
       spin_mutex() { BOOST_MOVE_INITIAL_LOCK(&sl); }

       void lock() { BOOST_CONTAINER_ACQUIRE_LOCK(&sl); }
       void unlock() { BOOST_CONTAINER_RELEASE_LOCK(&sl); }
    };
   typedef spin_mutex default_mutex;
 #elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_WIN32
    class mutex
    {
    private:
       CRITICAL_SECTION mtx;

       mutex(const mutex &);
       void operator=(const mutex &);

    public:
       mutex()
       { InitializeCriticalSection(&mtx); }

       ~mutex()
       { DeleteCriticalSection(&mtx); }

       void lock()
       { EnterCriticalSection(&mtx); }

       void unlock()
       { LeaveCriticalSection(&mtx); }
    };

   typedef mutex default_mutex;
 #elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_PTHREAD
    class mutex
    {
    private:
       pthread_mutex_t mtx;

       mutex(const mutex &);
       void operator=(const mutex &);

    public:
       mutex()
       { pthread_mutex_init(&mtx, 0); }

       ~mutex()
       { pthread_mutex_destroy(&mtx); }

       void lock()
       { pthread_mutex_lock(&mtx); }

       void unlock()
       { pthread_mutex_unlock(&mtx); }
    };

   typedef mutex default_mutex;
 #endif

 template<class Mutex>
 class scoped_lock
 {
    public:
    scoped_lock(Mutex &m)
       :  m_(m)
    { m_.lock(); }
    ~scoped_lock()
    { m_.unlock(); }

    private:
    Mutex &m_;
 };

 } // namespace dtl
 } // namespace container
 } // namespace boost

 #undef BOOST_MUTEX_HELPER_WIN32
 #undef BOOST_MUTEX_HELPER_PTHREAD
 #undef BOOST_MUTEX_HELPER_NONE
 #undef BOOST_MUTEX_HELPER
 #undef BOOST_MUTEX_HELPER_SPINLOCKS

 #include <boost/container/detail/config_end.hpp>

 #endif
	//////////////////////////////////////////////////////////////////////////////
	//
	// (C) Copyright Stephen Cleary 2000
	// (C) Copyright Ion Gaztanaga 2015-2017.
	//
	// Distributed under the Boost
	// Software License, Version 1.0. (See accompanying file
	// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
	//
	// See http://www.boost.org/libs/container for documentation.
	//
	//////////////////////////////////////////////////////////////////////////////

	#ifndef BOOST_CONTAINER_MUTEX_HPP
	#define BOOST_CONTAINER_MUTEX_HPP

	#ifndef BOOST_CONFIG_HPP
	# include <boost/config.hpp>
	#endif

	#if defined(BOOST_HAS_PRAGMA_ONCE)
	# pragma once
	#endif

	//#define BOOST_CONTAINER_NO_MT
	//#define BOOST_CONTAINER_NO_SPINLOCKS

	#include <boost/container/detail/config_begin.hpp>
	#include <boost/container/detail/workaround.hpp>

	// Extremely Light-Weight wrapper classes for OS thread synchronization

	#define BOOST_MUTEX_HELPER_NONE 0
	#define BOOST_MUTEX_HELPER_WIN32 1
	#define BOOST_MUTEX_HELPER_PTHREAD 2
	#define BOOST_MUTEX_HELPER_SPINLOCKS 3

	#if !defined(BOOST_HAS_THREADS) && !defined(BOOST_NO_MT)
	# define BOOST_NO_MT
	#endif

	#if defined(BOOST_NO_MT) \|\| defined(BOOST_CONTAINER_NO_MT)
	// No multithreading -> make locks into no-ops
	#define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_NONE
	#else
	//Taken from dlmalloc
	#if !defined(BOOST_CONTAINER_NO_SPINLOCKS) && \
	((defined(__GNUC__) && \
	((__GNUC__ > 4 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)) \|\| \
	defined(__i386__) \|\| defined(__x86_64__))) \|\| \
	(defined(_MSC_VER) && _MSC_VER>=1310))
	#define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_SPINLOCKS
	#endif

	#if defined(BOOST_WINDOWS)
	#include <windows.h>
	#ifndef BOOST_MUTEX_HELPER
	#define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_WIN32
	#endif
	#elif defined(BOOST_HAS_UNISTD_H)
	#include <unistd.h>
	#if !defined(BOOST_MUTEX_HELPER) && (defined(_POSIX_THREADS) \|\| defined(BOOST_HAS_PTHREADS))
	#define BOOST_MUTEX_HELPER BOOST_MUTEX_HELPER_PTHREAD
	#endif
	#endif
	#endif

	#ifndef BOOST_MUTEX_HELPER
	#error Unable to determine platform mutex type; #define BOOST_NO_MT to assume single-threaded
	#endif

	#if BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_NONE
	//...
	#elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_SPINLOCKS
	#if defined(_MSC_VER)
	#ifndef _M_AMD64
	/* These are already defined on AMD64 builds */
	#ifdef __cplusplus
	extern "C" {
	#endif /* __cplusplus */
	long __cdecl _InterlockedCompareExchange(long volatile *Dest, long Exchange, long Comp);
	long __cdecl _InterlockedExchange(long volatile *Target, long Value);
	#ifdef __cplusplus
	}
	#endif /* __cplusplus */
	#endif /* _M_AMD64 */
	#pragma intrinsic (_InterlockedCompareExchange)
	#pragma intrinsic (_InterlockedExchange)
	#define interlockedcompareexchange _InterlockedCompareExchange
	#define interlockedexchange _InterlockedExchange
	#elif defined(WIN32) && defined(__GNUC__)
	#define interlockedcompareexchange(a, b, c) __sync_val_compare_and_swap(a, c, b)
	#define interlockedexchange __sync_lock_test_and_set
	#endif /* Win32 */

	/* First, define CAS_LOCK and CLEAR_LOCK on ints */
	/* Note CAS_LOCK defined to return 0 on success */

	#if defined(__GNUC__)&& (__GNUC__ > 4 \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 1))
	#define BOOST_CONTAINER_CAS_LOCK(sl) __sync_lock_test_and_set(sl, 1)
	#define BOOST_CONTAINER_CLEAR_LOCK(sl) __sync_lock_release(sl)

	#elif (defined(__GNUC__) && (defined(__i386__) \|\| defined(__x86_64__)))
	/* Custom spin locks for older gcc on x86 */
	static inline int boost_container_x86_cas_lock(int *sl) {
	int ret;
	int val = 1;
	int cmp = 0;
	__asm__ __volatile__ ("lock; cmpxchgl %1, %2"
	: "=a" (ret)
	: "r" (val), "m" (*(sl)), "0"(cmp)
	: "memory", "cc");
	return ret;
	}

	static inline void boost_container_x86_clear_lock(int* sl) {
	assert(*sl != 0);
	int prev = 0;
	int ret;
	__asm__ __volatile__ ("lock; xchgl %0, %1"
	: "=r" (ret)
	: "m" (*(sl)), "0"(prev)
	: "memory");
	}

	#define BOOST_CONTAINER_CAS_LOCK(sl) boost_container_x86_cas_lock(sl)
	#define BOOST_CONTAINER_CLEAR_LOCK(sl) boost_container_x86_clear_lock(sl)

	#else /* Win32 MSC */
	#define BOOST_CONTAINER_CAS_LOCK(sl) interlockedexchange((long volatile*)sl, (long)1)
	#define BOOST_CONTAINER_CLEAR_LOCK(sl) interlockedexchange((long volatile*)sl, (long)0)
	#endif

	/* How to yield for a spin lock */
	#define SPINS_PER_YIELD 63
	#if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(WIN32)
	#define SLEEP_EX_DURATION 50 /* delay for yield/sleep */
	#define SPIN_LOCK_YIELD SleepEx(SLEEP_EX_DURATION, FALSE)
	#elif defined (__SVR4) && defined (__sun) /* solaris */
	#include <thread.h>
	#define SPIN_LOCK_YIELD thr_yield();
	#elif !defined(LACKS_SCHED_H)
	#include <sched.h>
	#define SPIN_LOCK_YIELD sched_yield();
	#else
	#define SPIN_LOCK_YIELD
	#endif /* ... yield ... */

	#define BOOST_CONTAINER_SPINS_PER_YIELD 63
	inline int boost_interprocess_spin_acquire_lock(int *sl) {
	int spins = 0;
	while ((volatile int )sl != 0 \|\|
	BOOST_CONTAINER_CAS_LOCK(sl)) {
	if ((++spins & BOOST_CONTAINER_SPINS_PER_YIELD) == 0) {
	SPIN_LOCK_YIELD;
	}
	}
	return 0;
	}
	#define BOOST_CONTAINER_MLOCK_T int
	#define BOOST_CONTAINER_TRY_LOCK(sl) !BOOST_CONTAINER_CAS_LOCK(sl)
	#define BOOST_CONTAINER_RELEASE_LOCK(sl) BOOST_CONTAINER_CLEAR_LOCK(sl)
	#define BOOST_CONTAINER_ACQUIRE_LOCK(sl) (BOOST_CONTAINER_CAS_LOCK(sl)? boost_interprocess_spin_acquire_lock(sl) : 0)
	#define BOOST_MOVE_INITIAL_LOCK(sl) (*sl = 0)
	#define BOOST_CONTAINER_DESTROY_LOCK(sl) (0)
	#elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_WIN32
	//
	#elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_PTHREAD
	#include <pthread.h>
	#endif

	namespace boost {
	namespace container {
	namespace dtl {

	#if BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_NONE
	class null_mutex
	{
	private:
	null_mutex(const null_mutex &);
	void operator=(const null_mutex &);

	public:
	null_mutex() { }

	static void lock() { }
	static void unlock() { }
	};

	typedef null_mutex default_mutex;
	#elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_SPINLOCKS

	class spin_mutex
	{
	private:
	BOOST_CONTAINER_MLOCK_T sl;
	spin_mutex(const spin_mutex &);
	void operator=(const spin_mutex &);

	public:
	spin_mutex() { BOOST_MOVE_INITIAL_LOCK(&sl); }

	void lock() { BOOST_CONTAINER_ACQUIRE_LOCK(&sl); }
	void unlock() { BOOST_CONTAINER_RELEASE_LOCK(&sl); }
	};
	typedef spin_mutex default_mutex;
	#elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_WIN32
	class mutex
	{
	private:
	CRITICAL_SECTION mtx;

	mutex(const mutex &);
	void operator=(const mutex &);

	public:
	mutex()
	{ InitializeCriticalSection(&mtx); }

	~mutex()
	{ DeleteCriticalSection(&mtx); }

	void lock()
	{ EnterCriticalSection(&mtx); }

	void unlock()
	{ LeaveCriticalSection(&mtx); }
	};

	typedef mutex default_mutex;
	#elif BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_PTHREAD
	class mutex
	{
	private:
	pthread_mutex_t mtx;

	mutex(const mutex &);
	void operator=(const mutex &);

	public:
	mutex()
	{ pthread_mutex_init(&mtx, 0); }

	~mutex()
	{ pthread_mutex_destroy(&mtx); }

	void lock()
	{ pthread_mutex_lock(&mtx); }

	void unlock()
	{ pthread_mutex_unlock(&mtx); }
	};

	typedef mutex default_mutex;
	#endif

	template<class Mutex>
	class scoped_lock
	{
	public:
	scoped_lock(Mutex &m)
	: m_(m)
	{ m_.lock(); }
	~scoped_lock()
	{ m_.unlock(); }

	private:
	Mutex &m_;
	};

	} // namespace dtl
	} // namespace container
	} // namespace boost

	#undef BOOST_MUTEX_HELPER_WIN32
	#undef BOOST_MUTEX_HELPER_PTHREAD
	#undef BOOST_MUTEX_HELPER_NONE
	#undef BOOST_MUTEX_HELPER
	#undef BOOST_MUTEX_HELPER_SPINLOCKS

	#include <boost/container/detail/config_end.hpp>

	#endif