move unbounded_queue_max_capacity to ctor

Author: odygrd

examples/bounded_dropping_queue_frontend.cpp

@@ -27,6 +27,7 @@ struct CustomFrontendOptions
   static constexpr size_t initial_queue_capacity = 256;
 
   static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
+  static constexpr size_t unbounded_queue_max_capacity = 2ull * 1024u * 1024u * 1024u;
   static constexpr quill::HugePagesPolicy huge_pages_policy = quill::HugePagesPolicy::Never;
 };
 

examples/custom_frontend_options.cpp

@@ -16,6 +16,7 @@ struct CustomFrontendOptions
   static constexpr quill::QueueType queue_type = quill::QueueType::BoundedDropping;
   static constexpr size_t initial_queue_capacity = 131'072;
   static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
+  static constexpr size_t unbounded_queue_max_capacity = 2ull * 1024u * 1024u * 1024u;
   static constexpr quill::HugePagesPolicy huge_pages_policy = quill::HugePagesPolicy::Never;
 };
 

include/quill/Logger.h

@@ -362,13 +362,7 @@ class LoggerImpl : public detail::LoggerBase
     if constexpr (using_unbounded_queue)
     {
       // MSVC doesn't like the template keyword, but every other compiler requires it
-#if defined(_MSC_VER)
-      return thread_context->get_spsc_queue<frontend_options_t::queue_type>().prepare_write(
-        total_size, frontend_options_t::unbounded_queue_max_capacity);
-#else
-      return thread_context->get_spsc_queue<frontend_options_t::queue_type>()
-        .template prepare_write<frontend_options_t::unbounded_queue_max_capacity>(total_size);
-#endif
+      return thread_context->get_spsc_queue<frontend_options_t::queue_type>().prepare_write(total_size);
     }
     else
     {

include/quill/core/ThreadContextManager.h

@@ -59,13 +59,14 @@ class ThreadContext
 
 public:
   /***/
-  ThreadContext(QueueType queue_type, size_t initial_queue_capacity, HugePagesPolicy huge_pages_policy)
+  ThreadContext(QueueType queue_type, size_t initial_queue_capacity,
+                QUILL_MAYBE_UNUSED size_t unbounded_queue_max_capacity, HugePagesPolicy huge_pages_policy)
     : _queue_type(queue_type)
   {
     if (has_unbounded_queue_type())
     {
       new (&_spsc_queue_union.unbounded_spsc_queue)
-        UnboundedSPSCQueue{initial_queue_capacity, huge_pages_policy};
+        UnboundedSPSCQueue{initial_queue_capacity, unbounded_queue_max_capacity, huge_pages_policy};
     }
     else if (has_bounded_queue_type())
     {
@@ -330,8 +331,10 @@ class ScopedThreadContext
 {
 public:
   /***/
-  ScopedThreadContext(QueueType queue_type, uint32_t spsc_queue_capacity, HugePagesPolicy huge_pages_policy)
-    : _thread_context(std::make_shared<ThreadContext>(queue_type, spsc_queue_capacity, huge_pages_policy))
+  ScopedThreadContext(QueueType queue_type, size_t initial_queue_capacity,
+                      size_t unbounded_queue_max_capacity, HugePagesPolicy huge_pages_policy)
+    : _thread_context(std::make_shared<ThreadContext>(
+        queue_type, initial_queue_capacity, unbounded_queue_max_capacity, huge_pages_policy))
   {
 #ifndef NDEBUG
     // Thread-local flag to track if an instance has been created for this thread.
@@ -389,7 +392,8 @@ template <typename TFrontendOptions>
 QUILL_NODISCARD QUILL_ATTRIBUTE_HOT ThreadContext* get_local_thread_context() noexcept
 {
   thread_local ScopedThreadContext scoped_thread_context{
-    TFrontendOptions::queue_type, TFrontendOptions::initial_queue_capacity, TFrontendOptions::huge_pages_policy};
+    TFrontendOptions::queue_type, TFrontendOptions::initial_queue_capacity,
+    TFrontendOptions::unbounded_queue_max_capacity, TFrontendOptions::huge_pages_policy};
 
   return scoped_thread_context.get_thread_context();
 }

include/quill/core/UnboundedSPSCQueue.h

@@ -71,9 +71,11 @@ class UnboundedSPSCQueue
   /**
    * Constructor
    */
-  explicit UnboundedSPSCQueue(size_t initial_bounded_queue_capacity,
-                              HugePagesPolicy huge_pages_policy = quill::HugePagesPolicy::Never)
-    : _producer(new Node(initial_bounded_queue_capacity, huge_pages_policy)), _consumer(_producer)
+  UnboundedSPSCQueue(size_t initial_bounded_queue_capacity, size_t max_capacity,
+                     HugePagesPolicy huge_pages_policy = quill::HugePagesPolicy::Never)
+    : _max_capacity(max_capacity),
+      _producer(new Node(initial_bounded_queue_capacity, huge_pages_policy)),
+      _consumer(_producer)
   {
   }
 
@@ -105,13 +107,7 @@ class UnboundedSPSCQueue
    * making it visible to the consumer.
    * @return a valid point to the buffer
    */
-#if defined(_MSC_VER)
-  // MSVC doesn't like this as template <QueueType queue_type> when called from Logger, while it compiles on MSVC there will be false positives from clang-tidy
-  QUILL_NODISCARD QUILL_ATTRIBUTE_HOT std::byte* prepare_write(size_t nbytes, size_t unbounded_queue_max_capacity)
-#else
-  template <size_t unbounded_queue_max_capacity>
   QUILL_NODISCARD QUILL_ATTRIBUTE_HOT std::byte* prepare_write(size_t nbytes)
-#endif
   {
     // Try to reserve the bounded queue
     std::byte* write_pos = _producer->bounded_queue.prepare_write(nbytes);
@@ -121,11 +117,7 @@ class UnboundedSPSCQueue
       return write_pos;
     }
 
-#if defined(_MSC_VER)
-    return _handle_full_queue(nbytes, unbounded_queue_max_capacity);
-#else
-    return _handle_full_queue<unbounded_queue_max_capacity>(nbytes);
-#endif
+    return _handle_full_queue(nbytes);
   }
 
   /**
@@ -244,12 +236,7 @@ class UnboundedSPSCQueue
 
 private:
   /***/
-#if defined(_MSC_VER)
-  QUILL_NODISCARD std::byte* _handle_full_queue(size_t nbytes, size_t unbounded_queue_max_capacity)
-#else
-  template <size_t unbounded_queue_max_capacity>
   QUILL_NODISCARD std::byte* _handle_full_queue(size_t nbytes)
-#endif
   {
     // Then it means the queue doesn't have enough size
     size_t capacity = _producer->bounded_queue.capacity() * 2ull;
@@ -258,9 +245,9 @@ class UnboundedSPSCQueue
       capacity = capacity * 2ull;
     }
 
-    if (QUILL_UNLIKELY(capacity > unbounded_queue_max_capacity))
+    if (QUILL_UNLIKELY(capacity > _max_capacity))
     {
-      if (nbytes > unbounded_queue_max_capacity)
+      if (nbytes > _max_capacity)
       {
         QUILL_THROW(
           QuillError{"Logging single messages larger than the configured maximum queue capacity "
@@ -274,7 +261,7 @@ class UnboundedSPSCQueue
                      std::to_string(capacity) +
                      " bytes\n"
                      "Configured maximum queue capacity: " +
-                     std::to_string(unbounded_queue_max_capacity) + " bytes"});
+                     std::to_string(_max_capacity) + " bytes"});
       }
 
       // we reached the unbounded_queue_max_capacity we won't be allocating more
@@ -335,6 +322,8 @@ class UnboundedSPSCQueue
   }
 
 private:
+  size_t _max_capacity;
+
   /** Modified by either the producer or consumer but never both */
   alignas(QUILL_CACHE_LINE_ALIGNED) Node* _producer{nullptr};
   alignas(QUILL_CACHE_LINE_ALIGNED) Node* _consumer{nullptr};

test/integration_tests/BoundedBlockingQueueTest.cpp

@@ -17,6 +17,7 @@ struct CustomFrontendOptions
   static constexpr quill::QueueType queue_type = quill::QueueType::BoundedBlocking;
   static constexpr size_t initial_queue_capacity = 131'072;
   static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
+  static constexpr size_t unbounded_queue_max_capacity = 2ull * 1024u * 1024u * 1024u;
   static constexpr quill::HugePagesPolicy huge_pages_policy = quill::HugePagesPolicy::Never;
 };
 

