node_cache.h

Go to the documentation of this file.

 
#pragma once
 
#include <neograph/api.h>
#include <neograph/graph/types.h>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <mutex>
#include <optional>
#include <set>
#include <string>
#include <unordered_map>
 
namespace neograph::graph {
 
struct RunContext;
 
enum class CacheScope {
    Execution,
    Reusable,
};
 
struct CacheKeyPolicy {
    CacheScope scope = CacheScope::Execution;
    std::function<std::string(const RunContext&)> context_key;
};
 
class NEOGRAPH_API NodeCache {
public:
    NodeCache() = default;
 
    void set_enabled(const std::string& node_name, bool enabled);
 
    bool is_enabled(const std::string& node_name) const;
 
    void set_policy(const std::string& node_name, CacheKeyPolicy policy);
 
    CacheKeyPolicy policy_for(const std::string& node_name) const;
 
    std::optional<NodeResult> lookup(const std::string& node_name,
                                     const std::string& state_hash) const;
 
    std::optional<NodeResult> lookup(const std::string& node_name,
                                     const std::string& state_hash,
                                     const std::string& scope_key) const;
 
    void store(const std::string& node_name,
               const std::string& state_hash,
               NodeResult result);
 
    void store(const std::string& node_name,
               const std::string& state_hash,
               const std::string& scope_key,
               NodeResult result);
 
    void clear();
 
    void set_max_entries(std::size_t max_entries);
 
    std::size_t max_entries() const;
 
    std::size_t size() const;
 
    std::size_t hit_count() const;
    std::size_t miss_count() const;
    std::size_t eviction_count() const;
 
private:
    struct CacheEntry {
        NodeResult result;
        std::uint64_t last_used = 0;
    };
 
    static std::string make_key(const std::string& node_name,
                                 const std::string& state_hash,
                                 const std::string& scope_key);
    void evict_one_locked();
 
    mutable std::mutex mu_;
    std::set<std::string> enabled_nodes_;
    std::unordered_map<std::string, CacheKeyPolicy> policies_;
    mutable std::unordered_map<std::string, CacheEntry> entries_;
    mutable std::size_t hits_   = 0;
    mutable std::size_t misses_ = 0;
    std::size_t max_entries_ = 0;
    std::size_t evictions_ = 0;
    mutable std::uint64_t access_sequence_ = 0;
};
 
NEOGRAPH_API std::string hash_state_for_cache(const json& state_value);
 
} // namespace neograph::graph