foedus::memory::DivvyupPageGrabBatch Class Reference

A helper class to grab a bunch of pages from multiple nodes in arbitrary fashion. More...

Detailed Description

A helper class to grab a bunch of pages from multiple nodes in arbitrary fashion.

Similar to RoundRobinPageGrabBatch. This class doesn't specify how nodes divvy up pages. The caller has the control. Or, this class provides a method for each policy.

Definition at line 375 of file page_pool.hpp.

#include <page_pool.hpp>

Public Member Functions
	DivvyupPageGrabBatch (Engine *engine)
	~DivvyupPageGrabBatch ()
	DivvyupPageGrabBatch ()=delete
	DivvyupPageGrabBatch (const DivvyupPageGrabBatch &)=delete
DivvyupPageGrabBatch &	operator= (const DivvyupPageGrabBatch &)=delete
storage::VolatilePagePointer	grab (thread::ThreadGroupId node)
	Grabs an in-memory page in specified NUMA node. More...
storage::VolatilePagePointer	grab_evenly (uint64_t cur, uint64_t total)
	Grabs an in-memory page evenly and contiguously from each NUMA node. More...
void	release_all ()
	Called at the end to return all remaining pages to their pools. More...

Constructor & Destructor Documentation

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

explicit

Definition at line 252 of file page_pool.cpp.

References ASSERT_ND.

: engine_(engine), node_count_(engine->get_options().thread_.group_count_) {
  chunks_ = new PagePoolOffsetChunk[node_count_];
  for (uint16_t node = 0; node < node_count_; ++node) {
    ASSERT_ND(chunks_[node].empty());
  }
}

foedus::memory::DivvyupPageGrabBatch::~DivvyupPageGrabBatch

(

)

Definition at line 260 of file page_pool.cpp.

References release_all().

                                            {
  release_all();
  delete[] chunks_;
  chunks_ = nullptr;
}

Here is the call graph for this function:

foedus::memory::DivvyupPageGrabBatch::DivvyupPageGrabBatch ( )

delete

foedus::memory::DivvyupPageGrabBatch::DivvyupPageGrabBatch ( const DivvyupPageGrabBatch &  )

delete

Member Function Documentation

storage::VolatilePagePointer foedus::memory::DivvyupPageGrabBatch::grab

(

thread::ThreadGroupId

node

)

Grabs an in-memory page in specified NUMA node.

Parameters

[in]

node

specify NUMA node

Precondition

node < node_count_

Definition at line 267 of file page_pool.cpp.

References ASSERT_ND, foedus::memory::PagePoolOffsetChunk::capacity(), foedus::get_error_name(), foedus::Engine::get_memory_manager(), foedus::memory::EngineMemory::get_node_memory(), foedus::memory::PagePool::get_recommended_pages_per_grab(), foedus::memory::NumaNodeMemoryRef::get_volatile_pool(), foedus::memory::PagePool::grab(), foedus::kErrorCodeMemoryNoFreePages, foedus::kErrorCodeOk, and foedus::storage::VolatilePagePointer::set().

Referenced by grab_evenly().

                                                                              {
  ASSERT_ND(node < node_count_);
  if (chunks_[node].empty()) {
    PagePool* pool = engine_->get_memory_manager()->get_node_memory(node)->get_volatile_pool();
    uint32_t grab_count = std::min<uint32_t>(
      chunks_[node].capacity(),
      pool->get_recommended_pages_per_grab());
    ErrorCode code = pool->grab(grab_count, chunks_ + node);
    if (code == kErrorCodeMemoryNoFreePages) {
      LOG(FATAL) << "NUMA node " << static_cast<int>(node) << " has no free pages. This situation "
        " is so far not handled in DivvyupPageGrabBatch. Aborting";
    } else if (code != kErrorCodeOk) {
      LOG(FATAL) << "Unexpected error code.. wtf error="
        << code << "(" << get_error_name(code) << ")";
    }
  }
  storage::VolatilePagePointer ret;
  ret.set(node, chunks_[node].pop_back());
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

storage::VolatilePagePointer foedus::memory::DivvyupPageGrabBatch::grab_evenly	(	uint64_t	cur,
		uint64_t	total
	)

Grabs an in-memory page evenly and contiguously from each NUMA node.

Parameters

[in]	cur	page index out of total.
[in]	total	total pages to be allocated.

For example, if total=6 and there are 2 numa nodes, cur=0,1,2 get pages from NUMA node 0, cur=3,4,5 get pages from NUMA node 1. This is the most simple policy.

Definition at line 288 of file page_pool.cpp.

References grab().

                                                                                         {
  thread::ThreadGroupId node;
  if (node_count_ == 1U) {
    node = 0;
  } else {
    node = cur * node_count_ / total;
  }
  return grab(node);
}

Here is the call graph for this function:

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

delete

void foedus::memory::DivvyupPageGrabBatch::release_all

(

)

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

The grabbed pages are not returned, of course.

Definition at line 298 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 ~DivvyupPageGrabBatch().

                                       {
  for (uint16_t node = 0; node < node_count_; ++node) {
    if (chunks_[node].empty()) {
      continue;
    }
    engine_->get_memory_manager()->get_node_memory(node)->get_volatile_pool()->release(
      chunks_[node].size(), chunks_ + node);
    ASSERT_ND(chunks_[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