BS_thread_pool_test.cpp File Reference

BS::thread_pool: a fast, lightweight, modern, and easy-to-use C++17/C++20/C++23 thread pool library. This program tests all aspects of the library, but is not needed in order to use the library. More...

#include <algorithm>
#include <array>
#include <atomic>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <functional>
#include <future>
#include <initializer_list>
#include <iomanip>
#include <ios>
#include <iostream>
#include <limits>
#include <map>
#include <memory>
#include <mutex>
#include <numeric>
#include <optional>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <string_view>
#include <thread>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>
#include "BS_thread_pool.hpp"

Include dependency graph for BS_thread_pool_test.cpp:

Macros
#define	BS_THREAD_POOL_TEST_VERSION   5, 1, 0
#define	UNPACK_2_BYTES(value)   static_cast<std::uint8_t>(value), static_cast<std::uint8_t>((value) >> 8)
#define	UNPACK_4_BYTES(value)   static_cast<std::uint8_t>(value), static_cast<std::uint8_t>((value) >> 8), static_cast<std::uint8_t>((value) >> 16), static_cast<std::uint8_t>((value) >> 24)

Functions
int	main (int argc, char *argv[])

Variables
constexpr bool	using_import_std = false

Detailed Description

BS::thread_pool: a fast, lightweight, modern, and easy-to-use C++17/C++20/C++23 thread pool library. This program tests all aspects of the library, but is not needed in order to use the library.

██████ ███████ ████████ ██ ██ ██████ ███████ █████ ██████ ██████ ██████ ██████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██████ ███████ ██ ███████ ██████ █████ ███████ ██ ██ ██████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██████ ███████ ██ ██ ██ ██ ██ ███████ ██ ██ ██████ ███████ ██ ██████ ██████ ███████

Author

