CachedMemoryMixin.h

Go to the documentation of this file.

#pragma once
 
#include <SimoxUtility/json.h>
 
#include <ArmarXCore/core/services/tasks/PeriodicTask.h>
 
#include <RobotAPI/libraries/armem/core/wm/memory_definitions.h>
 
namespace armarx::armem::server::ltm::detail::mixin
{
    template <class _CoreSegmentT>
    class CachedMemoryMixin
    {
    public:
        CachedMemoryMixin(const MemoryID& id) : cache(std::make_unique<armem::wm::Memory>(id))
        {
        }
 
    protected:
        armem::wm::Memory
        getCache() const
        {
            std::lock_guard l(this->cache_mutex);
            return *cache;
        }
 
        /// configuration
        void
        configureMixin(const nlohmann::json& json)
        {
            // TODO: Max cache size
            //
            // PROBLEM: The cache grows unbounded via addToCache() which continuously appends
            // without any eviction mechanism. This leads to unbounded memory growth over time,
            // only released on system restart.
            //
            // RECOMMENDED SOLUTION (Hybrid Approach):
            // Implement multiple eviction strategies for defense in depth:
            //
            // struct CacheConfig {
            //     long maxSnapshots = 50000;      // Hard limit on snapshot count
            //     long maxMemoryMB = 200;         // Hard limit on memory usage
            //     long maxAgeSeconds = 600;       // TTL: remove entries older than 10 minutes
            //     bool useLRU = false;            // Optional: LRU eviction (more complex)
            // };
            //
            // Eviction logic should:
            // 1. Remove entries older than maxAgeSeconds (TTL cleanup)
            // 2. If still over maxSnapshots OR maxMemoryMB, evict oldest entries (FIFO)
            // 3. Run cleanup periodically (e.g., every 30s) and on every addToCache() call
            //
            // This provides multiple safeguards:
            // - Time-based: prevents stale data accumulation
            // - Count-based: prevents unbounded snapshot growth
            // - Memory-based: prevents OOM scenarios
            //
            // NOTE: As of now, addToCache() is commented out in Memory.cpp:472, so this
            // issue may not be active. Verify cache usage before implementing eviction.
        }
 
        void
        setMixinMemoryID(const MemoryID& id)
        {
            ARMARX_CHECK_NOT_EMPTY(id.memoryName) << " The full id was: " << id.str();
 
            cache->id() = id.getMemoryID();
        }
 
        void
        addToCache(const armem::wm::Memory& memory)
        {
            std::lock_guard l(cache_mutex);
            cache->append(memory);
        }
 
        bool
        cacheHasCoreSegment(const std::string& n) const
        {
            std::lock_guard l(cache_mutex);
            return cache->hasCoreSegment(n);
        }
 
        bool
        cacheHasCoreSegment(const MemoryID& n) const
        {
            std::lock_guard l(cache_mutex);
            return cache->hasCoreSegment(n);
        }
 
        bool
        cacheHasProviderSegment(const MemoryID& n) const
        {
            std::lock_guard l(cache_mutex);
            return cache->hasProviderSegment(n);
        }
 
        bool
        cacheHasEntity(const MemoryID& n) const
        {
            std::lock_guard l(cache_mutex);
            return cache->hasEntity(n);
        }
 
        bool
        cacheHasEntitySnapshot(const MemoryID& n) const
        {
            std::lock_guard l(cache_mutex);
            return cache->hasSnapshot(n);
        }
 
        bool
        cacheHasEntityInstance(const MemoryID& n) const
        {
            std::lock_guard l(cache_mutex);
            return cache->hasInstance(n);
        }
 
 
    protected:
        std::unique_ptr<armem::wm::Memory> cache;
 
    private:
        mutable std::recursive_mutex cache_mutex;
    };
} // namespace armarx::armem::server::ltm::detail::mixin