foedus::memory::EngineMemory Class Reference

Repository of all memories dynamically acquired and shared within one database engine. More...

Detailed Description

Repository of all memories dynamically acquired and shared within one database engine.

Overview

This is the top-level memory repository in our engine. All other memory types are contained in this object.

List of engine-wide memories

• List of NumaNodeMemory, one for each NUMA socket in the machine.
• Page pool for volatile read/write store (VolatilePage) and the read-only bufferpool (SnapshotPage).

Definition at line 52 of file engine_memory.hpp.

#include <engine_memory.hpp>

Inheritance diagram for foedus::memory::EngineMemory:

Collaboration diagram for foedus::memory::EngineMemory:

Public Member Functions
	EngineMemory ()=delete
	EngineMemory (Engine *engine)
ErrorStack	initialize_once () override
ErrorStack	uninitialize_once () override
void *	get_shared_user_memory () const
	As part of the global shared memory, we reserve this size of 'user memory' that can be used for arbitrary purporses by the user to communicate between SOCs. More...
uint64_t	get_shared_user_memory_size () const
NumaNodeMemory *	get_local_memory () const
NumaNodeMemoryRef *	get_node_memory (foedus::thread::ThreadGroupId group) const
std::string	dump_free_memory_stat () const
	Report rough statistics of free memory. More...
const GlobalVolatilePageResolver &	get_global_volatile_page_resolver () const
	Returns the page resolver to convert volatile page ID to page pointer. More...
ErrorStack	grab_one_volatile_page (foedus::thread::ThreadGroupId node, storage::VolatilePagePointer *pointer, storage::Page **page)
	A convenience function to grab one free volatile page from the given node. More...
ErrorStack	load_one_volatile_page (cache::SnapshotFileSet *fileset, storage::SnapshotPagePointer snapshot_pointer, storage::VolatilePagePointer *pointer, storage::Page **page)
	Another convenience method that also reads an existing snapshot page to the volatile page. More...
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 ()

Constructor & Destructor Documentation

foedus::memory::EngineMemory::EngineMemory ( )

delete

foedus::memory::EngineMemory::EngineMemory ( Engine *  engine )

inlineexplicit

Definition at line 55 of file engine_memory.hpp.

: engine_(engine), local_memory_(CXX11_NULLPTR) {}

Member Function Documentation

std::string foedus::memory::EngineMemory::dump_free_memory_stat

(

)

const

Report rough statistics of free memory.

Definition at line 121 of file engine_memory.cpp.

References foedus::memory::NumaNodeMemoryRef::dump_free_memory_stat(), foedus::Engine::get_options(), foedus::thread::ThreadOptions::group_count_, and foedus::EngineOptions::thread_.

                                                    {
  std::stringstream ret;
  ret << "  == Free memory stat ==" << std::endl;
  thread::ThreadGroupId numa_nodes = engine_->get_options().thread_.group_count_;
  for (thread::ThreadGroupId node = 0; node < numa_nodes; ++node) {
    NumaNodeMemoryRef* memory = node_memories_[node];
    ret << " - Node_" << static_cast<int>(node) << " -" << std::endl;
    ret << memory->dump_free_memory_stat();
    if (node + 1U < numa_nodes) {
      ret << std::endl;
    }
  }
  return ret.str();
}

Here is the call graph for this function:

const GlobalVolatilePageResolver& foedus::memory::EngineMemory::get_global_volatile_page_resolver ( ) const

inline

Returns the page resolver to convert volatile page ID to page pointer.

Any code can get the global page resolver from engine memory. Note that this is only for volatile pages. As snapshot cache is per-node, there is no global snapshot page resolver (just the node-local one should be enough).

See also

thread::Thread::get_global_volatile_page_resolver()

Definition at line 90 of file engine_memory.hpp.