Barak Shoshany (barak.nosp@m.sh@g.nosp@m.mail..nosp@m.com) (https://baraksh.com/)

Version

5.1.0

Date

2026-01-03

Copyright

Copyright (c) 2021-2026 Barak Shoshany. Licensed under the MIT license. If you found this project useful, please consider starring it on GitHub! If you use this library in software of any kind, please provide a link to the GitHub repository https://github.com/bshoshany/thread-pool in the source code and documentation. If you use this library in published research, please cite it as follows: Barak Shoshany, "A C++17 Thread Pool for High-Performance Scientific Computing", doi:10.1016/j.softx.2024.101687, SoftwareX 26 (2024) 101687, arXiv:2105.00613

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

{
#ifdef __cpp_exceptions
    try
    {
#endif
        // Disable ANSI colors if the environment variable `NO_COLOR` is set.
        no_color = (std::getenv("NO_COLOR") != nullptr); // NOLINT(concurrency-mt-unsafe)
 
        // If the file default_args.txt exists in either this folder or the parent folder, read the default arguments from it (space separated in a single line). Otherwise, use the built-in defaults. This is useful when debugging.
        std::map<std::string, bool> defaults;
        std::ifstream default_args_file("default_args.txt");
        if (!default_args_file.is_open())
            default_args_file.open("../default_args.txt");
        if (default_args_file.is_open())
        {
            std::string line;
            std::getline(default_args_file, line);
            std::istringstream iss(line);
            std::string arg;
            while (iss >> arg)
                defaults[arg] = true;
            default_args_file.close();
        }
        else
        {
            defaults = {{"help", false}, {"stdout", true}, {"log", true}, {"tests", true}, {"deadlock", false}, {"benchmarks", true}, {"plot", false}, {"save", false}};
        }
 
        // Parse the command line arguments.
        arg_parser args(argc, argv);
        args.add_argument("help", "Show this help message and exit.", defaults["help"]);
        args.add_argument("stdout", "Print to the standard output.", defaults["stdout"]);
        args.add_argument("log", "Print to a log file.", defaults["log"]);
        args.add_argument("tests", "Perform standard tests.", defaults["tests"]);
        args.add_argument("deadlock", "Perform long deadlock tests.", defaults["deadlock"]);
        args.add_argument("benchmarks", "Perform full Mandelbrot plot benchmarks.", defaults["benchmarks"]);
        args.add_argument("plot", "Perform quick Mandelbrot plot benchmarks.", defaults["plot"]);
        args.add_argument("save", "Save the Mandelbrot plot to a file.", defaults["save"]);
 
        if (args.size() > 0)
        {
            if (args["help"] || !args.verify())
            {
                show_intro();
                args.show_help();
                return 0;
            }
            if (!args["stdout"] && !args["log"])
            {
                show_intro();
                args.show_help();
                logln_ansi(ansi_error, "\nERROR: No output stream specified! Please enter one or more of: log, stdout. Aborting.");
                return 0;
            }
            if (!args["benchmarks"] && !args["deadlock"] && !args["plot"] && !args["tests"])
            {
                show_intro();
                args.show_help();
                logln_ansi(ansi_error, "\nERROR: No tests or benchmarks requested! Please enter one or more of: benchmarks, deadlock, plot, tests. Aborting.");
                return 0;
            }
        }
 
        // A stream object used to access the log file.
        std::ofstream log_file;
 
        sync_log.remove_stream(std::cout);
        if (args["log"])
        {
            // Extract the name of the executable file, or use a default value if it is not available.
            const std::string_view executable = args.get_executable();
            const std::size_t last_slash = executable.find_last_of("/\\") + 1;
            std::string exe_file(executable.substr(last_slash, executable.find('.', last_slash) - last_slash));
            if (exe_file.empty())
                exe_file = "BS_thread_pool_test";
            // Create a log file using the name of the executable, followed by the current date and time.
            const std::string log_filename = exe_file + "-" + get_time() + ".log";
            log_file.open(log_filename);
            if (log_file.is_open())
            {
                logln_ansi(ansi_info, "Generating log file: ", log_filename);
                sync_log.add_stream(log_file);
            }
            else
            {
                logln_ansi(ansi_error, "ERROR: Could not create a log file.");
                return 1;
            }
        }
 
        use_stdout = args["stdout"];
        use_log = args["log"];
 
        show_intro();
 
        if (args["tests"])
        {
            print_header("Checking the constructor:");
            check_constructor();
 
            print_header("Checking reset():");
            check_reset();
 
            print_header("Checking detach_task() and submit_task():");
            check_task("detach_task()");
            check_task("submit_task()");
 
            print_header("Checking submission of member functions as tasks:");
            check_member_function();
            check_member_function_within_object();
 
            print_header("Checking submission of different callable types:");
            check_callables();
 
            print_header("Checking wait(), wait_for(), and wait_until():");
            check_wait();
            check_wait_blocks();
            check_wait_for();
            check_wait_until();
            check_wait_multiple_deadlock();
#ifdef __cpp_exceptions
            check_wait_self_deadlock();
 
            print_header("Checking exception handling:");
            check_exceptions_submit();
            check_exceptions_multi_future();
#else
        logln_ansi(ansi_info, "NOTE: Exceptions are disabled, skipping wait deadlock check and exception handling tests.");
#endif
 
            print_header("Checking detach_loop() and submit_loop():");
            check_loop();
 
            print_header("Checking detach_blocks() and submit_blocks():");
            check_blocks();
 
            print_header("Checking detach_sequence() and submit_sequence():");
            check_sequence();
 
            print_header("Checking task monitoring:");
            check_task_monitoring();
 
            print_header("Checking pausing:");
            check_pausing();
 
            print_header("Checking purge():");
            check_purge();
 
            print_header("Checking parallelized vector operations:");
            check_vectors();
 
            print_header("Checking task priority:");
            check_priority();
 
            print_header("Checking thread initialization/cleanup functions and BS::this_thread:");
            check_init();
            check_cleanup();
            check_get_pool();
 
            print_header("Checking that parallelized tasks do not get copied:");
            check_copy_all();
 
            print_header("Checking that shared pointers are correctly shared:");
            check_shared_ptr_all();
 
            print_header("Checking that tasks are destructed immediately after running:");
            check_task_destruct();
 
            print_header("Checking BS::common_index_type:");
            check_common_index_type();
 
#ifdef BS_THREAD_POOL_NATIVE_EXTENSIONS
            print_header("Checking native extensions:");
    #ifndef _WIN32
            if ((args["benchmarks"] || args["plot"]) && !BS::set_os_process_priority(BS::os_process_priority::realtime))
            {
                logln_ansi(ansi_info, "NOTE: Skipping process/thread priority checks since the test is running on Linux/macOS without root privileges and benchmarks are enabled. On Linux/macOS, if priorities are decreased, they cannot be increased back to normal without root privileges, so the process will be stuck on the lowest priority, and the benchmarks will be unreliable.\n");
            }
            else
    #endif
            {
                // Note: We have to check thread priorities first, because the check for process priorities lowers the priority of the process to the lowest level, and on Linux, if not running as root, we can only lower the priority, not raise it, so the process gets stuck on the lowest priority. Since the thread priorities cannot be set to higher than the process priorities, this means the thread priorities will also be stuck on the lowest priority, and the test will fail.
                check_os_thread_priorities();
                logln();
                check_os_process_priorities();
                logln();
            }
            check_os_thread_names();
            logln();
    #if defined(_WIN32) || defined(__linux__)
            check_os_thread_affinity();
            logln();
            check_os_process_affinity();
    #else
            logln_ansi(ansi_info, "NOTE: macOS does not support affinity, skipping the corresponding test.");
    #endif
#else
        logln_ansi(ansi_info, "NOTE: Native extensions disabled, skipping the corresponding test.");
#endif
        }
 
        if (args["deadlock"])
        {
            print_header("Checking for deadlocks:");
            logln("Checking for destruction deadlocks...");
            check_deadlock(
                []
                {
                    BS::thread_pool temp_pool;
                    temp_pool.detach_task([] {});
                });
            logln("Checking for reset deadlocks...");
            BS::thread_pool temp_pool;
            check_deadlock(
                [&temp_pool]
                {
                    temp_pool.reset();
                });
        }
 
        if (test_results::tests_failed > 0)
        {
            print_header("FAILURE: Passed " + std::to_string(test_results::tests_succeeded) + " checks, but failed " + std::to_string(test_results::tests_failed) + "!", '+', ansi_error);
            logln_ansi(ansi_error, "\nPlease submit a bug report at https://github.com/bshoshany/thread-pool/issues including the exact specifications of your system (OS, CPU, compiler, etc.) and the generated log file.");
            log_file.close();
            return static_cast<int>(test_results::tests_failed);
        }
 
        if (test_results::tests_succeeded > 0)
            print_header("SUCCESS: Passed all " + std::to_string(test_results::tests_succeeded) + " checks!", '+', ansi_success);
 
        if (args["benchmarks"] || args["plot"])
            check_performance(args["benchmarks"], args["plot"], args["save"]);
 
        log_file.close();
        return 0;
#ifdef __cpp_exceptions
    }
    catch (const std::exception& e)
    {
        logln_ansi(ansi_error, "ERROR: Tests failed due to exception: ", e.what());
        return 1;
    }
#endif
}