Backports of C++ language features for use with C++11 compilers. More...

Namespaces
namespace	impl
	Provision of tuple expansion to arguments.

namespace	internal

namespace	tbb

namespace	thread_pool

namespace	Threading

Classes
struct	JoinFunction

struct	JoinFunction< void, JoinArg >

struct	JoinFunction< void, void >

class	PackagedTask
	The task class is supplied to thread_pool. More...

struct	ScopeDestructor

class	Task
	The task class is supplied to thread_pool. More...

class	Task< RetT, void >
	The task class is supplied to thread_pool. More...

class	Task< void, void >
	The task class is supplied to thread_pool.

class	TaskFuture
	The task class is supplied to thread_pool. More...

class	TaskGroup

class	TaskManager

class	TaskRunManager

class	TaskSubQueue

class	TemplateAutoLock

class	ThreadData

class	ThreadPool

class	UserTaskQueue

class	VTask
	VTask is the abstract class stored in thread_pool. More...

class	VUserTaskQueue

Typedefs
using	AutoLock = TemplateAutoLock<Mutex>

using	RecursiveAutoLock = TemplateAutoLock<RecursiveMutex>

template<typename T>
using	decay_t = typename std::decay<T>::type

template<bool B, typename T = void>
using	enable_if_t = typename std::enable_if<B, T>::type

using	tbb_global_control_t = tbb::global_control

using	tbb_task_group_t = tbb::task_group

using	tbb_task_arena_t = tbb::task_arena

Functions
template<typename... Args>
void	ConsumeParameters (Args &&...)

template<typename Tp>
Tp	GetEnv (const std::string &env_id, Tp _default=Tp())

template<>
bool	GetEnv (const std::string &env_id, bool _default)

Pid_t	GetPidId ()

unsigned	GetNumberOfPhysicalCpus ()

unsigned	GetNumberOfCores ()

int	GetThreadId ()

void	SetThreadId (int aNewValue)

bool	SetPinAffinity (int idx)

bool	SetThreadPriority (int _v)

bool	SetPinAffinity (int idx, NativeThread &_t)

bool	SetThreadPriority (int _v, NativeThread &_t)

Variables
template<typename Tp, typename Arg, intmax_t MaxDepth>
int	TaskGroup< Tp, Arg, MaxDepth >::f_verbose = 0

Detailed Description

Backports of C++ language features for use with C++11 compilers.

Class Description:

This class provides a mechanism to create a mutex and locks/unlocks it. Can be used by applications to implement in a portable way a mutexing logic. Usage Example:

 #include "Threading.hh"
 #include "AutoLock.hh"

 /// defined somewhere -- static so all threads see the same mutex
 static Mutex aMutex;

 /// somewhere else:
 /// The AutoLock instance will automatically unlock the mutex when it
 /// goes out of scope. One typically defines the scope within { } if
 /// there is thread-safe code following the auto-lock

 {
     AutoLock l(&aMutex);
     ProtectedCode();
 }

 UnprotectedCode();

 /// When ProtectedCode() is calling a function that also tries to lock
 /// a normal AutoLock + Mutex will "deadlock". In other words, the
 /// the mutex in the ProtectedCode() function will wait forever to
 /// acquire the lock that is being held by the function that called
 /// ProtectedCode(). In this situation, use a RecursiveAutoLock +
 /// RecursiveMutex, e.g.

 /// defined somewhere -- static so all threads see the same mutex
 static RecursiveMutex aRecursiveMutex;

 /// this function is sometimes called directly and sometimes called
 /// from SomeFunction_B(), which also locks the mutex
 void SomeFunction_A()
 {
     /// when called from SomeFunction_B(), a Mutex + AutoLock will
     /// deadlock
     RecursiveAutoLock l(&aRecursiveMutex);
     /// do something
 }

 void SomeFunction_B()
 {

     {
         RecursiveAutoLock l(&aRecursiveMutex);
         SomeFunction_A();
     }

     UnprotectedCode();
 }

Author: Andrea Dotti (15 Feb 2013): First Implementation

Update: Jonathan Madsen (9 Feb 2018): Replaced custom implementation with inheritance from C++11 unique_lock, which inherits the following member functions:

