mempolicy.cpp

/**
 * @cond Impl
 * @file
 * @brief Definition of memory policy classes.
 * @copyright
 *   SPDX-FileCopyrightText: 2020-2023 European Southern Observatory (ESO)
 *
 *   SPDX-License-Identifier: LGPL-3.0-only
 */
#include <numapp/mempolicy.hpp>
 
#include <iostream>
 
#include <numapp/lowlevel.hpp>
 
namespace numapp {
namespace thisThread {
std::error_code Apply(MemPolicy const& policy) noexcept {
    if (auto err = ll::SetMemPolicy(static_cast<int>(policy.GetMode()), policy.GetNodemask());
        err) {
        return err;
    } else {
        return {};
    }
}
 
std::error_code ApplyStack(MemPolicy const& policy, MemPolicyFlag flags) noexcept {
    pthread_attr_t attr;
    void* stack_addr = nullptr;
    std::size_t stack_size = 0;
    if (auto err = pthread_getattr_np(pthread_self(), &attr); err != 0) {
        return std::make_error_code(static_cast<std::errc>(err));
    }
    if (auto err = pthread_attr_getstack(&attr, &stack_addr, &stack_size); err != 0) {
        return std::make_error_code(static_cast<std::errc>(err));
    }
    return ::numapp::Apply(stack_addr, stack_size, policy, flags);
}
 
}  // namespace thisThread
 
std::error_code Apply(void* address,
                      std::size_t length,
                      MemPolicy const& policy,
                      MemPolicyFlag flags) NUMAPP_NOEXCEPT {
    return ll::SetMemPolicy(address,
                            length,
                            static_cast<int>(policy.GetMode()),
                            policy.GetNodemask(),
                            static_cast<std::underlying_type<MemPolicyFlag>::type>(flags));
}
 
MemPolicy MemPolicy::MakeBindNode(int node) {
    auto node_mask = Nodemask();
    // setbit does not return error if node is greater than node mask
    (void)numa_bitmask_setbit(node_mask.GetNative(), node);
    // So verify that bit is set and throw otherwise
    if (!numa_bitmask_isbitset(node_mask.GetNative(), node)) {
        throw std::system_error(std::make_error_code(std::errc::invalid_argument));
    }
 
    return MemPolicy(Mode::Bind, std::move(node_mask));
}
 
MemPolicy MemPolicy::MakeFromActive() {
    int mode = 0;
    Nodemask mask;
    if (auto err = ll::GetMemPolicy(mode, mask, nullptr, 0); err) {
        throw std::system_error(err);
    }
    return MemPolicy(static_cast<Mode>(mode), std::move(mask));
}
 
MemPolicy MemPolicy::MakeFromAddress(void* address) {
    int mode = 0;
    Nodemask mask;
    if (auto err = ll::GetMemPolicy(mode, mask, address, MPOL_F_ADDR); err) {
        throw std::system_error(err);
    }
    return MemPolicy(static_cast<Mode>(mode), std::move(mask));
}
 
[[nodiscard]] std::error_code ScopedMemPolicy::Restore() noexcept {
    if (m_old_policy) {
        return thisThread::Apply(*m_old_policy);
    }
    return {};
}
 
std::ostream& operator<<(std::ostream& os, MemPolicy::Mode const& mode) {
    switch (mode) {
    case MemPolicy::Mode::Default:
        os << "Default";
        break;
    case MemPolicy::Mode::Bind:
        os << "Bind";
        break;
    case MemPolicy::Mode::Interleave:
        os << "Interleave";
        break;
    case MemPolicy::Mode::Preferred:
        os << "Preferred";
        break;
    };
    return os;
}
 
std::ostream& operator<<(std::ostream& os, MemPolicy const& mempolicy) {
    os << "MemPolicy {mode=" << mempolicy.GetMode() << ", mask=" << mempolicy.GetNodemask() << "}";
    return os;
}
}  // namespace numapp
/// @endcond Impl