* @brief Check if a condition is met, report the result, and keep count of the total number of successes and failures. * * @param condition The cond

* @brief Wait for all the futures stored in this `BS::multi_future`. */

* @brief Add an argument to the list of allowed arguments. * * @param arg The argument. * @param desc The description of the argument.

* @brief Print a stylized header with the specified ANSI styles. * * @param text The text of the header. Will appear between two lines. * @param sy

* @brief Get the number of command line arguments. * * @return The number of arguments. */

Print a message followed by a newline, but only if the verbose flag is set. Uses the given ANSI codes if specified.

* @brief Get the index after the last index of a block. * * @param block The block number. * @return The index after the last index.

* @brief Convert a `std::vector<bool>` representing CPU affinity to a string of 0s and 1s. * * @param affinity The affinity. * @return The string.

* @brief Get the results from all the futures stored in this `BS::multi_future`, rethrowing any stored exceptions. * * @return If the future

Print an error message followed by a newline in red and exit.

Print a key-value pair with the key left-aligned to the given length, but only if the verbose flag is set.

* @brief Get the string representation of an OS process priority. * * @param priority A `std::optional<BS::os_process_priority>` object. * @return

* @brief Set the priority of the current process using the current platform's native API. This should work on Windows, Linux, and macOS. However, note

If the path is relative to the current working directory, return it as a relative path; otherwise, return it as a full path.

* @brief Check if a condition is met, report the result, but do not keep count of the total number of successes and failures, because failure is expec

* @brief Check, for a specific member function which parallelizes loops or sequences of tasks, that the callable object does not get copied in the pro

* @brief Check, for a specific member function which parallelizes loops or sequences of tasks, that if a task that captures a shared pointer is submit

* @brief Get the processor affinity of the current process using the current platform's native API. This should work on Windows and Linux, but is not

* @brief Get the string representation of an OS thread priority. * * @param priority A `std::optional<BS::os_thread_priority>` object. * @return A

Print a separator line, but only if the verbose flag is set.

* @brief Atomically increments the internal counter. Any thread(s) waiting for the counter to be greater than 0, such as due to being blocked in `acqu

* @brief Get the number of milliseconds stored when `stop()` was last called. * * @return The number of milliseconds. */

* @brief Set the processor affinity of the current process using the current platform's native API. This should work on Windows and Linux, but is not

* @brief Check that detach_blocks() or submit_blocks() work for a specific range of indices split over a specific number of tasks, with no return valu

* @brief Check that detach_loop() or submit_loop() work for a specific range of indices split over a specific number of tasks, with no return value.

* @brief Show basic information about the program. */

* @brief Atomically decrements the internal counter by 1 if it is greater than 0; otherwise blocks until it is greater than 0 and can successfully dec

Print a message. Uses the given ANSI codes if specified. Does not add newline. Does not print color if the `NO_COLOR` environment variable is set.

* @brief Stop measuring time and store the elapsed time since the object was constructed or since `start()` was last called. */

* @brief Calculate the colors of a range of pixels in an image, enumerated as a range of indices in a 1-dimensional array containing the flattened mat

* @brief Check that detach_sequence() or submit_sequence() work for a specific range of indices, with no return value. * * @param pool The thread po

* @brief Check that detach_task() or submit_task() work. * * @param which_func A string naming the function to check. */

Compile a module with the given name. The first path in `paths` is the module file, and the rest are its dependencies. Returns True if the module was

* @brief Destroy the threads in the pool. */

Find the Visual Studio installation path, if it exists.

Get the path to the LLVM standard library module on Linux or macOS. If multiple paths are found, return the one with the latest LLVM version.

Get the appropriate flags to import a module with the given name from the given output path.

* @brief Get the number of blocks. Note that this may be different than the desired number of blocks that was passed to the constructor. * *

* @brief Get the priority of the current process using the current platform's native API. This should work on Windows, Linux, and macOS. * * @return

* @brief Get the number of threads in the pool. * * @return The number of threads. */

* @brief Create a plot of an image as characters, using either 24-bit ANSI colors or monochrome blocks of different brightness. * * @param image The

* @brief Start (or restart) measuring time. Note that the timer starts ticking as soon as the object is created, so this is only necessary if we want

* @brief Get the first index of a block. * * @param block The block number. * @return The first index. */

* @brief Wait for tasks to be completed. Normally, this function waits for all tasks, both those that are currently running in the threads and those t

* @brief A worker function to be assigned to each thread in the pool. Waits until it is notified by `detach_task()` that a task is available, and then

* @brief Add a stream to the list of output streams to print to. * * @param stream The stream. */

* @brief Calculate the mean and standard deviation of a set of integers. * * @param timings The integers. * @return A struct containing the mean an

* @brief Map a color to a monochrome Unicode block based on its brightness, using luma coefficients. * * @param col The color. * @return The Unicod

* @brief Check that detach_blocks() and submit_blocks() work using several different random values for the range of indices and number of tasks. */

* @brief Check that submit_blocks() works for a specific range of indices split over a specific number of tasks, with a return value. * * @param poo

* @brief Check that different callable types are accepted by the thread pool. */

* @brief Check that thread cleanup functions work. */

* @brief Check that the type trait `BS::common_index_type` works as expected. */

* @brief Check, for all member functions which parallelize loops or sequences of tasks, that the callable object does not get copied in the process.

* @brief Check that exceptions are forwarded correctly by `BS::multi_future`. */

* @brief Check that exceptions are forwarded correctly by submit_task(). */

* @brief Check that get_pool() works. */

* @brief Check that thread initialization functions and get_index() work. */

* @brief Check that detach_loop() and submit_loop() work using several different random values for the range of indices and number of tasks. */

* @brief Check that submitting member functions works. */

* @brief Check that submitting member functions within an object works. */

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

* @brief Check that getting and setting OS process priorities works. */

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

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

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

* @brief Check that pausing works. */

* @brief Benchmark multithreaded performance by calculating the Mandelbrot set. * * @param benchmark Whether to perform the full benchmarks. * @par

* @brief Check that task priority works as expected with all task submission methods. */

* @brief Check that purge() works. */

* @brief Check that reset() works. */

* @brief Check that detach_sequence() and submit_sequence() work using several different random values for the range of indices. */