thread_support

#include <compatibility/hpx/util/thread_specific_ptr.hpp>

#include <compatibility/hpx/util/set_thread_name.hpp>

#include <compatibility/hpx/util/atomic_count.hpp>

#include <compatibility/hpx/util/unlock_guard.hpp>

#include <compatibility/hpx/util/assert_owns_lock.hpp>

#include <hpx/thread_support/thread_specific_ptr.hpp>

Defines

HPX_EXPORT_THREAD_SPECIFIC_PTR
namespace hpx
namespace util
template <typename T, typename Tag>
struct thread_specific_ptr

Public Types

typedef boost::thread_specific_ptr<T>::element_type element_type

Public Functions

T *get() const
T *operator->() const
T &operator*() const
void reset(T *new_value = nullptr)

Private Static Attributes

boost::thread_specific_ptr<T> ptr_

#include <hpx/thread_support/set_thread_name.hpp>

namespace hpx
namespace util

Functions

void set_thread_name(char const *threadName)

#include <hpx/thread_support/atomic_count.hpp>

namespace hpx
namespace util
class atomic_count

Public Functions

HPX_NON_COPYABLE(atomic_count)
atomic_count(long value)
atomic_count &operator=(long value)
long operator++()
long operator--()
atomic_count &operator+=(long n)
atomic_count &operator-=(long n)
operator long() const

Private Members

std::atomic<long> value_

#include <hpx/thread_support/unlock_guard.hpp>

namespace hpx
namespace util
template <typename Mutex>
class unlock_guard

Public Types

template<>
using mutex_type = Mutex

Public Functions

HPX_NON_COPYABLE(unlock_guard)
unlock_guard(Mutex &m)
~unlock_guard()

Private Members

Mutex &m_

#include <hpx/thread_support/assert_owns_lock.hpp>

Defines

HPX_ASSERT_OWNS_LOCK(l)