A system transaction to reserve a physical record(s) in a hash data page. More...

Detailed Description

A system transaction to reserve a physical record(s) in a hash data page.

See also: Physical-only, short-living system transactions.

A record insertion happens in two steps:

During Execution: Physically inserts a deleted record for the key in the data page.
During Commit: Logically flips the delete-bit and installs the payload.

This system transaction does the former.

This does nothing and returns kErrorCodeOk in the following cases:

The page turns out to already contain a satisfying physical record for the key.

In all other cases, this sysxct creates or finds the record. In other words, this sysxct guarantees a success as far as it returns kErrorCodeOk.

Locks taken in this sysxct (in order of taking):

Page-lock of the target or the tail page if target_ is not the tail (in the order of the chain, so no deadlock).
Record-lock of an existing, matching record. Only when we have to expand the record. This also happens after the page-lock of the enclosing page, before the page-lock of following pages, so every lock is in order.

Note, however, that it might not be in address order (address order might be tail -> head). We thus might have a false deadlock-abort. However, as far as the first lock on the target_ page is unconditional, all locks after that should be non-racy, so all try-lock should succeed. We might want to specify a bit larger max_retries (5?) for this reason.

Differences from Masstree's reserve

This sysxct is simpler than masstree::ReserveRecords for a few reasons.

No need to split the page
No need to adopt a split page

We thus contain all required logics (reserve/expansion/migrate) in this sysxct. In all circumstances, this sysxct finds or reserves the required record. Simpler for the caller.

So far this sysxct installs only one physical record at a time. TASK(Hideaki): Probably it helps by batching several records.

Definition at line 73 of file hash_reserve_impl.hpp.

#include <hash_reserve_impl.hpp>

Inheritance diagram for foedus::storage::hash::ReserveRecords:

[legend]

Collaboration diagram for foedus::storage::hash::ReserveRecords:

[legend]

Public Member Functions
	ReserveRecords (thread::Thread context, HashDataPage target, const void *key, KeyLength key_length, const HashCombo &combo, PayloadLength payload_count, PayloadLength aggressive_payload_count_hint, DataPageSlotIndex hint_check_from)

virtual ErrorCode	run (xct::SysxctWorkspace *sysxct_workspace) override
	Execute the system transaction. More...

ErrorCode	find_or_create_or_expand (xct::SysxctWorkspace sysxct_workspace, HashDataPage page, DataPageSlotIndex examined_records)
	The main loop (well, recursion actually). More...

ErrorCode	expand_record (xct::SysxctWorkspace sysxct_workspace, HashDataPage page, DataPageSlotIndex index)

ErrorCode	find_and_lock_spacious_tail (xct::SysxctWorkspace sysxct_workspace, HashDataPage from_page, HashDataPage **tail)

ErrorCode	create_new_record_in_tail_page (HashDataPage *tail)
	Installs it as a fresh-new physical record, assuming the given page is the tail and already locked. More...

ErrorCode	create_new_tail_page (HashDataPage cur_tail, HashDataPage *new_tail)

DataPageSlotIndex	search_within_page (const HashDataPage *page, DataPageSlotIndex key_count, DataPageSlotIndex examined_records) const

DataPageSlotIndex	append_record_to_page (HashDataPage *page, xct::XctId initial_xid) const
	Appends a new physical record to the page. More...

Public Attributes
thread::Thread *const	context_
	Thread context. More...

HashDataPage *const	target_
	The data page to install a new physical record. More...

const void *const	key_
	The key of the new record. More...

const HashCombo &	combo_
	Hash info of the key. More...

const KeyLength	key_length_
	Byte length of the key. More...

const PayloadLength	payload_count_
	Minimal required length of the payload. More...

const PayloadLength	aggressive_payload_count_hint_
	When we expand the record or allocate a new record, we might allocate a larger-than-necessary space guided by this hint. More...

const DataPageSlotIndex	hint_check_from_
	The in-page location from which this sysxct will look for matching records. More...

DataPageSlotIndex	out_slot_
	[Out] The slot of the record that is found or created. More...

HashDataPage *	out_page_
	[Out] The page that contains the found/created record. More...

Constructor & Destructor Documentation

foedus::storage::hash::ReserveRecords::ReserveRecords	(	thread::Thread *	context,
		HashDataPage *	target,
		const void *	key,
		KeyLength	key_length,
		const HashCombo &	combo,
		PayloadLength	payload_count,
		PayloadLength	aggressive_payload_count_hint,
		DataPageSlotIndex	hint_check_from
	)

