reduce test load when logging

See merge request !282

I suspect some test which scale whith the number of CPUs to timeout
mostly on jenkins2.
This patch reduces the load when logging is active and increases the
load when logging is off.
Therefore our test build with debugoptimized will do less and hopefully
only timeout when they actually hung and the release test will do
more.

load CQ->tail only once during lockless stealing

See merge request !281

Currently we load the CQ->tail with acquire semantic to determine
if we should steal from teh victim and load it again in the actual
stealing logic which will also immediately abort if there are no
CQEs to steal.

Keep the optimization for the locked case.

EchoClient: improve the help message

See merge request !280

add concurrent BPS test

See merge request !279

echoclient: add a state variable for debugging

See merge request !278

The test introduces multiple cycles of Semaphores and
a Fiber for each semaphore blocking and signaling the next.
Through work-stealing the fibers from a cycle should be spread
across different workers and thus test concurrent use of
BinaryPrivateSemaphores.

Cycle of length 3: Sem A -> Sem B -> Sem C -> Sem A -> ...
Algorithm:
	if isFirstInCycle
		signal next

	wait

	if not isFirstInCycle
		signal next

[PipeSleepStrategy] fix notifyFromAnywhere

See merge request !277

Don't decrease the sleeper count in the CAS loop further than
-count, which is the threshold we need to ensure that the notification
will be observed.
Decreasing it further than our threshold is not faulty it just results
in unnecessary skipped sleeps.

Don't call writeNotifications with a negative count.
Which will be interpreted as an unsigned value and thus results
in writing way to much hints to the pipe, jamming it.
If the original value before a successfully CAS is already negative
we called writeNotifications with this negative value.
This is fixed by using max(toWakeup, 0).

make the victim count in work-stealing configurable

See merge request !276

Add two new mutual exclusive meson_options:
* work_stealing_victim_count: Which sets an absolute number of victims
* work_stealing_victim_denominator: Set victim count to #workers/denominator

[tools] Update check-format (from Mazstab)

See merge request !275

Fixes for clang-tidy 13

See merge request !274

Sync tools/check-format of EMPER and Mazstab by using the newer
Mazstab version of the script.

While we do not have yet LLVM 13 in the gitlab-ci, I use it on my
systems. So fix the new warnings found with clang-tidy 13.

Random computation echoserver

See merge request !272

Ci debian testing dev bump

See merge request !273

Now three variants of computation are available:

* fixed (echoserver <port> <computation>:
   This will always consume computation us before sending the echo
   back to the client.
* random range (echoserver <port> <computation> <computation-max>:
   This will consume a random computation uniformly selected
   from the interval [computation, computation-max] us.
* random min-max (echoserver <port> <computation> <computation-max> <max-probability>
   This will either consume computation or computation-max us.
   The max computation is randomly chosen with the specified probability.

All random values are generated with a thread_local mt19937 generator
and uniformly distributed with uniform_{int,real}_distribution.

This new builder pattern in addition to a more powerful Runtime constructor
allows the user to pass additional new worker hooks.
This is useful for example if an applications wants to initialize
thread local variables on each worker.

Current code does not need any modification and has no semantic changes.
Future code can use the new RuntimeBuilder class to construct
more sophisticated Runtime objects.

[RFC] IO-stealing analogue to work-stealing

See merge request !260

The lockless algorithm can now be configured by setting -Dio_lockless_cq=true
and the used memory ordering by setting -Dio_lockless_memory_order={weak,strong}.

io_lockless_memory_order=weak:
    read with acquire
    write with release

io_lockless_memory_order=strong:
    read with seq_cst
    write with seq_cst

In a running gdb process use:

source tools/gdb/dump_runtime_state.py

to dump the state of all threads, all WSL queues and all worker IoContexts.

[fsearch] remove obsolete offset tracking code

See merge request !271

This is fixed by using a normal lock instead of the try lock in the OWNER
case.

TODO: think about stats and possible ring buffer pointers overflow and ABA.

IO stealing is analog to work-stealing and means that worker thread
without work will try to steal IO completions (CQEs) from other worker's
IoContexts. The work stealing algorithm is modified to check a victims
CQ after findig their work queue empty.

This approach in combination with future additions (global notifications
on IO completions, and lock free CQE consumption) are a realistic candidate
to replace the completer thread without loosing its benefits.

To allow IO stealing the CQ must be synchronized which is already the
case with the IoContext::cq_lock.
Currently stealing workers always try to pop a single CQE (this could
be configurable).
Steal attempts are recorded in the IoContext's Stats object and
successfully stolen IO continuations in the AbstractWorkStealingWorkerStats.

I moved the code transforming CQEs into continuation Fibers from
reapCompletions into a seperate function to make the rather complicated
function more readable and thus easier to understand.

Remove the default CallerEnvironment template arguments to make
the code more explicit and prevent easy errors (not propagating
the caller environment or forgetting the function takes a caller environment).

io::Stats now need to use atomics because multiple thread may increment
them in parallel from EMPER and the OWNER.
And since using std::atomic<T*> in std::map is not easily possible we
use the compiler __atomic_* builtins.

Add, adjust and fix some comments.

The OWNER caller environment can be used when the executed algorithm
should be different if the current worker owns the objects it touches.
For example a worker reaping completions on a foreign IoContext may
use the EMPER callerEnvironment and the worker of the IoContext OWNER.

Also implement the stream operator to print caller environments.

print runtime stats to the environment variable EMPER_STATS_FILE

See merge request !269

* Make all stats print methods accept a std::ostream as output.
* Move the printing of runtime component stats into Runtime::printStats.
* Use Runtime::printStats instead of Runtime::printLastRuntimeStats in
  ~Runtime, because we are already in a runtime which may differ from
  Runtime::currentRuntime.
* Write the stats in ~Runtime to a possible file passed in the
  environment variable EMPER_STATS_FILE

[sleep_strategy/Stats] remove old obsolete stats member

See merge request !270

[Common.hpp] fix CACHE_LINE_EXCLUSIVE macro

See merge request !268