Represents a user transaction. More...

Detailed Description

Represents a user transaction.

To obtain this object, call Thread::get_current_xct(). This object represents a user transaction as opposed to physical-only internal transactions (so called system transactions, SysxctScope).

Definition at line 58 of file xct.hpp.

#include <xct.hpp>

Public Types
enum	Constants { kMaxPointerSets = 1024, kMaxPageVersionSets = 1024 }

Public Member Functions
	Xct (Engine engine, thread::Thread context, thread::ThreadId thread_id)

	Xct (const Xct &other)=delete

Xct &	operator= (const Xct &other)=delete

void	initialize (memory::NumaCoreMemory core_memory, uint32_t mcs_block_current, uint32_t *mcs_rw_async_mapping_current)

void	activate (IsolationLevel isolation_level)
	Begins the transaction. More...

void	deactivate ()
	Closes the transaction. More...

uint32_t	get_mcs_block_current () const

uint32_t	increment_mcs_block_current ()

void	decrement_mcs_block_current ()

bool	is_active () const
	Returns whether the object is an active transaction. More...

bool	is_enable_rll_for_this_xct () const

void	set_enable_rll_for_this_xct (bool value)

bool	is_default_rll_for_this_xct () const

void	set_default_rll_for_this_xct (bool value)

uint16_t	get_hot_threshold_for_this_xct () const

void	set_hot_threshold_for_this_xct (uint16_t value)

uint16_t	get_default_hot_threshold_for_this_xct () const

void	set_default_hot_threshold_for_this_xct (uint16_t value)

uint16_t	get_rll_threshold_for_this_xct () const

void	set_rll_threshold_for_this_xct (uint16_t value)

uint16_t	get_default_rll_threshold_for_this_xct () const

void	set_default_rll_threshold_for_this_xct (uint16_t value)

SysxctWorkspace *	get_sysxct_workspace () const

bool	is_read_only () const
	Returns if this transaction makes no writes. More...

IsolationLevel	get_isolation_level () const
	Returns the level of isolation for this transaction. More...

const XctId &	get_id () const
	Returns the ID of this transaction, but note that it is not issued until commit time! More...

thread::Thread *	get_thread_context ()

thread::ThreadId	get_thread_id () const

uint32_t	get_pointer_set_size () const

uint32_t	get_page_version_set_size () const

uint32_t	get_read_set_size () const

uint32_t	get_write_set_size () const

uint32_t	get_lock_free_read_set_size () const

uint32_t	get_lock_free_write_set_size () const

const PointerAccess *	get_pointer_set () const

const PageVersionAccess *	get_page_version_set () const

ReadXctAccess *	get_read_set ()

WriteXctAccess *	get_write_set ()

LockFreeReadXctAccess *	get_lock_free_read_set ()

LockFreeWriteXctAccess *	get_lock_free_write_set ()

void	issue_next_id (XctId max_xct_id, Epoch *epoch)
	Called while a successful commit of xct to issue a new xct id. More...

ErrorCode	add_to_pointer_set (const storage::VolatilePagePointer *pointer_address, storage::VolatilePagePointer observed)
	Add the given page pointer to the pointer set of this transaction. More...

void	overwrite_to_pointer_set (const storage::VolatilePagePointer *pointer_address, storage::VolatilePagePointer observed)
	The transaction that has updated the volatile pointer should not abort itself. More...

ErrorCode	add_to_page_version_set (const storage::PageVersion *version_address, storage::PageVersionStatus observed)
	Add the given page version to the page version set of this transaction. More...

ErrorCode	on_record_read (bool intended_for_write, RwLockableXctId tid_address, XctId observed_xid, ReadXctAccess **read_set_address, bool no_readset_if_moved=false, bool no_readset_if_next_layer=false)
	The general logic invoked for every record read. More...

ErrorCode	on_record_read (bool intended_for_write, RwLockableXctId *tid_address, bool no_readset_if_moved=false, bool no_readset_if_next_layer=false)
	Shortcut for a case when you don't need observed_xid/read_set_address back. More...

void	on_record_read_take_locks_if_needed (bool intended_for_write, const storage::Page page_address, UniversalLockId lock_id, RwLockableXctId tid_address)
	subroutine of on_record_read() to take lock(s). More...

ErrorCode	add_related_write_set (ReadXctAccess related_read_set, RwLockableXctId tid_address, char payload_address, log::RecordLogType log_entry)
	Registers a write-set related to an existing read-set. More...

ErrorCode	add_to_read_set (storage::StorageId storage_id, XctId observed_owner_id, RwLockableXctId owner_id_address, ReadXctAccess *read_set_address)
	Add the given record to the read set of this transaction. More...

ErrorCode	add_to_read_set (storage::StorageId storage_id, XctId observed_owner_id, UniversalLockId owner_lock_id, RwLockableXctId owner_id_address, ReadXctAccess *read_set_address)
	Use this in case you already have owner_lock_id. More...

ErrorCode	add_to_write_set (storage::StorageId storage_id, RwLockableXctId owner_id_address, char payload_address, log::RecordLogType *log_entry)
	Add the given record to the write set of this transaction. More...

ErrorCode	add_to_write_set (storage::StorageId storage_id, storage::Record record, log::RecordLogType log_entry)
	Add the given record to the write set of this transaction. More...

ErrorCode	add_to_read_and_write_set (storage::StorageId storage_id, XctId observed_owner_id, RwLockableXctId owner_id_address, char payload_address, log::RecordLogType *log_entry)
	Add a pair of read and write set of this transaction. More...

ErrorCode	add_to_lock_free_read_set (storage::StorageId storage_id, XctId observed_owner_id, RwLockableXctId *owner_id_address)
	Add the given record to the special read-set that is not placed in usual data pages. More...

ErrorCode	add_to_lock_free_write_set (storage::StorageId storage_id, log::RecordLogType *log_entry)
	Add the given log to the lock-free write set of this transaction. More...

void	remember_previous_xct_id (XctId new_id)

ErrorCode	acquire_local_work_memory (uint32_t size, void **out, uint32_t alignment=8)
	Get a tentative work memory of the specified size from pre-allocated thread-private memory. More...

xct::CurrentLockList *	get_current_lock_list ()

const xct::CurrentLockList *	get_current_lock_list () const

xct::RetrospectiveLockList *	get_retrospective_lock_list ()

bool	assert_related_read_write () const __attribute__((always_inline))
	This debug method checks whether the related_read_ and related_write_ fileds in read/write sets are consistent. More...

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

Member Enumeration Documentation

enum foedus::xct::Xct::Constants

Enumerator
kMaxPointerSets
kMaxPageVersionSets

Definition at line 60 of file xct.hpp.

                  {
     kMaxPointerSets = 1024,
     kMaxPageVersionSets = 1024,
   };

Constructor & Destructor Documentation

foedus::xct::Xct::Xct	(	Engine *	engine,
		thread::Thread *	context,
		thread::ThreadId	thread_id
	)

Definition at line 41 of file xct.cpp.

References foedus::storage::StorageOptions::kDefaultHotThreshold, foedus::xct::XctOptions::kDefaultHotThreshold, and foedus::xct::kSerializable.

   : engine_(engine), context_(context), thread_id_(thread_id) {
   id_ = XctId();
   active_ = false;
 
   default_rll_for_this_xct_ = false;
   enable_rll_for_this_xct_ = default_rll_for_this_xct_;
   default_hot_threshold_for_this_xct_ = storage::StorageOptions::kDefaultHotThreshold;
   hot_threshold_for_this_xct_ = default_hot_threshold_for_this_xct_;
   default_rll_threshold_for_this_xct_ = XctOptions::kDefaultHotThreshold;
   rll_threshold_for_this_xct_ = default_rll_threshold_for_this_xct_;
 
   sysxct_workspace_ = nullptr;
 
   read_set_ = nullptr;
   read_set_size_ = 0;
   max_read_set_size_ = 0;
   write_set_ = nullptr;
   write_set_size_ = 0;
   max_write_set_size_ = 0;
   lock_free_read_set_ = nullptr;
   lock_free_read_set_size_ = 0;
   max_lock_free_read_set_size_ = 0;
   lock_free_write_set_ = nullptr;
   lock_free_write_set_size_ = 0;
   max_lock_free_write_set_size_ = 0;
   pointer_set_size_ = 0;
   page_version_set_size_ = 0;
   isolation_level_ = kSerializable;
   mcs_block_current_ = nullptr;
   mcs_rw_async_mapping_current_ = nullptr;
   local_work_memory_ = nullptr;
   local_work_memory_size_ = 0;
   local_work_memory_cur_ = 0;
 }

