foedus::memory::RoundRobinPageGrabBatch Class Reference

A helper class to grab a bunch of pages from multiple nodes in round-robin fashion per chunk. More...

Detailed Description

A helper class to grab a bunch of pages from multiple nodes in round-robin fashion per chunk.

This grabs a large number of pages much more efficiently than grabbing one-by-one from individual node. Instead, this is not a true round-robin per page because we switch node only per chunk, which is actually an advantage as it achieves contiguous memory that is friendly for CPU cache. So far this is used when create a new array storage, which requires to grab a large number of pages in round-robin fashion to balance memory usage.

Definition at line 332 of file page_pool.hpp.

#include <page_pool.hpp>

Public Member Functions
	RoundRobinPageGrabBatch (Engine *engine)
	~RoundRobinPageGrabBatch ()
	RoundRobinPageGrabBatch ()=delete
	RoundRobinPageGrabBatch (const RoundRobinPageGrabBatch &)=delete
RoundRobinPageGrabBatch &	operator= (const RoundRobinPageGrabBatch &)=delete
storage::VolatilePagePointer	grab ()
	Grabs an in-memory page in some NUMA node. More...
void	release_all ()
	Called at the end to return all remaining pages to their pools. More...

Constructor & Destructor Documentation

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

explicit

Definition at line 194 of file page_pool.cpp.

: engine_(engine), numa_node_count_(engine->get_options().thread_.group_count_), current_node_(0) {
}

foedus::memory::RoundRobinPageGrabBatch::~RoundRobinPageGrabBatch

(

)

Definition at line 198 of file page_pool.cpp.

References release_all().

                                                  {
  release_all();
}

Here is the call graph for this function:

foedus::memory::RoundRobinPageGrabBatch::RoundRobinPageGrabBatch ( )

delete

foedus::memory::RoundRobinPageGrabBatch::RoundRobinPageGrabBatch ( const RoundRobinPageGrabBatch &  )

delete

Member Function Documentation

storage::VolatilePagePointer foedus::memory::RoundRobinPageGrabBatch::grab

(

)

Grabs an in-memory page in some NUMA node.

This internally batches the pages to return. At the end, call release_all() to release unused pages. Although the type of returned value is VolatilePagePointer, it can be used for snapshot page, too. I just want to return both NUMA node and offset. Maybe we should have another typedef for it.

Todo:

this so far doesn't handle out-of-memory case gracefully. what to do..

Definition at line 202 of file page_pool.cpp.

References ASSERT_ND, foedus::memory::PagePoolOffsetChunk::capacity(), foedus::memory::PagePoolOffsetChunk::empty(), 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::PagePool::grab(), foedus::kErrorCodeMemoryNoFreePages, foedus::kErrorCodeOk, foedus::memory::PagePoolOffsetChunk::pop_back(), foedus::print_backtrace(), and foedus::storage::VolatilePagePointer::set().

                                                         {
  if (chunk_.empty()) {
    const thread::ThreadGroupId old = current_node_;
    while (true) {
      ++current_node_;
      if (current_node_ >= numa_node_count_) {
        current_node_ = 0;
      }
      PagePool* pool = engine_->get_memory_manager()->get_node_memory(current_node_)->
        get_volatile_pool();
      uint32_t grab_count = std::min<uint32_t>(
        chunk_.capacity(),
        pool->get_recommended_pages_per_grab());
      ErrorCode code = pool->grab(grab_count, &chunk_);
      if (code == kErrorCodeOk) {
        break;
      }

      if (code == kErrorCodeMemoryNoFreePages) {
        LOG(WARNING) << "NUMA node-" << current_node_ << " has no more free pages."
          << " trying another node..";
        if (current_node_ == old) {
          print_backtrace();
          LOG(FATAL) << "No NUMA node has any free pages. This situation is so far "
            " not handled. Aborting";
        }
      } else {
        LOG(FATAL) << "Unexpected error code.. wtf error="
          << code << "(" << get_error_name(code) << ")";
      }
    }
    ASSERT_ND(!chunk_.empty());
  }

  storage::VolatilePagePointer ret;
  ret.set(current_node_, chunk_.pop_back());
  return ret;
}

Here is the call graph for this function:

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

delete

void foedus::memory::RoundRobinPageGrabBatch::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 241 of file page_pool.cpp.

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

Referenced by ~RoundRobinPageGrabBatch().

                                          {
  if (chunk_.empty()) {
    return;
  }

  engine_->get_memory_manager()->get_node_memory(current_node_)->get_volatile_pool()->release(
    chunk_.size(), &chunk_);
  ASSERT_ND(chunk_.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