thread_management.hpp

/* Copyright 2009-2017 Francesco Biscani (bluescarni@gmail.com)

This file is part of the Piranha library.

The Piranha library is free software; you can redistribute it and/or modify
it under the terms of either:

  * the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 3 of the License, or (at your
    option) any later version.

or

  * the GNU General Public License as published by the Free Software
    Foundation; either version 3 of the License, or (at your option) any
    later version.

or both in parallel, as here.

The Piranha library is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received copies of the GNU General Public License and the
GNU Lesser General Public License along with the Piranha library.  If not,
see https://www.gnu.org/licenses/. */

#ifndef PIRANHA_THREAD_MANAGEMENT_HPP
#define PIRANHA_THREAD_MANAGEMENT_HPP

#include <stdexcept>
#include <utility>

#include <piranha/config.hpp>
#include <piranha/exceptions.hpp>
#include <piranha/runtime_info.hpp>
#include <piranha/safe_cast.hpp>
#include <piranha/thread_management.hpp>

#if defined(PIRANHA_HAVE_PTHREAD_AFFINITY)

extern "C" {
#include <pthread.h>
#include <sched.h>
}

namespace piranha
{

inline namespace impl
{

// In old systems (CentOS 5) CPU_COUNT is not defined. We define a small wrapper
// that implements the functionality if it is missing. See:
// http://www.redhat.com/archives/libvir-list/2012-August/msg01515.html
inline int posix_cpu_count(::cpu_set_t *set)
{
#if defined(CPU_COUNT)
    return CPU_COUNT(set);
#else
    int count = 0;
    for (int i = 0; i < CPU_SETSIZE; ++i) {
        if (CPU_ISSET(i, set)) {
            ++count;
        }
    }
    return count;
#endif
}
}
}

#elif defined(__FreeBSD__)

extern "C" {
#include <sys/cpuset.h>
#include <sys/param.h>
}

#elif defined(_WIN32)

extern "C" {
#include <Windows.h>
}
#include <limits>

#endif

namespace piranha
{


inline void bind_to_proc(unsigned n)
{
    const auto hc = runtime_info::get_hardware_concurrency();
    if (hc != 0u && n >= hc) {
        piranha_throw(std::invalid_argument, "processor index is larger than the detected hardware concurrency");
    }
#if defined(PIRANHA_HAVE_PTHREAD_AFFINITY)
    unsigned cpu_setsize;
    int n_int;
    try {
        cpu_setsize = safe_cast<unsigned>(CPU_SETSIZE);
        n_int = safe_cast<int>(n);
    } catch (const safe_cast_failure &) {
        piranha_throw(std::runtime_error, "numeric conversion error");
    }
    if (n >= cpu_setsize) {
        piranha_throw(std::invalid_argument, "processor index is larger than the maximum allowed value");
    }
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(n_int, &cpuset);
    const int errno_ = ::pthread_setaffinity_np(::pthread_self(), sizeof(cpuset), &cpuset);
    if (errno_ != 0) {
        piranha_throw(std::runtime_error, "the call to pthread_setaffinity_np() failed");
    }
#elif defined(__FreeBSD__)
    unsigned cpu_setsize;
    int n_int;
    try {
        cpu_setsize = safe_cast<unsigned>(CPU_SETSIZE);
        n_int = safe_cast<int>(n);
    } catch (const safe_cast_failure &) {
        piranha_throw(std::runtime_error, "numeric conversion error");
    }
    if (n >= cpu_setsize) {
        piranha_throw(std::invalid_argument, "processor index is larger than the maximum allowed value");
    }
    cpuset_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(n, &cpuset);
    if (::cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, sizeof(cpuset), &cpuset) == -1) {
        piranha_throw(std::runtime_error, "the call to cpuset_setaffinity() failed");
    }
#elif defined(_WIN32)
    // Check we are not going to bit shift too much.
    if (n >= static_cast<unsigned>(std::numeric_limits<DWORD_PTR>::digits)) {
        piranha_throw(std::invalid_argument, "processor index is larger than the maximum allowed value");
    }
    if (::SetThreadAffinityMask(::GetCurrentThread(), (DWORD_PTR)1 << n) == 0) {
        piranha_throw(std::runtime_error, "the call to SetThreadAffinityMask() failed");
    }
#else
    piranha_throw(not_implemented_error, "bind_to_proc() is not available on this platform");
#endif
}


