CacheManager.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include <Atoms/Globals.h>
#include <AtomsCore/Metadata/MapMetadata.h>
#include <AtomsCore/Metadata/PoseMetadata.h>
#include <set>
#include <list>
 
namespace Atoms
{
    /* The cache manager is a container for multiple cache frames. It store those frames in memory until the
    * max memory is reached or until the removeCache function is called. When the cache manager reaches is max memory,
    * it starts to unload cache frames based on the time elapsed from the last request. 
    * Every acces to a cache must be preceded by a request* call. The cache manager converts this requests in tasks and stores 
    * them in a queue. If two task requeste the same agents or different agents for the same file, they ill be merged in a single task.
    * These tasks can be precessed using the  executeTasks() function. In this way task of multiple agents 
    * in the same cache frame are merged togheter to imporve to performance.
    */
    class ATOMS_EXPORT CacheManager
    {
    public:
 
        class FrameData
        {
        public:
            FrameData() :
                data(nullptr),
                time(0),
                memSize(0)
            {
 
            }
 
            AtomsPtr<AtomsCore::MapMetadata> data;
            long time;
            size_t memSize;
            std::set<int> agents;
        };
 
        typedef std::map<std::string, std::map<int, FrameData>> MapType;
 
        class Task
        {
        public:
            Task() :
                cachePath(),
                cacheName(),
                frame(0),
                type(0),
                multithread(false)
            {
            }
 
            enum Type
            {
                kPose = 0,
                kMeta = 1,
                kHeader = 2,
                kFrame = 3,
            };
 
            std::string cachePath;
 
            std::string cacheName;
 
            int frame;
 
            std::set<unsigned int> ids;
 
            short type;
 
            bool multithread;
        };
 
        static CacheManager& instance();
 
        const AtomsCore::Pose* getAgentPose(const std::string& cachePath, const std::string& cacheName, int frame, int agentId) const;
 
        const AtomsCore::MapMetadata* getAgentMetadata(const std::string& cachePath, const std::string& cacheName, int frame, int agentId) const;
 
        void getBlendAgentPose(const std::string& cachePath, const std::string& cacheName, double frame, int agentId, const AtomsCore::Skeleton& skeleton, AtomsCore::Pose& pose) const;
 
        void getBlendAgentMetadata(const std::string& cachePath, const std::string& cacheName, double frame, int agentId, AtomsCore::MapMetadata& mapMeta) const;
 
        const AtomsCore::MapMetadata* getAgentFrame(const std::string& cachePath, const std::string& cacheName, int frame, int agentId) const;
 
        const AtomsCore::MapMetadata* getHeaderFrame(const std::string& cachePath, const std::string& cacheName, int frame) const;
 
        const AtomsCore::MapMetadata* loadHeaderFrame(const std::string& cachePath, const std::string& cacheName, int frame);
 
        void requestFrameHeader(const std::string& cachePath, const std::string& cacheName, int frame, bool multithread=false);
 
        void requestAgentFrame(const std::string& cachePath, const std::string& cacheName, int frame, const std::vector<int>& ids, bool multithread = false);
 
        void requestAgentPose(const std::string& cachePath, const std::string& cacheName, int frame, const std::vector<int>& ids, bool multithread = false);
 
        void requestAgentMetadata(const std::string& cachePath, const std::string& cacheName, int frame, const std::vector<int>& ids, bool multithread = false);
 
        /*
        \param clearNotUsedCache If se tto true the manager removes all the caches not used by the task in the queue
        */
        void executeTasks(bool clearNotUsedCache = true);
 
        void clear();
 
        const MapType& agentsMetadata() const;
 
        const MapType& agentsPoses() const;
 
        const MapType& frameHeaders() const;
 
        const MapType& agentsFrames() const;
 
        void blendMetadata(AtomsCore::MapMetadata &outMetadata, std::vector<const AtomsCore::MapMetadata*> &inMetadatas, const std::vector<double> &inputWeightVector) const;
 
        void blendPose(const AtomsCore::Skeleton &skeleton, std::vector<const AtomsCore::Pose*>& posePorts, std::vector<double>& weightPorts, AtomsCore::Pose& outPose) const;
 
        size_t memoryUsage() const;
 
        size_t maxMemory() const;
 
        void setMaxMemory(size_t value);
 
        // ! Checks if a cache is already loaded in the manager
        bool hasCache(const std::string& cachePath, const std::string& cacheName);
 
        void removeCache(const std::string& cachePath, const std::string& cacheName);
 
        void loadFullCache(const std::string& cachePath, const std::string& cacheName);
 
        void loadCacheFrames(const std::string& cachePath, const std::string& cacheName, int start, int end);
 
    private:
 
        void requestAgentData(const std::string& cachePath, const std::string& cacheName, int frame, const std::vector<int>& ids, short taskType, bool multithread=false);
        
        size_t computeMemoryUsage();
 
        void cleanExtraMemory();
 
        CacheManager();
 
        ~CacheManager();
 
        CacheManager(const CacheManager&);
 
        CacheManager& operator=(const CacheManager&);
 
        std::vector<Task> m_taskQueue;
 
        MapType m_agentsMetadata;
 
        MapType m_agentsPoses;
 
        MapType m_frameHeaders;
 
        MapType m_agentsFrames;
 
        std::map<std::string, int> m_referenceCount;
 
        std::map<std::string, std::list<FrameData>> m_agentsMetadataPool;
        std::map<std::string, std::list<FrameData>> m_agentsPosesPool;
        std::map<std::string, std::list<FrameData>> m_agentsFramesPool;
 
        size_t m_currentMemorySize;
 
        size_t m_maxMemory;
    };
}