foedus::xct::Xct::Xct ( const Xct & other )

delete

Member Function Documentation

ErrorCode foedus::xct::Xct::acquire_local_work_memory	(	uint32_t	size,
		void **	out,
		uint32_t	alignment = `8`
	)

inline

Get a tentative work memory of the specified size from pre-allocated thread-private memory.

The local work memory is recycled after the current transaction.

Definition at line 397 of file xct.hpp.

References foedus::kErrorCodeOk, foedus::kErrorCodeXctNoMoreLocalWorkMemory, and UNLIKELY.

Referenced by foedus::thread::ThreadPimpl::find_or_read_a_snapshot_page(), and foedus::thread::ThreadPimpl::find_or_read_snapshot_pages_batch().

                                                                                                    {
     if (size % alignment != 0) {
       size = ((size / alignment) + 1U) * alignment;
     }
     uint64_t begin = local_work_memory_cur_;
     if (begin % alignment != 0) {
       begin = ((begin / alignment) + 1U) * alignment;
     }
     if (UNLIKELY(size + begin > local_work_memory_size_)) {
       return kErrorCodeXctNoMoreLocalWorkMemory;
     }
     local_work_memory_cur_ = size + begin;
     *out = reinterpret_cast<char*>(local_work_memory_) + begin;
     return kErrorCodeOk;
   }

Here is the caller graph for this function:

void foedus::xct::Xct::activate ( IsolationLevel isolation_level )

inline

Begins the transaction.

Definition at line 79 of file xct.hpp.

