Method parallelFor

include/tev/ThreadPool.h:133–167

    template <std::integral Int, std::invocable<Int> F>
    Task<void> parallelFor(Int start, Int end, size_t approxCost, F body, int priority) {
        const Int range = end - start;
        const Int n = nTasks(start, end, approxCost);

        std::vector<Task<void>> tasks;

        {
            // The task queue is already thread-safe due to the lock in enqueueTask, but we can optimize a bit by locking only once for all
            // tasks.
            const std::scoped_lock lock{mTaskQueueMutex};

            for (Int i = 0; i < n; ++i) {
                Int taskStart = start + (range * i / n);
                Int taskEnd = start + (range * (i + 1) / n);
                TEV_ASSERT(taskStart != taskEnd, "Should not produce tasks with empty range.");

                tasks.emplace_back(enqueueCoroutine(
                    [taskStart, taskEnd, &body]() -> Task<void> {
                        for (Int j = taskStart; j < taskEnd; ++j) {
                            if constexpr (is_coroutine_callable_v<F, Int>) {
                                co_await body(j);
                            } else {
                                body(j);
                            }
                        }

                        co_return; // Make sure this is a coroutine even if body() is not a coroutine
                    },
                    priority
                ));
            }
        }

        co_await awaitAll(tasks);
    }

    size_t numThreads() const { return mNumThreads; }