foedus::log Namespace Reference

Log Manager, which writes out transactional logs. More...

Detailed Description

Log Manager, which writes out transactional logs.

This package contains classes that control transactional logging.

Decentralized Logging

Unlike traditional log manager in DBMS, this log manager is decentralized, meaning each log writer writes to its own file concurrently. This eliminates the bottleneck in log manager when there are a large number of cores. The basic idea to guarantee serializability is the epoch-based commit protocol, which does the check on all loggers before returning the results to client in a way similar to group-commit.

Thread-private log buffer

Each ThreadLoadBugger instance maintains a thread-local log buffer that is filled by the thread without any synchronization or blocking. The logger collects them and writes them out to log files. A single log writer handles one or more transactional threads (cores), and a single NUMA node hosts one or more log writers.

See also

foedus::log::ThreadLogBuffer

Log Writer

Each Logger instance writes out files suffixed with ordinal (eg ".0", ".1"...). The older logs files are deactivated and deleted after log gleaner consumes them.

See also

foedus::log::Logger

Global Durable Epoch

An important job of Log Manager is to maintain the global durable epoch. Log manager is the module to determine when it's safe to advance the global durable epoch. It makes sure all loggers flushed their logs up to the epoch, invoked required fsync(), and also takes a savepoint before it announces the new global durable epoch.

See also

foedus::log::LogManager

Classes
struct	BaseLogType
	Base class for log type. More...
struct	EngineLogType
	Base class for log type of engine-wide operation. More...
struct	EpochHistory
	Represents an event where a logger switched its epoch. More...
struct	EpochMarkerLogType
	A log type to declare a switch of epoch in a logger or the engine. More...
struct	FillerLogType
	A dummy log type to fill up a sector in log files. More...
class	Logger
	A log writer that writes out buffered logs to stable storages. More...
struct	LoggerControlBlock
	Shared data of Logger. More...
class	LoggerRef
	A view of Logger object for other SOCs and master engine. More...
struct	LogHeader
	A common header part for all log types. More...
class	LogManager
	Log Manager class that provides API to write/read transaction logs. More...
struct	LogManagerControlBlock
	Shared data in LogManagerPimpl. More...
class	LogManagerPimpl
	Pimpl object of LogManager. More...
struct	LogOptions
	Set of options for log manager. More...
struct	LogRange
	a contiguous range of log entries that might span multiple files. More...
class	MetaLogBuffer
	A single log buffer for metadata (eg create/drop storage). More...
struct	MetaLogControlBlock
	Control block for MetaLogBuffer and MetaLogger. More...
class	MetaLogger
	A log writer for metadata operation. More...
struct	RecordLogType
	Base class for log type of record-wise operation. More...
struct	StorageLogType
	Base class for log type of storage-wide operation. More...
struct	ThreadEpockMark
	A thread-buffer's epoch marker, which indicates where a thread switched an epoch. More...
class	ThreadLogBuffer
	A thread-local log buffer. More...
struct	ThreadLogBufferMeta
	Metadata part of ThreadLogBuffer, without the actual buffer which is way way larger. More...

Typedefs
typedef uint16_t	LoggerId
	Typedef for an ID of Logger. More...
typedef uint32_t	LogFileOrdinal
	Ordinal of log files (eg "log.0", "log.1"). More...

Enumerations
enum	LogCode {   kLogCodeInvalid = 0, kLogCodeFiller = 0x3001, kLogCodeEpochMarker = 0x3002, kLogCodeDropLogType = 0x1011,   kLogCodeArrayCreate = 0x1021, kLogCodeArrayOverwrite = 0x0022, kLogCodeArrayIncrement = 0x0023, kLogCodeSequentialTruncate = 0x1024,   kLogCodeSequentialCreate = 0x1025, kLogCodeSequentialAppend = 0x0026, kLogCodeHashCreate = 0x1027, kLogCodeHashOverwrite = 0x0028,   kLogCodeHashInsert = 0x0029, kLogCodeHashDelete = 0x002A, kLogCodeHashUpdate = 0x002B, kLogCodeMasstreeCreate = 0x1031,   kLogCodeMasstreeOverwrite = 0x0032, kLogCodeMasstreeInsert = 0x0033, kLogCodeMasstreeDelete = 0x0034, kLogCodeMasstreeUpdate = 0x0035 }
	A unique identifier of all log types. More...
