foedus::memory::PageReleaseBatch Class Reference

A helper class to return a bunch of pages to individual nodes. More...

Detailed Description

A helper class to return a bunch of pages to individual nodes.

This returns a large number of pages much more efficiently than returning one-by-one, especially if the in-memory pages might come from different NUMA nodes. So far this is used when we shutdown the engine or drop a storage.

Definition at line 276 of file page_pool.hpp.

#include <page_pool.hpp>

Public Types
typedef PagePoolOffsetChunk *	ChunkPtr

Public Member Functions
	PageReleaseBatch (Engine *engine)
	~PageReleaseBatch ()
	PageReleaseBatch ()=delete
	PageReleaseBatch (const PageReleaseBatch &)=delete
PageReleaseBatch &	operator= (const PageReleaseBatch &)=delete
void	release (storage::VolatilePagePointer page_id)
	Returns the given in-memory volatile page to appropriate NUMA node. More...
void	release (thread::ThreadGroupId numa_node, PagePoolOffset offset)
	Returns the given in-memory page to the specified NUMA node. More...
void	release_chunk (thread::ThreadGroupId numa_node)
	Return all batched pages in the given chunk to its pool. More...
void	release_all ()
	Called at the end to return all batched pages to their pools. More...

Member Typedef Documentation

typedef PagePoolOffsetChunk* foedus::memory::PageReleaseBatch::ChunkPtr

Definition at line 278 of file page_pool.hpp.

Constructor & Destructor Documentation

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

explicit

Definition at line 153 of file page_pool.cpp.

  : engine_(engine), numa_node_count_(engine->get_options().thread_.group_count_) {
  std::memset(chunks_, 0, sizeof(ChunkPtr) * 256);
  for (thread::ThreadGroupId i = 0; i < numa_node_count_; ++i) {
    chunks_[i] = new PagePoolOffsetChunk;
  }
}

foedus::memory::PageReleaseBatch::~PageReleaseBatch

(

)

Definition at line 161 of file page_pool.cpp.

References release_all().

                                    {
  release_all();
  for (thread::ThreadGroupId i = 0; i < numa_node_count_; ++i) {
    delete chunks_[i];
    chunks_[i] = nullptr;
  }
}

Here is the call graph for this function:

foedus::memory::PageReleaseBatch::PageReleaseBatch ( )

delete

foedus::memory::PageReleaseBatch::PageReleaseBatch ( const PageReleaseBatch &  )

delete

Member Function Documentation

PageReleaseBatch& foedus::memory::PageReleaseBatch::operator= ( const PageReleaseBatch &  )

delete

void foedus::memory::PageReleaseBatch::release ( storage::VolatilePagePointer  page_id )

inline

Returns the given in-memory volatile page to appropriate NUMA node.

This internally batches the pages to return. At the end, call release_all() to flush it.

Definition at line 292 of file page_pool.hpp.

Referenced by foedus::storage::hash::HashIntermediatePage::release_pages_recursive(), foedus::storage::hash::HashDataPage::release_pages_recursive(), foedus::storage::array::ArrayStoragePimpl::release_pages_recursive(), foedus::storage::masstree::MasstreeIntermediatePage::release_pages_recursive(), and foedus::storage::masstree::MasstreeBorderPage::release_pages_recursive().

                                                          {
    release(page_id.get_numa_node(), page_id.get_offset());
  }

Here is the caller graph for this function:

void foedus::memory::PageReleaseBatch::release	(	thread::ThreadGroupId	numa_node,
		PagePoolOffset	offset
	)

Returns the given in-memory page to the specified NUMA node.

This internally batches the pages to return. At the end, call release_all() to flush it.

Definition at line 169 of file page_pool.cpp.

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

                                                                                   {
  ASSERT_ND(numa_node < numa_node_count_);
  if (chunks_[numa_node]->full()) {
    release_chunk(numa_node);
  }
  ASSERT_ND(!chunks_[numa_node]->full());
  chunks_[numa_node]->push_back(offset);
}

Here is the call graph for this function:

void foedus::memory::PageReleaseBatch::release_all

(

)

Called at the end to return all batched pages to their pools.

Definition at line 189 of file page_pool.cpp.

References release_chunk().

Referenced by foedus::storage::array::ArrayStorage::drop(), foedus::storage::hash::HashIntermediatePage::release_pages_recursive_parallel(), foedus::storage::masstree::release_parallel(), and ~PageReleaseBatch().

                                   {
  for (thread::ThreadGroupId i = 0; i < numa_node_count_; ++i) {
    release_chunk(i);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::memory::PageReleaseBatch::release_chunk

(

thread::ThreadGroupId

numa_node

)

Return all batched pages in the given chunk to its pool.

Definition at line 178 of file page_pool.cpp.

References ASSERT_ND, foedus::Engine::get_memory_manager(), foedus::memory::EngineMemory::get_node_memory(), foedus::memory::NumaNodeMemoryRef::get_volatile_pool(), and foedus::memory::PagePool::release().

Referenced by release(), and release_all().

                                                                  {
  ASSERT_ND(numa_node < numa_node_count_);
  if (chunks_[numa_node]->empty()) {
    return;
  }

  engine_->get_memory_manager()->get_node_memory(numa_node)->get_volatile_pool()->release(
    chunks_[numa_node]->size(), chunks_[numa_node]);
  ASSERT_ND(chunks_[numa_node]->empty());
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

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