test_hot_path_helper.cpp File Reference

Unit tests for hot-path optimization helpers. More...

#include <gtest/gtest.h>
#include <kcenon/monitoring/utils/hot_path_helper.h>
#include <atomic>
#include <memory>
#include <string>
#include <thread>
#include <unordered_map>
#include <vector>

Include dependency graph for test_hot_path_helper.cpp:

Go to the source code of this file.

Classes
class	HotPathHelperTest

Functions
	TEST_F (HotPathHelperTest, GetOrCreateNewEntry)
	TEST_F (HotPathHelperTest, GetOrCreateExistingEntry)
	TEST_F (HotPathHelperTest, GetOrCreateMultipleKeys)
	TEST_F (HotPathHelperTest, GetOrCreateWithInitNewEntry)
	TEST_F (HotPathHelperTest, GetOrCreateWithInitExistingEntry)
	TEST_F (HotPathHelperTest, GetOrCreateAndUpdateNewEntry)
	TEST_F (HotPathHelperTest, GetOrCreateAndUpdateExistingEntry)
	TEST_F (HotPathHelperTest, ConcurrentGetOrCreate)
	TEST_F (HotPathHelperTest, ConcurrentDifferentKeys)
	TEST_F (HotPathHelperTest, ConcurrentMixedReadWrite)
	TEST_F (HotPathHelperTest, HotPathOptimizationVerification)

Detailed Description

Unit tests for hot-path optimization helpers.

Definition in file test_hot_path_helper.cpp.

Function Documentation

TEST_F() [1/11]

TEST_F	(	HotPathHelperTest	,
		ConcurrentDifferentKeys	)

Definition at line 197 of file test_hot_path_helper.cpp.

                                                   {
    std::atomic<int> total_creates{0};
    const int num_threads = 10;
    const int keys_per_thread = 100;
 
    std::vector<std::thread> threads;
    threads.reserve(num_threads);
 
    for (int t = 0; t < num_threads; ++t) {
        threads.emplace_back([this, t, &total_creates, keys_per_thread]() {
            for (int i = 0; i < keys_per_thread; ++i) {
                std::string key = "key_" + std::to_string(t) + "_" + std::to_string(i);
                auto* ptr = get_or_create(
                    map_, mutex_, key,
                    [&total_creates]() {
                        ++total_creates;
                        return std::make_unique<TestData>();
                    });
                ASSERT_NE(ptr, nullptr);
            }
        });
    }
 
    for (auto& t : threads) {
        t.join();
    }
 
    EXPECT_EQ(map_.size(), static_cast<size_t>(num_threads * keys_per_thread));
    EXPECT_EQ(total_creates.load(), num_threads * keys_per_thread);
}

References kcenon::monitoring::hot_path::get_or_create().

Here is the call graph for this function:

TEST_F() [2/11]

TEST_F	(	HotPathHelperTest	,
		ConcurrentGetOrCreate	)

Definition at line 167 of file test_hot_path_helper.cpp.

                                                 {
    std::atomic<int> create_count{0};
    const int num_threads = 10;
    const int iterations_per_thread = 1000;
 
    std::vector<std::thread> threads;
    threads.reserve(num_threads);
 
    for (int t = 0; t < num_threads; ++t) {
        threads.emplace_back([this, &create_count, iterations_per_thread]() {
            for (int i = 0; i < iterations_per_thread; ++i) {
                auto* ptr = get_or_create(
                    map_, mutex_, "shared_key",
                    [&create_count]() {
                        ++create_count;
                        return std::make_unique<TestData>();
                    });
                ASSERT_NE(ptr, nullptr);
            }
        });
    }
 
    for (auto& t : threads) {
        t.join();
    }
 
    EXPECT_EQ(map_.size(), 1u);
    EXPECT_EQ(create_count.load(), 1);  // Only one creation should occur
}

References kcenon::monitoring::hot_path::get_or_create().

Here is the call graph for this function:

TEST_F() [3/11]

TEST_F	(	HotPathHelperTest	,
		ConcurrentMixedReadWrite	)

Definition at line 228 of file test_hot_path_helper.cpp.

                                                    {
    // Pre-create some entries
    for (int i = 0; i < 50; ++i) {
        map_["existing_" + std::to_string(i)] = std::make_unique<TestData>();
    }
 
    const int num_threads = 8;
    const int iterations = 500;
 
    std::vector<std::thread> threads;
    threads.reserve(num_threads);
 
    for (int t = 0; t < num_threads; ++t) {
        threads.emplace_back([this, t, iterations]() {
            for (int i = 0; i < iterations; ++i) {
                // Half the time access existing, half the time create new
                std::string key = (i % 2 == 0)
                    ? "existing_" + std::to_string(i % 50)
                    : "new_" + std::to_string(t) + "_" + std::to_string(i);
 
                auto* ptr = get_or_create(
                    map_, mutex_, key,
                    []() { return std::make_unique<TestData>(); });
                ASSERT_NE(ptr, nullptr);
            }
        });
    }
 
    for (auto& t : threads) {
        t.join();
    }
 
    EXPECT_GE(map_.size(), 50u);  // At least the pre-existing entries
}

References kcenon::monitoring::hot_path::get_or_create().

Here is the call graph for this function:

TEST_F() [4/11]

TEST_F	(	HotPathHelperTest	,
		GetOrCreateAndUpdateExistingEntry	)

Definition at line 146 of file test_hot_path_helper.cpp.

                                                             {
    // Pre-create an entry
    map_["key1"] = std::make_unique<TestData>();
    map_["key1"]->value = 10;
 
    int result = get_or_create_and_update(
        map_, mutex_, "key1",
        []() { return std::make_unique<TestData>(); },
        [](TestData& d) {
            d.value += 5;
            return d.value;
        });
 
    EXPECT_EQ(result, 15);
    EXPECT_EQ(map_["key1"]->value, 15);
}

