foedus::memory::NumaCoreMemory Class Reference

Repository of memories dynamically acquired within one CPU core (thread). More...

Detailed Description

Repository of memories dynamically acquired within one CPU core (thread).

One NumaCoreMemory corresponds to one foedus::thread::Thread. Each Thread exclusively access its NumaCoreMemory so that it needs no synchronization nor causes cache misses/cache-line ping-pongs. All memories here are allocated/freed via numa_alloc_interleaved(), numa_alloc_onnode(), and numa_free() (except the user specifies to not use them).

Definition at line 46 of file numa_core_memory.hpp.

#include <numa_core_memory.hpp>

Inheritance diagram for foedus::memory::NumaCoreMemory:

Collaboration diagram for foedus::memory::NumaCoreMemory:

Classes
struct	SmallThreadLocalMemoryPieces
	Packs pointers to pieces of small_thread_local_memory_. More...

Public Member Functions
	NumaCoreMemory ()=delete
	NumaCoreMemory (Engine *engine, NumaNodeMemory *node_memory, thread::ThreadId core_id)
ErrorStack	initialize_once () override
ErrorStack	uninitialize_once () override
AlignedMemorySlice	get_log_buffer_memory () const
NumaNodeMemory *	get_node_memory () const
	Returns the parent memory repository. More...
PagePoolOffset	grab_free_volatile_page ()
	Acquires one free volatile page from local page pool. More...
storage::VolatilePagePointer	grab_free_volatile_page_pointer ()
	Wrapper for grab_free_volatile_page(). More...
PagePoolOffset	grab_free_snapshot_page ()
	Same, except it's for snapshot page. More...
void	release_free_volatile_page (PagePoolOffset offset)
	Returns one free volatile page to local page pool. More...
void	release_free_snapshot_page (PagePoolOffset offset)
	Same, except it's for snapshot page. More...
memory::PagePool *	get_volatile_pool ()
memory::PagePool *	get_snapshot_pool ()
PagePoolOffsetAndEpochChunk *	get_retired_volatile_pool_chunk (uint16_t node)
xct::LockEntry *	get_current_lock_list_memory () const
uint64_t	get_current_lock_list_capacity () const
xct::LockEntry *	get_retrospective_lock_list_memory () const
uint64_t	get_retrospective_lock_list_capacity () const
const SmallThreadLocalMemoryPieces &	get_small_thread_local_memory_pieces () const
void *	get_local_work_memory () const
uint64_t	get_local_work_memory_size () const
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 ()

Static Public Member Functions
static uint64_t	calculate_local_small_memory_size (const EngineOptions &options)

Constructor & Destructor Documentation

foedus::memory::NumaCoreMemory::NumaCoreMemory ( )

delete

foedus::memory::NumaCoreMemory::NumaCoreMemory	(	Engine *	engine,
		NumaNodeMemory *	node_memory,
		thread::ThreadId	core_id
	)

Definition at line 39 of file numa_core_memory.cpp.

References ASSERT_ND, foedus::thread::compose_thread_id(), and foedus::memory::NumaNodeMemory::get_numa_node().

  : engine_(engine),
    node_memory_(node_memory),
    core_id_(core_id),
    numa_node_(thread::decompose_numa_node(core_id)),
    core_local_ordinal_(thread::decompose_numa_local_ordinal(core_id)),
    free_volatile_pool_chunk_(nullptr),
    free_snapshot_pool_chunk_(nullptr),
    retired_volatile_pool_chunks_(nullptr),
    current_lock_list_memory_(nullptr),
    current_lock_list_capacity_(0),
    retrospective_lock_list_memory_(nullptr),
    retrospective_lock_list_capacity_(0),
    volatile_pool_(nullptr),
    snapshot_pool_(nullptr) {
  ASSERT_ND(numa_node_ == node_memory->get_numa_node());
  ASSERT_ND(core_id_ == thread::compose_thread_id(node_memory->get_numa_node(),
                          core_local_ordinal_));
}

Here is the call graph for this function:

Member Function Documentation

uint64_t foedus::memory::NumaCoreMemory::calculate_local_small_memory_size ( const EngineOptions &  options )

static

Returns

