hot_path_helper.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <shared_mutex>
 
namespace kcenon {
namespace monitoring {
namespace hot_path {
 
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* {
    // 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();
    }
}
 
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* {
    // 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();
    }
}
 
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)) {
    // 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);
}
 
}  // namespace hot_path
}  // namespace monitoring
}  // namespace kcenon