foedus::storage::hash::HashComposeContext Class Reference

HashComposer's compose() implementation separated from the class itself. More...

Detailed Description

HashComposer's compose() implementation separated from the class itself.

It's a complicated method, so worth being its own class. This defines all the variables maintained during one compose() call.

Definition at line 142 of file hash_composer_impl.hpp.

#include <hash_composer_impl.hpp>

Public Member Functions
	HashComposeContext (Engine *engine, snapshot::MergeSort *merge_sort, snapshot::SnapshotWriter *snapshot_writer, cache::SnapshotFileSet *previous_snapshot_files, Page *root_info_page)
	HashComposeContext methods. More...
ErrorStack	execute ()

Constructor & Destructor Documentation

foedus::storage::hash::HashComposeContext::HashComposeContext	(	Engine *	engine,
		snapshot::MergeSort *	merge_sort,
		snapshot::SnapshotWriter *	snapshot_writer,
		cache::SnapshotFileSet *	previous_snapshot_files,
		Page *	root_info_page
	)

HashComposeContext methods.

Definition at line 436 of file hash_composer_impl.cpp.

References foedus::memory::AlignedMemory::alloc(), foedus::memory::AlignedMemory::get_block(), foedus::snapshot::SnapshotWriter::get_intermediate_base(), foedus::snapshot::SnapshotWriter::get_intermediate_size(), foedus::snapshot::SnapshotWriter::get_page_base(), foedus::snapshot::SnapshotWriter::get_page_size(), foedus::storage::hash::kHashMaxLevels, foedus::memory::AlignedMemory::kNumaAllocOnnode, and foedus::storage::kPageSize.

  : engine_(engine),
    merge_sort_(merge_sort),
    system_initial_epoch_(engine->get_savepoint_manager()->get_initial_durable_epoch()),
    storage_id_(merge_sort_->get_storage_id()),
    snapshot_id_(snapshot_writer->get_snapshot_id()),
    storage_(engine, storage_id_),
    snapshot_writer_(snapshot_writer),
    previous_snapshot_files_(previous_snapshot_files),
    root_info_page_(reinterpret_cast<HashRootInfoPage*>(root_info_page)),
    partitionable_(engine_->get_soc_count() > 1U),
    levels_(storage_.get_levels()),
    bin_bits_(storage_.get_bin_bits()),
    bin_shifts_(storage_.get_bin_shifts()),
    root_children_(storage_.get_root_children()),
    numa_node_(snapshot_writer->get_numa_node()),
    total_bin_count_(storage_.get_bin_count()),
    previous_root_page_pointer_(storage_.get_metadata()->root_snapshot_page_id_),
    volatile_resolver_(engine->get_memory_manager()->get_global_volatile_page_resolver()) {
  cur_path_memory_.alloc(
    kPageSize * kHashMaxLevels,
    kPageSize,
    memory::AlignedMemory::kNumaAllocOnnode,
    numa_node_);
  cur_path_ = reinterpret_cast<HashIntermediatePage*>(cur_path_memory_.get_block());
  cur_path_lowest_level_ = levels_;
  cur_path_valid_range_ = HashBinRange(0, 0);

  cur_bin_ = kCurBinNotOpened;
  cur_intermediate_tail_ = nullptr;

  data_page_io_memory_.alloc(
    kPageSize,
    kPageSize,
    memory::AlignedMemory::kNumaAllocOnnode,
    numa_node_);

  allocated_pages_ = 0;
  allocated_intermediates_ = 0;
  page_base_ = reinterpret_cast<HashDataPage*>(snapshot_writer_->get_page_base());
  max_pages_ = snapshot_writer_->get_page_size();
  intermediate_base_
    = reinterpret_cast<HashComposedBinsPage*>(snapshot_writer_->get_intermediate_base());
  max_intermediates_ = snapshot_writer_->get_intermediate_size();
}

Here is the call graph for this function:

Member Function Documentation

ErrorStack foedus::storage::hash::HashComposeContext::execute

(

)

Definition at line 487 of file hash_composer_impl.cpp.

References ASSERT_ND, CHECK_ERROR, foedus::storage::hash::HashTmpBin::clean(), foedus::storage::hash::HashTmpBin::create_memory(), foedus::storage::hash::HashStorage::get_bin_count(), foedus::snapshot::MergeSort::get_current_count(), foedus::snapshot::MergeSort::SortEntry::get_key(), foedus::snapshot::MergeSort::get_sort_entries(), foedus::storage::hash::HashIntermediatePage::header(), foedus::snapshot::MergeSort::is_ended_all(), foedus::storage::kPageSize, foedus::kRetOk, LIKELY, foedus::snapshot::MergeSort::next_batch(), foedus::storage::PageHeader::storage_id_, UNLIKELY, and WRAP_ERROR_CODE.

                                       {
  // Initializations
  std::memset(root_info_page_, 0, kPageSize);
  root_info_page_->header().storage_id_ = storage_id_;
  CHECK_ERROR(init_intermediates());
  CHECK_ERROR(init_cur_path());
  WRAP_ERROR_CODE(cur_bin_table_.create_memory(numa_node_));  // TASK(Hideaki) reuse memory
  cur_bin_table_.clean();
  VLOG(0) << "HashComposer-" << storage_id_ << " initialization done. processing...";

  bool processed_any = false;
  cur_bin_ = kCurBinNotOpened;
  while (true) {
    CHECK_ERROR(merge_sort_->next_batch());
    uint64_t count = merge_sort_->get_current_count();
    if (count == 0 && merge_sort_->is_ended_all()) {
      break;
    }
    processed_any = true;
    const snapshot::MergeSort::SortEntry* sort_entries = merge_sort_->get_sort_entries();
    uint64_t cur = 0;
    while (cur < count) {
      HashBin head_bin = sort_entries[cur].get_key();
      ASSERT_ND(head_bin < storage_.get_bin_count());
      if (cur_bin_ != head_bin) {
        // now we have to finalize the previous bin and switch to a new bin!
        ASSERT_ND(cur_bin_ == kCurBinNotOpened || cur_bin_ < head_bin);  // sorted by bins
        CHECK_ERROR(close_cur_bin());
        ASSERT_ND(cur_bin_ == kCurBinNotOpened);
        CHECK_ERROR(open_cur_bin(head_bin));
        ASSERT_ND(cur_bin_ == head_bin);
      }

      // grab a range of logs that are in the same bin.
      uint64_t next;
      for (next = cur + 1U; LIKELY(next < count); ++next) {
        // this check uses sort_entries which are nicely contiguous.
        HashBin bin = sort_entries[next].get_key();
        ASSERT_ND(bin >= head_bin);
        if (UNLIKELY(bin != head_bin)) {
          break;
        }
      }

      WRAP_ERROR_CODE(apply_batch(cur, next));
      cur = next;
    }
    ASSERT_ND(cur == count);
  }

  if (!processed_any) {
    LOG(ERROR) << "wtf? no logs? storage-" << storage_id_;
  }

  CHECK_ERROR(finalize());
  return kRetOk;
}

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/storage/hash/hash_composer_impl.hpp
• /home/shino/foedus_code/foedus-core/src/foedus/storage/hash/hash_composer_impl.cpp