According to godbolt.org

do { if constexpr(false) { break; } int foo = 42; foo++; } while(false);

does result in code generation for gcc 10.2 and clang 11.0.1 as opposed to

do { if constexpr(false) { int foo = 42; foo++; }} while(false);

which does not result in code generation for both gcc and clang.

And this simple change did indeed significantly increases our echo
benchmark performance. We were probably creating a lot of std::stringstream
objects without ever using them.

[Makefile] Make ninja consider the load average

See merge request !149

[Runtime] print stats in the destructor not at exit

See merge request !147

Various test-runner improvements

Closes #14

See merge request !142

[io/Stats] introduce named constants for special workerIds

See merge request !148

Allocate the Actor and the BPS on the heap as otherwise Fibers may
access already destructed Actor data.

While this does not fix anything, it appears sensible that we call
stop() prior destruction.

This should, at least for the EXIT_SUCCESS case, fix #14.

The test fixture will automatically assume that the test was
successful if emperTest() returns.

Resetting the Future on the last iteration may cause the assert that
the Future was never awaited to trigger (which is in the Future's destructor).

There was no reason that invokeTest() is part of the test-runner API.

[tests] Do not set EMPER_STACKTRACE_ON_ABORTS

See merge request !146

Stack unwinding via ligbcc does not (yet) work correctly within
EMPER. As result, the unwinding often causes a segfault shadowing the
actual cause.

[IO] make the behavior of the completer thread configurable

See merge request !143

reduce log level for io_uring_submit -> -EBUSY message and fix TIME_NS

See merge request !144

[Debug] s/WDBG/DBG and always terminate a log messager with a new line

See merge request !145

Rename the macro used to build up the debug message, to better reflect
its generality.
It can be used anywhere to build a string with C++ stream formatting.
std::string s = EMPER_BUILD_STR("foo = " << 1 " , bar = " << bar(42));

Since WDBG was the only log macro without a terminating newline, which
was in fact broken according to flow, we can remove it and the new line
handling code in the LOG macro.

Available behaviors:
  * none - the completer thread is not started

  * schedule (default) - the completer thread will reap and schedule available
                         completions from worker IoContexts

  * wakeup - the completer thread will wakeup all workers if it observes completions
             in a worker IoContext. The Fiber produced by the completion will
             be scheduled when the worker in which's IoContext the cqe lies
             reaps its completions.

TIME_NS was never expanded because emper-config.h was not included
in Common.hpp.

The log_level is reduced from Info to Debug because the IoContext reqs_in_uring
has only in debug builds a meaningful value.
And the fact that there where a full CQ during io_uring_submit is captured in the stats
anyway.

Don't record a full CQ before dying in the completer.

[Debug] don't append new line to log message

See merge request !141

Let the user of emper_log decide if they want a newline (most LOGX macros
do expect WDBG).

Currently since most LOGX macros append a new line to the log message
and emper_log adds one unconditionally we end up with an unnecessary
empty line per log message.

[gitlab-ci] Save meson-logs as artifact, add meson junit report

See merge request !139

Provider worker ID in "new worker" hook and change workerid_t from uint8_t to uint16_t.

See merge request !138

8 bits are not enough for some systems. This also means that
workeraffinity_t has to be increased.

Fix submit of invalid Future chains

Closes #13

See merge request !136

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] declare LOG_STR_LAMBDA's return type because gcc 8.3 can't infer it

See merge request !137

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.