Create unit-ordered_map-performance.cpp

Test performance and memory usage of ordered_json (will not report memory usage unless posix or MacOS).

Signed-off-by: Andrea Cocito <[email protected]>

Author: puffetto

tests/src/unit-ordered_map-performance.cpp

@@ -0,0 +1,111 @@
+#include <catch2/catch.hpp>
+#include "json.hpp"
+
+#include <chrono>
+#include <random>
+#include <iostream>
+#include <vector>
+#include <string>
+#include <numeric>
+#include <algorithm>
+
+#if defined(__unix__) || defined(__APPLE__)
+    #include <sys/resource.h>
+    #include <unistd.h>
+    static std::size_t get_memory_usage_kb()
+    {
+        struct rusage usage{};
+        if (getrusage(RUSAGE_SELF, &usage) == 0)
+        {
+        #if defined(__APPLE__)
+            // macOS returns bytes in ru_maxrss
+            return static_cast<std::size_t>(usage.ru_maxrss / 1024);
+        #else
+            // Linux/BSD return KB
+            return static_cast<std::size_t>(usage.ru_maxrss);
+        #endif
+        }
+        return 0;
+    }
+#else
+    static std::size_t get_memory_usage_kb()
+    {
+        return 0; // unavailable on this platform
+    }
+#endif
+
+// generate random hex string of fixed length
+static std::string random_hex(std::mt19937& rng, std::size_t length = 32)
+{
+    static const char* digits = "0123456789abcdef";
+    std::uniform_int_distribution<int> dist(0, 15);
+
+    std::string s;
+    s.resize(length);
+    for (std::size_t i = 0; i < length; ++i)
+    {
+        s[i] = digits[dist(rng)];
+    }
+    return s;
+}
+
+TEST_CASE("macro benchmark: ordered_json with 1,000,000 random hex pairs")
+{
+    using json = nlohmann::ordered_json;
+
+    constexpr std::size_t N = 1'000'000;
+
+    std::mt19937 rng(12345); // deterministic seed
+
+    std::vector<std::string> keys;
+    keys.reserve(N);
+
+    std::vector<std::string> values;
+    values.reserve(N);
+
+    // generate keys and values
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        keys.push_back(random_hex(rng));
+        values.push_back(random_hex(rng));
+    }
+
+    std::cout << "[ordered_map benchmark] Memory usage after generating arrays: "
+              << get_memory_usage_kb() << " KB" << std::endl;
+
+    json j;
+
+    // time to create
+    auto start_create = std::chrono::steady_clock::now();
+    for (std::size_t i = 0; i < N; ++i)
+    {
+        j[keys[i]] = values[i];
+    }
+    auto end_create = std::chrono::steady_clock::now();
+    auto create_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_create - start_create).count();
+
+    std::cout << "[ordered_map benchmark] Created " << N << " random hex entries in "
+              << create_ms << " ms" << std::endl;
+    std::cout << "Memory usage after create: " << get_memory_usage_kb() << " KB" << std::endl;
+
+    // random access order
+    std::vector<std::size_t> indices(N);
+    std::iota(indices.begin(), indices.end(), 0);
+    std::shuffle(indices.begin(), indices.end(), rng);
+
+    volatile std::size_t checksum = 0; // prevent optimizing away
+    auto start_read = std::chrono::steady_clock::now();
+    for (auto idx : indices)
+    {
+        const auto& v = j.at(keys[idx]);
+        checksum += v.size();
+    }
+    auto end_read = std::chrono::steady_clock::now();
+    auto read_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_read - start_read).count();
+
+    std::cout << "[ordered_map benchmark] Random read of " << N << " entries in "
+              << read_ms << " ms" << std::endl;
+    std::cout << "Memory usage after read: " << get_memory_usage_kb() << " KB" << std::endl;
+    std::cout << "Checksum: " << checksum << std::endl;
+}
+