enum	LogCodeKind { kRecordLogs = 0, kStorageLogs = 1, kEngineLogs = 2, kMarkerLogs = 3 }
	Represents the kind of log types. More...

Functions
void	_dummy_static_size_check__COUNTER__ ()
LogCodeKind	get_log_code_kind (LogCode code)
	Returns the kind of the given log code. More...
bool	is_valid_log_type (LogCode code)
	Returns if the LogCode value exists. More...
const char *	get_log_type_name (LogCode code)
	Returns the names of LogCode enum defined in log_type.xmacro. More...
template<typename LOG_TYPE >
constexpr LogCode	get_log_code ()
	Returns LogCode for the log type defined in log_type.xmacro. More...
template<>
constexpr LogCode	get_log_code< foedus::log::FillerLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::log::EpochMarkerLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::DropLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::array::ArrayCreateLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::array::ArrayOverwriteLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::array::ArrayIncrementLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::sequential::SequentialTruncateLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::sequential::SequentialCreateLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::sequential::SequentialAppendLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::hash::HashCreateLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::hash::HashOverwriteLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::hash::HashInsertLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::hash::HashDeleteLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::hash::HashUpdateLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::masstree::MasstreeCreateLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::masstree::MasstreeOverwriteLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::masstree::MasstreeInsertLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::masstree::MasstreeDeleteLogType > ()
template<>
constexpr LogCode	get_log_code< foedus::storage::masstree::MasstreeUpdateLogType > ()
void	invoke_apply_engine (void *log_buffer, thread::Thread *context)
	Invokes the apply logic for an engine-wide log type. More...
void	invoke_apply_storage (void *log_buffer, Engine *engine, storage::StorageId id)
	Invokes the apply logic for a storage-wide log type. More...
void	invoke_apply_record (void *log_buffer, thread::Thread *context, storage::StorageId storage_id, xct::RwLockableXctId *owner_id_address, char *payload_address)
	Invokes the apply logic for a record-wise log type. More...
void	invoke_assert_valid (void *log_buffer)
	Invokes the assertion logic of each log type. More...
void	invoke_ostream (const void *buffer, std::ostream *ptr)
	Invokes the ostream operator for the given log type defined in log_type.xmacro. More...
std::ostream &	operator<< (std::ostream &o, const LogHeader &v)
std::ostream &	operator<< (std::ostream &o, const FillerLogType &v)
std::ostream &	operator<< (std::ostream &o, const EpochMarkerLogType &v)
std::ostream &	operator<< (std::ostream &o, const EpochHistory &v)
bool	is_log_aligned (uint64_t offset)
uint64_t	align_log_ceil (uint64_t offset)
uint64_t	align_log_floor (uint64_t offset)
std::ostream &	operator<< (std::ostream &o, const Logger &v)
std::ostream &	operator<< (std::ostream &o, const MetaLogBuffer &v)
void	on_non_durable_meta_log_found (const log::LogHeader *entry, Epoch durable_epoch, uint64_t offset)
std::ostream &	operator<< (std::ostream &o, const MetaLogger &v)
std::ostream &	operator<< (std::ostream &o, const ThreadLogBuffer &v)
std::ostream &	operator<< (std::ostream &o, const ThreadLogBufferMeta &v)
std::ostream &	operator<< (std::ostream &o, const ThreadEpockMark &v)

Function Documentation

void foedus::log::_dummy_static_size_check__COUNTER__ ( )

inline

Definition at line 115 of file common_log_types.hpp.

