This test resembles our EchoClient implementation using linked futures.

[Debug] use a lambda to build up the log message

See merge request !133

This hides the used std::stringstream from the context using the LOG macros.
So we don't have to see the a huge messy std::stringstream object in gdb
for example.

The use of a lambda is a ISO C++ alternative to GCC's statement expression.

More debug related changes

See merge request !131

[IO] propagate callerEnvironment to reapCompletion

See merge request !132

* Remove the obsolete EMPER_LOG_OFF check.
* Add LogLevel::Debug to DBG and WDBG

[IO] add execution time option to EchoClient

See merge request !129

[Debug] remove OFF LogLevel, make Info release default, use constexpr everywhere

See merge request !130

[EchoServer] add configurable computation part in us spent busy looping

See merge request !124

Specifying execution time and iterations is not allowed.

Improved echo client

See merge request !128

[IO] make the lock implementation protecting a IoContext's cq configurable 

See merge request !126

This change introduces a new synchronization primitive "PseudoCountingTryLock"
which takes an actual lock as template and provides a CountingTryLock interface.
By using a PseudoCountingTryLock we don't have to change any synchronization
code in IoContext::reapCompletion.

Since all PseudoCountingTryLock code is defined in a header the compiler
should see our constant return values and hopefully optimize away any check
depending on those constant return values.

Options:
* spin_lock - naive CAS spin lock
* mutex - std::mutex
* counting_try_lock (default) - our own lightweight special
                                purpose synchronization primitive

Reduce the critical section of io_uring CQ

See merge request !120

[meson] Fix 'iwyu' target for meson >= 0.57

See merge request !125

Probably avoids dynamic memory allocation done by the previously used
std::vector.

The run_target() function requires an absolute path in meson >= 0.57.

* Open file only when the benchmark was successful
* Append to existing files without writing the header

Nagle's algorithm which tries to prevent small TCP frames is harmful
for our throughput if we send small echos.

Arithmetic means are inaccurate if the sample has extreme outliers
therefore we record and report the total execution times.

[IO] parallelize IO startup

See merge request !122

[meson] remove obsolete io_batch_anywhere_completions option

See merge request !121

GlobalIoContext::registerWorkerIo() now protects the GlobalIoContext's SQ
with a mutex and the globalCompleter waits till all worker's registered
their IoContext with the new Sempahore Runtime.ioReadySem.

Since 8f38dbed the globalCompleter
does always reap and schedule in batches through
IoContest::reapAndSchedule<CallerEnvironment::ANYWHERE> ->
Runtime::scheduleFromAnywhere(Input it begin, InputIt end) ->
AnywhereQueue::insert(Input it begin, InputIt end)

EMPER shutdown

See merge request !111

Fix reap completion race

See merge request !117

Our current naive try lock protecting a worker's IoContext's cq is racy.
This fact alone is no problem a try lock is by design racy in the sense
that two threads race who can take the lock.

The actual problem is:

While a worker is holding the lock additional completions could arrive
which the worker does not observe because it could be already finished
iterating the CQ.

In the case that the worker still holds the lock preventing the globalCompleter
from reaping the additional completions there exists a lost wakeup problem
possibly leading to a completely sleeping runtime with runnable completions
in a worker's IoContext.

To prevent this lost wakeup the cq_lock now counts the unsuccessful
lock attempts from the globalCompleter.

If a worker observes that the globalCompleter tried to reapCompletions
more than once we know that a lost wakeup could have occurred and we try to
reap again.
Observing one attempt is normal since we know the globalCompleter and the
worker owning the IoContext race for the cq_lock required to reap completions.

Additionally:

* Reduce the critical section in which the cq_lock is held by copying all
  seen cqes and completing the Futures after the lock was released.

* Don't immediately schedule blocked Fibers or Callbacks rather collect them
  an return them as batch. Maybe the caller knows better what to to with a
  batch of runnable Fibers

[meson] remove duplicate overflow_queue meson option

See merge request !118