lowlevel.cpp

/**
 * @cond Impl
 * @file
 * @ingroup numapp
 * @brief Definition of scheduler classes
 * @copyright
 *   SPDX-FileCopyrightText: 2020-2023 European Southern Observatory (ESO)
 *
 *   SPDX-License-Identifier: LGPL-3.0-only
 */
#include <cassert>
 
#include <numa.h>
#include <numaif.h>
#include <sys/resource.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
 
#include <numapp/lowlevel.hpp>
 
namespace numapp::ll {
 
#ifndef UNIT_TEST
std::error_code
SetSchedulerPolicy(pid_t pid, int policy, int static_priority, int dynamic_priority) NUMAPP_NOEXCEPT {
    // Set scheduler first, and only then set nice-value if used in policy.
    struct sched_param param = {0};
    switch (policy) {
    case SCHED_FIFO:
    case SCHED_RR:
        param.sched_priority = static_priority;
        break;
    default:
        break;
    };
    if (sched_setscheduler(pid, policy, &param) != 0) {
        return std::make_error_code(static_cast<std::errc>(errno));
    }
    switch (policy) {
    case SCHED_BATCH:
    case SCHED_OTHER:
        // Note: posix spec of setpriority mandates a process-wide nice-value, whereas Linux
        // deviates and supports a per-thread nice value.
        if (setpriority(PRIO_PROCESS, pid, dynamic_priority) != 0) {
            return std::make_error_code(static_cast<std::errc>(errno));
        }
        break;
    default:
        break;
    };
    return {};
}
 
std::error_code GetSchedulerPolicy(pid_t pid,
                                   int* policy,
                                   int* static_priority,
                                   int* dynamic_priority) NUMAPP_NOEXCEPT {
    assert(policy != nullptr);
    assert(static_priority != nullptr);
    assert(dynamic_priority != nullptr);
    if (int ret = sched_getscheduler(pid); ret == -1) {
        return std::make_error_code(static_cast<std::errc>(errno));
    } else {
        *policy = ret;
    }
    switch (*policy) {
    case SCHED_FIFO:
    case SCHED_RR: {
        struct sched_param param = {0};
        if (sched_getparam(pid, &param) != 0) {
            return std::make_error_code(static_cast<std::errc>(errno));
        }
        *static_priority = param.sched_priority;
        break;
    }
    case SCHED_BATCH:
    case SCHED_OTHER: {
        errno = 0;
        int prio = getpriority(PRIO_PROCESS, pid);
        // Prio can be -1 so also check errno.
        if (errno != 0) {
            return std::make_error_code(static_cast<std::errc>(errno));
        }
        *dynamic_priority = prio;
    }
    case SCHED_IDLE:
        break;
    default:
        return std::make_error_code(std::errc::not_supported);
    }
    return {};
}
 
std::error_code GetCpuAffinity(pid_t ttid, Cpumask& mask) NUMAPP_NOEXCEPT {
    if (numa_sched_getaffinity(ttid, mask.GetNative()) < 0) {
        return std::make_error_code(static_cast<std::errc>(errno));
    }
    return {};
}
 
std::error_code SetCpuAffinity(pid_t ttid, Cpumask const& mask) NUMAPP_NOEXCEPT {
    if (numa_sched_setaffinity(ttid, const_cast<Cpumask&>(mask).GetNative()) < 0) {
        return std::make_error_code(static_cast<std::errc>(errno));
    }
    return {};
}
 
std::error_code NumaNodeToCpumask(int node, Cpumask& mask) NUMAPP_NOEXCEPT {
    if (numa_node_to_cpus(node, mask.GetNative()) < 0) {
        return std::make_error_code(static_cast<std::errc>(errno));
    }
    return {};
}
 
std::error_code SetMemPolicy(int mode, Nodemask const& mask) NUMAPP_NOEXCEPT {
    if (auto err = set_mempolicy(mode, mask.GetNative()->maskp, mask.GetNative()->size + 1);
        err != 0) {
        return std::make_error_code(static_cast<std::errc>(errno));
    } else {
        return {};
    }
}
 
std::error_code
SetMemPolicy(void* addr, std::size_t len, int mode, Nodemask const& mask, unsigned flags)
    NUMAPP_NOEXCEPT {
    if (auto err =
            mbind(addr, len, mode, mask.GetNative()->maskp, mask.GetNative()->size + 1, flags);
        err != 0) {
        return std::make_error_code(static_cast<std::errc>(errno));
    } else {
        return {};
    }
}
 
std::error_code
GetMemPolicy(int& mode, Nodemask& mask, void* addr, unsigned flags) NUMAPP_NOEXCEPT {
    if (auto err =
            get_mempolicy(&mode, mask.GetNative()->maskp, mask.GetNative()->size + 1, addr, flags);
        err != 0) {
        return std::make_error_code(static_cast<std::errc>(errno));
    } else {
        return {};
    }
}
 
#endif
 
}  // namespace numapp
/// @endcond Impl