foedus::log::Logger Class Reference

A log writer that writes out buffered logs to stable storages. More...

Detailed Description

A log writer that writes out buffered logs to stable storages.

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.

Definition at line 168 of file logger_impl.hpp.

#include <logger_impl.hpp>

Inheritance diagram for foedus::log::Logger:

Collaboration diagram for foedus::log::Logger:

Public Member Functions
	Logger (Engine *engine, LoggerControlBlock *control_block, LoggerId id, thread::ThreadGroupId numa_node, uint8_t in_node_ordinal, const fs::Path &log_folder, const std::vector< thread::ThreadId > &assigned_thread_ids)
ErrorStack	initialize_once () override
ErrorStack	uninitialize_once () override
	Logger ()=delete
	Logger (const Logger &other)=delete
Logger &	operator= (const Logger &other)=delete
LogFileOrdinal	get_current_ordinal () const
bool	is_stop_requested () const
std::string	to_string () const
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 Member Functions inherited from foedus::log::LoggerRef
	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)

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

Additional Inherited Members
Protected Attributes inherited from foedus::log::LoggerRef
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::Logger::Logger ( Engine *  engine, LoggerControlBlock *  control_block, LoggerId  id, thread::ThreadGroupId  numa_node, uint8_t  in_node_ordinal, const fs::Path &  log_folder, const std::vector< thread::ThreadId > &  assigned_thread_ids  )

inline

Definition at line 170 of file logger_impl.hpp.

  : LoggerRef(engine, control_block, id, numa_node, in_node_ordinal),
    log_folder_(log_folder),
    assigned_thread_ids_(assigned_thread_ids) {}

foedus::log::Logger::Logger ( )

delete

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

delete

Member Function Documentation

LogFileOrdinal foedus::log::Logger::get_current_ordinal ( ) const

inline

Definition at line 188 of file logger_impl.hpp.

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

{ return control_block_->current_ordinal_; }

ErrorStack foedus::log::Logger::initialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 74 of file logger_impl.cpp.

References foedus::memory::NumaNodeMemory::allocate_numa_memory(), ASSERT_ND, CHECK_ERROR, foedus::log::LogOptions::construct_suffixed_log_path(), foedus::Attachable< LoggerControlBlock >::control_block_, foedus::thread::decompose_numa_local_ordinal(), foedus::log::LogOptions::emulation_, foedus::Attachable< LoggerControlBlock >::engine_, foedus::memory::AlignedMemory::get_alignment(), foedus::fs::DirectIoFile::get_current_offset(), foedus::savepoint::SavepointManager::get_initial_durable_epoch(), foedus::thread::ThreadPoolPimpl::get_local_group(), foedus::memory::EngineMemory::get_local_memory(), foedus::savepoint::SavepointManager::get_logger_savepoint(), foedus::Engine::get_memory_manager(), foedus::Engine::get_options(), foedus::thread::ThreadPool::get_pimpl(), foedus::Engine::get_savepoint_manager(), foedus::memory::AlignedMemory::get_size(), foedus::thread::ThreadGroup::get_thread(), foedus::Engine::get_thread_pool(), foedus::log::LoggerRef::id_, foedus::memory::AlignedMemory::is_null(), foedus::log::FillerLogType::kLogWriteUnitSize, foedus::kRetOk, foedus::EngineOptions::log_, foedus::log::LoggerRef::numa_node_, foedus::fs::DirectIoFile::open(), foedus::fs::DirectIoFile::truncate(), foedus::Epoch::value(), and WRAP_ERROR_CODE.

                                   {
  control_block_->initialize();
  // clear all variables
  current_file_ = nullptr;
  LOG(INFO) << "Initializing Logger-" << id_ << ". assigned " << assigned_thread_ids_.size()
    << " threads, starting from " << assigned_thread_ids_[0] << ", numa_node_="
    << static_cast<int>(numa_node_);

  // Initialize the values from the latest savepoint.
  savepoint::LoggerSavepointInfo info = engine_->get_savepoint_manager()->get_logger_savepoint(id_);
  // durable epoch from initial savepoint
  control_block_->durable_epoch_
    = engine_->get_savepoint_manager()->get_initial_durable_epoch().value();
  control_block_->marked_epoch_ = Epoch(control_block_->durable_epoch_);
  control_block_->oldest_ordinal_ = info.oldest_log_file_;  // ordinal/length too
  control_block_->current_ordinal_ = info.current_log_file_;
  control_block_->current_file_durable_offset_ = info.current_log_file_offset_durable_;
  control_block_->oldest_file_offset_begin_ = info.oldest_log_file_offset_begin_;
  current_file_path_ = engine_->get_options().log_.construct_suffixed_log_path(
    numa_node_,
    id_,
    control_block_->current_ordinal_);
  // open the log file
  current_file_ = new fs::DirectIoFile(current_file_path_,
                     engine_->get_options().log_.emulation_);
  WRAP_ERROR_CODE(current_file_->open(true, true, true, true));
  if (control_block_->current_file_durable_offset_ < current_file_->get_current_offset()) {
    // there are non-durable regions as an incomplete remnant of previous execution.
    // probably there was a crash. in this case, we discard the non-durable regions.
    LOG(ERROR) << "Logger-" << id_ << "'s log file has a non-durable region. Probably there"
      << " was a crash. Will truncate it to " << control_block_->current_file_durable_offset_
      << " from " << current_file_->get_current_offset();
    WRAP_ERROR_CODE(current_file_->truncate(
      control_block_->current_file_durable_offset_,
      true));  // sync right now
  }
  ASSERT_ND(control_block_->current_file_durable_offset_ == current_file_->get_current_offset());
  LOG(INFO) << "Initialized logger: " << *this;

  // which threads are assigned to me?
  for (auto thread_id : assigned_thread_ids_) {
    assigned_threads_.push_back(
      engine_->get_thread_pool()->get_pimpl()->get_local_group()->get_thread(
        thread::decompose_numa_local_ordinal(thread_id)));
  }

  // grab a buffer to pad incomplete blocks for direct file I/O
  CHECK_ERROR(engine_->get_memory_manager()->get_local_memory()->allocate_numa_memory(
    FillerLogType::kLogWriteUnitSize, &fill_buffer_));
  ASSERT_ND(!fill_buffer_.is_null());
  ASSERT_ND(fill_buffer_.get_size() >= FillerLogType::kLogWriteUnitSize);
  ASSERT_ND(fill_buffer_.get_alignment() >= FillerLogType::kLogWriteUnitSize);
  LOG(INFO) << "Logger-" << id_ << " grabbed a padding buffer. size=" << fill_buffer_.get_size();
  CHECK_ERROR(write_dummy_epoch_mark());

  // log file and buffer prepared. let's launch the logger thread
  logger_thread_ = std::move(std::thread(&Logger::handle_logger, this));

  assert_consistent();
  return kRetOk;
}

Here is the call graph for this function:

bool foedus::log::Logger::is_stop_requested ( ) const

inline

Definition at line 189 of file logger_impl.hpp.

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

{ return control_block_->stop_requested_; }

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

delete

std::string foedus::log::Logger::to_string

(

)

const

Definition at line 528 of file logger_impl.cpp.

                                  {
  std::stringstream stream;
  stream << *this;
  return stream.str();
}

ErrorStack foedus::log::Logger::uninitialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 136 of file logger_impl.cpp.

References foedus::fs::DirectIoFile::close(), foedus::Attachable< LoggerControlBlock >::control_block_, foedus::log::LoggerRef::id_, foedus::memory::AlignedMemory::release_block(), and SUMMARIZE_ERROR_BATCH.

                                     {
  LOG(INFO) << "Uninitializing Logger-" << id_ << ": " << *this;
  ErrorStackBatch batch;
  if (logger_thread_.joinable()) {
    {
      control_block_->stop_requested_ = true;
      control_block_->wakeup_cond_.signal();
    }
    logger_thread_.join();
  }
  if (current_file_) {
    current_file_->close();
    delete current_file_;
    current_file_ = nullptr;
  }
  fill_buffer_.release_block();
  control_block_->uninitialize();
  return SUMMARIZE_ERROR_BATCH(batch);
}

Here is the call graph for this function:

Friends And Related Function Documentation

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

friend

Definition at line 533 of file logger_impl.cpp.

                                                       {
  o << "<Logger>"
    << "<id_>" << v.id_ << "</id_>"
    << "<numa_node_>" << static_cast<int>(v.numa_node_) << "</numa_node_>"
    << "<in_node_ordinal_>" << static_cast<int>(v.in_node_ordinal_) << "</in_node_ordinal_>"
    << "<log_folder_>" << v.log_folder_ << "</log_folder_>";
  o << "<assigned_thread_ids_>";
  for (auto thread_id : v.assigned_thread_ids_) {
    o << "<thread_id>" << thread_id << "</thread_id>";
  }
  o << "</assigned_thread_ids_>";
  o << "<durable_epoch_>" << v.get_durable_epoch() << "</durable_epoch_>"
    << "<marked_epoch_>" << v.control_block_->marked_epoch_ << "</marked_epoch_>"
    << "<oldest_ordinal_>" << v.control_block_->oldest_ordinal_ << "</oldest_ordinal_>"
    << "<oldest_file_offset_begin_>" << v.control_block_->oldest_file_offset_begin_
      << "</oldest_file_offset_begin_>"
    << "<current_ordinal_>" << v.control_block_->current_ordinal_ << "</current_ordinal_>";

  o << "<current_file_>";
  if (v.current_file_) {
    o << *v.current_file_;
  } else {
    o << "nullptr";
  }
  o << "</current_file_>";

  o << "<current_file_path_>" << v.current_file_path_ << "</current_file_path_>";

  o << "<current_file_length_>";
  if (v.current_file_) {
    o << v.current_file_->get_current_offset();
  } else {
    o << "nullptr";
  }
  o << "</current_file_length_>";

  o << "<epoch_history_head>"
    << v.control_block_->epoch_history_head_ << "</epoch_history_head>";
  o << "<epoch_history_count>"
    << v.control_block_->epoch_history_count_ << "</epoch_history_count>";
  o << "</Logger>";
  return o;
}

---

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

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