io_uring_submit does some inline error checking and consumes less
cqes than prepared if an error is detected.

Currently we just cancel the Futures, whose prepared sqes were not submitted.
But this leaves already prepared sqes for those futures in the SQ
of the io_uring which will be submitted the next time io_uring_submit
is called.

This results in a violation of the chain guaranty, that dependent operations
are only executed if all dependencies were successful.
Additionally this leads to double completions or memory corruption
because the io_uring will produce cqes for already completed Futures.

To prevent this from happening we track all sqes we prepared to
invalidate and resubmit those which were not submitted because of a short submit.
We invalidate sqes by preparing them as NOP instructions and set their
user data to NULL.

I took this approach instead of rewinding the ring or somethings like
similar because it seemed safer for me not fiddle with io_uring internals
and just be less efficient.

Enable previously failing LinkFutureTest test cases.

Fix compilation error in LinkFutureTest where clsoe was used instead
of closeAndWait.

Debug changes for our Future

See merge request !134

Echo client changes

See merge request !135

While we haven't figured out why the version using linked futures breaks
we can use a simpler implementation which calls submitAndWait on both futures
separately

First of all this replaces the call to sleep(execution_seconds)
which calls POSIX sleep(3) which is definitely not what we want here
blocking one worker thread.

Using a std::thread for termination was chosen because we assume it
will be more precise than the emper native emper::sleep.

Gather stats regarding re-reaps

See merge request !127

Document the encountered failures in code comments.

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.