* @brief Check that submit_sequence() works for a specific range of indices, with a return value. * * @param pool The thread pool to check. * @para

* @brief Check, for all member functions which parallelize loops or sequences of tasks, that if a task that captures a shared pointer is submitted, th

* @brief Check that a task is destructed immediately after it executes, and therefore does not artificially extend the lifetime of any captured object

* @brief Check that task monitoring works. */

* @brief Check that parallelized vector operations work as expected by calculating the sum of two randomized vectors of a specific size in two ways, s

* @brief Check that parallelized vector operations work as expected. */

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

* @brief Check that wait() correctly blocks all external threads that call it. */

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

* @brief Check that calling wait() more than once doesn't create a deadlock. */

* @brief Check that calling wait() from within a thread of the same pool throws an exception instead of creating a deadlock. */

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

* @brief Detect the compiler used to compile this program. * * @return A string describing the compiler. */

* @brief Detect the C++ standard used to compile this program. * * @return A string describing the C++ standard. */

* @brief Detect the C++ standard library used to compile this program. * * @return A string describing the C++ standard library. */

* @brief Detect the operating system used to compile this program. * * @return A string describing the operating system. */

* @brief Determine how many threads the pool should have, based on the parameter passed to the constructor or reset(). * * @param num_thread

* @brief Get the name of the executable. * * @return The name of the executable. */

* @brief Get a string representing the current time. * * @return The string. */

* @brief Interpolate between two colors. * * @param first The first color. * @param second The second color. * @param t The interpolation point, i

* @brief Convert the escape time of a point into a color. * * @param iterations The fractional number of iterations before the point escapes the Man

* @brief Find the escape time of a point. * * @param c The point. * @return The escape time, that is, the number of iterations before the point esc

Extract the LLVM version from a path and returns it as a tuple of integers.

* @brief Pop a task from the queue. * * @return The task. */

* @brief Calculate and print the speedup obtained by multithreading. * * @param timings A vector of the timings corresponding to different numbers o

* @brief Print the timing of a specific test. * * @param stats A struct containing the mean and standard deviation. * @param pixels_per_ms The numb

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

* @brief Save an image to a BMP file. * * @param image The matrix containing the pixels. * @param filename The output file name. */

* @brief Try to set the OS priority of this thread to the highest possible value. Also set the name of the thread for debugging purposes. */

* @brief Verify that the command line arguments belong to the list of allowed arguments. * * @return `true` if all arguments are allowed, `f

Store the parsed arguments.

* @brief Convert the command line arguments passed to the `main()` function into an `std::vector`. * * @param argc The number of arguments.

* @brief Construct a `blocks` object with the given specifications. * * @param first_index_ The first index in the range. * @param inde

* @brief Construct a new counting semaphore with the given initial counter value. * * @param desired The initial counter value. */

* @brief Get the number of milliseconds that have elapsed since the object was constructed or since `start()` was last called, but keep the timer tick

* @brief Get the index of the current thread. If this thread belongs to a `BS::thread_pool` object, the return value will be an index in the range `[0

* @brief Get a vector containing the underlying implementation-defined thread handles for each of the pool's threads, as obtained by `std::thread::nat

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

* @brief Get the name of the current thread using the current platform's native API. This should work on Windows, Linux, and macOS. * * @ret

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

* @brief Get a pointer to the thread pool that owns the current thread. If this thread belongs to a `BS::thread_pool` object, the return value will be

* @brief Get the number of tasks currently waiting in the queue to be executed by the threads. * * @return The number of queued tasks.

* @brief Get the number of tasks currently being executed by the threads. * * @return The number of running tasks. */

* @brief Get the total number of unfinished tasks: either still waiting in the queue, or running in a thread. Note that `get_tasks_total() == get_task

* @brief Get a vector containing the unique identifiers for each of the pool's threads, as obtained by `std::thread::get_id()` (or `std::jthread::get_

* @brief Check whether the pool is currently paused. Only enabled if the flag `BS::tp::pause` is enabled in the template parameter. * * @ret

* @brief Returns the internal counter's maximum possible value, which in this implementation is equal to `LeastMaxValue`. * * @return The in

* @brief Compare the priority of two tasks. * * @param lhs The first task. * @param rhs The second task. * @return `true` if the f

* @brief Check if a specific command line argument has been passed to the program. If no arguments were passed, use the default value instead. *

* @brief Pause the pool. The workers will temporarily stop retrieving new tasks out of the queue, although any tasks already executing will keep runni

* @brief Construct a new task with an assigned priority. * * @param task_ The task. * @param priority_ The desired priority. */

* @brief Purge all the tasks waiting in the queue. Tasks that are currently running will not be affected, but any tasks still waiting in the queue wil

* @brief Check how many of the futures stored in this `BS::multi_future` are ready. * * @return The number of ready futures. */

* @brief Reset the pool with the default number of threads (as if constructed with the default constructor). Waits for all tasks to be completed, both

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