[AbstractWorkStealingScheduler] Get rid of "rand() % workerCount"

See merge request !229

The "rand() % workerCount" constructed used in the work-stealing
scheduler is flawed. It has a bias toward lower worker IDs due the
modulo operation. This is something I always wanted to get rid of, but
never found the time to do it. Until know.

Get rid of it and replace it with
std::uniform_int_distribution<workerid_t> (as field the Worker
instance).

The main changes in AbstractWorkStealingScheduler are
- use currentWorker->nextRandomWorkerId() (instead of the flawed construct)
- currentWorker->getWorkerId() (instead of Runtime::getWorkerId())

[stats] blocked contexts

See merge request !224

Support distributing multiple echoclient over the network

See merge request !228

The Coordinator is used for our echo evaluation and implements
a barrier style synchronization mechanism for processes spread across the network.

[meson] allow building EMPER on systems whithout <filesystem>

See merge request !221

Add meson option for "check anywhere queue while stealing"

See merge request !207

[io.hpp] add blocking functions using timeouts

See merge request !226

[stats] Add max-queue-length stats to AbstractWorkStealingScheduler

See merge request !223

[echoclient] print a short description of parameters

See merge request !225

Add docker tooling

See merge request !219

Check if std::filesystem::recursive_directory_iterator and std::filesystem::path
are available before using those in EMPER code.

We do not export the symbols using the not supported filesystem features
in our public headers using preprocessor ifdef.

But the code in the cpp files using it not removed using the preprocessor.
To allow linkage we use a constexpr which throws a logic_error on runtime
rendering the rest of the code dead und thus prevents its generation by
the compiler.
This methods allows the compiler to see the code in its analysis passes
but does not fail during linking.

Allow meson.build files in emper/ subdirectories add configuration options
by consuming the conf_data object after all subdirectories were visited.

Introduce a quasi naming standard for cpp feature flags in meson code:
	cpp_has_<namespace>_<feature>

Examples:
	cpp_has_fs_path

Usage run "docker.sh <your command>" to execute <your command> in the
docker image extracted from .gitlab-ci.yml in the emper root directory

NOTE: seccomp filtering is disabled for now since io_uring_* syscalls
are not working everywhere as expected.

[fsearch] gracefully terminate the runtime to print the collected stats

See merge request !222

[PipeSleepStrategy] use C++ smart ptrs instead of manual memory management

See merge request !220

The destructor of PipeSleepStrategy caused segmentation faults when
running optimized. Because the stats pointer is not initialized it was
possibly to pass a garbage pointer to delete. Now we use a well defined
C++ smart pointer which fixes the problem and is more idiomatic anyway.

[IoContext] wrap CQ locking in if constexpr

See merge request !218

We don't need to pay the overhead of the atomic operations on each
dispatch loop if there is no concurrent access to worker CQs.

Further improve fsearch

See merge request !217

Improve fsearch

See merge request !215

[Debug] prefix log messages from the I/O completer thread with "IOC"

See merge request !216

Implement sleep strategy using the IO subsystem

See merge request !214

Design goals
============

* Wakeup either on external newWork notifications or on local IO completions
  -> Sleep strategy is sound without the IO completer
* Do as less as possible in a system saturated with work
* Pass a hint where to find new work to suspended workers

Algorithm
=========

Data:
	Global:
		hint pipe
		sleepers count
	Per worker:
		dispatch hint buffer
		in flight flag

Sleep:
	if we have no sleep request in flight
		Atomic increment sleep count
		Remember that we are sleeping
		Prepare read cqe from the hint pipe to dispatch hint buffer
	Prevent the completer from reaping completions on this worker's IoContext
	Wait until IO completions occurred

NotifyEmper(n):
	if observed sleepers <= 0
		return

	// Determine how many we are responsible to wake
	do
		toWakeup = min(observed sleepers, n)
	while (!CAS(sleepers, toWakeup))

	write toWakeup hints to the hint pipe

NotifyAnywhere(n):
	// Ensure all n notifications take effect
	while (!CAS(sleepers, observed sleepers - n))
		if observed sleeping <= -n
			return

	toWakeup = min(observed sleeping, n)
	write toWakeup hints to the hint pipe

onNewWorkCompletion:
	reset in flight flag
	allow completer to reap completions on this IoContext

Notes
=====

* We must decrement the sleepers count on the notifier side to
  prevent multiple notifiers to observe all the same amount of sleepers,
  trying to wake up the same sleepers by writing to the pipe and jamming it up
  with unconsumed hints and thus blocking in the notify write resulting
  in a deadlock.
* The CAS loops on the notifier side are needed because decrementing
  and incrementing the excess is racy: Two notifier can observe the
  sum of both their excess decrement and increment to much resulting in a
  broken counter.
* Add the dispatch hint code in AbstractWorkStealingScheduler::nextFiber.
  This allows workers to check the dispatch hint after there
  where no local work to execute.
  This is a trade-off where we trade slower wakeup - a just awoken worker
  will check for local work - against a faster dispatch hot path when
  we have work to do in our local WSQ.
* The completer tread must not reap completions on the IoContexts of
  sleeping workers because this introduces a race for cqes and a possible
  lost wakeup if the completer consumes the completions before the worker
  is actually waiting for them.
* When notifying sleeping workers from anywhere we must ensure that all
  notifications take effect. This is needed for example when terminating
  the runtime to prevent sleep attempt from worker thread which are
  about to sleep but have not incremented the sleeper count yet.
  We achieve this by always decrementing the sleeper count by the notification
  count.

Thanks to Florian Schmaus <flow@cs.fau.de> for spotting bugs and suggesting
improvements.