thread.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup numapp_thread
 * @brief Definition of thread functions
 * @copyright
 *   SPDX-FileCopyrightText: 2021-2024 European Southern Observatory (ESO)
 *
 *   SPDX-License-Identifier: LGPL-3.0-only
 */
#include <cstring>
 
#include <sys/prctl.h>
#include <sys/resource.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
 
#include <numapp/thread.hpp>
 
namespace {
static constexpr const std::size_t THREAD_NAME_MAX_SIZE = 16;
}
 
namespace numapp {
 
namespace thisThread {
// Mocked functions
#if !defined(UNIT_TEST)
pid_t GetThreadId() noexcept {
    return ::syscall(SYS_gettid);
}
#endif
 
void SetThreadName(std::string_view thread_name, std::error_code& ec) noexcept {
    if (thread_name.size() >= THREAD_NAME_MAX_SIZE) {
        ec = std::make_error_code(std::errc::result_out_of_range);
        return;
    }
 
    std::array<char, THREAD_NAME_MAX_SIZE> c_str;
    std::strncpy(c_str.data(), thread_name.data(), thread_name.size());
    c_str[thread_name.size()] = '\0';
 
    if (prctl(PR_SET_NAME, c_str.data()) == -1) {
        ec = std::make_error_code(static_cast<std::errc>(errno));
        return;
    }
    ec.clear();
}
 
void SetThreadName(std::string_view thread_name) {
    std::error_code ec;
    SetThreadName(thread_name, ec);
    if (ec) {
        throw std::system_error(ec, "Failed to set thread name for current thread");
    }
}
 
std::string GetThreadName(std::error_code& ec) noexcept {
    std::string thread_name;
    std::array<char, THREAD_NAME_MAX_SIZE> c_str;
    if (prctl(PR_GET_NAME, c_str.data()) == -1) {
        ec = std::make_error_code(static_cast<std::errc>(errno));
        return thread_name;
    }
 
    try {
        thread_name.assign(c_str.data());
        ec.clear();
        return thread_name;
    } catch (...) {
        ec = std::make_error_code(std::errc::not_enough_memory);
        return thread_name;
    }
}
 
std::string GetThreadName() {
    std::error_code ec;
    auto name = GetThreadName(ec);
    if (ec) {
        throw std::system_error(ec, "failed to get thread name");
    }
    return name;
}
 
}  // namespace thisThread
 
namespace detail {
ThreadInitializer::ThreadInitializer(std::string_view name, NumaPolicies const& policies)
    : m_name(name), m_policies(policies), m_result(), m_cond(), m_mtx(), m_lck(m_mtx) {
}
 
auto ThreadInitializer::Wait() -> std::system_error const& {
    m_cond.wait(m_lck, [&] { return m_result.has_value(); });
    return *m_result;
}
 
auto ThreadInitializer::Initialize() -> std::error_code {
    // Condition must be signalled on all exit-paths
    // Although condition_variable::notify_one does not have to be called while holding a
    // lock this is done to avoid a false-positive reported by thread-sanitizer.
    // Performance-wise it does not matter one way or another in this case.
    //
    auto lck = std::unique_lock(m_mtx);
 
    {
        std::error_code ec;
        if (thisThread::SetThreadName(m_name, ec); ec) {
            m_result =
                std::system_error(ec, "MakeThread: numapp::thisThread::SetThreadName() failed");
            m_cond.notify_one();
            return ec;
        }
    }
 
    // Apply NUMA policies
    if (auto ec = thisThread::Apply(m_policies); ec) {
        m_result = std::system_error(ec, "MakeThread: numapp::thisThread::Apply() failed");
        m_cond.notify_one();
        return ec;
    }
    // Apply memory policy to stack, moving it if necessary.
    // This is done because pthread may recycle stack so applying policy before creating
    // thread does not always work.
    if (m_policies.GetMemPolicy()) {
        auto ec = thisThread::ApplyStack(*m_policies.GetMemPolicy(),
                                         MemPolicyFlag::Move | MemPolicyFlag::Strict);
        if (ec) {
            m_result = std::system_error(ec, "MakeThread: numapp::ApplyStack() failed");
            m_cond.notify_one();
            return ec;
        }
    }
 
    // Policies applied, notify creator of thread things were ok
    m_result = std::system_error(std::error_code());
    m_cond.notify_one();
    return {};
}
 
}  // namespace detail
}  // namespace numapp