foedus::soc::SharedMemoryRepo Class Reference

Repository of all shared memory in one FOEDUS instance. More...

Detailed Description

Repository of all shared memory in one FOEDUS instance.

These are the memories shared across SOCs, which are allocated at initialization. Be super careful on objects placed in these shared memories. You can't put objects with heap-allocated contents, such as std::string.

Definition at line 463 of file shared_memory_repo.hpp.

#include <shared_memory_repo.hpp>

Public Member Functions
	SharedMemoryRepo ()
	~SharedMemoryRepo ()
	SharedMemoryRepo (const SharedMemoryRepo &other)=delete
SharedMemoryRepo &	operator= (const SharedMemoryRepo &other)=delete
ErrorStack	allocate_shared_memories (uint64_t upid, Eid eid, const EngineOptions &options)
	Master process creates shared memories by calling this method. More...
ErrorStack	attach_shared_memories (uint64_t master_upid, Eid master_eid, SocId my_soc_id, EngineOptions *options)
	Child processes (emulated or not) set a reference to shared memory and receive the EngnieOption value by calling this method. More...
void	mark_for_release ()
	Marks shared memories as being removed so that it will be reclaimed when all processes detach it. More...
void	deallocate_shared_memories ()
	Detaches and releases the shared memories. More...
void *	get_global_memory ()
GlobalMemoryAnchors *	get_global_memory_anchors ()
void *	get_global_user_memory ()
void	change_master_status (MasterEngineStatus::StatusCode new_status)
MasterEngineStatus::StatusCode	get_master_status () const
void *	get_node_memory (SocId node)
NodeMemoryAnchors *	get_node_memory_anchors (SocId node)
void	change_child_status (SocId node, ChildEngineStatus::StatusCode new_status)
ChildEngineStatus::StatusCode	get_child_status (SocId node) const
ThreadMemoryAnchors *	get_thread_memory_anchors (thread::ThreadId thread_id)
void *	get_volatile_pool (SocId node)

Static Public Member Functions
static uint64_t	calculate_global_memory_size (uint64_t xml_size, const EngineOptions &options)
static uint64_t	calculate_node_memory_size (const EngineOptions &options)

Constructor & Destructor Documentation

foedus::soc::SharedMemoryRepo::SharedMemoryRepo ( )

inline

Definition at line 465 of file shared_memory_repo.hpp.

                     :
    soc_count_(0),
    my_soc_id_(0),
    node_memories_(CXX11_NULLPTR),
    node_memory_anchors_(CXX11_NULLPTR) {}

foedus::soc::SharedMemoryRepo::~SharedMemoryRepo ( )

inline

Definition at line 470 of file shared_memory_repo.hpp.

References deallocate_shared_memories().

{ deallocate_shared_memories(); }

Here is the call graph for this function:

foedus::soc::SharedMemoryRepo::SharedMemoryRepo ( const SharedMemoryRepo &  other )

delete

Member Function Documentation

ErrorStack foedus::soc::SharedMemoryRepo::allocate_shared_memories	(	uint64_t	upid,
		Eid	eid,
		const EngineOptions &	options
	)

Master process creates shared memories by calling this method.

Definition at line 96 of file shared_memory_repo.cpp.

References foedus::soc::align_2mb(), foedus::memory::SharedMemory::alloc(), calculate_global_memory_size(), calculate_node_memory_size(), CHECK_ERROR, deallocate_shared_memories(), foedus::memory::SharedMemory::get_block(), foedus::soc::get_self_path(), foedus::soc::MasterEngineStatus::kInitial, foedus::soc::kMaxSocs, foedus::kRetOk, foedus::soc::GlobalMemoryAnchors::master_status_memory_, foedus::EngineOptions::memory_, foedus::memory::MemoryOptions::rigorous_memory_boundary_check_, foedus::memory::MemoryOptions::rigorous_page_boundary_check_, foedus::externalize::Externalizable::save_to_stream(), and foedus::soc::MasterEngineStatus::status_code_.

