Function check_performance

tests/BS_thread_pool_test.cpp:3599–3782

* @brief Benchmark multithreaded performance by calculating the Mandelbrot set. * * @param benchmark Whether to perform the full benchmarks. * @param plot Whether to perform quick benchmarks by just plotting the image once. * @param save Whether to save the image as a BMP file. */

 * @param save Whether to save the image as a BMP file.
 */
void check_performance(const bool benchmark, const bool plot, const bool save)
{
    print_header("Preparing benchmarks:");

#ifdef BS_THREAD_POOL_NATIVE_EXTENSIONS
    // Try to give the process the highest possible priority, so that other processes do not interfere with the benchmarks.
    if (!BS::set_os_process_priority(BS::os_process_priority::realtime))
        if (!BS::set_os_process_priority(BS::os_process_priority::high))
            BS::set_os_process_priority(BS::os_process_priority::above_normal);

    const std::string process_priority = os_process_priority_name(BS::get_os_process_priority());
    logln("Process priority set to: ", process_priority, ".");
    if (process_priority != "realtime")
        logln_ansi(ansi_info, "Note: Please run as admin/root to enable a higher process priority.");

    try_os_thread_priority();
    const std::string thread_priority = os_thread_priority_name(BS::this_thread::get_os_thread_priority());
    logln("Thread priority set to: ", thread_priority, ".");
    if (thread_priority != "realtime")
        logln_ansi(ansi_info, "Note: Please run as admin/root to enable a higher thread priority.");

    // Initialize a thread pool with the default number of threads, and ensure that the threads have the highest possible priority, so that other processes do not interfere with the benchmarks.
    BS::thread_pool pool(try_os_thread_priority);
#else
    // If native extensions are disabled, just initialize a thread pool with the default number of threads.
    BS::thread_pool pool;
#endif

    // Store the number of available hardware threads for easy access.
    const std::size_t thread_count = pool.get_thread_count();
    logln("Using ", thread_count, " threads.");

    // Set the formatting of floating point numbers.
    log(std::fixed, std::setprecision(1));

    // Initialize a timer object to measure execution time.
    timer tmr;

    // The target execution time, in milliseconds, of the multithreaded test with the number of blocks equal to the number of threads. The total time spent on that test will be approximately equal to `repeat * target_ms`.
    constexpr std::chrono::milliseconds::rep target_ms = 50;

    // Find the Mandelbrot image size that will roughly achieve the target execution time.
    logln("Determining the Mandelbrot image size needed to achieve an approximate mean execution time of ", target_ms, " ms with ", thread_count, " tasks...");
    std::size_t image_size = thread_count;
    image_matrix<color> image;
    std::size_t jump = 1;
    std::size_t offset = 0;

    // Define the loop function.
    const auto loop = [&image, &jump, &offset](const std::size_t start, const std::size_t end)
    {
        calculate_mandelbrot(image, start, end, jump, offset);
    };

    // Increase the image size gradually until the target execution time is reached.
    do
    {
        image_size *= 2;