Optimize fuzzer

src/common/utils/string.cpp

@@ -0,0 +1,52 @@
+#include "string.hpp"
+
+#include <array>
+#include <cstdarg>
+
+namespace utils::string
+{
+    // NOLINTNEXTLINE(cert-dcl50-cpp)
+    const char* va(const char* format, ...)
+    {
+        constexpr auto buffer_count = 4;
+        thread_local std::array<std::vector<char>, buffer_count> buffers{};
+        thread_local size_t current_index{0};
+
+        const auto index = current_index++;
+        current_index %= buffers.size();
+
+        auto& buffer = buffers.at(index);
+
+        if (buffer.size() < 10)
+        {
+            buffer.resize(10);
+        }
+
+        while (true)
+        {
+            va_list ap{};
+            va_start(ap, format);
+
+#ifdef _WIN32
+            const int res = vsnprintf_s(buffer.data(), buffer.size(), _TRUNCATE, format, ap);
+#else
+            const int res = vsnprintf(buffer.data(), buffer.size(), format, ap);
+#endif
+
+            va_end(ap);
+
+            if (res > 0 && static_cast<size_t>(res) < buffer.size())
+            {
+                break;
+            }
+            if (res == 0)
+            {
+                return nullptr;
+            }
+
+            buffer.resize(std::max(buffer.size() * 2, static_cast<size_t>(1)));
+        }
+
+        return buffer.data();
+    }
+}

src/common/utils/string.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include <span>
 #include <string>
+#include <vector>
 #include <cstddef>
 #include <cwctype>
 #include <algorithm>
@@ -8,6 +9,12 @@
 
 namespace utils::string
 {
+#ifdef __clang__
+    __attribute__((__format__(__printf__, 1, 2)))
+#endif
+    const char*
+    va(const char* format, ...);
+
     template <typename T, size_t Size>
         requires(std::is_trivially_copyable_v<T>)
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)

src/common/utils/timer.hpp

@@ -14,10 +14,14 @@ namespace utils
         }
 
         bool has_elapsed(typename Clock::duration duration) const
+        {
+            return this->elapsed() > duration;
+        }
+
+        typename Clock::duration elapsed() const
         {
             const auto now = Clock::now();
-            const auto diff = now - this->point_;
-            return diff > duration;
+            return now - this->point_;
         }
 
       private: