foedus::xct::SysxctLockList Class Reference

RLL/CLL of a system transaction. More...

Detailed Description

RLL/CLL of a system transaction.

Unlike the normal transaction, lock-list is simpler in sysxct. Sysxct doesn't need read-set or asynchronous locking. It immediately takes the locks required by the logic, and abort if it couldn't. Unlike normal xct, sysxct also locks records for just a few times (counting "lock all records in this page" as one). We thus integrate RLL and CLL into this list in system transactions. We might follow this approach in normal xct later.

This object is a POD. We use a fixed-size array.

Definition at line 166 of file sysxct_impl.hpp.

#include <sysxct_impl.hpp>

Public Types
enum	Constants { kMaxSysxctLocks = 1 << 10 }

Public Member Functions
	SysxctLockList ()
	~SysxctLockList ()
	SysxctLockList (const SysxctLockList &other)=delete
SysxctLockList &	operator= (const SysxctLockList &other)=delete
void	init ()
void	clear_entries (UniversalLockId enclosing_max_lock_id)
	Remove all entries. More...
void	compress_entries (UniversalLockId enclosing_max_lock_id)
	Unlike clear_entries(), this is used when a sysxct is aborted and will be retried. More...
LockListPosition	lower_bound (UniversalLockId lock) const
	Analogous to std::lower_bound() for the given lock. More...
template<typename MCS_ADAPTOR >
ErrorCode	request_record_lock (MCS_ADAPTOR mcs_adaptor, storage::VolatilePagePointer page_id, RwLockableXctId *lock)
	If not yet acquired, acquires a record lock and adds an entry to this list, re-sorting part of the list if necessary to keep the sortedness. More...
template<typename MCS_ADAPTOR >
ErrorCode	batch_request_record_locks (MCS_ADAPTOR mcs_adaptor, storage::VolatilePagePointer page_id, uint32_t lock_count, RwLockableXctId **locks)
	Used to acquire many locks in a page at once. More...
template<typename MCS_ADAPTOR >
ErrorCode	request_page_lock (MCS_ADAPTOR mcs_adaptor, storage::Page *page)
	Acquires a page lock. More...
template<typename MCS_ADAPTOR >
ErrorCode	batch_request_page_locks (MCS_ADAPTOR mcs_adaptor, uint32_t lock_count, storage::Page **pages)
	The interface is same as the record version, but this one doesn't do much optimization. More...
template<typename MCS_ADAPTOR >
void	release_all_locks (MCS_ADAPTOR mcs_adaptor)
	Releases all locks that were acquired. More...
LockListPosition	get_or_add_entry (storage::VolatilePagePointer page_id, uintptr_t lock_addr, bool page_lock)
LockListPosition	batch_get_or_add_entries (storage::VolatilePagePointer page_id, uint32_t lock_count, uintptr_t *lock_addr, bool page_lock)
	Batched version of get_or_add_entry(). More...
const SysxctLockEntry *	get_array () const
SysxctLockEntry *	get_array ()
SysxctLockEntry *	get_entry (LockListPosition pos)
const SysxctLockEntry *	get_entry (LockListPosition pos) const
uint32_t	get_capacity () const
bool	is_full () const
	When this returns full, it's catastrophic. More...
LockListPosition	get_last_active_entry () const
bool	is_valid_entry (LockListPosition pos) const
bool	is_empty () const
void	assert_sorted () const __attribute__((always_inline))
	Inline definitions of SysxctLockList methods. More...
void	assert_sorted_impl () const
SysxctLockEntry *	begin ()
SysxctLockEntry *	end ()
const SysxctLockEntry *	cbegin () const
const SysxctLockEntry *	cend () const
LockListPosition	to_pos (const SysxctLockEntry *entry) const
LockListPosition	get_last_locked_entry () const
LockListPosition	calculate_last_locked_entry () const
	Calculate last_locked_entry_ by really checking the whole list. More...
LockListPosition	calculate_last_locked_entry_from (LockListPosition from) const
	Only searches among entries at or before "from". More...
void	assert_last_locked_entry () const
UniversalLockId	get_enclosing_max_lock_id () const
bool	is_try_mode_required (LockListPosition pos) const

Friends
struct	TestIsTryRequired
std::ostream &	operator<< (std::ostream &o, const SysxctLockList &v)

Member Enumeration Documentation

enum foedus::xct::SysxctLockList::Constants

Enumerator
kMaxSysxctLocks	Maximum number of locks one system transaction might take. In most cases just a few. The worst case is page-split where a sysxct takes a page-full of records.

Definition at line 170 of file sysxct_impl.hpp.

                 {
    kMaxSysxctLocks = 1 << 10,
  };

Constructor & Destructor Documentation

foedus::xct::SysxctLockList::SysxctLockList ( )

inline

Definition at line 179 of file sysxct_impl.hpp.

References init().

{ init(); }

Here is the call graph for this function:

foedus::xct::SysxctLockList::~SysxctLockList ( )

inline

Definition at line 180 of file sysxct_impl.hpp.

{}

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

delete

Member Function Documentation

void foedus::xct::SysxctLockList::assert_last_locked_entry ( ) const

inline

Definition at line 345 of file sysxct_impl.hpp.

References ASSERT_ND, and calculate_last_locked_entry().

Referenced by assert_sorted_impl(), and lower_bound().

                                        {
#ifndef NDEBUG
    LockListPosition correct = calculate_last_locked_entry();
    ASSERT_ND(correct == last_locked_entry_);
#endif  // NDEBUG
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::xct::SysxctLockList::assert_sorted ( ) const

inline

Inline definitions of SysxctLockList methods.

Definition at line 549 of file sysxct_impl.hpp.

References assert_sorted_impl().

Referenced by batch_get_or_add_entries(), clear_entries(), compress_entries(), and get_or_add_entry().

                                                {
  // In release mode, this code must be completely erased by compiler
#ifndef  NDEBUG
  assert_sorted_impl();
#endif  // NDEBUG
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::xct::SysxctLockList::assert_sorted_impl

(

)

const

Definition at line 78 of file sysxct_impl.cpp.

References assert_last_locked_entry(), ASSERT_ND, get_array(), get_last_active_entry(), foedus::storage::Page::get_volatile_page_id(), foedus::xct::kLockListPositionInvalid, foedus::xct::kNullUniversalLockId, foedus::storage::to_page(), and foedus::xct::to_universal_lock_id().

Referenced by assert_sorted().

                                              {
  assert_last_locked_entry();
  const SysxctLockEntry* array = get_array();
  ASSERT_ND(array[kLockListPositionInvalid].universal_lock_id_ == 0);
  ASSERT_ND(array[kLockListPositionInvalid].lock_ == kNullUniversalLockId);
  ASSERT_ND(array[kLockListPositionInvalid].mcs_block_ == 0);
  const LockListPosition last_active_entry = get_last_active_entry();
  for (LockListPosition pos = 2U; pos <= last_active_entry; ++pos) {
    ASSERT_ND(array[pos - 1U].universal_lock_id_ < array[pos].universal_lock_id_);
    ASSERT_ND(array[pos].universal_lock_id_ != 0);
    ASSERT_ND(array[pos].lock_ != kNullUniversalLockId);
    const storage::Page* page = storage::to_page(reinterpret_cast<void*>(array[pos].lock_));
    auto page_id = page->get_volatile_page_id();
    ASSERT_ND(array[pos].universal_lock_id_ == to_universal_lock_id(page_id, array[pos].lock_));
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

LockListPosition foedus::xct::SysxctLockList::batch_get_or_add_entries	(	storage::VolatilePagePointer	page_id,
		uint32_t	lock_count,
		uintptr_t *	lock_addr,
		bool	page_lock
	)

Batched version of get_or_add_entry().

Returns

position of the first entry that corresponds to any of the locks, either added or found. Returns kLockListPositionInvalid iff lock_count == 0.

Note

lock_addr does NOT have to be sorted. This function sorts it first (that's why it's not const param). However, you SHOULD give this method a sorted array if it's easy to do. This method first checks std::is_sorted() to skip sorting.

Definition at line 152 of file sysxct_impl.cpp.

References ASSERT_ND, assert_sorted(), get_last_active_entry(), get_or_add_entry(), foedus::xct::kLockListPositionInvalid, kMaxSysxctLocks, lower_bound(), foedus::xct::SysxctLockEntry::set(), foedus::xct::to_universal_lock_id(), foedus::xct::SysxctLockEntry::universal_lock_id_, and UNLIKELY.

                  {
  ASSERT_ND(lock_count);
  ASSERT_ND(get_last_active_entry() + lock_count <= kMaxSysxctLocks);
  if (UNLIKELY(get_last_active_entry() + lock_count > kMaxSysxctLocks)) {
    LOG(FATAL) << "SysxctLockList full. This must not happen";
  }
  if (lock_count == 0) {
    return kLockListPositionInvalid;
  }

  // Address order within the same page guarantees the Universal lock ID order.
  if (std::is_sorted(lock_addr, lock_addr + lock_count)) {
    DVLOG(3) << "Okay, sorted.";
  } else {
    // Most likely we hit this case for page locks (just 2 or 3 locks)
    // Otherwise something wrong...
    if (UNLIKELY(lock_count > 5U)) {
      LOG(INFO) << "Given array is not sorted. We have to sort it here. Is it intended??";
    }
    std::sort(lock_addr, lock_addr + lock_count);
    // If this is the majority case, the is_sorted() is a wasted cost (std::sort often
    // do something like this internally), but this should almost never happen. In that
    // case, std::is_sorted() is faster.
  }

  const UniversalLockId min_id = to_universal_lock_id(page_id, lock_addr[0]);
  const UniversalLockId max_id = to_universal_lock_id(page_id, lock_addr[lock_count - 1]);
  ASSERT_ND(min_id <= max_id);

  // We optimize for the case where this list has nothing in [min_lock_addr,max_lock_addr].
  // When this is not the case, we just call get_or_add_entry with for loop.
  // A large lock_count should mean page split sysxct, so this should never happen.

  const LockListPosition insert_pos = lower_bound(min_id);
  ASSERT_ND(insert_pos != kLockListPositionInvalid);
  if (insert_pos > last_active_entry_) {
    ASSERT_ND(insert_pos == last_active_entry_ + 1U);
    // Larger than all existing entries. This is easy. We just append all to the end.
  } else {
    const UniversalLockId next_id = array_[insert_pos].universal_lock_id_;
    ASSERT_ND(next_id >= min_id);  // lower_bound()'s contract
    if (next_id > max_id) {
      DVLOG(3) << "Okay, no overlap. Much easier.";
    } else {
      // This is unfortunate, but it happens.. especially with pessimisitic locks
      if (UNLIKELY(lock_count > 5U)) {
        DVLOG(0) << "Overlapped entry for a large batch. Well, unfortunate. but it happens.";
      }

      // Fall back to the slow path
      for (uint32_t i = 0; i < lock_count; ++i) {
        LockListPosition pos = get_or_add_entry(page_id, lock_addr[i], page_lock);
        ASSERT_ND(pos >= insert_pos);
      }
      return insert_pos;
    }
  }

  ASSERT_ND(insert_pos > last_active_entry_ || array_[insert_pos].universal_lock_id_ >= max_id);

  // Move existing entries at once, then set() in a tight for loop
  ASSERT_ND(last_active_entry_ + 1U >= insert_pos);
  const uint32_t move_count = last_active_entry_ + 1U - insert_pos;
  if (move_count > 0) {
    const uint64_t moved_bytes = sizeof(SysxctLockEntry) * move_count;
    std::memmove(array_ + insert_pos + lock_count, array_ + insert_pos, moved_bytes);
  }
  if (last_locked_entry_ >= insert_pos) {
    last_locked_entry_ += lock_count;
  }

  for (uint32_t i = 0; i < lock_count; ++i) {
    const UniversalLockId id = to_universal_lock_id(page_id, lock_addr[i]);
    array_[insert_pos + i].set(id, lock_addr[i], page_lock);
  }

  last_active_entry_ += lock_count;
  assert_sorted();
  return insert_pos;
}

Here is the call graph for this function:

template<typename MCS_ADAPTOR >

ErrorCode foedus::xct::SysxctLockList::batch_request_page_locks ( MCS_ADAPTOR  mcs_adaptor, uint32_t  lock_count, storage::Page **  pages  )

inline

The interface is same as the record version, but this one doesn't do much optimization.

We shouldn't frequently lock many pages in sysxct. However, at least this one locks the pages in UniversalLockId order to avoid deadlocks.

Definition at line 252 of file sysxct_impl.hpp.

References CHECK_ERROR_CODE, foedus::kErrorCodeOk, and request_page_lock().

                         {
    std::sort(pages, pages + lock_count, PageComparator());
    for (uint32_t i = 0; i < lock_count; ++i) {
      CHECK_ERROR_CODE(request_page_lock(mcs_adaptor, pages[i]));
    }
    return kErrorCodeOk;
  }

Here is the call graph for this function:

template<typename MCS_ADAPTOR >

ErrorCode foedus::xct::SysxctLockList::batch_request_record_locks ( MCS_ADAPTOR  mcs_adaptor, storage::VolatilePagePointer  page_id, uint32_t  lock_count, RwLockableXctId **  locks  )

inline

Used to acquire many locks in a page at once.

This reduces sorting cost.

Definition at line 230 of file sysxct_impl.hpp.

                             {
    uintptr_t* lock_addr = reinterpret_cast<uintptr_t*>(locks);
    return batch_request_locks_general(mcs_adaptor, page_id, lock_count, lock_addr, false);
  }

SysxctLockEntry* foedus::xct::SysxctLockList::begin ( )

inline

Definition at line 316 of file sysxct_impl.hpp.

Referenced by release_all_locks().

{ return array_ + 1U; }

Here is the caller graph for this function:

LockListPosition foedus::xct::SysxctLockList::calculate_last_locked_entry ( ) const

inline

Calculate last_locked_entry_ by really checking the whole list.

Usually for sanity checks

Definition at line 333 of file sysxct_impl.hpp.

References calculate_last_locked_entry_from().

Referenced by assert_last_locked_entry().

                                                       {
    return calculate_last_locked_entry_from(last_active_entry_);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

LockListPosition foedus::xct::SysxctLockList::calculate_last_locked_entry_from ( LockListPosition  from ) const

inline

Only searches among entries at or before "from".

Definition at line 337 of file sysxct_impl.hpp.

References foedus::xct::kLockListPositionInvalid.

Referenced by calculate_last_locked_entry().

                                                                                 {
    for (LockListPosition pos = from; pos > kLockListPositionInvalid; --pos) {
      if (array_[pos].is_locked()) {
        return pos;
      }
    }
    return kLockListPositionInvalid;
  }

Here is the caller graph for this function:

const SysxctLockEntry* foedus::xct::SysxctLockList::cbegin ( ) const

inline

Definition at line 318 of file sysxct_impl.hpp.

{ return array_ + 1U; }

const SysxctLockEntry* foedus::xct::SysxctLockList::cend ( ) const

inline

Definition at line 319 of file sysxct_impl.hpp.

{ return array_ + 1U + last_active_entry_; }

void foedus::xct::SysxctLockList::clear_entries ( UniversalLockId  enclosing_max_lock_id )

inline

Remove all entries.

This is used when a sysxct starts a fresh new transaction, not retry.

Definition at line 193 of file sysxct_impl.hpp.

References ASSERT_ND, assert_sorted(), and foedus::xct::kLockListPositionInvalid.

                                                            {
    ASSERT_ND(last_locked_entry_ == kLockListPositionInvalid);
    assert_sorted();
    clear_no_assert(enclosing_max_lock_id);
  }

Here is the call graph for this function:

void foedus::xct::SysxctLockList::compress_entries

(

UniversalLockId

enclosing_max_lock_id

)

Unlike clear_entries(), this is used when a sysxct is aborted and will be retried.

We 'inherit' some entries (although all of them must be released) to help guide next runs.

Definition at line 237 of file sysxct_impl.cpp.

References ASSERT_ND, assert_sorted(), foedus::xct::kLockListPositionInvalid, and foedus::xct::SysxctLockEntry::used_in_this_run_.

                                                                           {
  assert_sorted();
  ASSERT_ND(last_locked_entry_ == kLockListPositionInvalid);
  LockListPosition next_compressed_pos = 1U;
  for (LockListPosition pos = 1U; pos <= last_active_entry_; ++pos) {
    ASSERT_ND(!array_[pos].is_locked());
    ASSERT_ND(pos >= next_compressed_pos);
    if (array_[pos].used_in_this_run_) {
      // Okay, let's inherit this entry
      if (pos != next_compressed_pos) {
        array_[next_compressed_pos] = array_[pos];
      }
      array_[next_compressed_pos].used_in_this_run_ = false;
      ++next_compressed_pos;
    }
  }
  last_active_entry_ = next_compressed_pos - 1U;
  enclosing_max_lock_id_ = enclosing_max_lock_id;
  assert_sorted();
}

Here is the call graph for this function:

SysxctLockEntry* foedus::xct::SysxctLockList::end ( )

inline

Definition at line 317 of file sysxct_impl.hpp.

Referenced by release_all_locks().

{ return array_ + 1U + last_active_entry_; }

Here is the caller graph for this function:

const SysxctLockEntry* foedus::xct::SysxctLockList::get_array ( ) const

inline

Definition at line 293 of file sysxct_impl.hpp.

Referenced by assert_sorted_impl().

{ return array_; }

Here is the caller graph for this function:

SysxctLockEntry* foedus::xct::SysxctLockList::get_array ( )

inline

Definition at line 294 of file sysxct_impl.hpp.

{ return array_; }

uint32_t foedus::xct::SysxctLockList::get_capacity ( ) const

inline

Definition at line 303 of file sysxct_impl.hpp.

References kMaxSysxctLocks.

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

{ return kMaxSysxctLocks; }

Here is the caller graph for this function:

UniversalLockId foedus::xct::SysxctLockList::get_enclosing_max_lock_id ( ) const

inline

Definition at line 352 of file sysxct_impl.hpp.

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

{ return enclosing_max_lock_id_; }

Here is the caller graph for this function:

SysxctLockEntry* foedus::xct::SysxctLockList::get_entry ( LockListPosition  pos )

inline

Definition at line 295 of file sysxct_impl.hpp.

References ASSERT_ND, and is_valid_entry().

Referenced by is_try_mode_required().

                                                   {
    ASSERT_ND(is_valid_entry(pos));
    return array_ + pos;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

const SysxctLockEntry* foedus::xct::SysxctLockList::get_entry ( LockListPosition  pos ) const

inline

Definition at line 299 of file sysxct_impl.hpp.

References ASSERT_ND, and is_valid_entry().

                                                               {
    ASSERT_ND(is_valid_entry(pos));
    return array_ + pos;
  }

Here is the call graph for this function:

LockListPosition foedus::xct::SysxctLockList::get_last_active_entry ( ) const

inline

Definition at line 306 of file sysxct_impl.hpp.

Referenced by assert_sorted_impl(), batch_get_or_add_entries(), foedus::xct::operator<<(), and to_pos().

{ return last_active_entry_; }

Here is the caller graph for this function:

LockListPosition foedus::xct::SysxctLockList::get_last_locked_entry ( ) const

inline

Returns

largest index of entries that are already locked. kLockListPositionInvalid if no entry is locked.

Definition at line 331 of file sysxct_impl.hpp.

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

{ return last_locked_entry_; }

Here is the caller graph for this function:

LockListPosition foedus::xct::SysxctLockList::get_or_add_entry	(	storage::VolatilePagePointer	page_id,
		uintptr_t	lock_addr,
		bool	page_lock
	)

Returns

position of the entry that corresponds to the lock. either added or found. Never returns kLockListPositionInvalid.

Definition at line 103 of file sysxct_impl.cpp.

References ASSERT_ND, assert_sorted(), is_full(), foedus::xct::kLockListPositionInvalid, lower_bound(), foedus::xct::SysxctLockEntry::set(), foedus::xct::to_universal_lock_id(), and UNLIKELY.

Referenced by batch_get_or_add_entries().

                  {
  ASSERT_ND(!is_full());
  if (UNLIKELY(is_full())) {
    LOG(FATAL) << "SysxctLockList full. This must not happen";
  }
  const UniversalLockId id = to_universal_lock_id(page_id, lock_addr);

  // Easy case? (lock >= the last entry)
  LockListPosition insert_pos = lower_bound(id);
  ASSERT_ND(insert_pos != kLockListPositionInvalid);

  // Larger than all existing entries? Append to the last!
  if (insert_pos > last_active_entry_) {
    ASSERT_ND(insert_pos == last_active_entry_ + 1U);
    LockListPosition new_pos = issue_new_position();
    array_[new_pos].set(id, lock_addr, page_lock);
    ASSERT_ND(new_pos == insert_pos);
    return new_pos;
  }

  // lower_bound returns the first entry that is NOT less than. is it equal?
  ASSERT_ND(array_[insert_pos].universal_lock_id_ >= id);
  if (array_[insert_pos].universal_lock_id_ == id) {
    // Found existing!
    return insert_pos;
  }

  DVLOG(1) << "not an easy case. We need to adjust the order. This is costly!";
  ASSERT_ND(insert_pos <= last_active_entry_);  // otherwise we went into the 1st branch
  ASSERT_ND(array_[insert_pos].universal_lock_id_ > id);  // if ==, we went into the 2nd branch
  ASSERT_ND(insert_pos == 1U || array_[insert_pos - 1U].universal_lock_id_ < id);

  LockListPosition new_last_pos = issue_new_position();
  ASSERT_ND(new_last_pos > insert_pos);
  uint64_t moved_bytes = sizeof(SysxctLockEntry) * (new_last_pos - insert_pos);
  std::memmove(array_ + insert_pos + 1U, array_ + insert_pos, moved_bytes);
  DVLOG(1) << "Re-sorted. hope this won't happen often";
  array_[insert_pos].set(id, lock_addr, page_lock);
  if (last_locked_entry_ >= insert_pos) {
    ++last_locked_entry_;
  }

  assert_sorted();
  return insert_pos;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::xct::SysxctLockList::init ( )

inline

Definition at line 186 of file sysxct_impl.hpp.

References foedus::xct::kNullUniversalLockId.

Referenced by foedus::xct::SysxctWorkspace::init(), and SysxctLockList().

              {
    clear_no_assert(kNullUniversalLockId);
  }

Here is the caller graph for this function:

bool foedus::xct::SysxctLockList::is_empty ( ) const

inline

Definition at line 310 of file sysxct_impl.hpp.

References foedus::xct::kLockListPositionInvalid.

{ return last_active_entry_ == kLockListPositionInvalid; }

bool foedus::xct::SysxctLockList::is_full ( ) const

inline

When this returns full, it's catastrophic.

Definition at line 305 of file sysxct_impl.hpp.

References kMaxSysxctLocks.

Referenced by get_or_add_entry().

{ return last_active_entry_ == kMaxSysxctLocks; }

Here is the caller graph for this function:

bool foedus::xct::SysxctLockList::is_try_mode_required ( LockListPosition  pos ) const

inline

Returns

whether the lock must be taken in try mode

Definition at line 354 of file sysxct_impl.hpp.

References get_entry(), and foedus::xct::SysxctLockEntry::universal_lock_id_.

                                                        {
    const SysxctLockEntry* entry = get_entry(pos);
    // If the enclosing thread took a lock after this, we must be careful.
    if (entry->universal_lock_id_ <= enclosing_max_lock_id_) {
      return true;
    }

    // If this list contains an already-taken lock after this, we must be careful.
    if (pos <= last_locked_entry_) {
      return true;
    }

    return false;
  }

Here is the call graph for this function:

bool foedus::xct::SysxctLockList::is_valid_entry ( LockListPosition  pos ) const

inline

Definition at line 307 of file sysxct_impl.hpp.

References foedus::xct::kLockListPositionInvalid.

Referenced by get_entry().

                                                  {
    return pos != kLockListPositionInvalid && pos <= last_active_entry_;
  }

Here is the caller graph for this function:

LockListPosition foedus::xct::SysxctLockList::lower_bound

(

UniversalLockId

lock

)

const

Analogous to std::lower_bound() for the given lock.

Data manipulation (search/add/etc)

Returns

Index of the fist entry whose lock_ is not less than lock. If no such entry, last_active_entry_ + 1U, whether last_active_entry_ is 0 or not. Thus the return value is always >0. This is to immitate std::lower_bound's behavior.

Definition at line 98 of file sysxct_impl.cpp.

References assert_last_locked_entry().

Referenced by batch_get_or_add_entries(), and get_or_add_entry().

                                                                       {
  assert_last_locked_entry();
  return lock_lower_bound<SysxctLockList, SysxctLockEntry>(*this, lock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

delete

template<typename MCS_ADAPTOR >

void foedus::xct::SysxctLockList::release_all_locks ( MCS_ADAPTOR  mcs_adaptor )

inline

Releases all locks that were acquired.

Entries are left as they were. You should then call clear_entries() or compress_entries().

Definition at line 647 of file sysxct_impl.hpp.

References begin(), end(), foedus::storage::Page::get_header(), foedus::xct::kLockListPositionInvalid, foedus::storage::PageVersion::lock_, foedus::storage::PageHeader::page_version_, foedus::xct::McsWwImpl< ADAPTOR >::release(), and foedus::xct::McsImpl< ADAPTOR, RW_BLOCK >::release_rw_writer().

                                                                     {
  for (auto* entry = begin(); entry != end(); ++entry) {
    if (!entry->is_locked()) {
      continue;
    }
    if (entry->page_lock_) {
      McsWwImpl< MCS_ADAPTOR > impl(mcs_adaptor);
      storage::Page* page = entry->get_as_page_lock();
      McsWwLock* lock_addr = &page->get_header().page_version_.lock_;
      impl.release(lock_addr, entry->mcs_block_);
      entry->mcs_block_ = 0;
    } else {
      McsImpl< MCS_ADAPTOR, typename MCS_ADAPTOR::ThisRwBlock > impl(mcs_adaptor);
      McsRwLock* lock_addr = &entry->get_as_record_lock()->lock_;
      impl.release_rw_writer(lock_addr, entry->mcs_block_);
      entry->mcs_block_ = 0;
    }
  }
  last_locked_entry_ = kLockListPositionInvalid;
}

Here is the call graph for this function:

template<typename MCS_ADAPTOR >

ErrorCode foedus::xct::SysxctLockList::request_page_lock ( MCS_ADAPTOR  mcs_adaptor, storage::Page *  page  )

inline

Acquires a page lock.

Definition at line 241 of file sysxct_impl.hpp.

References foedus::storage::Page::get_volatile_page_id().

Referenced by batch_request_page_locks().

                                                                          {
    uintptr_t lock_addr = reinterpret_cast<uintptr_t>(page);
    return request_lock_general(mcs_adaptor, page->get_volatile_page_id(), lock_addr, true);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename MCS_ADAPTOR >

ErrorCode foedus::xct::SysxctLockList::request_record_lock ( MCS_ADAPTOR  mcs_adaptor, storage::VolatilePagePointer  page_id, RwLockableXctId *  lock  )

inline

If not yet acquired, acquires a record lock and adds an entry to this list, re-sorting part of the list if necessary to keep the sortedness.

If there is an existing entry for the lock, it resuses the entry.

Postcondition

Either the lock is taken or returns an error

Definition at line 220 of file sysxct_impl.hpp.

                           {
    uintptr_t lock_addr = reinterpret_cast<uintptr_t>(lock);
    return request_lock_general(mcs_adaptor, page_id, lock_addr, false);
  }

LockListPosition foedus::xct::SysxctLockList::to_pos ( const SysxctLockEntry *  entry ) const

inline

Definition at line 320 of file sysxct_impl.hpp.

References ASSERT_ND, and get_last_active_entry().

                                                              {
    ASSERT_ND(entry > array_);
    LockListPosition pos = entry - array_;
    ASSERT_ND(pos <= get_last_active_entry());
    return pos;
  }

Here is the call graph for this function:

Friends And Related Function Documentation

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

friend

Definition at line 53 of file sysxct_impl.cpp.

                                                               {
  o << "<SysxctLockList>"
    << "<Capacity>" << v.get_capacity() << "</Capacity>"
    << "<LastActiveEntry>" << v.get_last_active_entry() << "</LastActiveEntry>"
    << "<LastLockedEntry>" << v.get_last_locked_entry() << "</LastLockedEntry>"
    << "<EnclosingMaxLockId>" << v.get_enclosing_max_lock_id() << "</EnclosingMaxLockId>";
  const uint32_t kMaxShown = 32U;
  for (auto i = 1U; i <= std::min(v.last_active_entry_, kMaxShown); ++i) {
    o << std::endl << v.array_[i];
  }
  if (v.last_active_entry_ > kMaxShown) {
    o << std::endl << "<too_many />";
  }
  o << "</SysxctLockList>";
  return o;
}

friend struct TestIsTryRequired

friend

Definition at line 168 of file sysxct_impl.hpp.

---

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

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