[wdconinc]

Stacked on #41.

Summary

New core/tests/multithreading.cpp tests concurrent use as in multithreaded frameworks:

• process() on one shared algorithm instance from 8 threads;
• constructing and configuring algorithms concurrently;
• reading properties concurrently;
• logging from many threads, both plain/formatted and stream messages;
• first access of the same service, and of different services, concurrently;
• a Generator shared between threads, and per-thread generators sharing one engine. Full-range draws must all be distinct.

The AlgorithmSvc lifecycle test also creates, lists and adds algorithms concurrently. The tsan job from #41 runs all of this to catch races that do not change results.

The tests found two thread-safety bugs, fixed here in separate commits:

1. Service registration was not thread-safe. When different services were first accessed from several threads at once, ServiceSvc::registerService modified the registry concurrently, which corrupted it (TSan: data races, heap-use-after-free). The registry is now guarded by a recursive mutex. It is recursive because initializers can access, and so register, other services.
2. Logger streams mixed up concurrent messages. LoggerMixin returned one shared stream per log level and locked each <<, not whole messages. Threads logging through one logger produced fragments like "6stream 0". critical() ... trace() now return a new stream per call:
   • Its buffer is only created above threshold, so suppressed messages stay cheap.
   • Output without endmsg is reported at the end of the statement, instead of being prepended to the next message.
   • LoggerMixin stays non-copyable.
   • EICrecon only uses x() << ... << endmsg, which is unaffected.

Test plan

• Locally in eic_xl:nightly: 95/95 tests pass with TSan, ASan+UBSan, clang++ Debug, g++ Debug and g++ Release
• Without the two fixes, TSan reports the registry race and the logger stream test fails
• CI

🤖 Generated with Claude Code

[Copilot]

🔵 Needs a closer look

The concurrency rework of the shared registry and framework-wide logger redesign depend on sanitizer/TSan verification that has not yet passed in CI, leaving correctness unconfirmed.

No open issues 🎉

What changed in this PR

This PR adds a dedicated multithreading test suite that exercises the algorithms core framework as it would be used by concurrent frameworks (shared process(), concurrent construction/configuration, concurrent property reads, concurrent logging, concurrent first-access of services, and shared/parallel random generators). Running these under the thread sanitizer surfaced two real races, which are fixed in the same PR: non-thread-safe service registration and interleaved logger stream messages.

Changes:

• Guard the ServiceSvc registry with a mutable std::recursive_mutex (recursive because initializers can register other services) across all registry reads/writes.
• Redesign LoggerMixin/LoggerStream so each critical()/…/trace() call returns a fresh stream by value with a lazily-created buffer (suppressed messages stay cheap) that flushes unflushed output on destruction; LoggerMixin is explicitly non-copyable.
• Add core/tests/multithreading.cpp, a concurrent block in algorithm_svc.cpp, a new unflushed-stream test in logger.cpp, and link Threads::Threads.

File	Description
core/​include/​algorithms/​service.h	Adds recursive-mutex locking to registry mutators/accessors; documents services() as unprotected.
core/​include/​algorithms/​logger.h	Per-call LoggerStream returned by value with lazy buffer and destructor flush; LoggerMixin made explicitly non-copyable; level() simplified.
core/​tests/​multithreading.cpp	New suite covering concurrent algorithms, logging, properties, services, and RNG.
core/​tests/​logger.cpp	New test for reporting unflushed stream output at statement end.
core/​tests/​algorithm_svc.cpp	Adds concurrent create/list/add lifecycle checks.
core/​tests/​CMakeLists.txt	Finds and links Threads::Threads for all test executables.

_{Review effort: Balanced}