Detailed Description

A private pimpl object for CacheManager. Do not include this header from a client program unless you know what you are doing.

Eviction Policy: So far we use a simple CLOCK algorithm to minimize the overhead, especially synchronization overhead.

Definition at line 44 of file cache_manager_pimpl.hpp.

#include <cache_manager_pimpl.hpp>

Inheritance diagram for foedus::cache::CacheManagerPimpl:

[legend]

Collaboration diagram for foedus::cache::CacheManagerPimpl:

[legend]

Public Member Functions
	CacheManagerPimpl ()=delete

	CacheManagerPimpl (Engine *engine)

ErrorStack	initialize_once () override

ErrorStack	uninitialize_once () override

std::string	describe () const

void	handle_cleaner ()
	Main routine of cleaner_. More...

void	handle_cleaner_evict_pages (uint64_t target_count)
	Evicts pages up to about target_count (maybe a bit more or less). More...

ErrorStack	stop_cleaner ()

Public Member Functions inherited from foedus::DefaultInitializable
	DefaultInitializable ()

virtual	~DefaultInitializable ()

	DefaultInitializable (const DefaultInitializable &)=delete

DefaultInitializable &	operator= (const DefaultInitializable &)=delete

ErrorStack	initialize () override final
	Typical implementation of Initializable::initialize() that provides initialize-once semantics. More...

ErrorStack	uninitialize () override final
	Typical implementation of Initializable::uninitialize() that provides uninitialize-once semantics. More...

bool	is_initialized () const override final
	Returns whether the object has been already initialized or not. More...

Public Member Functions inherited from foedus::Initializable
virtual	~Initializable ()

Public Attributes
Engine *const	engine_

std::thread	cleaner_
	The only cleaner thread in this SOC engine. More...

uint64_t	total_pages_

uint64_t	cleaner_threshold_
	the number of allocated pages above which cleaner starts cleaning More...

uint64_t	urgent_threshold_
	the number of allocated pages above which cleaner advances epoch to release pages More...

std::atomic< bool >	stop_requested_
	to stop cleaner_ More...

memory::PagePool *	pool_
	The SOC-local snapshot page pool in this SOC engine. More...

CacheHashtable *	hashtable_
	The cache hashtable (SnapshotPageId -> offset in pool) on top of the page pool. More...

memory::PagePoolOffset *	reclaimed_pages_
	This buffers pages being reclaimed. More...

memory::AlignedMemory	reclaimed_pages_memory_
	The memory backing reclaimed_pages_. More...

uint64_t	reclaimed_pages_count_
	Number of pages buffered so far. More...

Constructor & Destructor Documentation

foedus::cache::CacheManagerPimpl::CacheManagerPimpl ( )

delete

foedus::cache::CacheManagerPimpl::CacheManagerPimpl ( Engine * engine )

explicit

Definition at line 38 of file cache_manager_pimpl.cpp.

   : engine_(engine),
   stop_requested_(false),
   pool_(nullptr),
   hashtable_(nullptr),
   reclaimed_pages_(nullptr),
   reclaimed_pages_count_(0) {
 }

Member Function Documentation

std::string foedus::cache::CacheManagerPimpl::describe ( ) const

Definition at line 213 of file cache_manager_pimpl.cpp.

References foedus::memory::PagePool::Stat::allocated_pages_, cleaner_threshold_, engine_, foedus::Engine::get_soc_id(), foedus::memory::PagePool::get_stat(), pool_, reclaimed_pages_count_, reclaimed_pages_memory_, foedus::memory::PagePool::Stat::total_pages_, and urgent_threshold_.

