Function check_os_thread_affinity

tests/BS_thread_pool_test.cpp:3042–3094

* @brief Check that getting and setting OS thread affinity works. */

 * @brief Check that getting and setting OS thread affinity works.
 */
void check_os_thread_affinity()
{
    BS::thread_pool pool;
    pool.detach_task(
        []
        {
            // Since the thread affinity must be a subset of the process affinity, we first set its affinity to all CPUs if it wasn't already.
            const std::optional<std::vector<bool>> initial_process_affinity = BS::get_os_process_affinity();
            const std::size_t num_process_bits = initial_process_affinity.has_value() ? initial_process_affinity->size() : std::thread::hardware_concurrency();
            const std::vector<bool> all_enabled(num_process_bits, true);
            BS::set_os_process_affinity(all_enabled);

            logln("Checking OS thread affinity for pool threads...");

            log("Obtaining initial thread affinity ");
            const std::optional<std::vector<bool>> initial_affinity = BS::this_thread::get_os_thread_affinity();
            check(initial_affinity.has_value());
            logln("Initial affinity is: ", affinity_to_string(initial_affinity));
            const std::size_t num_bits = initial_affinity.has_value() ? initial_affinity->size() : std::thread::hardware_concurrency();

            log("Setting affinity to CPU 1 only ");
            std::vector<bool> cpu_1_in(num_bits, false);
            cpu_1_in[0] = true;
            check(BS::this_thread::set_os_thread_affinity(cpu_1_in));
            log("Obtaining new affinity ");
            const std::optional<std::vector<bool>> cpu_1_out = BS::this_thread::get_os_thread_affinity();
            check(cpu_1_out.has_value());
            check(affinity_to_string(cpu_1_in), affinity_to_string(cpu_1_out));

            log("Setting affinity to alternating CPUs ");
            std::vector<bool> alternating_in(num_bits, false);
            for (std::size_t i = 0; i < num_bits; ++i)
                alternating_in[i] = (i % 2 == 1);
            check(BS::this_thread::set_os_thread_affinity(alternating_in));
            log("Obtaining new affinity ");
            const std::optional<std::vector<bool>> alternating_out = BS::this_thread::get_os_thread_affinity();
            check(alternating_out.has_value());
            check(affinity_to_string(alternating_in), affinity_to_string(alternating_out));

            if (initial_affinity.has_value())
            {
                log("Setting affinity back to initial value ");
                check(BS::this_thread::set_os_thread_affinity(*initial_affinity));
                log("Obtaining new affinity ");
                const std::optional<std::vector<bool>> initial_out = BS::this_thread::get_os_thread_affinity();
                check(initial_out.has_value());
                check(affinity_to_string(initial_affinity), affinity_to_string(initial_out));
            }

            if (initial_process_affinity.has_value())
                BS::set_os_process_affinity(*initial_process_affinity);
        });
}
    #endif

/**