foedus::xct::XctManagerPimpl Class Reference

Pimpl object of XctManager. More...

Detailed Description

Pimpl object of XctManager.

A private pimpl object for XctManager. Do not include this header from a client program unless you know what you are doing.

Definition at line 100 of file xct_manager_pimpl.hpp.

#include <xct_manager_pimpl.hpp>

Inheritance diagram for foedus::xct::XctManagerPimpl:

Collaboration diagram for foedus::xct::XctManagerPimpl:

Public Member Functions
	XctManagerPimpl ()=delete
	XctManagerPimpl (Engine *engine)
ErrorStack	initialize_once () override
ErrorStack	uninitialize_once () override
Epoch	get_current_global_epoch () const
Epoch	get_requested_global_epoch () const
Epoch	get_current_global_epoch_weak () const
ErrorCode	begin_xct (thread::Thread *context, IsolationLevel isolation_level)
	User transactions related methods. More...
ErrorCode	precommit_xct (thread::Thread *context, Epoch *commit_epoch)
	This is the gut of commit protocol. More...
ErrorCode	abort_xct (thread::Thread *context)
ErrorCode	wait_for_commit (Epoch commit_epoch, int64_t wait_microseconds)
void	set_requested_global_epoch (Epoch request)
void	advance_current_global_epoch ()
void	wait_for_current_global_epoch (Epoch target_epoch, int64_t wait_microseconds)
void	wakeup_epoch_chime_thread ()
ErrorCode	precommit_xct_readonly (thread::Thread *context, Epoch *commit_epoch)
	precommit_xct() if the transaction is read-only More...
ErrorCode	precommit_xct_readwrite (thread::Thread *context, Epoch *commit_epoch)
	precommit_xct() if the transaction is read-write More...
bool	precommit_xct_lock_track_write (thread::Thread *context, WriteXctAccess *entry)
	used from precommit_xct_lock() to track moved record More...
bool	precommit_xct_verify_track_read (thread::Thread *context, ReadXctAccess *entry)
	used from verification methods to track moved record More...
ErrorCode	precommit_xct_lock (thread::Thread *context, XctId *max_xct_id)
	Phase 1 of precommit_xct() More...
ErrorCode	precommit_xct_lock_batch_track_moved (thread::Thread *context)
	Subroutine of precommit_xct_lock to track most of moved records in write-set. More...
bool	precommit_xct_verify_readonly (thread::Thread *context, Epoch *commit_epoch)
	Phase 2 of precommit_xct() for read-only case. More...
bool	precommit_xct_verify_readwrite (thread::Thread *context, XctId *max_xct_id)
	Phase 2 of precommit_xct() for read-write case. More...
bool	precommit_xct_verify_pointer_set (thread::Thread *context)
	Returns false if there is any pointer set conflict. More...
bool	precommit_xct_verify_page_version_set (thread::Thread *context)
	Returns false if there is any page version conflict. More...
void	precommit_xct_apply (thread::Thread *context, XctId max_xct_id, Epoch *commit_epoch)
	Phase 3 of precommit_xct() More...
void	release_and_clear_all_current_locks (thread::Thread *context)
	unlocking all acquired locks, used when commit/abort. More...
bool	precommit_xct_acquire_writer_lock (thread::Thread *context, WriteXctAccess *write)
void	precommit_xct_sort_access (thread::Thread *context)
bool	precommit_xct_try_acquire_writer_locks (thread::Thread *context)
bool	precommit_xct_request_writer_lock (thread::Thread *context, WriteXctAccess *write)
void	handle_epoch_chime ()
	Main routine for epoch_chime_thread_. More...
void	handle_epoch_chime_wait_grace_period (Epoch grace_epoch)
	Makes sure all worker threads will commit with an epoch larger than grace_epoch. More...
bool	is_stop_requested () const
void	pause_accepting_xct ()
	Pause all begin_xct until you call resume_accepting_xct() More...
void	resume_accepting_xct ()
	Make sure you call this after pause_accepting_xct(). More...
void	wait_until_resume_accepting_xct (thread::Thread *context)
Public Member Functions inherited from foedus::DefaultInitializable
	DefaultInitializable ()
virtual	~DefaultInitializable ()
	DefaultInitializable (const DefaultInitializable &)=delete
DefaultInitializable &	operator= (const DefaultInitializable &)=delete
ErrorStack	initialize () override final
	Typical implementation of Initializable::initialize() that provides initialize-once semantics. More...
ErrorStack	uninitialize () override final
	Typical implementation of Initializable::uninitialize() that provides uninitialize-once semantics. More...
bool	is_initialized () const override final
	Returns whether the object has been already initialized or not. More...
Public Member Functions inherited from foedus::Initializable
virtual	~Initializable ()

Public Attributes
Engine *const	engine_
XctManagerControlBlock *	control_block_
std::thread	epoch_chime_thread_
	This thread keeps advancing the current_global_epoch_. More...

Constructor & Destructor Documentation

foedus::xct::XctManagerPimpl::XctManagerPimpl ( )

delete

foedus::xct::XctManagerPimpl::XctManagerPimpl ( Engine *  engine )

inlineexplicit

Definition at line 103 of file xct_manager_pimpl.hpp.

: engine_(engine) {}

Member Function Documentation

ErrorCode foedus::xct::XctManagerPimpl::abort_xct

(

thread::Thread *

context

)

Definition at line 954 of file xct_manager_pimpl.cpp.

