foedus::storage::masstree::MasstreeIntermediatePage Class Reference

Represents one intermediate page in Masstree Storage. More...

Detailed Description

Represents one intermediate page in Masstree Storage.

An intermediate page consists of bunch of separator keys and pointers to children nodes, which might be another intermediate pages or border nodes.

Attention

Do NOT instantiate this object or derive from this class. A page is always reinterpret-ed from a pooled memory region. No meaningful RTTI.

Definition at line 262 of file masstree_page_impl.hpp.

#include <masstree_page_impl.hpp>

Inheritance diagram for foedus::storage::masstree::MasstreeIntermediatePage:

Collaboration diagram for foedus::storage::masstree::MasstreeIntermediatePage:

Classes
struct	MiniPage

Public Member Functions
	MasstreeIntermediatePage ()=delete
	MasstreeIntermediatePage (const MasstreeIntermediatePage &other)=delete
MasstreeIntermediatePage &	operator= (const MasstreeIntermediatePage &other)=delete
void	prefetch () const
	prefetch upto separators. More...
uint8_t	find_minipage (KeySlice slice) const __attribute__((always_inline))
	Navigates a searching key-slice to one of the mini pages in this page. More...
MiniPage &	get_minipage (uint8_t index) __attribute__((always_inline))
const MiniPage &	get_minipage (uint8_t index) const __attribute__((always_inline))
KeySlice	get_separator (uint8_t index) const __attribute__((always_inline))
void	release_pages_recursive_parallel (Engine *engine)
	This method is used when we release a large number of volatile pages, most likely when we drop a storage. More...
void	release_pages_recursive (const memory::GlobalVolatilePageResolver &page_resolver, memory::PageReleaseBatch *batch)
void	initialize_volatile_page (StorageId storage_id, VolatilePagePointer page_id, uint8_t layer, uint8_t level, KeySlice low_fence, KeySlice high_fence)
void	initialize_snapshot_page (StorageId storage_id, SnapshotPagePointer page_id, uint8_t layer, uint8_t level, KeySlice low_fence, KeySlice high_fence)
void	append_pointer_snapshot (KeySlice low_fence, SnapshotPagePointer pointer)
	Appends a new poiner and separator in an existing mini page, used only by snapshot composer. More...
void	append_minipage_snapshot (KeySlice low_fence, SnapshotPagePointer pointer)
	Appends a new separator and the initial pointer in new mini page, used only by snapshot composer. More...
bool	is_full_snapshot () const
	Whether this page is full of poiters, used only by snapshot composer (or when no race) More...
void	extract_separators_snapshot (uint8_t index, uint8_t index_mini, KeySlice *separator_low, KeySlice *separator_high) const
	Retrieves separators defining the index, used only by snapshot composer, thus no race. More...
void	extract_separators_volatile (uint8_t index, uint8_t index_mini, KeySlice *separator_low, KeySlice *separator_high) const
	Retrieves separators defining the index, used for volatile page, which requires appropriate locks or retries by the caller. More...
void	extract_separators_common (uint8_t index, uint8_t index_mini, KeySlice *separator_low, KeySlice *separator_high) const
	Retrieves separators defining the index, used only by snapshot composer (or when no race) More...
void	verify_separators () const
void	set_separator (uint8_t minipage_index, KeySlice new_separator)
	Place a new separator for a new minipage. More...
Public Member Functions inherited from foedus::storage::masstree::MasstreePage
	MasstreePage ()=delete
	MasstreePage (const MasstreePage &other)=delete
MasstreePage &	operator= (const MasstreePage &other)=delete
PageHeader &	header ()
const PageHeader &	header () const
VolatilePagePointer	get_volatile_page_id () const
SnapshotPagePointer	get_snapshot_page_id () const
bool	is_border () const __attribute__((always_inline))
bool	is_empty_range () const __attribute__((always_inline))
	An empty-range page, either intermediate or border, never has any entries. More...