unique_lock(unique_lock&& other) noexcept;
explicit unique_lock(mutex_type& m);
unique_lock(mutex_type& m, std::defer_lock_t t) noexcept;
unique_lock(mutex_type& m, std::try_to_lock_t t);
unique_lock(mutex_type& m, std::adopt_lock_t t);
template <typename Rep, typename Period> unique_lock(mutex_type& m, const std::chrono::duration<Rep,Period>& timeout_duration);
template<typename Clock, typename Duration> unique_lock(mutex_type& m, const std::chrono::time_point<Clock,Duration>& timeout_time);
void lock();
void unlock();
bool try_lock();
template <typename Rep, typename Period> bool try_lock_for(const std::chrono::duration<Rep,Period>&);
template <typename Rep, typename Period> bool try_lock_until(const std::chrono::time_point<Clock,Duration>&);
void swap(unique_lock& other) noexcept;
mutex_type* release() noexcept;
mutex_type* mutex() const noexcept;
bool owns_lock() const noexcept;
explicit operator bool() const noexcept;
unique_lock& operator=(unique_lock&& other);

Note that AutoLock is defined also for a sequential Tasking build but below regarding implementation (also found in Threading.hh)

     NOTE ON Tasking SERIAL BUILDS AND MUTEX/UNIQUE_LOCK
     ==================================================

Mutex and RecursiveMutex are always C++11 std::mutex types however, in serial mode, using MUTEXLOCK and MUTEXUNLOCK on these types has no effect – i.e. the mutexes are not actually locked or unlocked

Additionally, when a Mutex or RecursiveMutex is used with AutoLock and RecursiveAutoLock, respectively, these classes also suppressing the locking and unlocking of the mutex. Regardless of the build type, AutoLock and RecursiveAutoLock inherit from std::unique_lock<std::mutex> and std::unique_lock<std::recursive_mutex>, respectively. This means that in situations (such as is needed by the analysis category), the AutoLock and RecursiveAutoLock can be passed to functions requesting a std::unique_lock. Within these functions, since std::unique_lock member functions are not virtual, they will not retain the dummy locking and unlocking behavior --> An example of this behavior can be found below

Jonathan R. Madsen (February 21, 2018)

Typedef Documentation

◆ AutoLock

using PTL::AutoLock = TemplateAutoLock<Mutex>

Definition at line 479 of file AutoLock.hh.

◆ decay_t

template<typename T>

using PTL::decay_t = typename std::decay<T>::type

Definition at line 35 of file CxxBackports.hh.

◆ enable_if_t

template<bool B, typename T = void>

using PTL::enable_if_t = typename std::enable_if<B, T>::type

Definition at line 38 of file CxxBackports.hh.

◆ RecursiveAutoLock

using PTL::RecursiveAutoLock = TemplateAutoLock<RecursiveMutex>

Definition at line 480 of file AutoLock.hh.

◆ tbb_global_control_t

using PTL::tbb_global_control_t = tbb::global_control

Definition at line 123 of file ThreadData.hh.

◆ tbb_task_arena_t

using PTL::tbb_task_arena_t = tbb::task_arena

Definition at line 125 of file ThreadData.hh.

◆ tbb_task_group_t

using PTL::tbb_task_group_t = tbb::task_group

Definition at line 124 of file ThreadData.hh.

Function Documentation

◆ ConsumeParameters()

template<typename... Args>

void PTL::ConsumeParameters ( Args && ... )

Definition at line 29 of file ConsumeParameters.hh.

30{}

Referenced by SetPinAffinity(), SetPinAffinity(), SetThreadPriority(), and SetThreadPriority().

◆ GetEnv() [1/2]

template<>

bool PTL::GetEnv	(	const std::string &	env_id,
		bool	_default )

inline

Definition at line 68 of file GetEnv.hh.

{
    char* env_var = std::getenv(env_id.c_str());
    if(env_var)
    {
        std::string var = std::string(env_var);
        bool        val = true;
        if(var.find_first_not_of("0123456789") == std::string::npos)
            val = (bool) atoi(var.c_str());
        else
        {
            for(auto& itr : var)
                itr = tolower(itr);
            if(var == "off" || var == "false")
                val = false;
        }
        return val;
    }
 
    // return default if not specified in environment
    return _default;
}

◆ GetEnv() [2/2]

template<typename Tp>

Tp PTL::GetEnv	(	const std::string &	env_id,
		Tp	_default = Tp() )

Definition at line 47 of file GetEnv.hh.

{
    char* env_var = std::getenv(env_id.c_str());
    if(env_var)
    {
        std::string        str_var = std::string(env_var);
        std::istringstream iss(str_var);
        Tp                 var = Tp();
        iss >> var;
        return var;
    }
 
    // return default if not specified in environment
    return _default;
}

◆ GetNumberOfCores()

unsigned PTL::GetNumberOfCores ( )

Definition at line 67 of file Threading.cc.

{
    return std::thread::hardware_concurrency();
}