test/integration_tests/BoundedDroppingQueueDropMessagesTest.cpp

@@ -17,6 +17,7 @@ struct CustomFrontendOptions
   static constexpr quill::QueueType queue_type = quill::QueueType::BoundedDropping;
   static constexpr size_t initial_queue_capacity = 1024;
   static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
+  static constexpr size_t unbounded_queue_max_capacity = 2ull * 1024u * 1024u * 1024u;
   static constexpr quill::HugePagesPolicy huge_pages_policy = quill::HugePagesPolicy::Never;
 };
 

test/integration_tests/BoundedDroppingQueueTest.cpp

@@ -17,6 +17,7 @@ struct CustomFrontendOptions
   static constexpr quill::QueueType queue_type = quill::QueueType::BoundedDropping;
   static constexpr size_t initial_queue_capacity = 131'072;
   static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
+  static constexpr size_t unbounded_queue_max_capacity = 2ull * 1024u * 1024u * 1024u;
   static constexpr quill::HugePagesPolicy huge_pages_policy = quill::HugePagesPolicy::Never;
 };
 

test/integration_tests/CsvWritingCustomFrontendTest.cpp

@@ -19,6 +19,7 @@ struct CustomFrontendOptions
   static constexpr quill::QueueType queue_type = quill::QueueType::BoundedBlocking;
   static constexpr size_t initial_queue_capacity = 131'072;
   static constexpr uint32_t blocking_queue_retry_interval_ns = 800;