the byte size of small_thread_local_memory each thread consumes

Definition at line 62 of file numa_core_memory.cpp.

References foedus::thread::ThreadOptions::group_count_, foedus::xct::Xct::kMaxPageVersionSets, foedus::xct::Xct::kMaxPointerSets, foedus::xct::XctOptions::max_lock_free_read_set_size_, foedus::xct::XctOptions::max_lock_free_write_set_size_, foedus::xct::XctOptions::max_read_set_size_, foedus::xct::XctOptions::max_write_set_size_, foedus::EngineOptions::thread_, foedus::thread::ThreadOptions::thread_count_per_group_, and foedus::EngineOptions::xct_.

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

                                                                                       {
  uint64_t memory_size = 0;
  // for the "shift" part, we calculate conservatively then skip it at the end.
  // it's a wasted memory, but negligible.
  memory_size += static_cast<uint64_t>(options.thread_.thread_count_per_group_) << 12;
  memory_size += sizeof(xct::SysxctWorkspace);
  memory_size += sizeof(xct::PageVersionAccess) * xct::Xct::kMaxPageVersionSets;
  memory_size += sizeof(xct::PointerAccess) * xct::Xct::kMaxPointerSets;
  const xct::XctOptions& xct_opt = options.xct_;
  const uint16_t nodes = options.thread_.group_count_;
  memory_size += sizeof(xct::ReadXctAccess) * xct_opt.max_read_set_size_;
  memory_size += sizeof(xct::WriteXctAccess) * xct_opt.max_write_set_size_;
  memory_size += sizeof(xct::LockFreeReadXctAccess)
    * xct_opt.max_lock_free_read_set_size_;
  memory_size += sizeof(xct::LockFreeWriteXctAccess)
    * xct_opt.max_lock_free_write_set_size_;
  memory_size += sizeof(memory::PagePoolOffsetAndEpochChunk) * nodes;

  // In reality almost no chance we take as many locks as all read/write-sets,
  // but let's simplify that. Not much memory anyways.
  const uint64_t total_access_sets = xct_opt.max_read_set_size_ + xct_opt.max_write_set_size_;
  memory_size += sizeof(xct::LockEntry) * total_access_sets;
  memory_size += sizeof(xct::LockEntry) * total_access_sets;
  return memory_size;
}

Here is the caller graph for this function:

uint64_t foedus::memory::NumaCoreMemory::get_current_lock_list_capacity ( ) const

inline

Definition at line 95 of file numa_core_memory.hpp.

Referenced by foedus::xct::Xct::initialize().

                                                  {
    return current_lock_list_capacity_;
  }

Here is the caller graph for this function:

xct::LockEntry* foedus::memory::NumaCoreMemory::get_current_lock_list_memory ( ) const

inline

Definition at line 92 of file numa_core_memory.hpp.

Referenced by foedus::xct::Xct::initialize().

                                                     {
    return current_lock_list_memory_;
  }

Here is the caller graph for this function:

void* foedus::memory::NumaCoreMemory::get_local_work_memory ( ) const

inline

Definition at line 109 of file numa_core_memory.hpp.

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

Referenced by foedus::xct::Xct::initialize().

{ return local_work_memory_.get_block(); }

Here is the call graph for this function:

Here is the caller graph for this function:

uint64_t foedus::memory::NumaCoreMemory::get_local_work_memory_size ( ) const

inline

Definition at line 110 of file numa_core_memory.hpp.

References foedus::memory::AlignedMemory::get_size().

Referenced by foedus::xct::Xct::initialize().

{ return local_work_memory_.get_size(); }

Here is the call graph for this function:

Here is the caller graph for this function:

AlignedMemorySlice foedus::memory::NumaCoreMemory::get_log_buffer_memory ( ) const

inline

Definition at line 64 of file numa_core_memory.hpp.

Referenced by foedus::log::ThreadLogBuffer::initialize_once().

{ return log_buffer_memory_; }

Here is the caller graph for this function:

NumaNodeMemory* foedus::memory::NumaCoreMemory::get_node_memory ( ) const

inline

Returns the parent memory repository.

Definition at line 67 of file numa_core_memory.hpp.

