LockedSemaphore is the already existening Semaphore using
a mutex and a condition variable.
PosixMutex is a thin wrapper around a POSIX semaphore.
SpuriousFutexSemaphore is a atomic/futex based implementation
prune to spurious wakeups which is fine for the worker wakeup usecase.

[Runtime] Fix skipWakeupThreshold value

See merge request i4/manycore/emper!106

Adjust to sem_getvalue() being allowed to return 0 if there are
waiting workers.

[Runtime] use a semaphore to suspend/wakeup workers

See merge request i4/manycore/emper!99

To prevent deadlocks where all workers are going to sleep and new work
arrives from without emper we always increment the wakeup semaphore
unless we observe its value as > worker count.
If the semaphore value is bigger than worker count it is guarantied that
at least on worker will not block and will iterate a second time
in its dispatchLoop observing the new work.

Fix build for systems with incomplete C++ standard library

See merge request i4/manycore/emper!105

Fix Actor::waitUntilIdle

See merge request !103

[Makefile] fix smoke-test/static-analysis target

See merge request i4/manycore/emper!104

This adds yet another target "smoke-test-suite", which just runs all
tests in the 'smoke' test suite. The static-analysis target was
changed to include *all* static analysis thingies we have, even 'doc'
as Doxygen does also do some checks that the documentation is
"correct".

The smoke-test target is also kept, as it allows developers to simply
run all smoke tests. Furthermore, this adds some missing PHONY
declarations in the Makefile.

The gitlab-ci now runs the smoke-test-suite and static-analysis
targets in two different jobs. Previously the smoke-test would also
run the static-analysis target, which was not intended.

Using an AlarmFuture blocks the Fiber executing Actor::waitUntilIdle,
freeing its current worker and thus preventing life-locks.
Where all workers are sleeping except one.
Which executes the Actor::waitUntilIdle Fiber causing a starvation of
the actual Actor.

[meson] fix version header custom target for meson >= 0.57

See merge request i4/manycore/emper!96

Apparently custom_target no longer supports the @CURRENT_SOURCE_DIR@
and @SOURCE_DIR@ substitutions.
We now locate the script using find_program().
Since meson.project_source_dir() is not available in older meson version
there is a version check.

[IO] replace the std::mutex.try_lock with our own std::atomic based implementation

See merge request i4/manycore/emper!95

[IO] add option to use a common async backend for all io_urings

See merge request i4/manycore/emper!94

[EchoServerCallback] report error value passed to callback not errno

See merge request i4/manycore/emper!93

[IO/Stats] make sure only Future's with a buffer have a completion expectation

See merge request !92

[IO] add FutureError and throw it when wait is called on a Future with callback

See merge request i4/manycore/emper!91

[IO] add output file support to echoclient

See merge request i4/manycore/emper!90

Currently future.len if set is used as completion expectation.
This does not make any sense for Futures using the len field for different
values than a buffer length.
For example the OpenatFuture uses future.len for the flags passed to openat.
Those flags should not be interpreted as an expectation about the completion
value (a file descriptor).

The wait() call on a Future with callback currently will never return
therefore calling wait() is disallowed.

This is useful for my evaluation. Because with an output file I
just have to check if it exists to see if an echoclient execution was
successful.

Improved dying

See merge request !89

This was never reported by the compiler because DIE_MSG treated
its argument as a string. With the new stream formatting support the
compiler sees the undefined symbol flag.

The stream formatting for DIE_MSG is already wrongly used in
IoContext, EchoClient and LawsDispatcher.

[IO] add callback support

See merge request i4/manycore/emper!87

Futures can have a registered Callback of type
std::function<void(const uint32_t&)> which gets called in a new
Fiber with the result of the IO Request.
Note the first completion will cause the execution of a callback and
partial completion support must be implemented manually in the callback.

Callbacks are stored in a heap allocated std::function on registration
and are freed by the new Fiber after the callback returned;

The Future with a registered Callback is not referenced in any way in
the IO subsystem and therefore can be dropped after being submitted.
This also means that a Future with a registered callback will not be
signaled by the IO subsystem on completion.
If signaling is desired one must implement it manually in the registered
callback.

[test] use gtest meson wrap if gtest is not found

See merge request !88

The gtest wrap can be updated with the meson wrap command

Towards fixing modernize-avoid-c-arrays, add template_util::getSize()

See merge request i4/manycore/emper!84