foedus::log::ThreadLogBuffer Class Reference

A thread-local log buffer. More...

Detailed Description

A thread-local log buffer.

This is a private implementation-details of Log Manager, thus file name ends with _impl. Do not include this header from a client program unless you know what you are doing.

Circular buffers

See also

foedus::log::ThreadLogBufferMeta

Epoch marks

See also

foedus::log::ThreadEpockMark

Definition at line 266 of file thread_log_buffer.hpp.

#include <thread_log_buffer.hpp>

Inheritance diagram for foedus::log::ThreadLogBuffer:

Collaboration diagram for foedus::log::ThreadLogBuffer:

Classes
struct	OffsetRange

Public Member Functions
	ThreadLogBuffer (Engine *engine, thread::ThreadId thread_id)
ErrorStack	initialize_once () override
ErrorStack	uninitialize_once () override
	ThreadLogBuffer ()=delete
	ThreadLogBuffer (const ThreadLogBuffer &other)=delete
ThreadLogBuffer &	operator= (const ThreadLogBuffer &other)=delete
void	assert_consistent () const
	Only for Debug-assertion. More...
thread::ThreadId	get_thread_id () const
char *	reserve_new_log (uint16_t log_length) __attribute__((always_inline))
	Reserves a space for a new (uncommitted) log entry at the tail. More...
uint64_t	head_to_tail_distance () const __attribute__((always_inline))
void	publish_committed_log (Epoch commit_epoch) __attribute__((always_inline))
	Called when the current transaction is successfully committed. More...
void	discard_current_xct_log ()
	Called when the current transaction aborts. More...
Epoch	get_last_epoch () const
void	wait_for_space (uint16_t required_space)
	Called when we have to wait till offset_head_ advances so that we can put new logs. More...
uint64_t	get_offset_head () const
	This marks the position where log entries start. More...
uint64_t	get_offset_durable () const
	This marks the position upto which the log writer durably wrote out to log files. More...
uint64_t	get_offset_committed () const
	This marks the position upto which transaction logs are committed by the thread. More...
uint64_t	get_offset_tail () const
	The current cursor to which next log will be written. More...
const ThreadLogBufferMeta &	get_meta () const
	Returns the state of this buffer. More...
const char *	get_buffer () const
OffsetRange	get_logs_to_write (Epoch written_epoch)
	Returns begin/end offsets of logs in the given epoch. More...
void	on_log_written (Epoch written_epoch)
	Called when the logger wrote out all logs in the given epoch, advancing oldest_mark_index_. More...
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 ()

Static Public Member Functions
static uint64_t	distance (uint64_t buffer_size, uint64_t from, uint64_t to) __attribute__((always_inline))
	Subtract operator, considering wrapping around. More...
static void	advance (uint64_t buffer_size, uint64_t *target, uint64_t amount) __attribute__((always_inline))
	Addition operator, considering wrapping around. More...

Friends
class	Logger
std::ostream &	operator<< (std::ostream &o, const ThreadLogBuffer &v)

Constructor & Destructor Documentation

foedus::log::ThreadLogBuffer::ThreadLogBuffer	(	Engine *	engine,
		thread::ThreadId	thread_id
	)

Definition at line 104 of file thread_log_buffer.cpp.

References foedus::log::ThreadLogBufferMeta::thread_id_.

  : engine_(engine), meta_() {
  meta_.thread_id_ = thread_id;
  buffer_ = nullptr;
}

foedus::log::ThreadLogBuffer::ThreadLogBuffer ( )

delete

foedus::log::ThreadLogBuffer::ThreadLogBuffer ( const ThreadLogBuffer &  other )

delete

Member Function Documentation

static void foedus::log::ThreadLogBuffer::advance ( uint64_t  buffer_size, uint64_t *  target, uint64_t  amount  )

inlinestatic

Addition operator, considering wrapping around.

Definition at line 284 of file thread_log_buffer.hpp.

References ASSERT_ND.

Referenced by reserve_new_log().

                                                                                             {
    ASSERT_ND(*target < buffer_size);
    ASSERT_ND(amount < buffer_size);
    *target += amount;
    if (*target >= buffer_size) {
      *target -= buffer_size;
    }
  }

Here is the caller graph for this function:

void foedus::log::ThreadLogBuffer::assert_consistent ( ) const

inline

Only for Debug-assertion.