inline std::pair<bool, unsigned> bound_proc()
{
#if defined(PIRANHA_HAVE_PTHREAD_AFFINITY)
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    const int errno_ = ::pthread_getaffinity_np(::pthread_self(), sizeof(cpuset), &cpuset);
    if (errno_ != 0) {
        piranha_throw(std::runtime_error, "the call to pthread_getaffinity_np() failed");
    }
    const int cpu_count = posix_cpu_count(&cpuset);
    if (cpu_count == 0 || cpu_count > 1) {
        return std::make_pair(false, static_cast<unsigned>(0));
    }
    int cpu_setsize;
    try {
        cpu_setsize = safe_cast<int>(CPU_SETSIZE);
    } catch (const safe_cast_failure &) {
        piranha_throw(std::runtime_error, "numeric conversion error");
    }
    for (int i = 0; i < cpu_setsize; ++i) {
        if (CPU_ISSET(i, &cpuset)) {
            // Cast is safe here (verified above that cpu_setsize is representable in int,
            // and, by extension, in unsigned).
            return std::make_pair(true, static_cast<unsigned>(i));
        }
    }
    piranha_throw(std::runtime_error, "operation failed");
#elif defined(__FreeBSD__)
    cpuset_t cpuset;
    CPU_ZERO(&cpuset);
    const int errno_ = ::cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, sizeof(cpuset), &cpuset);
    if (errno_ != 0) {
        piranha_throw(std::runtime_error, "the call to ::cpuset_getaffinity() failed");
    }
    int cpu_setsize;
    try {
        cpu_setsize = safe_cast<int>(CPU_SETSIZE);
    } catch (const safe_cast_failure &) {
        piranha_throw(std::runtime_error, "numeric conversion error");
    }
    unsigned bound_cpus = 0;
    int candidate = 0;
    for (int i = 0; i < cpu_setsize; ++i) {
        if (CPU_ISSET(i, &cpuset)) {
            ++bound_cpus;
            candidate = i;
        }
    }
    if (bound_cpus == 0 || bound_cpus > 1) {
        return std::make_pair(false, static_cast<unsigned>(0));
    } else {
        return std::make_pair(true, static_cast<unsigned>(candidate));
    }
#elif defined(_WIN32)
    // Store the original affinity mask.
    const DWORD_PTR original_affinity_mask = ::SetThreadAffinityMask(::GetCurrentThread(), (DWORD_PTR)1);
    if (original_affinity_mask == 0) {
        piranha_throw(std::runtime_error, "the call to SetThreadAffinityMask() failed");
    }
    const unsigned cpu_setsize = static_cast<unsigned>(std::numeric_limits<DWORD_PTR>::digits);
    unsigned bound_cpus = 0, candidate = 0;
    for (unsigned i = 0; i < cpu_setsize; ++i) {
        if (((DWORD_PTR)1 << i) & original_affinity_mask) {
            ++bound_cpus;
            candidate = i;
        }
    }
    // Restore the original affinity mask.
    if (::SetThreadAffinityMask(::GetCurrentThread(), original_affinity_mask) == 0) {
        piranha_throw(std::runtime_error, "the call to SetThreadAffinityMask() failed");
    }
    if (bound_cpus == 0 || bound_cpus > 1) {
        return std::make_pair(false, static_cast<unsigned>(0));
    } else {
        return std::make_pair(true, candidate);
    }
#else
    piranha_throw(not_implemented_error, "bound_proc() is not available on this platform");
#endif
}
}

#endif