References ASSERT_ND, foedus::xct::CurrentLockList::clear_entries(), foedus::xct::RetrospectiveLockList::is_empty(), and foedus::xct::CurrentLockList::prepopulate_for_retrospective_lock_list().

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

                                                                {
     ASSERT_ND(!active_);
     active_ = true;
     enable_rll_for_this_xct_ = default_rll_for_this_xct_;
     hot_threshold_for_this_xct_ = default_hot_threshold_for_this_xct_;
     rll_threshold_for_this_xct_ = default_rll_threshold_for_this_xct_;
     isolation_level_ = isolation_level;
     pointer_set_size_ = 0;
     page_version_set_size_ = 0;
     read_set_size_ = 0;
     write_set_size_ = 0;
     lock_free_read_set_size_ = 0;
     lock_free_write_set_size_ = 0;
     *mcs_block_current_ = 0;
     *mcs_rw_async_mapping_current_ = 0;
     local_work_memory_cur_ = 0;
     current_lock_list_.clear_entries();
     if (!retrospective_lock_list_.is_empty()) {
       // If we have RLL, we will highly likely lock all of them.
       // So, let's make CLL entries for all of them at the beginning.
       // This is both for simplicity and performance.
       current_lock_list_.prepopulate_for_retrospective_lock_list(retrospective_lock_list_);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::xct::Xct::add_related_write_set	(	ReadXctAccess *	related_read_set,
		RwLockableXctId *	tid_address,
		char *	payload_address,
		log::RecordLogType *	log_entry
	)

Registers a write-set related to an existing read-set.

This is typically invoked after on_record_read(), which returns the read-set address.

Note: so far you can't reigster more than one write-set to a read-set. but, registering related read/write sets are just for performance. correctness is guaranteed even if they are not registered as "related".

Definition at line 506 of file xct.cpp.

References add_to_write_set(), ASSERT_ND, CHECK_ERROR_CODE, foedus::log::invoke_assert_valid(), foedus::kErrorCodeOk, foedus::xct::RecordXctAccess::owner_id_address_, foedus::xct::WriteXctAccess::related_read_, foedus::xct::ReadXctAccess::related_write_, and foedus::xct::RecordXctAccess::storage_id_.

Referenced by foedus::storage::masstree::MasstreeStoragePimpl::register_record_write_log(), and foedus::storage::hash::HashStoragePimpl::register_record_write_log().

                                {
   ASSERT_ND(related_read_set);
   ASSERT_ND(tid_address);
 #ifndef NDEBUG
   log::invoke_assert_valid(log_entry);
 #endif  // NDEBUG
 
   auto* write = write_set_ + write_set_size_;
   auto storage_id = related_read_set->storage_id_;
   auto* owner_id_address = related_read_set->owner_id_address_;
   CHECK_ERROR_CODE(add_to_write_set(storage_id, owner_id_address, payload_address, log_entry));
 
   related_read_set->related_write_ = write;
   write->related_read_ = related_read_set;
   ASSERT_ND(related_read_set->related_write_->related_read_ == related_read_set);
   ASSERT_ND(write->related_read_->related_write_ == write);
   ASSERT_ND(write->log_entry_ == log_entry);
   ASSERT_ND(write->owner_id_address_ == owner_id_address);
   ASSERT_ND(write_set_size_ > 0);
   return kErrorCodeOk;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::xct::Xct::add_to_lock_free_read_set	(	storage::StorageId	storage_id,
		XctId	observed_owner_id,
		RwLockableXctId *	owner_id_address
	)

Add the given record to the special read-set that is not placed in usual data pages.

Definition at line 532 of file xct.cpp.

References ASSERT_ND, foedus::kErrorCodeOk, foedus::kErrorCodeXctReadSetOverflow, foedus::xct::kSerializable, foedus::xct::LockFreeReadXctAccess::observed_owner_id_, foedus::xct::LockFreeReadXctAccess::owner_id_address_, foedus::xct::LockFreeReadXctAccess::storage_id_, and UNLIKELY.

Referenced by foedus::storage::sequential::SequentialStorageControlBlock::optimistic_read_truncate_epoch().

                                      {
   ASSERT_ND(storage_id != 0);
   if (isolation_level_ != kSerializable) {
     return kErrorCodeOk;
   }
   if (UNLIKELY(lock_free_read_set_size_ >= max_lock_free_read_set_size_)) {
     return kErrorCodeXctReadSetOverflow;
   }
 
   lock_free_read_set_[lock_free_read_set_size_].storage_id_ = storage_id;
   lock_free_read_set_[lock_free_read_set_size_].observed_owner_id_ = observed_owner_id;
   lock_free_read_set_[lock_free_read_set_size_].owner_id_address_ = owner_id_address;
   ++lock_free_read_set_size_;
   return kErrorCodeOk;
 }

Here is the caller graph for this function:

ErrorCode foedus::xct::Xct::add_to_lock_free_write_set	(	storage::StorageId	storage_id,
		log::RecordLogType *	log_entry
	)

Add the given log to the lock-free write set of this transaction.

Definition at line 551 of file xct.cpp.

References ASSERT_ND, foedus::log::invoke_assert_valid(), foedus::kErrorCodeOk, foedus::kErrorCodeXctWriteSetOverflow, foedus::xct::LockFreeWriteXctAccess::log_entry_, foedus::xct::LockFreeWriteXctAccess::storage_id_, and UNLIKELY.

Referenced by foedus::storage::sequential::SequentialStorage::append_record().

                                {
   ASSERT_ND(storage_id != 0);
   ASSERT_ND(log_entry);
   if (UNLIKELY(lock_free_write_set_size_ >= max_lock_free_write_set_size_)) {
     return kErrorCodeXctWriteSetOverflow;
   }
 
 #ifndef NDEBUG
   log::invoke_assert_valid(log_entry);
 #endif  // NDEBUG
 
   lock_free_write_set_[lock_free_write_set_size_].storage_id_ = storage_id;
   lock_free_write_set_[lock_free_write_set_size_].log_entry_ = log_entry;
   ++lock_free_write_set_size_;
   return kErrorCodeOk;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::xct::Xct::add_to_page_version_set	(	const storage::PageVersion *	version_address,
		storage::PageVersionStatus	observed
	)

Add the given page version to the page version set of this transaction.

This is similar to pointer set. The difference is that this remembers the PageVersion value we observed when we accessed the page. This can capture many more concurrency issues in the page because PageVersion contains many flags and counters. However, PageVersionAccess can't be used if the page itself might be swapped.

Both PointerAccess and PageVersionAccess can be considered as "node set" in [TU2013], but for a little bit different purpose.

Definition at line 242 of file xct.cpp.

References foedus::xct::PageVersionAccess::address_, ASSERT_ND, foedus::kErrorCodeOk, foedus::kErrorCodeXctPageVersionSetOverflow, kMaxPointerSets, foedus::xct::kSerializable, foedus::xct::PageVersionAccess::observed_, and UNLIKELY.

Referenced by foedus::storage::masstree::MasstreeStoragePimpl::locate_record(), foedus::storage::hash::HashStoragePimpl::locate_record(), and foedus::storage::masstree::MasstreeStoragePimpl::locate_record_normalized().

                                      {
   ASSERT_ND(version_address);
   if (isolation_level_ != kSerializable) {
     return kErrorCodeOk;
   } else if (UNLIKELY(page_version_set_size_ >= kMaxPointerSets)) {
     return kErrorCodeXctPageVersionSetOverflow;
   }
 
   page_version_set_[page_version_set_size_].address_ = version_address;
   page_version_set_[page_version_set_size_].observed_ = observed;
   ++page_version_set_size_;
   return kErrorCodeOk;
 }

Here is the caller graph for this function:

ErrorCode foedus::xct::Xct::add_to_pointer_set	(	const storage::VolatilePagePointer *	pointer_address,
		storage::VolatilePagePointer	observed
	)

Add the given page pointer to the pointer set of this transaction.

You must call this method in the following cases;

When following a volatile pointer that might be later swapped with the RCU protocol.
When following a snapshot pointer except it is under a snapshot page.

To clarify, the first case does not apply to storage types that don't swap volatile pointers. So far, only Masstree Storage has such a swapping for root pages. All other storage types thus don't have to take pointer sets for this.

The second case doesn't apply to snapshot pointers once we follow a snapshot pointer in the tree because everything is assured to be stable once we follow a snapshot pointer.

Definition at line 198 of file xct.cpp.

References foedus::xct::PointerAccess::address_, ASSERT_ND, foedus::kErrorCodeOk, foedus::kErrorCodeXctPointerSetOverflow, kMaxPointerSets, foedus::xct::kSerializable, foedus::xct::PointerAccess::observed_, and UNLIKELY.

Referenced by foedus::thread::ThreadPimpl::follow_page_pointer(), foedus::thread::ThreadPimpl::follow_page_pointers_for_read_batch(), and foedus::storage::hash::HashStoragePimpl::locate_bin().

                                        {
   ASSERT_ND(pointer_address);
   if (isolation_level_ != kSerializable) {
     return kErrorCodeOk;
   }
 
   // TASK(Hideaki) even though pointer set should be small, we don't want sequential search
   // everytime. but insertion sort requires shifting. mmm.
   for (uint32_t i = 0; i < pointer_set_size_; ++i) {
     if (pointer_set_[i].address_ == pointer_address) {
       pointer_set_[i].observed_ = observed;
       return kErrorCodeOk;
     }
   }
 
   if (UNLIKELY(pointer_set_size_ >= kMaxPointerSets)) {
     return kErrorCodeXctPointerSetOverflow;
   }
 
   // no need for fence. the observed pointer itself is the only data to verify
   pointer_set_[pointer_set_size_].address_ = pointer_address;
   pointer_set_[pointer_set_size_].observed_ = observed;
   ++pointer_set_size_;
   return kErrorCodeOk;
 }

Here is the caller graph for this function:

ErrorCode foedus::xct::Xct::add_to_read_and_write_set	(	storage::StorageId	storage_id,
		XctId	observed_owner_id,
		RwLockableXctId *	owner_id_address,
		char *	payload_address,
		log::RecordLogType *	log_entry
	)

Add a pair of read and write set of this transaction.

Definition at line 474 of file xct.cpp.

References add_to_read_set(), add_to_write_set(), ASSERT_ND, CHECK_ERROR_CODE, foedus::log::invoke_assert_valid(), foedus::xct::XctId::is_valid(), and foedus::kErrorCodeOk.

                                {
   ASSERT_ND(observed_owner_id.is_valid());
 #ifndef NDEBUG
   log::invoke_assert_valid(log_entry);
 #endif  // NDEBUG
   auto* write = write_set_ + write_set_size_;
   CHECK_ERROR_CODE(add_to_write_set(storage_id, owner_id_address, payload_address, log_entry));
 
   auto* read = read_set_ + read_set_size_;
   ReadXctAccess* dummy;
   CHECK_ERROR_CODE(add_to_read_set(
     storage_id,
     observed_owner_id,
     write->owner_lock_id_,
     owner_id_address,
     &dummy));
   ASSERT_ND(read->owner_id_address_ == owner_id_address);
   read->related_write_ = write;
   write->related_read_ = read;
   ASSERT_ND(read->related_write_->related_read_ == read);
   ASSERT_ND(write->related_read_->related_write_ == write);
   ASSERT_ND(write->log_entry_ == log_entry);
   ASSERT_ND(write->owner_id_address_ == owner_id_address);
   ASSERT_ND(write_set_size_ > 0);
   return kErrorCodeOk;
 }

Here is the call graph for this function:

ErrorCode foedus::xct::Xct::add_to_read_set	(	storage::StorageId	storage_id,
		XctId	observed_owner_id,
		RwLockableXctId *	owner_id_address,
		ReadXctAccess **	read_set_address
	)

Add the given record to the read set of this transaction.

You must call this method BEFORE reading the data, otherwise it violates the commit protocol.

Definition at line 395 of file xct.cpp.

References foedus::xct::RetrospectiveLockList::get_volatile_page_resolver(), and foedus::xct::xct_id_to_universal_lock_id().

Referenced by add_to_read_and_write_set(), and on_record_read().

                                     {
   const auto& resolver = retrospective_lock_list_.get_volatile_page_resolver();
   UniversalLockId owner_lock_id = xct_id_to_universal_lock_id(resolver, owner_id_address);
   return add_to_read_set(
     storage_id,
     observed_owner_id,
     owner_lock_id,
     owner_id_address,
     read_set_address);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::xct::Xct::add_to_read_set	(	storage::StorageId	storage_id,
		XctId	observed_owner_id,
		UniversalLockId	owner_lock_id,
		RwLockableXctId *	owner_id_address,
		ReadXctAccess **	read_set_address
	)

Use this in case you already have owner_lock_id.

Slightly faster.

Definition at line 410 of file xct.cpp.

References ASSERT_ND, foedus::storage::assert_within_valid_volatile_page(), foedus::xct::RetrospectiveLockList::get_volatile_page_resolver(), foedus::xct::XctId::is_being_written(), foedus::xct::XctId::is_next_layer(), foedus::kErrorCodeOk, foedus::kErrorCodeXctReadSetOverflow, foedus::xct::RecordXctAccess::ordinal_, UNLIKELY, and foedus::xct::xct_id_to_universal_lock_id().

                                     {
 #ifndef NDEBUG
   const auto& resolver = retrospective_lock_list_.get_volatile_page_resolver();
   storage::assert_within_valid_volatile_page(resolver, owner_id_address);
   ASSERT_ND(owner_lock_id == xct_id_to_universal_lock_id(resolver, owner_id_address));
 #endif  // NDEBUG
 
   ASSERT_ND(storage_id != 0);
   ASSERT_ND(owner_id_address);
   ASSERT_ND(!observed_owner_id.is_being_written());
   ASSERT_ND(read_set_address);
   if (UNLIKELY(read_set_size_ >= max_read_set_size_)) {
     return kErrorCodeXctReadSetOverflow;
   }
   // if the next-layer bit is ON, the record is not logically a record, so why we are adding
   // it to read-set? we should have already either aborted or retried in this case.
   ASSERT_ND(!observed_owner_id.is_next_layer());
   ReadXctAccess* entry = read_set_ + read_set_size_;
   *read_set_address = entry;
   entry->ordinal_ = read_set_size_;
   entry->storage_id_ = storage_id;
   entry->set_owner_id_and_lock_id(owner_id_address, owner_lock_id);
   entry->observed_owner_id_ = observed_owner_id;
   entry->related_write_ = nullptr;
   ++read_set_size_;
   return kErrorCodeOk;
 }

Here is the call graph for this function:

ErrorCode foedus::xct::Xct::add_to_write_set	(	storage::StorageId	storage_id,
		RwLockableXctId *	owner_id_address,
		char *	payload_address,
		log::RecordLogType *	log_entry
	)

Add the given record to the write set of this transaction.

Definition at line 444 of file xct.cpp.

References ASSERT_ND, foedus::storage::assert_within_valid_volatile_page(), CXX11_NULLPTR, foedus::xct::RetrospectiveLockList::get_volatile_page_resolver(), foedus::log::invoke_assert_valid(), foedus::kErrorCodeOk, foedus::kErrorCodeXctWriteSetOverflow, foedus::xct::WriteXctAccess::log_entry_, foedus::xct::RecordXctAccess::ordinal_, foedus::xct::WriteXctAccess::payload_address_, foedus::xct::WriteXctAccess::related_read_, foedus::xct::RecordXctAccess::set_owner_id_resolve_lock_id(), foedus::xct::RecordXctAccess::storage_id_, and UNLIKELY.

Referenced by add_related_write_set(), add_to_read_and_write_set(), add_to_write_set(), foedus::storage::array::ArrayStoragePimpl::increment_record(), foedus::storage::array::ArrayStoragePimpl::increment_record_oneshot(), foedus::storage::array::ArrayStoragePimpl::overwrite_record(), foedus::storage::array::ArrayStoragePimpl::overwrite_record_primitive(), foedus::storage::masstree::MasstreeStoragePimpl::register_record_write_log(), and foedus::storage::hash::HashStoragePimpl::register_record_write_log().

                                {
   ASSERT_ND(storage_id != 0);
   ASSERT_ND(owner_id_address);
   ASSERT_ND(payload_address);
   ASSERT_ND(log_entry);
   const auto& resolver = retrospective_lock_list_.get_volatile_page_resolver();
 #ifndef NDEBUG
   storage::assert_within_valid_volatile_page(resolver, owner_id_address);
   log::invoke_assert_valid(log_entry);
 #endif  // NDEBUG
 
   if (UNLIKELY(write_set_size_ >= max_write_set_size_)) {
     return kErrorCodeXctWriteSetOverflow;
   }
   WriteXctAccess* write = write_set_ + write_set_size_;
   write->ordinal_ = write_set_size_;
   write->payload_address_ = payload_address;
   write->log_entry_ = log_entry;
   write->storage_id_ = storage_id;
   write->set_owner_id_resolve_lock_id(resolver, owner_id_address);
   write->related_read_ = CXX11_NULLPTR;
   ++write_set_size_;
   return kErrorCodeOk;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::xct::Xct::add_to_write_set	(	storage::StorageId	storage_id,
		storage::Record *	record,
		log::RecordLogType *	log_entry
	)

inline

Add the given record to the write set of this transaction.

Definition at line 354 of file xct.hpp.

References add_to_write_set(), foedus::storage::Record::owner_id_, and foedus::storage::Record::payload_.

                                  {
     return add_to_write_set(storage_id, &record->owner_id_, record->payload_, log_entry);
   }

Here is the call graph for this function:

bool foedus::xct::Xct::assert_related_read_write ( ) const

inline

This debug method checks whether the related_read_ and related_write_ fileds in read/write sets are consistent.

This method is completely wiped out in release build.

Returns: whether it is consistent. but this method anyway asserts as of finding inconsistency.

Definition at line 538 of file xct.hpp.

References ASSERT_ND, foedus::xct::RecordXctAccess::owner_id_address_, foedus::xct::WriteXctAccess::related_read_, and foedus::xct::ReadXctAccess::related_write_.

Referenced by foedus::xct::XctManagerPimpl::precommit_xct(), foedus::xct::XctManagerPimpl::precommit_xct_lock(), and foedus::xct::XctManagerPimpl::precommit_xct_sort_access().

                                                  {
 #ifndef NDEBUG
   for (uint32_t i = 0; i < write_set_size_; ++i) {
     WriteXctAccess* write = write_set_ + i;
     if (write->related_read_) {
       ASSERT_ND(write->related_read_ >= read_set_);
       uint32_t index = write->related_read_ - read_set_;
       ASSERT_ND(index < read_set_size_);
       ASSERT_ND(write->owner_id_address_ == write->related_read_->owner_id_address_);
       ASSERT_ND(write == write->related_read_->related_write_);
     }
   }
 
   for (uint32_t i = 0; i < read_set_size_; ++i) {
     ReadXctAccess* read = read_set_ + i;
     if (read->related_write_) {
       ASSERT_ND(read->related_write_ >= write_set_);
       uint32_t index = read->related_write_ - write_set_;
       ASSERT_ND(index < write_set_size_);
       ASSERT_ND(read->owner_id_address_ == read->related_write_->owner_id_address_);
       ASSERT_ND(read == read->related_write_->related_read_);
     }
   }
 #endif  // NDEBUG
   return true;
 }

Here is the caller graph for this function:

void foedus::xct::Xct::deactivate ( )

inline

Closes the transaction.

Precondition: Before calling this method, all locks must be already released.

Definition at line 108 of file xct.hpp.

References ASSERT_ND, and foedus::xct::CurrentLockList::is_empty().

Referenced by foedus::xct::XctManagerPimpl::abort_xct(), and foedus::xct::XctManagerPimpl::precommit_xct().

                                    {
     ASSERT_ND(active_);
     ASSERT_ND(current_lock_list_.is_empty());
     active_ = false;
     *mcs_block_current_ = 0;
     *mcs_rw_async_mapping_current_ = 0;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::xct::Xct::decrement_mcs_block_current ( )

inline

Definition at line 118 of file xct.hpp.

118 { --(*mcs_block_current_); }

xct::CurrentLockList* foedus::xct::Xct::get_current_lock_list ( )

inline

Definition at line 413 of file xct.hpp.

Referenced by foedus::thread::ThreadPimpl::cll_get_max_locked_id(), foedus::thread::ThreadPimpl::cll_giveup_all_locks_after(), foedus::thread::ThreadPimpl::cll_release_all_locks(), foedus::thread::ThreadPimpl::cll_release_all_locks_after(), foedus::thread::ThreadPimpl::cll_try_or_acquire_multiple_locks(), foedus::thread::ThreadPimpl::cll_try_or_acquire_single_lock(), foedus::xct::XctManagerPimpl::precommit_xct(), foedus::xct::XctManagerPimpl::precommit_xct_lock(), and foedus::xct::XctManagerPimpl::release_and_clear_all_current_locks().

413 { return &current_lock_list_; }

Here is the caller graph for this function:

const xct::CurrentLockList* foedus::xct::Xct::get_current_lock_list ( ) const

inline

Definition at line 414 of file xct.hpp.

414 { return &current_lock_list_; }

uint16_t foedus::xct::Xct::get_default_hot_threshold_for_this_xct ( ) const

inline

Definition at line 130 of file xct.hpp.

Referenced by foedus::xct::operator<<().

130 {

131 return default_hot_threshold_for_this_xct_ ; }

Here is the caller graph for this function:

uint16_t foedus::xct::Xct::get_default_rll_threshold_for_this_xct ( ) const

inline

Definition at line 137 of file xct.hpp.

Referenced by foedus::xct::operator<<().

137 {

138 return default_rll_threshold_for_this_xct_ ; }

Here is the caller graph for this function:

uint16_t foedus::xct::Xct::get_hot_threshold_for_this_xct ( ) const

inline

Definition at line 128 of file xct.hpp.

Referenced by foedus::storage::PageHeader::contains_hot_records(), foedus::thread::Thread::is_hot_page(), and foedus::xct::operator<<().

128 { return hot_threshold_for_this_xct_; }

Here is the caller graph for this function:

const XctId& foedus::xct::Xct::get_id ( ) const

inline

Returns the ID of this transaction, but note that it is not issued until commit time!

Definition at line 151 of file xct.hpp.

Referenced by foedus::xct::operator<<(), and foedus::xct::XctManagerPimpl::precommit_xct_apply().

151 { return id_; }

Here is the caller graph for this function:

IsolationLevel foedus::xct::Xct::get_isolation_level ( ) const

inline

Returns the level of isolation for this transaction.

Definition at line 149 of file xct.hpp.

Referenced by foedus::storage::hash::HashStoragePimpl::follow_page_bin_head(), foedus::thread::ThreadPimpl::follow_page_pointer(), foedus::thread::ThreadPimpl::follow_page_pointers_for_read_batch(), foedus::storage::array::ArrayStoragePimpl::get_record_for_write(), foedus::storage::array::ArrayStoragePimpl::get_record_for_write_batch(), foedus::storage::array::ArrayStoragePimpl::get_record_payload(), foedus::storage::array::ArrayStoragePimpl::get_record_payload_batch(), foedus::storage::array::ArrayStoragePimpl::get_record_primitive_batch(), foedus::storage::hash::HashStoragePimpl::locate_bin(), and foedus::storage::sequential::SequentialCursor::SequentialCursor().

149 { return isolation_level_; }

Here is the caller graph for this function:

LockFreeReadXctAccess* foedus::xct::Xct::get_lock_free_read_set ( )

inline

Definition at line 164 of file xct.hpp.

Referenced by foedus::xct::XctManagerPimpl::precommit_xct_verify_readonly(), and foedus::xct::XctManagerPimpl::precommit_xct_verify_readwrite().

164 { return lock_free_read_set_; }

Here is the caller graph for this function:

uint32_t foedus::xct::Xct::get_lock_free_read_set_size ( ) const

inline

Definition at line 158 of file xct.hpp.

Referenced by foedus::xct::operator<<(), foedus::xct::XctManagerPimpl::precommit_xct_verify_readonly(), and foedus::xct::XctManagerPimpl::precommit_xct_verify_readwrite().

158 { return lock_free_read_set_size_; }

Here is the caller graph for this function:

LockFreeWriteXctAccess* foedus::xct::Xct::get_lock_free_write_set ( )

inline

Definition at line 165 of file xct.hpp.

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

165 { return lock_free_write_set_; }

Here is the caller graph for this function:

uint32_t foedus::xct::Xct::get_lock_free_write_set_size ( ) const

inline

Definition at line 159 of file xct.hpp.

Referenced by foedus::xct::XctManagerPimpl::begin_xct(), foedus::xct::operator<<(), and foedus::xct::XctManagerPimpl::precommit_xct_apply().

159 { return lock_free_write_set_size_; }

Here is the caller graph for this function:

uint32_t foedus::xct::Xct::get_mcs_block_current ( ) const

inline

Definition at line 116 of file xct.hpp.

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

116 { return *mcs_block_current_; }

Here is the caller graph for this function:

const PageVersionAccess* foedus::xct::Xct::get_page_version_set ( ) const

inline

Definition at line 161 of file xct.hpp.

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

161 { return page_version_set_; }

Here is the caller graph for this function:

uint32_t foedus::xct::Xct::get_page_version_set_size ( ) const

inline

Definition at line 155 of file xct.hpp.

Referenced by foedus::xct::operator<<(), and foedus::xct::XctManagerPimpl::precommit_xct_verify_page_version_set().

155 { return page_version_set_size_; }

Here is the caller graph for this function:

const PointerAccess* foedus::xct::Xct::get_pointer_set ( ) const

inline

Definition at line 160 of file xct.hpp.

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

160 { return pointer_set_; }

Here is the caller graph for this function:

uint32_t foedus::xct::Xct::get_pointer_set_size ( ) const

inline

Definition at line 154 of file xct.hpp.

Referenced by foedus::xct::operator<<(), and foedus::xct::XctManagerPimpl::precommit_xct_verify_pointer_set().

154 { return pointer_set_size_; }

Here is the caller graph for this function:

ReadXctAccess* foedus::xct::Xct::get_read_set ( )

inline

Definition at line 162 of file xct.hpp.

Referenced by foedus::xct::XctManagerPimpl::abort_xct(), foedus::xct::RetrospectiveLockList::construct(), foedus::xct::XctManagerPimpl::precommit_xct_verify_readonly(), and foedus::xct::XctManagerPimpl::precommit_xct_verify_readwrite().

162 { return read_set_; }

Here is the caller graph for this function:

uint32_t foedus::xct::Xct::get_read_set_size ( ) const

inline

Definition at line 156 of file xct.hpp.

Referenced by foedus::xct::XctManagerPimpl::abort_xct(), foedus::xct::XctManagerPimpl::begin_xct(), foedus::xct::RetrospectiveLockList::construct(), foedus::xct::operator<<(), foedus::xct::XctManagerPimpl::precommit_xct_verify_readonly(), and foedus::xct::XctManagerPimpl::precommit_xct_verify_readwrite().

156 { return read_set_size_; }

Here is the caller graph for this function:

xct::RetrospectiveLockList* foedus::xct::Xct::get_retrospective_lock_list ( )

inline

Definition at line 415 of file xct.hpp.

Referenced by foedus::xct::XctManagerPimpl::abort_xct(), foedus::xct::XctManagerPimpl::begin_xct(), and foedus::xct::XctManagerPimpl::precommit_xct().

                                                           {
     return &retrospective_lock_list_;
   }

Here is the caller graph for this function:

uint16_t foedus::xct::Xct::get_rll_threshold_for_this_xct ( ) const

inline

Definition at line 135 of file xct.hpp.

Referenced by foedus::xct::XctManagerPimpl::abort_xct(), and foedus::xct::operator<<().

135 { return rll_threshold_for_this_xct_; }

Here is the caller graph for this function:

SysxctWorkspace* foedus::xct::Xct::get_sysxct_workspace ( ) const

inline

Definition at line 142 of file xct.hpp.

Referenced by foedus::xct::operator<<(), and foedus::thread::ThreadPimpl::run_nested_sysxct().

142 { return sysxct_workspace_; }

Here is the caller graph for this function:

thread::Thread* foedus::xct::Xct::get_thread_context ( )

inline

Definition at line 152 of file xct.hpp.

152 { return context_; }

thread::ThreadId foedus::xct::Xct::get_thread_id ( ) const

inline

Definition at line 153 of file xct.hpp.

153 { return thread_id_; }

WriteXctAccess* foedus::xct::Xct::get_write_set ( )

inline

Definition at line 163 of file xct.hpp.

Referenced by foedus::xct::RetrospectiveLockList::construct(), foedus::xct::XctManagerPimpl::precommit_xct_apply(), foedus::xct::XctManagerPimpl::precommit_xct_lock(), foedus::xct::XctManagerPimpl::precommit_xct_lock_batch_track_moved(), foedus::xct::XctManagerPimpl::precommit_xct_readwrite(), and foedus::xct::XctManagerPimpl::precommit_xct_sort_access().

163 { return write_set_; }

Here is the caller graph for this function:

uint32_t foedus::xct::Xct::get_write_set_size ( ) const

inline

Definition at line 157 of file xct.hpp.

Referenced by foedus::xct::XctManagerPimpl::begin_xct(), foedus::xct::RetrospectiveLockList::construct(), foedus::xct::operator<<(), foedus::xct::XctManagerPimpl::precommit_xct_apply(), foedus::xct::XctManagerPimpl::precommit_xct_lock(), foedus::xct::XctManagerPimpl::precommit_xct_lock_batch_track_moved(), foedus::xct::XctManagerPimpl::precommit_xct_readwrite(), and foedus::xct::XctManagerPimpl::precommit_xct_sort_access().

157 { return write_set_size_; }

Here is the caller graph for this function:

uint32_t foedus::xct::Xct::increment_mcs_block_current ( )

inline

Definition at line 117 of file xct.hpp.

117 { return ++(*mcs_block_current_); }

void foedus::xct::Xct::initialize	(	memory::NumaCoreMemory *	core_memory,
		uint32_t *	mcs_block_current,
		uint32_t *	mcs_rw_async_mapping_current
	)

Definition at line 77 of file xct.cpp.

References ASSERT_ND, foedus::xct::XctOptions::enable_retrospective_lock_list_, foedus::memory::NumaCoreMemory::get_current_lock_list_capacity(), foedus::memory::NumaCoreMemory::get_current_lock_list_memory(), foedus::memory::EngineMemory::get_global_volatile_page_resolver(), foedus::savepoint::SavepointManager::get_initial_current_epoch(), foedus::memory::NumaCoreMemory::get_local_work_memory(), foedus::memory::NumaCoreMemory::get_local_work_memory_size(), foedus::Engine::get_memory_manager(), foedus::Engine::get_options(), foedus::memory::NumaCoreMemory::get_retrospective_lock_list_capacity(), foedus::memory::NumaCoreMemory::get_retrospective_lock_list_memory(), foedus::Engine::get_savepoint_manager(), foedus::memory::NumaCoreMemory::get_small_thread_local_memory_pieces(), foedus::storage::StorageOptions::hot_threshold_, foedus::xct::XctOptions::hot_threshold_for_retrospective_lock_list_, foedus::xct::RetrospectiveLockList::init(), foedus::xct::CurrentLockList::init(), foedus::xct::SysxctWorkspace::init(), foedus::xct::XctId::is_valid(), foedus::xct::XctOptions::max_lock_free_read_set_size_, foedus::xct::XctOptions::max_lock_free_write_set_size_, foedus::xct::XctOptions::max_read_set_size_, foedus::xct::XctOptions::max_write_set_size_, foedus::xct::XctId::set_epoch(), foedus::xct::XctId::set_ordinal(), foedus::EngineOptions::storage_, and foedus::EngineOptions::xct_.

Referenced by foedus::thread::ThreadPimpl::initialize_once().

                                           {
   id_.set_epoch(engine_->get_savepoint_manager()->get_initial_current_epoch());
   id_.set_ordinal(0);  // ordinal 0 is possible only as a dummy "latest" XctId
   ASSERT_ND(id_.is_valid());
   memory::NumaCoreMemory:: SmallThreadLocalMemoryPieces pieces
     = core_memory->get_small_thread_local_memory_pieces();
   const XctOptions& xct_opt = engine_->get_options().xct_;
 
   default_rll_for_this_xct_ = xct_opt.enable_retrospective_lock_list_;
   enable_rll_for_this_xct_ = default_rll_for_this_xct_;
   default_hot_threshold_for_this_xct_ = engine_->get_options().storage_.hot_threshold_;
   hot_threshold_for_this_xct_ = default_hot_threshold_for_this_xct_;
   default_rll_threshold_for_this_xct_ = xct_opt.hot_threshold_for_retrospective_lock_list_;
   rll_threshold_for_this_xct_ = default_rll_threshold_for_this_xct_;
 
   sysxct_workspace_ = reinterpret_cast<SysxctWorkspace*>(pieces.sysxct_workspace_memory_);
 
   read_set_ = reinterpret_cast<ReadXctAccess*>(pieces.xct_read_access_memory_);
   read_set_size_ = 0;
   max_read_set_size_ = xct_opt.max_read_set_size_;
   write_set_ = reinterpret_cast<WriteXctAccess*>(pieces.xct_write_access_memory_);
   write_set_size_ = 0;
   max_write_set_size_ = xct_opt.max_write_set_size_;
   lock_free_read_set_ = reinterpret_cast<LockFreeReadXctAccess*>(
     pieces.xct_lock_free_read_access_memory_);
   lock_free_read_set_size_ = 0;
   max_lock_free_read_set_size_ = xct_opt.max_lock_free_read_set_size_;
   lock_free_write_set_ = reinterpret_cast<LockFreeWriteXctAccess*>(
     pieces.xct_lock_free_write_access_memory_);
   lock_free_write_set_size_ = 0;
   max_lock_free_write_set_size_ = xct_opt.max_lock_free_write_set_size_;
   pointer_set_ = reinterpret_cast<PointerAccess*>(pieces.xct_pointer_access_memory_);
   pointer_set_size_ = 0;
   page_version_set_ = reinterpret_cast<PageVersionAccess*>(pieces.xct_page_version_memory_);
   page_version_set_size_ = 0;
   mcs_block_current_ = mcs_block_current;
   *mcs_block_current_ = 0;
   mcs_rw_async_mapping_current_ = mcs_rw_async_mapping_current;
   *mcs_rw_async_mapping_current_ = 0;
   local_work_memory_ = core_memory->get_local_work_memory();
   local_work_memory_size_ = core_memory->get_local_work_memory_size();
   local_work_memory_cur_ = 0;
 
   sysxct_workspace_->init(context_);
   current_lock_list_.init(
     core_memory->get_current_lock_list_memory(),
     core_memory->get_current_lock_list_capacity(),
     engine_->get_memory_manager()->get_global_volatile_page_resolver());
   retrospective_lock_list_.init(
     core_memory->get_retrospective_lock_list_memory(),
     core_memory->get_retrospective_lock_list_capacity(),
     engine_->get_memory_manager()->get_global_volatile_page_resolver());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::xct::Xct::is_active ( ) const

inline

Returns whether the object is an active transaction.

Definition at line 121 of file xct.hpp.

Referenced by foedus::xct::XctManagerPimpl::abort_xct(), foedus::xct::XctManagerPimpl::begin_xct(), foedus::xct::RetrospectiveLockList::construct(), foedus::thread::Thread::is_running_xct(), foedus::storage::masstree::MasstreeCursor::open(), foedus::xct::operator<<(), foedus::storage::sequential::SequentialStorageControlBlock::optimistic_read_truncate_epoch(), and foedus::xct::XctManagerPimpl::precommit_xct().

121 { return active_; }

Here is the caller graph for this function:

bool foedus::xct::Xct::is_default_rll_for_this_xct ( ) const

inline

Definition at line 125 of file xct.hpp.

Referenced by foedus::xct::operator<<().

125 { return default_rll_for_this_xct_ ; }

Here is the caller graph for this function:

bool foedus::xct::Xct::is_enable_rll_for_this_xct ( ) const

inline

Definition at line 123 of file xct.hpp.

Referenced by foedus::xct::XctManagerPimpl::abort_xct(), and foedus::xct::operator<<().

123 { return enable_rll_for_this_xct_; }

Here is the caller graph for this function:

bool foedus::xct::Xct::is_read_only ( ) const

inline

Returns if this transaction makes no writes.

Definition at line 145 of file xct.hpp.

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

                                            {
     return write_set_size_ == 0 && lock_free_write_set_size_ == 0;
   }

Here is the caller graph for this function:

void foedus::xct::Xct::issue_next_id	(	XctId	max_xct_id,
		Epoch *	epoch
	)

Called while a successful commit of xct to issue a new xct id.

Parameters

[in]	max_xct_id	largest xct_id this transaction depends on.
[in,out]	epoch	(in) The minimal epoch this transaction has to be in. (out) the epoch this transaction ended up with, which is epoch+1 only when it found ordinal is full for the current epoch.

This method issues a XctId that satisfies the following properties (see [TU13]). Clarification: "larger" hereby means either a) the epoch is larger or b) the epoch is same and ordinal is larger.

Larger than the most recent XctId issued for read-write transaction on this thread.
Larger than every XctId of any record read or written by this transaction.
In the returned(out) epoch (which is same or larger than the given(in) epoch).

This method also advancec epoch when ordinal is full for the current epoch. This method never fails.

Definition at line 134 of file xct.cpp.

References foedus::xct::XctManager::advance_current_global_epoch(), ASSERT_ND, foedus::Epoch::before(), foedus::xct::XctManager::get_current_global_epoch(), foedus::xct::XctManager::get_current_global_epoch_weak(), foedus::xct::XctId::get_epoch(), foedus::xct::XctId::get_ordinal(), foedus::Engine::get_xct_manager(), foedus::xct::XctId::is_valid(), foedus::xct::kMaxXctOrdinal, remember_previous_xct_id(), foedus::xct::XctId::set_epoch(), foedus::xct::XctId::set_ordinal(), foedus::xct::XctId::store_max(), and UNLIKELY.

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

                                                        {
   ASSERT_ND(id_.is_valid());
 
   while (true) {
     // invariant 1: Larger than latest XctId of this thread.
     XctId new_id = id_;
     // invariant 2: Larger than every XctId of any record read or written by this transaction.
     new_id.store_max(max_xct_id);
     // invariant 3: in the epoch
     if (new_id.get_epoch().before(*epoch)) {
       new_id.set_epoch(*epoch);
       new_id.set_ordinal(0);
     }
     ASSERT_ND(new_id.get_epoch() == *epoch);
 
     // Now, is it possible to get an ordinal one larger than this one?
     if (UNLIKELY(new_id.get_ordinal() >= kMaxXctOrdinal)) {
       // oh, that's rare.
       LOG(WARNING) << "Reached the maximum ordinal in this epoch. Advancing current epoch"
         << " just for this reason. It's rare, but not an error.";
       engine_->get_xct_manager()->advance_current_global_epoch();
       ASSERT_ND(epoch->before(engine_->get_xct_manager()->get_current_global_epoch()));
       // we have already issued fence by now, so we can use nonatomic version.
       *epoch = engine_->get_xct_manager()->get_current_global_epoch_weak();
       continue;  // try again with this epoch.
     }
 
     ASSERT_ND(new_id.get_ordinal() < kMaxXctOrdinal);
     new_id.set_ordinal(new_id.get_ordinal() + 1U);
     remember_previous_xct_id(new_id);
     break;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::xct::Xct::on_record_read	(	bool	intended_for_write,
		RwLockableXctId *	tid_address,
		XctId *	observed_xid,
		ReadXctAccess **	read_set_address,
		bool	no_readset_if_moved = `false`,
		bool	no_readset_if_next_layer = `false`
	)

The general logic invoked for every record read.

Parameters

[in]	intended_for_write	Hints whether the record will be written after this read
[in,out]	tid_address	The record's TID address
[out]	observed_xid	Returns the observed XID. See below for more details.
[out]	read_set_address	If this method took a read-set, points to the read-set record. nullptr if it didn't.
[in]	no_readset_if_moved	When this is true, and if we observe an XID whose is_moved() is on, we do not add it to readset. See the comment below for more details.
[in]	no_readset_if_next_layer	When this is true, and if we observe an XID whose is_next_layer() is on, we do not add it to readset. See the comment below for more details.

Returns: The only possible error is read-set full.

Precondition: tid_address != nullptr && observed_xid != nullptr; tid_address must be pointing to somewhere in an aligned data page. We reinterpret_cast the address to acquire the enclosing page and its header.

Postcondition: returns error code, or !observed_xid->is_being_written().

You must call this method BEFORE reading the data, otherwise it violates the commit protocol. This method does a few things listed below:

Observes XID: Observes XID in the TID and spins until we at least observe an XID that is !observed_xid->is_being_written(). However, remember that concurrent threads might write the data and XID after this method leaves. If you want to make sure your "read" is strictly as of one time point, you must call this method in a loop. In terms of serializability, you don't need it because commit protocol will catch it.

Takes lock(s) recommended by RLL or temperature stat.: This happens only when MOCC is on, and the page is a volatile page. This method might take a PCC-like lock on this record, and also other locks to keep the transaction in canonical mode.

Add to read set: This happens only when the transaction has higher isolation level (serializable), and the page is a volatile page. To protect the read, we add the observed XID and the address to read set of this transaction.

no_readset_if_moved/next_layer: After invoking on_record_read(), we might find the observed TID tells that the record is now permanently out of our interest (e.g., moved/next-layer). In that case, the caller doesn't want to have the entry in read-set. These flags tell this method to not add such entries to read-set. Note that such a protocol is safe because moved/next-layer flags in the storage type is immutable once set, eg masstree storage only changes moved-flag off->on, not the other way around. deleted flag is mutable (can off->on->off), so we can't skip such readset. Use it appropriately according to the protcol in the storage type. If you are unsure, don't give "true" to these parameters. Having unnecessary read-sets is just a performance issue, not correctness.

Definition at line 258 of file xct.cpp.

References add_to_read_set(), ASSERT_ND, foedus::storage::assert_within_valid_volatile_page(), CHECK_ERROR_CODE, foedus::storage::construct_volatile_page_pointer(), foedus::thread::Thread::get_global_volatile_page_resolver(), foedus::storage::Page::get_header(), foedus::storage::VolatilePagePointer::get_numa_node(), foedus::storage::VolatilePagePointer::get_offset(), foedus::xct::XctId::is_being_written(), foedus::xct::XctId::is_moved(), foedus::xct::XctId::is_next_layer(), foedus::xct::kDirtyRead, foedus::kErrorCodeOk, foedus::xct::kSerializable, foedus::xct::kSnapshot, foedus::assorted::memory_fence_acquire(), on_record_read_take_locks_if_needed(), foedus::xct::XctId::spin_while_being_written(), foedus::storage::PageHeader::storage_id_, foedus::storage::to_page(), foedus::xct::to_universal_lock_id(), and foedus::xct::RwLockableXctId::xct_id_.

                                  {
   ASSERT_ND(tid_address);
   ASSERT_ND(observed_xid);
   ASSERT_ND(read_set_address);
   *read_set_address = nullptr;
 
   const storage::Page* page = storage::to_page(reinterpret_cast<const void*>(tid_address));
   const auto& page_header = page->get_header();
   if (page_header.snapshot_) {
     // Snapshot page is immutable.
     // No read-set, lock, or check for being_written flag needed.
     *observed_xid = tid_address->xct_id_;
     ASSERT_ND(!observed_xid->is_being_written());
     return kErrorCodeOk;
   } else if (isolation_level_ != kSerializable) {
     // No read-set or read-locks needed in non-serializable transactions.
     // Also no point to conservatively take write-locks recommended by RLL
     // because we don't take any read locks in these modes, so the
     // original SILO's write-lock protocol is enough and abort-free.
     ASSERT_ND(isolation_level_ == kDirtyRead || isolation_level_ == kSnapshot);
     *observed_xid = tid_address->xct_id_.spin_while_being_written();
     ASSERT_ND(!observed_xid->is_being_written());
     return kErrorCodeOk;
   }
 
   storage::VolatilePagePointer vpp(storage::construct_volatile_page_pointer(page_header.page_id_));
 #ifndef NDEBUG
   const auto& resolver = context_->get_global_volatile_page_resolver();
   storage::assert_within_valid_volatile_page(resolver, tid_address);
 
   ASSERT_ND(vpp.get_numa_node() < resolver.numa_node_count_);
   ASSERT_ND(vpp.get_offset() >= resolver.begin_);
   ASSERT_ND(vpp.get_offset() < resolver.end_);
 #endif  // NDEBUG
 
   // This is a serializable transaction, and we are reading a record from a volatile page.
   // We might take a pessimisitic lock for the record, which is our MOCC protocol.
   // However, we need to do this _before_ observing XctId. Otherwise there is a
   // chance of aborts even with the lock.
   const UniversalLockId lock_id = to_universal_lock_id(
     vpp.get_numa_node(),
     vpp.get_offset(),
     reinterpret_cast<uintptr_t>(tid_address));
   on_record_read_take_locks_if_needed(intended_for_write, page, lock_id, tid_address);
 
   *observed_xid = tid_address->xct_id_.spin_while_being_written();
   ASSERT_ND(!observed_xid->is_being_written());
 
   // Now that we observe XID in its own (non-inlined) function, probably not needed...
   assorted::memory_fence_acquire();  // following reads must happen *after* observing xid
 
   // check non-reversible flags and skip read-set
   if (observed_xid->is_moved() && no_readset_if_moved) {
     return kErrorCodeOk;
   } else if (observed_xid->is_next_layer() && no_readset_if_next_layer) {
     return kErrorCodeOk;
   }
 
   const storage::StorageId storage_id = page->get_header().storage_id_;
   ASSERT_ND(storage_id != 0);
   CHECK_ERROR_CODE(add_to_read_set(
     storage_id,
     *observed_xid,
     lock_id,
     tid_address,
     read_set_address));
 
   return kErrorCodeOk;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::xct::Xct::on_record_read	(	bool	intended_for_write,
		RwLockableXctId *	tid_address,
		bool	no_readset_if_moved = `false`,
		bool	no_readset_if_next_layer = `false`
	)

inline

Shortcut for a case when you don't need observed_xid/read_set_address back.

Definition at line 286 of file xct.hpp.

References on_record_read().

                                            {
     XctId dummy_xctid;
     ReadXctAccess* dummy_read_set;
     return on_record_read(
       intended_for_write,
       tid_address,
       &dummy_xctid,
       &dummy_read_set,
       no_readset_if_moved ,
       no_readset_if_next_layer);
   }

Here is the call graph for this function:

void foedus::xct::Xct::on_record_read_take_locks_if_needed	(	bool	intended_for_write,
		const storage::Page *	page_address,
		UniversalLockId	lock_id,
		RwLockableXctId *	tid_address
	)

subroutine of on_record_read() to take lock(s).

Definition at line 334 of file xct.cpp.

References ASSERT_ND, foedus::storage::assert_within_valid_volatile_page(), foedus::xct::RetrospectiveLockList::binary_search(), foedus::xct::RetrospectiveLockList::clear_entries(), foedus::thread::Thread::cll_giveup_all_locks_after(), foedus::thread::Thread::cll_try_or_acquire_multiple_locks(), foedus::thread::Thread::cll_try_or_acquire_single_lock(), foedus::xct::RetrospectiveLockList::get_array(), foedus::xct::CurrentLockList::get_entry(), foedus::thread::Thread::get_global_volatile_page_resolver(), foedus::xct::CurrentLockList::get_or_add_entry(), foedus::xct::RetrospectiveLockList::is_empty(), foedus::xct::LockEntry::is_enough(), foedus::thread::Thread::is_hot_page(), foedus::kErrorCodeOk, foedus::kErrorCodeXctLockAbort, foedus::xct::kLockListPositionInvalid, foedus::xct::kNullUniversalLockId, foedus::xct::kReadLock, foedus::xct::kWriteLock, foedus::xct::LockEntry::universal_lock_id_, and foedus::xct::xct_id_to_universal_lock_id().

Referenced by on_record_read().

                                 {
 #ifndef NDEBUG
   const auto& resolver = context_->get_global_volatile_page_resolver();
   storage::assert_within_valid_volatile_page(resolver, tid_address);
   ASSERT_ND(lock_id == xct_id_to_universal_lock_id(resolver, tid_address));
 #endif  // NDEBUG
 
   LockListPosition rll_pos = kLockListPositionInvalid;
   bool lets_take_lock = false;
   if (!retrospective_lock_list_.is_empty()) {
     // RLL is set, which means the previous run aborted for race.
     // binary-search for each read-set is not cheap, but in this case better than aborts.
     // So, let's see if we should take the lock.
     rll_pos = retrospective_lock_list_.binary_search(lock_id);
     if (rll_pos != kLockListPositionInvalid) {
       ASSERT_ND(retrospective_lock_list_.get_array()[rll_pos].universal_lock_id_ == lock_id);
       DVLOG(1) << "RLL recommends to take lock on this record!";
       lets_take_lock = true;
     }
   }
 
   if (!lets_take_lock && context_->is_hot_page(page_address)) {
     lets_take_lock = true;
   }
 
   if (lets_take_lock) {
     LockMode mode = intended_for_write ? kWriteLock : kReadLock;
     LockListPosition cll_pos = current_lock_list_.get_or_add_entry(lock_id, tid_address, mode);
     LockEntry* cll_entry = current_lock_list_.get_entry(cll_pos);
     if (cll_entry->is_enough()) {
       return;  // already had the lock
     }
 
     ErrorCode lock_ret;
     if (rll_pos == kLockListPositionInvalid) {
       // Then, this is a single read-lock to take.
       lock_ret = context_->cll_try_or_acquire_single_lock(cll_pos);
       // TODO(Hideaki) The above locks unconditionally in canonnical mode. Even in non-canonical,
       // when it returns kErrorCodeXctLockAbort AND we haven't taken any write-lock yet,
       // we might still want a retry here.. but it has pros/cons. Revisit later.
     } else {
       // Then we should take all locks before this too.
       lock_ret = context_->cll_try_or_acquire_multiple_locks(cll_pos);
     }
 
     if (lock_ret != kErrorCodeOk) {
       ASSERT_ND(lock_ret == kErrorCodeXctLockAbort);
       DVLOG(0) << "Failed to take some of the lock that might be beneficial later"
         << ". We still go on because the locks here are not mandatory.";
       // At this point, no point to be advised by RLL any longer.
       // Let's clear it, and let's give-up all incomplete locks in CLL.
       context_->cll_giveup_all_locks_after(kNullUniversalLockId);
       retrospective_lock_list_.clear_entries();
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Xct& foedus::xct::Xct::operator= ( const Xct & other )

delete

void foedus::xct::Xct::overwrite_to_pointer_set	(	const storage::VolatilePagePointer *	pointer_address,
		storage::VolatilePagePointer	observed
	)

The transaction that has updated the volatile pointer should not abort itself.

So, it calls this method to apply the version it installed.

Definition at line 226 of file xct.cpp.

References ASSERT_ND, foedus::xct::kSerializable, and foedus::xct::PointerAccess::observed_.

                                        {
   ASSERT_ND(pointer_address);
   if (isolation_level_ != kSerializable) {
     return;
   }
 
   for (uint32_t i = 0; i < pointer_set_size_; ++i) {
     if (pointer_set_[i].address_ == pointer_address) {
       pointer_set_[i].observed_ = observed;
       return;
     }
   }
 }

void foedus::xct::Xct::remember_previous_xct_id ( XctId new_id )

inline

Definition at line 386 of file xct.hpp.

References ASSERT_ND, and foedus::xct::XctId::before().

Referenced by issue_next_id().

                                                              {
     ASSERT_ND(id_.before(new_id));
     id_ = new_id;
     ASSERT_ND(id_.get_ordinal() > 0);
     ASSERT_ND(id_.is_valid());
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::xct::Xct::set_default_hot_threshold_for_this_xct ( uint16_t value )

inline

Definition at line 132 of file xct.hpp.

Referenced by foedus::thread::ThreadPimpl::handle_tasks().

132 {

133 default_hot_threshold_for_this_xct_ = value; }

Here is the caller graph for this function:

void foedus::xct::Xct::set_default_rll_for_this_xct ( bool value )

inline

Definition at line 126 of file xct.hpp.

Referenced by foedus::thread::ThreadPimpl::handle_tasks().

126 { default_rll_for_this_xct_ = value; }

Here is the caller graph for this function:

void foedus::xct::Xct::set_default_rll_threshold_for_this_xct ( uint16_t value )

inline

Definition at line 139 of file xct.hpp.

Referenced by foedus::thread::ThreadPimpl::handle_tasks().

139 {

140 default_rll_threshold_for_this_xct_ = value; }

Here is the caller graph for this function:

void foedus::xct::Xct::set_enable_rll_for_this_xct ( bool value )

inline

Definition at line 124 of file xct.hpp.

124 { enable_rll_for_this_xct_ = value; }

void foedus::xct::Xct::set_hot_threshold_for_this_xct ( uint16_t value )

inline

Definition at line 129 of file xct.hpp.

129 { hot_threshold_for_this_xct_ = value; }

void foedus::xct::Xct::set_rll_threshold_for_this_xct ( uint16_t value )

inline

Definition at line 136 of file xct.hpp.

136 { rll_threshold_for_this_xct_ = value; }

Friends And Related Function Documentation

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

friend

Definition at line 168 of file xct.cpp.

                                                     {
   o << "<Xct>"
     << "<active_>" << v.is_active() << "</active_>";
   o << "<enable_rll_for_this_xct_>" << v.is_enable_rll_for_this_xct()
     << "</enable_rll_for_this_xct_>";
   o << "<default_rll_for_this_xct_>" << v.is_default_rll_for_this_xct()
     << "</default_rll_for_this_xct_>";
   o << "<hot_threshold>" << v.get_hot_threshold_for_this_xct() << "</hot_threshold>";
   o << "<default_hot_threshold>" << v.get_default_hot_threshold_for_this_xct()
     << "</default_hot_threshold>";
   o << "<rll_threshold>" << v.get_rll_threshold_for_this_xct() << "</rll_threshold>";
   o << "<default_rll_threshold>" << v.get_default_rll_threshold_for_this_xct()
     << "</default_rll_threshold>";
   if (v.is_active()) {
     o << "<id_>" << v.get_id() << "</id_>"
       << "<read_set_size>" << v.get_read_set_size() << "</read_set_size>"
       << "<write_set_size>" << v.get_write_set_size() << "</write_set_size>"
       << "<pointer_set_size>" << v.get_pointer_set_size() << "</pointer_set_size>"
       << "<page_version_set_size>" << v.get_page_version_set_size() << "</page_version_set_size>"
       << "<lock_free_read_set_size>" << v.get_lock_free_read_set_size()
         << "</lock_free_read_set_size>"
       << "<lock_free_write_set_size>" << v.get_lock_free_write_set_size()
         << "</lock_free_write_set_size>";
     const SysxctWorkspace* sysxct_workspace = v.get_sysxct_workspace();
     o << *sysxct_workspace;
   }
   o << "</Xct>";
   return o;
 }

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

/home/shino/foedus_code/foedus-core/include/foedus/xct/xct.hpp
/home/shino/foedus_code/foedus-core/src/foedus/xct/xct.cpp

Detailed Description

Public Types

Public Member Functions

Friends

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation