The Runtime class was never a good place for inRuntime(): due its
central role in EMPER's architecture, it causes easily include
cycles. Furthermore, the API was not ideal, once we would move Runtime
into emper::, it would become emper::Runtime::inRuntime().

We declare emper::Emper::inRuntime and emper::Emper::assertInRuntime()
as static struct functions to avoid multiple definitions, and then use
a constexpr function "alias" to have those functions available in the
emper:: namespace.

[IO] overhaul SQPOLL support

See merge request !210

[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.

Two meson options control the io_uring sqpoll feature:
* io_uring_sqpoll - enable sq polling
* io_uring_shared_poller - share the polling thread between all io_urings

Since 5.12 the IORING_SETUP_ATTACH_WQ only causes sharing of
poller threads not the work queues.
See: https://github.com/axboe/liburing/issues/349

When using SQPOLL the userspace has no good way to
know how many sqes the kernel has consumed therefore we
wait for available sqes using io_uring_sqring_wait if there
was no usable sqe.

Remove the GlobalIoContext::registerLock and register all worker
io_uring eventfd reads at the beginning of the completer function.
Also register all the worker io_uring eventfds since they never change
and it hopefully reduces overhead in the global io_uring.

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