kcenon::monitoring::hot_path Namespace Reference

Functions
template<typename Map , typename Key , typename CreateFn >
auto	get_or_create (Map &map, std::shared_mutex &mutex, const Key &key, CreateFn create_fn) -> typename std::remove_reference< decltype(*map.begin() ->second)>::type *
template<typename Map , typename Key , typename CreateFn , typename InitFn >
auto	get_or_create_with_init (Map &map, std::shared_mutex &mutex, const Key &key, CreateFn create_fn, InitFn init_fn) -> typename std::remove_reference< decltype(*map.begin() ->second)>::type *
template<typename Map , typename Key , typename CreateFn , typename UpdateFn >
auto	get_or_create_and_update (Map &map, std::shared_mutex &mutex, const Key &key, CreateFn create_fn, UpdateFn update_fn) -> decltype(update_fn(*map.begin() ->second))

Function Documentation

get_or_create()

template<typename Map , typename Key , typename CreateFn >

auto kcenon::monitoring::hot_path::get_or_create	(	Map &	map,
		std::shared_mutex &	mutex,
		const Key &	key,
		CreateFn	create_fn ) -> typename std::remove_reference<decltype(*map.begin()->second)>::type*

Examples

/home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/utils/hot_path_helper.h.

Definition at line 69 of file hot_path_helper.h.

                                                                      {
    // Fast path: try with shared lock (read-only, allows concurrent readers)
    {
        std::shared_lock<std::shared_mutex> read_lock(mutex);
        auto it = map.find(key);
        if (it != map.end()) {
            return it->second.get();
        }
    }
 
    // Slow path: upgrade to write lock and double-check
    {
        std::unique_lock<std::shared_mutex> write_lock(mutex);
        // Double-check after acquiring write lock
        // Another thread may have created the entry while we were waiting
        auto& ptr = map[key];
        if (!ptr) {
            ptr = create_fn();
        }
        return ptr.get();
    }
}

Referenced by get_or_create_and_update(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), TEST_F(), and TEST_F().

Here is the caller graph for this function:

get_or_create_and_update()

template<typename Map , typename Key , typename CreateFn , typename UpdateFn >

auto kcenon::monitoring::hot_path::get_or_create_and_update	(	Map &	map,
		std::shared_mutex &	mutex,
		const Key &	key,
		CreateFn	create_fn,
		UpdateFn	update_fn ) -> decltype(update_fn(*map.begin()->second))

Examples

/home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/utils/hot_path_helper.h.

Definition at line 204 of file hot_path_helper.h.

                                                 {
    // Get or create the entry
    auto* ptr = get_or_create(map, mutex, key, std::move(create_fn));
 
    // Apply the update function outside of map locks
    // The value's own synchronization handles thread safety
    return update_fn(*ptr);
}

References get_or_create().

Referenced by TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

get_or_create_with_init()

template<typename Map , typename Key , typename CreateFn , typename InitFn >

auto kcenon::monitoring::hot_path::get_or_create_with_init	(	Map &	map,
		std::shared_mutex &	mutex,
		const Key &	key,
		CreateFn	create_fn,
		InitFn	init_fn ) -> typename std::remove_reference<decltype(*map.begin()->second)>::type*

Examples

/home/runner/work/monitoring_system/monitoring_system/include/kcenon/monitoring/utils/hot_path_helper.h.

Definition at line 135 of file hot_path_helper.h.

                                                                      {
    // Fast path: try with shared lock (read-only, allows concurrent readers)
    {
        std::shared_lock<std::shared_mutex> read_lock(mutex);
        auto it = map.find(key);
        if (it != map.end()) {
            return it->second.get();
        }
    }
 
    // Slow path: upgrade to write lock and double-check
    {
        std::unique_lock<std::shared_mutex> write_lock(mutex);
        // Double-check after acquiring write lock
        // Another thread may have created the entry while we were waiting
        auto& ptr = map[key];
        if (!ptr) {
            ptr = create_fn();
            // Initialize the newly created entry while still under write lock
            init_fn(*ptr);
        }
        return ptr.get();
    }
}

Referenced by TEST_F(), and TEST_F().

Here is the caller graph for this function: