nodemask.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup numapp_numa
 * @brief Contains declarations for Nodemask
 * @copyright
 *   SPDX-FileCopyrightText: 2020-2024 European Southern Observatory (ESO)
 *
 *   SPDX-License-Identifier: LGPL-3.0-only
 */
#ifndef NUMAPP_NODEMASK_HPP_
#define NUMAPP_NODEMASK_HPP_
#include <system_error>
#include <numa.h>
 
#include "bitmask.hpp"
 
namespace numapp {
 
/**
 * Type-safe NUMA node mask
 *
 * @sa ForEach
 * @ingroup numapp_numa
 */
struct Nodemask : public Bitmask<Nodemask> {
public:
    /**
     * Inherit constructors from Bitmask.
     */
    using Bitmask<Nodemask>::Bitmask;
 
    /**
     * Construct Nodemask from nodestring that considers current cpuset.
     *
     * @note Uses @c numa_parse_nodestring to parse.
     *
     * @manpages
     * @manpage{numa,3}
     *
     * @param nodestring Mask expressed as nodestring. See man page.
     * @throws std::system_error containing error code if parsing fails.
     */
    [[nodiscard]] static Nodemask MakeFromNodestring(char const* nodestring) {
        return MakeFromString(nodestring, numa_parse_nodestring);
    }
 
    /**
     * Construct Nodemask from nodestring that considers does not consider current cpuset.
     *
     * @note Uses @c numa_parse_nodestring_all to parse.
     *
     * @manpages
     * @manpage{numa,3}
     *
     * @param nodestring Mask expressed as nodestring. See man page.
     * @throws std::system_error containing error code if parsing fails.
     */
    [[nodiscard]] static Nodemask MakeFromNodestringAll(char const* nodestring) {
        return MakeFromString(nodestring, numa_parse_nodestring_all);
    }
protected:
    using ParseFunc = struct bitmask *(*)(const char *);
    [[nodiscard]] static Nodemask MakeFromString(char const* nodestring, ParseFunc func) {
        // note: numa_parse functions do not set errno.
        auto* mask_ptr = func(nodestring);
        if (mask_ptr == nullptr) {
            throw std::system_error(std::make_error_code(std::errc::invalid_argument),
                                    "Could not parse nodestring");
        } else if (mask_ptr == numa_no_nodes_ptr) {
            // CpuAffinity takes ownership of the struct bitmask* so we create our own empty
            // set instead of returning the globally shared numa_no_nodes_ptr.
            return Alloc();
        } else {
            return NumaBitmaskPtr(mask_ptr, &numa_free_nodemask);
        }
    }
 
    friend class Bitmask<Nodemask>;
    [[nodiscard]] static NumaBitmaskPtr Alloc() {
        return NumaBitmaskPtr(numa_allocate_nodemask(), &numa_free_nodemask);
    }
};
 
 
/**
 * Formats @a mask and inserts it to @a os.
 *
 * Mask up to number of configured NUMA nodes are formatted if no higher bits are set.
 *
 * @param os output stream to insert into.
 * @param mask Nodemask to format.
 * @returns @a os
 *
 * @ingroup numapp_numa
 */
inline std::ostream& operator<<(std::ostream& os, Nodemask const& mask) {
    return FormatBitmask(os, mask, numa_num_configured_nodes());
}
 
}  // namespace numapp
 
#endif  // #ifndef NUMAPP_NODEMASK_HPP_