.. _program_listing_file_umap_RegionManager.hpp:

Program Listing for File RegionManager.hpp
==========================================

|exhale_lsh| :ref:`Return to documentation for file <file_umap_RegionManager.hpp>` (``umap/RegionManager.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   //////////////////////////////////////////////////////////////////////////////
   // Copyright 2017-2020 Lawrence Livermore National Security, LLC and other
   // UMAP Project Developers. See the top-level LICENSE file for details.
   //
   // SPDX-License-Identifier: LGPL-2.1-only
   //////////////////////////////////////////////////////////////////////////////
   #ifndef _UMAP_RegionManager_HPP
   #define _UMAP_RegionManager_HPP
   
   #include <cstdint>
   #include <mutex>
   #include <map>
   
   #include "umap/Buffer.hpp"
   #include "umap/EvictManager.hpp"
   #include "umap/FillWorkers.hpp"
   #include "umap/Uffd.hpp"
   #include "umap/umap.h"
   #include "umap/store/Store.hpp"
   #include "umap/RegionDescriptor.hpp"
   
   namespace Umap {
   class FillWorkers;
   class EvictManager;
   
   struct Version {
     int major;
     int minor;
     int patch;
   };
   
   //
   // Implemented as a singleton for now.  Things can get too weird attempting to
   // manage changes in configuration parameters when we have active monitors
   // working.  So, we only allow changing configuration when there are no active
   // monitors
   //
   class RegionManager {
     public:
       static RegionManager& getInstance( void );
   
       // delete copy, move, and assign operators
       RegionManager(RegionManager const&) = delete;             // Copy construct
       RegionManager(RegionManager&&) = delete;                  // Move construct
       RegionManager& operator=(RegionManager const&) = delete;  // Copy assign
       RegionManager& operator=(RegionManager &&) = delete;      // Move assign
   
       void addRegion(
             Store*   store
           , char*    region
           , uint64_t region_size
           , char*    mmap_region
           , uint64_t mmap_region_size
       );
   
       int flush_buffer();
       void prefetch(int npages, umap_prefetch_item* page_array);
       void fetch_and_pin( char* paddr, uint64_t size );
       void removeRegion( char* mmap_region );
       Version  get_umap_version( void ) { return m_version; }
       long     get_system_page_size( void ) { return m_system_page_size; }
       uint64_t get_max_pages_in_buffer( void ) { return m_max_pages_in_buffer; }
       int      get_monitor_freq( void ) { return m_monitor_freq; }
       uint64_t get_umap_page_size( void ) { return m_umap_page_size; }
       uint64_t get_num_fillers( void ) { return m_num_fillers; }
       uint64_t get_num_evictors( void ) { return m_num_evictors; }
       int get_evict_low_water_threshold( void ) { return m_evict_low_water_threshold; }
       int get_evict_high_water_threshold( void ) { return m_evict_high_water_threshold; }
       uint64_t get_max_fault_events( void ) { return m_max_fault_events; }
       Buffer* get_buffer_h() { return m_buffer; }
       Uffd* get_uffd_h() { return m_uffd; }
       FillWorkers* get_fill_workers_h() { return m_fill_workers; }
       EvictManager* get_evict_manager() { return m_evict_manager; }
       RegionDescriptor* containing_region( char* vaddr );
       uint64_t get_num_active_regions( void ) { return (uint64_t)m_active_regions.size(); }
   
     private:
       Version  m_version;
       uint64_t m_max_pages_in_buffer;
       int      m_monitor_freq;
       long     m_umap_page_size;
       uint64_t m_system_page_size;
       uint64_t m_num_fillers;
       uint64_t m_num_evictors;
       int m_evict_low_water_threshold;
       int m_evict_high_water_threshold;
       uint64_t m_max_fault_events;
       Buffer* m_buffer;
       Uffd* m_uffd;
       FillWorkers* m_fill_workers;
       EvictManager* m_evict_manager;
       std::mutex m_mutex;
   
       std::map<void*, RegionDescriptor*> m_active_regions;
       std::map<void*, RegionDescriptor*>::iterator m_last_iter;
   
       RegionManager( void );
   
       uint64_t* read_env_var( const char* env, uint64_t* val);
       uint64_t        get_max_pages_in_memory( void );
       void set_max_fault_events( uint64_t max_events );
       void set_max_pages_in_buffer( uint64_t max_pages );
       void set_umap_page_size( uint64_t page_size );
       void set_num_fillers( uint64_t num_fillers );
       void set_num_evictors( uint64_t num_evictors );
       void set_evict_low_water_threshold( int percent );
       void set_evict_high_water_threshold( int percent );
   };
   
   } // end of namespace Umap
   #endif // _UMAP_RegionManager_HPP