This method must be called by the worker thread itself. When logger calls it, it must make sure the worker is not modifying anything concurrently.

Definition at line 306 of file thread_log_buffer.hpp.

References foedus::log::ThreadLogBufferMeta::assert_consistent().

Referenced by wait_for_space().

                                        {
#ifndef NDEBUG
    meta_.assert_consistent();
#endif  // NDEBUG
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::log::ThreadLogBuffer::discard_current_xct_log ( )

inline

Called when the current transaction aborts.

Definition at line 358 of file thread_log_buffer.hpp.

References foedus::log::ThreadLogBufferMeta::offset_committed_, and foedus::log::ThreadLogBufferMeta::offset_tail_.

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

                                        {
    meta_.offset_tail_ = meta_.offset_committed_;
  }

Here is the caller graph for this function:

static uint64_t foedus::log::ThreadLogBuffer::distance ( uint64_t  buffer_size, uint64_t  from, uint64_t  to  )

inlinestatic

Subtract operator, considering wrapping around.

Attention

Be careful. As this is a circular buffer, from and to are NOT commutative. actually, distance(from, to) = buffer_size - distance(to, from).

Definition at line 274 of file thread_log_buffer.hpp.

References ASSERT_ND.

Referenced by head_to_tail_distance().

                                                                                           {
    ASSERT_ND(from < buffer_size);
    ASSERT_ND(to < buffer_size);
    if (to >= from) {
      return to - from;
    } else {
      return to + buffer_size - from;  // wrap around
    }
  }

Here is the caller graph for this function:

const char* foedus::log::ThreadLogBuffer::get_buffer ( ) const

inline

Definition at line 383 of file thread_log_buffer.hpp.

{ return buffer_; }

Epoch foedus::log::ThreadLogBuffer::get_last_epoch ( ) const

inline

Definition at line 361 of file thread_log_buffer.hpp.

References foedus::log::ThreadLogBufferMeta::current_mark_index_, foedus::log::ThreadEpockMark::new_epoch_, and foedus::log::ThreadLogBufferMeta::thread_epoch_marks_.

Referenced by publish_committed_log().

                                     {
    return meta_.thread_epoch_marks_[meta_.current_mark_index_].new_epoch_;
  }

Here is the caller graph for this function:

ThreadLogBuffer::OffsetRange foedus::log::ThreadLogBuffer::get_logs_to_write

(

Epoch

written_epoch

)

Returns begin/end offsets of logs in the given epoch.

It might be empty (0/0).

Definition at line 234 of file thread_log_buffer.cpp.

References ASSERT_ND, foedus::log::ThreadLogBuffer::OffsetRange::begin_, foedus::log::ThreadLogBufferMeta::current_mark_index_, foedus::log::ThreadLogBuffer::OffsetRange::end_, foedus::log::ThreadLogBufferMeta::increment_mark_index(), foedus::log::ThreadLogBufferMeta::kMaxNonDurableEpochs, foedus::assorted::memory_fence_acq_rel(), foedus::assorted::memory_fence_acquire(), foedus::log::ThreadEpockMark::new_epoch_, foedus::log::ThreadEpockMark::offset_begin_, foedus::log::ThreadLogBufferMeta::offset_committed_, foedus::log::ThreadLogBufferMeta::offset_durable_, foedus::log::ThreadEpockMark::offset_end_, foedus::log::ThreadLogBufferMeta::oldest_mark_index_, and foedus::log::ThreadLogBufferMeta::thread_epoch_marks_.

                                                                                 {
  // See ThreadLogBufferMeta's class comment about tricky cases (the thread being idle).
  // assert_consistent(); this verification assumes the worker is not working. we can't use it here
  OffsetRange ret;
  ThreadEpockMark& target = meta_.thread_epoch_marks_[meta_.oldest_mark_index_];
  if (target.new_epoch_ > written_epoch) {
    // Case 1) no logs in this epoch.
    ASSERT_ND(target.offset_begin_ == meta_.offset_durable_);
    ret.begin_ = 0;
    ret.end_ = 0;
  } else if (target.new_epoch_ == written_epoch) {
    // Case 2) Is it 2-a? or 2-b?
    ASSERT_ND(target.offset_begin_ == meta_.offset_durable_);
    ret.begin_ = target.offset_begin_;
    if (meta_.oldest_mark_index_ != meta_.current_mark_index_) {
      // 2-a, easy.
      ret.end_ = target.offset_end_;
    } else {
      // 2-b, now we have to populate target.offset_end_ ourselves.
      VLOG(0) << "This guy seems sleeping for a while.." << *this;
      // We can safely populate target.offset_end_, but be careful on reading offset_committed_.
      // If the thread now resumes working, it adds a new mark *and then* increments
      // offset_committed_. So, it's safe as far as we take appropriate fences.

      // well, a bit redundant fences, but this part is not executed so often. no issue.
      assorted::memory_fence_acquire();
      uint64_t committed_copy = meta_.offset_committed_;
      assorted::memory_fence_acquire();
      bool still_current = meta_.oldest_mark_index_ == meta_.current_mark_index_;
      assorted::memory_fence_acq_rel();
      if (still_current) {
        target.offset_end_ = committed_copy;
        VLOG(0) << "Okay, the logger populated the offset_end on behalf." << *this;
      } else {
        // This is super-rare.
        LOG(INFO) << "Interesting. The thread has now awaken and added a new mark. offset_end"
          << " should be now populated. "<< *this;
      }

      assorted::memory_fence_acquire();
      ret.end_ = target.offset_end_;
    }
  } else {
    // Case 3) First, consume stale marks as much as possible
    // (note, in this case "target.offset_begin_ == meta_.offset_durable_" might not hold
    ASSERT_ND(target.new_epoch_ < written_epoch);
    if (meta_.oldest_mark_index_ != meta_.current_mark_index_) {
      VLOG(0) << "Advancing oldest mark index. before=" << *this;
      while (meta_.oldest_mark_index_ != meta_.current_mark_index_
          && meta_.thread_epoch_marks_[meta_.oldest_mark_index_].new_epoch_ < written_epoch) {
        meta_.oldest_mark_index_
          = ThreadLogBufferMeta::increment_mark_index(meta_.oldest_mark_index_);
        ASSERT_ND(meta_.oldest_mark_index_ < ThreadLogBufferMeta::kMaxNonDurableEpochs);
        if (meta_.oldest_mark_index_ >= ThreadLogBufferMeta::kMaxNonDurableEpochs) {
          LOG(FATAL) << "meta_.oldest_mark_index_ out of range. we must have waited.";
        }
      }
      VLOG(0) << "Advanced oldest mark index. after=" << *this;
      // Then re-evaluate. It might be now Case 1 or 2. recursion, but essentially a retry.
      ret = get_logs_to_write(written_epoch);
    } else {
      VLOG(1) << "Heh, this guy is still sleeping.." << *this;
      ret.begin_ = 0;
      ret.end_ = 0;
    }
  }
  return ret;
}

Here is the call graph for this function:

const ThreadLogBufferMeta& foedus::log::ThreadLogBuffer::get_meta ( ) const

inline

Returns the state of this buffer.

Definition at line 382 of file thread_log_buffer.hpp.

{ return meta_; }

uint64_t foedus::log::ThreadLogBuffer::get_offset_committed ( ) const

inline

This marks the position upto which transaction logs are committed by the thread.

Log writers can safely read log entries and write them to log files up to this place. When the transaction commits, this value is advanced by the thread. The only possible update pattern to this variable is advance by this thread. Thus, the log writer can safely read this variable without any fence or lock thanks to regular (either old value or new value, never garbage) read of 64-bit.

Definition at line 375 of file thread_log_buffer.hpp.

References foedus::log::ThreadLogBufferMeta::offset_committed_.

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

{ return meta_.offset_committed_; }

Here is the caller graph for this function:

uint64_t foedus::log::ThreadLogBuffer::get_offset_durable ( ) const

inline

This marks the position upto which the log writer durably wrote out to log files.

Everything after this position must not be discarded because they are not yet durable. When the log writer reads log entries after here, writes them to log file, and calls fsync, this variable is advanced by the log writer. This variable is read by this thread to check the end of the circular buffer.

Definition at line 372 of file thread_log_buffer.hpp.

References foedus::log::ThreadLogBufferMeta::offset_durable_.

{ return meta_.offset_durable_; }

uint64_t foedus::log::ThreadLogBuffer::get_offset_head ( ) const

inline

This marks the position where log entries start.

This private log buffer is a circular buffer where the head is eaten by log gleaner. However, log gleaner is okay to get behind, reading from log file instead (but slower). Thus, offset_head_ is advanced either by log gleaner or this thread. If the latter happens, log gleaner has to give up using in-memory logs and instead read from log files.

Definition at line 369 of file thread_log_buffer.hpp.

References foedus::log::ThreadLogBufferMeta::offset_head_.

{ return meta_.offset_head_; }

uint64_t foedus::log::ThreadLogBuffer::get_offset_tail ( ) const

inline

The current cursor to which next log will be written.

This is the location the current transaction of this thread is writing to before commit. When the transaction commits, offset_committed_ catches up with this. When the transaction aborts, this value rolls back to offset_committed_. Only this thread reads/writes to this variable. No other threads access this.

Definition at line 378 of file thread_log_buffer.hpp.

References foedus::log::ThreadLogBufferMeta::offset_tail_.

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

{ return meta_.offset_tail_; }

Here is the caller graph for this function:

thread::ThreadId foedus::log::ThreadLogBuffer::get_thread_id ( ) const

inline

Definition at line 311 of file thread_log_buffer.hpp.

References foedus::log::ThreadLogBufferMeta::thread_id_.

{ return meta_.thread_id_; }

uint64_t foedus::log::ThreadLogBuffer::head_to_tail_distance ( ) const

inline

Definition at line 338 of file thread_log_buffer.hpp.

References foedus::log::ThreadLogBufferMeta::buffer_size_, distance(), foedus::log::ThreadLogBufferMeta::offset_head_, and foedus::log::ThreadLogBufferMeta::offset_tail_.

Referenced by reserve_new_log(), and wait_for_space().

                                                          {
    return distance(meta_.buffer_size_, meta_.offset_head_, meta_.offset_tail_);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::log::ThreadLogBuffer::initialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 110 of file thread_log_buffer.cpp.

References foedus::log::ThreadLogBufferMeta::buffer_size_, foedus::log::ThreadLogBufferMeta::buffer_size_safe_, foedus::log::ThreadLogBufferMeta::current_mark_index_, foedus::memory::AlignedMemorySlice::get_block(), foedus::memory::NumaNodeMemory::get_core_memory(), foedus::savepoint::SavepointManager::get_initial_current_epoch(), foedus::savepoint::SavepointManager::get_initial_durable_epoch(), foedus::memory::EngineMemory::get_local_memory(), foedus::memory::NumaCoreMemory::get_log_buffer_memory(), foedus::Engine::get_memory_manager(), foedus::Engine::get_savepoint_manager(), foedus::memory::AlignedMemorySlice::get_size(), foedus::kRetOk, foedus::log::ThreadLogBufferMeta::offset_committed_, foedus::log::ThreadLogBufferMeta::offset_durable_, foedus::log::ThreadLogBufferMeta::offset_head_, foedus::log::ThreadLogBufferMeta::offset_tail_, foedus::log::ThreadLogBufferMeta::oldest_mark_index_, foedus::log::ThreadLogBufferMeta::thread_epoch_marks_, and foedus::log::ThreadLogBufferMeta::thread_id_.

                                            {
  memory::NumaCoreMemory *memory
    = engine_->get_memory_manager()->get_local_memory()->get_core_memory(meta_.thread_id_);
  memory::AlignedMemorySlice buffer_memory = memory->get_log_buffer_memory();
  buffer_ = reinterpret_cast<char*>(buffer_memory.get_block());
  meta_.buffer_size_ = buffer_memory.get_size();
  meta_.buffer_size_safe_ = meta_.buffer_size_ - 64;

  meta_.offset_head_ = 0;
  meta_.offset_durable_ = 0;
  meta_.offset_committed_ = 0;
  meta_.offset_tail_ = 0;

  Epoch initial_current = engine_->get_savepoint_manager()->get_initial_current_epoch();
  Epoch initial_durable = engine_->get_savepoint_manager()->get_initial_durable_epoch();
  meta_.current_mark_index_ = 0;
  meta_.oldest_mark_index_ = 0;
  meta_.thread_epoch_marks_[0] = ThreadEpockMark(initial_durable, initial_current, 0);
  return kRetOk;
}

Here is the call graph for this function:

void foedus::log::ThreadLogBuffer::on_log_written

(

Epoch

written_epoch

)

Called when the logger wrote out all logs in the given epoch, advancing oldest_mark_index_.

Definition at line 303 of file thread_log_buffer.cpp.

References ASSERT_ND, foedus::log::ThreadLogBufferMeta::current_mark_index_, foedus::log::ThreadLogBufferMeta::increment_mark_index(), foedus::log::ThreadEpockMark::new_epoch_, foedus::log::ThreadEpockMark::offset_begin_, foedus::log::ThreadLogBufferMeta::offset_durable_, foedus::log::ThreadEpockMark::offset_end_, foedus::log::ThreadLogBufferMeta::oldest_mark_index_, and foedus::log::ThreadLogBufferMeta::thread_epoch_marks_.

                                                        {
  // See ThreadLogBufferMeta's class comment about tricky cases (the thread being idle).
  // assert_consistent(); this verification assumes the worker is not working. we can't use it here

  ThreadEpockMark& target = meta_.thread_epoch_marks_[meta_.oldest_mark_index_];
  if (target.new_epoch_ > written_epoch) {
    // Case 1) no thing to do.
    ASSERT_ND(target.offset_begin_ == meta_.offset_durable_);
  } else if (target.new_epoch_ == written_epoch) {
    // Case 2) Is it 2-a? or 2-b?
    ASSERT_ND(target.offset_begin_ == meta_.offset_durable_);
    meta_.offset_durable_ = target.offset_end_;
    if (meta_.oldest_mark_index_ != meta_.current_mark_index_) {
      // 2-a, go to next mark.
      meta_.oldest_mark_index_
        = ThreadLogBufferMeta::increment_mark_index(meta_.oldest_mark_index_);
    } else {
      // 2-b, remains here. Will be case-3 next time.
    }
  } else {
    // Case 3 (even after consuming stale marks). Do nothing.
    ASSERT_ND(target.new_epoch_ < written_epoch);
  }
  DVLOG(0) << "Logger has written out all logs in epoch-" << written_epoch << ". " << *this;
  // assert_consistent(); this verification assumes the worker is not working. we can't use it here
}

Here is the call graph for this function:

ThreadLogBuffer& foedus::log::ThreadLogBuffer::operator= ( const ThreadLogBuffer &  other )

delete

void foedus::log::ThreadLogBuffer::publish_committed_log ( Epoch  commit_epoch )

inline

Called when the current transaction is successfully committed.

Definition at line 345 of file thread_log_buffer.hpp.

References ASSERT_ND, get_last_epoch(), foedus::log::ThreadLogBufferMeta::offset_committed_, foedus::log::ThreadLogBufferMeta::offset_tail_, and UNLIKELY.

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

                                                                      {
    Epoch last_epoch = get_last_epoch();
    ASSERT_ND(commit_epoch >= last_epoch);
    if (UNLIKELY(commit_epoch > last_epoch)) {
      on_new_epoch_observed(commit_epoch);  // epoch switches!
    } else if (UNLIKELY(commit_epoch < last_epoch)) {
      // This MUST not happen because it means an already durable epoch received a new log!
      crash_stale_commit_epoch(commit_epoch);
    }
    meta_.offset_committed_ = meta_.offset_tail_;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

char* foedus::log::ThreadLogBuffer::reserve_new_log ( uint16_t  log_length )

inline

Reserves a space for a new (uncommitted) log entry at the tail.

Parameters

[in]

log_length

byte size of the log. You have to give it beforehand.

If the circular buffer's tail reaches the head, this method might block. But it will be rare as we release a large region of buffer at each time.

Definition at line 320 of file thread_log_buffer.hpp.

References advance(), ASSERT_ND, foedus::log::ThreadLogBufferMeta::buffer_size_, foedus::log::ThreadLogBufferMeta::buffer_size_safe_, head_to_tail_distance(), foedus::log::ThreadLogBufferMeta::offset_tail_, UNLIKELY, and wait_for_space().

Referenced by foedus::storage::sequential::SequentialStorage::append_record(), foedus::storage::masstree::MasstreeStoragePimpl::delete_general(), foedus::storage::hash::HashStoragePimpl::delete_record(), foedus::storage::masstree::MasstreeStoragePimpl::increment_general(), foedus::storage::array::ArrayStoragePimpl::increment_record(), foedus::storage::hash::HashStoragePimpl::increment_record(), foedus::storage::array::ArrayStoragePimpl::increment_record_oneshot(), foedus::storage::masstree::MasstreeStoragePimpl::insert_general(), foedus::storage::hash::HashStoragePimpl::insert_record(), foedus::storage::masstree::MasstreeStoragePimpl::overwrite_general(), foedus::storage::array::ArrayStoragePimpl::overwrite_record(), foedus::storage::hash::HashStoragePimpl::overwrite_record(), foedus::storage::array::ArrayStoragePimpl::overwrite_record_primitive(), foedus::storage::masstree::MasstreeStoragePimpl::upsert_general(), and foedus::storage::hash::HashStoragePimpl::upsert_record().

                                                                 {
    if (UNLIKELY(log_length + meta_.offset_tail_ >= meta_.buffer_size_)) {
      // now we need wrap around. to simplify, let's avoid having a log entry spanning the
      // end of the buffer. put a filler log to fill the rest.
      fillup_tail();
      ASSERT_ND(meta_.offset_tail_ == 0);
    }
    // also make sure tail isn't too close to head (full). in that case, we wait for loggers
    if (UNLIKELY(
      head_to_tail_distance() + log_length >= meta_.buffer_size_safe_)) {
      wait_for_space(log_length);
      ASSERT_ND(head_to_tail_distance() + log_length < meta_.buffer_size_safe_);
    }
    ASSERT_ND(head_to_tail_distance() + log_length < meta_.buffer_size_safe_);
    char *buffer = buffer_ + meta_.offset_tail_;
    advance(meta_.buffer_size_, &meta_.offset_tail_, log_length);
    return buffer;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::log::ThreadLogBuffer::uninitialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 131 of file thread_log_buffer.cpp.

References foedus::kRetOk.

                                              {
  buffer_ = nullptr;
  return kRetOk;
}

void foedus::log::ThreadLogBuffer::wait_for_space

(

uint16_t

required_space

)

Called when we have to wait till offset_head_ advances so that we can put new logs.

Definition at line 136 of file thread_log_buffer.cpp.

References assert_consistent(), ASSERT_ND, foedus::log::ThreadLogBufferMeta::buffer_size_safe_, foedus::log::LogOptions::emulation_, foedus::Engine::get_log_manager(), foedus::Engine::get_options(), head_to_tail_distance(), foedus::EngineOptions::log_, foedus::assorted::memory_fence_acquire(), foedus::assorted::memory_fence_release(), foedus::fs::DeviceEmulationOptions::null_device_, foedus::log::ThreadLogBufferMeta::offset_committed_, foedus::log::ThreadLogBufferMeta::offset_durable_, foedus::log::ThreadLogBufferMeta::offset_head_, foedus::log::ThreadLogBufferMeta::thread_id_, and foedus::log::LogManager::wakeup_loggers().

Referenced by reserve_new_log().

                                                            {
  assert_consistent();
  LOG(INFO) << "Thread-" << meta_.thread_id_ << " waiting for space to write logs..";
  if (engine_->get_options().log_.emulation_.null_device_) {
    // logging disabled
    meta_.offset_head_ = meta_.offset_durable_ = meta_.offset_committed_;
    assorted::memory_fence_release();
    return;
  }
  // @spinlock, but with a sleep (not in critical path, usually).
  while (head_to_tail_distance() + required_space >= meta_.buffer_size_safe_) {
    assorted::memory_fence_acquire();
    if (meta_.offset_durable_ != meta_.offset_head_) {
      // TASK(Hideaki) actually we should kick axx of log gleaner in this case.
      LOG(INFO) << "Thread-" << meta_.thread_id_ << " moving head to durable: " << *this;
      assorted::memory_fence_release();
      meta_.offset_head_ = meta_.offset_durable_;
      assorted::memory_fence_release();
    } else {
      LOG(WARNING) << "Thread-" << meta_.thread_id_ << " logger is getting behind. sleeping "
        << " for a while.." << *this;
      engine_->get_log_manager()->wakeup_loggers();
      // TASK(Hideaki) this duration should be configurable.
      std::this_thread::sleep_for(std::chrono::milliseconds(20));
    }
  }
  ASSERT_ND(head_to_tail_distance() + required_space < meta_.buffer_size_safe_);
  assert_consistent();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

friend class Logger

friend

Definition at line 268 of file thread_log_buffer.hpp.

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

friend

Definition at line 330 of file thread_log_buffer.cpp.

                                                                {
  o << v.meta_;
  return o;
}

---

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

• /home/shino/foedus_code/foedus-core/include/foedus/log/thread_log_buffer.hpp
• /home/shino/foedus_code/foedus-core/src/foedus/log/thread_log_buffer.cpp