foedus::restart::RestartManagerPimpl Class Reference

Pimpl object of RestartManager. More...

Detailed Description

Pimpl object of RestartManager.

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

Definition at line 44 of file restart_manager_pimpl.hpp.

#include <restart_manager_pimpl.hpp>

Inheritance diagram for foedus::restart::RestartManagerPimpl:

Collaboration diagram for foedus::restart::RestartManagerPimpl:

Public Member Functions
	RestartManagerPimpl ()=delete
	RestartManagerPimpl (Engine *engine)
ErrorStack	initialize_once () override
ErrorStack	uninitialize_once () override
ErrorStack	recover ()
	Recover the state of database from recent snapshot files and transaction logs. More...
ErrorStack	redo_meta_logs (Epoch durable_epoch, Epoch snapshot_epoch)
	Redo metadata operation (create/drop storage) since the latest snapshot. 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 ()

Public Attributes
Engine *const	engine_
RestartManagerControlBlock *	control_block_

Constructor & Destructor Documentation

foedus::restart::RestartManagerPimpl::RestartManagerPimpl ( )

delete

foedus::restart::RestartManagerPimpl::RestartManagerPimpl ( Engine *  engine )

inlineexplicit

Definition at line 47 of file restart_manager_pimpl.hpp.

: engine_(engine) {}

Member Function Documentation

ErrorStack foedus::restart::RestartManagerPimpl::initialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 40 of file restart_manager_pimpl.cpp.

References CHECK_ERROR, control_block_, engine_, ERROR_STACK, foedus::soc::SocManager::get_shared_memory_repo(), foedus::Engine::get_soc_manager(), foedus::Engine::get_xct_manager(), foedus::xct::XctManager::is_initialized(), foedus::Engine::is_master(), foedus::kErrorCodeDepedentModuleUnavailableInit, foedus::kRetOk, and recover().

                                                {
  if (!engine_->get_xct_manager()->is_initialized()) {
    return ERROR_STACK(kErrorCodeDepedentModuleUnavailableInit);
  }
  control_block_ = engine_->get_soc_manager()->get_shared_memory_repo()->
    get_global_memory_anchors()->restart_manager_memory_;

  // Restart manager works only in master
  if (engine_->is_master()) {
    LOG(INFO) << "Initializing RestartManager..";

    // after all other initializations, we trigger recovery procedure.
    CHECK_ERROR(recover());
  }
  return kRetOk;
}

Here is the call graph for this function:

ErrorStack foedus::restart::RestartManagerPimpl::recover

(

)

Recover the state of database from recent snapshot files and transaction logs.

Precondition

is_initialized(), and all other modules in the engine is_initialized().

Definition at line 71 of file restart_manager_pimpl.cpp.

References CHECK_ERROR, engine_, foedus::log::LogManager::get_durable_global_epoch(), foedus::Engine::get_log_manager(), foedus::snapshot::SnapshotManager::get_pimpl(), foedus::snapshot::SnapshotManager::get_snapshot_epoch(), foedus::Engine::get_snapshot_manager(), foedus::Engine::get_storage_manager(), foedus::snapshot::SnapshotManagerPimpl::handle_snapshot_triggered(), foedus::Epoch::kEpochInitialDurable, foedus::kRetOk, redo_meta_logs(), foedus::storage::StorageManager::reinitialize_for_recovered_snapshot(), and foedus::Epoch::value().