Referenced by foedus::storage::hash::HashStoragePimpl::debugout_single_thread(), foedus::storage::hash::HashStoragePimpl::debugout_single_thread_data(), foedus::storage::masstree::MasstreeStoragePimpl::debugout_single_thread_follow(), foedus::storage::hash::HashStoragePimpl::debugout_single_thread_intermediate(), foedus::storage::array::ArrayPartitioner::design_partition(), foedus::storage::masstree::MasstreePartitioner::design_partition(), foedus::storage::masstree::design_partition_first_parallel(), foedus::storage::hash::HashPartitioner::design_partition_task(), foedus::storage::array::ArrayStorage::drop(), foedus::storage::masstree::MasstreeStoragePimpl::drop(), foedus::storage::hash::HashStoragePimpl::drop(), foedus::storage::Composer::DropVolatilesArguments::drop(), foedus::storage::sequential::SequentialStoragePimpl::get_head_pointer(), foedus::storage::sequential::SequentialStoragePimpl::get_tail_pointer(), foedus::storage::hash::HashStoragePimpl::hcc_reset_all_temperature_stat_data(), foedus::storage::masstree::MasstreeStoragePimpl::hcc_reset_all_temperature_stat_follow(), foedus::storage::array::ArrayStoragePimpl::hcc_reset_all_temperature_stat_intermediate(), foedus::storage::hash::HashStoragePimpl::hcc_reset_all_temperature_stat_intermediate(), foedus::xct::Xct::initialize(), foedus::thread::ThreadPimpl::initialize_once(), foedus::storage::masstree::MasstreeStoragePimpl::peek_volatile_page_boundaries(), foedus::storage::StorageManagerPimpl::reinitialize_for_recovered_snapshot(), foedus::storage::hash::HashIntermediatePage::release_pages_recursive_parallel(), foedus::storage::masstree::release_parallel(), foedus::storage::hash::release_parallel(), foedus::storage::masstree::MasstreeBorderPage::track_moved_record(), foedus::storage::masstree::MasstreeBorderPage::track_moved_record_next_layer(), foedus::storage::hash::HashStoragePimpl::track_moved_record_search(), foedus::storage::hash::HashStoragePimpl::verify_single_thread(), foedus::storage::hash::HashStoragePimpl::verify_single_thread_data(), and foedus::storage::hash::HashStoragePimpl::verify_single_thread_intermediate().

                                                                              {
    return global_volatile_page_resolver_;
  }

Here is the caller graph for this function:

NumaNodeMemory* foedus::memory::EngineMemory::get_local_memory ( ) const

inline

Definition at line 73 of file engine_memory.hpp.

Referenced by foedus::thread::ThreadGroup::initialize_once(), foedus::cache::CacheManagerPimpl::initialize_once(), foedus::thread::ThreadPimpl::initialize_once(), foedus::log::Logger::initialize_once(), and foedus::log::ThreadLogBuffer::initialize_once().

                                           {
    return local_memory_;
  }

Here is the caller graph for this function:

NumaNodeMemoryRef* foedus::memory::EngineMemory::get_node_memory ( foedus::thread::ThreadGroupId  group ) const

inline

Definition at line 76 of file engine_memory.hpp.

Referenced by foedus::storage::hash::HashStoragePimpl::create(), foedus::storage::sequential::SequentialStoragePimpl::drop(), foedus::storage::Composer::DropVolatilesArguments::drop(), foedus::snapshot::SnapshotManagerPimpl::drop_volatile_pages_parallel(), foedus::storage::sequential::SequentialComposer::drop_volatiles(), foedus::thread::ThreadPimpl::flush_retired_volatile_page(), foedus::storage::sequential::SequentialStoragePimpl::for_every_page(), foedus::memory::RoundRobinPageGrabBatch::grab(), foedus::memory::DivvyupPageGrabBatch::grab(), grab_one_volatile_page(), foedus::storage::sequential::SequentialStoragePimpl::initialize_head_tail_pages(), foedus::storage::masstree::MasstreeStoragePimpl::load_empty(), foedus::memory::RoundRobinPageGrabBatch::release_all(), foedus::memory::DivvyupPageGrabBatch::release_all(), foedus::memory::PageReleaseBatch::release_chunk(), foedus::storage::hash::HashIntermediatePage::release_pages_recursive_parallel(), foedus::storage::masstree::MasstreeIntermediatePage::release_pages_recursive_parallel(), and foedus::thread::ThreadPimpl::uninitialize_once().

                                                                            {
    return node_memories_[group];
  }

Here is the caller graph for this function:

void * foedus::memory::EngineMemory::get_shared_user_memory

(

)

const