References foedus::xct::RetrospectiveLockList::clear_entries(), foedus::xct::RetrospectiveLockList::construct(), foedus::xct::Xct::deactivate(), foedus::log::ThreadLogBuffer::discard_current_xct_log(), foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_read_set(), foedus::xct::Xct::get_read_set_size(), foedus::xct::Xct::get_retrospective_lock_list(), foedus::xct::Xct::get_rll_threshold_for_this_xct(), foedus::thread::Thread::get_thread_id(), foedus::thread::Thread::get_thread_log_buffer(), foedus::xct::RwLockableXctId::hotter(), foedus::xct::Xct::is_active(), foedus::xct::Xct::is_enable_rll_for_this_xct(), foedus::kErrorCodeOk, foedus::kErrorCodeXctNoXct, foedus::xct::ReadXctAccess::observed_owner_id_, foedus::xct::RecordXctAccess::owner_id_address_, release_and_clear_all_current_locks(), and foedus::xct::RwLockableXctId::xct_id_.

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

                                                          {
  Xct& current_xct = context->get_current_xct();
  if (!current_xct.is_active()) {
    return kErrorCodeXctNoXct;
  }
  DVLOG(1) << *context << " Aborted transaction in thread-" << context->get_thread_id();


  // The abort was probably due to read-set verification failure, either in lock()'s
  // 'related_read' check or in verify(). To handle both cases at once, we re-check
  // all read-sets here and make violating ones hotter.
  // This might sound like a bit of wasted effort, but anyway aborts must be reasonably
  // infrequent (otherwise we are screwed!) so this doesn't add too much.
  // Rather, we want to make sure we surely make them hotter.
  // Actually, I spent half a day to figure out why a page doesn't become hot despite
  // lots of aborts! (A: lock()'s related_read check forgot to make it hotter!)
  ReadXctAccess*          read_set = current_xct.get_read_set();
  const uint32_t          read_set_size = current_xct.get_read_set_size();
  for (uint32_t i = 0; i < read_set_size; ++i) {
    ReadXctAccess& access = read_set[i];
    if (access.observed_owner_id_ != access.owner_id_address_->xct_id_) {
      access.owner_id_address_->hotter(context);
    }
  }

  // When we abort, whether in precommit or via user's explicit abort, we construct RLL.
  // Abort may happen due to try-failure in reads, so we now put this in here, not precommit.
  // One drawback is that we can't check the "cause" of the abort.
  // We should probably construct RLL only in the case of race-abort.
  // So, we might revist this choice.
  if (current_xct.is_enable_rll_for_this_xct()) {
    const uint32_t threshold = current_xct.get_rll_threshold_for_this_xct();
    current_xct.get_retrospective_lock_list()->construct(context, threshold);
  } else {
    current_xct.get_retrospective_lock_list()->clear_entries();
  }

  release_and_clear_all_current_locks(context);
  current_xct.deactivate();
  context->get_thread_log_buffer().discard_current_xct_log();
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::xct::XctManagerPimpl::advance_current_global_epoch

(

)

Definition at line 255 of file xct_manager_pimpl.cpp.

References foedus::soc::SharedPolling::acquire_ticket(), control_block_, foedus::xct::XctManagerControlBlock::current_global_epoch_advanced_, get_current_global_epoch(), foedus::Epoch::one_more(), set_requested_global_epoch(), foedus::soc::SharedPolling::wait(), and wakeup_epoch_chime_thread().

Referenced by foedus::xct::XctManager::advance_current_global_epoch().

                                                   {
  Epoch now = get_current_global_epoch();
  Epoch request = now.one_more();
  LOG(INFO) << "Requesting to immediately advance epoch. request=" << request << "...";
  set_requested_global_epoch(request);
  while (get_current_global_epoch() < request) {
    wakeup_epoch_chime_thread();
    {
      uint64_t demand = control_block_->current_global_epoch_advanced_.acquire_ticket();
      if (get_current_global_epoch() < request) {
        control_block_->current_global_epoch_advanced_.wait(demand);
      }
    }
  }

  LOG(INFO) << "epoch advanced. current_global_epoch_=" << get_current_global_epoch();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::xct::XctManagerPimpl::begin_xct	(	thread::Thread *	context,
		IsolationLevel	isolation_level
	)

User transactions related methods.

Definition at line 307 of file xct_manager_pimpl.cpp.

References foedus::xct::Xct::activate(), ASSERT_ND, control_block_, foedus::thread::Thread::get_current_xct(), foedus::xct::RetrospectiveLockList::get_last_active_entry(), foedus::xct::Xct::get_lock_free_write_set_size(), foedus::xct::Xct::get_mcs_block_current(), foedus::log::ThreadLogBuffer::get_offset_committed(), foedus::log::ThreadLogBuffer::get_offset_tail(), foedus::xct::Xct::get_read_set_size(), foedus::xct::Xct::get_retrospective_lock_list(), foedus::thread::Thread::get_thread_log_buffer(), foedus::xct::Xct::get_write_set_size(), foedus::xct::Xct::is_active(), foedus::kErrorCodeOk, foedus::kErrorCodeXctAlreadyRunning, foedus::xct::XctManagerControlBlock::new_transaction_paused_, UNLIKELY, and wait_until_resume_accepting_xct().

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

                                                                                          {
  Xct& current_xct = context->get_current_xct();
  if (current_xct.is_active()) {
    return kErrorCodeXctAlreadyRunning;
  }
  if (UNLIKELY(control_block_->new_transaction_paused_.load())) {
    wait_until_resume_accepting_xct(context);
  }
  DVLOG(1) << *context << " Began new transaction."
    << " RLL size=" << current_xct.get_retrospective_lock_list()->get_last_active_entry();
  current_xct.activate(isolation_level);
  ASSERT_ND(current_xct.get_mcs_block_current() == 0);
  ASSERT_ND(context->get_thread_log_buffer().get_offset_tail()
    == context->get_thread_log_buffer().get_offset_committed());
  ASSERT_ND(current_xct.get_read_set_size() == 0);
  ASSERT_ND(current_xct.get_write_set_size() == 0);
  ASSERT_ND(current_xct.get_lock_free_write_set_size() == 0);
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Epoch foedus::xct::XctManagerPimpl::get_current_global_epoch ( ) const

inline

Definition at line 107 of file xct_manager_pimpl.hpp.

References control_block_, and foedus::xct::XctManagerControlBlock::current_global_epoch_.

Referenced by advance_current_global_epoch(), foedus::xct::XctManager::get_current_global_epoch(), foedus::xct::XctManager::get_current_grace_epoch(), handle_epoch_chime(), handle_epoch_chime_wait_grace_period(), initialize_once(), wait_for_commit(), and wait_for_current_global_epoch().

                                               {
    return Epoch(control_block_->current_global_epoch_.load());
  }

Here is the caller graph for this function:

Epoch foedus::xct::XctManagerPimpl::get_current_global_epoch_weak ( ) const

inline

Definition at line 113 of file xct_manager_pimpl.hpp.

References control_block_, and foedus::xct::XctManagerControlBlock::current_global_epoch_.

Referenced by foedus::xct::XctManager::get_current_global_epoch_weak(), foedus::xct::XctManager::get_current_grace_epoch_weak(), and precommit_xct_readwrite().

                                                    {
    return Epoch(control_block_->current_global_epoch_.load(std::memory_order_relaxed));
  }

Here is the caller graph for this function:

Epoch foedus::xct::XctManagerPimpl::get_requested_global_epoch ( ) const

inline

Definition at line 110 of file xct_manager_pimpl.hpp.

References control_block_, and foedus::xct::XctManagerControlBlock::requested_global_epoch_.

Referenced by handle_epoch_chime(), and set_requested_global_epoch().

                                                 {
    return Epoch(control_block_->requested_global_epoch_.load());
  }

Here is the caller graph for this function:

void foedus::xct::XctManagerPimpl::handle_epoch_chime

(

)

Main routine for epoch_chime_thread_.

Epoch Chime related methods.

This method keeps advancing global_epoch with the interval configured in XctOptions. This method exits when this object's uninitialize() is called.

Definition at line 135 of file xct_manager_pimpl.cpp.

References foedus::soc::SharedPolling::acquire_ticket(), ASSERT_ND, control_block_, foedus::xct::XctManagerControlBlock::current_global_epoch_, foedus::xct::XctManagerControlBlock::current_global_epoch_advanced_, engine_, foedus::xct::XctOptions::epoch_advance_interval_ms_, foedus::xct::XctManagerControlBlock::epoch_chime_wakeup_, get_current_global_epoch(), foedus::Engine::get_log_manager(), foedus::Engine::get_options(), get_requested_global_epoch(), handle_epoch_chime_wait_grace_period(), foedus::DefaultInitializable::is_initialized(), foedus::Engine::is_master(), is_stop_requested(), foedus::soc::kDefaultPollingSpins, foedus::assorted::memory_fence_acquire(), foedus::assorted::memory_fence_release(), foedus::Epoch::one_less(), foedus::Epoch::one_more(), foedus::soc::SharedPolling::signal(), SPINLOCK_WHILE, foedus::soc::SharedPolling::timedwait(), foedus::Epoch::value(), foedus::log::LogManager::wakeup_loggers(), and foedus::EngineOptions::xct_.

Referenced by initialize_once().

                                         {
  LOG(INFO) << "epoch_chime_thread started.";
  ASSERT_ND(engine_->is_master());
  // Wait until all the other initializations are done.
  SPINLOCK_WHILE(!is_stop_requested() && !is_initialized()) {
    assorted::memory_fence_acquire();
  }
  uint64_t interval_microsec = engine_->get_options().xct_.epoch_advance_interval_ms_ * 1000ULL;
  LOG(INFO) << "epoch_chime_thread now starts processing. interval_microsec=" << interval_microsec;
  while (!is_stop_requested()) {
    {
      uint64_t demand = control_block_->epoch_chime_wakeup_.acquire_ticket();
      if (is_stop_requested()) {
        break;
      }
      if (get_requested_global_epoch() <= get_current_global_epoch())  {  // otherwise no sleep
        bool signaled = control_block_->epoch_chime_wakeup_.timedwait(
          demand,
          interval_microsec,
          soc::kDefaultPollingSpins,
          interval_microsec);
        VLOG(1) << "epoch_chime_thread. wokeup with " << (signaled ? "signal" : "timeout");
      }
    }
    if (is_stop_requested()) {
      break;
    }
    VLOG(1) << "epoch_chime_thread. current_global_epoch_=" << get_current_global_epoch();
    ASSERT_ND(get_current_global_epoch().is_valid());

    // Before advanding the epoch, we have to make sure there is no thread that might commit
    // with previous epoch.
    Epoch grace_epoch = get_current_global_epoch().one_less();
    handle_epoch_chime_wait_grace_period(grace_epoch);
    if (is_stop_requested()) {
      break;
    }

    {
      // soc::SharedMutexScope scope(control_block_->current_global_epoch_advanced_.get_mutex());
      // There is only one thread (this) that might update current_global_epoch_, so
      // no mutex needed. just set it and put fence.
      control_block_->current_global_epoch_ = get_current_global_epoch().one_more().value();
      assorted::memory_fence_release();
      control_block_->current_global_epoch_advanced_.signal();
    }
    engine_->get_log_manager()->wakeup_loggers();
  }
  LOG(INFO) << "epoch_chime_thread ended.";
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::xct::XctManagerPimpl::handle_epoch_chime_wait_grace_period

(

Epoch

grace_epoch

)

Makes sure all worker threads will commit with an epoch larger than grace_epoch.

Definition at line 186 of file xct_manager_pimpl.cpp.

References ASSERT_ND, foedus::debugging::StopWatch::elapsed_ms(), foedus::debugging::StopWatch::elapsed_ns(), engine_, get_current_global_epoch(), foedus::thread::ThreadPool::get_group_ref(), foedus::thread::ThreadGroupRef::get_min_in_commit_epoch(), foedus::Engine::get_soc_count(), foedus::Engine::get_thread_pool(), foedus::Engine::is_master(), is_stop_requested(), foedus::Epoch::is_valid(), foedus::Epoch::one_more(), SPINLOCK_WHILE, and foedus::debugging::StopWatch::stop().

Referenced by handle_epoch_chime().

                                                                            {
  ASSERT_ND(engine_->is_master());
  ASSERT_ND(grace_epoch.one_more() == get_current_global_epoch());

  VLOG(1) << "XctManager waiting until all worker threads exit grace_epoch:" << grace_epoch;
  debugging::StopWatch watch;

  // In most cases, all workers have already switched to the current epoch long before.
  // Quickly check it, then really wait if there is suspicious one.
  thread::ThreadPool* pool = engine_->get_thread_pool();
  uint16_t nodes = engine_->get_soc_count();
  for (uint16_t node = 0; node < nodes; ++node) {
    // Check all threads' in-commit epoch now.
    // We might add a background thread in each SOC to avoid checking too many threads
    // in the master engine, but anyway this happens only once in tens of milliseconds.
    thread::ThreadGroupRef* group = pool->get_group_ref(node);

    // @spinlock until the long-running transaction exits.
    const uint32_t kSpins = 1 << 12;  // some number of spins first, then sleep.
    uint32_t spins = 0;
    SPINLOCK_WHILE(!is_stop_requested()) {
      Epoch min_epoch = group->get_min_in_commit_epoch();
      if (!min_epoch.is_valid() || min_epoch > grace_epoch) {
        break;
      }
      ++spins;
      if (spins == 1U) {
        // first spin.
        VLOG(0) << "Interesting, node-" << node << " has some thread that is still running "
          << "epoch-" << grace_epoch << ". we have to wait before advancing epoch. min_epoch="
          << min_epoch;
      } else if (spins >= kSpins) {
        if (spins == kSpins) {
          LOG(INFO) << "node-" << node << " has some thread that is running "
            << "epoch-" << grace_epoch << " for long time. we are still waiting before advancing"
            << " epoch. min_epoch=" << min_epoch;
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
      }
    }
  }

  watch.stop();
  VLOG(1) << "grace_epoch-" << grace_epoch << " guaranteed. took " << watch.elapsed_ns() << "ns";
  if (watch.elapsed_ms() > 10) {
    LOG(INFO) << "Very interesting, grace_epoch-" << grace_epoch << " took "
      << watch.elapsed_ms() << "ms to be guaranteed. Most likely there was a long-running xct";
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::xct::XctManagerPimpl::initialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 84 of file xct_manager_pimpl.cpp.

References ASSERT_ND, control_block_, foedus::xct::XctManagerControlBlock::current_global_epoch_, engine_, foedus::xct::XctManagerControlBlock::epoch_chime_terminate_requested_, epoch_chime_thread_, ERROR_STACK, get_current_global_epoch(), foedus::soc::SharedMemoryRepo::get_global_memory_anchors(), foedus::savepoint::SavepointManager::get_initial_current_epoch(), foedus::Engine::get_savepoint_manager(), foedus::soc::SocManager::get_shared_memory_repo(), foedus::Engine::get_soc_manager(), foedus::Engine::get_storage_manager(), handle_epoch_chime(), foedus::xct::XctManagerControlBlock::initialize(), foedus::storage::StorageManager::is_initialized(), foedus::Engine::is_master(), foedus::kErrorCodeDepedentModuleUnavailableInit, foedus::kRetOk, foedus::xct::XctManagerControlBlock::requested_global_epoch_, foedus::Epoch::value(), and foedus::soc::GlobalMemoryAnchors::xct_manager_memory_.

                                            {
  LOG(INFO) << "Initializing XctManager..";
  if (!engine_->get_storage_manager()->is_initialized()) {
    return ERROR_STACK(kErrorCodeDepedentModuleUnavailableInit);
  }
  soc::SharedMemoryRepo* memory_repo = engine_->get_soc_manager()->get_shared_memory_repo();
  control_block_ = memory_repo->get_global_memory_anchors()->xct_manager_memory_;

  if (engine_->is_master()) {
    control_block_->initialize();
    control_block_->current_global_epoch_
      = engine_->get_savepoint_manager()->get_initial_current_epoch().value();
    ASSERT_ND(get_current_global_epoch().is_valid());
    control_block_->requested_global_epoch_ = control_block_->current_global_epoch_.load();
    control_block_->epoch_chime_terminate_requested_ = false;
    epoch_chime_thread_ = std::move(std::thread(&XctManagerPimpl::handle_epoch_chime, this));
  }
  return kRetOk;
}

Here is the call graph for this function:

bool foedus::xct::XctManagerPimpl::is_stop_requested

(

)

const

Definition at line 125 of file xct_manager_pimpl.cpp.

References ASSERT_ND, control_block_, engine_, foedus::xct::XctManagerControlBlock::epoch_chime_terminate_requested_, and foedus::Engine::is_master().

Referenced by handle_epoch_chime(), and handle_epoch_chime_wait_grace_period().

                                              {
  ASSERT_ND(engine_->is_master());
  return control_block_->epoch_chime_terminate_requested_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::xct::XctManagerPimpl::pause_accepting_xct

(

)

Pause all begin_xct until you call resume_accepting_xct()

Definition at line 327 of file xct_manager_pimpl.cpp.

References control_block_, and foedus::xct::XctManagerControlBlock::new_transaction_paused_.

Referenced by foedus::xct::XctManager::pause_accepting_xct().

                                          {
  control_block_->new_transaction_paused_.store(true);
}

Here is the caller graph for this function:

ErrorCode foedus::xct::XctManagerPimpl::precommit_xct	(	thread::Thread *	context,
		Epoch *	commit_epoch
	)

This is the gut of commit protocol.

It's mostly same as [TU2013].

Definition at line 343 of file xct_manager_pimpl.cpp.

References abort_xct(), ASSERT_ND, foedus::xct::Xct::assert_related_read_write(), foedus::xct::RetrospectiveLockList::clear_entries(), foedus::xct::Xct::deactivate(), foedus::xct::Xct::get_current_lock_list(), foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_retrospective_lock_list(), foedus::xct::Xct::is_active(), foedus::xct::CurrentLockList::is_empty(), foedus::xct::Xct::is_read_only(), foedus::kErrorCodeOk, foedus::kErrorCodeXctNoXct, precommit_xct_readonly(), precommit_xct_readwrite(), and release_and_clear_all_current_locks().

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

                                                                                   {
  Xct& current_xct = context->get_current_xct();
  if (!current_xct.is_active()) {
    return kErrorCodeXctNoXct;
  }
  ASSERT_ND(current_xct.assert_related_read_write());

  ErrorCode result;
  bool read_only = context->get_current_xct().is_read_only();
  if (read_only) {
    result = precommit_xct_readonly(context, commit_epoch);
  } else {
    result = precommit_xct_readwrite(context, commit_epoch);
  }

  ASSERT_ND(current_xct.assert_related_read_write());
  if (result != kErrorCodeOk) {
    ErrorCode abort_ret = abort_xct(context);
    ASSERT_ND(abort_ret == kErrorCodeOk);
    DVLOG(1) << *context << " Aborting because of contention";
  } else {
    current_xct.get_retrospective_lock_list()->clear_entries();
    release_and_clear_all_current_locks(context);
    current_xct.deactivate();
  }
  ASSERT_ND(current_xct.get_current_lock_list()->is_empty());
  return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::xct::XctManagerPimpl::precommit_xct_acquire_writer_lock	(	thread::Thread *	context,
		WriteXctAccess *	write
	)

void foedus::xct::XctManagerPimpl::precommit_xct_apply	(	thread::Thread *	context,
		XctId	max_xct_id,
		Epoch *	commit_epoch
	)

Phase 3 of precommit_xct()

Parameters

[in]	context	thread context
[in]	max_xct_id	largest xct_id this transaction depends on, or max(all xct_id).
[in,out]	commit_epoch	commit epoch of this transaction. it's finalized in this function.

Assuming phase 1 and 2 are successfully completed, apply all changes. This method does NOT release locks yet. This is one difference from SILO.

Definition at line 868 of file xct_manager_pimpl.cpp.

References ASSERT_ND, foedus::xct::XctId::before(), foedus::xct::XctId::clear_status_bits(), engine_, foedus::thread::Thread::get_current_xct(), foedus::xct::XctId::get_epoch(), foedus::xct::Xct::get_id(), foedus::xct::Xct::get_lock_free_write_set(), foedus::xct::Xct::get_lock_free_write_set_size(), foedus::storage::StorageManager::get_name(), foedus::xct::XctId::get_ordinal(), foedus::Engine::get_storage_manager(), foedus::log::LogHeader::get_type(), foedus::xct::Xct::get_write_set(), foedus::xct::Xct::get_write_set_size(), foedus::log::BaseLogType::header_, foedus::log::invoke_apply_record(), foedus::xct::XctId::is_being_written(), foedus::xct::XctId::is_deleted(), foedus::xct::RwLockableXctId::is_keylocked(), foedus::Epoch::is_valid(), foedus::xct::Xct::issue_next_id(), foedus::log::kLogCodeHashDelete, foedus::log::kLogCodeMasstreeDelete, foedus::xct::WriteXctAccess::log_entry_, foedus::xct::LockFreeWriteXctAccess::log_entry_, foedus::assorted::memory_fence_release(), foedus::xct::RecordXctAccess::owner_id_address_, foedus::xct::WriteXctAccess::payload_address_, foedus::xct::XctId::set_being_written(), foedus::xct::XctId::set_deleted(), foedus::log::LogHeader::set_xct_id(), foedus::xct::RecordXctAccess::storage_id_, foedus::xct::LockFreeWriteXctAccess::storage_id_, and foedus::xct::RwLockableXctId::xct_id_.

Referenced by precommit_xct_readwrite().

                       {
  Xct& current_xct = context->get_current_xct();
  WriteXctAccess* write_set = current_xct.get_write_set();
  uint32_t        write_set_size = current_xct.get_write_set_size();
  LockFreeWriteXctAccess* lock_free_write_set = current_xct.get_lock_free_write_set();
  uint32_t                lock_free_write_set_size = current_xct.get_lock_free_write_set_size();
  DVLOG(1) << *context << " applying.. write_set_size=" << write_set_size
    << ", lock_free_write_set_size=" << lock_free_write_set_size;

  current_xct.issue_next_id(max_xct_id, commit_epoch);
  XctId new_xct_id = current_xct.get_id();
  ASSERT_ND(new_xct_id.get_epoch() == *commit_epoch);
  ASSERT_ND(new_xct_id.get_ordinal() > 0);
  new_xct_id.clear_status_bits();
  XctId new_deleted_xct_id = new_xct_id;
  new_deleted_xct_id.set_deleted();  // used if the record after apply is in deleted state.

  DVLOG(1) << *context << " generated new xct id=" << new_xct_id;
  for (uint32_t i = 0; i < write_set_size; ++i) {
    WriteXctAccess& write = write_set[i];
    DVLOG(2) << *context << " Applying "
      << engine_->get_storage_manager()->get_name(write.storage_id_)
      << ":" << write.owner_id_address_;
    ASSERT_ND(write.owner_id_address_->is_keylocked());

    // We must be careful on the memory order of unlock and data write.
    // We must write data first (invoke_apply), then unlock.
    // Otherwise the correctness is not guaranteed.
    ASSERT_ND(write.log_entry_);
    write.log_entry_->header_.set_xct_id(new_xct_id);
    ASSERT_ND(new_xct_id.get_epoch().is_valid());
    if (i > 0 && write.owner_id_address_ == write_set[i - 1].owner_id_address_) {
      // the previous one has already set being_written and kept the lock
      ASSERT_ND(write.owner_id_address_->xct_id_.is_being_written());
    } else {
      ASSERT_ND(!write.owner_id_address_->xct_id_.is_being_written());
      write.owner_id_address_->xct_id_.set_being_written();
      assorted::memory_fence_release();
    }
    log::invoke_apply_record(
      write.log_entry_,
      context,
      write.storage_id_,
      write.owner_id_address_,
      write.payload_address_);
    ASSERT_ND(!write.owner_id_address_->xct_id_.get_epoch().is_valid() ||
      write.owner_id_address_->xct_id_.before(new_xct_id));  // ordered correctly?
    if (i < write_set_size - 1 &&
      write.owner_id_address_ == write_set[i + 1].owner_id_address_) {
      DVLOG(0) << *context << " Multiple write sets on record "
        << engine_->get_storage_manager()->get_name(write_set[i].storage_id_)
        << ":" << write_set[i].owner_id_address_ << ". Unlock at the last one of the write sets";
      // keep the lock for the next write set
    } else {
      // For this reason, we put memory_fence_release() between data and owner_id writes.
      assorted::memory_fence_release();
      if (write.owner_id_address_->xct_id_.is_deleted()) {
        // preserve delete-flag set by delete operations (so, the operation should be delete)
        ASSERT_ND(
          write.log_entry_->header_.get_type() == log::kLogCodeHashDelete ||
          write.log_entry_->header_.get_type() == log::kLogCodeMasstreeDelete);
        write.owner_id_address_->xct_id_ = new_deleted_xct_id;
      } else {
        ASSERT_ND(
          write.log_entry_->header_.get_type() != log::kLogCodeHashDelete &&
          write.log_entry_->header_.get_type() != log::kLogCodeMasstreeDelete);
        write.owner_id_address_->xct_id_ = new_xct_id;
      }
      // This method does NOT unlock. we do it at the end, all locks together.
      // This is another difference from SILO.
    }
  }
  // lock-free write-set doesn't have to worry about lock or ordering.
  for (uint32_t i = 0; i < lock_free_write_set_size; ++i) {
    LockFreeWriteXctAccess& write = lock_free_write_set[i];
    DVLOG(2) << *context << " Applying Lock-Free write "
      << engine_->get_storage_manager()->get_name(write.storage_id_);
    write.log_entry_->header_.set_xct_id(new_xct_id);
    log::invoke_apply_record(write.log_entry_, context, write.storage_id_, nullptr, nullptr);
  }
  DVLOG(1) << *context << " applied and unlocked write set";
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::xct::XctManagerPimpl::precommit_xct_lock	(	thread::Thread *	context,
		XctId *	max_xct_id
	)

Phase 1 of precommit_xct()

Parameters

[in]	context	thread context
[out]	max_xct_id	largest xct_id this transaction depends on, or max(locked xct_id).

Returns

true if successful. false if we need to abort the transaction, in which case locks are not obtained yet (so no need for unlock).

Try to lock all records we are going to write. After phase 2, we take memory fence.

Definition at line 539 of file xct_manager_pimpl.cpp.

References ASSERT_ND, foedus::xct::Xct::assert_related_read_write(), foedus::xct::CurrentLockList::batch_insert_write_placeholders(), CHECK_ERROR_CODE, foedus::thread::Thread::cll_release_all_locks_after(), foedus::thread::Thread::cll_try_or_acquire_single_lock(), foedus::xct::XctOptions::force_canonical_xlocks_in_precommit_, foedus::xct::CurrentLockList::get_array(), foedus::xct::Xct::get_current_lock_list(), foedus::thread::Thread::get_current_xct(), foedus::thread::Thread::get_engine(), foedus::xct::CurrentLockList::get_last_locked_entry(), foedus::Engine::get_options(), foedus::xct::Xct::get_write_set(), foedus::xct::Xct::get_write_set_size(), foedus::xct::RwLockableXctId::is_keylocked(), foedus::xct::RwLockableXctId::is_moved(), foedus::xct::RwLockableXctId::is_next_layer(), foedus::xct::CurrentLockListIteratorForWriteSet::is_valid(), foedus::kErrorCodeOk, foedus::kErrorCodeXctRaceAbort, foedus::xct::kLockListPositionInvalid, foedus::xct::kWriteLock, foedus::xct::LockEntry::lock_, foedus::xct::RwLockableXctId::needs_track_moved(), foedus::xct::ReadXctAccess::observed_owner_id_, foedus::xct::RecordXctAccess::owner_id_address_, precommit_xct_lock_batch_track_moved(), precommit_xct_sort_access(), foedus::xct::LockEntry::preferred_mode_, foedus::xct::WriteXctAccess::related_read_, foedus::xct::XctId::store_max(), foedus::xct::LockEntry::taken_mode_, foedus::xct::LockEntry::universal_lock_id_, UNLIKELY, foedus::EngineOptions::xct_, and foedus::xct::RwLockableXctId::xct_id_.

Referenced by precommit_xct_readwrite().

                                                                                      {
  Xct& current_xct = context->get_current_xct();
  WriteXctAccess* write_set = current_xct.get_write_set();
  uint32_t        write_set_size = current_xct.get_write_set_size();
  CurrentLockList* cll = current_xct.get_current_lock_list();
  const bool force_canonical
    = context->get_engine()->get_options().xct_.force_canonical_xlocks_in_precommit_;
  DVLOG(1) << *context << " #write_sets=" << write_set_size << ", addr=" << write_set;

#ifndef NDEBUG
  // Initially, write-sets must be ordered by the insertion order.
  for (uint32_t i = 0; i < write_set_size; ++i) {
    ASSERT_ND(write_set[i].ordinal_ == i);
    // Because of RLL, the write-set might or might not already have a corresponding lock
  }
#endif  // NDEBUG

moved_retry:
  CHECK_ERROR_CODE(precommit_xct_lock_batch_track_moved(context));
  precommit_xct_sort_access(context);

  // TODO(Hideaki) Because of how the new locks work, I'm not sure the prefetch still helps.
  // Previously it did, but not significant either, so let's disable for now and revisit this later.
  // we have to access the owner_id's pointed address. let's prefetch them in parallel
  // for (uint32_t i = 0; i < write_set_size; ++i) {
  //   assorted::prefetch_cacheline(write_set[i].owner_id_address_);
  // }

  // Create entries in CLL for all write sets. At this point they are not locked yet.
  cll->batch_insert_write_placeholders(write_set, write_set_size);

  ASSERT_ND(current_xct.assert_related_read_write());
  // Note: one alterantive is to sequentailly iterate over write-set and CLL,
  // both of which are sorted. It will be faster, but probably not that different
  // unless we have a large number of locks. For now binary_search each time.

  // Both write-set and CLL are sorted in canonical order. Simply iterate over in order.
  // This is way faster than invoking cll->binary_search() for each write-set entry.
  // Remember one thing, tho: write-set might have multiple entries for one record!
  for (CurrentLockListIteratorForWriteSet it(write_set, cll, write_set_size);
        it.is_valid();
        it.next_writes()) {
    // for multiple writes on one record, only the first one (write_cur_pos_) takes the lock
    WriteXctAccess* entry = write_set + it.write_cur_pos_;

    LockListPosition lock_pos = it.cll_pos_;
    ASSERT_ND(lock_pos != kLockListPositionInvalid);  // we have put placeholders for all!
    LockEntry* lock_entry = cll->get_array() + lock_pos;
    ASSERT_ND(lock_entry->lock_ == entry->owner_id_address_);
    ASSERT_ND(lock_entry->preferred_mode_ == kWriteLock);
    if (lock_entry->taken_mode_ == kWriteLock) {
      DVLOG(2) << "Yay, already taken. Probably Thanks to RLL?";
    } else {
      // We need to take or upgrade the lock.
      // This might return kErrorCodeXctRaceAbort when we are not in canonical mode and
      // we could not immediately acquire the lock.
      const LockListPosition last_locked_pos = cll->get_last_locked_entry();
      if (force_canonical &&
        (last_locked_pos != kLockListPositionInvalid && last_locked_pos >= lock_pos)) {
        // We are not in canonical mode. Let's aggressively restore canonical mode.
        DVLOG(0) << "Aggressively releasing locks to restore canonical mode in precommit";
        context->cll_release_all_locks_after(lock_entry->universal_lock_id_ - 1U);
#ifndef NDEBUG
        const LockListPosition new_pos = cll->get_last_locked_entry();
        ASSERT_ND(new_pos == kLockListPositionInvalid || new_pos < lock_pos);
#endif  // NDEBUG
      }
      CHECK_ERROR_CODE(context->cll_try_or_acquire_single_lock(lock_pos));
    }

    if (UNLIKELY(entry->owner_id_address_->needs_track_moved())) {
      // Because we invoked precommit_xct_lock_batch_track_moved beforehand,
      // this happens only when a concurrent thread again split some of the overlapping page.
      // Though rare, it happens. In that case redo the procedure.
      DLOG(INFO) << "Someone has split the page and moved our record after we check. Retry..";
      goto moved_retry;
    }

    ASSERT_ND(!entry->owner_id_address_->is_moved());
    ASSERT_ND(!entry->owner_id_address_->is_next_layer());
    ASSERT_ND(entry->owner_id_address_->is_keylocked());
    max_xct_id->store_max(entry->owner_id_address_->xct_id_);

    // If we have to abort, we should abort early to not waste time.
    // Thus, we check related read sets right here.
    // For other writes of the same record, too.
    for (uint32_t rec = it.write_cur_pos_; rec < it.write_next_pos_; ++rec) {
      WriteXctAccess* r = write_set + rec;
      ASSERT_ND(entry->owner_id_address_ == r->owner_id_address_);
      if (r->related_read_) {
        ASSERT_ND(r->related_read_->owner_id_address_ == r->owner_id_address_);
        if (r->owner_id_address_->xct_id_ != r->related_read_->observed_owner_id_) {
          return kErrorCodeXctRaceAbort;
        }
      }
    }
  }

  DVLOG(1) << *context << " locked write set";
#ifndef NDEBUG
  for (uint32_t i = 0; i < write_set_size; ++i) {
    ASSERT_ND(write_set[i].owner_id_address_->is_keylocked());
  }
#endif  // NDEBUG
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::xct::XctManagerPimpl::precommit_xct_lock_batch_track_moved

(

thread::Thread *

context

)

Subroutine of precommit_xct_lock to track most of moved records in write-set.

We initially did it per-record while we take a lock, but then we need lots of redoing when the transaction is batch-loading a bunch of records that cause many splits. Thus, before we take X-locks and do final check, we invoke this method to do best-effort tracking in one shot. Note that there still is a chance that the record is moved after this method before we take lock. In that case we redo the process. It happens.

Definition at line 514 of file xct_manager_pimpl.cpp.

References ASSERT_ND, foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_write_set(), foedus::xct::Xct::get_write_set_size(), foedus::kErrorCodeOk, foedus::kErrorCodeXctRaceAbort, foedus::xct::RecordXctAccess::owner_id_address_, precommit_xct_lock_track_write(), and UNLIKELY.

Referenced by precommit_xct_lock().

                                                                                     {
  Xct& current_xct = context->get_current_xct();
  WriteXctAccess* write_set = current_xct.get_write_set();
  uint32_t        write_set_size = current_xct.get_write_set_size();
  uint32_t moved_count = 0;
  for (uint32_t i = 0; i < write_set_size; ++i) {
    WriteXctAccess* entry = write_set + i;
    auto* rec = entry->owner_id_address_;
    if (UNLIKELY(rec->needs_track_moved())) {
      if (!precommit_xct_lock_track_write(context, entry)) {
        DLOG(INFO) << "Failed to track moved record?? this must be very rare";
        return kErrorCodeXctRaceAbort;
      }
      ASSERT_ND(entry->owner_id_address_ != rec);
      ++moved_count;
    }
  }
  DVLOG(1) << "Tracked " << moved_count << " moved records in precommit_xct_lock.";
  if (moved_count > 100U) {
    LOG(INFO) << "Tracked " << moved_count << " moved records in precommit_xct_lock."
      << " That's a lot. maybe this is a batch-loading transaction?";
  }
  return kErrorCodeOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::xct::XctManagerPimpl::precommit_xct_lock_track_write	(	thread::Thread *	context,
		WriteXctAccess *	entry
	)

used from precommit_xct_lock() to track moved record

Definition at line 432 of file xct_manager_pimpl.cpp.

References ASSERT_ND, engine_, foedus::thread::Thread::get_global_volatile_page_resolver(), foedus::Engine::get_storage_manager(), foedus::xct::RwLockableXctId::needs_track_moved(), foedus::xct::TrackMovedRecordResult::new_owner_address_, foedus::xct::TrackMovedRecordResult::new_payload_address_, foedus::xct::RecordXctAccess::owner_id_address_, foedus::xct::WriteXctAccess::payload_address_, foedus::xct::WriteXctAccess::related_read_, foedus::xct::ReadXctAccess::related_write_, foedus::xct::RecordXctAccess::set_owner_id_resolve_lock_id(), and foedus::xct::RecordXctAccess::storage_id_.

Referenced by precommit_xct_lock_batch_track_moved().

                                                {
  ASSERT_ND(entry->owner_id_address_->needs_track_moved());
  storage::StorageManager* st = engine_->get_storage_manager();
  TrackMovedRecordResult result = st->track_moved_record(
    entry->storage_id_,
    entry->owner_id_address_,
    entry);
  if (result.new_owner_address_ == nullptr) {
    // failed to track down even with the write set. this is a quite rare event.
    // in that case, retry the whole transaction.
    DLOG(INFO) << "Failed to track moved record even with write set";
    return false;
  }
  const auto& resolver = context->get_global_volatile_page_resolver();
  if (entry->related_read_) {
    // also apply the result to related read access so that we don't have to track twice.
    ASSERT_ND(entry->related_read_->related_write_ == entry);
    ASSERT_ND(entry->related_read_->owner_id_address_ == entry->owner_id_address_);
    entry->related_read_->set_owner_id_resolve_lock_id(resolver, result.new_owner_address_);
  }
  entry->set_owner_id_resolve_lock_id(resolver, result.new_owner_address_);
  entry->payload_address_ = result.new_payload_address_;
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::xct::XctManagerPimpl::precommit_xct_readonly	(	thread::Thread *	context,
		Epoch *	commit_epoch
	)

precommit_xct() if the transaction is read-only

If the transaction is read-only, commit-epoch (serialization point) is the largest epoch number in the read set. We don't have to take two memory fences in this case.

Definition at line 371 of file xct_manager_pimpl.cpp.

References ASSERT_ND, foedus::log::ThreadLogBuffer::get_offset_committed(), foedus::log::ThreadLogBuffer::get_offset_tail(), foedus::thread::Thread::get_thread_log_buffer(), foedus::kErrorCodeOk, foedus::kErrorCodeXctRaceAbort, foedus::assorted::memory_fence_acquire(), and precommit_xct_verify_readonly().

Referenced by precommit_xct().

                                                                                            {
  DVLOG(1) << *context << " Committing read_only";
  ASSERT_ND(context->get_thread_log_buffer().get_offset_committed() ==
      context->get_thread_log_buffer().get_offset_tail());
  *commit_epoch = Epoch();
  assorted::memory_fence_acquire();  // this is enough for read-only case
  if (precommit_xct_verify_readonly(context, commit_epoch)) {
    return kErrorCodeOk;
  } else {
    return kErrorCodeXctRaceAbort;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorCode foedus::xct::XctManagerPimpl::precommit_xct_readwrite	(	thread::Thread *	context,
		Epoch *	commit_epoch
	)

precommit_xct() if the transaction is read-write

See [TU2013] for the full protocol in this case.

Definition at line 384 of file xct_manager_pimpl.cpp.

References ASSERT_ND, foedus::log::ThreadLogBuffer::discard_current_xct_log(), foedus::log::LogOptions::emulation_, engine_, get_current_global_epoch_weak(), foedus::thread::Thread::get_current_xct(), foedus::thread::Thread::get_in_commit_epoch_address(), foedus::Engine::get_options(), foedus::thread::Thread::get_thread_log_buffer(), foedus::xct::Xct::get_write_set(), foedus::xct::Xct::get_write_set_size(), foedus::Epoch::kEpochInitialDurable, foedus::kErrorCodeOk, foedus::kErrorCodeXctRaceAbort, foedus::EngineOptions::log_, foedus::assorted::memory_fence_acq_rel(), foedus::assorted::memory_fence_release(), foedus::fs::DeviceEmulationOptions::null_device_, precommit_xct_apply(), precommit_xct_lock(), precommit_xct_verify_readwrite(), foedus::log::ThreadLogBuffer::publish_committed_log(), and foedus::xct::XctId::set().

Referenced by precommit_xct().

                                                                                             {
  DVLOG(1) << *context << " Committing read-write";
  XctId max_xct_id;
  max_xct_id.set(Epoch::kEpochInitialDurable, 1);  // TODO(Hideaki) not quite..
  ErrorCode lock_ret = precommit_xct_lock(context, &max_xct_id);  // Phase 1
  if (lock_ret != kErrorCodeOk) {
    return lock_ret;
  }

  // BEFORE the first fence, update the in commit epoch for epoch chime.
  // see InCommitEpochGuard class comments for why we need to do this.
  Epoch conservative_epoch = get_current_global_epoch_weak();
  InCommitEpochGuard guard(context->get_in_commit_epoch_address(), conservative_epoch);

  assorted::memory_fence_acq_rel();

  *commit_epoch = get_current_global_epoch_weak();  // serialization point!
  DVLOG(1) << *context << " Acquired read-write commit epoch " << *commit_epoch;

  assorted::memory_fence_acq_rel();
  bool verified = precommit_xct_verify_readwrite(context, &max_xct_id);  // phase 2
#ifndef NDEBUG
  {
    WriteXctAccess* write_set = context->get_current_xct().get_write_set();
    uint32_t        write_set_size = context->get_current_xct().get_write_set_size();
    for (uint32_t i = 0; i < write_set_size; ++i) {
      ASSERT_ND(write_set[i].owner_id_address_->is_keylocked());
      ASSERT_ND(!write_set[i].owner_id_address_->needs_track_moved());
      ASSERT_ND(write_set[i].log_entry_);
      ASSERT_ND(write_set[i].payload_address_);
    }
  }
#endif  // NDEBUG
  if (verified) {
    precommit_xct_apply(context, max_xct_id, commit_epoch);  // phase 3. this does NOT unlock
    // announce log AFTER (with fence) apply, because apply sets xct_order in the logs.
    assorted::memory_fence_release();
    if (engine_->get_options().log_.emulation_.null_device_) {
      context->get_thread_log_buffer().discard_current_xct_log();
    } else {
      context->get_thread_log_buffer().publish_committed_log(*commit_epoch);
    }
    return kErrorCodeOk;
  }
  return kErrorCodeXctRaceAbort;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::xct::XctManagerPimpl::precommit_xct_request_writer_lock	(	thread::Thread *	context,
		WriteXctAccess *	write
	)

void foedus::xct::XctManagerPimpl::precommit_xct_sort_access

(

thread::Thread *

context

)

Definition at line 478 of file xct_manager_pimpl.cpp.

References ASSERT_ND, foedus::xct::Xct::assert_related_read_write(), foedus::xct::WriteXctAccess::compare(), foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_write_set(), foedus::xct::Xct::get_write_set_size(), foedus::xct::RecordXctAccess::ordinal_, foedus::xct::RecordXctAccess::owner_id_address_, foedus::xct::WriteXctAccess::related_read_, and foedus::xct::ReadXctAccess::related_write_.

Referenced by precommit_xct_lock().

                                                                     {
  Xct& current_xct = context->get_current_xct();
  WriteXctAccess* write_set = current_xct.get_write_set();
  uint32_t        write_set_size = current_xct.get_write_set_size();

  ASSERT_ND(current_xct.assert_related_read_write());
  std::sort(write_set, write_set + write_set_size, WriteXctAccess::compare);
  // after the sorting, the related-link from read-set to write-set is now broken.
  // we fix it by following the back-link from write-set to read-set.
  for (uint32_t i = 0; i < write_set_size; ++i) {
    WriteXctAccess* entry = write_set + i;
    if (entry->related_read_) {
      ASSERT_ND(entry->owner_id_address_ == entry->related_read_->owner_id_address_);
      ASSERT_ND(entry->related_read_->related_write_);
      entry->related_read_->related_write_ = entry;
    }
    entry->ordinal_ = i;
  }
  ASSERT_ND(current_xct.assert_related_read_write());

#ifndef NDEBUG
  ASSERT_ND(current_xct.assert_related_read_write());
  // check that write sets are now sorted.
  // when address is the same, they must be ordered by the order they are created.
  // eg: repeated overwrites to one record should be applied in the order the user issued.
  for (uint32_t i = 1; i < write_set_size; ++i) {
    ASSERT_ND(write_set[i - 1].ordinal_ != write_set[i].ordinal_);
    if (write_set[i].owner_lock_id_ == write_set[i - 1].owner_lock_id_) {
      ASSERT_ND(write_set[i - 1].ordinal_ < write_set[i].ordinal_);
    } else {
      ASSERT_ND(write_set[i - 1].owner_lock_id_ < write_set[i].owner_lock_id_);
    }
  }
#endif  // NDEBUG
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::xct::XctManagerPimpl::precommit_xct_try_acquire_writer_locks

(

thread::Thread *

context

)

bool foedus::xct::XctManagerPimpl::precommit_xct_verify_page_version_set

(

thread::Thread *

context

)

Returns false if there is any page version conflict.

Definition at line 847 of file xct_manager_pimpl.cpp.

References foedus::xct::PageVersionAccess::address_, foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_page_version_set(), foedus::xct::Xct::get_page_version_set_size(), foedus::xct::PageVersionAccess::observed_, foedus::assorted::prefetch_cacheline(), and foedus::storage::PageVersion::status_.

Referenced by precommit_xct_verify_readonly(), and precommit_xct_verify_readwrite().

                                                                                 {
  const Xct& current_xct = context->get_current_xct();
  const PageVersionAccess*  page_version_set = current_xct.get_page_version_set();
  const uint32_t            page_version_set_size = current_xct.get_page_version_set_size();
  for (uint32_t i = 0; i < page_version_set_size; ++i) {
    // let's prefetch address_ in parallel
    if (i % kReadsetPrefetchBatch == 0) {
      for (uint32_t j = i; j < i + kReadsetPrefetchBatch && j < page_version_set_size; ++j) {
        assorted::prefetch_cacheline(page_version_set[j].address_);
      }
    }
    const PageVersionAccess& access = page_version_set[i];
    if (access.address_->status_ != access.observed_) {
      DLOG(WARNING) << *context << " page version is changed by other transaction. will abort"
        " observed=" << access.observed_ << ", now=" << access.address_->status_;
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::xct::XctManagerPimpl::precommit_xct_verify_pointer_set

(

thread::Thread *

context

)

Returns false if there is any pointer set conflict.

Definition at line 828 of file xct_manager_pimpl.cpp.

References foedus::xct::PointerAccess::address_, foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_pointer_set(), foedus::xct::Xct::get_pointer_set_size(), foedus::xct::PointerAccess::observed_, foedus::assorted::prefetch_cacheline(), and foedus::storage::VolatilePagePointer::word.

Referenced by precommit_xct_verify_readonly(), and precommit_xct_verify_readwrite().

                                                                            {
  const Xct& current_xct = context->get_current_xct();
  const PointerAccess*    pointer_set = current_xct.get_pointer_set();
  const uint32_t          pointer_set_size = current_xct.get_pointer_set_size();
  for (uint32_t i = 0; i < pointer_set_size; ++i) {
    // let's prefetch address_ in parallel
    if (i % kReadsetPrefetchBatch == 0) {
      for (uint32_t j = i; j < i + kReadsetPrefetchBatch && j < pointer_set_size; ++j) {
        assorted::prefetch_cacheline(pointer_set[j].address_);
      }
    }
    const PointerAccess& access = pointer_set[i];
    if (access.address_->word !=  access.observed_.word) {
      DLOG(WARNING) << *context << " volatile ptr is changed by other transaction. will abort";
      return false;
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::xct::XctManagerPimpl::precommit_xct_verify_readonly	(	thread::Thread *	context,
		Epoch *	commit_epoch
	)

Phase 2 of precommit_xct() for read-only case.

Returns

true if verification succeeded. false if we need to abort.

Verify the observed read set and set the commit epoch to the highest epoch it observed.

Definition at line 648 of file xct_manager_pimpl.cpp.

References ASSERT_ND, engine_, foedus::thread::Thread::get_current_xct(), foedus::log::LogManager::get_durable_global_epoch_weak(), foedus::xct::XctId::get_epoch(), foedus::xct::Xct::get_lock_free_read_set(), foedus::xct::Xct::get_lock_free_read_set_size(), foedus::Engine::get_log_manager(), foedus::storage::StorageManager::get_name(), foedus::xct::Xct::get_read_set(), foedus::xct::Xct::get_read_set_size(), foedus::Engine::get_storage_manager(), foedus::xct::XctId::is_being_written(), foedus::xct::RwLockableXctId::needs_track_moved(), foedus::xct::ReadXctAccess::observed_owner_id_, foedus::xct::LockFreeReadXctAccess::observed_owner_id_, foedus::xct::RecordXctAccess::owner_id_address_, foedus::xct::LockFreeReadXctAccess::owner_id_address_, precommit_xct_verify_page_version_set(), precommit_xct_verify_pointer_set(), precommit_xct_verify_track_read(), foedus::assorted::prefetch_cacheline(), foedus::xct::RecordXctAccess::storage_id_, foedus::Epoch::store_max(), UNLIKELY, and foedus::xct::RwLockableXctId::xct_id_.

Referenced by precommit_xct_readonly().

                                                                                              {
  Xct& current_xct = context->get_current_xct();
  ReadXctAccess*    read_set = current_xct.get_read_set();
  const uint32_t    read_set_size = current_xct.get_read_set_size();
  storage::StorageManager* st = engine_->get_storage_manager();
  for (uint32_t i = 0; i < read_set_size; ++i) {
    ASSERT_ND(read_set[i].related_write_ == nullptr);
    // let's prefetch owner_id in parallel
    if (i % kReadsetPrefetchBatch == 0) {
      for (uint32_t j = i; j < i + kReadsetPrefetchBatch && j < read_set_size; ++j) {
        assorted::prefetch_cacheline(read_set[j].owner_id_address_);
      }
    }

    ReadXctAccess& access = read_set[i];
    DVLOG(2) << *context << "Verifying " << st->get_name(access.storage_id_)
      << ":" << access.owner_id_address_ << ". observed_xid=" << access.observed_owner_id_
        << ", now_xid=" << access.owner_id_address_->xct_id_;
    if (UNLIKELY(access.observed_owner_id_.is_being_written())) {
      // safety net. observing this case.
      // hm, this should be checked and retried during transaction.
      // probably there still is some code to forget that.
      // At least safe to abort here, so keep it this way for now.
      DLOG(WARNING) << *context << "?? this should have been checked. being_written! will abort";
      return false;
    }

    // Implementation Note: we do verify the versions whether we took a lock on this record or not.
    // In a sentence, this is the simplest and most reliable while wasted cost is not that much.

    // In a paragraph.. We could check whether it's locked, and in \e some case skip verification,
    // but think of case 1) read A without read-lock, later take a write-lock on A due to RLL.
    // also case 2) read A without read-lock, then read A again but this time with read-lock.
    // Yes, we could rule these cases out by checking something for each read/write,
    // but that's fragile. too much complexity for little. we just verify always. period.
    if (UNLIKELY(access.owner_id_address_->needs_track_moved())) {
      if (!precommit_xct_verify_track_read(context, &access)) {
        return false;
      }
    }
    if (access.observed_owner_id_ != access.owner_id_address_->xct_id_) {
      DLOG(WARNING) << *context << " read set changed by other transaction. will abort";
      // read clobbered
      return false;
    }

    // Remembers the highest epoch observed.
    commit_epoch->store_max(access.observed_owner_id_.get_epoch());
  }

  // Check lock-free read-set, which is a bit simpler.
  LockFreeReadXctAccess* lock_free_read_set = current_xct.get_lock_free_read_set();
  const uint32_t    lock_free_read_set_size = current_xct.get_lock_free_read_set_size();
  for (uint32_t i = 0; i < lock_free_read_set_size; ++i) {
    const LockFreeReadXctAccess& access = lock_free_read_set[i];
    ASSERT_ND(!access.owner_id_address_->needs_track_moved());
    if (access.observed_owner_id_ != access.owner_id_address_->xct_id_) {
      DLOG(WARNING) << *context << " lock free read set changed by other transaction. will abort";
      return false;
    }

    commit_epoch->store_max(access.observed_owner_id_.get_epoch());
  }

  DVLOG(1) << *context << "Read-only higest epoch observed: " << *commit_epoch;
  if (!commit_epoch->is_valid()) {
    DVLOG(1) << *context
      << " Read-only higest epoch was empty. The transaction has no read set??";
    // In this case, set already-durable epoch. We don't have to use atomic version because
    // it's just conservatively telling how long it should wait.
    *commit_epoch = Epoch(engine_->get_log_manager()->get_durable_global_epoch_weak());
  }

  // Check Page Pointer/Version
  if (!precommit_xct_verify_pointer_set(context)) {
    return false;
  } else if (!precommit_xct_verify_page_version_set(context)) {
    return false;
  } else {
    return true;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::xct::XctManagerPimpl::precommit_xct_verify_readwrite	(	thread::Thread *	context,
		XctId *	max_xct_id
	)

Phase 2 of precommit_xct() for read-write case.

Parameters

[in]	context	thread context
[in,out]	max_xct_id	largest xct_id this transaction depends on, or max(all xct_id).

Returns

true if verification succeeded. false if we need to abort.

Verify the observed read set and write set against the same record. Because phase 2 is after the memory fence, no thread would take new locks while checking.

Definition at line 731 of file xct_manager_pimpl.cpp.

References ASSERT_ND, engine_, foedus::thread::Thread::get_current_xct(), foedus::xct::Xct::get_lock_free_read_set(), foedus::xct::Xct::get_lock_free_read_set_size(), foedus::storage::StorageManager::get_name(), foedus::xct::Xct::get_read_set(), foedus::xct::Xct::get_read_set_size(), foedus::Engine::get_storage_manager(), foedus::xct::XctId::is_being_written(), foedus::xct::RwLockableXctId::needs_track_moved(), foedus::xct::ReadXctAccess::observed_owner_id_, foedus::xct::LockFreeReadXctAccess::observed_owner_id_, foedus::xct::RecordXctAccess::owner_id_address_, foedus::xct::LockFreeReadXctAccess::owner_id_address_, precommit_xct_verify_page_version_set(), precommit_xct_verify_pointer_set(), precommit_xct_verify_track_read(), foedus::assorted::prefetch_cacheline(), foedus::xct::ReadXctAccess::related_write_, foedus::xct::RecordXctAccess::storage_id_, foedus::xct::XctId::store_max(), UNLIKELY, and foedus::xct::RwLockableXctId::xct_id_.

Referenced by precommit_xct_readwrite().

                                                                                             {
  Xct& current_xct = context->get_current_xct();
  ReadXctAccess*          read_set = current_xct.get_read_set();
  const uint32_t          read_set_size = current_xct.get_read_set_size();
  for (uint32_t i = 0; i < read_set_size; ++i) {
    // let's prefetch owner_id in parallel
    if (i % kReadsetPrefetchBatch == 0) {
      for (uint32_t j = i; j < i + kReadsetPrefetchBatch && j < read_set_size; ++j) {
        if (read_set[j].related_write_ == nullptr) {
          assorted::prefetch_cacheline(read_set[j].owner_id_address_);
        }
      }
    }
    // The owning transaction has changed.
    // We don't check ordinal here because there is no change we are racing with ourselves.
    ReadXctAccess& access = read_set[i];
    if (UNLIKELY(access.observed_owner_id_.is_being_written())) {
      // same as above.
      DLOG(WARNING) << *context << "?? this should have been checked. being_written! will abort";
      return false;
    }
    storage::StorageManager* st = engine_->get_storage_manager();
    if (access.related_write_) {
      // we already checked this in lock()
      DVLOG(3) << *context << " skipped read-sets that are already checked";
      ASSERT_ND(access.observed_owner_id_ == access.owner_id_address_->xct_id_);
      continue;
    }
    DVLOG(2) << *context << " Verifying " << st->get_name(access.storage_id_)
      << ":" << access.owner_id_address_ << ". observed_xid=" << access.observed_owner_id_
        << ", now_xid=" << access.owner_id_address_->xct_id_;
    // As noted in precommit_xct_verify_readonly, we verify read-set whether it's locked or not.

    // read-set has to also track moved records.
    // however, unlike write-set locks, we don't have to do retry-loop.
    // if the rare event (yet another concurrent split) happens, we just abort the transaction.
    if (UNLIKELY(access.owner_id_address_->needs_track_moved())) {
      if (!precommit_xct_verify_track_read(context, &access)) {
        return false;
      }
    }

    if (access.observed_owner_id_ != access.owner_id_address_->xct_id_) {
      DVLOG(1) << *context << " read set changed by other transaction. will abort";
      // same as read_only
      return false;
    }

    /*
    // Hideaki[2016Feb] I think I remember why I kept this here. When we didn't have the
    // "being_written" flag, we did need it even after splitting XID/TID.
    // But, now that we have it in XID, it's surely safe without this.
    // Still.. in case I miss something, I leave it here commented out.

    // Hideaki: Umm, after several changes, I'm now not sure if we still need this check.
    // As far as XID hasn't changed, do we care whether others locked it or not?
    // Thanks to the separation of XID and Lock-word, I think this is now unnecessary.
    // If it's our own lock, we haven't applied our changes yet, so safe. If it's other's lock,
    // why do we care as far as XID hasn'nt changed? Everyone updates XID -> unlocks in this order.
    // Anyways, we are in the course of a bigger change, so revisit it later.
    if (access.owner_id_address_->is_keylocked()) {
      DVLOG(2) << *context
        << " read set contained a locked record. was it myself who locked it?";
      LockListPosition my_lock_pos = cll->binary_search(access.owner_id_address_);
      if (my_lock_pos != kLockListPositionInvalid && cll->get_array()[my_lock_pos].is_locked()) {
        DVLOG(2) << *context << " okay, myself. go on.";
      } else {
        DVLOG(1) << *context << " no, not me. will abort";
        return false;
      }
    }
    */
    max_xct_id->store_max(access.observed_owner_id_);
  }

  // Check Page Pointer/Version
  // Check lock-free read-set, which is a bit simpler.
  LockFreeReadXctAccess* lock_free_read_set = current_xct.get_lock_free_read_set();
  const uint32_t    lock_free_read_set_size = current_xct.get_lock_free_read_set_size();
  for (uint32_t i = 0; i < lock_free_read_set_size; ++i) {
    const LockFreeReadXctAccess& access = lock_free_read_set[i];
    ASSERT_ND(!access.owner_id_address_->needs_track_moved());
    if (access.observed_owner_id_ != access.owner_id_address_->xct_id_) {
      DLOG(WARNING) << *context << " lock free read set changed by other transaction. will abort";
      return false;
    }
  }

  if (!precommit_xct_verify_pointer_set(context)) {
    return false;
  } else if (!precommit_xct_verify_page_version_set(context)) {
    return false;
  } else {
    return true;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool foedus::xct::XctManagerPimpl::precommit_xct_verify_track_read	(	thread::Thread *	context,
		ReadXctAccess *	entry
	)

used from verification methods to track moved record

Definition at line 458 of file xct_manager_pimpl.cpp.

References ASSERT_ND, engine_, foedus::thread::Thread::get_global_volatile_page_resolver(), foedus::Engine::get_storage_manager(), foedus::xct::RwLockableXctId::needs_track_moved(), foedus::xct::TrackMovedRecordResult::new_owner_address_, foedus::xct::RecordXctAccess::owner_id_address_, foedus::xct::ReadXctAccess::related_write_, foedus::xct::RecordXctAccess::set_owner_id_resolve_lock_id(), foedus::xct::RecordXctAccess::storage_id_, and foedus::storage::StorageManager::track_moved_record().

Referenced by precommit_xct_verify_readonly(), and precommit_xct_verify_readwrite().

                                               {
  ASSERT_ND(entry->owner_id_address_->needs_track_moved());
  ASSERT_ND(entry->related_write_ == nullptr);  // if there is, lock() should have updated it.
  storage::StorageManager* st = engine_->get_storage_manager();
  TrackMovedRecordResult result = st->track_moved_record(
    entry->storage_id_,
    entry->owner_id_address_,
    entry->related_write_);
  if (result.new_owner_address_ == nullptr) {
    // failed to track down. if entry->related_write_ is null, this always happens when
    // the record is now in next layer. in this case, retry the whole transaction.
    return false;
  }

  const auto& resolver = context->get_global_volatile_page_resolver();
  entry->set_owner_id_resolve_lock_id(resolver, result.new_owner_address_);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::xct::XctManagerPimpl::release_and_clear_all_current_locks

(

thread::Thread *

context

)

unlocking all acquired locks, used when commit/abort.

Definition at line 997 of file xct_manager_pimpl.cpp.

References foedus::xct::CurrentLockList::clear_entries(), foedus::thread::Thread::cll_release_all_locks(), foedus::xct::Xct::get_current_lock_list(), and foedus::thread::Thread::get_current_xct().

Referenced by abort_xct(), and precommit_xct().

                                                                               {
  context->cll_release_all_locks();
  CurrentLockList* cll = context->get_current_xct().get_current_lock_list();
  cll->clear_entries();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::xct::XctManagerPimpl::resume_accepting_xct

(

)

Make sure you call this after pause_accepting_xct().

Definition at line 330 of file xct_manager_pimpl.cpp.

References control_block_, and foedus::xct::XctManagerControlBlock::new_transaction_paused_.

Referenced by foedus::xct::XctManager::resume_accepting_xct().

                                           {
  control_block_->new_transaction_paused_.store(false);
}

Here is the caller graph for this function:

void foedus::xct::XctManagerPimpl::set_requested_global_epoch

(

Epoch

request

)

Definition at line 241 of file xct_manager_pimpl.cpp.

References control_block_, get_requested_global_epoch(), foedus::xct::XctManagerControlBlock::requested_global_epoch_, and foedus::Epoch::value().

Referenced by advance_current_global_epoch(), wait_for_commit(), and wait_for_current_global_epoch().

                                                              {
  // set request value, atomically
  while (true) {
    Epoch already_requested = get_requested_global_epoch();
    if (already_requested >= request) {
      break;
    }
    Epoch::EpochInteger cmp = already_requested.value();
    if (control_block_->requested_global_epoch_.compare_exchange_strong(cmp, request.value())) {
      break;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::xct::XctManagerPimpl::uninitialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 104 of file xct_manager_pimpl.cpp.

References CHECK_ERROR, control_block_, foedus::ErrorStackBatch::emprace_back(), engine_, foedus::xct::XctManagerControlBlock::epoch_chime_terminate_requested_, epoch_chime_thread_, foedus::xct::XctManagerControlBlock::epoch_chime_wakeup_, ERROR_STACK, foedus::Engine::get_cache_manager(), foedus::Engine::get_storage_manager(), foedus::storage::StorageManager::is_initialized(), foedus::Engine::is_master(), foedus::kErrorCodeDepedentModuleUnavailableUninit, foedus::soc::SharedPolling::signal(), foedus::cache::CacheManager::stop_cleaner(), SUMMARIZE_ERROR_BATCH, and foedus::xct::XctManagerControlBlock::uninitialize().

                                              {
  LOG(INFO) << "Uninitializing XctManager..";
  ErrorStackBatch batch;
  if (!engine_->get_storage_manager()->is_initialized()) {
    batch.emprace_back(ERROR_STACK(kErrorCodeDepedentModuleUnavailableUninit));
  }
  // See CacheManager's comments for why we have to stop the cleaner here
  CHECK_ERROR(engine_->get_cache_manager()->stop_cleaner());
  if (engine_->is_master()) {
    if (epoch_chime_thread_.joinable()) {
      {
        control_block_->epoch_chime_terminate_requested_ = true;
        control_block_->epoch_chime_wakeup_.signal();
      }
      epoch_chime_thread_.join();
    }
    control_block_->uninitialize();
  }
  return SUMMARIZE_ERROR_BATCH(batch);
}

Here is the call graph for this function:

ErrorCode foedus::xct::XctManagerPimpl::wait_for_commit	(	Epoch	commit_epoch,
		int64_t	wait_microseconds
	)

Definition at line 290 of file xct_manager_pimpl.cpp.

References engine_, get_current_global_epoch(), foedus::Engine::get_log_manager(), foedus::Epoch::one_more(), set_requested_global_epoch(), foedus::log::LogManager::wait_until_durable(), and wakeup_epoch_chime_thread().

Referenced by foedus::xct::XctManager::wait_for_commit().

                                                                                        {
  // to durably commit transactions in commit_epoch, the current global epoch should be
  // commit_epoch + 2 or more. (current-1 is grace epoch. current-2 is the the latest loggable ep)
  Epoch target_epoch = commit_epoch.one_more().one_more();
  if (target_epoch > get_current_global_epoch()) {
    set_requested_global_epoch(target_epoch);
    wakeup_epoch_chime_thread();
  }

  return engine_->get_log_manager()->wait_until_durable(commit_epoch, wait_microseconds);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::xct::XctManagerPimpl::wait_for_current_global_epoch	(	Epoch	target_epoch,
		int64_t	wait_microseconds
	)

Definition at line 273 of file xct_manager_pimpl.cpp.

References foedus::soc::SharedPolling::acquire_ticket(), control_block_, foedus::xct::XctManagerControlBlock::current_global_epoch_advanced_, get_current_global_epoch(), set_requested_global_epoch(), foedus::soc::SharedPolling::timedwait(), and foedus::soc::SharedPolling::wait().

Referenced by foedus::xct::XctManager::wait_for_current_global_epoch().

                                                                                                 {
  // this method doesn't aggressively wake up the epoch-advance thread. it just waits.
  set_requested_global_epoch(target_epoch);
  while (get_current_global_epoch() < target_epoch) {
    uint64_t demand = control_block_->current_global_epoch_advanced_.acquire_ticket();
    if (get_current_global_epoch() < target_epoch) {
      if (wait_microseconds < 0) {
        control_block_->current_global_epoch_advanced_.wait(demand);
      } else {
        control_block_->current_global_epoch_advanced_.timedwait(demand, wait_microseconds);
        return;
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::xct::XctManagerPimpl::wait_until_resume_accepting_xct

(

thread::Thread *

context

)

Definition at line 334 of file xct_manager_pimpl.cpp.

References control_block_, and foedus::xct::XctManagerControlBlock::new_transaction_paused_.

Referenced by begin_xct().

                                                                           {
  LOG(INFO) << *context << " realized that new transactions are not accepted now."
    << " waits until it is allowed to start a new transaction";
  // no complex thing here. just sleep-check. this happens VERY infrequently.
  while (control_block_->new_transaction_paused_.load()) {
    std::this_thread::sleep_for(std::chrono::milliseconds(20));
  }
}

Here is the caller graph for this function:

void foedus::xct::XctManagerPimpl::wakeup_epoch_chime_thread

(

)

Definition at line 237 of file xct_manager_pimpl.cpp.

References control_block_, foedus::xct::XctManagerControlBlock::epoch_chime_wakeup_, and foedus::soc::SharedPolling::signal().

Referenced by advance_current_global_epoch(), and wait_for_commit().

                                                {
  control_block_->epoch_chime_wakeup_.signal();  // hurrrrry up!
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

XctManagerControlBlock* foedus::xct::XctManagerPimpl::control_block_

Definition at line 225 of file xct_manager_pimpl.hpp.

Referenced by advance_current_global_epoch(), begin_xct(), get_current_global_epoch(), get_current_global_epoch_weak(), get_requested_global_epoch(), handle_epoch_chime(), initialize_once(), is_stop_requested(), pause_accepting_xct(), resume_accepting_xct(), set_requested_global_epoch(), uninitialize_once(), wait_for_current_global_epoch(), wait_until_resume_accepting_xct(), and wakeup_epoch_chime_thread().

Engine* const foedus::xct::XctManagerPimpl::engine_

Definition at line 224 of file xct_manager_pimpl.hpp.

Referenced by handle_epoch_chime(), handle_epoch_chime_wait_grace_period(), initialize_once(), is_stop_requested(), precommit_xct_apply(), precommit_xct_lock_track_write(), precommit_xct_readwrite(), precommit_xct_verify_readonly(), precommit_xct_verify_readwrite(), precommit_xct_verify_track_read(), uninitialize_once(), and wait_for_commit().

std::thread foedus::xct::XctManagerPimpl::epoch_chime_thread_

This thread keeps advancing the current_global_epoch_.

Launched only in master engine.

Definition at line 231 of file xct_manager_pimpl.hpp.

Referenced by initialize_once(), and uninitialize_once().

---

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

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