foedus::snapshot::SnapshotWriter Class Reference

Writes out one snapshot file for all data pages in one reducer. More...

Detailed Description

Writes out one snapshot file for all data pages in one reducer.

In a nutshell, snapshot writer is a in-memory page pool that dumps out some or all of the pages to a snapshot file. It consists of 3 phases for each storage.

Compose Phase

This first phase is invoked by the composers, loading prior snapshot pages and modifying them. Here, snapshot writers behave just as a usual in-memory page pool. This part depends on composer, so the snapshot writer calls composer's method.

Fix Phase

Next phase is invoked at the end of composer for the storage, finalizing page ID in the snapshot file for each modified page and replacing volatile page pointers with snapshot pointers. This part also depends on composer (or page format of the storage), so this is done by composer.

Dump Phase

The last phase simply dumps out the pages to snapshot file. This is a sequential write because no two storages have overlapping pages. This is independent from storage type, thus done in snapshot writer.

Conquer already-divided

Snapshot writer might not have enough pages to hold all pages of the storage modified in this snapshot. This can happen for a large storage with lots of changes. No worry, we have already sorted log entries by keys for this reason. When the page pool becomes fully occupied, we go on to the fix/dump phase, only keeping the right-most pages in all levels. After dumping everything else, we repeat the compose phase just like moving on to another storage.

Note

This is a private implementation-details of Snapshot Manager, thus file name ends with _impl. Do not include this header from a client program. There is no case client program needs to access this internal class.

Definition at line 76 of file snapshot_writer_impl.hpp.

#include <snapshot_writer_impl.hpp>

Public Member Functions
	SnapshotWriter (Engine *engine, uint16_t numa_node, SnapshotId snapshot_id, memory::AlignedMemory *pool_memory, memory::AlignedMemory *intermediate_memory, bool append=false)
	~SnapshotWriter ()
ErrorStack	open ()
	Open the file so that the writer can start writing. More...
bool	is_opened () const
bool	close ()
	Close the file and makes sure all writes become durable (including the directory entry). More...
	SnapshotWriter ()=delete
	SnapshotWriter (const SnapshotWriter &other)=delete
SnapshotWriter &	operator= (const SnapshotWriter &other)=delete
uint16_t	get_numa_node () const
storage::Page *	get_page_base () __attribute__((always_inline))
memory::PagePoolOffset	get_page_size () const __attribute__((always_inline))
storage::Page *	get_intermediate_base () __attribute__((always_inline))
memory::PagePoolOffset	get_intermediate_size () const __attribute__((always_inline))
storage::SnapshotPagePointer	get_next_page_id () const
SnapshotId	get_snapshot_id () const
storage::Page *	resolve (memory::PagePoolOffset offset) __attribute__((always_inline))
memory::PagePoolOffset	resolve (storage::Page *page) __attribute__((always_inline))
ErrorCode	dump_pages (memory::PagePoolOffset from_page, uint32_t count)
	Write out pages that are contiguous in the main page pool. More...
ErrorCode	dump_intermediates (memory::PagePoolOffset from_page, uint32_t count)
	Write out pages that are contiguous in the sub intermediate page pool. More...
std::string	to_string () const
ErrorCode	expand_pool_memory (uint32_t required_pages, bool retain_content)
	Expands pool_memory_ in case it is too small. More...
ErrorCode	expand_intermediate_memory (uint32_t required_pages, bool retain_content)
	Expands intermediate_memory_ in case it is too small. More...

Friends
std::ostream &	operator<< (std::ostream &o, const SnapshotWriter &v)

Constructor & Destructor Documentation

foedus::snapshot::SnapshotWriter::SnapshotWriter	(	Engine *	engine,
		uint16_t	numa_node,
		SnapshotId	snapshot_id,
		memory::AlignedMemory *	pool_memory,
		memory::AlignedMemory *	intermediate_memory,
		bool	append = false
	)