As part of the global shared memory, we reserve this size of 'user memory' that can be used for arbitrary purporses by the user to communicate between SOCs.

See also

get_shared_user_memory_size()

Definition at line 113 of file engine_memory.cpp.

References foedus::soc::SocManager::get_shared_user_memory(), and foedus::Engine::get_soc_manager().

                                                 {
  return engine_->get_soc_manager()->get_shared_user_memory();
}

Here is the call graph for this function:

uint64_t foedus::memory::EngineMemory::get_shared_user_memory_size

(

)

const

Returns

the byte size of shared user-controlled memory. Equivalent to SocOptions.shared_user_memory_size_kb_ << 10.

See also

get_shared_user_memory()

Definition at line 117 of file engine_memory.cpp.

References foedus::soc::SocManager::get_shared_user_memory_size(), and foedus::Engine::get_soc_manager().

                                                         {
  return engine_->get_soc_manager()->get_shared_user_memory_size();
}

Here is the call graph for this function:

ErrorStack foedus::memory::EngineMemory::grab_one_volatile_page	(	foedus::thread::ThreadGroupId	node,
		storage::VolatilePagePointer *	pointer,
		storage::Page **	page
	)

A convenience function to grab one free volatile page from the given node.

DO NOT USE THIS METHOD in a frequently invoked place. You should use the batched interface to avoid mutex each time. This method is used only where performance doesn't matter.

Definition at line 136 of file engine_memory.cpp.

References get_node_memory(), foedus::memory::PagePool::get_resolver(), foedus::memory::NumaNodeMemoryRef::get_volatile_pool(), foedus::memory::PagePool::grab_one(), foedus::kRetOk, foedus::memory::LocalPageResolver::resolve_offset_newpage(), foedus::storage::VolatilePagePointer::set(), and WRAP_ERROR_CODE.

Referenced by foedus::storage::array::ArrayStoragePimpl::load_empty(), and load_one_volatile_page().

                      {
  PagePool* pool = get_node_memory(node)->get_volatile_pool();
  PagePoolOffset offset;
  WRAP_ERROR_CODE(pool->grab_one(&offset));
  *page = pool->get_resolver().resolve_offset_newpage(offset);
  pointer->set(node, offset);
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::memory::EngineMemory::initialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 43 of file engine_memory.cpp.

References ASSERT_ND, foedus::memory::LocalPageResolver::begin_, CHECK_ERROR, foedus::memory::LocalPageResolver::end_, ERROR_STACK, foedus::memory::PagePool::get_base(), foedus::Engine::get_debug(), foedus::Engine::get_options(), foedus::memory::PagePool::get_resolver(), foedus::Engine::get_soc_id(), foedus::memory::NumaNodeMemoryRef::get_volatile_pool(), foedus::thread::ThreadOptions::group_count_, foedus::DefaultInitializable::initialize(), foedus::DefaultInitializable::is_initialized(), foedus::Engine::is_master(), foedus::kErrorCodeDepedentModuleUnavailableInit, foedus::kRetOk, numa_available(), and foedus::EngineOptions::thread_.

                                         {
  LOG(INFO) << "Initializing EngineMemory..";
  if (!engine_->get_debug()->is_initialized()) {
    return ERROR_STACK(kErrorCodeDepedentModuleUnavailableInit);
  } else if (::numa_available() < 0) {
    LOG(WARNING) << "WARNING, this machine is not a NUMA machine. FOEDUS still works fine,"
      << " but it is mainly designed for large servers with many sockets and cores";
    // Even if the kernel is built without NUMA (eg ARMv8), we keep running.
    // return ERROR_STACK(kErrorCodeMemoryNumaUnavailable);
  }

  ASSERT_ND(node_memories_.empty());
  const EngineOptions& options = engine_->get_options();
  const thread::ThreadGroupId numa_nodes = options.thread_.group_count_;
  GlobalVolatilePageResolver::Base bases[256];
  uint64_t pool_begin = 0, pool_end = 0;
  for (thread::ThreadGroupId node = 0; node < numa_nodes; ++node) {
    NumaNodeMemoryRef* ref = new NumaNodeMemoryRef(engine_, node);
    node_memories_.push_back(ref);
    bases[node] = ref->get_volatile_pool()->get_base();
    pool_begin = ref->get_volatile_pool()->get_resolver().begin_;
    pool_end = ref->get_volatile_pool()->get_resolver().end_;
  }
  global_volatile_page_resolver_ = GlobalVolatilePageResolver(
    bases,
    numa_nodes,
    pool_begin,
    pool_end);

  // Initialize local memory.
  if (!engine_->is_master()) {
    soc::SocId node = engine_->get_soc_id();
    local_memory_ = new NumaNodeMemory(engine_, node);
    CHECK_ERROR(local_memory_->initialize());
    LOG(INFO) << "Node memory-" << node << " was initialized!";
  } else {
    if (options.memory_.rigorous_memory_boundary_check_) {
      LOG(WARNING) << "CAUTION: memory_.rigorous_memory_boundary_check_ is ON. We will"
        << " put mprotect-ed pages between memory regions for debugging. It will be SLOW!";
    }
    if (options.memory_.rigorous_page_boundary_check_) {
      LOG(WARNING) << "CAUTION: memory_.rigorous_page_boundary_check_ is ON. We will"
        << " put mprotect-ed pages between every single page for debugging. It will be SLOOOW!";
    }
  }
  return kRetOk;
}

Here is the call graph for this function:

ErrorStack foedus::memory::EngineMemory::load_one_volatile_page	(	cache::SnapshotFileSet *	fileset,
		storage::SnapshotPagePointer	snapshot_pointer,
		storage::VolatilePagePointer *	pointer,
		storage::Page **	page
	)

Another convenience method that also reads an existing snapshot page to the volatile page.

Again, its performance is not optimized at all. Do not abuse. In fact, this is used only for one-time initialization code.

Definition at line 148 of file engine_memory.cpp.

References ASSERT_ND, CHECK_ERROR, foedus::storage::extract_numa_node_from_snapshot_pointer(), grab_one_volatile_page(), foedus::kRetOk, foedus::cache::SnapshotFileSet::read_page(), foedus::storage::VolatilePagePointer::word, and WRAP_ERROR_CODE.

Referenced by foedus::storage::array::ArrayStoragePimpl::load(), foedus::storage::masstree::MasstreeStoragePimpl::load(), and foedus::storage::hash::HashStoragePimpl::load().

                      {
  ASSERT_ND(snapshot_pointer != 0);
  thread::ThreadGroupId node = storage::extract_numa_node_from_snapshot_pointer(snapshot_pointer);
  CHECK_ERROR(grab_one_volatile_page(node, pointer, page));
  WRAP_ERROR_CODE(fileset->read_page(snapshot_pointer, *page));
  (*page)->get_header().snapshot_ = false;
  (*page)->get_header().page_id_ = pointer->word;
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::memory::EngineMemory::uninitialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 91 of file engine_memory.cpp.

References foedus::ErrorStackBatch::emprace_back(), ERROR_STACK, foedus::Engine::get_debug(), foedus::Engine::get_soc_id(), foedus::DefaultInitializable::is_initialized(), foedus::Engine::is_master(), foedus::kErrorCodeDepedentModuleUnavailableUninit, SUMMARIZE_ERROR_BATCH, and foedus::DefaultInitializable::uninitialize().

                                           {
  LOG(INFO) << "Uninitializing EngineMemory..";
  ErrorStackBatch batch;
  if (!engine_->get_debug()->is_initialized()) {
    batch.emprace_back(ERROR_STACK(kErrorCodeDepedentModuleUnavailableUninit));
  }
  for (auto* ref : node_memories_) {
    delete ref;
  }
  node_memories_.clear();

  // Uninitialize local memory.
  if (!engine_->is_master() && local_memory_) {
    soc::SocId node = engine_->get_soc_id();
    batch.emprace_back(local_memory_->uninitialize());
    delete local_memory_;
    local_memory_ = nullptr;
    LOG(INFO) << "Node memory-" << node << " was uninitialized!";
  }
  return SUMMARIZE_ERROR_BATCH(batch);
}

Here is the call graph for this function:

---

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

• /home/shino/foedus_code/foedus-core/include/foedus/memory/engine_memory.hpp
• /home/shino/foedus_code/foedus-core/src/foedus/memory/engine_memory.cpp