foedus::storage::hash::HashStoragePimpl Class Reference

Pimpl object of HashStorage. More...

Detailed Description

Pimpl object of HashStorage.

A private pimpl object for HashStorage. Do not include this header from a client program unless you know what you are doing.

Definition at line 93 of file hash_storage_pimpl.hpp.

#include <hash_storage_pimpl.hpp>

Inheritance diagram for foedus::storage::hash::HashStoragePimpl:

Collaboration diagram for foedus::storage::hash::HashStoragePimpl:

Public Member Functions
	HashStoragePimpl ()
	HashStoragePimpl (HashStorage *storage)
void	release_pages_recursive_root (memory::PageReleaseBatch *batch, HashIntermediatePage *page, VolatilePagePointer volatile_page_id)
	Used only from uninitialize() More...
void	release_pages_recursive_intermediate (memory::PageReleaseBatch *batch, HashIntermediatePage *page, VolatilePagePointer volatile_page_id)
void	release_pages_recursive_data (memory::PageReleaseBatch *batch, HashDataPage *page, VolatilePagePointer volatile_page_id)
xct::TrackMovedRecordResult	track_moved_record (xct::RwLockableXctId *old_address, xct::WriteXctAccess *write_set)
xct::TrackMovedRecordResult	track_moved_record_search (HashDataPage *page, const void *key, uint16_t key_length, const HashCombo &combo)
ErrorStack	verify_single_thread (Engine *engine)
	These are defined in hash_storage_verify.cpp. More...
