threading.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATHCONTAINERS_THREADING_H
#define ATHCONTAINERS_THREADING_H
 
 
#ifdef ATHCONTAINERS_NO_THREADS
 
 
namespace AthContainers_detail {
 
 
class mutex {};
 
 
class recursive_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; }
  thread_specific_ptr (const thread_specific_ptr&) = delete;
  thread_specific_ptr& operator= (const thread_specific_ptr&) = delete;
  T* get() { return m_ptr; }
  T* operator->() { return m_ptr; }
  T& operator*() { return *m_ptr; }
  const T* get() const { return m_ptr; }
  const T* operator->() const { return m_ptr; }
  const 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() {}
 
 
template <class T>
class atomic
{
public:
  atomic() : m_val() {}
  operator T() const { return m_val; }
  atomic& operator= (const T& val) { m_val = val; return *this; }
 
private:
  T m_val;
};
 
 
} // 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"
 
 
#include <atomic>
#include <mutex>
#include <thread>
 
 
namespace AthContainers_detail {
 
 
// Take these from boost.  (Boost extensions not in C++.)
using boost::upgrade_mutex;
using boost::thread_specific_ptr;
 
using std::mutex;
using std::recursive_mutex;
using std::lock_guard;
using std::thread;
using std::atomic;
 
 
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