References kcenon::monitoring::hot_path::get_or_create_and_update().

Here is the call graph for this function:

TEST_F() [5/11]

TEST_F	(	HotPathHelperTest	,
		GetOrCreateAndUpdateNewEntry	)

Definition at line 133 of file test_hot_path_helper.cpp.

                                                        {
    int result = get_or_create_and_update(
        map_, mutex_, "key1",
        []() { return std::make_unique<TestData>(); },
        [](TestData& d) {
            d.value = 42;
            return d.value;
        });
 
    EXPECT_EQ(result, 42);
    EXPECT_EQ(map_["key1"]->value, 42);
}

References kcenon::monitoring::hot_path::get_or_create_and_update().

Here is the call graph for this function:

TEST_F() [6/11]

TEST_F	(	HotPathHelperTest	,
		GetOrCreateExistingEntry	)

Definition at line 57 of file test_hot_path_helper.cpp.

                                                    {
    // Pre-create an entry
    map_["key1"] = std::make_unique<TestData>();
    map_["key1"]->value = 42;
 
    int create_count = 0;
    auto* ptr = get_or_create(
        map_, mutex_, "key1",
        [&create_count]() {
            ++create_count;
            return std::make_unique<TestData>();
        });
 
    ASSERT_NE(ptr, nullptr);
    EXPECT_EQ(map_.size(), 1u);
    EXPECT_EQ(ptr->value, 42);
    EXPECT_EQ(create_count, 0);  // Factory should not be called
}

References kcenon::monitoring::hot_path::get_or_create().

Here is the call graph for this function:

TEST_F() [7/11]

TEST_F	(	HotPathHelperTest	,
		GetOrCreateMultipleKeys	)

Definition at line 76 of file test_hot_path_helper.cpp.

                                                   {
    auto* ptr1 = get_or_create(
        map_, mutex_, "key1",
        []() { return std::make_unique<TestData>(); });
    auto* ptr2 = get_or_create(
        map_, mutex_, "key2",
        []() { return std::make_unique<TestData>(); });
 
    ASSERT_NE(ptr1, nullptr);
    ASSERT_NE(ptr2, nullptr);
    EXPECT_NE(ptr1, ptr2);
    EXPECT_EQ(map_.size(), 2u);
}

References kcenon::monitoring::hot_path::get_or_create().

Here is the call graph for this function:

TEST_F() [8/11]

TEST_F	(	HotPathHelperTest	,
		GetOrCreateNewEntry	)

Definition at line 47 of file test_hot_path_helper.cpp.

                                               {
    auto* ptr = get_or_create(
        map_, mutex_, "key1",
        []() { return std::make_unique<TestData>(); });
 
    ASSERT_NE(ptr, nullptr);
    EXPECT_EQ(map_.size(), 1u);
    EXPECT_EQ(ptr->value, 0);
}

References kcenon::monitoring::hot_path::get_or_create().

Here is the call graph for this function:

TEST_F() [9/11]

TEST_F	(	HotPathHelperTest	,
		GetOrCreateWithInitExistingEntry	)

Definition at line 108 of file test_hot_path_helper.cpp.

                                                            {
    // Pre-create an entry
    map_["key1"] = std::make_unique<TestData>();
    map_["key1"]->value = 42;
    map_["key1"]->name = "original";
 
    int init_count = 0;
    auto* ptr = get_or_create_with_init(
        map_, mutex_, "key1",
        []() { return std::make_unique<TestData>(); },
        [&init_count](TestData& d) {
            ++init_count;
            d.value = 100;
        });
 
    ASSERT_NE(ptr, nullptr);
    EXPECT_EQ(ptr->value, 42);  // Should not be modified
    EXPECT_EQ(ptr->name, "original");
    EXPECT_EQ(init_count, 0);  // Init should not be called
}

References kcenon::monitoring::hot_path::get_or_create_with_init().

Here is the call graph for this function:

TEST_F() [10/11]

TEST_F	(	HotPathHelperTest	,
		GetOrCreateWithInitNewEntry	)

Definition at line 94 of file test_hot_path_helper.cpp.

                                                       {
    auto* ptr = get_or_create_with_init(
        map_, mutex_, "key1",
        []() { return std::make_unique<TestData>(); },
        [](TestData& d) {
            d.value = 100;
            d.name = "initialized";
        });
 
    ASSERT_NE(ptr, nullptr);
    EXPECT_EQ(ptr->value, 100);
    EXPECT_EQ(ptr->name, "initialized");
}

References kcenon::monitoring::hot_path::get_or_create_with_init().

Here is the call graph for this function:

TEST_F() [11/11]

TEST_F	(	HotPathHelperTest	,
		HotPathOptimizationVerification	)

Definition at line 267 of file test_hot_path_helper.cpp.

                                                           {
    // Create entry first
    map_["hot_key"] = std::make_unique<TestData>();
 
    std::atomic<int> create_calls{0};
    const int hot_path_iterations = 10000;
 
    // Simulate hot path - many reads, no creates
    for (int i = 0; i < hot_path_iterations; ++i) {
        auto* ptr = get_or_create(
            map_, mutex_, "hot_key",
            [&create_calls]() {
                ++create_calls;
                return std::make_unique<TestData>();
            });
        ASSERT_NE(ptr, nullptr);
    }
 
    // Verify factory was never called (hot path optimization working)
    EXPECT_EQ(create_calls.load(), 0);
}

References kcenon::monitoring::hot_path::get_or_create().

Here is the call graph for this function: