MemoryManager.h

Go to the documentation of this file.

#ifndef HYPERISO_MEMORY_MANAGER_H
#define HYPERISO_MEMORY_MANAGER_H
 
#include <unordered_map>
#include <thread>
 
#include "config.hpp"
#include "Include.h"
#include "BlockAccessor.h"
#include "DBMemento.h"
#include "CorrelationRepo.h"
#include "ISpectrumCalculator.h"
#include "IDataLoader.h"
#include "IPathsProvider.h"
#include "ILhaPrototypeRegistry.h"
#include "Config.h"
 
enum class InternalFlag { PARAMS_CHANGED };
 
struct MemoryCache {
    HyperisoConfig config;                                                              
    std::map<InternalFlag, bool> flags {{InternalFlag::PARAMS_CHANGED, false}}; 
    fs::path lha_path;                                                          
    std::vector<ParameterType> parameter_types;                                 
    std::thread::id thread_id;                                                  
    bool is_ready;                                                              
 
};
 
struct ReadyGuard {
    bool& flag;
    ReadyGuard(bool& f) : flag(f) { flag = false; }
    ~ReadyGuard() { flag = true; }
};
 
class MemoryManager {
private:
    static MemoryManager* instance;                                             
    MemoryCache cache;                                                          
    std::shared_ptr<BlockAccessor> input_cache;                                 
    DBMemento memento;                                                          
    CorrelationRepository correlation_repository;                               
    std::shared_ptr<ISpectrumCalculator> sc;                                    
    std::shared_ptr<IDataLoader<BlockAccessor>> dl_ba;                          
    std::shared_ptr<IDataLoader<CorrelationMatrixPair<ParamId>>> dl_cmp_p;      
    std::shared_ptr<IDataLoader<CorrelationMatrixPair<ExperimentObs>>> dl_cmp_o; 
    std::shared_ptr<IPathsProvider> paths_provider;                             
    std::shared_ptr<ILhaPrototypeRegistry> lha_prototype_registry;              
 
    MemoryManager();
 
    MemoryManager(std::shared_ptr<IDataLoader<BlockAccessor>> loader, 
        std::shared_ptr<IDataLoader<CorrelationMatrixPair<ParamId>>> param_corr, 
        std::shared_ptr<IDataLoader<CorrelationMatrixPair<ExperimentObs>>> obs_corr, 
        std::shared_ptr<ISpectrumCalculator> spectrum_c,
        std::shared_ptr<IPathsProvider> paths_provider_,
        std::shared_ptr<ILhaPrototypeRegistry> lha_prototype_registry_);
 
    void check_if_ready();
 
    void read_default_input();
 
    void read_user_input();
 
    void read_lha_input(const std::string& lhaFile, const HyperisoConfig& config);
 
    fs::path format_lha_path(const std::string& path);
 
    fs::path calculate_spectrum(fs::path input_lha_path, const HyperisoConfig& config);
 
    void deduce_parameter_types(const HyperisoConfig &config);
 
    void save_input_cache();
 
public:
    static MemoryManager* GetInstance();
 
    static MemoryManager* Create(std::shared_ptr<IDataLoader<BlockAccessor>> loader, 
        std::shared_ptr<IDataLoader<CorrelationMatrixPair<ParamId>>> param_corr, 
        std::shared_ptr<IDataLoader<CorrelationMatrixPair<ExperimentObs>>> obs_corr, 
        std::shared_ptr<ISpectrumCalculator> spectrum_c,
        std::shared_ptr<IPathsProvider> paths_provider,
        std::shared_ptr<ILhaPrototypeRegistry> lha_prototype_registry=nullptr);
 
    void set_paths_provider(std::shared_ptr<IPathsProvider> paths_provider_);
 
    fs::path get_path(APIPath path_name);
 
    void init(const std::string &lhaFile, HyperisoConfig config);
 
    void add_lha_prototype(BlockName blockName,
                           size_t itemCount=2,
                           size_t valueIdx=1,
                           int scaleIdx=-1,
                           int rgIdx=-1,
                           int binIdx=-1,
                           bool globalScale=false);
 
    void add_lha_prototypes(const std::vector<LhaPrototypeSpec>& prototypes);
 
    void switch_lha(const std::string& lhaFile, HyperisoConfig config);
 
    void reload_user_input(HyperisoConfig config);
 
    void reload_user_input(const std::string &lhaFile, HyperisoConfig config);
 
    void switch_model(Model model = Model::SM);
 
    inline const MemoryCache& getMemoryCache() { check_if_ready(); return cache; }
 
    inline bool is_ready() const { return cache.is_ready; }
 
    std::shared_ptr<BlockAccessor> extract_blocks(std::unordered_set<BlockName> block_names);
 
    std::shared_ptr<BlockAccessor> extract_block_accessor();
 
    std::shared_ptr<BlockAccessor> clone_input_cache_deep() const;
 
    const CorrelationRepository& get_correlation_repository();
 
    std::unordered_set<ParamId> get_all_source_parameters(const std::unordered_set<ParamId>& param_ids) const;
 
    MemoryManager(const MemoryManager&) = delete;
    MemoryManager& operator=(const MemoryManager&) = delete;
    MemoryManager(MemoryManager&&) noexcept = default;
    MemoryManager& operator=(MemoryManager&&) noexcept = default;
 
    friend class Parameters;
};
 
#endif // HYPERISO_MEMORY_MANAGER_H