A view of Logger object for other SOCs and master engine. More...

Detailed Description

A view of Logger object for other SOCs and master engine.

Definition at line 35 of file logger_ref.hpp.

#include <logger_ref.hpp>

Inheritance diagram for foedus::log::LoggerRef:

[legend]

Collaboration diagram for foedus::log::LoggerRef:

[legend]

Public Member Functions
	LoggerRef ()

	LoggerRef (Engine engine, LoggerControlBlock block, LoggerId id, uint16_t numa_node, uint16_t in_node_ordinal)

Epoch	get_durable_epoch () const
	Returns this logger's durable epoch. More...

void	wakeup ()
	Wakes up this logger if it is sleeping. More...

void	wakeup_for_durable_epoch (Epoch desired_durable_epoch)
	Wakes up this logger if its durable_epoch has not reached the given epoch yet. More...

void	copy_logger_state (savepoint::Savepoint *new_savepoint) const
	Called from log manager's copy_logger_states. More...

void	add_epoch_history (const EpochMarkerLogType &epoch_marker)
	Append a new epoch history. More...

LogRange	get_log_range (Epoch prev_epoch, Epoch until_epoch)
	Constructs the range of log entries that represent the given epoch ranges. More...

Public Member Functions inherited from foedus::Attachable< LoggerControlBlock >
	Attachable ()

	Attachable (Engine *engine)

	Attachable (Engine engine, LoggerControlBlock control_block)

	Attachable (LoggerControlBlock *control_block)

	Attachable (const Attachable &other)

virtual	~Attachable ()

Attachable &	operator= (const Attachable &other)

virtual void	attach (LoggerControlBlock *control_block)
	Attaches to the given shared memory. More...

bool	is_attached () const
	Returns whether the object has been already attached to some shared memory. More...

LoggerControlBlock *	get_control_block () const

Engine *	get_engine () const

void	set_engine (Engine *engine)

Protected Attributes
LoggerId	id_

uint16_t	numa_node_

uint16_t	in_node_ordinal_

Protected Attributes inherited from foedus::Attachable< LoggerControlBlock >
Engine *	engine_
	Most attachable object stores an engine pointer (local engine), so we define it here. More...

LoggerControlBlock *	control_block_
	The shared data on shared memory that has been initialized in some SOC or master engine. More...

Constructor & Destructor Documentation

foedus::log::LoggerRef::LoggerRef ( )

Definition at line 28 of file logger_ref.cpp.

28 : Attachable<LoggerControlBlock>() {}

foedus::log::LoggerRef::LoggerRef	(	Engine *	engine,
		LoggerControlBlock *	block,
		LoggerId	id,
		uint16_t	numa_node,
		uint16_t	in_node_ordinal
	)

Definition at line 29 of file logger_ref.cpp.

References id_, in_node_ordinal_, and numa_node_.

   : Attachable<LoggerControlBlock>(engine, block) {
   id_ = id;
   numa_node_ = numa_node;
   in_node_ordinal_ = in_node_ordinal;
 }

Member Function Documentation

void foedus::log::LoggerRef::add_epoch_history ( const EpochMarkerLogType & epoch_marker )

Append a new epoch history.

Definition at line 65 of file logger_ref.cpp.

References ASSERT_ND, foedus::Attachable< LoggerControlBlock >::control_block_, id_, foedus::log::LoggerControlBlock::kMaxEpochHistory, foedus::log::EpochMarkerLogType::new_epoch_, and foedus::log::EpochMarkerLogType::old_epoch_.

