thread_parameter.h

Go to the documentation of this file.

#ifndef _THREAD_CLASS_HEADER_
#define _THREAD_CLASS_HEADER_
 
#include <thread>
#include <functional>
 
namespace A_UTILS_NS
{

#ifndef __STDCALL
#ifdef WIN32
#define __STDCALL    __stdcall
#else
#define __STDCALL
#endif
#endif

#ifndef __THREAD_RESULT
#ifdef WIN32
#define __THREAD_RESULT unsigned long
#else
#define __THREAD_RESULT void*
#endif
#endif
 
#ifdef _DEBUG
#define _DEBUG_NAME_SIZE    512
#endif

#ifdef WIN32
#define __THREADCALL __stdcall
#else
#define __THREADCALL
#endif

enum class tSchedulingClass: tUInt32
{
    Default = 0, 
    Normal = 1, 
    RealTime = 2, 
};
enum class tSchedulingClass: tUInt32 {…};

#define A_UTILS_THREAD_PRIORITY_LOWEST          0.0
#define A_UTILS_THREAD_PRIORITY_LOW             0.25
#define A_UTILS_THREAD_PRIORITY_NORMAL          0.5
#define A_UTILS_THREAD_PRIORITY_HIGH            0.625
#define A_UTILS_THREAD_PRIORITY_HIGHEST         0.75
#define A_UTILS_THREAD_PRIORITY_TIME_CRITICAL   1.0

typedef std::vector<bool> tCpuAffinityMask;

struct tSchedulingParameters
{
    tSchedulingParameters():
       eSchedulingClass(tSchedulingClass::Default),
       fPriority{0.5}
    {
    }
    tSchedulingParameters(): {…}

    tSchedulingParameters(tSchedulingClass eSchedulingClass, tFloat64 fPriority):
        eSchedulingClass(eSchedulingClass),
        fPriority{fPriority}
    {
    }
    tSchedulingParameters(tSchedulingClass eSchedulingClass, tFloat64 fPriority): {…}

    tSchedulingParameters(tSchedulingClass eSchedulingClass, tFloat64 fPriority,
                          const tCpuAffinityMask& oCpuAffinity):
        eSchedulingClass(eSchedulingClass),
        fPriority{fPriority},
        oCpuAffinity(oCpuAffinity)
    {
    }
    tSchedulingParameters(tSchedulingClass eSchedulingClass, tFloat64 fPriority, {…}

    tSchedulingParameters(const tSchedulingParameters&) = default;

    tSchedulingParameters(tSchedulingParameters&&) = default;

    inline bool operator==(const tSchedulingParameters& sOther) const
    {
        return (eSchedulingClass == sOther.eSchedulingClass) &&
               (fPriority == sOther.fPriority) &&
               (oCpuAffinity == sOther.oCpuAffinity);
    }
    inline bool operator==(const tSchedulingParameters& sOther) const {…}
 
    tSchedulingClass eSchedulingClass; 
    tFloat64 fPriority; 
    tCpuAffinityMask oCpuAffinity; 
};
struct tSchedulingParameters {…};

std::thread::native_handle_type get_native_handle_of_this_thread();

tResult set_priority(std::thread::native_handle_type oThreadHandle,
                     tSchedulingClass eSchedulingClass, tFloat64 fPriority);

tResult get_priority(std::thread::native_handle_type oThreadHandle,
                     tSchedulingClass& eSchedulingClass, tFloat64& fPriority);

tResult set_cpu_affinity(std::thread::native_handle_type oThreadHandle,
                         const tCpuAffinityMask& oCpuAffinity);

tResult get_cpu_affinity(std::thread::native_handle_type oThreadHandle,
                         tCpuAffinityMask& oCpuAffinity);

tResult set_scheduling(std::thread::native_handle_type oThreadHandle,
                       const tSchedulingParameters& sScheduling);

tResult get_scheduling(const std::thread::native_handle_type& oThreadHandle,
                       tSchedulingParameters& sScheduling);

template <typename Callable, typename ...Args>
void run_with_scheduling(tSchedulingParameters sScheduling, Callable&& pFunc, Args&&... args)
{
    set_scheduling(get_native_handle_of_this_thread(), sScheduling);
    pFunc(std::forward<Args>(args)...);
}
void run_with_scheduling(tSchedulingParameters sScheduling, Callable&& pFunc, Args&&... args) {…}

template <typename Callable, typename ...Args>
void run_with_checked_scheduling(tSchedulingParameters sScheduling, Callable&& pFunc, Args&&... args)
{
    if (IS_OK(set_scheduling(get_native_handle_of_this_thread(), sScheduling)))
    {
        pFunc(std::forward<Args>(args)...);
    }
}
void run_with_checked_scheduling(tSchedulingParameters sScheduling, Callable&& pFunc, Args&&... args) {…}

tResult create_thread_with_scheduling_impl(std::thread& oThread,
                                           const tSchedulingParameters& sScheduling,
                                           std::function<void()> pFunc);

template <typename Callable, typename ...Args>
tResult create_thread_with_scheduling(std::thread& oThread,
                                      const tSchedulingParameters& sScheduling,
                                      Callable&& pFunc, Args&&... args)
{
    // a lambda is not usable here, gcc 4.8 has a bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=41933
    // so we use this bind as a workaround
    auto pFuncCallable = std::bind(std::forward<Callable>(pFunc), std::forward<Args>(args)...);
    return create_thread_with_scheduling_impl(oThread, sScheduling, pFuncCallable);
}
tResult create_thread_with_scheduling(std::thread& oThread, {…}

template <typename Callable, typename ...Args>
std::thread create_thread_with_scheduling(const tSchedulingParameters& sScheduling,
                                          Callable&& pFunc, Args&&... args)
{
    std::thread oThread;
    create_thread_with_scheduling(oThread, sScheduling,
                                  std::forward<Callable>(pFunc),
                                  std::forward<Args>(args)...);
    return oThread;
}
std::thread create_thread_with_scheduling(const tSchedulingParameters& sScheduling, {…}
 
} // namespace A_UTILS_NS
 
#endif // _THREAD_CLASS_HEADER_