KeySlice	get_low_fence () const __attribute__((always_inline))
KeySlice	get_high_fence () const __attribute__((always_inline))
bool	is_high_fence_supremum () const __attribute__((always_inline))
bool	is_low_fence_infimum () const __attribute__((always_inline))
bool	is_layer_root () const __attribute__((always_inline))
KeySlice	get_foster_fence () const __attribute__((always_inline))
bool	is_foster_minor_null () const __attribute__((always_inline))
bool	is_foster_major_null () const __attribute__((always_inline))
VolatilePagePointer	get_foster_minor () const __attribute__((always_inline))
VolatilePagePointer	get_foster_major () const __attribute__((always_inline))
void	set_foster_twin (VolatilePagePointer minor, VolatilePagePointer major)
void	install_foster_twin (VolatilePagePointer minor, VolatilePagePointer major, KeySlice foster_fence)
bool	within_fences (KeySlice slice) const __attribute__((always_inline))
bool	within_foster_minor (KeySlice slice) const __attribute__((always_inline))
bool	within_foster_major (KeySlice slice) const __attribute__((always_inline))
bool	has_foster_child () const __attribute__((always_inline))
uint8_t	get_layer () const __attribute__((always_inline))
	Layer-0 stores the first 8 byte slice, Layer-1 next 8 byte... More...
uint8_t	get_btree_level () const __attribute__((always_inline))
	used only in masstree. More...
SlotIndex	get_key_count () const __attribute__((always_inline))
	physical key count (those keys might be deleted) in this page. More...
void	set_key_count (SlotIndex count) __attribute__((always_inline))
void	increment_key_count () __attribute__((always_inline))
void	prefetch_general () const __attribute__((always_inline))
	prefetch upto keys/separators, whether this page is border or interior. More...
const PageVersion &	get_version () const __attribute__((always_inline))
PageVersion &	get_version () __attribute__((always_inline))
const PageVersion *	get_version_address () const __attribute__((always_inline))
PageVersion *	get_version_address () __attribute__((always_inline))
xct::McsWwLock *	get_lock_address () __attribute__((always_inline))
bool	is_locked () const __attribute__((always_inline))
bool	is_moved () const __attribute__((always_inline))
bool	is_retired () const __attribute__((always_inline))
void	set_moved () __attribute__((always_inline))
void	set_retired () __attribute__((always_inline))
void	release_pages_recursive_common (const memory::GlobalVolatilePageResolver &page_resolver, memory::PageReleaseBatch *batch)
void	set_foster_major_offset_unsafe (memory::PagePoolOffset offset) __attribute__((always_inline))
	As the name suggests, this should be used only by composer. More...
void	set_high_fence_unsafe (KeySlice high_fence) __attribute__((always_inline))
	As the name suggests, this should be used only by composer. More...

Friends
struct	SplitIntermediate
std::ostream &	operator<< (std::ostream &o, const MasstreeIntermediatePage &v)
	defined in masstree_page_debug.cpp. More...

Additional Inherited Members
Protected Member Functions inherited from foedus::storage::masstree::MasstreePage
void	initialize_volatile_common (StorageId storage_id, VolatilePagePointer page_id, PageType page_type, uint8_t layer, uint8_t level, KeySlice low_fence, KeySlice high_fence)
void	initialize_snapshot_common (StorageId storage_id, SnapshotPagePointer page_id, PageType page_type, uint8_t layer, uint8_t level, KeySlice low_fence, KeySlice high_fence)
Protected Attributes inherited from foedus::storage::masstree::MasstreePage
PageHeader	header_
KeySlice	low_fence_
	Inclusive low fence of this page. More...
KeySlice	high_fence_
	Inclusive high fence of this page. More...
KeySlice	foster_fence_
	Inclusive low_fence of foster child. More...
VolatilePagePointer	foster_twin_ [2]
	Points to foster children, or tentative child pages. More...

Constructor & Destructor Documentation

foedus::storage::masstree::MasstreeIntermediatePage::MasstreeIntermediatePage ( )

delete

foedus::storage::masstree::MasstreeIntermediatePage::MasstreeIntermediatePage ( const MasstreeIntermediatePage &  other )

delete

Member Function Documentation

void foedus::storage::masstree::MasstreeIntermediatePage::append_minipage_snapshot ( KeySlice  low_fence, SnapshotPagePointer  pointer  )