Referenced by foedus::soc::SocManagerPimpl::initialize_master().

                                {
  deallocate_shared_memories();
  init_empty(options);

  // We place a serialized EngineOptions in the beginning of shared memory.
  std::stringstream options_stream;
  options.save_to_stream(&options_stream);
  std::string xml(options_stream.str());
  uint64_t xml_size = xml.size();

  // construct unique meta files using PID.
  uint64_t global_memory_size = align_2mb(calculate_global_memory_size(xml_size, options));
  std::string global_memory_path = get_self_path(upid, eid) + std::string("_global");
  const bool global_hugepages = !options.memory_.rigorous_memory_boundary_check_;
  CHECK_ERROR(global_memory_.alloc(global_memory_path, global_memory_size, 0, global_hugepages));

  // from now on, be very careful to not exit without releasing this shared memory.

  set_global_memory_anchors(xml_size, options, true);
  global_memory_anchors_.master_status_memory_->status_code_ = MasterEngineStatus::kInitial;

  // copy the EngineOptions string into the beginning of the global memory
  std::memcpy(global_memory_.get_block(), &xml_size, sizeof(xml_size));
  std::memcpy(global_memory_.get_block() + sizeof(xml_size), xml.data(), xml_size);

  // the following is parallelized
  uint64_t node_memory_size = align_2mb(calculate_node_memory_size(options));
  ErrorStack alloc_results[kMaxSocs];
  std::vector< std::thread > alloc_threads;
  for (uint16_t node = 0; node < soc_count_; ++node) {
    alloc_threads.emplace_back(std::thread(
      SharedMemoryRepo::allocate_one_node,
      upid,
      eid,
      node,
      node_memory_size,
      options.memory_.rigorous_memory_boundary_check_,
      options.memory_.rigorous_page_boundary_check_,
      alloc_results + node,
      this));
  }

  ErrorStack last_error;
  bool failed = false;
  for (uint16_t node = 0; node < soc_count_; ++node) {
    alloc_threads[node].join();
    if (alloc_results[node].is_error()) {
      std::cerr << "[FOEDUS] Failed to allocate node shared memory for node-" << node
        << ". " << alloc_results[node] << std::endl;
      last_error = alloc_results[node];
      failed = true;
    }
  }

  if (failed) {
    deallocate_shared_memories();
    return last_error;
  }

  for (uint16_t node = 0; node < soc_count_; ++node) {
    set_node_memory_anchors(node, options, true);
  }

  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::soc::SharedMemoryRepo::attach_shared_memories	(	uint64_t	master_upid,
		Eid	master_eid,
		SocId	my_soc_id,
		EngineOptions *	options
	)

Child processes (emulated or not) set a reference to shared memory and receive the EngnieOption value by calling this method.

Parameters

[in]	master_upid	Universal (or Unique) ID of the master process. This is the parameter that has to be passed from the master process to child processes.
[in]	master_eid	Engine ID of the master process. This is another parameter that has to be passed from the master process to child processes.
[in]	my_soc_id	SOC ID of this node.
[out]	options	One of the shared memory contains the EngineOption values. This method also retrieves them from the shared memory.

Definition at line 165 of file shared_memory_repo.cpp.

References ASSERT_ND, foedus::memory::SharedMemory::attach(), change_child_status(), CHECK_ERROR, deallocate_shared_memories(), ERROR_STACK, foedus::memory::SharedMemory::get_block(), foedus::soc::get_master_path(), foedus::memory::SharedMemory::is_null(), foedus::kErrorCodeSocShmAttachFailed, foedus::soc::ChildEngineStatus::kFatalError, foedus::kRetOk, foedus::externalize::Externalizable::load_from_string(), foedus::EngineOptions::memory_, and foedus::memory::MemoryOptions::rigorous_memory_boundary_check_.

Referenced by foedus::soc::SocManagerPimpl::initialize_child().

                          {
  deallocate_shared_memories();

  std::string base = get_master_path(master_upid, master_eid);
  std::string global_memory_path = base + std::string("_global");
  const bool global_hugepages = !options->memory_.rigorous_memory_boundary_check_;
  global_memory_.attach(global_memory_path, global_hugepages);
  if (global_memory_.is_null()) {
    deallocate_shared_memories();
    return ERROR_STACK(kErrorCodeSocShmAttachFailed);
  }

  // read the options from global_memory
  uint64_t xml_size = 0;
  std::memcpy(&xml_size, global_memory_.get_block(), sizeof(xml_size));
  ASSERT_ND(xml_size > 0);
  std::string xml(global_memory_.get_block() + sizeof(xml_size), xml_size);
  CHECK_ERROR(options->load_from_string(xml));

  my_soc_id_ = my_soc_id;
  init_empty(*options);
  set_global_memory_anchors(xml_size, *options, false);

  bool failed = false;
  for (uint16_t node = 0; node < soc_count_; ++node) {
    std::string node_memory_str = base + std::string("_node_") + std::to_string(node);
    node_memories_[node].attach(node_memory_str, !options->memory_.rigorous_memory_boundary_check_);
    if (node_memories_[node].is_null()) {
      failed = true;
    } else {
      set_node_memory_anchors(node, *options, false);
    }
  }

  if (failed) {
    if (!node_memories_[my_soc_id].is_null()) {
      // then we can at least notify the error via the shared memory
      change_child_status(my_soc_id, ChildEngineStatus::kFatalError);
    }
    deallocate_shared_memories();
    return ERROR_STACK(kErrorCodeSocShmAttachFailed);
  }
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint64_t foedus::soc::SharedMemoryRepo::calculate_global_memory_size ( uint64_t  xml_size, const EngineOptions &  options  )

static

Definition at line 365 of file shared_memory_repo.cpp.

References foedus::soc::align_4kb(), foedus::soc::GlobalMemoryAnchors::kLogManagerMemorySize, foedus::soc::GlobalMemoryAnchors::kMasterStatusMemorySize, foedus::soc::GlobalMemoryAnchors::kMetaLoggerSize, foedus::soc::GlobalMemoryAnchors::kRestartManagerMemorySize, foedus::soc::GlobalMemoryAnchors::kSavepointManagerMemorySize, foedus::soc::GlobalMemoryAnchors::kSnapshotManagerMemorySize, foedus::soc::GlobalMemoryAnchors::kStorageManagerMemorySize, foedus::soc::GlobalMemoryAnchors::kStorageMemorySize, foedus::soc::GlobalMemoryAnchors::kXctManagerMemorySize, foedus::storage::StorageOptions::max_storages_, foedus::storage::StorageOptions::partitioner_data_memory_mb_, foedus::soc::SocOptions::shared_user_memory_size_kb_, foedus::EngineOptions::soc_, and foedus::EngineOptions::storage_.

Referenced by allocate_shared_memories(), and foedus::EngineOptions::calculate_required_memory().

                                {
  const uint64_t kBoundarySize = sizeof(assorted::ProtectedBoundary);
  uint64_t total = 0;
  total += align_4kb(sizeof(xml_size) + xml_size) + kBoundarySize;  // options_xml_
  total += GlobalMemoryAnchors::kMasterStatusMemorySize + kBoundarySize;
  total += GlobalMemoryAnchors::kLogManagerMemorySize + kBoundarySize;
  total += GlobalMemoryAnchors::kMetaLoggerSize + kBoundarySize;
  total += GlobalMemoryAnchors::kRestartManagerMemorySize + kBoundarySize;
  total += GlobalMemoryAnchors::kSavepointManagerMemorySize + kBoundarySize;
  total += GlobalMemoryAnchors::kSnapshotManagerMemorySize + kBoundarySize;
  total += GlobalMemoryAnchors::kStorageManagerMemorySize + kBoundarySize;
  total += GlobalMemoryAnchors::kXctManagerMemorySize + kBoundarySize;
  total +=
    align_4kb(sizeof(storage::PartitionerMetadata) * options.storage_.max_storages_)
    + kBoundarySize;
  total +=
    (static_cast<uint64_t>(options.storage_.partitioner_data_memory_mb_) << 20)
     + kBoundarySize;
  total +=
    align_4kb(sizeof(storage::StorageId) * options.storage_.max_storages_)
    + kBoundarySize;
  total +=
    static_cast<uint64_t>(GlobalMemoryAnchors::kStorageMemorySize) * options.storage_.max_storages_
    + kBoundarySize;
  total += align_4kb(1024ULL * options.soc_.shared_user_memory_size_kb_) + kBoundarySize;
  return total;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint64_t foedus::soc::SharedMemoryRepo::calculate_node_memory_size ( const EngineOptions &  options )

static

Definition at line 505 of file shared_memory_repo.cpp.

References foedus::soc::align_4kb(), foedus::soc::NodeMemoryAnchors::kChildStatusMemorySize, foedus::soc::NodeMemoryAnchors::kLoggerMemorySize, foedus::soc::NodeMemoryAnchors::kLogReducerMemorySize, foedus::soc::ThreadMemoryAnchors::kMcsRwAsyncMappingMemorySize, foedus::soc::ThreadMemoryAnchors::kMcsRwLockMemorySize, foedus::soc::ThreadMemoryAnchors::kMcsWwLockMemorySize, foedus::soc::NodeMemoryAnchors::kPagePoolMemorySize, foedus::soc::NodeMemoryAnchors::kProcManagerMemorySize, foedus::soc::ThreadMemoryAnchors::kTaskInputMemorySize, foedus::soc::ThreadMemoryAnchors::kTaskOutputMemorySize, foedus::soc::ThreadMemoryAnchors::kThreadMemorySize, foedus::EngineOptions::log_, foedus::snapshot::SnapshotOptions::log_reducer_buffer_mb_, foedus::log::LogOptions::loggers_per_node_, foedus::proc::ProcOptions::max_proc_count_, foedus::storage::StorageOptions::max_storages_, foedus::EngineOptions::memory_, foedus::memory::MemoryOptions::page_pool_size_mb_per_node_, foedus::EngineOptions::proc_, foedus::EngineOptions::snapshot_, foedus::EngineOptions::storage_, foedus::EngineOptions::thread_, and foedus::thread::ThreadOptions::thread_count_per_group_.

Referenced by allocate_shared_memories(), and foedus::EngineOptions::calculate_required_memory().

                                                                                  {
  const uint64_t kBoundarySize = sizeof(assorted::ProtectedBoundary);
  uint64_t total = 0;
  total += NodeMemoryAnchors::kChildStatusMemorySize + kBoundarySize;
  total += NodeMemoryAnchors::kPagePoolMemorySize + kBoundarySize;
  total += NodeMemoryAnchors::kProcManagerMemorySize + kBoundarySize;
  total += align_4kb(sizeof(proc::ProcAndName) * options.proc_.max_proc_count_) + kBoundarySize;
  total += align_4kb(sizeof(proc::LocalProcId) * options.proc_.max_proc_count_) + kBoundarySize;
  total += NodeMemoryAnchors::kLogReducerMemorySize + kBoundarySize;
  total += options.storage_.max_storages_ * 4096ULL + kBoundarySize;

  uint64_t loggers_per_node = options.log_.loggers_per_node_;
  total += loggers_per_node * (NodeMemoryAnchors::kLoggerMemorySize + kBoundarySize);

  uint64_t threads_per_node = options.thread_.thread_count_per_group_;
  total += threads_per_node * (ThreadMemoryAnchors::kThreadMemorySize + kBoundarySize);
  total += threads_per_node * (ThreadMemoryAnchors::kTaskInputMemorySize + kBoundarySize);
  total += threads_per_node * (ThreadMemoryAnchors::kTaskOutputMemorySize + kBoundarySize);
  total += threads_per_node * (ThreadMemoryAnchors::kMcsWwLockMemorySize + kBoundarySize);
  total += threads_per_node * (ThreadMemoryAnchors::kMcsRwLockMemorySize + kBoundarySize);
  total += threads_per_node * (ThreadMemoryAnchors::kMcsRwLockMemorySize + kBoundarySize);
  total += threads_per_node * (ThreadMemoryAnchors::kMcsRwAsyncMappingMemorySize + kBoundarySize);

  total +=
    (static_cast<uint64_t>(options.snapshot_.log_reducer_buffer_mb_) << 20)
    + kBoundarySize;

  // Then volatile pool at the end.
  total +=
    (static_cast<uint64_t>(options.memory_.page_pool_size_mb_per_node_) << 20)
    + kBoundarySize;
  return total;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::soc::SharedMemoryRepo::change_child_status	(	SocId	node,
		ChildEngineStatus::StatusCode	new_status
	)

Definition at line 547 of file shared_memory_repo.cpp.

References foedus::soc::ChildEngineStatus::change_status_atomic(), and foedus::soc::NodeMemoryAnchors::child_status_memory_.

Referenced by attach_shared_memories(), foedus::soc::SocManagerPimpl::child_main_common(), and foedus::soc::SocManagerPimpl::initialize_child().

                                                                                             {
  node_memory_anchors_[node].child_status_memory_->change_status_atomic(new_status);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::soc::SharedMemoryRepo::change_master_status

(

MasterEngineStatus::StatusCode

new_status

)

Definition at line 539 of file shared_memory_repo.cpp.

References foedus::soc::MasterEngineStatus::change_status_atomic(), and foedus::soc::GlobalMemoryAnchors::master_status_memory_.

Referenced by foedus::EnginePimpl::initialize_once(), foedus::soc::SocManagerPimpl::launch_forked_children(), foedus::soc::SocManagerPimpl::launch_spawned_children(), foedus::soc::SocManagerPimpl::uninitialize_once(), foedus::EnginePimpl::uninitialize_once(), foedus::soc::SocManagerPimpl::wait_for_child_attach(), and foedus::soc::SocManagerPimpl::wait_for_child_terminate().

                                                                                   {
  global_memory_anchors_.master_status_memory_->change_status_atomic(new_status);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::soc::SharedMemoryRepo::deallocate_shared_memories

(

)

Detaches and releases the shared memories.

In child processes, this just detaches.

Definition at line 223 of file shared_memory_repo.cpp.

References foedus::assorted::ProtectedBoundary::assert_boundary(), foedus::soc::GlobalMemoryAnchors::clear(), foedus::memory::SharedMemory::is_null(), mark_for_release(), foedus::soc::GlobalMemoryAnchors::protected_boundaries_, foedus::soc::NodeMemoryAnchors::protected_boundaries_, foedus::soc::GlobalMemoryAnchors::protected_boundaries_count_, foedus::soc::NodeMemoryAnchors::protected_boundaries_count_, foedus::soc::GlobalMemoryAnchors::protected_boundaries_needs_release_, foedus::memory::SharedMemory::release_block(), and foedus::assorted::ProtectedBoundary::release_protect().

Referenced by allocate_shared_memories(), attach_shared_memories(), foedus::soc::SocManagerPimpl::initialize_master(), foedus::soc::SocManagerPimpl::launch_forked_children(), foedus::soc::SocManagerPimpl::launch_spawned_children(), foedus::soc::SocManagerPimpl::uninitialize_once(), foedus::soc::SocManagerPimpl::wait_for_child_attach(), and ~SharedMemoryRepo().

                                                  {
  mark_for_release();

  if (!global_memory_.is_null()) {
    if (global_memory_anchors_.protected_boundaries_needs_release_) {
      for (uint32_t i = 0; i < global_memory_anchors_.protected_boundaries_count_; ++i) {
        assorted::ProtectedBoundary* boundary = global_memory_anchors_.protected_boundaries_[i];
        boundary->release_protect();
        boundary->assert_boundary();
      }
    }
  }
  global_memory_anchors_.clear();

  // release_block() is idempotent, so just do it on all of them
  global_memory_.release_block();

  for (uint16_t i = 0; i < soc_count_; ++i) {
    if (node_memories_) {
      if (node_memory_anchors_[i].protected_boundaries_needs_release_) {
        for (uint32_t j = 0; j < node_memory_anchors_[i].protected_boundaries_count_; ++j) {
          assorted::ProtectedBoundary* boundary = node_memory_anchors_[i].protected_boundaries_[j];
          boundary->release_protect();
          boundary->assert_boundary();
        }
      }

      node_memories_[i].release_block();
    }
  }

  if (node_memories_) {
    delete[] node_memories_;
    node_memories_ = nullptr;
  }
  if (node_memory_anchors_) {
    delete[] node_memory_anchors_;
    node_memory_anchors_ = nullptr;
  }
  soc_count_ = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ChildEngineStatus::StatusCode foedus::soc::SharedMemoryRepo::get_child_status

(

SocId

node

)

const

Definition at line 551 of file shared_memory_repo.cpp.

References foedus::soc::NodeMemoryAnchors::child_status_memory_, and foedus::soc::ChildEngineStatus::read_status_atomic().

Referenced by foedus::soc::SocManagerPimpl::wait_for_child_attach(), and foedus::soc::SocManagerPimpl::wait_for_child_terminate().

                                                                               {
  return node_memory_anchors_[node].child_status_memory_->read_status_atomic();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* foedus::soc::SharedMemoryRepo::get_global_memory ( )

inline

Definition at line 513 of file shared_memory_repo.hpp.

References foedus::memory::SharedMemory::get_block().

Referenced by foedus::soc::SocManagerPimpl::uninitialize_once().

{ return global_memory_.get_block(); }

Here is the call graph for this function:

Here is the caller graph for this function:

GlobalMemoryAnchors* foedus::soc::SharedMemoryRepo::get_global_memory_anchors ( )

inline

Definition at line 514 of file shared_memory_repo.hpp.

Referenced by foedus::snapshot::LogGleaner::execute(), foedus::snapshot::LogReducerRef::get_cur_snapshot(), foedus::storage::PartitionerMetadata::get_index0_metadata(), foedus::storage::PartitionerMetadata::get_metadata(), foedus::soc::SocManagerPimpl::initialize_master(), foedus::log::MetaLogger::initialize_once(), foedus::storage::StorageManagerPimpl::initialize_once(), foedus::log::LogManagerPimpl::initialize_once(), foedus::xct::XctManagerPimpl::initialize_once(), foedus::snapshot::SnapshotManagerPimpl::initialize_once(), foedus::storage::PartitionerMetadata::locate_data(), foedus::snapshot::LogGleanerRef::LogGleanerRef(), foedus::EnginePimpl::on_module_initialized(), foedus::EnginePimpl::on_module_uninitialized(), foedus::soc::SocManagerPimpl::report_engine_fatal_error(), foedus::savepoint::SavepointManagerPimpl::savepoint_main(), foedus::snapshot::SnapshotManagerPimpl::uninitialize_once(), and foedus::soc::SocManagerPimpl::wait_for_master_module().

{ return &global_memory_anchors_; }

Here is the caller graph for this function:

void* foedus::soc::SharedMemoryRepo::get_global_user_memory ( )

inline

Definition at line 515 of file shared_memory_repo.hpp.

References foedus::soc::GlobalMemoryAnchors::user_memory_.

Referenced by foedus::soc::SocManager::get_shared_user_memory().

{ return global_memory_anchors_.user_memory_; }

Here is the caller graph for this function:

MasterEngineStatus::StatusCode foedus::soc::SharedMemoryRepo::get_master_status

(

)

const

Definition at line 543 of file shared_memory_repo.cpp.

References foedus::soc::GlobalMemoryAnchors::master_status_memory_, and foedus::soc::MasterEngineStatus::read_status_atomic().

Referenced by foedus::soc::SocManagerPimpl::wait_for_master_status().

                                                                       {
  return global_memory_anchors_.master_status_memory_->read_status_atomic();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void* foedus::soc::SharedMemoryRepo::get_node_memory ( SocId  node )

inline

Definition at line 520 of file shared_memory_repo.hpp.

References foedus::memory::SharedMemory::get_block().

{ return node_memories_[node].get_block(); }

Here is the call graph for this function:

NodeMemoryAnchors* foedus::soc::SharedMemoryRepo::get_node_memory_anchors ( SocId  node )

inline

Definition at line 521 of file shared_memory_repo.hpp.

Referenced by foedus::snapshot::LogReducerRef::get_buffer(), foedus::soc::SocManagerPimpl::initialize_master(), foedus::memory::NumaNodeMemory::initialize_once(), foedus::EnginePimpl::initialize_once(), foedus::proc::ProcManagerPimpl::initialize_once(), foedus::log::LogManagerPimpl::initialize_once(), foedus::snapshot::LogReducerRef::LogReducerRef(), foedus::memory::NumaNodeMemoryRef::NumaNodeMemoryRef(), foedus::EnginePimpl::on_module_initialized(), foedus::EnginePimpl::on_module_uninitialized(), foedus::soc::SocManagerPimpl::report_engine_fatal_error(), and foedus::soc::SocManagerPimpl::wait_for_children_module().

{ return &node_memory_anchors_[node]; }

Here is the caller graph for this function:

ThreadMemoryAnchors* foedus::soc::SharedMemoryRepo::get_thread_memory_anchors ( thread::ThreadId  thread_id )

inline

Definition at line 526 of file shared_memory_repo.hpp.

References foedus::thread::decompose_numa_local_ordinal(), foedus::thread::decompose_numa_node(), and foedus::soc::NodeMemoryAnchors::thread_anchors_.

Referenced by foedus::thread::ThreadPimpl::initialize_once(), and foedus::thread::ThreadRef::ThreadRef().

                                                                           {
    SocId node = thread::decompose_numa_node(thread_id);
    uint16_t thread_ordinal = thread::decompose_numa_local_ordinal(thread_id);
    return &node_memory_anchors_[node].thread_anchors_[thread_ordinal];
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void* foedus::soc::SharedMemoryRepo::get_volatile_pool ( SocId  node )

inline

Definition at line 532 of file shared_memory_repo.hpp.

References foedus::soc::NodeMemoryAnchors::volatile_page_pool_.

Referenced by foedus::memory::NumaNodeMemory::initialize_once(), and foedus::memory::NumaNodeMemoryRef::NumaNodeMemoryRef().

{ return node_memory_anchors_[node].volatile_page_pool_; }

Here is the caller graph for this function:

void foedus::soc::SharedMemoryRepo::mark_for_release

(

)

Marks shared memories as being removed so that it will be reclaimed when all processes detach it.

This is part of deallocation of shared memory in master process. After calling this method, no process can attach this shared memory. So, do not call this too early. However, on the other hand, do not call this too late. If the master process dies for an unexpected reason, the shared memory remains until next reboot. Call it as soon as child processes ack-ed that they have attached the memory or that there are some issues the master process should exit. This method is idempotent, meaning you can safely call this many times.

Definition at line 214 of file shared_memory_repo.cpp.

References foedus::memory::SharedMemory::mark_for_release().

Referenced by deallocate_shared_memories(), and foedus::soc::SocManagerPimpl::wait_for_child_attach().

                                        {
  // mark_for_release() is idempotent, so just do it on all of them
  global_memory_.mark_for_release();
  for (uint16_t i = 0; i < soc_count_; ++i) {
    if (node_memories_) {
      node_memories_[i].mark_for_release();
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SharedMemoryRepo& foedus::soc::SharedMemoryRepo::operator= ( const SharedMemoryRepo &  other )

delete

---

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

• /home/shino/foedus_code/foedus-core/include/foedus/soc/shared_memory_repo.hpp
• /home/shino/foedus_code/foedus-core/src/foedus/soc/shared_memory_repo.cpp