ErrorStack	verify_single_thread (thread::Thread *context)
ErrorStack	verify_single_thread_intermediate (Engine *engine, HashIntermediatePage *page)
ErrorStack	verify_single_thread_data (Engine *engine, HashDataPage *head)
ErrorStack	hcc_reset_all_temperature_stat ()
	For stupid reasons (I'm lazy!) these are defined in _debug.cpp. More...
ErrorStack	hcc_reset_all_temperature_stat_intermediate (VolatilePagePointer intermediate_page_id)
ErrorStack	hcc_reset_all_temperature_stat_data (VolatilePagePointer head_page_id)
ErrorStack	debugout_single_thread (Engine *engine, bool volatile_only, bool intermediate_only, uint32_t max_pages)
	These are defined in hash_storage_debug.cpp. More...
ErrorStack	debugout_single_thread_intermediate (Engine *engine, cache::SnapshotFileSet *fileset, HashIntermediatePage *parent, bool follow_volatile, bool intermediate_only, uint32_t *remaining_pages)
ErrorStack	debugout_single_thread_data (Engine *engine, cache::SnapshotFileSet *fileset, HashDataPage *head, bool follow_volatile, uint32_t *remaining_pages)
ErrorStack	create (const HashMetadata &metadata)
ErrorStack	load (const StorageControlBlock &snapshot_block)
ErrorStack	drop ()
bool	exists () const
StorageId	get_id () const
const StorageName &	get_name () const
const HashMetadata &	get_meta () const
uint8_t	get_levels () const
HashBin	get_bin_count () const
uint8_t	get_bin_bits () const
uint8_t	get_bin_shifts () const
ErrorCode	get_record (thread::Thread *context, const void *key, uint16_t key_length, const HashCombo &combo, void *payload, uint16_t *payload_capacity, bool read_only)
template<typename PAYLOAD >
ErrorCode	get_record_primitive (thread::Thread *context, const void *key, uint16_t key_length, const HashCombo &combo, PAYLOAD *payload, uint16_t payload_offset, bool read_only)
ErrorCode	get_record_part (thread::Thread *context, const void *key, uint16_t key_length, const HashCombo &combo, void *payload, uint16_t payload_offset, uint16_t payload_count, bool read_only)
ErrorCode	register_record_write_log (thread::Thread *context, const RecordLocation &location, log::RecordLogType *log_entry)
	Used in the following methods. More...
ErrorCode	insert_record (thread::Thread *context, const void *key, uint16_t key_length, const HashCombo &combo, const void *payload, uint16_t payload_count, uint16_t physical_payload_hint)
ErrorCode	delete_record (thread::Thread *context, const void *key, uint16_t key_length, const HashCombo &combo)
ErrorCode	upsert_record (thread::Thread *context, const void *key, uint16_t key_length, const HashCombo &combo, const void *payload, uint16_t payload_count, uint16_t physical_payload_hint)
ErrorCode	overwrite_record (thread::Thread *context, const void *key, uint16_t key_length, const HashCombo &combo, const void *payload, uint16_t payload_offset, uint16_t payload_count)
template<typename PAYLOAD >
ErrorCode	overwrite_record_primitive (thread::Thread *context, const void *key, uint16_t key_length, const HashCombo &combo, PAYLOAD payload, uint16_t payload_offset)
template<typename PAYLOAD >
ErrorCode	increment_record (thread::Thread *context, const void *key, uint16_t key_length, const HashCombo &combo, PAYLOAD *value, uint16_t payload_offset)
ErrorCode	get_root_page (thread::Thread *context, bool for_write, HashIntermediatePage **root)
	Retrieves the root page of this storage. More...
ErrorCode	follow_page (thread::Thread *context, bool for_write, HashIntermediatePage *parent, uint16_t index_in_parent, Page **page)
	for non-root More...
ErrorCode	follow_page_bin_head (thread::Thread *context, bool for_write, HashIntermediatePage *parent, uint16_t index_in_parent, Page **page)
	subroutine to follow a pointer to head of bin from a volatile parent More...
ErrorCode	locate_bin (thread::Thread *context, bool for_write, const HashCombo &combo, HashDataPage **bin_head)
	Find a pointer to the bin that contains records for the hash. More...
ErrorCode	locate_record (thread::Thread *context, bool for_write, bool physical_only, bool create_if_notfound, uint16_t create_payload_length, const void *key, uint16_t key_length, const HashCombo &combo, HashDataPage *bin_head, RecordLocation *result)
	Usually follows locate_bin to locate the exact physical record for the key, or create a new one if not exists (only when for_write). More...
ErrorCode	locate_record_physical_only (thread::Thread *context, bool for_write, bool create_if_notfound, uint16_t create_payload_length, const void *key, uint16_t key_length, const HashCombo &combo, HashDataPage *bin_head, RecordLocation *result)
	locate_record()'s physical_only version. More...
ErrorCode	locate_record_logical (thread::Thread *context, bool for_write, bool create_if_notfound, uint16_t create_payload_length, const void *key, uint16_t key_length, const HashCombo &combo, HashDataPage *bin_head, RecordLocation *result)
	locate_record()'s logical+physical version. More...
ErrorCode	locate_record_in_snapshot (thread::Thread *context, const void *key, uint16_t key_length, const HashCombo &combo, HashDataPage *bin_head, RecordLocation *result)
	Simpler version of locate_record for when we are in snapshot world. More...
ErrorCode	locate_record_reserve_physical (thread::Thread *context, const void *key, uint16_t key_length, const HashCombo &combo, uint16_t payload_length, HashDataPage **page_in_out, uint16_t examined_records, DataPageSlotIndex *new_location)
	Subroutine of locate_record() to create/migrate a physical record of the given key in the page or its next pages. More...
Public Member Functions inherited from foedus::Attachable< HashStorageControlBlock >
	Attachable ()
	Attachable (Engine *engine)
	Attachable (Engine *engine, HashStorageControlBlock *control_block)
	Attachable (HashStorageControlBlock *control_block)
	Attachable (const Attachable &other)
virtual	~Attachable ()
Attachable &	operator= (const Attachable &other)
virtual void	attach (HashStorageControlBlock *control_block)
	Attaches to the given shared memory. More...
bool	is_attached () const
	Returns whether the object has been already attached to some shared memory. More...
HashStorageControlBlock *	get_control_block () const
Engine *	get_engine () const
void	set_engine (Engine *engine)

Additional Inherited Members
Protected Attributes inherited from foedus::Attachable< HashStorageControlBlock >
Engine *	engine_
	Most attachable object stores an engine pointer (local engine), so we define it here. More...
HashStorageControlBlock *	control_block_
	The shared data on shared memory that has been initialized in some SOC or master engine. More...

Constructor & Destructor Documentation

foedus::storage::hash::HashStoragePimpl::HashStoragePimpl ( )

inline

Definition at line 95 of file hash_storage_pimpl.hpp.

: Attachable<HashStorageControlBlock>() {}

foedus::storage::hash::HashStoragePimpl::HashStoragePimpl ( HashStorage *  storage )

inlineexplicit

Definition at line 96 of file hash_storage_pimpl.hpp.

    : Attachable<HashStorageControlBlock>(
      storage->get_engine(),
      storage->get_control_block()) {}

Member Function Documentation

ErrorStack foedus::storage::hash::HashStoragePimpl::create

(

const HashMetadata &

metadata

)

Definition at line 76 of file hash_storage_pimpl.cpp.

References ASSERT_ND, foedus::storage::hash::HashIntermediatePage::assert_range(), foedus::storage::hash::bins_to_level(), foedus::Attachable< HashStorageControlBlock >::control_block_, foedus::Attachable< HashStorageControlBlock >::engine_, ERROR_STACK, ERROR_STACK_MSG, exists(), foedus::storage::hash::fanout_power(), get_bin_bits(), foedus::storage::hash::HashMetadata::get_bin_count(), get_bin_count(), get_id(), get_levels(), foedus::Engine::get_memory_manager(), get_name(), foedus::memory::EngineMemory::get_node_memory(), foedus::Engine::get_options(), foedus::memory::PagePool::get_resolver(), foedus::memory::NumaNodeMemoryRef::get_volatile_pool(), foedus::memory::PagePool::grab_one(), foedus::storage::hash::HashIntermediatePage::initialize_volatile_page(), foedus::kErrorCodeStrAlreadyExists, foedus::kErrorCodeStrHashBinsTooMany, foedus::storage::kExists, foedus::kRetOk, foedus::storage::StorageOptions::partitioner_data_memory_mb_, foedus::memory::LocalPageResolver::resolve_offset_newpage(), foedus::EngineOptions::storage_, and WRAP_ERROR_CODE.

Referenced by foedus::storage::hash::HashStorage::create().

                                                                {
  if (exists()) {
    LOG(ERROR) << "This hash-storage already exists: " << get_name();
    return ERROR_STACK(kErrorCodeStrAlreadyExists);
  }

  // hash-specific check.
  // Due to the current design of hash_partitioner, we spend hashbins bytes
  // out of the partitioner memory.
  uint64_t required_partitioner_bytes = metadata.get_bin_count() + 4096ULL;
  uint64_t partitioner_bytes
    = engine_->get_options().storage_.partitioner_data_memory_mb_ * (1ULL << 20);
  // we don't bother checking other storages' consumption. the config might later change anyways.
  // Instead, leave a bit of margin (25%) for others.
  if (partitioner_bytes < required_partitioner_bytes * 1.25) {
    std::stringstream str;
    str << metadata << ".\n"
      << "To accomodate this number of hash bins, partitioner_data_memory_mb_ must be"
      << " at least " << (required_partitioner_bytes * 1.25 / (1ULL << 20));
    return ERROR_STACK_MSG(kErrorCodeStrHashBinsTooMany, str.str().c_str());
  }

  control_block_->meta_ = metadata;
  LOG(INFO) << "Newly creating an hash-storage " << get_name();
  control_block_->bin_count_ = 1ULL << get_bin_bits();
  control_block_->levels_ = bins_to_level(control_block_->bin_count_);
  ASSERT_ND(control_block_->levels_ >= 1U);
  ASSERT_ND(control_block_->bin_count_ <= fanout_power(control_block_->levels_));
  ASSERT_ND(control_block_->bin_count_ > fanout_power(control_block_->levels_ - 1U));
  LOG(INFO) << "bin_count=" << get_bin_count() << ", levels=" << static_cast<int>(get_levels());

  // small number of root pages. we should at least have that many free pages.
  // so far grab all of them from node 0. no round robbin
  const uint16_t kTheNode = 0;
  memory::PagePool* pool
    = engine_->get_memory_manager()->get_node_memory(kTheNode)->get_volatile_pool();
  const memory::LocalPageResolver &local_resolver = pool->get_resolver();

  // allocate only the root page
  memory::PagePoolOffset root_offset;
  WRAP_ERROR_CODE(pool->grab_one(&root_offset));
  ASSERT_ND(root_offset);
  HashIntermediatePage* root_page = reinterpret_cast<HashIntermediatePage*>(
    local_resolver.resolve_offset_newpage(root_offset));
  control_block_->root_page_pointer_.snapshot_pointer_ = 0;
  control_block_->root_page_pointer_.volatile_pointer_.set(kTheNode, root_offset);
  root_page->initialize_volatile_page(
    get_id(),
    control_block_->root_page_pointer_.volatile_pointer_,
    nullptr,
    control_block_->levels_ - 1U,
    0);
  root_page->assert_range();

  LOG(INFO) << "Newly created an hash-storage " << get_name();
  control_block_->status_ = kExists;
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::hash::HashStoragePimpl::debugout_single_thread	(	Engine *	engine,
		bool	volatile_only,
		bool	intermediate_only,
		uint32_t	max_pages
	)

These are defined in hash_storage_debug.cpp.

Definition at line 53 of file hash_storage_debug.cpp.

References foedus::storage::hash::TmpSnashotPage::as_intermediate(), CHECK_ERROR, foedus::Attachable< HashStorageControlBlock >::control_block_, debugout_single_thread_intermediate(), foedus::Attachable< HashStorageControlBlock >::engine_, foedus::memory::EngineMemory::get_global_volatile_page_resolver(), foedus::Engine::get_memory_manager(), foedus::storage::hash::TmpSnashotPage::init(), foedus::DefaultInitializable::initialize(), foedus::storage::VolatilePagePointer::is_null(), foedus::kRetOk, foedus::UninitializeGuard::kWarnIfUninitializeError, foedus::memory::GlobalVolatilePageResolver::resolve_offset(), foedus::storage::DualPagePointer::snapshot_pointer_, foedus::DefaultInitializable::uninitialize(), and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by foedus::storage::hash::HashStorage::debugout_single_thread().

                      {
  LOG(INFO) << "**"
    << std::endl << "***************************************************************"
    << std::endl << "***   Dumping " << HashStorage(engine_, control_block_) << " in details. "
    << std::endl << "*** volatile_only=" << volatile_only
      << ", intermediate_only=" << intermediate_only << ", max_pages=" << max_pages
    << std::endl << "***************************************************************";

  if (max_pages == 0) {
    return kRetOk;
  }

  cache::SnapshotFileSet files(engine);
  CHECK_ERROR(files.initialize());
  UninitializeGuard files_guard(&files, UninitializeGuard::kWarnIfUninitializeError);

  LOG(INFO) << "First, dumping volatile pages...";
  DualPagePointer pointer = control_block_->root_page_pointer_;
  if (pointer.volatile_pointer_.is_null()) {
    LOG(INFO) << "No volatile pages.";
  } else {
    HashIntermediatePage* root = reinterpret_cast<HashIntermediatePage*>(
      engine->get_memory_manager()->get_global_volatile_page_resolver().resolve_offset(
        pointer.volatile_pointer_));
    uint32_t remaining = max_pages - 1U;
    CHECK_ERROR(debugout_single_thread_intermediate(
      engine,
      &files,
      root,
      true,
      intermediate_only,
      &remaining));
  }
  LOG(INFO) << "Dumped volatile pages.";
  if (!volatile_only) {
    LOG(INFO) << "Now dumping snapshot pages...";
    if (pointer.snapshot_pointer_ == 0) {
      LOG(INFO) << "No snapshot pages.";
    } else {
      TmpSnashotPage tmp;
      CHECK_ERROR(tmp.init(&files, pointer.snapshot_pointer_));
      HashIntermediatePage* root = tmp.as_intermediate();
      uint32_t remaining = max_pages - 1U;
      CHECK_ERROR(debugout_single_thread_intermediate(
        engine,
        &files,
        root,
        false,
        intermediate_only,
        &remaining));
    }
    LOG(INFO) << "Dumped snapshot pages.";
  }

  CHECK_ERROR(files.uninitialize());
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::hash::HashStoragePimpl::debugout_single_thread_data	(	Engine *	engine,
		cache::SnapshotFileSet *	fileset,
		HashDataPage *	head,
		bool	follow_volatile,
		uint32_t *	remaining_pages
	)

Definition at line 181 of file hash_storage_debug.cpp.

References foedus::storage::hash::TmpSnashotPage::as_data(), CHECK_ERROR, foedus::memory::EngineMemory::get_global_volatile_page_resolver(), foedus::Engine::get_memory_manager(), foedus::storage::hash::TmpSnashotPage::init(), foedus::storage::VolatilePagePointer::is_null(), foedus::kRetOk, foedus::storage::DualPagePointer::snapshot_pointer_, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by debugout_single_thread_intermediate().

                       {
  TmpSnashotPage tmp;
  const auto& resolver = engine->get_memory_manager()->get_global_volatile_page_resolver();
  for (HashDataPage* cur = head; cur;) {
    LOG(INFO) << *cur;
    if ((*remaining) == 0 || --(*remaining) == 0) {
      LOG(INFO) << "Reached write-out max. skip the following";
      return kRetOk;
    }

    // here, we take a copy of pointer so that "cur" might be okay to become invalid after here.
    DualPagePointer pointer = cur->next_page();
    cur = nullptr;
    if (follow_volatile) {
      if (!pointer.volatile_pointer_.is_null()) {
        cur = reinterpret_cast<HashDataPage*>(resolver.resolve_offset(pointer.volatile_pointer_));
      }
    } else {
      if (pointer.snapshot_pointer_) {
        CHECK_ERROR(tmp.init(files, pointer.snapshot_pointer_));  // note, this overwrites tmp
        cur = tmp.as_data();
      }
    }
  }
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::hash::HashStoragePimpl::debugout_single_thread_intermediate	(	Engine *	engine,
		cache::SnapshotFileSet *	fileset,
		HashIntermediatePage *	parent,
		bool	follow_volatile,
		bool	intermediate_only,
		uint32_t *	remaining_pages
	)

Definition at line 116 of file hash_storage_debug.cpp.

References foedus::storage::hash::TmpSnashotPage::as_data(), foedus::storage::hash::TmpSnashotPage::as_intermediate(), CHECK_ERROR, debugout_single_thread_data(), foedus::memory::EngineMemory::get_global_volatile_page_resolver(), foedus::storage::hash::HashIntermediatePage::get_level(), foedus::Engine::get_memory_manager(), foedus::storage::hash::HashIntermediatePage::get_pointer(), foedus::storage::hash::TmpSnashotPage::init(), foedus::storage::VolatilePagePointer::is_null(), foedus::kRetOk, foedus::storage::DualPagePointer::snapshot_pointer_, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by debugout_single_thread().

                       {
  if (((*remaining) == 0) || --(*remaining) == 0) {
    LOG(INFO) << "Reached write-out max. skip the following";
    return kRetOk;
  }

  LOG(INFO) << *parent;
  bool bottom = parent->get_level() == 0;
  if (bottom && intermediate_only) {
    return kRetOk;
  }

  const auto& resolver = engine->get_memory_manager()->get_global_volatile_page_resolver();
  TmpSnashotPage tmp;
  for (uint8_t i = 0; i < kHashIntermediatePageFanout && ((*remaining) > 0); ++i) {
    DualPagePointer pointer = parent->get_pointer(i);
    if (follow_volatile) {
      if (pointer.volatile_pointer_.is_null()) {
        continue;
      }
      if (bottom) {
        HashDataPage* page = reinterpret_cast<HashDataPage*>(
          resolver.resolve_offset(pointer.volatile_pointer_));
        CHECK_ERROR(debugout_single_thread_data(engine, files, page, true, remaining));
      } else {
        HashIntermediatePage* page = reinterpret_cast<HashIntermediatePage*>(
          resolver.resolve_offset(pointer.volatile_pointer_));
        CHECK_ERROR(debugout_single_thread_intermediate(
          engine,
          files,
          page,
          true,
          intermediate_only,
          remaining));
      }
    } else {
      if (pointer.snapshot_pointer_ == 0) {
        continue;
      }
      CHECK_ERROR(tmp.init(files, pointer.snapshot_pointer_));
      if (bottom) {
        HashDataPage* page = tmp.as_data();
        CHECK_ERROR(debugout_single_thread_data(engine, files, page, false, remaining));
      } else {
        HashIntermediatePage* page = tmp.as_intermediate();
        CHECK_ERROR(debugout_single_thread_intermediate(
          engine,
          files,
          page,
          false,
          intermediate_only,
          remaining));
      }
    }
  }

  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::delete_record	(	thread::Thread *	context,
		const void *	key,
		uint16_t	key_length,
		const HashCombo &	combo
	)

See also

foedus::storage::hash::HashStorage::delete_record()

Definition at line 356 of file hash_storage_pimpl.cpp.

References ASSERT_ND, foedus::storage::hash::HashCommonLogType::calculate_log_length(), CHECK_ERROR_CODE, get_bin_bits(), get_id(), foedus::thread::Thread::get_thread_log_buffer(), foedus::storage::hash::HashCombo::hash_, foedus::xct::XctId::is_deleted(), foedus::storage::hash::RecordLocation::is_found(), foedus::kErrorCodeStrKeyNotFound, locate_bin(), locate_record_logical(), foedus::storage::hash::RecordLocation::observed_, foedus::storage::hash::HashDeleteLogType::populate(), register_record_write_log(), and foedus::log::ThreadLogBuffer::reserve_new_log().

Referenced by foedus::storage::hash::HashStorage::delete_record().

                          {
  HashDataPage* bin_head;
  CHECK_ERROR_CODE(locate_bin(context, true, combo, &bin_head));
  ASSERT_ND(bin_head);
  RecordLocation location;
  CHECK_ERROR_CODE(locate_record_logical(
    context,
    true,
    false,
    0,
    key,
    key_length,
    combo,
    bin_head,
    &location));

  if (!location.is_found()) {
    return kErrorCodeStrKeyNotFound;  // protected by page version set, so we are done
  } else if (location.observed_.is_deleted()) {
    return kErrorCodeStrKeyNotFound;  // protected by the read set
  }

  uint16_t log_length = HashDeleteLogType::calculate_log_length(key_length, 0);
  HashDeleteLogType* log_entry = reinterpret_cast<HashDeleteLogType*>(
    context->get_thread_log_buffer().reserve_new_log(log_length));
  log_entry->populate(get_id(), key, key_length, get_bin_bits(), combo.hash_);

  return register_record_write_log(context, location, log_entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::hash::HashStoragePimpl::drop

(

)

Definition at line 59 of file hash_storage_pimpl.cpp.

References foedus::Attachable< HashStorageControlBlock >::control_block_, foedus::Attachable< HashStorageControlBlock >::engine_, foedus::memory::EngineMemory::get_global_volatile_page_resolver(), foedus::Engine::get_memory_manager(), get_name(), foedus::kRetOk, foedus::storage::hash::HashIntermediatePage::release_pages_recursive_parallel(), and foedus::memory::GlobalVolatilePageResolver::resolve_offset().

Referenced by foedus::storage::hash::HashStorage::drop().

                                  {
  LOG(INFO) << "Uninitializing an hash-storage " << get_name();

  if (!control_block_->root_page_pointer_.volatile_pointer_.is_null()) {
    // release volatile pages
    const memory::GlobalVolatilePageResolver& page_resolver
      = engine_->get_memory_manager()->get_global_volatile_page_resolver();
    HashIntermediatePage* root = reinterpret_cast<HashIntermediatePage*>(
      page_resolver.resolve_offset(control_block_->root_page_pointer_.volatile_pointer_));
    root->release_pages_recursive_parallel(engine_);
    control_block_->root_page_pointer_.volatile_pointer_.word = 0;
  }

  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::storage::hash::HashStoragePimpl::exists ( ) const

inline

Definition at line 160 of file hash_storage_pimpl.hpp.

References foedus::Attachable< HashStorageControlBlock >::control_block_.

Referenced by create().

{ return control_block_->exists(); }

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::follow_page	(	thread::Thread *	context,
		bool	for_write,
		HashIntermediatePage *	parent,
		uint16_t	index_in_parent,
		Page **	page
	)

for non-root

Definition at line 625 of file hash_storage_pimpl.cpp.

References ASSERT_ND, foedus::storage::hash::HashBinRange::begin_, CHECK_ERROR_CODE, foedus::thread::Thread::find_or_read_a_snapshot_page(), follow_page_bin_head(), foedus::thread::Thread::follow_page_pointer(), foedus::storage::hash::HashIntermediatePage::get_bin_range(), foedus::storage::hash::HashIntermediatePage::get_level(), foedus::storage::PageHeader::get_page_type(), foedus::storage::hash::HashIntermediatePage::get_pointer(), foedus::storage::hash::hash_intermediate_volatile_page_init(), foedus::storage::hash::HashIntermediatePage::header(), foedus::kErrorCodeOk, foedus::storage::kHashDataPageType, foedus::storage::hash::kHashIntermediatePageFanout, foedus::storage::kHashIntermediatePageType, foedus::storage::PageHeader::snapshot_, and foedus::storage::DualPagePointer::snapshot_pointer_.

Referenced by locate_bin().

               {
  ASSERT_ND(index_in_parent < kHashIntermediatePageFanout);
  ASSERT_ND(parent);
  ASSERT_ND(parent->header().get_page_type() == kHashIntermediatePageType);
  bool is_parent_snapshot = parent->header().snapshot_;
  uint8_t parent_level = parent->get_level();
  ASSERT_ND(!is_parent_snapshot || !for_write);

  DualPagePointer& pointer = parent->get_pointer(index_in_parent);
  bool child_intermediate = (parent_level > 0);
  if (is_parent_snapshot) {
    // if we are in snapshot world, there is no choice.
    // separating this out also handles SI level well.
    ASSERT_ND(!for_write);
    if (pointer.snapshot_pointer_ == 0) {
      *page = nullptr;
    } else {
      CHECK_ERROR_CODE(context->find_or_read_a_snapshot_page(pointer.snapshot_pointer_, page));
      ASSERT_ND((*page)->get_header().snapshot_);
    }
  } else if (child_intermediate) {
    CHECK_ERROR_CODE(context->follow_page_pointer(
      hash_intermediate_volatile_page_init,
      !for_write,  // null page is a valid result only for reads ("not found")
      for_write,
      true,   // if we jump to snapshot page, we need to add it to pointer set for serializability.
      &pointer,
      page,
      reinterpret_cast<Page*>(parent),
      index_in_parent));
  } else {
    // we are in a level-0 volatile page. so the pointee is a bin-head.
    // we need a bit special handling in this case
    CHECK_ERROR_CODE(follow_page_bin_head(context, for_write, parent, index_in_parent, page));
  }

  if (*page) {
    if (child_intermediate) {
      ASSERT_ND((*page)->get_page_type() == kHashIntermediatePageType);
      ASSERT_ND((*page)->get_header().get_in_layer_level() + 1U == parent_level);
    } else {
      ASSERT_ND((*page)->get_page_type() == kHashDataPageType);
      ASSERT_ND(reinterpret_cast<HashDataPage*>(*page)->get_bin()
        == parent->get_bin_range().begin_ + index_in_parent);
    }
  }
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::follow_page_bin_head	(	thread::Thread *	context,
		bool	for_write,
		HashIntermediatePage *	parent,
		uint16_t	index_in_parent,
		Page **	page
	)

subroutine to follow a pointer to head of bin from a volatile parent

Definition at line 679 of file hash_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::storage::VolatilePagePointer::clear(), foedus::storage::construct_volatile_page_pointer(), foedus::thread::Thread::find_or_read_a_snapshot_page(), foedus::thread::Thread::follow_page_pointer(), foedus::storage::hash::HashDataPage::get_bin(), foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_isolation_level(), foedus::storage::hash::HashIntermediatePage::get_level(), foedus::thread::Thread::get_local_volatile_page_resolver(), foedus::thread::Thread::get_numa_node(), foedus::storage::VolatilePagePointer::get_numa_node(), foedus::storage::VolatilePagePointer::get_offset(), foedus::storage::PageHeader::get_page_type(), foedus::storage::hash::HashIntermediatePage::get_pointer_address(), foedus::thread::Thread::get_thread_memory(), foedus::memory::NumaCoreMemory::grab_free_volatile_page_pointer(), foedus::storage::hash::hash_data_volatile_page_init(), foedus::storage::hash::HashIntermediatePage::header(), foedus::storage::hash::HashDataPage::header(), foedus::storage::VolatilePagePointer::is_null(), foedus::kErrorCodeMemoryNoFreePages, foedus::kErrorCodeOk, foedus::storage::kHashIntermediatePageType, foedus::storage::kPageSize, foedus::xct::kSerializable, foedus::xct::kSnapshot, foedus::storage::hash::HashDataPage::next_page(), foedus::storage::hash::HashDataPage::next_page_address(), foedus::storage::PageHeader::page_id_, foedus::memory::NumaCoreMemory::release_free_volatile_page(), foedus::thread::Thread::resolve(), foedus::thread::Thread::resolve_cast(), foedus::memory::LocalPageResolver::resolve_offset_newpage(), foedus::storage::PageHeader::snapshot_, foedus::storage::DualPagePointer::snapshot_pointer_, UNLIKELY, foedus::storage::DualPagePointer::volatile_pointer_, and foedus::storage::VolatilePagePointer::word.

Referenced by follow_page().

               {
  // do we have to newly create a volatile version of the pointed bin?
  ASSERT_ND(!parent->header().snapshot_);
  ASSERT_ND(parent->header().get_page_type() == kHashIntermediatePageType);
  ASSERT_ND(parent->get_level() == 0);
  xct::Xct& cur_xct = context->get_current_xct();
  xct::IsolationLevel isolation = cur_xct.get_isolation_level();
  DualPagePointer* pointer = parent->get_pointer_address(index_in_parent);

  // otherwise why in volatile page.
  ASSERT_ND(for_write || isolation != xct::kSnapshot || pointer->snapshot_pointer_ == 0);
  // in other words, we can safely "prefer" volatile page here.
  if (!pointer->volatile_pointer_.is_null()) {
    *page = context->resolve(pointer->volatile_pointer_);
  } else {
    SnapshotPagePointer snapshot_pointer = pointer->snapshot_pointer_;
    if (!for_write) {
      // reads don't have to create a new page. easy
      if (snapshot_pointer == 0) {
        *page = nullptr;
      } else {
        CHECK_ERROR_CODE(context->find_or_read_a_snapshot_page(snapshot_pointer, page));
      }

      if (isolation == xct::kSerializable) {
        VolatilePagePointer null_pointer;
        null_pointer.clear();
        cur_xct.add_to_pointer_set(&(pointer->volatile_pointer_), null_pointer);
      }
    } else {
      // writes need the volatile version.
      if (snapshot_pointer == 0) {
        // The bin is completely empty. we just make a new empty page.
        CHECK_ERROR_CODE(context->follow_page_pointer(
          hash_data_volatile_page_init,
          false,
          true,
          true,
          pointer,
          page,
          reinterpret_cast<Page*>(parent),
          index_in_parent));
      } else {
        // Otherwise, we must create a volatile version of the existing page.
        // a special rule for hash storage in this case: we create/drop volatile versions
        // in the granularity of hash bin. all or nothing.
        // thus, not just the head page of the bin, we have to volatilize the entire bin.
        memory::NumaCoreMemory* core_memory = context->get_thread_memory();
        const memory::LocalPageResolver& local_resolver
          = context->get_local_volatile_page_resolver();
        VolatilePagePointer head_page_id = core_memory->grab_free_volatile_page_pointer();
        const auto offset = head_page_id.get_offset();
        if (UNLIKELY(head_page_id.is_null())) {
          return kErrorCodeMemoryNoFreePages;
        }

        HashDataPage* head_page
          = reinterpret_cast<HashDataPage*>(local_resolver.resolve_offset_newpage(offset));
        storage::Page* snapshot_head;
        ErrorCode code = context->find_or_read_a_snapshot_page(snapshot_pointer, &snapshot_head);
        if (code != kErrorCodeOk) {
          core_memory->release_free_volatile_page(offset);
          return code;
        }

        std::memcpy(head_page, snapshot_head, kPageSize);
        ASSERT_ND(head_page->header().snapshot_);
        head_page->header().snapshot_ = false;
        head_page->header().page_id_ = head_page_id.word;

        // load following pages. hopefully this is a rare case.
        ErrorCode last_error = kErrorCodeOk;
        if (UNLIKELY(head_page->next_page().snapshot_pointer_)) {
          HashDataPage* cur_page = head_page;
          while (true) {
            ASSERT_ND(last_error == kErrorCodeOk);
            SnapshotPagePointer next = cur_page->next_page().snapshot_pointer_;
            if (next == 0) {
              break;
            }

            DVLOG(1) << "Following next-link in hash data pages. Hopefully it's not that long..";
            VolatilePagePointer next_page_id = core_memory->grab_free_volatile_page_pointer();
            memory::PagePoolOffset next_offset = next_page_id.get_offset();
            if (UNLIKELY(next_page_id.is_null())) {
              // we have to release preceding pages too
              last_error = kErrorCodeMemoryNoFreePages;
              break;
            }
            HashDataPage* next_page
              = reinterpret_cast<HashDataPage*>(local_resolver.resolve_offset_newpage(next_offset));
            // immediately install because:
            // 1) we don't have any race here, 2) we need to follow them to release on error.
            DualPagePointer* target = cur_page->next_page_address();
            ASSERT_ND(target->volatile_pointer_.is_null());
            target->volatile_pointer_ = next_page_id;
            target->snapshot_pointer_ = 0;  // will be no longer used, let's clear them

            storage::Page* snapshot_page;
            last_error = context->find_or_read_a_snapshot_page(next, &snapshot_page);
            if (last_error != kErrorCodeOk) {
              break;
            }
            std::memcpy(next_page, snapshot_page, kPageSize);
            ASSERT_ND(next_page->header().snapshot_);
            ASSERT_ND(next_page->get_bin() == cur_page->get_bin());
            next_page->header().snapshot_ = false;
            next_page->header().page_id_ = next_page_id.word;
            cur_page = next_page;
          }
        }

        // all rihgt, now atomically install the pointer to the volatile head page.
        bool must_release_pages = false;
        if (last_error == kErrorCodeOk) {
          uint64_t expected = 0;
          if (assorted::raw_atomic_compare_exchange_strong<uint64_t>(
            &(pointer->volatile_pointer_.word),
            &expected,
            head_page_id.word)) {
            // successfully installed the head pointer. fine.
            *page = reinterpret_cast<Page*>(head_page);
          } else {
            ASSERT_ND(expected);
            // someone else has installed it, which is also fine.
            // but, we must release pages we created (which turned out to be a waste effort)
            LOG(INFO) << "Interesting. Someone else has installed a volatile version.";
            *page = context->resolve(pointer->volatile_pointer_);
            must_release_pages = true;
          }
        } else {
          must_release_pages = true;
        }

        if (must_release_pages) {
          HashDataPage* cur = head_page;
          while (true) {
            VolatilePagePointer cur_id = construct_volatile_page_pointer(cur->header().page_id_);
            ASSERT_ND(cur_id.get_numa_node() == context->get_numa_node());
            ASSERT_ND(!cur_id.is_null());
            // retrieve next_id BEFORE releasing (revoking) cur page.
            VolatilePagePointer next_id = cur->next_page().volatile_pointer_;
            core_memory->release_free_volatile_page(cur_id.get_offset());
            if (next_id.is_null()) {
              break;
            }
            cur = context->resolve_cast<HashDataPage>(next_id);
          }
        }

        CHECK_ERROR_CODE(last_error);
      }
    }
  }

  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t foedus::storage::hash::HashStoragePimpl::get_bin_bits ( ) const

inline

Definition at line 166 of file hash_storage_pimpl.hpp.

References foedus::storage::hash::HashMetadata::bin_bits_, and get_meta().

Referenced by create(), delete_record(), increment_record(), insert_record(), load(), overwrite_record(), and upsert_record().

{ return get_meta().bin_bits_; }

Here is the call graph for this function:

Here is the caller graph for this function:

HashBin foedus::storage::hash::HashStoragePimpl::get_bin_count ( ) const

inline

Definition at line 165 of file hash_storage_pimpl.hpp.

References foedus::storage::hash::HashMetadata::get_bin_count(), and get_meta().

Referenced by create().

{ return get_meta().get_bin_count(); }

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t foedus::storage::hash::HashStoragePimpl::get_bin_shifts ( ) const

inline

Definition at line 167 of file hash_storage_pimpl.hpp.

References foedus::storage::hash::HashMetadata::get_bin_shifts(), and get_meta().

{ return get_meta().get_bin_shifts(); }

Here is the call graph for this function:

StorageId foedus::storage::hash::HashStoragePimpl::get_id ( ) const

inline

Definition at line 161 of file hash_storage_pimpl.hpp.

References foedus::Attachable< HashStorageControlBlock >::control_block_.

Referenced by create(), delete_record(), increment_record(), insert_record(), overwrite_record(), register_record_write_log(), and upsert_record().

{ return control_block_->meta_.id_; }

Here is the caller graph for this function:

uint8_t foedus::storage::hash::HashStoragePimpl::get_levels ( ) const

inline

Definition at line 164 of file hash_storage_pimpl.hpp.

References foedus::Attachable< HashStorageControlBlock >::control_block_.

Referenced by create().

{ return control_block_->levels_; }

Here is the caller graph for this function:

const HashMetadata& foedus::storage::hash::HashStoragePimpl::get_meta ( ) const

inline

Definition at line 163 of file hash_storage_pimpl.hpp.

References foedus::Attachable< HashStorageControlBlock >::control_block_.

Referenced by get_bin_bits(), get_bin_count(), and get_bin_shifts().

{ return control_block_->meta_; }

Here is the caller graph for this function:

const StorageName& foedus::storage::hash::HashStoragePimpl::get_name ( ) const

inline

Definition at line 162 of file hash_storage_pimpl.hpp.

References foedus::Attachable< HashStorageControlBlock >::control_block_.

Referenced by create(), drop(), and load().

{ return control_block_->meta_.name_; }

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::get_record	(	thread::Thread *	context,
		const void *	key,
		uint16_t	key_length,
		const HashCombo &	combo,
		void *	payload,
		uint16_t *	payload_capacity,
		bool	read_only
	)

See also

foedus::storage::hash::HashStorage::get_record()

Definition at line 166 of file hash_storage_pimpl.cpp.

References CHECK_ERROR_CODE, foedus::storage::hash::RecordLocation::cur_payload_length_, foedus::storage::hash::RecordLocation::get_aligned_key_length(), foedus::storage::hash::RecordLocation::is_found(), foedus::kErrorCodeOk, foedus::kErrorCodeStrKeyNotFound, foedus::kErrorCodeStrTooSmallPayloadBuffer, locate_bin(), locate_record_logical(), and foedus::storage::hash::RecordLocation::record_.

Referenced by foedus::storage::hash::HashStorage::get_record().

                  {
  HashDataPage* bin_head;
  CHECK_ERROR_CODE(locate_bin(context, !read_only, combo, &bin_head));
  if (!bin_head) {
    return kErrorCodeStrKeyNotFound;  // protected by pointer set, so we are done
  }
  RecordLocation location;
  CHECK_ERROR_CODE(locate_record_logical(
    context,
    !read_only,
    false,
    0,
    key,
    key_length,
    combo,
    bin_head,
    &location));
  if (!location.is_found()) {
    return kErrorCodeStrKeyNotFound;  // protected by page version set, so we are done
  }

  // here, we do NOT have to do another optimistic-read protocol because we already took
  // the owner_id into read-set. If this read is corrupted, we will be aware of it at commit time.
  uint16_t payload_length = location.cur_payload_length_;
  if (payload_length > *payload_capacity) {
    // buffer too small
    DVLOG(0) << "buffer too small??" << payload_length << ":" << *payload_capacity;
    *payload_capacity = payload_length;
    return kErrorCodeStrTooSmallPayloadBuffer;
  }

  *payload_capacity = payload_length;
  uint16_t key_offset = location.get_aligned_key_length();
  std::memcpy(payload, location.record_ + key_offset, payload_length);
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::get_record_part	(	thread::Thread *	context,
		const void *	key,
		uint16_t	key_length,
		const HashCombo &	combo,
		void *	payload,
		uint16_t	payload_offset,
		uint16_t	payload_count,
		bool	read_only
	)

See also

foedus::storage::hash::HashStorage::get_record_part()

Definition at line 210 of file hash_storage_pimpl.cpp.

References CHECK_ERROR_CODE, foedus::storage::hash::RecordLocation::cur_payload_length_, foedus::storage::hash::RecordLocation::get_aligned_key_length(), foedus::storage::hash::RecordLocation::is_found(), foedus::kErrorCodeOk, foedus::kErrorCodeStrKeyNotFound, foedus::kErrorCodeStrTooShortPayload, locate_bin(), locate_record_logical(), and foedus::storage::hash::RecordLocation::record_.

Referenced by foedus::storage::hash::HashStorage::get_record_part(), and get_record_primitive().

                  {
  HashDataPage* bin_head;
  CHECK_ERROR_CODE(locate_bin(context, !read_only, combo, &bin_head));
  if (!bin_head) {
    return kErrorCodeStrKeyNotFound;  // protected by pointer set, so we are done
  }
  RecordLocation location;
  CHECK_ERROR_CODE(locate_record_logical(
    context,
    !read_only,
    false,
    0,
    key,
    key_length,
    combo,
    bin_head,
    &location));
  if (!location.is_found()) {
    return kErrorCodeStrKeyNotFound;  // protected by page version set, so we are done
  }

  uint16_t payload_length = location.cur_payload_length_;
  if (payload_length < payload_offset + payload_count) {
    LOG(WARNING) << "short record " << combo;  // probably this is a rare error. so warn.
    return kErrorCodeStrTooShortPayload;
  }

  uint16_t key_offset = location.get_aligned_key_length();
  std::memcpy(payload, location.record_ + key_offset + payload_offset, payload_count);
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename PAYLOAD >

ErrorCode foedus::storage::hash::HashStoragePimpl::get_record_primitive ( thread::Thread *  context, const void *  key, uint16_t  key_length, const HashCombo &  combo, PAYLOAD *  payload, uint16_t  payload_offset, bool  read_only  )

inline

See also

foedus::storage::hash::HashStorage::get_record_primitive()

Definition at line 181 of file hash_storage_pimpl.hpp.

References get_record_part().

Referenced by foedus::storage::hash::HashStorage::get_record_primitive().

                    {
    // at this point, there isn't enough benefit to do optimization specific to this case.
    // hash-lookup is anyway dominant. memcpy-vs-primitive is not the issue.
    return get_record_part(
      context,
      key,
      key_length,
      combo,
      payload,
      payload_offset,
      sizeof(PAYLOAD),
      read_only);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::get_root_page	(	thread::Thread *	context,
		bool	for_write,
		HashIntermediatePage **	root
	)

Retrieves the root page of this storage.

Definition at line 607 of file hash_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::Attachable< HashStorageControlBlock >::control_block_, foedus::thread::Thread::follow_page_pointer(), foedus::kErrorCodeOk, and foedus::storage::kHashIntermediatePageType.

Referenced by locate_bin().

                               {
  CHECK_ERROR_CODE(context->follow_page_pointer(
    nullptr,  // guaranteed to be non-null
    false,    // guaranteed to be non-null
    for_write,
    false,    // guaranteed to be non-null
    &control_block_->root_page_pointer_,
    reinterpret_cast<Page**>(root),
    nullptr,  // no parent. it's root.
    0));
  ASSERT_ND((*root)->header().get_page_type() == kHashIntermediatePageType);
  ASSERT_ND((*root)->get_level() + 1U == control_block_->levels_);
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::hash::HashStoragePimpl::hcc_reset_all_temperature_stat

(

)

For stupid reasons (I'm lazy!) these are defined in _debug.cpp.

Definition at line 213 of file hash_storage_debug.cpp.

References CHECK_ERROR, foedus::Attachable< HashStorageControlBlock >::control_block_, foedus::Attachable< HashStorageControlBlock >::engine_, hcc_reset_all_temperature_stat_intermediate(), foedus::storage::VolatilePagePointer::is_null(), foedus::kRetOk, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by foedus::storage::hash::HashStorage::hcc_reset_all_temperature_stat().

                                                            {
  LOG(INFO) << "**"
    << std::endl << "***************************************************************"
    << std::endl << "***   Reseting " << HashStorage(engine_, control_block_) << "'s "
    << std::endl << "*** temperature stat for HCC"
    << std::endl << "***************************************************************";

  DualPagePointer pointer = control_block_->root_page_pointer_;
  if (pointer.volatile_pointer_.is_null()) {
    LOG(INFO) << "No volatile pages.";
  } else {
    CHECK_ERROR(hcc_reset_all_temperature_stat_intermediate(pointer.volatile_pointer_));
  }

  LOG(INFO) << "Done resettting";
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::hash::HashStoragePimpl::hcc_reset_all_temperature_stat_data

(

VolatilePagePointer

head_page_id

)

Definition at line 253 of file hash_storage_debug.cpp.

References foedus::Attachable< HashStorageControlBlock >::engine_, foedus::memory::EngineMemory::get_global_volatile_page_resolver(), foedus::Engine::get_memory_manager(), foedus::storage::hash::HashDataPage::header(), foedus::storage::PageHeader::hotness_, foedus::storage::VolatilePagePointer::is_null(), foedus::kRetOk, and foedus::assorted::ProbCounter::reset().

Referenced by hcc_reset_all_temperature_stat_intermediate().

                                                                                                 {
  const auto& resolver = engine_->get_memory_manager()->get_global_volatile_page_resolver();
  HashDataPage* head = reinterpret_cast<HashDataPage*>(resolver.resolve_offset(head_page_id));
  for (HashDataPage* cur = head; cur;) {
    cur->header().hotness_.reset();
    VolatilePagePointer next_id = cur->next_page().volatile_pointer_;
    cur = nullptr;
    if (!next_id.is_null()) {
      cur = reinterpret_cast<HashDataPage*>(resolver.resolve_offset(next_id));
    }
  }
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::hash::HashStoragePimpl::hcc_reset_all_temperature_stat_intermediate

(

VolatilePagePointer

intermediate_page_id

)

Definition at line 231 of file hash_storage_debug.cpp.

References ASSERT_ND, CHECK_ERROR, foedus::Attachable< HashStorageControlBlock >::engine_, foedus::memory::EngineMemory::get_global_volatile_page_resolver(), foedus::storage::hash::HashIntermediatePage::get_level(), foedus::Engine::get_memory_manager(), foedus::storage::hash::HashIntermediatePage::get_pointer(), hcc_reset_all_temperature_stat_data(), foedus::storage::VolatilePagePointer::is_null(), foedus::storage::hash::kHashIntermediatePageFanout, foedus::kRetOk, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by hcc_reset_all_temperature_stat().

                                            {
  const auto& resolver = engine_->get_memory_manager()->get_global_volatile_page_resolver();
  HashIntermediatePage* page
    = reinterpret_cast<HashIntermediatePage*>(resolver.resolve_offset(intermediate_page_id));
  ASSERT_ND(page);
  const bool bottom = page->get_level() == 0;
  for (uint8_t i = 0; i < kHashIntermediatePageFanout; ++i) {
    DualPagePointer pointer = page->get_pointer(i);
    if (pointer.volatile_pointer_.is_null()) {
      continue;
    }
    if (bottom) {
      CHECK_ERROR(hcc_reset_all_temperature_stat_data(pointer.volatile_pointer_));
    } else {
      CHECK_ERROR(hcc_reset_all_temperature_stat_intermediate(pointer.volatile_pointer_));
    }
  }

  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename PAYLOAD >

ErrorCode foedus::storage::hash::HashStoragePimpl::increment_record	(	thread::Thread *	context,
		const void *	key,
		uint16_t	key_length,
		const HashCombo &	combo,
		PAYLOAD *	value,
		uint16_t	payload_offset
	)

See also

foedus::storage::hash::HashStorage::increment_record()

Definition at line 554 of file hash_storage_pimpl.cpp.

References ASSERT_ND, foedus::storage::hash::HashCommonLogType::calculate_log_length(), CHECK_ERROR_CODE, foedus::storage::hash::RecordLocation::cur_payload_length_, foedus::storage::hash::RecordLocation::get_aligned_key_length(), get_bin_bits(), get_id(), foedus::thread::Thread::get_thread_log_buffer(), foedus::storage::hash::HashCombo::hash_, foedus::xct::XctId::is_deleted(), foedus::storage::hash::RecordLocation::is_found(), foedus::kErrorCodeStrKeyNotFound, foedus::kErrorCodeStrTooShortPayload, locate_bin(), locate_record_logical(), foedus::storage::hash::RecordLocation::observed_, foedus::storage::hash::HashOverwriteLogType::populate(), foedus::storage::hash::RecordLocation::record_, register_record_write_log(), and foedus::log::ThreadLogBuffer::reserve_new_log().

Referenced by foedus::storage::hash::HashStorage::increment_record().

                           {
  HashDataPage* bin_head;
  CHECK_ERROR_CODE(locate_bin(context, true, combo, &bin_head));
  ASSERT_ND(bin_head);
  RecordLocation location;
  CHECK_ERROR_CODE(locate_record_logical(
    context,
    true,
    false,
    0,
    key,
    key_length,
    combo,
    bin_head,
    &location));

  if (!location.is_found()) {
    return kErrorCodeStrKeyNotFound;  // protected by page version set, so we are done
  } else if (location.observed_.is_deleted()) {
    return kErrorCodeStrKeyNotFound;  // protected by the read set
  } else if (location.cur_payload_length_ < payload_offset + sizeof(PAYLOAD)) {
    LOG(WARNING) << "short record " << combo;  // probably this is a rare error. so warn.
    return kErrorCodeStrTooShortPayload;  // protected by the read set
  }

  // value: (in) addendum, (out) value after addition.
  PAYLOAD* current = reinterpret_cast<PAYLOAD*>(
    location.record_ + location.get_aligned_key_length() + payload_offset);
  *value += *current;

  uint16_t log_length
    = HashOverwriteLogType::calculate_log_length(key_length, sizeof(PAYLOAD));
  HashOverwriteLogType* log_entry = reinterpret_cast<HashOverwriteLogType*>(
    context->get_thread_log_buffer().reserve_new_log(log_length));
  log_entry->populate(
    get_id(),
    key,
    key_length,
    get_bin_bits(),
    combo.hash_,
    value,
    payload_offset,
    sizeof(PAYLOAD));

  return register_record_write_log(context, location, log_entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::insert_record	(	thread::Thread *	context,
		const void *	key,
		uint16_t	key_length,
		const HashCombo &	combo,
		const void *	payload,
		uint16_t	payload_count,
		uint16_t	physical_payload_hint
	)

See also

foedus::storage::hash::HashStorage::insert_record()

Definition at line 277 of file hash_storage_pimpl.cpp.

References foedus::storage::hash::adjust_payload_hint(), ASSERT_ND, foedus::storage::hash::HashDataPage::bloom_filter(), foedus::storage::hash::HashCommonLogType::calculate_log_length(), CHECK_ERROR_CODE, foedus::storage::hash::DataPageBloomFilter::contains(), foedus::storage::hash::HashCombo::fingerprint_, get_bin_bits(), get_id(), foedus::storage::hash::RecordLocation::get_max_payload(), foedus::thread::Thread::get_thread_log_buffer(), foedus::storage::hash::HashCombo::hash_, foedus::storage::hash::HashDataPage::header(), foedus::storage::hash::RecordLocation::index_, foedus::xct::XctId::is_deleted(), foedus::storage::hash::RecordLocation::is_found(), foedus::kErrorCodeStrKeyAlreadyExists, locate_bin(), locate_record_logical(), foedus::storage::hash::RecordLocation::observed_, foedus::storage::hash::RecordLocation::page_, foedus::storage::hash::HashInsertLogType::populate(), foedus::storage::hash::RecordLocation::record_, register_record_write_log(), foedus::log::ThreadLogBuffer::reserve_new_log(), foedus::thread::Thread::run_nested_sysxct(), and foedus::storage::PageHeader::snapshot_.

Referenced by foedus::storage::hash::HashStorage::insert_record().

                                  {
  physical_payload_hint = adjust_payload_hint(payload_count, physical_payload_hint);

  HashDataPage* bin_head;
  CHECK_ERROR_CODE(locate_bin(context, true, combo, &bin_head));
  ASSERT_ND(bin_head);

  while (true) {  // we might retry due to migrate_record. not that often, tho.
    RecordLocation location;
    CHECK_ERROR_CODE(locate_record_logical(
      context,
      true,
      true,
      physical_payload_hint,
      key,
      key_length,
      combo,
      bin_head,
      &location));

    // we create if not exists, these are surely non-null
    ASSERT_ND(location.is_found());
    ASSERT_ND(location.record_);

    // but, that record might be not logically deleted
    if (!location.observed_.is_deleted()) {
      return kErrorCodeStrKeyAlreadyExists;  // protected by the read set
    }

    if (payload_count > location.get_max_payload()) {
      // The physical record is too short. It will trigger a record expansion, which is a
      // system transaction (logically does nothing!) to migrate this deleted record.
      HashDataPage* cur_page = location.page_;
      ASSERT_ND(!cur_page->header().snapshot_);
      ASSERT_ND(cur_page->bloom_filter().contains(combo.fingerprint_));
      DataPageSlotIndex cur_index = location.index_;
      DVLOG(2) << "Record expansion triggered. payload_count=" << payload_count
        << ", current max=" << location.get_max_payload()
        << ", size hint=" << physical_payload_hint;

      ReserveRecords functor(
        context,
        cur_page,
        key,
        key_length,
        combo,
        payload_count,
        physical_payload_hint,
        cur_index);
      CHECK_ERROR_CODE(context->run_nested_sysxct(&functor, 5U));
      DVLOG(2) << "Expanded record!";
      // need to re-locate. also, beacuse the above method is physical-only,
      // the moved location might be again moved or now deleted. easise to just retry.
      continue;
    }

    uint16_t log_length = HashInsertLogType::calculate_log_length(key_length, payload_count);
    HashInsertLogType* log_entry = reinterpret_cast<HashInsertLogType*>(
      context->get_thread_log_buffer().reserve_new_log(log_length));
    log_entry->populate(
      get_id(),
      key,
      key_length,
      get_bin_bits(),
      combo.hash_,
      payload,
      payload_count);

    return register_record_write_log(context, location, log_entry);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::hash::HashStoragePimpl::load

(

const StorageControlBlock &

snapshot_block

)

Definition at line 135 of file hash_storage_pimpl.cpp.

References foedus::storage::hash::bins_to_level(), CHECK_ERROR, foedus::Attachable< HashStorageControlBlock >::control_block_, foedus::Attachable< HashStorageControlBlock >::engine_, get_bin_bits(), foedus::Engine::get_memory_manager(), get_name(), foedus::DefaultInitializable::initialize(), foedus::storage::kExists, foedus::kRetOk, foedus::UninitializeGuard::kWarnIfUninitializeError, foedus::memory::EngineMemory::load_one_volatile_page(), foedus::storage::StorageControlBlock::meta_, foedus::storage::Metadata::root_snapshot_page_id_, and foedus::DefaultInitializable::uninitialize().

Referenced by foedus::storage::hash::HashStorage::load().

                                                                           {
  control_block_->meta_ = static_cast<const HashMetadata&>(snapshot_block.meta_);
  const HashMetadata& meta = control_block_->meta_;
  control_block_->bin_count_ = 1ULL << get_bin_bits();
  control_block_->levels_ = bins_to_level(control_block_->bin_count_);
  control_block_->root_page_pointer_.snapshot_pointer_ = meta.root_snapshot_page_id_;
  control_block_->root_page_pointer_.volatile_pointer_.word = 0;

  // Root page always has volatile version.
  // Construct it from snapshot version.
  cache::SnapshotFileSet fileset(engine_);
  CHECK_ERROR(fileset.initialize());
  UninitializeGuard fileset_guard(&fileset, UninitializeGuard::kWarnIfUninitializeError);

  // load root page
  VolatilePagePointer volatile_pointer;
  HashIntermediatePage* volatile_root;
  CHECK_ERROR(engine_->get_memory_manager()->load_one_volatile_page(
    &fileset,
    meta.root_snapshot_page_id_,
    &volatile_pointer,
    reinterpret_cast<Page**>(&volatile_root)));
  control_block_->root_page_pointer_.volatile_pointer_ = volatile_pointer;

  CHECK_ERROR(fileset.uninitialize());

  LOG(INFO) << "Loaded a hash-storage " << get_name();
  control_block_->status_ = kExists;
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::locate_bin	(	thread::Thread *	context,
		bool	for_write,
		const HashCombo &	combo,
		HashDataPage **	bin_head
	)

Find a pointer to the bin that contains records for the hash.

Parameters

[in]	context	Thread context
[in]	for_write	Whether we are reading these pages to modify
[in]	combo	Hash values.
[out]	bin_head	Pointer to the first data page of the bin. Might be null.

If the search is for-write search, we always create a volatile page, even recursively, thus *bin_head!= null.

If the search is a for-read search and also the corresponding data page or its ascendants do not exist yet, *bin_head returns null. In that case, you can just return "not found" as a result. locate_bin() internally adds a pointer set to protect the result, too.

Note

Although the above rule is simple, this might be wasteful in some situation. Deletions and updates for non-existing keys do not need to instantiate volatile pages. It can be handled like read access in that case. But, to really achieve it, delete/update have to be 2-path. Search it using snapshot pages, then goes through volatile path when found. Rather, let's always create volatile pages for all writes. It's simple and performs the best except a very unlucky case. If miss-delete/update is really the common path, the user code can manually achieve the same thing by get() first, then delete/update().

Definition at line 842 of file hash_storage_pimpl.cpp.

References foedus::xct::Xct::add_to_pointer_set(), ASSERT_ND, foedus::storage::hash::HashCombo::bin_, CHECK_ERROR_CODE, foedus::storage::VolatilePagePointer::clear(), follow_page(), foedus::storage::hash::HashDataPage::get_bin(), foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_isolation_level(), foedus::storage::hash::HashIntermediatePage::get_level(), foedus::storage::hash::HashIntermediatePage::get_pointer(), get_root_page(), foedus::storage::hash::HashIntermediatePage::header(), foedus::kErrorCodeOk, foedus::xct::kSerializable, foedus::storage::hash::IntermediateRoute::route, foedus::storage::hash::HashCombo::route_, foedus::storage::PageHeader::snapshot_, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by delete_record(), get_record(), get_record_part(), increment_record(), insert_record(), overwrite_record(), and upsert_record().

                           {
  HashIntermediatePage* root;
  CHECK_ERROR_CODE(get_root_page(context, for_write, &root));
  ASSERT_ND(root);
  *bin_head = nullptr;
  xct::Xct& current_xct = context->get_current_xct();

  HashIntermediatePage* parent = root;
  while (true) {
    ASSERT_ND(parent);
    uint8_t parent_level = parent->get_level();
    uint16_t index = combo.route_.route[parent_level];
    Page* next;
    CHECK_ERROR_CODE(follow_page(context, for_write, parent, index, &next));
    if (!next) {
      // if this is a read-access, it is possible that the page even doesn't exist.
      // it is a valid result (not found). we just have to add a pointer set to protect the result.
      ASSERT_ND(!for_write);
      if (!parent->header().snapshot_  // then we already added a pointer set in higher level
        && current_xct.get_isolation_level() == xct::kSerializable) {
        VolatilePagePointer volatile_null;
        volatile_null.clear();
        CHECK_ERROR_CODE(
          current_xct.add_to_pointer_set(
            &parent->get_pointer(index).volatile_pointer_,
            volatile_null));
      }
      break;
    } else {
      if (parent_level == 0) {
        *bin_head = reinterpret_cast<HashDataPage*>(next);
        break;
      } else {
        parent = reinterpret_cast<HashIntermediatePage*>(next);
      }
    }
  }

  ASSERT_ND(*bin_head != nullptr || !for_write);
  ASSERT_ND(*bin_head == nullptr || (*bin_head)->get_bin() == combo.bin_);
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::locate_record	(	thread::Thread *	context,
		bool	for_write,
		bool	physical_only,
		bool	create_if_notfound,
		uint16_t	create_payload_length,
		const void *	key,
		uint16_t	key_length,
		const HashCombo &	combo,
		HashDataPage *	bin_head,
		RecordLocation *	result
	)

Usually follows locate_bin to locate the exact physical record for the key, or create a new one if not exists (only when for_write).

Parameters

[in]	context	Thread context
[in]	for_write	Whether we are seeking the record to modify
[in]	physical_only	If true, we skip observing XID and registering readset in a finalized fashion, see RecordLocation.
[in]	create_if_notfound	Whether we will create a new physical record if not exists
[in]	create_payload_length	If this method creates a physical record, it makes sure the record can accomodate at least this size of payload.
[in]	key	The searching key.
[in]	key_length	Byte length of the searching key.
[in]	combo	Hash values. Also the result of this method.
[in]	bin_head	Pointer to the first data page of the bin.
[out]	result	Information on the found slot.

Precondition

bin_head->get_bin() == combo.bin_

bin_head != nullptr

bin_head must be volatile page if for_write

If the exact record is not found, this method protects the result by adding page version set if physical_only is false. If create_if_notfound is true (an insert case), this method creates a new physical record for the key with a deleted-state as a system transaction.

See also

RecordLocation

Definition at line 936 of file hash_storage_pimpl.cpp.

References foedus::xct::Xct::add_to_page_version_set(), ASSERT_ND, foedus::storage::hash::HashCombo::bin_, CHECK_ERROR_CODE, foedus::storage::hash::RecordLocation::clear(), foedus::storage::hash::HashDataPage::compare_slot_key(), foedus::storage::hash::HashCombo::fingerprint_, foedus::storage::hash::HashDataPage::get_bin(), foedus::thread::Thread::get_current_xct(), foedus::thread::Thread::get_numa_node(), foedus::storage::hash::HashDataPage::get_record_count(), foedus::storage::PageVersionStatus::has_next_page(), foedus::storage::hash::HashCombo::hash_, foedus::storage::hash::HashDataPage::header(), foedus::xct::XctId::is_moved(), foedus::storage::VolatilePagePointer::is_null(), foedus::kErrorCodeOk, foedus::storage::hash::kSlotNotFound, locate_record_in_snapshot(), locate_record_reserve_physical(), foedus::assorted::memory_fence_acquire(), foedus::storage::hash::HashDataPage::next_page_address(), foedus::storage::hash::RecordLocation::observed_, foedus::storage::PageHeader::page_version_, foedus::storage::hash::RecordLocation::populate_logical(), foedus::storage::hash::RecordLocation::populate_physical(), foedus::thread::Thread::resolve_cast(), foedus::storage::hash::HashDataPage::search_key_physical(), foedus::storage::PageHeader::snapshot_, foedus::storage::PageHeader::stat_last_updater_node_, foedus::storage::PageVersion::status_, UNLIKELY, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by locate_record_logical(), and locate_record_physical_only().

                          {
  ASSERT_ND(bin_head);
  ASSERT_ND(bin_head->get_bin() == combo.bin_);
  ASSERT_ND(for_write || !create_if_notfound);  // create_if_notfound implies for_write

  // Snapshot case is way easier. Separtely handle that case.
  if (bin_head->header().snapshot_) {
    ASSERT_ND(!for_write);
    ASSERT_ND(!create_if_notfound);
    return locate_record_in_snapshot(context, key, key_length, combo, bin_head, result);
  }

  xct::Xct* cur_xct = &context->get_current_xct();

  // in hash storage, we maintain only bin_head's stat. it's enough
  if (for_write) {
    bin_head->header().stat_last_updater_node_ = context->get_numa_node();
  }

  HashDataPage* page = bin_head;
  while (true) {
    // Start with a physical-only search. We will re-check our observation below.
    const uint16_t record_count = page->get_record_count();
    const DataPageSlotIndex index = page->search_key_physical(
      combo.hash_,
      combo.fingerprint_,
      key,
      key_length,
      record_count);
    if (index != kSlotNotFound) {
      // found! but it might be now being logically moved/deleted.
      ASSERT_ND(page->compare_slot_key(index, combo.hash_, key, key_length));
      if (physical_only) {
        // we don't care. the caller is responsible to do logical operation
        result->populate_physical(page, index);
        return kErrorCodeOk;
      } else {
        CHECK_ERROR_CODE(result->populate_logical(cur_xct, page, index, for_write));
        if (UNLIKELY(result->observed_.is_moved())) {
          LOG(INFO) << "Interesting. The record has been just moved";
          continue;
        }
        return kErrorCodeOk;
      }
    }

    // Apparently not in this page, now on to next page. We have to be a bit careful
    // in this case. Non-null next page means this page is already static, but we
    // have to make sure we confirmed it in a right order.
    DualPagePointer* next_page = page->next_page_address();

    // we are in volatile page, there might be a race!
    PageVersionStatus page_status = page->header().page_version_.status_;
    assorted::memory_fence_acquire();  // from now on, page_status is the ground truth here.
    // check a few things after the fence.
    // invariant: we never move on to next page without guaranteeing that this page does not
    // contain a physical non-moved record with the key.

    // did someone insert a new record at this moment?
    uint16_t record_count_again = page->get_record_count();
    if (UNLIKELY(record_count != record_count_again)) {
      LOG(INFO) << "Interesting. concurrent insertion just happend to the page";
      assorted::memory_fence_acquire();
      continue;  // just retry to make it sure. this is rare.
    }

    // did someone install a new page at this moment?
    if (UNLIKELY(!page_status.has_next_page() && !next_page->volatile_pointer_.is_null())) {
      LOG(INFO) << "Interesting. concurrent next-page installation just happend to the page";
      assorted::memory_fence_acquire();
      continue;  // just retry to make it sure. this is rare.
    }

    if (next_page->volatile_pointer_.is_null()) {
      // no next page.
      if (create_if_notfound) {
        // this is the tail page, so let's insert it here.
        // we do that as a system transaction.
        ASSERT_ND(for_write);
        DataPageSlotIndex new_location;
        CHECK_ERROR_CODE(locate_record_reserve_physical(
          context,
          key,
          key_length,
          combo,
          create_payload_length,
          &page,
          record_count,
          &new_location));
        ASSERT_ND(new_location != kSlotNotFound);  // contract of the above method
        // The returned location is not logically protected... yet.
        ASSERT_ND(page->compare_slot_key(new_location, combo.hash_, key, key_length));
        if (physical_only) {
          // we don't care. the caller is responsible to do logical operation
          result->populate_physical(page, new_location);
          return kErrorCodeOk;
        } else {
          CHECK_ERROR_CODE(result->populate_logical(cur_xct, page, new_location, for_write));
          if (UNLIKELY(result->observed_.is_moved())) {
            LOG(INFO) << "Interesting. The record has been just moved after creation!";
            continue;
          }
          return kErrorCodeOk;
        }
      } else {
        // "NotFound" result. To finalize it,
        // we have to take version set because someone might
        // insert a new record/next-page later.
        result->clear();
        if (physical_only) {
          // we don't care. the caller is responsible to do logical operation
          return kErrorCodeOk;
        } else {
          // [Logical check]: Remember the page_status we observed as of checking record count
          // and verify it at commit time.
          CHECK_ERROR_CODE(cur_xct->add_to_page_version_set(
            &page->header().page_version_,
            page_status));
          return kErrorCodeOk;
        }
      }
    } else {
      page = context->resolve_cast<HashDataPage>(next_page->volatile_pointer_);
      ASSERT_ND(!page->header().snapshot_);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::locate_record_in_snapshot	(	thread::Thread *	context,
		const void *	key,
		uint16_t	key_length,
		const HashCombo &	combo,
		HashDataPage *	bin_head,
		RecordLocation *	result
	)

Simpler version of locate_record for when we are in snapshot world.

Definition at line 889 of file hash_storage_pimpl.cpp.

References ASSERT_ND, foedus::storage::hash::HashCombo::bin_, CHECK_ERROR_CODE, foedus::storage::hash::RecordLocation::clear(), foedus::storage::hash::HashDataPage::compare_slot_key(), foedus::thread::Thread::find_or_read_a_snapshot_page(), foedus::storage::hash::HashCombo::fingerprint_, foedus::storage::hash::HashDataPage::get_bin(), foedus::storage::Page::get_header(), foedus::storage::hash::HashDataPage::get_record_count(), foedus::storage::hash::HashCombo::hash_, foedus::storage::hash::HashDataPage::header(), foedus::xct::XctId::is_moved(), foedus::storage::VolatilePagePointer::is_null(), foedus::kErrorCodeOk, foedus::storage::hash::kSlotNotFound, foedus::storage::hash::HashDataPage::next_page_address(), foedus::storage::hash::RecordLocation::observed_, foedus::storage::hash::RecordLocation::populate_physical(), foedus::storage::hash::HashDataPage::search_key_physical(), foedus::storage::PageHeader::snapshot_, foedus::storage::DualPagePointer::snapshot_pointer_, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by locate_record().

                          {
  ASSERT_ND(bin_head);
  ASSERT_ND(bin_head->get_bin() == combo.bin_);
  ASSERT_ND(bin_head->header().snapshot_);
  result->clear();
  // Snapshot version doesn't need any of the concerns above. Easy!
  // Just physically search and follow to next page.
  HashDataPage* page = bin_head;
  while (true) {
    const uint16_t record_count = page->get_record_count();
    const DataPageSlotIndex index = page->search_key_physical(
      combo.hash_,
      combo.fingerprint_,
      key,
      key_length,
      record_count);
    if (index != kSlotNotFound) {
      // found! this is final in snapshot page, so physical-only suffices (no protection needed).
      ASSERT_ND(page->compare_slot_key(index, combo.hash_, key, key_length));
      result->populate_physical(page, index);
      ASSERT_ND(!result->observed_.is_moved());
      return kErrorCodeOk;
    }

    // Definitely not in this page, now on to next page.
    DualPagePointer* next_page = page->next_page_address();
    // then we are in snapshot world. no race.
    ASSERT_ND(next_page->volatile_pointer_.is_null());
    SnapshotPagePointer pointer = next_page->snapshot_pointer_;
    if (pointer) {
      Page* next;
      CHECK_ERROR_CODE(context->find_or_read_a_snapshot_page(pointer, &next));
      ASSERT_ND(next->get_header().snapshot_);
      page = reinterpret_cast<HashDataPage*>(next);
    } else {
      // it's snapshot world. the result is final, we are done.
      return kErrorCodeOk;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::locate_record_logical ( thread::Thread *  context, bool  for_write, bool  create_if_notfound, uint16_t  create_payload_length, const void *  key, uint16_t  key_length, const HashCombo &  combo, HashDataPage *  bin_head, RecordLocation *  result  )

inline

locate_record()'s logical+physical version.

Invoke this rather than locate_record directly

Definition at line 400 of file hash_storage_pimpl.hpp.

References locate_record().

Referenced by delete_record(), get_record(), get_record_part(), increment_record(), insert_record(), overwrite_record(), and upsert_record().

                            {
    return locate_record(
      context,
      for_write,
      false,
      create_if_notfound,
      create_payload_length,
      key,
      key_length,
      combo,
      bin_head,
      result);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::locate_record_physical_only ( thread::Thread *  context, bool  for_write, bool  create_if_notfound, uint16_t  create_payload_length, const void *  key, uint16_t  key_length, const HashCombo &  combo, HashDataPage *  bin_head, RecordLocation *  result  )

inline

locate_record()'s physical_only version.

Invoke this rather than locate_record directly

Definition at line 377 of file hash_storage_pimpl.hpp.

References locate_record().

                            {
    return locate_record(
      context,
      for_write,
      true,
      create_if_notfound,
      create_payload_length,
      key,
      key_length,
      combo,
      bin_head,
      result);
  }

Here is the call graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::locate_record_reserve_physical	(	thread::Thread *	context,
		const void *	key,
		uint16_t	key_length,
		const HashCombo &	combo,
		uint16_t	payload_length,
		HashDataPage **	page_in_out,
		uint16_t	examined_records,
		DataPageSlotIndex *	new_location
	)

Subroutine of locate_record() to create/migrate a physical record of the given key in the page or its next pages.

This method has the following possible outcomes:

• Created a new physical record of the key in the given page or its next pages.
• Did nothing because we found an existing record of the key in the given page or its next pages.

In either case, new_location returns the index of the record, thus it's never a kSlotNotFound.

This method is physical-only. It doesn't add any read-set or take logical record locks. Thus, even seemingly right after calling this method, you might find the new_location points to a moved record. It might happen. The caller is responsible to do a logical lock/readset etc and retries if necessary. But, this method does guarantee that the new_location points to a record of the given key that was at least at some point valid.

Definition at line 1074 of file hash_storage_pimpl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, foedus::kErrorCodeOk, foedus::storage::hash::ReserveRecords::out_page_, foedus::storage::hash::ReserveRecords::out_slot_, and foedus::thread::Thread::run_nested_sysxct().

Referenced by locate_record().

                                   {
  ASSERT_ND(new_location);
  ReserveRecords functor(
    context,
    *page_in_out,
    key,
    key_length,
    combo,
    payload_length,
    payload_length,
    examined_records);
  CHECK_ERROR_CODE(context->run_nested_sysxct(&functor, 5U));
  *page_in_out = functor.out_page_;
  *new_location = functor.out_slot_;
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::overwrite_record	(	thread::Thread *	context,
		const void *	key,
		uint16_t	key_length,
		const HashCombo &	combo,
		const void *	payload,
		uint16_t	payload_offset,
		uint16_t	payload_count
	)

See also

foedus::storage::hash::HashStorage::overwrite_record()

Definition at line 502 of file hash_storage_pimpl.cpp.

References ASSERT_ND, foedus::storage::hash::HashCommonLogType::calculate_log_length(), CHECK_ERROR_CODE, foedus::storage::hash::RecordLocation::cur_payload_length_, get_bin_bits(), get_id(), foedus::thread::Thread::get_thread_log_buffer(), foedus::storage::hash::HashCombo::hash_, foedus::xct::XctId::is_deleted(), foedus::storage::hash::RecordLocation::is_found(), foedus::kErrorCodeStrKeyNotFound, foedus::kErrorCodeStrTooShortPayload, locate_bin(), locate_record_logical(), foedus::storage::hash::RecordLocation::observed_, foedus::storage::hash::HashOverwriteLogType::populate(), register_record_write_log(), and foedus::log::ThreadLogBuffer::reserve_new_log().

Referenced by foedus::storage::hash::HashStorage::overwrite_record(), and overwrite_record_primitive().

                          {
  HashDataPage* bin_head;
  CHECK_ERROR_CODE(locate_bin(context, true, combo, &bin_head));
  ASSERT_ND(bin_head);
  RecordLocation location;
  CHECK_ERROR_CODE(locate_record_logical(
    context,
    true,
    false,
    0,
    key,
    key_length,
    combo,
    bin_head,
    &location));

  if (!location.is_found()) {
    return kErrorCodeStrKeyNotFound;  // protected by page version set, so we are done
  } else if (location.observed_.is_deleted()) {
    return kErrorCodeStrKeyNotFound;  // protected by the read set
  } else if (location.cur_payload_length_ < payload_offset + payload_count) {
    LOG(WARNING) << "short record " << combo;  // probably this is a rare error. so warn.
    return kErrorCodeStrTooShortPayload;  // protected by the read set
  }

  uint16_t log_length = HashOverwriteLogType::calculate_log_length(key_length, payload_count);
  HashOverwriteLogType* log_entry = reinterpret_cast<HashOverwriteLogType*>(
    context->get_thread_log_buffer().reserve_new_log(log_length));
  log_entry->populate(
    get_id(),
    key,
    key_length,
    get_bin_bits(),
    combo.hash_,
    payload,
    payload_offset,
    payload_count);

  // overwrite_record is apparently a blind-write, but actually it's not.
  // we depend on the fact that the record was not deleted/moved! so,
  // this still has a related/dependent read-set
  return register_record_write_log(context, location, log_entry);
}

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename PAYLOAD >

ErrorCode foedus::storage::hash::HashStoragePimpl::overwrite_record_primitive ( thread::Thread *  context, const void *  key, uint16_t  key_length, const HashCombo &  combo, PAYLOAD  payload, uint16_t  payload_offset  )

inline

See also

foedus::storage::hash::HashStorage::overwrite_record_primitive()

Definition at line 259 of file hash_storage_pimpl.hpp.

References overwrite_record().

Referenced by foedus::storage::hash::HashStorage::overwrite_record_primitive().

                             {
    // same above. still handy as an API, though.
    return overwrite_record(
      context,
      key,
      key_length,
      combo,
      &payload,
      payload_offset,
      sizeof(payload));
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::register_record_write_log	(	thread::Thread *	context,
		const RecordLocation &	location,
		log::RecordLogType *	log_entry
	)

Used in the following methods.

Definition at line 260 of file hash_storage_pimpl.cpp.

References foedus::xct::Xct::add_related_write_set(), foedus::xct::Xct::add_to_write_set(), ASSERT_ND, foedus::thread::Thread::get_current_xct(), get_id(), foedus::storage::hash::HashDataPage::get_slot_address(), foedus::storage::hash::RecordLocation::index_, foedus::storage::hash::RecordLocation::is_found(), foedus::storage::hash::RecordLocation::page_, foedus::storage::hash::RecordLocation::readset_, and foedus::storage::hash::RecordLocation::record_.

Referenced by delete_record(), increment_record(), insert_record(), overwrite_record(), and upsert_record().

                               {
  // If we have taken readset in locate_record, add as a related write set
  ASSERT_ND(location.is_found());
  auto* slot = location.page_->get_slot_address(location.index_);
  char* record = location.record_;
  xct::Xct* cur_xct = &context->get_current_xct();
  if (location.readset_) {
    return cur_xct->add_related_write_set(location.readset_, &slot->tid_, record, log_entry);
  } else {
    return cur_xct->add_to_write_set(get_id(), &slot->tid_, record, log_entry);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::hash::HashStoragePimpl::release_pages_recursive_data	(	memory::PageReleaseBatch *	batch,
		HashDataPage *	page,
		VolatilePagePointer	volatile_page_id
	)

void foedus::storage::hash::HashStoragePimpl::release_pages_recursive_intermediate	(	memory::PageReleaseBatch *	batch,
		HashIntermediatePage *	page,
		VolatilePagePointer	volatile_page_id
	)

void foedus::storage::hash::HashStoragePimpl::release_pages_recursive_root	(	memory::PageReleaseBatch *	batch,
		HashIntermediatePage *	page,
		VolatilePagePointer	volatile_page_id
	)

Used only from uninitialize()

xct::TrackMovedRecordResult foedus::storage::hash::HashStoragePimpl::track_moved_record	(	xct::RwLockableXctId *	old_address,
		xct::WriteXctAccess *	write_set
	)

Definition at line 1099 of file hash_storage_pimpl.cpp.

References ASSERT_ND, foedus::storage::hash::HashCommonLogType::assert_record_and_log_keys(), foedus::Attachable< HashStorageControlBlock >::control_block_, foedus::xct::RwLockableXctId::is_moved(), foedus::storage::kHashDataPageType, foedus::xct::WriteXctAccess::log_entry_, foedus::xct::WriteXctAccess::payload_address_, foedus::xct::RecordXctAccess::storage_id_, foedus::storage::to_page(), and track_moved_record_search().

Referenced by foedus::storage::hash::HashStorage::track_moved_record().

                                {
  ASSERT_ND(old_address);
  ASSERT_ND(old_address->is_moved());
  // We use moved bit only for volatile data pages
  HashDataPage* page = reinterpret_cast<HashDataPage*>(to_page(old_address));
  ASSERT_ND(!page->header().snapshot_);
  ASSERT_ND(page->header().get_page_type() == kHashDataPageType);

  // TID is the first member in slot, so this ugly cast works.
  HashDataPage::Slot* old_slot = reinterpret_cast<HashDataPage::Slot*>(old_address);
  ASSERT_ND(&old_slot->tid_ == old_address);

  // for tracking, we need the full key and hash. let's extract them.
  const char* key = page->record_from_offset(old_slot->offset_);
  uint16_t key_length = old_slot->key_length_;
  HashCombo combo(key, key_length, control_block_->meta_);

  // we need write_set only for sanity check. It's easier in hash storage!
  if (write_set) {
#ifndef NDEBUG
    ASSERT_ND(write_set->storage_id_ == page->header().storage_id_);
    ASSERT_ND(write_set->payload_address_ == page->record_from_offset(old_slot->offset_));
    HashCommonLogType* the_log = reinterpret_cast<HashCommonLogType*>(write_set->log_entry_);
    the_log->assert_record_and_log_keys(old_address, page->record_from_offset(old_slot->offset_));
#endif  // NDEBUG
  }
  HashDataPage::Slot* slot_origin = reinterpret_cast<HashDataPage::Slot*>(page + 1);
  ASSERT_ND(slot_origin > old_slot);  // because origin corresponds to "-1".
  DataPageSlotIndex old_index = slot_origin - old_slot - 1;
  ASSERT_ND(page->get_slot_address(old_index) == old_slot);

  return track_moved_record_search(page, key, key_length, combo);
}

Here is the call graph for this function:

Here is the caller graph for this function:

xct::TrackMovedRecordResult foedus::storage::hash::HashStoragePimpl::track_moved_record_search	(	HashDataPage *	page,
		const void *	key,
		uint16_t	key_length,
		const HashCombo &	combo
	)

Definition at line 1135 of file hash_storage_pimpl.cpp.

References ASSERT_ND, foedus::Attachable< HashStorageControlBlock >::engine_, foedus::storage::hash::HashCombo::fingerprint_, foedus::memory::EngineMemory::get_global_volatile_page_resolver(), foedus::Engine::get_memory_manager(), foedus::storage::hash::HashDataPage::get_record_count(), foedus::storage::hash::HashDataPage::get_slot_address(), foedus::storage::hash::HashCombo::hash_, foedus::storage::hash::HashDataPage::header(), foedus::storage::VolatilePagePointer::is_null(), foedus::storage::hash::kSlotNotFound, foedus::assorted::memory_fence_acquire(), foedus::assorted::memory_fence_consume(), foedus::storage::hash::HashDataPage::next_page_address(), foedus::storage::hash::HashDataPage::Slot::offset_, foedus::storage::hash::HashDataPage::record_from_offset(), foedus::memory::GlobalVolatilePageResolver::resolve_offset(), foedus::storage::hash::HashDataPage::search_key_physical(), foedus::storage::PageHeader::snapshot_, foedus::storage::DualPagePointer::snapshot_pointer_, foedus::storage::hash::HashDataPage::Slot::tid_, UNLIKELY, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by track_moved_record().

                          {
  const memory::GlobalVolatilePageResolver& resolver
    = engine_->get_memory_manager()->get_global_volatile_page_resolver();
  RecordLocation result;
  while (true) {
    ASSERT_ND(!page->header().snapshot_);
    ASSERT_ND(page->next_page_address()->snapshot_pointer_ == 0);
    const uint16_t record_count = page->get_record_count();

    // Tracking happens in commit phase, so we don't need further logical readset/lock things.
    // This is just to locate the new address. So, physical_only search.
    // (which might miss a new record being inserted, but it's just a bit conservative abort)
    DataPageSlotIndex index = page->search_key_physical(
      combo.hash_,
      combo.fingerprint_,
      key,
      key_length,
      record_count);
    if (index != kSlotNotFound) {
      HashDataPage::Slot* slot = page->get_slot_address(index);
      char* payload = page->record_from_offset(slot->offset_);
      return xct::TrackMovedRecordResult(&slot->tid_, payload);
    }

    // we must meet the same invariant as usual case. a bit simpler, though
    assorted::memory_fence_consume();
    DualPagePointer* next_page = page->next_page_address();
    assorted::memory_fence_consume();

    uint16_t record_count_again = page->get_record_count();
    if (UNLIKELY(record_count != record_count_again)) {
      LOG(INFO) << "Interesting. concurrent insertion just happend to the page";
      assorted::memory_fence_consume();
      continue;
    }
    if (next_page->volatile_pointer_.is_null()) {
      // This shouldn't happen as far as we flip moved bit after installing the new record
      LOG(WARNING) << "no next page?? but we didn't find the moved record in this page";
      assorted::memory_fence_acquire();
      if (next_page->volatile_pointer_.is_null()) {
        LOG(ERROR) << "Unexpected error, failed to track moved record in hash storage."
          << " This should not happen. hash combo=" << combo;
        return xct::TrackMovedRecordResult();
      }
      continue;
    }
    page = reinterpret_cast<HashDataPage*>(resolver.resolve_offset(next_page->volatile_pointer_));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::HashStoragePimpl::upsert_record	(	thread::Thread *	context,
		const void *	key,
		uint16_t	key_length,
		const HashCombo &	combo,
		const void *	payload,
		uint16_t	payload_count,
		uint16_t	physical_payload_hint
	)

See also

foedus::storage::hash::HashStorage::upsert_record()

Definition at line 390 of file hash_storage_pimpl.cpp.

References foedus::storage::hash::adjust_payload_hint(), ASSERT_ND, foedus::storage::hash::HashDataPage::bloom_filter(), foedus::storage::hash::HashCommonLogType::calculate_log_length(), CHECK_ERROR_CODE, foedus::storage::hash::DataPageBloomFilter::contains(), foedus::storage::hash::RecordLocation::cur_payload_length_, foedus::storage::hash::HashCombo::fingerprint_, get_bin_bits(), get_id(), foedus::storage::hash::RecordLocation::get_max_payload(), foedus::thread::Thread::get_thread_log_buffer(), foedus::storage::hash::HashCombo::hash_, foedus::storage::hash::HashDataPage::header(), foedus::storage::hash::RecordLocation::index_, foedus::xct::XctId::is_deleted(), foedus::storage::hash::RecordLocation::is_found(), locate_bin(), locate_record_logical(), foedus::storage::hash::RecordLocation::observed_, foedus::storage::hash::RecordLocation::page_, foedus::storage::hash::HashInsertLogType::populate(), foedus::storage::hash::HashUpdateLogType::populate(), foedus::storage::hash::HashOverwriteLogType::populate(), foedus::storage::hash::RecordLocation::record_, register_record_write_log(), foedus::log::ThreadLogBuffer::reserve_new_log(), foedus::thread::Thread::run_nested_sysxct(), and foedus::storage::PageHeader::snapshot_.

Referenced by foedus::storage::hash::HashStorage::upsert_record().

                                  {
  physical_payload_hint = adjust_payload_hint(payload_count, physical_payload_hint);

  // Upsert is a combination of what insert does and what delete does.
  // If there isn't an existing physical record, it's exactly same as insert.
  // If there is, it's _basically_ a delete followed by an insert.
  // There are a few complications, depending on the status of the record.

  HashDataPage* bin_head;
  CHECK_ERROR_CODE(locate_bin(context, true, combo, &bin_head));
  ASSERT_ND(bin_head);

  while (true) {  // we might retry due to migrate_record. not that often, tho.
    RecordLocation location;
    CHECK_ERROR_CODE(locate_record_logical(
      context,
      true,
      true,
      physical_payload_hint,
      key,
      key_length,
      combo,
      bin_head,
      &location));

    // we create if not exists, these are surely non-null
    ASSERT_ND(location.is_found());
    ASSERT_ND(location.record_);

    // Whether currently deleted or not, migrate it to make sure the record is long enough.
    if (payload_count > location.get_max_payload()) {
      HashDataPage* cur_page = location.page_;
      ASSERT_ND(!cur_page->header().snapshot_);
      ASSERT_ND(cur_page->bloom_filter().contains(combo.fingerprint_));
      DataPageSlotIndex cur_index = location.index_;
      DVLOG(2) << "Record expansion triggered. payload_count=" << payload_count
        << ", current max=" << location.get_max_payload()
        << ", size hint=" << physical_payload_hint;

      ReserveRecords functor(
        context,
        cur_page,
        key,
        key_length,
        combo,
        payload_count,
        physical_payload_hint,
        cur_index);
      CHECK_ERROR_CODE(context->run_nested_sysxct(&functor, 5U));
      DVLOG(2) << "Expanded record!";
      continue;  // need to re-locate the record. retry.
    }

    ASSERT_ND(payload_count <= location.get_max_payload());
    HashCommonLogType* log_common;
    if (location.observed_.is_deleted()) {
      // If it's a deleted record, this turns to be a plain insert.
      uint16_t log_length = HashInsertLogType::calculate_log_length(key_length, payload_count);
      HashInsertLogType* log_entry = reinterpret_cast<HashInsertLogType*>(
        context->get_thread_log_buffer().reserve_new_log(log_length));
      log_entry->populate(
        get_id(),
        key,
        key_length,
        get_bin_bits(),
        combo.hash_,
        payload,
        payload_count);
      log_common = log_entry;
    } else if (location.cur_payload_length_ == payload_count) {
      // If it's not changing payload size of existing record, we can conver it to an overwrite,
      // which is more efficient
      uint16_t log_length = HashUpdateLogType::calculate_log_length(key_length, payload_count);
      HashOverwriteLogType* log_entry = reinterpret_cast<HashOverwriteLogType*>(
        context->get_thread_log_buffer().reserve_new_log(log_length));
      log_entry->populate(
        get_id(),
        key,
        key_length,
        get_bin_bits(),
        combo.hash_,
        payload,
        0,
        payload_count);
      log_common = log_entry;
    } else {
      // If not, this is an update operation.
      uint16_t log_length = HashUpdateLogType::calculate_log_length(key_length, payload_count);
      HashUpdateLogType* log_entry = reinterpret_cast<HashUpdateLogType*>(
        context->get_thread_log_buffer().reserve_new_log(log_length));
      log_entry->populate(
        get_id(),
        key,
        key_length,
        get_bin_bits(),
        combo.hash_,
        payload,
        payload_count);
      log_common = log_entry;
    }

    return register_record_write_log(context, location, log_common);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::hash::HashStoragePimpl::verify_single_thread

(

Engine *

engine

)

These are defined in hash_storage_verify.cpp.

Definition at line 42 of file hash_storage_verify.cpp.

References CHECK_AND_ASSERT, CHECK_ERROR, foedus::Attachable< HashStorageControlBlock >::control_block_, foedus::memory::EngineMemory::get_global_volatile_page_resolver(), foedus::storage::hash::HashIntermediatePage::get_level(), foedus::Engine::get_memory_manager(), foedus::storage::VolatilePagePointer::is_null(), foedus::kRetOk, foedus::memory::GlobalVolatilePageResolver::resolve_offset(), and verify_single_thread_intermediate().

Referenced by foedus::storage::hash::HashStorage::verify_single_thread(), and verify_single_thread().

                                                                {
  VolatilePagePointer pointer = control_block_->root_page_pointer_.volatile_pointer_;
  if (!pointer.is_null()) {
    // TASK(Hideaki) probably two versions: always follow volatile vs snapshot
    // so far check volatile only
    HashIntermediatePage* root = reinterpret_cast<HashIntermediatePage*>(
      engine->get_memory_manager()->get_global_volatile_page_resolver().resolve_offset(pointer));
    CHECK_AND_ASSERT(root->get_level() + 1U == control_block_->levels_);
    CHECK_ERROR(verify_single_thread_intermediate(engine, root));
  }
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::hash::HashStoragePimpl::verify_single_thread

(

thread::Thread *

context

)

Definition at line 39 of file hash_storage_verify.cpp.

References foedus::thread::Thread::get_engine(), and verify_single_thread().

                                                                       {
  return verify_single_thread(context->get_engine());
}

Here is the call graph for this function:

ErrorStack foedus::storage::hash::HashStoragePimpl::verify_single_thread_data	(	Engine *	engine,
		HashDataPage *	head
	)

Definition at line 87 of file hash_storage_verify.cpp.

References CHECK_AND_ASSERT, foedus::storage::hash::HashDataPage::get_bin(), foedus::xct::XctId::get_epoch(), foedus::memory::EngineMemory::get_global_volatile_page_resolver(), foedus::Engine::get_memory_manager(), foedus::xct::XctId::is_being_written(), foedus::xct::RwLockableXctId::is_keylocked(), foedus::storage::VolatilePagePointer::is_null(), foedus::Epoch::is_valid(), foedus::storage::kHashDataPageType, foedus::kRetOk, foedus::storage::hash::HashDataPage::Slot::tid_, and foedus::xct::RwLockableXctId::xct_id_.

Referenced by verify_single_thread_intermediate().

                      {
  const auto& resolver = engine->get_memory_manager()->get_global_volatile_page_resolver();
  HashBin bin = head->get_bin();
  for (HashDataPage* page = head; page;) {
    CHECK_AND_ASSERT(page->header().get_page_type() == kHashDataPageType);
    CHECK_AND_ASSERT(!page->header().page_version_.is_locked());
    CHECK_AND_ASSERT(!page->header().page_version_.is_moved());
    CHECK_AND_ASSERT(!page->header().page_version_.is_retired());
    CHECK_AND_ASSERT(page->header().masstree_in_layer_level_ == 0);
    CHECK_AND_ASSERT(page->get_bin() == bin);

    page->assert_entries_impl();

    uint16_t records = page->get_record_count();
    for (DataPageSlotIndex i = 0; i < records; ++i) {
      HashDataPage::Slot* slot = page->get_slot_address(i);
      CHECK_AND_ASSERT(!slot->tid_.is_keylocked());
      CHECK_AND_ASSERT(!slot->tid_.xct_id_.is_being_written());
      CHECK_AND_ASSERT(slot->tid_.xct_id_.get_epoch().is_valid());
    }

    VolatilePagePointer next = page->next_page().volatile_pointer_;
    page = nullptr;
    if (!next.is_null()) {
      page = reinterpret_cast<HashDataPage*>(resolver.resolve_offset(next));
    }
  }

  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::storage::hash::HashStoragePimpl::verify_single_thread_intermediate	(	Engine *	engine,
		HashIntermediatePage *	page
	)

Definition at line 55 of file hash_storage_verify.cpp.

References foedus::storage::hash::HashBinRange::begin_, CHECK_AND_ASSERT, CHECK_ERROR, foedus::storage::hash::HashBinRange::end_, foedus::storage::hash::HashDataPage::get_bin(), foedus::storage::hash::HashIntermediatePage::get_bin_range(), foedus::memory::EngineMemory::get_global_volatile_page_resolver(), foedus::storage::hash::HashIntermediatePage::get_level(), foedus::Engine::get_memory_manager(), foedus::storage::PageHeader::get_page_type(), foedus::storage::hash::HashIntermediatePage::get_pointer(), foedus::storage::hash::HashIntermediatePage::header(), foedus::storage::PageVersion::is_locked(), foedus::storage::PageVersion::is_moved(), foedus::storage::VolatilePagePointer::is_null(), foedus::storage::PageVersion::is_retired(), foedus::storage::hash::kHashIntermediatePageFanout, foedus::storage::kHashIntermediatePageType, foedus::storage::hash::kHashMaxBins, foedus::kRetOk, foedus::storage::PageHeader::page_version_, verify_single_thread_data(), and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by verify_single_thread().

                              {
  CHECK_AND_ASSERT(page->header().get_page_type() == kHashIntermediatePageType);
  CHECK_AND_ASSERT(!page->header().page_version_.is_locked());
  CHECK_AND_ASSERT(!page->header().page_version_.is_moved());
  CHECK_AND_ASSERT(!page->header().page_version_.is_retired());
  uint8_t level = page->get_level();
  HashBin begin = page->get_bin_range().begin_;
  HashBin interval = kHashMaxBins[level];
  CHECK_AND_ASSERT(page->get_bin_range().end_ == begin + interval * kHashIntermediatePageFanout);
  const auto& resolver = engine->get_memory_manager()->get_global_volatile_page_resolver();
  for (uint8_t i = 0; i < kHashIntermediatePageFanout; ++i) {
    DualPagePointer pointer = page->get_pointer(i);
    if (!pointer.volatile_pointer_.is_null()) {
      if (level == 0) {
        HashDataPage* child = reinterpret_cast<HashDataPage*>(
          resolver.resolve_offset(pointer.volatile_pointer_));
        CHECK_AND_ASSERT(child->get_bin() == begin + i);
        CHECK_ERROR(verify_single_thread_data(engine, child));
      } else {
        HashIntermediatePage* child = reinterpret_cast<HashIntermediatePage*>(
          resolver.resolve_offset(pointer.volatile_pointer_));
        CHECK_AND_ASSERT(child->get_level() + 1U == level);
        CHECK_AND_ASSERT(child->get_bin_range().begin_ == begin + i * interval);
        CHECK_ERROR(verify_single_thread_intermediate(engine, child));
      }
    }
  }
  return kRetOk;
}

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