Referenced by foedus::thread::Thread::get_node_memory().

{ return node_memory_; }

Here is the caller graph for this function:

PagePoolOffsetAndEpochChunk * foedus::memory::NumaCoreMemory::get_retired_volatile_pool_chunk

(

uint16_t

node

)

Definition at line 253 of file numa_core_memory.cpp.

Referenced by foedus::thread::ThreadPimpl::collect_retired_volatile_page(), and foedus::thread::ThreadPimpl::uninitialize_once().

                                                                                          {
  return retired_volatile_pool_chunks_ + node;
}

Here is the caller graph for this function:

uint64_t foedus::memory::NumaCoreMemory::get_retrospective_lock_list_capacity ( ) const

inline

Definition at line 101 of file numa_core_memory.hpp.

Referenced by foedus::xct::Xct::initialize().

                                                        {
    return retrospective_lock_list_capacity_;
  }

Here is the caller graph for this function:

xct::LockEntry* foedus::memory::NumaCoreMemory::get_retrospective_lock_list_memory ( ) const

inline

Definition at line 98 of file numa_core_memory.hpp.

Referenced by foedus::xct::Xct::initialize().

                                                           {
    return retrospective_lock_list_memory_;
  }

Here is the caller graph for this function:

const SmallThreadLocalMemoryPieces& foedus::memory::NumaCoreMemory::get_small_thread_local_memory_pieces ( ) const

inline

Definition at line 105 of file numa_core_memory.hpp.

Referenced by foedus::xct::Xct::initialize().

                                                                                   {
    return small_thread_local_memory_pieces_;
  }

Here is the caller graph for this function:

memory::PagePool* foedus::memory::NumaCoreMemory::get_snapshot_pool ( )

inline

Definition at line 89 of file numa_core_memory.hpp.

{ return snapshot_pool_; }

memory::PagePool* foedus::memory::NumaCoreMemory::get_volatile_pool ( )

inline

Definition at line 88 of file numa_core_memory.hpp.

{ return volatile_pool_; }

PagePoolOffset foedus::memory::NumaCoreMemory::grab_free_snapshot_page

(

)

Same, except it's for snapshot page.

Definition at line 221 of file numa_core_memory.cpp.

References ASSERT_ND, foedus::memory::PagePoolOffsetChunk::empty(), foedus::kErrorCodeOk, foedus::memory::PagePoolOffsetChunk::pop_back(), and UNLIKELY.

Referenced by foedus::thread::ThreadPimpl::on_snapshot_cache_miss().

                                                       {
  if (UNLIKELY(free_snapshot_pool_chunk_->empty())) {
    if (grab_free_pages_from_node(free_snapshot_pool_chunk_, snapshot_pool_) != kErrorCodeOk) {
      return 0;
    }
  }
  ASSERT_ND(!free_snapshot_pool_chunk_->empty());
  return free_snapshot_pool_chunk_->pop_back();
}

Here is the call graph for this function:

Here is the caller graph for this function:

PagePoolOffset foedus::memory::NumaCoreMemory::grab_free_volatile_page

(

)

Acquires one free volatile page from local page pool.

Returns

acquired page, or 0 if no free page is available (OUTOFMEMORY).

This method does not return error code to be simple and fast. Instead, The caller MUST check if the returned page is zero or not.

Definition at line 199 of file numa_core_memory.cpp.

References ASSERT_ND, foedus::memory::PagePoolOffsetChunk::empty(), foedus::kErrorCodeOk, foedus::memory::PagePoolOffsetChunk::pop_back(), and UNLIKELY.

Referenced by foedus::storage::masstree::allocate_new_border_page(), foedus::storage::sequential::SequentialStoragePimpl::append_record(), foedus::thread::ThreadPimpl::follow_page_pointer(), foedus::thread::ThreadPimpl::follow_page_pointers_for_read_batch(), foedus::thread::ThreadPimpl::follow_page_pointers_for_write_batch(), foedus::thread::GrabFreeVolatilePagesScope::grab(), grab_free_volatile_page_pointer(), and foedus::storage::masstree::ReserveRecords::run().

                                                       {
  if (UNLIKELY(free_volatile_pool_chunk_->empty())) {
    if (grab_free_pages_from_node(free_volatile_pool_chunk_, volatile_pool_) != kErrorCodeOk) {
      return 0;
    }
  }
  ASSERT_ND(!free_volatile_pool_chunk_->empty());
  return free_volatile_pool_chunk_->pop_back();
}