Referenced by PTL::ThreadPool::execute_on_all_threads(), PTL::ThreadPool::execute_on_specific_threads(), and GetNumberOfPhysicalCpus().

◆ GetNumberOfPhysicalCpus()

unsigned PTL::GetNumberOfPhysicalCpus ( )

Definition at line 75 of file Threading.cc.

{
#if defined(PTL_MACOS)
    int    count;
    size_t count_len = sizeof(count);
    sysctlbyname("hw.physicalcpu", &count, &count_len, nullptr, 0);
    return static_cast<unsigned>(count);
#elif defined(PTL_LINUX)
    unsigned      core_id_count = 0;
    std::ifstream ifs("/proc/cpuinfo");
    if(ifs)
    {
        std::set<std::string> core_ids;
        while(true)
        {
            std::string line = {};
            getline(ifs, line);
            if(!ifs.good())
                break;
            if(line.find("core id") != std::string::npos)
            {
                for(std::string itr : { "core id", ":", " ", "\t" })
                {
                    static auto _npos = std::string::npos;
                    auto        _pos  = _npos;
                    while((_pos = line.find(itr)) != _npos)
                        line = line.replace(_pos, itr.length(), "");
                }
                core_ids.insert(std::move(line));
            }
        }
        core_id_count = static_cast<unsigned>(core_ids.size());
        if(core_id_count > 0)
            return core_id_count;
    }
    return GetNumberOfCores();
#else
    return GetNumberOfCores();
#endif
}

◆ GetPidId()

Pid_t PTL::GetPidId ( )

Definition at line 58 of file Threading.cc.

{
    // In multithreaded mode return Thread ID
    return std::this_thread::get_id();
}

◆ GetThreadId()

int PTL::GetThreadId ( )

Definition at line 125 of file Threading.cc.

{
    return ThreadID;
}

◆ SetPinAffinity() [1/2]

bool PTL::SetPinAffinity ( int idx )

Definition at line 133 of file Threading.cc.

{
#if defined(__linux__) || defined(_AIX)
    cpu_set_t _cpu_set{};
    CPU_ZERO(&_cpu_set);
    if(_cpu >= 0)
        CPU_SET(_cpu, &_cpu_set);
    return (pthread_setaffinity_np(pthread_self(), sizeof(cpu_set_t), &_cpu_set) == 0);
#else  // Not available for Mac, WIN,...
    ConsumeParameters(_cpu);
    return true;
#endif
}

Referenced by PTL::ThreadPool::set_affinity().

◆ SetPinAffinity() [2/2]

bool PTL::SetPinAffinity	(	int	idx,
		NativeThread &	_t )

Definition at line 163 of file Threading.cc.

{
#if defined(__linux__) || defined(_AIX)
    cpu_set_t _cpu_set{};
    CPU_ZERO(&_cpu_set);
    CPU_SET(_cpu, &_cpu_set);
    return (pthread_setaffinity_np(static_cast<pthread_t>(_t), sizeof(cpu_set_t),
                                   &_cpu_set) == 0);
#else  // Not available for Mac, WIN,...
    ConsumeParameters(_cpu, _t);
    return true;
#endif
}

◆ SetThreadId()

void PTL::SetThreadId ( int aNewValue )

Definition at line 119 of file Threading.cc.

{
    ThreadID = value;
}

Referenced by PTL::ThreadPool::add_thread_id().

◆ SetThreadPriority() [1/2]

bool PTL::SetThreadPriority ( int _v )

Definition at line 150 of file Threading.cc.

{
#if defined(__linux__) || defined(_AIX)
    return (pthread_setschedprio(pthread_self(), _prio) == 0);
#else  // Not available for Mac, WIN,...
    ConsumeParameters(_prio);
    return true;
#endif
}

Referenced by PTL::ThreadPool::set_priority().

◆ SetThreadPriority() [2/2]

bool PTL::SetThreadPriority	(	int	_v,
		NativeThread &	_t )

Definition at line 180 of file Threading.cc.

{
#if defined(__linux__) || defined(_AIX)
    return (pthread_setschedprio(static_cast<pthread_t>(_t), _prio) == 0);
#else
    ConsumeParameters(_prio, _t);
    return true;
#endif
}

Variable Documentation

◆ TaskGroup< Tp, Arg, MaxDepth >::f_verbose

template<typename Tp, typename Arg, intmax_t MaxDepth>

int PTL::TaskGroup< Tp, Arg, MaxDepth >::f_verbose = 0

Definition at line 737 of file TaskGroup.hh.

Namespaces

Classes

Typedefs

Functions

Variables