parallel_for is much slower than std::for_each with std::execution::par

[dontweaks]

Hi. I want to update 1 million particles and I decided to check if the standard version is checking out, and I found that the standard version is much faster. I ran this code in benchmark_JobSystem.cpp

#include <execution>

#include "PerformanceCounters.h"

#include <utils/JobSystem.h>
#include <utils/compiler.h>

#include <benchmark/benchmark.h>

using namespace utils;

static void BM_JobSystem512_32(benchmark::State& state) {
	JobSystem js;
	js.adopt();

	std::vector<int> data(1000000);

	for (auto _ : state) {
		auto job = jobs::parallel_for(js, nullptr, data.data(), data.size(), [](auto...) {}, jobs::CountSplitter<512, 32>());
		js.runAndWait(job);
	}

	js.emancipate();
}

static void BM_JobSystem128_32(benchmark::State& state) {
	JobSystem js;
	js.adopt();

	std::vector<int> data(1000000);

	for (auto _ : state) {
		auto job = jobs::parallel_for(js, nullptr, data.data(), data.size(), [](auto...) {}, jobs::CountSplitter<128, 32>());
		js.runAndWait(job);
	}

	js.emancipate();
}

static void BM_JobSystem32_12(benchmark::State& state) {
	JobSystem js;
	js.adopt();

	std::vector<int> data(1000000);

	for (auto _ : state) {
		auto job = jobs::parallel_for(js, nullptr, data.data(), data.size(), [](auto...) {}, jobs::CountSplitter<32>());
		js.runAndWait(job);
	}

	js.emancipate();
}

static void BM_JobSystem16_12(benchmark::State& state) {
	JobSystem js;
	js.adopt();

	std::vector<int> data(1000000);

	for (auto _ : state) {
		auto job = jobs::parallel_for(js, nullptr, data.data(), data.size(), [](auto...) {}, jobs::CountSplitter<16>());
		js.runAndWait(job);
	}

	js.emancipate();
}

static void BM_ForEachUnseq(benchmark::State& state) {
	std::vector<int> data(1000000);

	for (auto _ : state) {
		std::for_each(std::execution::par_unseq, data.begin(), data.end(), [](auto...) {});
	}
}
static void BM_ForEachPar(benchmark::State& state) {
	std::vector<int> data(1000000);

	for (auto _ : state) {
		std::for_each(std::execution::par, data.begin(), data.end(), [](auto...) {});
	}
}

BENCHMARK(BM_JobSystem512_32);
BENCHMARK(BM_JobSystem128_32);
BENCHMARK(BM_JobSystem32_12);
BENCHMARK(BM_JobSystem16_12);
BENCHMARK(BM_ForEachUnseq);
BENCHMARK(BM_ForEachPar);

here's result:

It's a debug build but the release is the same story.

Should I use the std::for_each version then?

System: Windows 10
CPU i7 7600k

[pixelflinger]

Well, currently, as far as I can tell, std::execution::par_unseq doesn't do anything (I tested with GCC) it's just doing a regular single threaded for_each. And since your workload is nothing, it just does nothing.

JobSystem is really not optimized for very small tasks, so you will get a fair amount of overhead just scheduling the (empty) jobs.

A more relevant test would be to actually process some data. Also I as said, JobSystem is not very good with very small loads -- and since std::execution::par_unseq is actually cheating by not running things in parallel it could be faster with very small loads, because JobSystem has some overhead there.

In filament we're careful to give JobSystem (many) decent-sized jobs