: public BaseLogType {

uint64_t foedus::log::align_log_ceil ( uint64_t  offset )

inline

Definition at line 62 of file logger_impl.cpp.

                                                {
  return assorted::align< uint64_t, FillerLogType::kLogWriteUnitSize >(offset);
}

uint64_t foedus::log::align_log_floor ( uint64_t  offset )

inline

Definition at line 65 of file logger_impl.cpp.

References foedus::log::FillerLogType::kLogWriteUnitSize.

                                                 {
  if (offset % FillerLogType::kLogWriteUnitSize == 0) {
    return offset;
  } else {
    return assorted::align< uint64_t, FillerLogType::kLogWriteUnitSize >(offset)
      - FillerLogType::kLogWriteUnitSize;
  }
}

template<>

constexpr LogCode foedus::log::get_log_code< foedus::log::EpochMarkerLogType > ( )

inline

Definition at line 23 of file log_type.hpp.

{

template<>

constexpr LogCode foedus::log::get_log_code< foedus::log::FillerLogType > ( )

inline

Definition at line 22 of file log_type.hpp.

{

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::array::ArrayCreateLogType > ( )

inline

Definition at line 25 of file log_type.hpp.

{

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::array::ArrayIncrementLogType > ( )

inline

Definition at line 27 of file log_type.hpp.

{

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::array::ArrayOverwriteLogType > ( )

inline

Definition at line 26 of file log_type.hpp.

{

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::DropLogType > ( )

inline

Definition at line 24 of file log_type.hpp.

{

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::hash::HashCreateLogType > ( )

inline

Definition at line 31 of file log_type.hpp.

{

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::hash::HashDeleteLogType > ( )

inline

Definition at line 34 of file log_type.hpp.

:
 *

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::hash::HashInsertLogType > ( )

inline

Definition at line 33 of file log_type.hpp.

{

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::hash::HashOverwriteLogType > ( )

inline

Definition at line 32 of file log_type.hpp.

{

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::hash::HashUpdateLogType > ( )

inline

Definition at line 35 of file log_type.hpp.

:
 *

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::masstree::MasstreeCreateLogType > ( )

inline

Definition at line 36 of file log_type.hpp.

:
 *

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::masstree::MasstreeDeleteLogType > ( )

inline

Definition at line 39 of file log_type.hpp.

: For engine-wide operation.

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::masstree::MasstreeInsertLogType > ( )

inline

Definition at line 38 of file log_type.hpp.

:
 *

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::masstree::MasstreeOverwriteLogType > ( )

inline

Definition at line 37 of file log_type.hpp.

:
 *

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::masstree::MasstreeUpdateLogType > ( )

inline

Definition at line 40 of file log_type.hpp.

: For engine-wide operation.

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::sequential::SequentialAppendLogType > ( )

inline

Definition at line 30 of file log_type.hpp.

{

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::sequential::SequentialCreateLogType > ( )

inline

Definition at line 29 of file log_type.hpp.

{

template<>

constexpr LogCode foedus::log::get_log_code< foedus::storage::sequential::SequentialTruncateLogType > ( )

inline

Definition at line 28 of file log_type.hpp.

{

bool foedus::log::is_log_aligned ( uint64_t  offset )

inline

Definition at line 59 of file logger_impl.cpp.

References foedus::log::FillerLogType::kLogWriteUnitSize.

                                            {
  return offset % FillerLogType::kLogWriteUnitSize == 0;
}

void foedus::log::on_non_durable_meta_log_found	(	const log::LogHeader *	entry,
		Epoch	durable_epoch,
		uint64_t	offset
	)

Definition at line 64 of file meta_logger_impl.cpp.

References foedus::xct::XctId::get_epoch_int(), foedus::xct::XctId::get_ordinal(), invoke_ostream(), foedus::log::LogHeader::log_length_, foedus::log::LogHeader::log_type_code_, foedus::log::LogHeader::storage_id_, and foedus::log::LogHeader::xct_id_.

                   {
  std::stringstream ss;
  ss << "    <Log offset=\"" << assorted::Hex(offset) << "\""
    << " len=\"" << assorted::Hex(entry->log_length_) << "\""
    << " type=\"" << assorted::Hex(entry->log_type_code_) << "\""
    << " storage_id=\"" << assorted::Hex(entry->storage_id_) << "\"";
  if (entry->log_length_ >= 8U) {
    ss << " xct_id_epoch=\"" << entry->xct_id_.get_epoch_int() << "\"";
    ss << " xct_id_ordinal=\"" << entry->xct_id_.get_ordinal() << "\"";
  }
  ss << ">";
  log::invoke_ostream(entry, &ss);
  ss << "</Log>";
  LOG(WARNING) << "Found a meta log that is not in durable epoch (" << durable_epoch
    << "). Probably the last run didn't invoke wait_for_commit(). The operation is discarded."
    << " Log content:" << std::endl << ss.str();
}

Here is the call graph for this function:

std::ostream& foedus::log::operator<<	(	std::ostream &	o,
		const EpochHistory &	v
	)

Definition at line 26 of file epoch_history.cpp.

References foedus::log::EpochHistory::log_file_offset_, foedus::log::EpochHistory::log_file_ordinal_, foedus::log::EpochHistory::new_epoch_, and foedus::log::EpochHistory::old_epoch_.

                                                             {
  o << "<EpochHistory old_epoch=\"" << v.old_epoch_ << "\" new_epoch=\"" << v.new_epoch_
    << "\" log_file_ordinal=\"" << v.log_file_ordinal_
    << "\" log_file_offset_=\"" << assorted::Hex(v.log_file_offset_) << "\" />";
  return o;
}

std::ostream& foedus::log::operator<<	(	std::ostream &	o,
		const LogHeader &	v
	)

Definition at line 31 of file common_log_types.cpp.

References get_log_type_name(), foedus::log::LogHeader::get_type(), foedus::log::LogHeader::log_length_, foedus::log::LogHeader::log_type_code_, and foedus::log::LogHeader::storage_id_.

                                                          {
  o << "<Header type=\"" << assorted::Hex(v.log_type_code_) << "\" type_name=\""
    << get_log_type_name(v.get_type()) << "\" length=\"" << assorted::Hex(v.log_length_)
    << "\" storage_id=\"" << v.storage_id_ << "\" />";
  return o;
}

Here is the call graph for this function:

std::ostream& foedus::log::operator<<	(	std::ostream &	o,
		const FillerLogType &	v
	)

Definition at line 37 of file common_log_types.cpp.

References foedus::log::BaseLogType::header_.

                                                              {
  o << "<FillerLog>" << v.header_ << "</FillerLog>";
  return o;
}

std::ostream& foedus::log::operator<<	(	std::ostream &	o,
		const EpochMarkerLogType &	v
	)

Definition at line 42 of file common_log_types.cpp.

References foedus::log::BaseLogType::header_, foedus::log::EpochMarkerLogType::log_file_offset_, foedus::log::EpochMarkerLogType::log_file_ordinal_, foedus::log::EpochMarkerLogType::logger_id_, foedus::log::EpochMarkerLogType::logger_in_node_ordinal_, foedus::log::EpochMarkerLogType::logger_numa_node_, foedus::log::EpochMarkerLogType::new_epoch_, and foedus::log::EpochMarkerLogType::old_epoch_.

                                                                   {
  o << "<EpochMarker>" << v.header_
    << "<old_epoch_>" << v.old_epoch_ << "</old_epoch_>"
    << "<new_epoch_>" << v.new_epoch_ << "</new_epoch_>"
    << "<logger_numa_node_>" << static_cast<int>(v.logger_numa_node_) << "</logger_numa_node_>"
    << "<logger_in_node_ordinal_>"
      << static_cast<int>(v.logger_in_node_ordinal_) << "</logger_in_node_ordinal_>"
    << "<logger_id_>" << v.logger_id_ << "</logger_id_>"
    << "<log_file_ordinal_>" << v.log_file_ordinal_ << "</log_file_ordinal_>"
    << "<log_file_offset_>" << assorted::Hex(v.log_file_offset_) << "</log_file_offset_>"
    << "</EpochMarker>";
  return o;
}

std::ostream& foedus::log::operator<<	(	std::ostream &	o,
		const MetaLogBuffer &	v
	)

Definition at line 70 of file meta_log_buffer.cpp.

References foedus::log::MetaLogControlBlock::buffer_used_, foedus::Attachable< CONTROL_BLOCK >::control_block_, foedus::log::MetaLogControlBlock::durable_offset_, and foedus::log::MetaLogControlBlock::oldest_offset_.

                                                              {
  o << "<MetaLogBuffer>"
    << "<buffer_used_>" << v.control_block_->buffer_used_ << "</buffer_used_>"
    << "<oldest_offset_>" << v.control_block_->oldest_offset_ << "</oldest_offset_>"
    << "<durable_offset_>" << v.control_block_->durable_offset_ << "</durable_offset_>"
    << "</MetaLogBuffer>";
  return o;
}

std::ostream& foedus::log::operator<<	(	std::ostream &	o,
		const MetaLogger &	v
	)

Definition at line 228 of file meta_logger_impl.cpp.

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

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

Definition at line 330 of file thread_log_buffer.cpp.

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

std::ostream& foedus::log::operator<<	(	std::ostream &	o,
		const ThreadLogBufferMeta &	v
	)

Definition at line 335 of file thread_log_buffer.cpp.

References foedus::log::ThreadLogBufferMeta::buffer_size_, foedus::log::ThreadLogBufferMeta::current_mark_index_, foedus::log::ThreadLogBufferMeta::increment_mark_index(), 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_.

                                                                    {
  o << "<ThreadLogBuffer>";
  o << "<thread_id_>" << v.thread_id_ << "</thread_id_>";
  o << "<buffer_size_>" << v.buffer_size_ << "</buffer_size_>";
  o << "<offset_head_>" << v.offset_head_ << "</offset_head_>";
  o << "<offset_durable_>" << v.offset_durable_ << "</offset_durable_>";
  o << "<offset_committed_>" << v.offset_committed_ << "</offset_committed_>";
  o << "<offset_tail_>" << v.offset_tail_ << "</offset_tail_>";
  o << "<thread_epoch_marks"
    << " oldest=\"" << v.oldest_mark_index_ << "\""
    << " current=\"" << v.current_mark_index_ << "\""
    << ">";

  // from oldest (inclusive) to current (exclusive).
  for (uint32_t i = v.oldest_mark_index_;
        i != v.current_mark_index_;
        i = ThreadLogBufferMeta::increment_mark_index(i)) {
    o << "<Entry index=\"" << i << "\">" << v.thread_epoch_marks_[i] << "</Entry>";
  }
  // also write out current entry
  o << "<Entry index=\"" << v.current_mark_index_ << "\">"
    << v.thread_epoch_marks_[v.current_mark_index_]
    << "</Entry>";
  o << "</thread_epoch_marks>";
  o << "</ThreadLogBuffer>";
  return o;
}

Here is the call graph for this function:

std::ostream& foedus::log::operator<<	(	std::ostream &	o,
		const ThreadEpockMark &	v
	)

Definition at line 363 of file thread_log_buffer.cpp.

References foedus::log::ThreadEpockMark::new_epoch_, foedus::log::ThreadEpockMark::offset_begin_, foedus::log::ThreadEpockMark::offset_end_, and foedus::log::ThreadEpockMark::old_epoch_.

                                                                {
  o << "<ThreadEpockMark "
    << " old=\"" << v.old_epoch_ << "\""
    << " new=\"" << v.new_epoch_ << "\""
    << " offset_begin=\"" << assorted::Hex(v.offset_begin_) << "\""
    << " offset_end=\"" << assorted::Hex(v.offset_end_) << "\""
    << " />";
  return o;
}

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

Definition at line 533 of file logger_impl.cpp.

References foedus::Attachable< CONTROL_BLOCK >::control_block_, foedus::log::LoggerControlBlock::current_ordinal_, foedus::log::LoggerControlBlock::epoch_history_count_, foedus::log::LoggerControlBlock::epoch_history_head_, foedus::fs::DirectIoFile::get_current_offset(), foedus::log::LoggerRef::get_durable_epoch(), foedus::log::LoggerRef::id_, foedus::log::LoggerRef::in_node_ordinal_, foedus::log::LoggerControlBlock::marked_epoch_, foedus::log::LoggerRef::numa_node_, foedus::log::LoggerControlBlock::oldest_file_offset_begin_, and foedus::log::LoggerControlBlock::oldest_ordinal_.

                                                       {
  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;
}

Here is the call graph for this function: