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&) {}
};
 
 
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 <atomic>
#include <mutex>
#include <thread>
 
 
namespace AthContainers_detail {
 
 
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