Complete rework of pre-allocated static buffer strategy. No buffers are being created more than once

Author: ChristianPanov

.github/workflows/linux.yml

@@ -3,9 +3,9 @@ name: Linux
 on:
   workflow_dispatch:
   push:
-    branches: [ "master" ]
+    branches: [ "master", "experimental" ]
   pull_request:
-    branches: [ "master" ]
+    branches: [ "master", "experimental" ]
 
 env:
   BUILD_TYPE: Release

.github/workflows/macOS.yml

@@ -3,9 +3,9 @@ name: macOS
 on:
   workflow_dispatch:
   push:
-    branches: [ "master" ]
+    branches: [ "master", "experimental" ]
   pull_request:
-    branches: [ "master" ]
+    branches: [ "master", "experimental" ]
 
 jobs:
   build:

.github/workflows/static_analysis.yml

@@ -3,9 +3,9 @@ name: Static Analysis
 on:
   workflow_dispatch:
   push:
-    branches: [ "master" ]
+    branches: [ "master", "experimental" ]
   pull_request:
-    branches: [ "master" ]
+    branches: [ "master", "experimental" ]
 
 env:
   BUILD_TYPE: Release

.github/workflows/windows.yml

@@ -3,9 +3,9 @@ name: Windows
 on: 
   workflow_dispatch:
   push:
-    branches: [ "master" ]
+    branches: [ "master", "experimental" ]
   pull_request:
-    branches: [ "master" ]
+    branches: [ "master", "experimental" ]
 
 env:
   BUILD_TYPE: Release

Sandbox/Sandbox.cpp

@@ -5,7 +5,7 @@
 static size_t allocation_count = 0;
 
 // Override global new operator
-void* operator new(size_t size) 
+void* operator new(size_t size)
 {
 	++allocation_count;
 	return std::malloc(size); // Use malloc for allocation
@@ -15,23 +15,23 @@ int main()
 {
 	using logger_config = lwlog::configuration<
 		lwlog::disable_local_time,
-		lwlog::disable_thread_id, 
+		lwlog::disable_thread_id,
 		lwlog::disable_process_id,
 		lwlog::disable_topics
 	>;
 
 	auto console = std::make_shared<
 		lwlog::logger<
-			lwlog::default_config,
-			lwlog::default_memory_buffer_limits,
-			lwlog::asynchronous_policy<
-				lwlog::default_overflow_policy,
-				lwlog::default_async_queue_size,
-				lwlog::default_thread_affinity
-			>,
-			lwlog::immediate_flush_policy,
-			lwlog::single_threaded_policy,
-			lwlog::sinks::stdout_sink
+		lwlog::default_config,
+		lwlog::default_memory_buffer_limits,
+		lwlog::asynchronous_policy<
+			lwlog::default_overflow_policy,
+			lwlog::default_async_queue_size,
+			lwlog::default_thread_affinity
+		>,
+		lwlog::immediate_flush_policy,
+		lwlog::single_threaded_policy,
+		lwlog::sinks::stdout_sink
 		>
 	>("CONSOLE");
 

lwlog/src/buffer_limits.h

@@ -40,12 +40,15 @@ namespace lwlog
 		static constexpr std::size_t arg_count{ ArgCountLimit::Value };
 		static constexpr std::size_t padding{ PaddingLimit::Value };
 		static constexpr std::size_t conversion{ ConvLimit::Value };
+
+		static constexpr std::size_t pool_size{ 8 };
+
 	};
 
-	using default_pattern_limit = pattern_limit<512>;
-	using default_message_limit = message_limit<256>;
-	using default_argument_limit = argument_limit<24>;
-	using default_arg_count_limit = arg_count_limit<10>;
+	using default_pattern_limit = pattern_limit<256>;
+	using default_message_limit = message_limit<128>;
+	using default_argument_limit = argument_limit<12>;
+	using default_arg_count_limit = arg_count_limit<4>;
 	using default_padding_limit = padding_limit<24>;
 	using default_conv_limit = conv_limit<64>;
 

lwlog/src/details/argument_formatter/argument_buffers_pool.h

@@ -0,0 +1,21 @@
+#pragma once
+
+namespace lwlog::details
+{
+    template<typename BufferLimits>
+    class argument_buffers_pool
+    {
+    public:        
+        argument_buffers_pool();
+        std::uint8_t acquire_args_buffer();
+        void release_args_buffer(std::uint8_t idx);
+        char(*get_args_buffer(std::uint8_t idx))[BufferLimits::arg_count][BufferLimits::argument];
+
+    private:
+        char m_args_buffers[BufferLimits::pool_size][BufferLimits::arg_count][BufferLimits::argument];
+        std::uint8_t m_args_buffers_free_indices[BufferLimits::pool_size];
+        std::atomic<std::uint8_t> m_args_buffers_free_top;
+    };
+}
+
+#include "argument_buffers_pool_impl.h"

lwlog/src/details/argument_formatter/argument_buffers_pool_impl.h

@@ -0,0 +1,48 @@
+#pragma once
+
+namespace lwlog::details
+{
+    template<typename BufferLimits>
+    argument_buffers_pool<BufferLimits>::argument_buffers_pool()
+        : m_args_buffers_free_top{ BufferLimits::pool_size }
+    {
+        for (std::uint8_t i = 0; i < BufferLimits::pool_size; ++i)
+        {
+            m_args_buffers_free_indices[i] = i;
+        }
+    }
+
+    template<typename BufferLimits>
+    std::uint8_t argument_buffers_pool<BufferLimits>::acquire_args_buffer()
+    {
+        std::uint8_t old_top{ m_args_buffers_free_top.load(std::memory_order_acquire) };
+        while (old_top > 0)
+        {
+            if (m_args_buffers_free_top.compare_exchange_weak(old_top, old_top - 1, std::memory_order_acq_rel))
+            {
+                return m_args_buffers_free_indices[old_top - 1];
+            }
+        }
+
+        return 0;
+    }
+
+    template<typename BufferLimits>
+    void argument_buffers_pool<BufferLimits>::release_args_buffer(std::uint8_t idx)
+    {
+        std::uint8_t old_top{ m_args_buffers_free_top.load(std::memory_order_acquire) };
+        while (old_top < static_cast<std::uint8_t>(BufferLimits::pool_size))
+        {
+            if (m_args_buffers_free_top.compare_exchange_weak(old_top, old_top + 1, std::memory_order_acq_rel))
+            {
+                m_args_buffers_free_indices[old_top] = idx;
+                break;
+            }
+        }
+    }
+    template<typename BufferLimits>
+    char(*argument_buffers_pool<BufferLimits>::get_args_buffer(std::uint8_t idx))[BufferLimits::arg_count][BufferLimits::argument]
+    {
+        return &m_args_buffers[idx];
+    }
+}