+  static constexpr size_t unbounded_queue_max_capacity = 2ull * 1024u * 1024u * 1024u;
   static constexpr quill::HugePagesPolicy huge_pages_policy = quill::HugePagesPolicy::Never;
 };
 

test/unit_tests/UnboundedQueueTest.cpp

@@ -15,17 +15,13 @@ TEST_CASE("unbounded_queue_shrink")
   constexpr size_t CHUNK{256};
   constexpr size_t INITIAL_SIZE{1024};
 
-  UnboundedSPSCQueue buffer{INITIAL_SIZE};
+  UnboundedSPSCQueue buffer{INITIAL_SIZE, quill::FrontendOptions::unbounded_queue_max_capacity};
   REQUIRE_EQ(buffer.producer_capacity(), INITIAL_SIZE);
 
   // This queue will grow as we request 5 * 256
   for (uint32_t i = 0; i < 5; ++i)
   {
-#if defined(_MSC_VER)
-    auto* write_buffer = buffer.prepare_write(CHUNK, quill::FrontendOptions::unbounded_queue_max_capacity);
-#else
-    auto* write_buffer = buffer.prepare_write<quill::FrontendOptions::unbounded_queue_max_capacity>(CHUNK);
-#endif
+    auto* write_buffer = buffer.prepare_write(CHUNK);
 
     REQUIRE(write_buffer);
     buffer.finish_write(CHUNK);
@@ -69,19 +65,15 @@ TEST_CASE("unbounded_queue_shrink")
 
 TEST_CASE("unbounded_queue_allocation_within_limit")
 {
-  UnboundedSPSCQueue buffer{1024};
+  UnboundedSPSCQueue buffer{1024, std::numeric_limits<uint64_t>::max()};
 
   static constexpr size_t two_mb = 2u * 1024u * 1024u;
 
   // Attempt to allocate a buffer size that exceeds the default limit,
   // ensuring that allocation within configurable bounds does not throw.
   auto func = [&buffer]()
   {
-    #if defined(_MSC_VER)
-    auto* write_buffer_z = buffer.prepare_write(2 * two_mb, std::numeric_limits<uint64_t>::max());
-    #else
-    auto* write_buffer_z = buffer.prepare_write<std::numeric_limits<uint64_t>::max()>(2 * two_mb);
-    #endif
+    auto* write_buffer_z = buffer.prepare_write(2 * two_mb);
     return write_buffer_z;
   };
 
@@ -91,19 +83,15 @@ TEST_CASE("unbounded_queue_allocation_within_limit")
 
 TEST_CASE("unbounded_queue_allocation_exceeds_limit")
 {
-  UnboundedSPSCQueue buffer{1024};
-
   constexpr static uint64_t two_mb = 2u * 1024u * 1024u;
 
+  UnboundedSPSCQueue buffer{1024, two_mb};
+
   // Attempt to allocate a buffer size that exceeds the specified capacity,
   // which should trigger an exception.
   auto func = [&buffer]()
   {
-    #if defined(_MSC_VER)
-    auto* write_buffer_z = buffer.prepare_write(2 * two_mb, two_mb);
-    #else
-    auto* write_buffer_z = buffer.prepare_write<two_mb>(2 * two_mb);
-    #endif
+    auto* write_buffer_z = buffer.prepare_write(2 * two_mb);
     return write_buffer_z;
   };
 
@@ -113,7 +101,7 @@ TEST_CASE("unbounded_queue_allocation_exceeds_limit")
 
 TEST_CASE("unbounded_queue_read_write_multithreaded_plain_ints")
 {
-  UnboundedSPSCQueue buffer{1024};
+  UnboundedSPSCQueue buffer{1024, quill::FrontendOptions::unbounded_queue_max_capacity};
 
   std::thread producer_thread(
     [&buffer]()
@@ -122,25 +110,15 @@ TEST_CASE("unbounded_queue_read_write_multithreaded_plain_ints")
       {
         for (uint32_t i = 0; i < 8192; ++i)
         {
-#if defined(_MSC_VER)
-          auto* write_buffer =
-            buffer.prepare_write(sizeof(uint32_t), quill::FrontendOptions::unbounded_queue_max_capacity);
-#else
           auto* write_buffer =
-            buffer.prepare_write<quill::FrontendOptions::unbounded_queue_max_capacity>(sizeof(uint32_t));
-#endif
+            buffer.prepare_write(sizeof(uint32_t));
 
           while (!write_buffer)
           {
             std::this_thread::sleep_for(std::chrono::microseconds{2});
-#if defined(_MSC_VER)
-            write_buffer =
-              buffer.prepare_write(sizeof(uint32_t), quill::FrontendOptions::unbounded_queue_max_capacity);
-#else
+
             write_buffer =
-              buffer.prepare_write<quill::FrontendOptions::unbounded_queue_max_capacity>(
-                sizeof(uint32_t));
-#endif
+              buffer.prepare_write(sizeof(uint32_t));
           }
 
           std::memcpy(write_buffer, &i, sizeof(uint32_t));