Referenced by initialize_once().

                                        {
  Epoch durable_epoch = engine_->get_log_manager()->get_durable_global_epoch();
  Epoch snapshot_epoch = engine_->get_snapshot_manager()->get_snapshot_epoch();
  LOG(INFO) << "Recovering the database... durable_epoch=" << durable_epoch
    << ", snapshot_epoch=" << snapshot_epoch;

  if (durable_epoch.value() == Epoch::kEpochInitialDurable) {
    if (!snapshot_epoch.is_valid()) {
      LOG(INFO) << "The database is in initial state. Nothing to recover.";
      return kRetOk;
    } else {
      // this means durable_epoch wraps around. nothing wrong, but worth logging.
      LOG(INFO) << "Interesting. durable_epoch is initial value, but we have snapshot."
        << " This means epoch wrapped around!";
    }
  }

  if (durable_epoch == snapshot_epoch) {
    LOG(INFO) << "The snapshot is up-to-date. No need to recover.";
    return kRetOk;
  }

  LOG(INFO) << "There are logs that are durable but not yet snapshotted.";
  CHECK_ERROR(redo_meta_logs(durable_epoch, snapshot_epoch));
  LOG(INFO) << "Launching snapshot..";
  snapshot::SnapshotManagerPimpl* snapshot_pimpl = engine_->get_snapshot_manager()->get_pimpl();
  snapshot::Snapshot the_snapshot;
  CHECK_ERROR(snapshot_pimpl->handle_snapshot_triggered(&the_snapshot));
  LOG(INFO) << "Finished initial snapshot during start-up.";

  // This fixes Bug #127.
  // Right after the recovery-snapshot, any non-null volatile root pages becomes stale.
  // we need to replace them with the new snapshot pages.
  CHECK_ERROR(engine_->get_storage_manager()->reinitialize_for_recovered_snapshot());

  LOG(INFO) << "Now we can start processing transaction";
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::restart::RestartManagerPimpl::redo_meta_logs	(	Epoch	durable_epoch,
		Epoch	snapshot_epoch
	)

Redo metadata operation (create/drop storage) since the latest snapshot.

Essentially this is the only thing the restart manager has to do.

Definition at line 110 of file restart_manager_pimpl.cpp.

References foedus::memory::AlignedMemory::alloc(), ASSERT_ND, foedus::log::LogOptions::construct_meta_log_path(), foedus::storage::StorageManager::drop_storage_apply(), foedus::log::LogOptions::emulation_, engine_, foedus::fs::file_size(), foedus::memory::AlignedMemory::get_block(), foedus::xct::XctId::get_epoch(), foedus::log::LogHeader::get_kind(), foedus::savepoint::SavepointManager::get_meta_logger_offsets(), foedus::Engine::get_options(), foedus::Engine::get_savepoint_manager(), foedus::Engine::get_storage_manager(), foedus::log::LogHeader::get_type(), foedus::log::BaseLogType::header_, foedus::Epoch::is_valid(), foedus::fs::DirectIoFile::kDirectIoSeekSet, foedus::log::kLogCodeArrayCreate, foedus::log::kLogCodeDropLogType, foedus::log::kLogCodeEpochMarker, foedus::log::kLogCodeFiller, foedus::log::kLogCodeHashCreate, foedus::log::kLogCodeInvalid, foedus::log::kLogCodeMasstreeCreate, foedus::log::kLogCodeSequentialCreate, foedus::memory::AlignedMemory::kNumaAllocOnnode, foedus::log::kRecordLogs, foedus::kRetOk, foedus::EngineOptions::log_, foedus::log::LogHeader::log_length_, foedus::log::LogHeader::storage_id_, WRAP_ERROR_CODE, and foedus::log::LogHeader::xct_id_.

Referenced by recover().

                                                                                        {
  ASSERT_ND(!snapshot_epoch.is_valid() || snapshot_epoch < durable_epoch);
  LOG(INFO) << "Redoing metadata operations from " << snapshot_epoch << " to " << durable_epoch;

  // Because metadata log is tiny, we do nothing complex here. Just read them all.
  fs::Path path(engine_->get_options().log_.construct_meta_log_path());
  fs::DirectIoFile file(path, engine_->get_options().log_.emulation_);
  WRAP_ERROR_CODE(file.open(true, false, false, false));
  uint64_t oldest_offset;
  uint64_t durable_offset;
  engine_->get_savepoint_manager()->get_meta_logger_offsets(&oldest_offset, &durable_offset);
  ASSERT_ND(oldest_offset % (1 << 12) == 0);
  ASSERT_ND(durable_offset % (1 << 12) == 0);
  ASSERT_ND(oldest_offset <= durable_offset);
  ASSERT_ND(fs::file_size(path) >= durable_offset);
  uint32_t read_size = durable_offset - oldest_offset;

  LOG(INFO) << "Will read " << read_size << " bytes from meta log";

  // Assuming it's tiny, just read it in one shot.
  memory::AlignedMemory buffer;
  buffer.alloc(read_size, 1U << 12, memory::AlignedMemory::kNumaAllocOnnode, 0);

  WRAP_ERROR_CODE(file.seek(oldest_offset, fs::DirectIoFile::kDirectIoSeekSet));
  WRAP_ERROR_CODE(file.read_raw(read_size, buffer.get_block()));

  char* buf = reinterpret_cast<char*>(buffer.get_block());
  uint32_t cur = 0;
  uint32_t processed = 0;
  storage::StorageManager* stm = engine_->get_storage_manager();
  while (cur < read_size) {
    log::BaseLogType* entry = reinterpret_cast<log::BaseLogType*>(buf + cur);
    ASSERT_ND(entry->header_.get_kind() != log::kRecordLogs);
    const uint32_t log_length = entry->header_.log_length_;
    cur += log_length;
    log::LogCode type = entry->header_.get_type();
    ASSERT_ND(type != log::kLogCodeInvalid);
    if (type == log::kLogCodeFiller || type == log::kLogCodeEpochMarker) {
      continue;
    }
    Epoch epoch = entry->header_.xct_id_.get_epoch();
    if (epoch > durable_epoch) {
      LOG(FATAL) << "WTF. This should have been checked in meta logger's startup??";
    }
    if (snapshot_epoch.is_valid() && epoch <= snapshot_epoch) {
      continue;
    }
    switch (type) {
      case log::kLogCodeDropLogType:
        LOG(INFO) << "Redoing DROP STORAGE-" << entry->header_.storage_id_;
        stm->drop_storage_apply(entry->header_.storage_id_);
        ++processed;
        break;
      case log::kLogCodeArrayCreate:
      case log::kLogCodeSequentialCreate:
      case log::kLogCodeHashCreate:
      case log::kLogCodeMasstreeCreate:
        reinterpret_cast<storage::CreateLogType*>(entry)->apply_storage(
          engine_,
          entry->header_.storage_id_);
        ++processed;
        break;
      default:
        LOG(ERROR) << "Unexpected log type in metadata log:" << entry->header_;
    }
  }

  file.close();
  LOG(INFO) << "Redone " << processed << " metadata operations";
  return kRetOk;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ErrorStack foedus::restart::RestartManagerPimpl::uninitialize_once ( )

overridevirtual

Implements foedus::DefaultInitializable.

Definition at line 57 of file restart_manager_pimpl.cpp.

References foedus::ErrorStackBatch::emprace_back(), engine_, ERROR_STACK, foedus::snapshot::SnapshotManager::get_pimpl(), foedus::Engine::get_snapshot_manager(), foedus::Engine::get_xct_manager(), foedus::xct::XctManager::is_initialized(), foedus::Engine::is_master(), foedus::kErrorCodeDepedentModuleUnavailableUninit, foedus::snapshot::SnapshotManagerPimpl::stop_snapshot_thread(), and SUMMARIZE_ERROR_BATCH.

                                                  {
  ErrorStackBatch batch;
  if (!engine_->get_xct_manager()->is_initialized()) {
    batch.emprace_back(ERROR_STACK(kErrorCodeDepedentModuleUnavailableUninit));
  }
  if (engine_->is_master()) {
    LOG(INFO) << "Uninitializing RestartManager..";
    // restart manager essentially has nothing to release, but because this is the first module
    // to uninit, we place "stop them first" kind of operations here.
    engine_->get_snapshot_manager()->get_pimpl()->stop_snapshot_thread();  // stop snapshot thread
  }
  return SUMMARIZE_ERROR_BATCH(batch);
}

Here is the call graph for this function:

Member Data Documentation

RestartManagerControlBlock* foedus::restart::RestartManagerPimpl::control_block_

Definition at line 63 of file restart_manager_pimpl.hpp.

Referenced by initialize_once().

Engine* const foedus::restart::RestartManagerPimpl::engine_

Definition at line 62 of file restart_manager_pimpl.hpp.

Referenced by initialize_once(), recover(), redo_meta_logs(), and uninitialize_once().

---

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

• /home/shino/foedus_code/foedus-core/include/foedus/restart/restart_manager_pimpl.hpp
• /home/shino/foedus_code/foedus-core/src/foedus/restart/restart_manager_pimpl.cpp