Here is the call graph for this function:

Here is the caller graph for this function:

storage::VolatilePagePointer foedus::memory::NumaCoreMemory::grab_free_volatile_page_pointer

(

)

Wrapper for grab_free_volatile_page().

Definition at line 208 of file numa_core_memory.cpp.

References grab_free_volatile_page(), and foedus::storage::VolatilePagePointer::set().

Referenced by foedus::storage::hash::ReserveRecords::create_new_tail_page(), foedus::storage::hash::HashStoragePimpl::follow_page_bin_head(), foedus::storage::masstree::grow_case_b_common(), and foedus::thread::ThreadPimpl::install_a_volatile_page().

                                                                           {
  storage::VolatilePagePointer ret;
  ret.set(numa_node_, grab_free_volatile_page());
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::memory::NumaCoreMemory::initialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 88 of file numa_core_memory.cpp.

References foedus::memory::NumaNodeMemory::allocate_numa_memory(), ASSERT_ND, calculate_local_small_memory_size(), CHECK_ERROR, foedus::memory::PagePoolOffsetAndEpochChunk::clear(), foedus::memory::AlignedMemory::get_block(), foedus::memory::PagePool::get_free_pool_capacity(), foedus::memory::NumaNodeMemory::get_log_buffer_memory_piece(), foedus::Engine::get_options(), foedus::memory::PagePool::get_recommended_pages_per_grab(), foedus::memory::NumaNodeMemory::get_snapshot_offset_chunk_memory_piece(), foedus::memory::NumaNodeMemory::get_snapshot_pool(), foedus::memory::NumaNodeMemory::get_volatile_offset_chunk_memory_piece(), foedus::memory::NumaNodeMemory::get_volatile_pool(), foedus::memory::PagePool::grab(), foedus::thread::ThreadOptions::group_count_, foedus::xct::Xct::kMaxPageVersionSets, foedus::xct::Xct::kMaxPointerSets, foedus::kRetOk, foedus::EngineOptions::memory_, foedus::memory::MemoryOptions::private_page_pool_initial_grab_, foedus::memory::NumaCoreMemory::SmallThreadLocalMemoryPieces::sysxct_workspace_memory_, foedus::EngineOptions::thread_, foedus::thread::ThreadOptions::thread_count_per_group_, WRAP_ERROR_CODE, foedus::EngineOptions::xct_, foedus::memory::NumaCoreMemory::SmallThreadLocalMemoryPieces::xct_lock_free_read_access_memory_, foedus::memory::NumaCoreMemory::SmallThreadLocalMemoryPieces::xct_lock_free_write_access_memory_, foedus::memory::NumaCoreMemory::SmallThreadLocalMemoryPieces::xct_page_version_memory_, foedus::memory::NumaCoreMemory::SmallThreadLocalMemoryPieces::xct_pointer_access_memory_, foedus::memory::NumaCoreMemory::SmallThreadLocalMemoryPieces::xct_read_access_memory_, and foedus::memory::NumaCoreMemory::SmallThreadLocalMemoryPieces::xct_write_access_memory_.

                                           {
  LOG(INFO) << "Initializing NumaCoreMemory for core " << core_id_;
  free_volatile_pool_chunk_ = node_memory_->get_volatile_offset_chunk_memory_piece(
    core_local_ordinal_);
  free_snapshot_pool_chunk_ = node_memory_->get_snapshot_offset_chunk_memory_piece(
    core_local_ordinal_);
  volatile_pool_ = node_memory_->get_volatile_pool();
  snapshot_pool_ = node_memory_->get_snapshot_pool();
  log_buffer_memory_ = node_memory_->get_log_buffer_memory_piece(core_local_ordinal_);

  // allocate small_thread_local_memory_. it's a collection of small memories
  uint64_t memory_size = calculate_local_small_memory_size(engine_->get_options());
  if (memory_size > (1U << 21)) {
    VLOG(1) << "mm, small_local_memory_size is more than 2MB(" << memory_size << ")."
      " not a big issue, but consumes one more TLB entry...";
  }
  CHECK_ERROR(node_memory_->allocate_numa_memory(memory_size, &small_thread_local_memory_));

  const xct::XctOptions& xct_opt = engine_->get_options().xct_;
  const uint16_t nodes = engine_->get_options().thread_.group_count_;
  const uint16_t thread_per_group = engine_->get_options().thread_.thread_count_per_group_;
  char* memory = reinterpret_cast<char*>(small_thread_local_memory_.get_block());
  // "shift" 4kb for each thread on this node so that memory banks are evenly used.
  // in many architecture, 13th- or 14th- bits are memory banks (see [JEONG11])
  memory += static_cast<uint64_t>(core_local_ordinal_) << 12;
  small_thread_local_memory_pieces_.sysxct_workspace_memory_ = memory;
  memory += sizeof(xct::SysxctWorkspace);
  small_thread_local_memory_pieces_.xct_page_version_memory_ = memory;
  memory += sizeof(xct::PageVersionAccess) * xct::Xct::kMaxPageVersionSets;
  small_thread_local_memory_pieces_.xct_pointer_access_memory_ = memory;
  memory += sizeof(xct::PointerAccess) * xct::Xct::kMaxPointerSets;
  small_thread_local_memory_pieces_.xct_read_access_memory_ = memory;
  memory += sizeof(xct::ReadXctAccess) * xct_opt.max_read_set_size_;
  small_thread_local_memory_pieces_.xct_write_access_memory_ = memory;
  memory += sizeof(xct::WriteXctAccess) * xct_opt.max_write_set_size_;
  small_thread_local_memory_pieces_.xct_lock_free_read_access_memory_ = memory;
  memory += sizeof(xct::LockFreeReadXctAccess) * xct_opt.max_lock_free_read_set_size_;
  small_thread_local_memory_pieces_.xct_lock_free_write_access_memory_ = memory;
  memory += sizeof(xct::LockFreeWriteXctAccess) * xct_opt.max_lock_free_write_set_size_;
  retired_volatile_pool_chunks_ = reinterpret_cast<PagePoolOffsetAndEpochChunk*>(memory);
  memory += sizeof(memory::PagePoolOffsetAndEpochChunk) * nodes;

  const uint64_t total_access_sets = xct_opt.max_read_set_size_ + xct_opt.max_write_set_size_;
  current_lock_list_memory_ = reinterpret_cast<xct::LockEntry*>(memory);
  current_lock_list_capacity_ = total_access_sets;
  memory += sizeof(xct::LockEntry) * total_access_sets;
  retrospective_lock_list_memory_ = reinterpret_cast<xct::LockEntry*>(memory);
  retrospective_lock_list_capacity_ = total_access_sets;
  memory += sizeof(xct::LockEntry) * total_access_sets;

  memory += static_cast<uint64_t>(thread_per_group - core_local_ordinal_) << 12;
  ASSERT_ND(reinterpret_cast<char*>(small_thread_local_memory_.get_block())
    + memory_size == memory);

  for (uint16_t node = 0; node < nodes; ++node) {
    retired_volatile_pool_chunks_[node].clear();
  }

  CHECK_ERROR(node_memory_->allocate_numa_memory(
    xct_opt.local_work_memory_size_mb_ * (1ULL << 20),
    &local_work_memory_));

  // Each core starts from 50%-full free pool chunk (configurable)
  uint32_t initial_pages = engine_->get_options().memory_.private_page_pool_initial_grab_;
  {
    uint32_t grab_count = std::min<uint32_t>(
      volatile_pool_->get_recommended_pages_per_grab(),
      std::min<uint32_t>(
        initial_pages,
        volatile_pool_->get_free_pool_capacity() / (2U * thread_per_group)));
    WRAP_ERROR_CODE(volatile_pool_->grab(grab_count, free_volatile_pool_chunk_));
  }
  {
    uint32_t grab_count = std::min<uint32_t>(
      snapshot_pool_->get_recommended_pages_per_grab(),
      std::min<uint32_t>(
        initial_pages,
        snapshot_pool_->get_free_pool_capacity() / (2U * thread_per_group)));
    WRAP_ERROR_CODE(snapshot_pool_->grab(grab_count, free_snapshot_pool_chunk_));
  }
  return kRetOk;
}

Here is the call graph for this function:

void foedus::memory::NumaCoreMemory::release_free_snapshot_page

(

PagePoolOffset

offset

)

Same, except it's for snapshot page.

Definition at line 230 of file numa_core_memory.cpp.

References ASSERT_ND, foedus::memory::PagePoolOffsetChunk::full(), foedus::memory::PagePoolOffsetChunk::push_back(), and UNLIKELY.

Referenced by foedus::thread::ThreadPimpl::on_snapshot_cache_miss().

                                                                     {
  if (UNLIKELY(free_snapshot_pool_chunk_->full())) {
    release_free_pages_to_node(free_snapshot_pool_chunk_, snapshot_pool_);
  }
  ASSERT_ND(!free_snapshot_pool_chunk_->full());
  free_snapshot_pool_chunk_->push_back(offset);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::memory::NumaCoreMemory::release_free_volatile_page

(

PagePoolOffset

offset

)

Returns one free volatile page to local page pool.

Definition at line 213 of file numa_core_memory.cpp.

References ASSERT_ND, foedus::memory::PagePoolOffsetChunk::full(), foedus::memory::PagePoolOffsetChunk::push_back(), and UNLIKELY.

Referenced by foedus::storage::hash::HashStoragePimpl::follow_page_bin_head(), foedus::thread::GrabFreeVolatilePagesScope::grab(), foedus::thread::ThreadPimpl::place_a_new_volatile_page(), foedus::thread::GrabFreeVolatilePagesScope::release(), and foedus::memory::AutoVolatilePageReleaseScope::~AutoVolatilePageReleaseScope().

                                                                     {
  if (UNLIKELY(free_volatile_pool_chunk_->full())) {
    release_free_pages_to_node(free_volatile_pool_chunk_, volatile_pool_);
  }
  ASSERT_ND(!free_volatile_pool_chunk_->full());
  free_volatile_pool_chunk_->push_back(offset);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::memory::NumaCoreMemory::uninitialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 170 of file numa_core_memory.cpp.

References ASSERT_ND, foedus::memory::AlignedMemorySlice::clear(), foedus::memory::PagePoolOffsetAndEpochChunk::empty(), foedus::Engine::get_soc_count(), foedus::memory::PagePool::release(), foedus::memory::AlignedMemory::release_block(), foedus::memory::PagePoolOffsetChunk::size(), and SUMMARIZE_ERROR_BATCH.

                                             {
  LOG(INFO) << "Releasing NumaCoreMemory for core " << core_id_;
  ErrorStackBatch batch;
  // return all free pages
  if (retired_volatile_pool_chunks_) {
    // this should be already released in ThreadPimpl's uninitialize.
    // we can't do it here because uninitialization of node/core memories are parallelized
    for (uint16_t node = 0; node < engine_->get_soc_count(); ++node) {
      PagePoolOffsetAndEpochChunk* chunk = retired_volatile_pool_chunks_ + node;
      ASSERT_ND(chunk->empty());  // just sanity check
    }
    retired_volatile_pool_chunks_ = nullptr;
  }
  if (free_volatile_pool_chunk_) {
    volatile_pool_->release(free_volatile_pool_chunk_->size(), free_volatile_pool_chunk_);
    free_volatile_pool_chunk_ = nullptr;
    volatile_pool_ = nullptr;
  }
  if (free_snapshot_pool_chunk_) {
    snapshot_pool_->release(free_snapshot_pool_chunk_->size(), free_snapshot_pool_chunk_);
    free_snapshot_pool_chunk_ = nullptr;
    snapshot_pool_ = nullptr;
  }
  log_buffer_memory_.clear();
  local_work_memory_.release_block();
  small_thread_local_memory_.release_block();
  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/numa_core_memory.hpp
• /home/shino/foedus_code/foedus-core/src/foedus/memory/numa_core_memory.cpp