Waitfree work stealing is configured with the meson option
'waitfree_work_stealing'.

The retry logic is intentionally left in the Queues and not lifted to
the scheduler to reuse the load of an unsuccessful CAS.

Consider the following pseudo code examples:

steal() -> bool:                       steal() -> res
  load                                   load
loop:                                    if empty return EMPTY
  if empty return EMPTY                  cas
  cas                                    return cas ? STOLEN : LOST_RACE
  if not WAITFREE and not cas:
    goto loop                          outer():
  return cas ? STOLEN : LOST_RACE      loop:
                                         res = steal()
outer():                                 if not WAITFREE and res == LOST_RACE:
  steal()                                  goto loop

In the right example the value loaded by a possible unsuccessful CAS
can not be reused. And a loop of unsuccessful CAS' will result in
double loads.

The retries are configurable through a template variable maxRetries.
* maxRetries < 0: indefinitely retries
* maxRetries >= 0: maxRetries

Multiple changes to improve IO stealing

See merge request !288

This has the benefit of adequat sized intermediate arrays reducing
the needed stack size.

[gitlab-ci] Cache subprojects/packagecache

See merge request !287

This removes the rather expensive (reported by perf) initialization
of the std::arrays.

To distinguish the outcomes of the waitfree reap attempt a new
enum StealingResult::{Empty, LostRace, Stolen} is introduced.

Fix includes (as reported by IWYU 0.17) and update CI container image

See merge request !285

[meson] set check_anywhere_queue_while_steal automatic

See merge request !286

We introduced the check_anywhere_queue_while_steal configuration
as an optimization to get the IO completions reaped by the completer
faster into the normal WSQ.
But now the emper has configurations where we don't use a completer
thus making this optimization useless or rather harmful.

By default automatically decide the value of
check_anywhere_queue_while_stealing based on the value of
io_completer_behavior.

[io/Stats] do not record steal attempts

See merge request !284

Recording every steal attempt is rather excessive and we are not doing
it for normal work.
Flamegraphs have show io-stealing takes considerable more time
than normal work stealing because of the recording of steal attempts,
especially if we are using atomics to aggregate them.

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.