inline

Definition at line 142 of file hash_reserve_impl.hpp.

     : xct::SysxctFunctor(),
       context_(context),
       target_(target),
       key_(key),
       combo_(combo),
       key_length_(key_length),
       payload_count_(payload_count),
       aggressive_payload_count_hint_(aggressive_payload_count_hint),
       hint_check_from_(hint_check_from),
       out_slot_(kSlotNotFound),
       out_page_(nullptr) {
   }

Member Function Documentation

DataPageSlotIndex foedus::storage::hash::ReserveRecords::append_record_to_page	(	HashDataPage *	page,
		xct::XctId	initial_xid
	)		const

Appends a new physical record to the page.

The caller must make sure there is no race in the page. In other words, the page must be either locked or a not-yet-published page.

Definition at line 261 of file hash_reserve_impl.cpp.

Referenced by create_new_record_in_tail_page(), and expand_record().

                               {
   ASSERT_ND(page->available_space()
     >= HashDataPage::required_space(key_length_, aggressive_payload_count_hint_));
   DataPageSlotIndex index = page->get_record_count();
   auto& slot = page->get_new_slot(index);
   slot.offset_ = page->next_offset();
   slot.hash_ = combo_.hash_;
   slot.key_length_ = key_length_;
   slot.physical_record_length_ = assorted::align8(key_length_) + assorted::align8(payload_count_);
   slot.payload_length_ = 0;
   char* record = page->record_from_offset(slot.offset_);
   std::memcpy(record, key_, key_length_);
   if (key_length_ % 8 != 0) {
     std::memset(record + key_length_, 0, 8 - (key_length_ % 8));
   }
   slot.tid_.reset();
   slot.tid_.xct_id_ = initial_xid;
 
   // we install the fingerprint to bloom filter BEFORE we increment key count.
   // it's okay for concurrent reads to see false positives, but false negatives are wrong!
   page->bloom_filter_.add(combo_.fingerprint_);
 
   // we increment key count AFTER installing the key because otherwise the optimistic read
   // might see the record but find that the key doesn't match. we need a fence to prevent it.
   assorted::memory_fence_release();
   page->header_.increment_key_count();
   return index;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::ReserveRecords::create_new_record_in_tail_page ( HashDataPage * tail )

Installs it as a fresh-new physical record, assuming the given page is the tail and already locked.

Definition at line 208 of file hash_reserve_impl.cpp.

References aggressive_payload_count_hint_, append_record_to_page(), ASSERT_ND, foedus::storage::hash::HashDataPage::available_space(), CHECK_ERROR_CODE, create_new_tail_page(), foedus::storage::hash::HashDataPage::get_volatile_page_id(), foedus::storage::hash::HashDataPage::header(), foedus::storage::hash::HashDataPage::is_locked(), foedus::storage::VolatilePagePointer::is_null(), foedus::Epoch::kEpochInitialCurrent, foedus::kErrorCodeOk, key_length_, foedus::assorted::memory_fence_release(), foedus::storage::hash::HashDataPage::next_page(), out_page_, out_slot_, foedus::storage::PageHeader::page_version_, foedus::storage::hash::HashDataPage::required_space(), foedus::xct::XctId::set(), foedus::xct::XctId::set_deleted(), foedus::storage::PageVersion::set_has_next_page(), and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by find_or_create_or_expand().

                                                                            {
   ASSERT_ND(tail->is_locked());
   ASSERT_ND(tail->next_page().volatile_pointer_.is_null());
 
   // do we have enough room in this page?
   const uint16_t available_space = tail->available_space();
   const uint16_t required_space
     = HashDataPage::required_space(key_length_, aggressive_payload_count_hint_);
   xct::XctId initial_xid;
   initial_xid.set(
     Epoch::kEpochInitialCurrent,  // TODO(Hideaki) this should be something else
     0);
   initial_xid.set_deleted();
   if (available_space < required_space) {
     // This page can't hold it. Let's make a new page.
     HashDataPage* new_tail;
     CHECK_ERROR_CODE(create_new_tail_page(tail, &new_tail));
 
     // Then append a record to it.
     out_slot_ = append_record_to_page(new_tail, initial_xid);
     ASSERT_ND(out_slot_ == 0);  // it's the first record in the new page
     out_page_ = new_tail;
     // Then, after all, we "publish" this new page
     assorted::memory_fence_release();  // so that others don't see uninitialized page
     tail->next_page().volatile_pointer_ = new_tail->get_volatile_page_id();
     assorted::memory_fence_release();  // so that others don't have "where's the next page" issue
     tail->header().page_version_.set_has_next_page();
   } else {
     // the page is enough spacious, and has no next page. we rule!
     out_slot_ = append_record_to_page(tail, initial_xid);
     out_page_ = tail;
   }
 
   return kErrorCodeOk;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::ReserveRecords::create_new_tail_page	(	HashDataPage *	cur_tail,
		HashDataPage **	new_tail
	)

Definition at line 187 of file hash_reserve_impl.cpp.

References ASSERT_ND, context_, foedus::storage::hash::HashDataPage::get_bin(), foedus::storage::hash::HashDataPage::get_bin_shifts(), foedus::storage::VolatilePagePointer::get_offset(), foedus::thread::Thread::get_thread_memory(), foedus::memory::NumaCoreMemory::grab_free_volatile_page_pointer(), foedus::storage::hash::HashDataPage::header(), foedus::storage::hash::HashDataPage::initialize_volatile_page(), foedus::storage::hash::HashDataPage::is_locked(), foedus::storage::VolatilePagePointer::is_null(), foedus::kErrorCodeMemoryNoFreePages, foedus::kErrorCodeOk, foedus::thread::Thread::resolve_newpage_cast(), foedus::storage::PageHeader::storage_id_, and UNLIKELY.

Referenced by create_new_record_in_tail_page(), and find_and_lock_spacious_tail().

                            {
   ASSERT_ND(cur_tail->is_locked());
   DVLOG(2) << "Volatile HashDataPage is full. Adding a next page..";
   const VolatilePagePointer new_pointer
     = context_->get_thread_memory()->grab_free_volatile_page_pointer();
   if (UNLIKELY(new_pointer.is_null())) {
     return kErrorCodeMemoryNoFreePages;
   }
 
   *new_tail = context_->resolve_newpage_cast<HashDataPage>(new_pointer.get_offset());
   (*new_tail)->initialize_volatile_page(
     cur_tail->header().storage_id_,
     new_pointer,
     reinterpret_cast<Page*>(cur_tail),
     cur_tail->get_bin(),
     cur_tail->get_bin_shifts());
   return kErrorCodeOk;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::ReserveRecords::expand_record	(	xct::SysxctWorkspace *	sysxct_workspace,
		HashDataPage *	page,
		DataPageSlotIndex	index
	)

Definition at line 101 of file hash_reserve_impl.cpp.

References aggressive_payload_count_hint_, append_record_to_page(), ASSERT_ND, foedus::storage::hash::HashDataPage::available_space(), CHECK_ERROR_CODE, context_, find_and_lock_spacious_tail(), foedus::storage::hash::HashDataPage::get_slot(), foedus::storage::hash::HashDataPage::get_volatile_page_id(), foedus::storage::hash::HashDataPage::is_locked(), foedus::kErrorCodeOk, foedus::kErrorCodeXctRaceAbort, key_length_, foedus::assorted::memory_fence_release(), out_page_, out_slot_, foedus::storage::hash::HashDataPage::required_space(), foedus::thread::Thread::sysxct_record_lock(), and foedus::storage::hash::HashDataPage::Slot::tid_.

Referenced by find_or_create_or_expand().

                            {
   auto* record = &page->get_slot(index).tid_;
   CHECK_ERROR_CODE(context_->sysxct_record_lock(
     sysxct_workspace,
     page->get_volatile_page_id(),
     record));
   // After locking, now the record status is finalized.
   if (record->is_moved()) {
     // If we now find it moved, we have two choices.
     //  1) resume the search. the new location should be somewhere after here.
     //  2) retry the whole sysxct.
     // We do 2) to save coding (yikes!). Excuse: This case should be rare.
     LOG(INFO) << "Rare. The record turns out to be moved after locking. Retry the sysxct";
     return kErrorCodeXctRaceAbort;
   }
 
   // Now, because we locked a record of the key, and because it wasn't moved yet,
   // we are sure that this is the only record in this hash bucket that might contain this key.
   // We'll be done as soon as we figure out where to move this record.
   HashDataPage* tail;
   CHECK_ERROR_CODE(find_and_lock_spacious_tail(sysxct_workspace, page, &tail));
   ASSERT_ND(tail->is_locked());
   ASSERT_ND(tail->available_space()
     >= HashDataPage::required_space(key_length_, aggressive_payload_count_hint_));
 
   // Copy the XID of the existing record
   out_slot_ = append_record_to_page(tail, record->xct_id_);
   out_page_ = tail;
 
   // Now we mark the old record as moved
   assorted::memory_fence_release();
   record->xct_id_.set_moved();
   return kErrorCodeOk;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::ReserveRecords::find_and_lock_spacious_tail	(	xct::SysxctWorkspace *	sysxct_workspace,
		HashDataPage *	from_page,
		HashDataPage **	tail
	)

Definition at line 139 of file hash_reserve_impl.cpp.

References aggressive_payload_count_hint_, foedus::storage::hash::HashDataPage::available_space(), CHECK_ERROR_CODE, context_, create_new_tail_page(), foedus::storage::hash::HashDataPage::get_volatile_page_id(), foedus::storage::hash::HashDataPage::header(), foedus::storage::VolatilePagePointer::is_null(), foedus::kErrorCodeOk, key_length_, foedus::assorted::memory_fence_release(), foedus::storage::hash::HashDataPage::next_page(), foedus::storage::PageHeader::page_version_, foedus::storage::hash::HashDataPage::required_space(), foedus::thread::Thread::resolve_cast(), foedus::storage::PageVersion::set_has_next_page(), foedus::thread::Thread::sysxct_page_lock(), and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by expand_record().

                        {
   *tail = nullptr;
   HashDataPage* cur = from_page;
   while (true) {
     VolatilePagePointer next_pointer = cur->next_page().volatile_pointer_;
     if (!next_pointer.is_null()) {
       cur = context_->resolve_cast<HashDataPage>(next_pointer);
       continue;
     }
     // cur looks like a tail page, but we need to confirm that after locking.
     CHECK_ERROR_CODE(context_->sysxct_page_lock(sysxct_workspace, reinterpret_cast<Page*>(cur)));
     if (!cur->next_page().volatile_pointer_.is_null()) {
       LOG(INFO) << "Rare. Someone has just made a next page";
       continue;
     }
 
     const uint16_t available_space = cur->available_space();
     const uint16_t required_space
       = HashDataPage::required_space(key_length_, aggressive_payload_count_hint_);
     if (available_space >= required_space) {
       *tail = cur;
       return kErrorCodeOk;
     } else {
       // need to make a new page..
       HashDataPage* new_tail;
       CHECK_ERROR_CODE(create_new_tail_page(cur, &new_tail));
 
       // Then, after all, we "publish" this new page
       assorted::memory_fence_release();  // so that others don't see uninitialized page
       cur->next_page().volatile_pointer_ = new_tail->get_volatile_page_id();
       assorted::memory_fence_release();  // so that others don't have "where's the next page" issue
       cur->header().page_version_.set_has_next_page();
 
       // We could immediately make a record in this page before the publish above.
       // If we do that we could avoid lock here. But the code becomes a bit uglier.
       // record-expand is anyway a costly operation, so ok for now.
       CHECK_ERROR_CODE(context_->sysxct_page_lock(
         sysxct_workspace,
         reinterpret_cast<Page*>(new_tail)));
       *tail = new_tail;
       return kErrorCodeOk;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::ReserveRecords::find_or_create_or_expand	(	xct::SysxctWorkspace *	sysxct_workspace,
		HashDataPage *	page,
		DataPageSlotIndex	examined_records
	)

The main loop (well, recursion actually).

Definition at line 36 of file hash_reserve_impl.cpp.

References ASSERT_ND, CHECK_ERROR_CODE, context_, create_new_record_in_tail_page(), expand_record(), foedus::storage::hash::HashDataPage::Slot::get_max_payload(), foedus::storage::hash::HashDataPage::get_record_count(), foedus::storage::hash::HashDataPage::get_slot(), foedus::storage::hash::HashDataPage::header(), foedus::storage::hash::HashDataPage::is_locked(), foedus::kErrorCodeOk, foedus::storage::hash::kSlotNotFound, foedus::assorted::memory_fence_acquire(), foedus::storage::hash::HashDataPage::next_page(), out_page_, out_slot_, payload_count_, foedus::thread::Thread::resolve_cast(), search_within_page(), foedus::storage::PageHeader::snapshot_, foedus::thread::Thread::sysxct_page_lock(), target_, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by run().

                                       {
   ASSERT_ND(!page->header().snapshot_);
   // lock the page first so that there is no race on new keys.
   VolatilePagePointer next_pointer = page->next_page().volatile_pointer_;
   if (next_pointer.is_null()) {
     CHECK_ERROR_CODE(context_->sysxct_page_lock(sysxct_workspace, reinterpret_cast<Page*>(page)));
     next_pointer = page->next_page().volatile_pointer_;
   } else {
     // If the page already has a next-page pointer, the page is already finalized. Skip locking.
     assorted::memory_fence_acquire();  // must check next-page BEFORE everything else
   }
   // In either case, from now on this page is finalized
   ASSERT_ND(page->is_locked() || !next_pointer.is_null());
   const DataPageSlotIndex count = target_->get_record_count();
   ASSERT_ND(examined_records <= count);
 
   // Locate the key in this page.
   DataPageSlotIndex index;
   if (examined_records == count) {
 #ifndef NDEBUG
     // is examined_records correct? let's confirm
     index = search_within_page(page, examined_records, 0);
     ASSERT_ND(index == kSlotNotFound);
 #endif  // NDEBUG
     index = kSlotNotFound;
   } else {
     // We can skip the first examined_records records.
     // We took the page lock, so physical-only search is enough.
     index = search_within_page(page, count, examined_records);
   }
 
   if (index == kSlotNotFound) {
     // still no match, This is simpler.
     if (!next_pointer.is_null()) {
       // We have a next page, let's go on.
       // This is so far a recursion. Easier to debug than a loop.
       // Stackoverflow? If you have a long chain in hash bucket, you are already screwed
       HashDataPage* next_page = context_->resolve_cast<HashDataPage>(next_pointer);
       return find_or_create_or_expand(sysxct_workspace, next_page, 0);
     } else {
       // This is the tail page. and we locked it.
       // We simply create a new physical record.
       ASSERT_ND(page->is_locked());
       return create_new_record_in_tail_page(page);
     }
   } else {
     // We found a match! This is either super easy or complex
     ASSERT_ND(index >= examined_records);
     ASSERT_ND(index < count);
     if (page->get_slot(index).get_max_payload() >= payload_count_) {
       // This record is enough spacious. we are done! a super easy case.
       out_slot_ = index;
       out_page_ = page;
       return kErrorCodeOk;
     } else {
       // We need to expand this record. To do that, we need to lock this record and move it.
       // This can be complex.
       return expand_record(sysxct_workspace, page, index);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::storage::hash::ReserveRecords::run ( xct::SysxctWorkspace * sysxct_workspace )

overridevirtual

Execute the system transaction.

You should override this method.

Implements foedus::xct::SysxctFunctor.

Definition at line 31 of file hash_reserve_impl.cpp.

References aggressive_payload_count_hint_, ASSERT_ND, find_or_create_or_expand(), hint_check_from_, payload_count_, and target_.

                                                                   {
   ASSERT_ND(aggressive_payload_count_hint_ >= payload_count_);
   return find_or_create_or_expand(sysxct_workspace, target_, hint_check_from_);
 }

Here is the call graph for this function:

DataPageSlotIndex foedus::storage::hash::ReserveRecords::search_within_page	(	const HashDataPage *	page,
		DataPageSlotIndex	key_count,
		DataPageSlotIndex	examined_records
	)		const

Definition at line 244 of file hash_reserve_impl.cpp.

References ASSERT_ND, combo_, foedus::storage::hash::HashCombo::fingerprint_, foedus::storage::hash::HashDataPage::get_record_count(), foedus::storage::hash::HashCombo::hash_, foedus::storage::hash::HashDataPage::header(), foedus::storage::PageVersion::is_locked(), foedus::storage::VolatilePagePointer::is_null(), key_, key_length_, foedus::storage::hash::HashDataPage::next_page(), foedus::storage::PageHeader::page_version_, foedus::storage::hash::HashDataPage::search_key_physical(), foedus::storage::PageHeader::snapshot_, and foedus::storage::DualPagePointer::volatile_pointer_.

Referenced by find_or_create_or_expand().

                                             {
   ASSERT_ND(!page->header().snapshot_);
   ASSERT_ND(page->header().page_version_.is_locked()
     || !page->next_page().volatile_pointer_.is_null());
   ASSERT_ND(key_count == page->get_record_count());
   return page->search_key_physical(
     combo_.hash_,
     combo_.fingerprint_,
     key_,
     key_length_,
     key_count,
     examined_records);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

const PayloadLength foedus::storage::hash::ReserveRecords::aggressive_payload_count_hint_

When we expand the record or allocate a new record, we might allocate a larger-than-necessary space guided by this hint.

It's useful to avoid future record expansion.

Precondition: aggressive_payload_count_hint_ >= payload_count_

Definition at line 113 of file hash_reserve_impl.hpp.

Referenced by append_record_to_page(), create_new_record_in_tail_page(), expand_record(), find_and_lock_spacious_tail(), and run().

const HashCombo& foedus::storage::hash::ReserveRecords::combo_

Hash info of the key.

It's &, so lifetime of the caller's HashCombo object must be longer than this sysxct.

Definition at line 102 of file hash_reserve_impl.hpp.

Referenced by append_record_to_page(), and search_within_page().

thread::Thread* const foedus::storage::hash::ReserveRecords::context_

Thread context.

Definition at line 75 of file hash_reserve_impl.hpp.

Referenced by create_new_tail_page(), expand_record(), find_and_lock_spacious_tail(), and find_or_create_or_expand().

const DataPageSlotIndex foedus::storage::hash::ReserveRecords::hint_check_from_

The in-page location from which this sysxct will look for matching records.

The caller is sure that no record before this position can match the slice. Thanks to append-only writes in data pages, the caller can guarantee that the records it observed are final.

In most cases, this is same as key_count after locking, thus completely avoiding the re-check. In some cases, the caller already found a matching key in this index, but even in that case this sysxct must re-search after locking because the record might be now moved.

Definition at line 124 of file hash_reserve_impl.hpp.

Referenced by run().

const void* const foedus::storage::hash::ReserveRecords::key_

The key of the new record.

Definition at line 97 of file hash_reserve_impl.hpp.

Referenced by append_record_to_page(), and search_within_page().

const KeyLength foedus::storage::hash::ReserveRecords::key_length_

Byte length of the key.

Definition at line 104 of file hash_reserve_impl.hpp.

Referenced by append_record_to_page(), create_new_record_in_tail_page(), expand_record(), find_and_lock_spacious_tail(), and search_within_page().

HashDataPage* foedus::storage::hash::ReserveRecords::out_page_

[Out] The page that contains the found/created record.

As far as this sysxct returns kErrorCodeOk, out_page_ is either the target_ itself or some page after target_.

Postcondition: out_page_ != nullptr

Definition at line 140 of file hash_reserve_impl.hpp.

Referenced by create_new_record_in_tail_page(), expand_record(), find_or_create_or_expand(), and foedus::storage::hash::HashStoragePimpl::locate_record_reserve_physical().

DataPageSlotIndex foedus::storage::hash::ReserveRecords::out_slot_

[Out] The slot of the record that is found or created.

As far as this sysxct returns kErrorCodeOk, this guarantees the following.

Postcondition: out_slot_ != kSlotNotFound; out_page_'s out_slot_ is at least at some point a valid non-moved record of the given key with satisfying max-payload length.

Definition at line 133 of file hash_reserve_impl.hpp.

Referenced by create_new_record_in_tail_page(), expand_record(), find_or_create_or_expand(), and foedus::storage::hash::HashStoragePimpl::locate_record_reserve_physical().

const PayloadLength foedus::storage::hash::ReserveRecords::payload_count_

Minimal required length of the payload.

Definition at line 106 of file hash_reserve_impl.hpp.

Referenced by append_record_to_page(), find_or_create_or_expand(), and run().

HashDataPage* const foedus::storage::hash::ReserveRecords::target_

The data page to install a new physical record.

This might NOT be the head page of the hash bin. The contract here is that the caller must be sure that any pages before this page in the chain must not contain a record of the given key that is not marked as moved. In other words, the caller must have checked that there is no such record before hint_check_from_ of target_.

Example 1: the caller found an existing record in target_ that is not moved. hint_check_from_ < target_->get_key_count(), and target_ might not be the tail of the bin.
Example 2: the caller found no existing non-moved record. hint_check_from_ == target_->get_key_count(), and target_ is the tail of the bin.

Of course, by the time this sysxct takes a lock, other threads might insert more records, some of which might have the key. This sysxct thus needs to resume search from target_ and hint_check_from_ (but, not anywhere before!).

Definition at line 95 of file hash_reserve_impl.hpp.

Referenced by find_or_create_or_expand(), and run().

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

/home/shino/foedus_code/foedus-core/include/foedus/storage/hash/hash_reserve_impl.hpp
/home/shino/foedus_code/foedus-core/src/foedus/storage/hash/hash_reserve_impl.cpp

Detailed Description

Public Member Functions

Public Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation