[CI] print the number of available CPUs

See merge request !290

[qsort] fix implicit widening clang-tidy error

See merge request !292

[ConcurrentNetworkEchoTest] add optional computation per echo

See merge request !293

This makes the test closer to our echoserver.

fix {RwLocked,SharedMutex}UnboundedQueues

See merge request !291

A "fast check" consists of our smoke tests and the fast static analysis
this ensures that the emper variants even build successfully and
are not totally broken.

Previous RwLockUnboundedQueue versions did not drop their rw lock
before trying to grab the wr lock which may result in a deadlock.
Also wrap the noisy POSIX functions names in cleaner helper functions.

Introduce waitfree work/io-stealing

See merge request !289

Waitfree IO-stealing can be enabled with the meson option
-Dio_waitfree_stealing.

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