The throttle algorithm had the same problem like our sleep algorithms
where notifications from anywhere may race with a worker going to
sleep resulting in lost wakeups.
In the sleep strategy we prevent those races by preventing sleep attempts
when notifing from anywhere.
The throttle algorithm also does now exactly this. A notifier from anywhere
will now always set the WakeupStrategy state to notified.
If the state was previously pending this new approach does not differ from
the previous behavior and a sleeping worker will be notified.
If the state was waking the waking worker skips its sleep if it observes
the WakeupStrategy state as notified.

std::localtime takes a global lock and is therefore not scalable and
inapplicable for analyzing timing sensible bugs.
Introduce a new option to add UTC timestamps. This allows on my system
to double the CPU load while using mmapped logging.

Also increase the LogBuffer size from 1MB to 1GB because I had some
crashes where a renewed buffer was still used.

* single io_uring
* pipe sleep strategy
* pipe sleep strategy without completer

When setting the environment variable EMPER_LOG_FILE=<logfile> EMPER
will write its log messages to <logfile> instead of stderr.
This removes the need for the mutex protecting std::cerr as well as
multiple write calls to flush std:cerr.

To efficiently write log messages to the log file the algorithm uses
three memory 1MiB mapped views into <logfile> to store the log messages.
One buffer is active, one is new, and one is old.
The next buffer ensures that threads can write log messages even if the
active buffer would overflows.
The old buffer allows slower threads to still write safely while everyone
else uses the active buffer.
When a thread changes from the active buffer to the new buffer it
is responsible to renew the current old buffer and changing the semantic
of the buffers:

* active -> old
* next -> active
* old -> next

This buffer scheme allows wait-free logging.
But the approach is NOT sound because delayed thread may still use the
old buffer which gets renewed by the first thread touching the next buffer.
But the likeliness for this situation decreases with bigger sizes of the
buffers.

ATTENTION: Using SCHED_IDLE for the completer may break this likeliness
assumption.

Add new CI test job with mmaped log files.

This contains code cleanups
Suggested-By: Florian Schmaus <flow@cs.fau.de>

The EMPER option Meson option for stats is called 'stats' not
'worker_stats'.

This required that we backport iwyu_tool.py from
https://github.com/include-what-you-use/include-what-you-use/pull/891
into tools/, which supports --load.

This should improve the CI response time, as we now (potentially)
perform iwyu and clang-tidy in parallel.

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.

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.

The 'static-analysis' Make target runs all static analysis we
currently have. This allows to run at least static analysis, in cases
where we are able build a particular EMPER configuration, but no able
to execute it (e.g. because the kernel lacks io_uring support).

This also changes emper_log so that a std::ostringstream is used to
assemble the log message.

Co-authored-by: Florian Fischer <florian.fl.fischer@fau.de>

And fix the #include issues reported by the newer IWYU version.

The default flavor is the preferred way to use the userspace library it uses
the sys_membarrier syscall or falls back to using userspace membarriers.

This adds the liburcu dependency which must be installed regardless the
'liburcu' meson option.