Referenced by foedus::log::EpochMarkerLogType::apply_engine().

                                                                         {
   soc::SharedMutexScope scope(&control_block_->epoch_history_mutex_);
   uint32_t tail_index = control_block_->get_tail_epoch_history();
   ASSERT_ND(control_block_->epoch_history_count_ == 0
     || control_block_->epoch_histories_[tail_index].new_epoch_ ==  epoch_marker.old_epoch_);
   // the first epoch marker is allowed only if it's a dummy marker.
   // this simplifies the detection of first epoch marker
   if (!control_block_->is_epoch_history_empty()
       && epoch_marker.old_epoch_ == epoch_marker.new_epoch_) {
     LOG(INFO) << "Ignored a dummy epoch marker while replaying epoch marker log on Logger-"
       << id_ << ". marker=" << epoch_marker;
   } else {
     if (control_block_->epoch_history_count_ >= LoggerControlBlock::kMaxEpochHistory) {
       // TASK(Hideaki) To avoid this, we should maintain sparse history, like one history per
       // tens of epochs. So far kMaxEpochHistory is enough big, so it won't happen.
       LOG(FATAL) << "Exceeded kMaxEpochHistory. Unexpected.";
     }
     ++control_block_->epoch_history_count_;
     tail_index = control_block_->get_tail_epoch_history();
     control_block_->epoch_histories_[tail_index] = EpochHistory(epoch_marker);
     ASSERT_ND(control_block_->epoch_histories_[tail_index].new_epoch_.is_valid());
     ASSERT_ND(control_block_->epoch_histories_[tail_index].old_epoch_.is_valid());
   }
 }

Here is the caller graph for this function:

void foedus::log::LoggerRef::copy_logger_state ( savepoint::Savepoint * new_savepoint ) const

Called from log manager's copy_logger_states.

Definition at line 56 of file logger_ref.cpp.

References foedus::Attachable< LoggerControlBlock >::control_block_, foedus::savepoint::Savepoint::current_log_files_, foedus::savepoint::Savepoint::current_log_files_offset_durable_, foedus::savepoint::Savepoint::oldest_log_files_, and foedus::savepoint::Savepoint::oldest_log_files_offset_begin_.

                                                                          {
   new_savepoint->oldest_log_files_.push_back(control_block_->oldest_ordinal_);
   new_savepoint->oldest_log_files_offset_begin_.push_back(
     control_block_->oldest_file_offset_begin_);
   new_savepoint->current_log_files_.push_back(control_block_->current_ordinal_);
   new_savepoint->current_log_files_offset_durable_.push_back(
     control_block_->current_file_durable_offset_);
 }

Epoch foedus::log::LoggerRef::get_durable_epoch ( ) const

Returns this logger's durable epoch.

Definition at line 41 of file logger_ref.cpp.

References foedus::Attachable< LoggerControlBlock >::control_block_.

Referenced by get_log_range(), foedus::log::operator<<(), and wakeup_for_durable_epoch().

                                          {
   return Epoch(control_block_->durable_epoch_);
 }

Here is the caller graph for this function:

LogRange foedus::log::LoggerRef::get_log_range	(	Epoch	prev_epoch,
		Epoch	until_epoch
	)

Constructs the range of log entries that represent the given epoch ranges.

Parameters

[in]	prev_epoch	Log entries until this epoch are skipped. An invalid epoch means from the beginning.
[in]	until_epoch	Log entries until this epoch are contained. Must be valid.

Returns: log range that contains all logs (prev_epoch, until_epoch]. In other owrds, from prev_epoch-exclusive and to until_epoch-inclusive.

In case there is no ending epoch marker (only when marked_epoch_ < durable_epoch_.one_more()) this method writes out a new epoch marker. This method is called only for each snapshotting, so it shouldn't be too big a waste.

Definition at line 91 of file logger_ref.cpp.

References ASSERT_ND, foedus::log::LogRange::begin_file_ordinal, foedus::log::LogRange::begin_offset, foedus::Attachable< LoggerControlBlock >::control_block_, foedus::log::LogRange::end_file_ordinal, foedus::log::LogRange::end_offset, get_durable_epoch(), id_, foedus::Epoch::is_valid(), foedus::log::EpochHistory::log_file_offset_, foedus::log::EpochHistory::log_file_ordinal_, and foedus::log::EpochHistory::new_epoch_.

Referenced by foedus::snapshot::LogMapper::handle_process().

                                                                      {
   // TASK(Hideaki) binary search. we assume there are not many epoch histories, so not urgent.
   ASSERT_ND(until_epoch <= get_durable_epoch());
   LogRange result;
 
   // Epoch mark is not written to empty epoch. Thus, we might holes at the beginning, in the
   // middle, and at the end. Be careful.
   soc::SharedMutexScope scope(&control_block_->epoch_history_mutex_);
   const uint32_t head = control_block_->epoch_history_head_;
   const uint32_t count = control_block_->epoch_history_count_;
   uint32_t pos = 0;  // RELATIVE position from head
   result.begin_file_ordinal = 0;
   result.begin_offset = 0;
   if (prev_epoch.is_valid()) {
     // first, locate the prev_epoch
     for (; pos < count; ++pos) {
       uint32_t abs_pos = control_block_->wrap_epoch_history_index(head + pos);
       const EpochHistory& cur = control_block_->epoch_histories_[abs_pos];
       if (cur.new_epoch_ > prev_epoch) {
         result.begin_file_ordinal = cur.log_file_ordinal_;
         result.begin_offset = cur.log_file_offset_;
         break;
       }
     }
     if (pos == count) {
       LOG(INFO) << "No epoch mark found for " << prev_epoch << " in logger-" << id_
         << " This usually happens when there was no transactional log before system shutdown";
       result.end_file_ordinal = 0;
       result.end_offset = 0;
       return result;
     }
   }
 
   // next, locate until_epoch. we might not find it if the logger was idle for a while.
   // in that case, the last mark tells the file/ordinal.
   for (; pos < count; ++pos) {
     uint32_t abs_pos = control_block_->wrap_epoch_history_index(head + pos);
     const EpochHistory& cur = control_block_->epoch_histories_[abs_pos];
     // first mark that is after the until_epoch tells how much we have to read.
     // note that we might have multiple marks of the same epoch because of beginning-of-file marker.
     // we can't stop at the first mark with new_epoch==until.
     if (cur.new_epoch_ > until_epoch) {
       result.end_file_ordinal = cur.log_file_ordinal_;
       result.end_offset = cur.log_file_offset_;
       break;
     }
   }
 
   if (pos == count) {
     if (count == 0) {
       ASSERT_ND(result.begin_file_ordinal == 0);
       ASSERT_ND(result.begin_offset == 0);
       result.end_file_ordinal = 0;
       result.end_offset = 0;
     } else {
       // in this case, we read everything.
       result.end_file_ordinal = control_block_->current_ordinal_;
       result.end_offset = control_block_->current_file_durable_offset_;
     }
   }
 
   ASSERT_ND(result.begin_file_ordinal <= result.end_file_ordinal);
   ASSERT_ND(result.begin_file_ordinal < result.end_file_ordinal
     || result.begin_offset <= result.end_offset);
   return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void foedus::log::LoggerRef::wakeup ( )

Wakes up this logger if it is sleeping.

Definition at line 52 of file logger_ref.cpp.

References foedus::Attachable< LoggerControlBlock >::control_block_.

Referenced by wakeup_for_durable_epoch().

                        {
   control_block_->wakeup_cond_.signal();
 }

Here is the caller graph for this function:

void foedus::log::LoggerRef::wakeup_for_durable_epoch ( Epoch desired_durable_epoch )

Wakes up this logger if its durable_epoch has not reached the given epoch yet.

If this logger's durable_epoch is already same or larger than the epoch, does nothing. This method just wakes up the logger and immediately returns.

Definition at line 45 of file logger_ref.cpp.

References get_durable_epoch(), foedus::assorted::memory_fence_acquire(), and wakeup().

                                                                     {
   assorted::memory_fence_acquire();
   if (get_durable_epoch() < desired_durable_epoch) {
     wakeup();
   }
 }