feat: Use buffer pool for logging

toolbox/sys/Log.hpp

@@ -46,7 +46,11 @@ class Log {
     , level_{level}
     , os_{log_stream()}
     {
-        os_.set_storage(os_.make_storage());
+        LogMsgPtr storage;
+        if (!log_buf_pool().pop(storage)) [[unlikely]] {
+            storage = LogStream::make_storage();
+        }
+        os_.set_storage(std::move(storage));
     }
     ~Log()
     {

toolbox/sys/Log.ut.cpp

@@ -44,6 +44,9 @@ struct TestLogger final : Logger {
     void do_write_log(WallTime /*ts*/, LogLevel level, int /*tid*/, LogMsgPtr&& msg,
                       size_t size) noexcept override
     {
+        const auto finally = make_finally([&]() noexcept {
+            log_buf_pool().bounded_push(std::move(msg));
+        });
         last_level = level;
         last_msg.assign(static_cast<const char*>(msg.get()), size);
     }

toolbox/sys/Logger.cpp

@@ -16,6 +16,8 @@
 
 #include "Logger.hpp"
 
+#include <toolbox/util/Finally.hpp>
+
 #include <atomic>
 #include <mutex>
 
@@ -61,17 +63,34 @@ inline pid_t gettid()
 }
 #endif
 
+struct LogBufPoolWrapper {
+    static constexpr std::size_t InitialPoolSize = 8;
+    LogBufPoolWrapper()
+    {
+        for ([[maybe_unused]] std::size_t i = 0; i < InitialPoolSize; i++) {
+            pool.bounded_push(util::make_storage<MaxLogLine>());
+        }
+    }
+    LogBufPool pool;
+};
+static LogBufPoolWrapper log_buf_pool_{};
+
 class NullLogger final : public Logger {
-    void do_write_log(WallTime /*ts*/, LogLevel /*level*/, int /*tid*/, LogMsgPtr&& /*msg*/,
+    void do_write_log(WallTime /*ts*/, LogLevel /*level*/, int /*tid*/, LogMsgPtr&& msg,
                       size_t /*size*/) noexcept override
     {
+        log_buf_pool().bounded_push(std::move(msg));
     }
 } null_logger_;
 
 class StdLogger final : public Logger {
     void do_write_log(WallTime ts, LogLevel level, int tid, LogMsgPtr&& msg,
                       size_t size) noexcept override
     {
+        const auto finally = make_finally([&]() noexcept {
+            log_buf_pool().bounded_push(std::move(msg));
+        });
+
         const auto t{WallClock::to_time_t(ts)};
         tm tm;
         localtime_r(&t, &tm);
@@ -107,6 +126,10 @@ class SysLogger final : public Logger {
     void do_write_log(WallTime /*ts*/, LogLevel level, int /*tid*/, LogMsgPtr&& msg,
                       size_t size) noexcept override
     {
+        const auto finally = make_finally([&]() noexcept {
+            log_buf_pool().bounded_push(std::move(msg));
+        });
+
         int prio;
         switch (level) {
         case LogLevel::None:
@@ -152,6 +175,11 @@ inline Logger& acquire_logger() noexcept
 
 } // namespace
 
+LogBufPool& log_buf_pool() noexcept
+{
+    return log_buf_pool_.pool;
+}
+
 Logger& null_logger() noexcept
 {
     return null_logger_;
@@ -244,7 +272,7 @@ void AsyncLogger::do_write_log(WallTime ts, LogLevel level, int tid, LogMsgPtr&&
         // and prevents crashes caused by an out-of-memory situation during rare log-burst spikes.
     }
     // Failed to push the task, restore ownership of msg_ptr.
-    LogMsgPtr{msg_ptr};
+    log_buf_pool().bounded_push(LogMsgPtr{msg_ptr});
 }
 
 } // namespace sys

toolbox/sys/Logger.hpp

@@ -17,14 +17,16 @@
 #ifndef TOOLBOX_SYS_LOGGER_HPP
 #define TOOLBOX_SYS_LOGGER_HPP
 
-#include <boost/lockfree/queue.hpp>
-#include <thread>
-
 #include <toolbox/sys/Limits.hpp>
 #include <toolbox/sys/Time.hpp>
 #include <toolbox/util/Storage.hpp>
 #include <toolbox/util/Concepts.hpp>
 
+#include <boost/lockfree/queue.hpp>
+#include <boost/lockfree/stack.hpp>
+
+#include <thread>
+
 namespace toolbox {
 inline namespace sys {
 
@@ -50,6 +52,11 @@ enum class LogLevel : int {
 };
 
 using LogMsgPtr = StoragePtr<MaxLogLine>;
+inline constexpr std::size_t LogBufPoolCapacity = 64;
+using LogBufPool = boost::lockfree::stack<LogMsgPtr, boost::lockfree::capacity<LogBufPoolCapacity>>;
+
+/// A pool of log buffers, eliminating the need for dynamic memory allocations when logging
+TOOLBOX_API LogBufPool& log_buf_pool() noexcept;
 
 /// Null logger. This logger does nothing and is effectively /dev/null.
 TOOLBOX_API Logger& null_logger() noexcept;