numapolicies.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup numapp
 * @copyright ESO 2024 - European Southern Observatory
 *
 * @brief Contains declarations for NumaPolicies
 */
#ifndef NUMAPP_NUMAPOLICIES_HPP_
#define NUMAPP_NUMAPOLICIES_HPP_
#include <iosfwd>
 
#include <numapp/cpuaffinity.hpp>
#include <numapp/mempolicy.hpp>
#include <numapp/scheduler.hpp>
 
namespace numapp {
 
class NumaPolicies;
 
namespace thisThread {
/**
 * @name Apply Policies to Current Thread
 *
 * Applies specified policies to calling thread.
 */
/// @{
 
/**
 * Apply the set policies to current thread.
 *
 * If any failure occurs the function will stop applying policies and return error.
 * This means the policies can be partially applied.
 *
 * @param policies The set of policies to apply.
 * @returns system error code if policies fails to apply.
 *
 * @relatesalso numapp::NumaPolicies
 */
std::error_code Apply(NumaPolicies const& policies) noexcept;
/// @}
 
} // namespace thisThread
 
/**
 * Combines the the available NUMA policy types in one object.
 *
 * @ingroup numapp
 */
class NumaPolicies {
public:
    NumaPolicies() noexcept = default;
    NumaPolicies(MemPolicy const& policy) : m_mempolicy(policy) {};
    NumaPolicies(CpuAffinity const& policy) : m_affinity(policy) {};
    NumaPolicies(Scheduler const& policy) : m_scheduler(policy) {};
    NumaPolicies(NumaPolicies&&) noexcept = default;
    NumaPolicies& operator=(NumaPolicies&&) noexcept = default;
 
    NumaPolicies(NumaPolicies const& rhs) = default;
    NumaPolicies& operator=(NumaPolicies const& rhs) noexcept = default;
 
    /**
     * Set CPU affinity.
     */
    inline void SetCpuAffinity(std::optional<CpuAffinity> affinity) noexcept;
 
    /**
     * Get CPU affinity.
     */
    inline std::optional<CpuAffinity> GetCpuAffinity() const noexcept;
 
    /**
     * Swap CPU affinity.
     */
    inline void SwapCpuAffinity(std::optional<CpuAffinity>& affinity) noexcept;
 
    /**
     * Set scheduler.
     */
    inline void SetScheduler(std::optional<Scheduler> scheduler) noexcept;
 
    /**
     * Get scheduler.
     */
    inline std::optional<Scheduler> GetScheduler() const noexcept;
 
    /**
     * Swap scheduler.
     */
    inline void SwapScheduler(std::optional<Scheduler>& scheduler) noexcept;
 
    /**
     * Set memory policy.
     */
    inline void SetMemPolicy(std::optional<MemPolicy> policy) noexcept;
 
 
    /**
     * Get memory policy.
     */
    inline std::optional<MemPolicy> GetMemPolicy() const noexcept;
 
    /**
     * Swap memory policy.
     */
    inline void SwapMemPolicy(std::optional<MemPolicy>& mempol) noexcept ;
 
private:
    std::optional<CpuAffinity> m_affinity;
    std::optional<MemPolicy> m_mempolicy;
    std::optional<Scheduler> m_scheduler;
};
 
// Inlines
void NumaPolicies::SetCpuAffinity(std::optional<CpuAffinity> affinity) noexcept {
    m_affinity.swap(affinity);
}
 
std::optional<CpuAffinity> NumaPolicies::GetCpuAffinity() const noexcept {
    return m_affinity;
}
 
void NumaPolicies::SwapCpuAffinity(std::optional<CpuAffinity>& affinity) noexcept {
    m_affinity.swap(affinity);
}
 
void NumaPolicies::SetScheduler(std::optional<Scheduler> scheduler) noexcept {
    m_scheduler.swap(scheduler);
}
 
std::optional<Scheduler> NumaPolicies::GetScheduler() const noexcept {
    return m_scheduler;
}
 
void NumaPolicies::SwapScheduler(std::optional<Scheduler>& scheduler) noexcept {
    m_scheduler.swap(scheduler);
}
 
void NumaPolicies::SetMemPolicy(std::optional<MemPolicy> policy) noexcept {
    m_mempolicy.swap(policy);
}
 
std::optional<MemPolicy> NumaPolicies::GetMemPolicy() const noexcept {
    return m_mempolicy;
}
 
void NumaPolicies::SwapMemPolicy(std::optional<MemPolicy>& mempol) noexcept {
    m_mempolicy.swap(mempol);
}
 
/**
 * Formats @a policies and inserts it to @a os.
 *
 * @param os output stream to insert into.
 * @param policies policy to format.
 * @returns @a os
 */
std::ostream& operator<<(std::ostream& os, NumaPolicies const& policies);
 
}  // namespace numapp
#endif  // NUMAPP_NUMAPOLICIES_HPP_