An iterator over CurrentLockList to find entries along with sorted write-set. More...

Detailed Description

An iterator over CurrentLockList to find entries along with sorted write-set.

This is used from precommit_xct_lock() to iterate over CurrentLockList. Separated as an iterator object by itself for readability and testability.

Note: This object itself is thread-private. No concurrency control needed.

Definition at line 243 of file xct_manager_pimpl.hpp.

#include <xct_manager_pimpl.hpp>

Collaboration diagram for foedus::xct::CurrentLockListIteratorForWriteSet:

[legend]

Public Member Functions
	CurrentLockListIteratorForWriteSet (const WriteXctAccess write_set, const CurrentLockList cll, uint32_t write_set_size)

void	next_writes ()
	Look for next record's write-set(s). More...

bool	is_valid () const

Public Attributes
const WriteXctAccess *const	write_set_

const CurrentLockList *const	cll_

const uint32_t	write_set_size_

uint32_t	write_cur_pos_
	inclusive beginning of write-sets of the current record in write-set. More...

uint32_t	write_next_pos_
	exclusive end of write-sets of the current record in write-set. More...

LockListPosition	cll_pos_
	CLL entry that corresponds to the current record in write-set. More...

Constructor & Destructor Documentation

foedus::xct::CurrentLockListIteratorForWriteSet::CurrentLockListIteratorForWriteSet	(	const WriteXctAccess *	write_set,
		const CurrentLockList *	cll,
		uint32_t	write_set_size
	)

inline

Precondition: write_set must be sorted and CLL must contain all entries for write-sets. In other words, you must call precommit_xct_sort_access() and batch_insert_write_placeholders() beforehand.

Definition at line 277 of file xct_manager_pimpl.hpp.

References foedus::xct::CurrentLockList::assert_sorted(), cll_, cll_pos_, foedus::xct::kLockListPositionInvalid, next_writes(), write_cur_pos_, and write_next_pos_.

   : write_set_(write_set),
   cll_(cll),
   write_set_size_(write_set_size)  {
   write_cur_pos_ = 0;
   write_next_pos_ = 0;
   cll_pos_ = kLockListPositionInvalid;
   cll_->assert_sorted();
 
   next_writes();  // set to initial record.
 }

Here is the call graph for this function:

Member Function Documentation

bool foedus::xct::CurrentLockListIteratorForWriteSet::is_valid ( ) const

inline

Definition at line 259 of file xct_manager_pimpl.hpp.

References write_cur_pos_, and write_next_pos_.

Referenced by foedus::xct::XctManagerPimpl::precommit_xct_lock().

259 { return write_cur_pos_ < write_next_pos_; }

foedus::xct::CurrentLockListIteratorForWriteSet::write_next_pos_

uint32_t write_next_pos_

exclusive end of write-sets of the current record in write-set.

Definition: xct_manager_pimpl.hpp:272

foedus::xct::CurrentLockListIteratorForWriteSet::write_cur_pos_

uint32_t write_cur_pos_

inclusive beginning of write-sets of the current record in write-set.

Definition: xct_manager_pimpl.hpp:268

Here is the caller graph for this function:

void foedus::xct::CurrentLockListIteratorForWriteSet::next_writes ( )

inline

Look for next record's write-set(s).

Precondition: is_valid(). otherwise undefined behavior

Definition at line 292 of file xct_manager_pimpl.hpp.

References ASSERT_ND, cll_, cll_pos_, foedus::xct::CurrentLockList::get_entry(), foedus::xct::RecordXctAccess::owner_lock_id_, foedus::xct::LockEntry::universal_lock_id_, write_cur_pos_, write_next_pos_, write_set_, and write_set_size_.

Referenced by CurrentLockListIteratorForWriteSet().

                                                             {
   write_cur_pos_ = write_next_pos_;
   ++cll_pos_;
   if (write_cur_pos_ >= write_set_size_) {
     return;
   }
   const WriteXctAccess* write = write_set_ + write_cur_pos_;
   const UniversalLockId write_id = write->owner_lock_id_;
 
   // CLL must contain all entries in write-set. We are reading in-order.
   // So, we must find a valid CLL entry that is == write_id
   const LockEntry* l = cll_->get_entry(cll_pos_);
   while (l->universal_lock_id_ < write_id) {
     ASSERT_ND(cll_pos_ < cll_->get_last_active_entry());
     ++cll_pos_;
     l = cll_->get_entry(cll_pos_);
   }
 
   ASSERT_ND(l->universal_lock_id_ == write_id);
   ASSERT_ND(write_next_pos_ < write_set_size_);
   while (true) {
     ++write_next_pos_;
     if (write_next_pos_ == write_set_size_) {
       break;
     }
     const WriteXctAccess* next_write = write_set_ + write_next_pos_;
     const UniversalLockId next_write_id = next_write->owner_lock_id_;
     ASSERT_ND(write_id <= next_write_id);
     if (write_id < next_write_id) {
       break;
     }
   }
 }