Definition at line 36 of file snapshot_writer_impl.cpp.

  : engine_(engine),
  numa_node_(numa_node),
  append_(append),
  snapshot_id_(snapshot_id),
  pool_memory_(pool_memory),
  intermediate_memory_(intermediate_memory),
  snapshot_file_(nullptr),
  next_page_id_(0) {
}

foedus::snapshot::SnapshotWriter::~SnapshotWriter ( )

inline

Definition at line 85 of file snapshot_writer_impl.hpp.

References close().

{ close(); }

Here is the call graph for this function:

foedus::snapshot::SnapshotWriter::SnapshotWriter ( )

delete

foedus::snapshot::SnapshotWriter::SnapshotWriter ( const SnapshotWriter &  other )

delete

Member Function Documentation

bool foedus::snapshot::SnapshotWriter::close

(

)

Close the file and makes sure all writes become durable (including the directory entry).

Returns

whether successfully closed and synced.

Definition at line 53 of file snapshot_writer_impl.cpp.

References foedus::fs::DirectIoFile::close(), foedus::fs::fsync(), and foedus::fs::DirectIoFile::get_path().

Referenced by open(), and ~SnapshotWriter().

                           {
  if (snapshot_file_) {
    bool success = true;
    fs::Path path = snapshot_file_->get_path();
    bool closed = snapshot_file_->close();
    if (!closed) {
      LOG(ERROR) << "Failed to close a snapshot file: " << *this;
      success = false;
    }
    // also fsync the file.
    if (!fs::fsync(path, true)) {
      LOG(ERROR) << "Failed to fsync a snapshot file: " << *this;
      success = false;
    }

    delete snapshot_file_;
    snapshot_file_ = nullptr;
    return success;
  } else {
    return true;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::snapshot::SnapshotWriter::dump_intermediates ( memory::PagePoolOffset  from_page, uint32_t  count  )

inline

Write out pages that are contiguous in the sub intermediate page pool.

Parameters

[in]	from_page	beginning of contiguous in-memory pages to fix
[in]	count	number of pages to write out

Definition at line 144 of file snapshot_writer_impl.hpp.

                                                                               {
    return dump_general(intermediate_memory_, from_page, count);
  }

ErrorCode foedus::snapshot::SnapshotWriter::dump_pages ( memory::PagePoolOffset  from_page, uint32_t  count  )

inline

Write out pages that are contiguous in the main page pool.

Parameters

[in]	from_page	beginning of contiguous in-memory pages to fix
[in]	count	number of pages to write out

Definition at line 135 of file snapshot_writer_impl.hpp.

Referenced by foedus::storage::hash::ComposedBinsMergedStream::assure_writer_buffer(), foedus::storage::array::ArrayComposer::construct_root(), foedus::storage::hash::HashComposer::construct_root(), foedus::storage::masstree::MasstreeComposer::construct_root(), and foedus::storage::sequential::SequentialComposer::construct_root().

                                                                       {
    return dump_general(pool_memory_, from_page, count);
  }

Here is the caller graph for this function:

ErrorCode foedus::snapshot::SnapshotWriter::expand_intermediate_memory	(	uint32_t	required_pages,
		bool	retain_content
	)

Expands intermediate_memory_ in case it is too small.

Parameters

[in]	required_pages	number of pages that are guaranteed after expansion. The actual size will probably be larger than this value to avoid frequent expansion.
[in]	retain_content	whether to copy the content of old memory to new memory

Postcondition

get_intermediate_size() >= required_pages

Returns

only possible error is out of memory

Note

intermediate_base will be also changed, so do not forget to re-obtain it.

Does nothing if it's already enough large. We use this method to make sure intermediate pool (which some composer assumes sufficiently large) can contain all intermediate pages.

Definition at line 163 of file snapshot_writer_impl.cpp.

References ASSERT_ND, foedus::memory::AlignedMemory::assure_capacity(), CHECK_ERROR_CODE, get_intermediate_size(), and foedus::kErrorCodeOk.

Referenced by foedus::storage::hash::ComposedBinsMergedStream::assure_writer_buffer().

                                                                                                 {
  if (required_pages <= get_intermediate_size()) {
    return kErrorCodeOk;
  }

  uint64_t bytes = required_pages * sizeof(storage::Page);
  CHECK_ERROR_CODE(intermediate_memory_->assure_capacity(bytes, 2.0, retain_content));
  ASSERT_ND(get_intermediate_size() >= required_pages);
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::snapshot::SnapshotWriter::expand_pool_memory	(	uint32_t	required_pages,
		bool	retain_content
	)

Expands pool_memory_ in case it is too small.

Parameters

[in]	required_pages	number of pages that are guaranteed after expansion. The actual size will probably be larger than this value to avoid frequent expansion.
[in]	retain_content	whether to copy the content of old memory to new memory

Postcondition

get_page_size() >= required_pages

Returns

only possible error is out of memory

Note

page_base will be also changed, so do not forget to re-obtain it.

Does nothing if it's already enough large. Most likely we don't have to use this method as composers should be able to run even when the number of leaf (content) pages is large.

Definition at line 150 of file snapshot_writer_impl.cpp.

References ASSERT_ND, foedus::memory::AlignedMemory::assure_capacity(), CHECK_ERROR_CODE, get_page_size(), and foedus::kErrorCodeOk.

                                                                                         {
  if (required_pages <= get_page_size()) {
    return kErrorCodeOk;
  }

  uint64_t bytes = required_pages * sizeof(storage::Page);
  CHECK_ERROR_CODE(pool_memory_->assure_capacity(bytes, 2.0, retain_content));
  ASSERT_ND(get_page_size() >= required_pages);
  return kErrorCodeOk;
}

Here is the call graph for this function:

storage::Page* foedus::snapshot::SnapshotWriter::get_intermediate_base ( )

inline

Definition at line 108 of file snapshot_writer_impl.hpp.

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

Referenced by foedus::storage::array::ArrayComposeContext::ArrayComposeContext(), foedus::storage::hash::HashComposeContext::HashComposeContext(), and foedus::storage::hash::ComposedBinsMergedStream::open_path().

                                                                     {
    return reinterpret_cast<storage::Page*>(intermediate_memory_->get_block());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

memory::PagePoolOffset foedus::snapshot::SnapshotWriter::get_intermediate_size ( ) const

inline

Definition at line 111 of file snapshot_writer_impl.hpp.

References foedus::memory::AlignedMemory::get_size(), and foedus::storage::kPageSize.

Referenced by foedus::storage::array::ArrayComposeContext::ArrayComposeContext(), foedus::storage::hash::ComposedBinsMergedStream::assure_writer_buffer(), expand_intermediate_memory(), foedus::storage::hash::HashComposeContext::HashComposeContext(), and foedus::storage::hash::ComposedBinsMergedStream::open_path().

                                                                           {
    return intermediate_memory_->get_size() / storage::kPageSize;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

storage::SnapshotPagePointer foedus::snapshot::SnapshotWriter::get_next_page_id ( ) const

inline

Definition at line 115 of file snapshot_writer_impl.hpp.

Referenced by foedus::storage::array::ArrayComposer::construct_root(), foedus::storage::hash::HashComposer::construct_root(), foedus::storage::masstree::MasstreeComposer::construct_root(), foedus::storage::sequential::SequentialComposer::construct_root(), foedus::storage::masstree::MasstreeComposeContext::MasstreeComposeContext(), and foedus::storage::hash::ComposedBinsMergedStream::open_path().

{ return next_page_id_; }

Here is the caller graph for this function:

uint16_t foedus::snapshot::SnapshotWriter::get_numa_node ( ) const

inline

Definition at line 101 of file snapshot_writer_impl.hpp.

Referenced by foedus::storage::sequential::SequentialComposer::compose(), foedus::storage::sequential::SequentialComposer::construct_root(), and foedus::storage::array::ArrayComposeContext::execute().

{ return numa_node_; }

Here is the caller graph for this function:

storage::Page* foedus::snapshot::SnapshotWriter::get_page_base ( )

inline

Definition at line 102 of file snapshot_writer_impl.hpp.

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

Referenced by foedus::storage::array::ArrayComposeContext::ArrayComposeContext(), foedus::storage::sequential::SequentialComposer::compose(), foedus::storage::array::ArrayComposer::construct_root(), foedus::storage::hash::HashComposer::construct_root(), foedus::storage::masstree::MasstreeComposer::construct_root(), foedus::storage::sequential::SequentialComposer::construct_root(), foedus::storage::hash::HashComposeContext::HashComposeContext(), foedus::storage::hash::ComposedBinsMergedStream::open_path(), and resolve().

                                                      {
    return reinterpret_cast<storage::Page*>(pool_memory_->get_block());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

memory::PagePoolOffset foedus::snapshot::SnapshotWriter::get_page_size ( ) const

inline

Definition at line 105 of file snapshot_writer_impl.hpp.

References foedus::memory::AlignedMemory::get_size(), and foedus::storage::kPageSize.

Referenced by foedus::storage::array::ArrayComposeContext::ArrayComposeContext(), foedus::storage::hash::ComposedBinsMergedStream::assure_writer_buffer(), foedus::storage::sequential::SequentialComposer::compose(), expand_pool_memory(), foedus::storage::hash::HashComposeContext::HashComposeContext(), foedus::storage::hash::ComposedBinsMergedStream::open_path(), and resolve().

                                                                   {
    return pool_memory_->get_size() / storage::kPageSize;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

SnapshotId foedus::snapshot::SnapshotWriter::get_snapshot_id ( ) const

inline

Definition at line 116 of file snapshot_writer_impl.hpp.

Referenced by foedus::storage::sequential::SequentialComposer::compose(), foedus::storage::array::ArrayComposer::construct_root(), foedus::storage::sequential::SequentialComposer::construct_root(), foedus::storage::masstree::from_this_snapshot(), and foedus::storage::hash::ComposedBinsMergedStream::init().

{ return snapshot_id_; }

Here is the caller graph for this function:

bool foedus::snapshot::SnapshotWriter::is_opened ( ) const

inline

Definition at line 89 of file snapshot_writer_impl.hpp.

{ return snapshot_file_; }

ErrorStack foedus::snapshot::SnapshotWriter::open

(

)

Open the file so that the writer can start writing.

Definition at line 82 of file snapshot_writer_impl.cpp.

References ASSERT_ND, foedus::storage::PageHeader::checksum_, close(), foedus::snapshot::SnapshotOptions::emulation_, foedus::fs::file_size(), foedus::memory::AlignedMemory::get_block(), foedus::fs::DirectIoFile::get_current_offset(), foedus::Engine::get_options(), foedus::kRetOk, foedus::fs::DirectIoFile::open(), foedus::storage::PageHeader::page_id_, foedus::EngineOptions::snapshot_, foedus::storage::PageHeader::storage_id_, foedus::storage::to_snapshot_page_pointer(), to_string(), WRAP_ERROR_CODE, and foedus::fs::DirectIoFile::write().

                                {
  close();
  fs::Path path(get_snapshot_file_path());
  snapshot_file_ = new fs::DirectIoFile(path, engine_->get_options().snapshot_.emulation_);
  bool create_new_file = append_ ? false : true;
  WRAP_ERROR_CODE(snapshot_file_->open(true, true, true, create_new_file));
  if (!append_) {
    // write page-0. this is a dummy page which will never be read
    char* first_page = reinterpret_cast<char*>(pool_memory_->get_block());
    // first 8 bytes have some data, but we would use them just for sanity checks and debugging
    storage::PageHeader* first_page_header = reinterpret_cast<storage::PageHeader*>(first_page);
    first_page_header->page_id_ = storage::to_snapshot_page_pointer(snapshot_id_, numa_node_, 0);
    first_page_header->storage_id_ = 0x1BF0ED05;  // something unusual
    first_page_header->checksum_ = 0x1BF0ED05;  // something unusual
    std::memset(
      first_page + sizeof(storage::PageHeader),
      0,
      sizeof(storage::Page) - sizeof(storage::PageHeader));
    std::string duh("This is the first 4kb page of a snapshot file in libfoedus."
      " The first page is never used as data. It just has the common page header"
      " and these useless sentences. Maybe we put our complaints on our cafeteria here.");
    std::memcpy(first_page + sizeof(storage::PageHeader), duh.data(), duh.size());

    WRAP_ERROR_CODE(snapshot_file_->write(sizeof(storage::Page), *pool_memory_));
    next_page_id_ = storage::to_snapshot_page_pointer(snapshot_id_, numa_node_, 1);
  } else {
    // if appending, nothing to do
    uint64_t file_size = snapshot_file_->get_current_offset();
    LOG(INFO) << to_string() << " Appending to " << file_size << "th bytes";
    ASSERT_ND(file_size >= sizeof(storage::Page));  // have at least the dummy page
    ASSERT_ND(file_size % sizeof(storage::Page) == 0);  // must be aligned writes
    uint64_t next_offset = file_size / sizeof(storage::Page);
    next_page_id_ = storage::to_snapshot_page_pointer(snapshot_id_, numa_node_, next_offset);
  }
  return kRetOk;
}

Here is the call graph for this function:

SnapshotWriter& foedus::snapshot::SnapshotWriter::operator= ( const SnapshotWriter &  other )

delete

storage::Page* foedus::snapshot::SnapshotWriter::resolve ( memory::PagePoolOffset  offset )

inline

Definition at line 118 of file snapshot_writer_impl.hpp.

References ASSERT_ND, get_page_base(), and get_page_size().

                                                                           {
    ASSERT_ND(offset > 0);
    ASSERT_ND(offset < get_page_size());
    return get_page_base() + offset;
  }

Here is the call graph for this function:

memory::PagePoolOffset foedus::snapshot::SnapshotWriter::resolve ( storage::Page *  page )

inline

Definition at line 123 of file snapshot_writer_impl.hpp.

References ASSERT_ND, get_page_base(), and get_page_size().

                                                                 {
    memory::PagePoolOffset offset = page - get_page_base();
    ASSERT_ND(offset > 0);
    ASSERT_ND(offset < get_page_size());
    return offset;
  }

Here is the call graph for this function:

std::string foedus::snapshot::SnapshotWriter::to_string ( ) const

inline

Definition at line 148 of file snapshot_writer_impl.hpp.

Referenced by open().

                                          {
    return "SnapshotWriter-" + std::to_string(numa_node_) + (append_ ? "(append)" : "");
  }

Here is the caller graph for this function:

Friends And Related Function Documentation

std::ostream& operator<< ( std::ostream &  o, const SnapshotWriter &  v  )

friend

Definition at line 174 of file snapshot_writer_impl.cpp.

                                                               {
  o << "<SnapshotWriter>"
    << "<numa_node_>" << v.numa_node_ << "</numa_node_>"
    << "<append_>" << v.append_ << "</append_>"
    << "<snapshot_id_>" << v.snapshot_id_ << "</snapshot_id_>"
    << "<pool_memory_>" << *v.pool_memory_ << "</pool_memory_>"
    << "<intermediate_memory_>" << *v.intermediate_memory_ << "</intermediate_memory_>"
    << "<next_page_id_>" << v.next_page_id_ << "</next_page_id_>"
    << "</SnapshotWriter>";
  return o;
}

---

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

• /home/shino/foedus_code/foedus-core/include/foedus/snapshot/snapshot_writer_impl.hpp
• /home/shino/foedus_code/foedus-core/src/foedus/snapshot/snapshot_writer_impl.cpp