inline

Appends a new separator and the initial pointer in new mini page, used only by snapshot composer.

Precondition

header_.snapshot

!is_full_snapshot()

Definition at line 1522 of file masstree_page_impl.hpp.

References ASSERT_ND, foedus::storage::VolatilePagePointer::clear(), foedus::storage::masstree::MasstreePage::get_key_count(), get_minipage(), foedus::storage::masstree::MasstreePage::header_, is_full_snapshot(), foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::key_count_, foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::pointers_, foedus::storage::masstree::MasstreePage::set_key_count(), foedus::storage::PageHeader::snapshot_, foedus::storage::DualPagePointer::snapshot_pointer_, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by append_pointer_snapshot().

                               {
  ASSERT_ND(header_.snapshot_);
  ASSERT_ND(!is_full_snapshot());
  uint16_t key_count = get_key_count();
  ASSERT_ND(key_count < kMaxIntermediateSeparators);
  ASSERT_ND(mini_pages_[key_count].key_count_ == kMaxIntermediateMiniSeparators);
  ASSERT_ND(low_fence > get_minipage(key_count).separators_[kMaxIntermediateMiniSeparators - 1]);
  separators_[key_count] = low_fence;
  MiniPage& new_minipage = mini_pages_[key_count + 1];
  new_minipage.key_count_ = 0;
  new_minipage.pointers_[0].volatile_pointer_.clear();
  new_minipage.pointers_[0].snapshot_pointer_ = pointer;
  set_key_count(key_count + 1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::masstree::MasstreeIntermediatePage::append_pointer_snapshot ( KeySlice  low_fence, SnapshotPagePointer  pointer  )

inline

Appends a new poiner and separator in an existing mini page, used only by snapshot composer.

Precondition

header_.snapshot

!is_full_snapshot()

Definition at line 1496 of file masstree_page_impl.hpp.

References append_minipage_snapshot(), ASSERT_ND, foedus::storage::VolatilePagePointer::clear(), foedus::storage::extract_snapshot_id_from_snapshot_pointer(), foedus::storage::masstree::MasstreePage::get_high_fence(), foedus::storage::masstree::MasstreePage::get_key_count(), foedus::storage::masstree::MasstreePage::get_low_fence(), foedus::storage::masstree::MasstreePage::header_, is_full_snapshot(), foedus::storage::masstree::MasstreePage::is_high_fence_supremum(), foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::key_count_, foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::pointers_, foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::separators_, foedus::storage::PageHeader::snapshot_, foedus::storage::DualPagePointer::snapshot_pointer_, and foedus::storage::DualPagePointer::volatile_pointer_.

                               {
  ASSERT_ND(header_.snapshot_);
  ASSERT_ND(!is_full_snapshot());
  uint16_t index = get_key_count();
  MiniPage& mini = mini_pages_[index];
  uint16_t index_mini = mini.key_count_;
  ASSERT_ND(low_fence > get_low_fence());
  ASSERT_ND(is_high_fence_supremum() || low_fence < get_high_fence());
  ASSERT_ND(pointer == 0 || extract_snapshot_id_from_snapshot_pointer(pointer) != 0);
  if (index_mini < kMaxIntermediateMiniSeparators) {
    // p0 s0 p1  + "s p" -> p0 s0 p1 s1 p2
    ASSERT_ND(pointer == 0  // composer init_root uses this method to set null pointers..
      || mini.pointers_[index_mini].snapshot_pointer_ != pointer);  // otherwise dup.
    ASSERT_ND(index_mini == 0 || low_fence > mini.separators_[index_mini - 1]);
    ASSERT_ND(index == 0 || low_fence > separators_[index - 1]);
    mini.separators_[index_mini] = low_fence;
    mini.pointers_[index_mini + 1].volatile_pointer_.clear();
    mini.pointers_[index_mini + 1].snapshot_pointer_ = pointer;
    ++mini.key_count_;
  } else {
    append_minipage_snapshot(low_fence, pointer);
  }
}

Here is the call graph for this function:

void foedus::storage::masstree::MasstreeIntermediatePage::extract_separators_common ( uint8_t  index, uint8_t  index_mini, KeySlice *  separator_low, KeySlice *  separator_high  ) const

inline

Retrieves separators defining the index, used only by snapshot composer (or when no race)

Definition at line 1539 of file masstree_page_impl.hpp.

References ASSERT_ND, foedus::storage::masstree::MasstreePage::get_high_fence(), foedus::storage::masstree::MasstreePage::get_key_count(), foedus::storage::masstree::MasstreePage::get_low_fence(), get_minipage(), get_separator(), foedus::storage::masstree::MasstreePage::is_border(), foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::key_count_, and foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::separators_.

Referenced by extract_separators_snapshot(), and extract_separators_volatile().

                                  {
  ASSERT_ND(!is_border());
  uint8_t key_count = get_key_count();
  ASSERT_ND(index <= key_count);
  const MasstreeIntermediatePage::MiniPage& minipage = get_minipage(index);
  ASSERT_ND(index_mini <= minipage.key_count_);
  if (index_mini == 0) {
    if (index == 0) {
      *separator_low = get_low_fence();
    } else {
      *separator_low = get_separator(index - 1U);
    }
  } else {
    *separator_low = minipage.separators_[index_mini - 1U];
  }
  if (index_mini == minipage.key_count_) {
    if (index == key_count) {
      *separator_high = get_high_fence();
    } else {
      *separator_high = get_separator(index);
    }
  } else {
    *separator_high = minipage.separators_[index_mini];
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::masstree::MasstreeIntermediatePage::extract_separators_snapshot ( uint8_t  index, uint8_t  index_mini, KeySlice *  separator_low, KeySlice *  separator_high  ) const

inline

Retrieves separators defining the index, used only by snapshot composer, thus no race.

Definition at line 367 of file masstree_page_impl.hpp.

References ASSERT_ND, extract_separators_common(), foedus::storage::masstree::MasstreePage::header_, and foedus::storage::PageHeader::snapshot_.

Referenced by foedus::storage::masstree::MasstreeComposer::construct_root().

                                    {
    ASSERT_ND(header_.snapshot_);
    extract_separators_common(index, index_mini, separator_low, separator_high);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::masstree::MasstreeIntermediatePage::extract_separators_volatile ( uint8_t  index, uint8_t  index_mini, KeySlice *  separator_low, KeySlice *  separator_high  ) const

inline

Retrieves separators defining the index, used for volatile page, which requires appropriate locks or retries by the caller.

The caller must be careful!

Definition at line 379 of file masstree_page_impl.hpp.

References ASSERT_ND, extract_separators_common(), foedus::storage::masstree::MasstreePage::header_, and foedus::storage::PageHeader::snapshot_.

                                    {
    ASSERT_ND(!header_.snapshot_);
    extract_separators_common(index, index_mini, separator_low, separator_high);
  }

Here is the call graph for this function:

uint8_t foedus::storage::masstree::MasstreeIntermediatePage::find_minipage ( KeySlice  slice ) const

inline

Navigates a searching key-slice to one of the mini pages in this page.

Definition at line 312 of file masstree_page_impl.hpp.

References ASSERT_ND, and foedus::storage::masstree::MasstreePage::get_key_count().

Referenced by foedus::storage::masstree::MasstreeStoragePimpl::fatify_first_root_double(), foedus::storage::masstree::MasstreeStoragePimpl::find_border_physical(), foedus::storage::masstree::MasstreeStoragePimpl::peek_volatile_page_boundaries_next_layer(), foedus::storage::masstree::MasstreeStoragePimpl::peek_volatile_page_boundaries_this_layer_recurse(), foedus::storage::masstree::Adopt::run(), and foedus::storage::masstree::MasstreeBorderPage::track_moved_record_next_layer().

                                                            {
    uint8_t key_count = get_key_count();
    ASSERT_ND(key_count <= kMaxIntermediateSeparators);
    for (uint8_t i = 0; i < key_count; ++i) {
      if (slice < separators_[i]) {
        return i;
      }
    }
    return key_count;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

MiniPage& foedus::storage::masstree::MasstreeIntermediatePage::get_minipage ( uint8_t  index )

inline

Definition at line 322 of file masstree_page_impl.hpp.

Referenced by foedus::storage::masstree::Adopt::adopt_case_a(), foedus::storage::masstree::Adopt::adopt_case_b(), append_minipage_snapshot(), foedus::storage::masstree::MasstreeComposer::construct_root(), foedus::storage::masstree::count_children_approximate(), foedus::storage::masstree::MasstreeComposer::drop_volatiles(), extract_separators_common(), foedus::storage::masstree::MasstreeStoragePimpl::fatify_first_root_double(), foedus::storage::masstree::MasstreeStoragePimpl::find_border_physical(), foedus::storage::masstree::MasstreeIntermediatePointerIterator::get_high_key(), foedus::storage::masstree::MasstreeIntermediatePointerIterator::get_low_key(), foedus::storage::masstree::MasstreeIntermediatePointerIterator::get_pointer(), foedus::storage::masstree::grow_case_b_common(), initialize_snapshot_page(), initialize_volatile_page(), foedus::storage::masstree::MasstreeIntermediatePointerIterator::is_valid(), foedus::storage::masstree::MasstreeStoragePimpl::load_empty(), foedus::storage::masstree::SplitIntermediate::migrate_pointers(), foedus::storage::masstree::MasstreeIntermediatePointerIterator::next(), foedus::storage::masstree::operator<<(), foedus::storage::masstree::MasstreeStoragePimpl::peek_volatile_page_boundaries_this_layer_recurse(), foedus::storage::masstree::MasstreeStoragePimpl::prefetch_pages_normalized_recurse(), release_pages_recursive(), release_pages_recursive_parallel(), foedus::storage::masstree::Adopt::run(), foedus::storage::masstree::MasstreeBorderPage::track_moved_record_next_layer(), verify_separators(), and foedus::storage::masstree::MasstreeStoragePimpl::verify_single_thread_intermediate().

{ return mini_pages_[index]; }

Here is the caller graph for this function:

const MiniPage& foedus::storage::masstree::MasstreeIntermediatePage::get_minipage ( uint8_t  index ) const

inline

Definition at line 323 of file masstree_page_impl.hpp.

{ return mini_pages_[index]; }

KeySlice foedus::storage::masstree::MasstreeIntermediatePage::get_separator ( uint8_t  index ) const

inline

Definition at line 324 of file masstree_page_impl.hpp.

Referenced by extract_separators_common(), foedus::storage::masstree::MasstreeIntermediatePointerIterator::get_high_key(), foedus::storage::masstree::MasstreeIntermediatePointerIterator::get_low_key(), foedus::storage::masstree::operator<<(), foedus::storage::masstree::MasstreeStoragePimpl::prefetch_pages_normalized_recurse(), and foedus::storage::masstree::MasstreeStoragePimpl::verify_single_thread_intermediate().

{ return separators_[index]; }

Here is the caller graph for this function:

void foedus::storage::masstree::MasstreeIntermediatePage::initialize_snapshot_page	(	StorageId	storage_id,
		SnapshotPagePointer	page_id,
		uint8_t	layer,
		uint8_t	level,
		KeySlice	low_fence,
		KeySlice	high_fence
	)

Definition at line 108 of file masstree_page_impl.cpp.

References get_minipage(), foedus::storage::masstree::MasstreePage::initialize_snapshot_common(), foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::key_count_, foedus::storage::kMasstreeIntermediatePageType, and foedus::storage::masstree::kMaxIntermediateSeparators.

                                  {
  initialize_snapshot_common(
    storage_id,
    page_id,
    kMasstreeIntermediatePageType,
    layer,
    level,
    low_fence,
    high_fence);
  for (uint16_t i = 0; i <= kMaxIntermediateSeparators; ++i) {
    get_minipage(i).key_count_ = 0;
  }
}

Here is the call graph for this function:

void foedus::storage::masstree::MasstreeIntermediatePage::initialize_volatile_page	(	StorageId	storage_id,
		VolatilePagePointer	page_id,
		uint8_t	layer,
		uint8_t	level,
		KeySlice	low_fence,
		KeySlice	high_fence
	)

Definition at line 88 of file masstree_page_impl.cpp.

References get_minipage(), foedus::storage::masstree::MasstreePage::initialize_volatile_common(), foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::key_count_, foedus::storage::kMasstreeIntermediatePageType, and foedus::storage::masstree::kMaxIntermediateSeparators.

Referenced by foedus::storage::masstree::grow_case_b_common(), foedus::storage::masstree::MasstreeStoragePimpl::load_empty(), and foedus::storage::masstree::SplitIntermediate::split_impl_no_error().

                                  {
  initialize_volatile_common(
    storage_id,
    page_id,
    kMasstreeIntermediatePageType,
    layer,
    level,
    low_fence,
    high_fence);
  for (uint16_t i = 0; i <= kMaxIntermediateSeparators; ++i) {
    get_minipage(i).key_count_ = 0;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::storage::masstree::MasstreeIntermediatePage::is_full_snapshot ( ) const

inline

Whether this page is full of poiters, used only by snapshot composer (or when no race)

Definition at line 1487 of file masstree_page_impl.hpp.

References ASSERT_ND, foedus::storage::masstree::MasstreePage::get_key_count(), foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::key_count_, and foedus::storage::masstree::kMaxIntermediateMiniSeparators.

Referenced by append_minipage_snapshot(), and append_pointer_snapshot().

                                                             {
  uint16_t keys = get_key_count();
  ASSERT_ND(keys <= kMaxIntermediateSeparators);
  const MiniPage& minipage = mini_pages_[keys];
  uint16_t keys_mini = minipage.key_count_;
  ASSERT_ND(keys_mini <= kMaxIntermediateMiniSeparators);
  return keys == kMaxIntermediateSeparators && keys_mini == kMaxIntermediateMiniSeparators;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MasstreeIntermediatePage& foedus::storage::masstree::MasstreeIntermediatePage::operator= ( const MasstreeIntermediatePage &  other )

delete

void foedus::storage::masstree::MasstreeIntermediatePage::prefetch ( ) const

inline

prefetch upto separators.

Definition at line 305 of file masstree_page_impl.hpp.

References foedus::assorted::prefetch_cachelines().

                        {
    assorted::prefetch_cachelines(this, 3);
  }

Here is the call graph for this function:

void foedus::storage::masstree::MasstreeIntermediatePage::release_pages_recursive	(	const memory::GlobalVolatilePageResolver &	page_resolver,
		memory::PageReleaseBatch *	batch
	)

Definition at line 226 of file masstree_page_impl.cpp.

References ASSERT_ND, foedus::storage::masstree::MasstreePage::foster_twin_, foedus::storage::masstree::MasstreePage::get_key_count(), get_minipage(), foedus::storage::masstree::MasstreePage::header(), foedus::storage::masstree::MasstreePage::header_, foedus::storage::masstree::MasstreePage::is_empty_range(), foedus::storage::PageVersion::is_moved(), foedus::storage::masstree::MasstreePage::is_moved(), foedus::storage::VolatilePagePointer::is_null(), foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::key_count_, foedus::storage::masstree::kMaxIntermediateMiniSeparators, foedus::storage::masstree::kMaxIntermediateSeparators, foedus::storage::PageHeader::page_id_, foedus::storage::PageHeader::page_version_, foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::pointers_, foedus::memory::PageReleaseBatch::release(), release_pages_recursive(), foedus::storage::masstree::MasstreePage::release_pages_recursive_common(), foedus::memory::GlobalVolatilePageResolver::resolve_offset(), foedus::storage::DualPagePointer::volatile_pointer_, and foedus::storage::VolatilePagePointer::word.

Referenced by release_pages_recursive(), and foedus::storage::masstree::MasstreePage::release_pages_recursive_common().

                                 {
  if (!is_empty_range()) {
    if (header_.page_version_.is_moved()) {
      for (int i = 0; i < 2; ++i) {
        ASSERT_ND(!foster_twin_[i].is_null());
        MasstreeIntermediatePage* p =
          reinterpret_cast<MasstreeIntermediatePage*>(
            page_resolver.resolve_offset(foster_twin_[i]));
        p->release_pages_recursive(page_resolver, batch);
        foster_twin_[i].word = 0;
      }
    } else {
      uint16_t key_count = get_key_count();
      ASSERT_ND(key_count <= kMaxIntermediateSeparators);
      for (uint8_t i = 0; i < key_count + 1; ++i) {
        MiniPage& minipage = get_minipage(i);
        uint16_t mini_count = minipage.key_count_;
        ASSERT_ND(mini_count <= kMaxIntermediateMiniSeparators);
        for (uint8_t j = 0; j < mini_count + 1; ++j) {
          VolatilePagePointer pointer = minipage.pointers_[j].volatile_pointer_;
          if (!pointer.is_null()) {
            MasstreePage* child = reinterpret_cast<MasstreePage*>(
              page_resolver.resolve_offset(pointer));
            child->release_pages_recursive_common(page_resolver, batch);
          }
        }
      }
    }
  } else {
    ASSERT_ND(!is_moved());
    ASSERT_ND(get_key_count() == 0);
  }

  VolatilePagePointer volatile_id;
  volatile_id.word = header().page_id_;
  batch->release(volatile_id);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::masstree::MasstreeIntermediatePage::release_pages_recursive_parallel

(

Engine *

engine

)

This method is used when we release a large number of volatile pages, most likely when we drop a storage.

In that case, we don't need to stick to the current thread. rather, this thread spawns lots of threads to parallelize the work.

Definition at line 188 of file masstree_page_impl.cpp.

References ASSERT_ND, foedus::storage::masstree::MasstreePage::foster_twin_, foedus::storage::masstree::MasstreePage::get_key_count(), foedus::Engine::get_memory_manager(), get_minipage(), foedus::memory::EngineMemory::get_node_memory(), foedus::storage::VolatilePagePointer::get_numa_node(), foedus::storage::VolatilePagePointer::get_offset(), foedus::storage::masstree::MasstreePage::header(), foedus::storage::masstree::MasstreePage::header_, foedus::storage::PageVersion::is_moved(), foedus::storage::VolatilePagePointer::is_null(), foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::key_count_, foedus::storage::masstree::kMaxIntermediateMiniSeparators, foedus::storage::masstree::kMaxIntermediateSeparators, foedus::storage::PageHeader::page_id_, foedus::storage::PageHeader::page_version_, foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::pointers_, foedus::memory::PagePool::release_one(), foedus::storage::masstree::release_parallel(), foedus::storage::DualPagePointer::volatile_pointer_, and foedus::storage::VolatilePagePointer::word.

Referenced by foedus::storage::masstree::MasstreeStoragePimpl::drop().

                                                                              {
  // so far, we spawn a thread for every single pointer.
  // it might be an oversubscription, but not a big issue.
  std::vector<std::thread> threads;
  if (header_.page_version_.is_moved()) {
    for (int i = 0; i < 2; ++i) {
      ASSERT_ND(!foster_twin_[i].is_null());
      threads.emplace_back(release_parallel, engine, foster_twin_[i]);
    }
    // if this page is moved, following pointers in this page results in double-release.
    // we just follow pointers in non-moved page.
  } else {
    uint16_t key_count = get_key_count();
    ASSERT_ND(key_count <= kMaxIntermediateSeparators);
    for (uint8_t i = 0; i < key_count + 1; ++i) {
      MiniPage& minipage = get_minipage(i);
      uint16_t mini_count = minipage.key_count_;
      ASSERT_ND(mini_count <= kMaxIntermediateMiniSeparators);
      for (uint8_t j = 0; j < mini_count + 1; ++j) {
        VolatilePagePointer pointer = minipage.pointers_[j].volatile_pointer_;
        if (!pointer.is_null()) {
          threads.emplace_back(release_parallel, engine, pointer);
        }
      }
    }
  }

  for (auto& t : threads) {
    t.join();
  }

  VolatilePagePointer volatile_id;
  volatile_id.word = header().page_id_;
  memory::PagePool* pool = engine->get_memory_manager()->get_node_memory(
    volatile_id.get_numa_node())->get_volatile_pool();
  pool->release_one(volatile_id.get_offset());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::storage::masstree::MasstreeIntermediatePage::set_separator ( uint8_t  minipage_index, KeySlice  new_separator  )

inline

Place a new separator for a new minipage.

Definition at line 397 of file masstree_page_impl.hpp.

Referenced by foedus::storage::masstree::Adopt::adopt_case_b().

                                                                     {
    separators_[minipage_index] = new_separator;
  }

Here is the caller graph for this function:

void foedus::storage::masstree::MasstreeIntermediatePage::verify_separators

(

)

const

Definition at line 475 of file masstree_page_impl.cpp.

References ASSERT_ND, foedus::storage::masstree::MasstreePage::get_key_count(), get_minipage(), foedus::storage::masstree::MasstreePage::high_fence_, foedus::storage::DualPagePointer::is_both_null(), foedus::storage::masstree::MasstreePage::is_empty_range(), foedus::storage::masstree::MasstreePage::is_moved(), foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::key_count_, foedus::storage::masstree::MasstreePage::low_fence_, foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::pointers_, and foedus::storage::masstree::MasstreeIntermediatePage::MiniPage::separators_.

Referenced by foedus::storage::masstree::SplitIntermediate::migrate_pointers(), foedus::storage::masstree::Adopt::run(), and foedus::storage::masstree::SplitIntermediate::split_impl_no_error().

                                                       {
#ifndef NDEBUG
  if (is_empty_range()) {
    ASSERT_ND(get_key_count() == 0);
    ASSERT_ND(!is_moved());
    return;
  }
  for (uint8_t i = 0; i <= get_key_count(); ++i) {
    KeySlice low, high;
    if (i < get_key_count()) {
      if (i > 0) {
        low = separators_[i - 1];
      } else {
        low = low_fence_;
      }
      high = separators_[i];
      ASSERT_ND(separators_[i] > low);
    } else {
      ASSERT_ND(i == get_key_count());
      if (i == 0) {
        low = low_fence_;
      } else {
        low = separators_[i - 1];
      }
      high = high_fence_;
    }
    const MiniPage& minipage = get_minipage(i);
    for (uint8_t j = 0; j <= minipage.key_count_; ++j) {
      ASSERT_ND(!minipage.pointers_[j].is_both_null());
      if (j < minipage.key_count_) {
        ASSERT_ND(minipage.separators_[j] > low);
        ASSERT_ND(minipage.separators_[j] < high);
      }
    }
  }
#endif  // NDEBUG
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

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

friend

defined in masstree_page_debug.cpp.

Definition at line 54 of file masstree_page_debug.cpp.

                                                                         {
  o << "<MasstreeIntermediatePage>";
  describe_masstree_page_common(&o, v);
  if (v.is_empty_range()) {
    o << "<EmptyRangePage />";
  } else {
    for (uint16_t i = 0; i <= v.get_key_count(); ++i) {
      const MasstreeIntermediatePage::MiniPage& minipage = v.get_minipage(i);
      KeySlice minipage_low = i == 0 ? v.get_low_fence() : v.get_separator(i - 1);
      o << std::endl << "  <Minipage index=\"" << static_cast<int>(i)
        << "\" low=\"" << assorted::Hex(minipage_low, 16)
        << "\" count=\"" << static_cast<int>(minipage.key_count_)
        << "\">";
      for (uint16_t j = 0; j <= minipage.key_count_; ++j) {
        o << std::endl << "    <Pointer index=\"" << static_cast<int>(j)
          << "\" low=\""
            << assorted::Hex(j == 0 ? minipage_low : minipage.separators_[j - 1], 16)
          << "\">" << minipage.pointers_[j] << "</Pointer>";
      }
      o << std::endl << "  </Minipage>";
    }
  }
  o << "</MasstreeIntermediatePage>";
  return o;
}

friend struct SplitIntermediate

friend

Definition at line 264 of file masstree_page_impl.hpp.

---

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

• /home/shino/foedus_code/foedus-core/include/foedus/storage/masstree/masstree_page_impl.hpp
• /home/shino/foedus_code/foedus-core/src/foedus/storage/masstree/masstree_page_impl.cpp