Referenced by foedus::cache::CacheManager::describe(), handle_cleaner(), and uninitialize_once().

                                             {
   if (pool_ == nullptr) {
     return "<SnapshotCacheManager />";
   }
 
   std::stringstream str;
   memory::PagePool::Stat pool_stat = pool_->get_stat();
   str << "<SpCache "
     << " node=\"" << engine_->get_soc_id() << "\""
     << " total=\"" << pool_stat.total_pages_ << "\""
     << " alloc=\"" << pool_stat.allocated_pages_ << "\""
     << " threshold=\"" << cleaner_threshold_ << "\""
     << " urgent_threshold=\"" << urgent_threshold_ << "\""
     << " reclaimed_count=\"" << reclaimed_pages_count_ << "\""
     << ">" << reclaimed_pages_memory_ << "</SpCache>";
   return str.str();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::cache::CacheManagerPimpl::handle_cleaner ( )

Main routine of cleaner_.

Definition at line 119 of file cache_manager_pimpl.cpp.

References foedus::xct::XctManager::advance_current_global_epoch(), foedus::memory::PagePool::Stat::allocated_pages_, ASSERT_ND, cleaner_threshold_, describe(), foedus::debugging::StopWatch::elapsed_us(), engine_, foedus::xct::XctManager::get_current_global_epoch(), foedus::memory::PagePool::get_stat(), foedus::Engine::get_xct_manager(), handle_cleaner_evict_pages(), foedus::xct::XctManager::is_initialized(), foedus::assorted::memory_fence_acquire(), foedus::Epoch::one_more(), pool_, reclaimed_pages_, reclaimed_pages_count_, foedus::memory::PagePool::release(), foedus::debugging::StopWatch::stop(), stop_requested_, total_pages_, foedus::memory::PagePool::Stat::total_pages_, urgent_threshold_, and foedus::xct::XctManager::wait_for_current_global_epoch().

Referenced by initialize_once().

                                        {
   LOG(INFO) << "Here we go. Cleaner thread: " << describe();
 
   const uint32_t kIntervalMs = 5;  // should be a bit shorter than epoch-advance interval
   while (!stop_requested_) {
     DVLOG(2) << "Cleaner thread came in: " << describe();
     ASSERT_ND(reclaimed_pages_count_ == 0);
     assorted::memory_fence_acquire();
     memory::PagePool::Stat stat = pool_->get_stat();
     ASSERT_ND(stat.total_pages_ == total_pages_);
     if (stat.allocated_pages_ > cleaner_threshold_) {
       VLOG(0) << "Time to evict: " << describe();
 
       uint64_t target_count = stat.allocated_pages_ - cleaner_threshold_;
       debugging::StopWatch evict_watch;
       handle_cleaner_evict_pages(target_count);
       evict_watch.stop();
       VLOG(0) << "Evicted " << reclaimed_pages_count_ << " pages in " << evict_watch.elapsed_us()
         << "us: " << describe();
 
       if (reclaimed_pages_count_ > 0) {
         // We collected some number of pages in previous execution. now we have to wait for
         // grace period before returning them to the pool as free pages.
         xct::XctManager* xct_manager = engine_->get_xct_manager();
         ASSERT_ND(xct_manager->is_initialized());  // see stop_cleaner()'s comment why this is true.
         Epoch reclaimed_pages_epoch = xct_manager->get_current_global_epoch();
         VLOG(0) << "Collected " << reclaimed_pages_count_ << " pages. let's return them to "
           << "the pool: " << describe();
         Epoch wait_until = reclaimed_pages_epoch.one_more();
 
         // We have to wait for grace-period, in other words until the next epoch.
         if (stat.allocated_pages_ >= urgent_threshold_) {
           VLOG(0) << "We are in urgent lack of free pages, let's advance epoch right now";
           xct_manager->advance_current_global_epoch();
         }
         // wait forever, but occasionally wake up to check if the system is being shutdown
         while (!stop_requested_ && xct_manager->get_current_global_epoch() < wait_until) {
           const uint64_t interval_microsec = 100000ULL;
           xct_manager->wait_for_current_global_epoch(wait_until, interval_microsec);
         }
 
         if (!stop_requested_) {
           Epoch current_epoch = xct_manager->get_current_global_epoch();
           ASSERT_ND(reclaimed_pages_epoch < current_epoch);
           VLOG(0) << "Okay! reclaimed_pages_epoch_=" << reclaimed_pages_epoch
             << ", current_epoch=" << current_epoch;
 
           memory::PagePoolOffsetDynamicChunk chunk(reclaimed_pages_count_, reclaimed_pages_);
           pool_->release(reclaimed_pages_count_, &chunk);
           reclaimed_pages_count_ = 0;
         }
       } else {
         LOG(INFO) << "Wtf, we couldn't collect any pages? that's weird...: " << describe();
       }
 
       if (stat.allocated_pages_ >= urgent_threshold_) {
         LOG(INFO) << "Umm, still severely lacking free pages. This might mean"
           " that the cleaner thread is getting behind or the pool is too small: " << describe();
       }
     } else {
       DVLOG(2) << "Still enough free pages. do nothing";
     }
 
     if (!stop_requested_) {
       std::this_thread::sleep_for(std::chrono::milliseconds(kIntervalMs));
     }
   }
 
   LOG(INFO) << "Quiting... Cleaner thread: " << describe();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::cache::CacheManagerPimpl::handle_cleaner_evict_pages ( uint64_t target_count )

Evicts pages up to about target_count (maybe a bit more or less).

Results are written to reclaimed_pages_count_ and reclaimed_pages_.

Definition at line 190 of file cache_manager_pimpl.cpp.

References ASSERT_ND, foedus::cache::CacheHashtable::evict(), foedus::cache::CacheHashtable::EvictArgs::evicted_count_, hashtable_, reclaimed_pages_, and reclaimed_pages_count_.

Referenced by handle_cleaner().

                                                                         {
   ASSERT_ND(reclaimed_pages_count_ == 0);
   ASSERT_ND(target_count > 0);
   CacheHashtable::EvictArgs args = { target_count, 0, reclaimed_pages_ };
   hashtable_->evict(&args);
   reclaimed_pages_count_ = args.evicted_count_;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::cache::CacheManagerPimpl::initialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 47 of file cache_manager_pimpl.cpp.

References foedus::memory::AlignedMemory::alloc(), ASSERT_ND, foedus::EngineOptions::cache_, cleaner_, cleaner_threshold_, engine_, ERROR_STACK, foedus::memory::AlignedMemory::get_block(), foedus::memory::EngineMemory::get_local_memory(), foedus::Engine::get_memory_manager(), foedus::Engine::get_options(), foedus::memory::NumaNodeMemory::get_snapshot_cache_table(), foedus::memory::NumaNodeMemory::get_snapshot_pool(), foedus::Engine::get_soc_id(), foedus::memory::PagePool::get_stat(), foedus::thread::ThreadOptions::get_total_thread_count(), handle_cleaner(), hashtable_, foedus::DefaultInitializable::is_initialized(), foedus::Engine::is_master(), foedus::kErrorCodeDepedentModuleUnavailableInit, foedus::memory::AlignedMemory::kNumaAllocOnnode, foedus::kRetOk, foedus::EngineOptions::memory_, pool_, foedus::memory::MemoryOptions::private_page_pool_initial_grab_, reclaimed_pages_, reclaimed_pages_count_, reclaimed_pages_memory_, foedus::cache::CacheOptions::snapshot_cache_eviction_threshold_, foedus::cache::CacheOptions::snapshot_cache_urgent_threshold_, stop_requested_, foedus::EngineOptions::thread_, total_pages_, foedus::memory::PagePool::Stat::total_pages_, and urgent_threshold_.

Referenced by foedus::cache::CacheManager::initialize_once().

                                               {
   if (engine_->is_master()) {
     // nothing to do in master engine
     return kRetOk;
   } else if (!engine_->get_memory_manager()->is_initialized()) {
     return ERROR_STACK(kErrorCodeDepedentModuleUnavailableInit);
   }
 
   LOG(INFO) << "Initializing Snapshot Cache in Node-" << engine_->get_soc_id() << "...";
 
   memory::NumaNodeMemory* node = engine_->get_memory_manager()->get_local_memory();
   pool_ = node->get_snapshot_pool();
   hashtable_ = node->get_snapshot_cache_table();
   reclaimed_pages_count_ = 0;
 
   // So far, the reclaimed_pages_memory_ is large enough to hold all pages in the pool at once.
   // This is obviously too much for most cases, but wouldn't be an issue as the memory consumption
   // is anyway negligibly smaller than the page pool itself. Keep it simple stupid.
   total_pages_ = pool_->get_stat().total_pages_;
   const CacheOptions& options = engine_->get_options().cache_;
 
   cleaner_threshold_ = total_pages_ * options.snapshot_cache_eviction_threshold_;
   urgent_threshold_ = total_pages_ * options.snapshot_cache_urgent_threshold_;
 
   // exclude page counts initially grabbed by each thread.
   uint64_t initial_allocations
     = engine_->get_options().memory_.private_page_pool_initial_grab_
     * engine_->get_options().thread_.get_total_thread_count();
   cleaner_threshold_ += initial_allocations;
   urgent_threshold_ += initial_allocations;
   if (cleaner_threshold_ > total_pages_) {
     cleaner_threshold_ = total_pages_;
   }
   if (urgent_threshold_ > total_pages_) {
     urgent_threshold_ = total_pages_;
   }
 
   ASSERT_ND(cleaner_threshold_ > 0);
   ASSERT_ND(urgent_threshold_ >= cleaner_threshold_);
   ASSERT_ND(total_pages_ >= urgent_threshold_);
 
   reclaimed_pages_memory_.alloc(
     total_pages_ * sizeof(memory::PagePoolOffset),
     1ULL << 21,
     memory::AlignedMemory::kNumaAllocOnnode,
     engine_->get_soc_id());
   reclaimed_pages_ = reinterpret_cast<memory::PagePoolOffset*>(reclaimed_pages_memory_.get_block());
 
   // launch the cleaner thread
   stop_requested_.store(false);
   cleaner_ = std::move(std::thread(&CacheManagerPimpl::handle_cleaner, this));
 
   return kRetOk;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::cache::CacheManagerPimpl::stop_cleaner ( )

Definition at line 198 of file cache_manager_pimpl.cpp.

References cleaner_, foedus::kRetOk, and stop_requested_.

Referenced by foedus::cache::CacheManager::stop_cleaner(), and uninitialize_once().

                                            {
   bool original = false;
   bool changed = stop_requested_.compare_exchange_strong(original, true);
   if (changed) {
     if (cleaner_.joinable()) {
       LOG(INFO) << "Requesting Cache Cleaner to stop...";
       cleaner_.join();
     }
   } else {
     LOG(INFO) << "Cache Cleaner seems already stop-requested";
   }
   return kRetOk;
 }

Here is the caller graph for this function:

ErrorStack foedus::cache::CacheManagerPimpl::uninitialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 102 of file cache_manager_pimpl.cpp.

References CHECK_ERROR, describe(), engine_, hashtable_, foedus::Engine::is_master(), foedus::kRetOk, pool_, reclaimed_pages_, reclaimed_pages_count_, reclaimed_pages_memory_, foedus::memory::AlignedMemory::release_block(), and stop_cleaner().

Referenced by foedus::cache::CacheManager::uninitialize_once().

                                                 {
   if (engine_->is_master()) {
     // nothing to do in master engine
     return kRetOk;
   }
 
   LOG(INFO) << "Uninitializing Snapshot Cache... " << describe();
   CHECK_ERROR(stop_cleaner());
 
   pool_ = nullptr;
   hashtable_ = nullptr;
   reclaimed_pages_ = nullptr;
   reclaimed_pages_memory_.release_block();
   reclaimed_pages_count_ = 0;
   return kRetOk;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

std::thread foedus::cache::CacheManagerPimpl::cleaner_

The only cleaner thread in this SOC engine.

In a master engine, this is not used.

Definition at line 70 of file cache_manager_pimpl.hpp.

Referenced by initialize_once(), and stop_cleaner().

uint64_t foedus::cache::CacheManagerPimpl::cleaner_threshold_

the number of allocated pages above which cleaner starts cleaning

Definition at line 73 of file cache_manager_pimpl.hpp.

Referenced by describe(), handle_cleaner(), and initialize_once().

Engine* const foedus::cache::CacheManagerPimpl::engine_

Definition at line 63 of file cache_manager_pimpl.hpp.

Referenced by describe(), handle_cleaner(), initialize_once(), and uninitialize_once().

CacheHashtable* foedus::cache::CacheManagerPimpl::hashtable_

The cache hashtable (SnapshotPageId -> offset in pool) on top of the page pool.

This cache manager keeps checking In a master engine, this is null.

Definition at line 93 of file cache_manager_pimpl.hpp.

Referenced by handle_cleaner_evict_pages(), initialize_once(), and uninitialize_once().

memory::PagePool* foedus::cache::CacheManagerPimpl::pool_

The SOC-local snapshot page pool in this SOC engine.

This passively (no thread by itself) holds used pages and free pages. In a master engine, this is null.

Definition at line 85 of file cache_manager_pimpl.hpp.

Referenced by describe(), handle_cleaner(), initialize_once(), and uninitialize_once().

memory::PagePoolOffset* foedus::cache::CacheManagerPimpl::reclaimed_pages_

This buffers pages being reclaimed.

We reclaim pages after a grace period, rather than immediately after collecting them from the hashtable. Because of this epoch-based grace-period, we don't have to worry about thread-safety. This is super benefitial for simplicity and scalability. Because snapshot pages are immutable, that's all we have to do. Whereas, traditional bufferpools have to take care of dirty pages and singularity of page, so they can't just do grace-period. So far, the grace period is one epoch.

Definition at line 106 of file cache_manager_pimpl.hpp.

Referenced by handle_cleaner(), handle_cleaner_evict_pages(), initialize_once(), and uninitialize_once().

uint64_t foedus::cache::CacheManagerPimpl::reclaimed_pages_count_

Number of pages buffered so far.

Definition at line 112 of file cache_manager_pimpl.hpp.

Referenced by describe(), handle_cleaner(), handle_cleaner_evict_pages(), initialize_once(), and uninitialize_once().

memory::AlignedMemory foedus::cache::CacheManagerPimpl::reclaimed_pages_memory_

The memory backing reclaimed_pages_.

Definition at line 109 of file cache_manager_pimpl.hpp.

Referenced by describe(), initialize_once(), and uninitialize_once().

std::atomic<bool> foedus::cache::CacheManagerPimpl::stop_requested_

to stop cleaner_

Definition at line 77 of file cache_manager_pimpl.hpp.

Referenced by handle_cleaner(), initialize_once(), and stop_cleaner().

uint64_t foedus::cache::CacheManagerPimpl::total_pages_

Definition at line 71 of file cache_manager_pimpl.hpp.

Referenced by handle_cleaner(), and initialize_once().

uint64_t foedus::cache::CacheManagerPimpl::urgent_threshold_

the number of allocated pages above which cleaner advances epoch to release pages

Definition at line 75 of file cache_manager_pimpl.hpp.

Referenced by describe(), handle_cleaner(), and initialize_once().

The documentation for this class was generated from the following files:

/home/shino/foedus_code/foedus-core/include/foedus/cache/cache_manager_pimpl.hpp
/home/shino/foedus_code/foedus-core/src/foedus/cache/cache_manager_pimpl.cpp

Detailed Description

Public Member Functions

Public Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation