/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/AthContainers/AthContainers/tools/threading.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
// $Id$
#ifndef ATHCONTAINERS_THREADING_H
#define ATHCONTAINERS_THREADING_H


#if defined(XAOD_STANDALONE) || defined(__GCCXML__)
# ifndef ATHCONTAINERS_NO_THREADS
#  define ATHCONTAINERS_NO_THREADS
# endif
#endif


#ifdef ATHCONTAINERS_NO_THREADS


namespace AthContainers_detail {


class mutex {};


template <class LOCKABLE>
class lock_guard
{
public:
  lock_guard() {}
  lock_guard(LOCKABLE&) {}
};


class upgrade_mutex
{
public:
  void lock() {}
  void unlock() {}
  void lock_shared() {}
  void unlock_shared() {}
  void lock_upgrade() {}
  void unlock_upgrade() {}
  void unlock_upgrade_and_lock() {}
private:
  // Real upgrade_mutex is not assignable.  Need this for proper
  // dictionary generation.
  upgrade_mutex& operator= (const upgrade_mutex&);
};


template <class T>
class thread_specific_ptr
{
public:
  thread_specific_ptr() : m_ptr(0) {}
  ~thread_specific_ptr() { delete m_ptr; }
  T* get() const { return m_ptr; }
  T* operator->() const { return m_ptr; }
  T& operator*() const { return *m_ptr; }
  void reset (T* new_value=0) { delete m_ptr; m_ptr = new_value; }
  T* release() { T* ret = m_ptr; m_ptr = 0; return ret; }

private:
  T* m_ptr;
};


inline void fence_acq_rel() {}
inline void fence_seq_cst() {}


} // namespace AthContainers_detail


#else  // not ATHCONTAINERS_NO_THREADS

//the shared_mutex include generates annoying unused_variable warnings during compilations... silence this in athanalysisbase
#ifdef XAOD_ANALYSIS
#ifndef BOOST_SYSTEM_NO_DEPRECATED
#define BOOST_SYSTEM_NO_DEPRECATED 1
#endif
#endif

#include "boost/thread/shared_mutex.hpp"
#include "boost/thread/tss.hpp"
#if __cplusplus > 201100
# include <atomic>
# include <mutex>
# include <thread>
namespace SG_STD_OR_BOOST = std;
#else
# include "boost/atomic.hpp"
# include "boost/thread/mutex.hpp"
# include "boost/thread/thread.hpp"
namespace SG_STD_OR_BOOST = boost;
#endif


namespace AthContainers_detail {


// Take these from boost.  (Boost extensions not in C++.)
using boost::upgrade_mutex;
using boost::thread_specific_ptr;

// Other mutex/lock types come from either boost or std.
using SG_STD_OR_BOOST::mutex;
using SG_STD_OR_BOOST::lock_guard;
using SG_STD_OR_BOOST::thread;


void fence_acq_rel();


void fence_seq_cst();


} // namespace AthContainers_detail


#endif // not ATHCONTAINERS_NO_THREADS



namespace AthContainers_detail {


template <typename LOCKABLE>
class strict_shared_lock 
{
public:
  typedef LOCKABLE lockable_type;


  explicit strict_shared_lock(lockable_type& obj);


  explicit strict_shared_lock(const lockable_type& obj);
  

  ~strict_shared_lock();


private:
  // Disallow these.
  strict_shared_lock();
  strict_shared_lock(strict_shared_lock const&);
  strict_shared_lock& operator=(strict_shared_lock const&);


private:
  lockable_type& m_obj;
};


template <class LOCKABLE>
class upgrading_lock
{
public:
  typedef LOCKABLE lockable_type;


  explicit upgrading_lock (lockable_type& obj);


  ~upgrading_lock();


  void upgrade();


private:
  // Disallow these.
  upgrading_lock();
  upgrading_lock(upgrading_lock const&);
  upgrading_lock& operator=(upgrading_lock const&);


private:
  lockable_type& m_obj;

  bool m_exclusive;
};


} // namespace AthContainers_detail


#include "AthContainers/tools/threading.icc"


#endif // not ATHCONTAINERS_THREADING_H

---