foedus::storage::masstree::GrowFirstLayerRoot Struct Reference

A system transaction to grow a first-layer root. More...

Detailed Description

A system transaction to grow a first-layer root.

See also

Physical-only, short-living system transactions.

The root page of a first-layer in masstree is a bit special. We thus have a separate sysxct.

This does nothing and returns kErrorCodeOk in the following cases:

• The special lock in control block seems contended.
• The first-layer root turns out to be not moved (already grown).

Grow is a non-mandatory operation. We can delay it.

Locks taken in this sysxct:

• A special lock that protects first-layer root pointer in control block.
• Page-lock of the current first-layer root (will be retired).

Definition at line 49 of file masstree_grow_impl.hpp.

#include <masstree_grow_impl.hpp>

Inheritance diagram for foedus::storage::masstree::GrowFirstLayerRoot:

Collaboration diagram for foedus::storage::masstree::GrowFirstLayerRoot:

Public Member Functions
	GrowFirstLayerRoot (thread::Thread *context, StorageId storage_id)
virtual ErrorCode	run (xct::SysxctWorkspace *sysxct_workspace) override
	Execute the system transaction. More...

Public Attributes
thread::Thread *const	context_
	Thread context. More...
StorageId	storage_id_
	ID of the masstree storage to grow. More...

Constructor & Destructor Documentation

foedus::storage::masstree::GrowFirstLayerRoot::GrowFirstLayerRoot ( thread::Thread *  context, StorageId  storage_id  )

inline

Definition at line 55 of file masstree_grow_impl.hpp.

    : xct::SysxctFunctor(),
      context_(context),
      storage_id_(storage_id) {
  }

Member Function Documentation

ErrorCode foedus::storage::masstree::GrowFirstLayerRoot::run ( xct::SysxctWorkspace *  sysxct_workspace )

overridevirtual

Execute the system transaction.

You should override this method.

Implements foedus::xct::SysxctFunctor.

Definition at line 119 of file masstree_grow_impl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, context_, foedus::Attachable< CONTROL_BLOCK >::get_control_block(), foedus::thread::Thread::get_engine(), foedus::storage::masstree::MasstreePage::get_foster_fence(), foedus::thread::Thread::get_global_volatile_page_resolver(), foedus::storage::masstree::MasstreePage::get_high_fence(), foedus::storage::masstree::MasstreePage::get_layer(), foedus::storage::masstree::MasstreePage::get_low_fence(), foedus::storage::masstree::grow_case_a_common(), foedus::storage::masstree::grow_case_b_common(), foedus::storage::masstree::MasstreePage::is_layer_root(), foedus::storage::masstree::MasstreePage::is_locked(), foedus::assorted::DumbSpinlock::is_locked_by_me(), foedus::storage::masstree::MasstreePage::is_moved(), foedus::storage::VolatilePagePointer::is_null(), foedus::storage::masstree::MasstreePage::is_retired(), foedus::kErrorCodeOk, storage_id_, foedus::thread::Thread::sysxct_page_lock(), foedus::assorted::DumbSpinlock::try_lock(), and foedus::storage::DualPagePointer::volatile_pointer_.

                                                                      {
  MasstreeStorage storage(context_->get_engine(), storage_id_);
  auto* cb = storage.get_control_block();

  // Take the special lock in control block.
  // This locking happens outside of the normal lock/commit protocol.
  // In order to avoid contention, we take the lock only when it looks available.
  if (cb->first_root_locked_) {
    DVLOG(0) << "Interesting. other thread seems growing the first-layer. let him do that";
    return kErrorCodeOk;
  }
  // Always a try-lock to avoid deadlock. Remember, this is a special lock!
  assorted::DumbSpinlock first_root_lock(&cb->first_root_locked_, false);
  if (!first_root_lock.try_lock()) {
    DVLOG(0) << "Interesting. other thread is growing the first-layer. let him do that";
    return kErrorCodeOk;
  }
  ASSERT_ND(first_root_lock.is_locked_by_me());

  const auto& resolver = context_->get_global_volatile_page_resolver();
  DualPagePointer* pointer = &cb->root_page_pointer_;
  ASSERT_ND(!pointer->volatile_pointer_.is_null());
  Page* cur_root_page = resolver.resolve_offset(pointer->volatile_pointer_);
  MasstreePage* cur_root = reinterpret_cast<MasstreePage*>(cur_root_page);
  ASSERT_ND(cur_root->is_layer_root());
  ASSERT_ND(cur_root->get_layer() == 0);

  CHECK_ERROR_CODE(context_->sysxct_page_lock(sysxct_workspace, cur_root_page));
  ASSERT_ND(cur_root->is_locked());
  // After locking the page, check the state of the page
  if (!cur_root->is_moved()) {
    DVLOG(0) << "Interesting. concurrent thread has already grown it.";
    return kErrorCodeOk;
  }

  ASSERT_ND(!cur_root->is_retired());
  if (cur_root->get_foster_fence() == cur_root->get_low_fence()
    || cur_root->get_foster_fence() == cur_root->get_high_fence()) {
    DVLOG(0) << "Adopting Empty-range child for first layer root. storage_id=" << storage_id_;
    grow_case_a_common(context_, pointer, cur_root);
  } else {
    LOG(INFO) << "Growing first layer root. storage_id=" << storage_id_;
    CHECK_ERROR_CODE(grow_case_b_common(context_, pointer, cur_root));
  }

  return kErrorCodeOk;
}

Here is the call graph for this function:

Member Data Documentation

thread::Thread* const foedus::storage::masstree::GrowFirstLayerRoot::context_

Thread context.

Definition at line 51 of file masstree_grow_impl.hpp.

Referenced by run().

StorageId foedus::storage::masstree::GrowFirstLayerRoot::storage_id_

ID of the masstree storage to grow.

Definition at line 53 of file masstree_grow_impl.hpp.

Referenced by run().

---

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

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