RestartableDataWriter Class Reference

Writer for restartable data, to be read by the RestartableDataReader. More...

#include <RestartableDataWriter.h>

Inheritance diagram for RestartableDataWriter:

Public Member Functions
	RestartableDataWriter (MooseApp &app, RestartableDataMap &data)
	RestartableDataWriter (MooseApp &app, std::vector< RestartableDataMap > &data)
void	write (std::ostream &header_stream, std::ostream &data_stream)
	Writes the restartable data to header stream header_stream and data stream data_stream.
std::vector< std::filesystem::path >	write (const std::filesystem::path &folder_base)
	Writes the restartable data to the folder with base folder_base.
PerfGraph &	perfGraph ()
	Get the PerfGraph.
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const

Static Public Member Functions
static const std::string &	getRestartableExt ()
static const std::string &	restartableDataFile ()
static std::filesystem::path	restartableDataFile (const std::filesystem::path &folder_base)
static const std::string &	restartableHeaderFile ()
static std::filesystem::path	restartableHeaderFile (const std::filesystem::path &folder_base)
static std::filesystem::path	restartableDataFolder (const std::filesystem::path &folder_base)
static InputParameters	validParams ()

Protected Types
typedef int	COMPARE_HASH_CODE_TYPE
	The type to used for comparing hash codes (sanity checking)

Protected Member Functions
RestartableDataMap &	currentData (const THREAD_ID tid)
std::size_t	dataSize () const
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing.
PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing.
std::string	timedSectionName (const std::string &section_name) const

Protected Attributes
const std::variant< RestartableDataMap *, std::vector< RestartableDataMap > * >	_data
	The data we wish to act on This is a variant so that we can act on threaded and non-threaded data.
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.
const std::string	_prefix
	A prefix to use for all sections.
const Parallel::Communicator &	_communicator

Static Protected Attributes
static const unsigned int	CURRENT_BACKUP_FILE_VERSION = 4
	The current version for the backup file.

Detailed Description

Writer for restartable data, to be read by the RestartableDataReader.

Definition at line 17 of file RestartableDataWriter.h.

Member Typedef Documentation

COMPARE_HASH_CODE_TYPE

typedef int RestartableDataIO::COMPARE_HASH_CODE_TYPE

protectedinherited

The type to used for comparing hash codes (sanity checking)

Definition at line 84 of file RestartableDataIO.h.

Constructor & Destructor Documentation

RestartableDataWriter() [1/2]

RestartableDataWriter::RestartableDataWriter	(	MooseApp &	app,
		RestartableDataMap &	data
	)

Definition at line 18 of file RestartableDataWriter.C.

  : RestartableDataIO(app, data)
{
}

RestartableDataWriter() [2/2]

RestartableDataWriter::RestartableDataWriter	(	MooseApp &	app,
		std::vector< RestartableDataMap > &	data
	)

Definition at line 23 of file RestartableDataWriter.C.

  : RestartableDataIO(app, data)
{
}

Member Function Documentation

currentData()

RestartableDataMap & RestartableDataIO::currentData ( const THREAD_ID  tid )

protectedinherited

Returns

The restartable data for thread tid

This exists so that we can support threaded and non-threaded data in _data

Definition at line 33 of file RestartableDataIO.C.

{
  mooseAssert(dataSize() > tid, "Invalid thread");
 
  if (std::holds_alternative<RestartableDataMap *>(_data))
    return *std::get<RestartableDataMap *>(_data);
  return (*std::get<std::vector<RestartableDataMap> *>(_data))[tid];
}

Referenced by RestartableDataReader::restore(), RestartableDataReader::restoreData(), and write().

dataSize()

std::size_t RestartableDataIO::dataSize ( ) const

protectedinherited

Returns

The size of _data

Definition at line 43 of file RestartableDataIO.C.

{
  return std::holds_alternative<RestartableDataMap *>(_data)
             ? 1
             : std::get<std::vector<RestartableDataMap> *>(_data)->size();
}

Referenced by RestartableDataIO::currentData(), RestartableDataReader::readHeader(), RestartableDataReader::restore(), and write().

getRestartableExt()

const std::string & RestartableDataIO::getRestartableExt ( )

staticinherited

Returns

The common extension for restartable data folders

Definition at line 51 of file RestartableDataIO.C.

{
  static const std::string ext = ".rd";
  return ext;
}

Referenced by RestartableDataIO::restartableDataFolder().

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), PerfGraphReporter::finalize(), and PerfGraphOutput::output().

registerTimedSection() [1/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level  ) const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns

The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

registerTimedSection() [2/2]

PerfID PerfGraphInterface::registerTimedSection ( const std::string &  section_name, const unsigned int  level, const std::string &  live_message, const bool  print_dots = true  ) const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)
live_message	The message to be printed to the screen during execution
print_dots	Whether or not progress dots should be printed for this section

Returns

The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(
        timedSectionName(section_name), level, live_message, print_dots);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

restartableDataFile() [1/2]

const std::string & RestartableDataIO::restartableDataFile ( )

staticinherited

Returns

The filename for the restartable data

Definition at line 58 of file RestartableDataIO.C.

{
  static const std::string file = "data";
  return file;
}

Referenced by RestartableDataReader::isAvailable(), RestartableDataIO::restartableDataFile(), RestartableDataReader::setInput(), and write().

restartableDataFile() [2/2]

std::filesystem::path RestartableDataIO::restartableDataFile ( const std::filesystem::path &  folder_base )

staticinherited

Returns

The path to the restartable data file with base folder_base

Does not append .rd to the folder base

Definition at line 80 of file RestartableDataIO.C.

{
  return folder_base / restartableDataFile();
}

restartableDataFolder()

std::filesystem::path RestartableDataIO::restartableDataFolder ( const std::filesystem::path &  folder_base )

staticinherited

Returns

The path to the restartable data folder with base folder_base

This just appends .rd

Definition at line 72 of file RestartableDataIO.C.

{
  auto folder = folder_base;
  folder += getRestartableExt();
  return folder;
}

Referenced by MooseApp::metaDataFolderBase(), and MooseApp::restartFolderBase().

restartableHeaderFile() [1/2]

const std::string & RestartableDataIO::restartableHeaderFile ( )

staticinherited

Returns

The filename for the restartable header

Definition at line 65 of file RestartableDataIO.C.

{
  static const std::string file = "header";
  return file;
}

Referenced by RestartableDataIO::restartableHeaderFile(), RestartableDataReader::setInput(), and write().

restartableHeaderFile() [2/2]

std::filesystem::path RestartableDataIO::restartableHeaderFile ( const std::filesystem::path &  folder_base )

staticinherited

Returns

The path to the restartable header file with base folder_base

Does not append .rd to the folder base

Definition at line 86 of file RestartableDataIO.C.

{
  return folder_base / restartableHeaderFile();
}

timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string &  section_name ) const

protectedinherited

Returns

The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

{
  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
}

Referenced by PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

validParams()

InputParameters PerfGraphInterface::validParams ( )

staticinherited

Definition at line 16 of file PerfGraphInterface.C.

{
  InputParameters params = emptyInputParameters();
  return params;
}

Referenced by Convergence::validParams().

write() [1/2]

std::vector< std::filesystem::path > RestartableDataWriter::write

(

const std::filesystem::path &

folder_base

)

Writes the restartable data to the folder with base folder_base.

Definition at line 87 of file RestartableDataWriter.C.

{
  const auto header_file = restartableHeaderFile(folder_base);
  const auto data_file = restartableDataFile(folder_base);
 
  // Make the folder if it doesn't exist
  const auto dir = header_file.parent_path();
  mooseAssert(dir == data_file.parent_path(), "Inconsistent directories");
  if (!std::filesystem::exists(dir))
  {
    std::error_code err;
    if (!std::filesystem::create_directory(dir, err))
      mooseError("Unable to create restart directory\n",
                 std::filesystem::absolute(dir),
                 "\n\n",
                 err.message());
  }
 
  // We want to keep track of the paths that we create so that we can
  // return them for file management later (primarily removing old checkpoints)
  std::vector<std::filesystem::path> paths;
 
  // Helper for opening a stream for use
  auto open = [&paths](const std::filesystem::path & filename)
  {
    std::ofstream stream;
    stream.open(filename.c_str(), std::ios::out | std::ios::binary);
    if (!stream.is_open())
      mooseError(
          "Unable to open restart file ", std::filesystem::absolute(filename), " for writing");
    paths.push_back(filename);
    return stream;
  };
 
  // Open and write
  auto header_stream = open(header_file);
  auto data_stream = open(data_file);
  write(header_stream, data_stream);
 
  // Update the folder's modified time to now for consistency
  // (this used in checking for the latest checkpoint)
  const auto data_write_time = std::filesystem::last_write_time(header_file);
  std::filesystem::last_write_time(dir, data_write_time);
 
  return paths;
}

write() [2/2]

void RestartableDataWriter::write	(	std::ostream &	header_stream,
		std::ostream &	data_stream
	)

Writes the restartable data to header stream header_stream and data stream data_stream.

Definition at line 29 of file RestartableDataWriter.C.

{
  // Set everything as not stored
  for (const auto tid : make_range(dataSize()))
    for (auto & value : currentData(tid))
      value.setNotStored({});
 
  // Header
  char id[] = {'R', 'D'};
  header_stream.write(id, 2);
 
  // File version
  auto file_version = CURRENT_BACKUP_FILE_VERSION;
  dataStore(header_stream, file_version, nullptr);
 
  // Type hash for basic hash
  std::size_t compare_hash_code = typeid(COMPARE_HASH_CODE_TYPE).hash_code();
  dataStore(header_stream, compare_hash_code, nullptr);
 
  // Number of procs
  auto n_procs = n_processors();
  dataStore(header_stream, n_procs, nullptr);
 
  // Number of data
  auto num_data = dataSize();
  dataStore(header_stream, num_data, nullptr);
 
  // Size of data for each thread
  for (const auto tid : make_range(dataSize()))
  {
    std::size_t n_data = currentData(tid).size();
    dataStore(header_stream, n_data, nullptr);
  }
 
  // Write out the RestartableData header, and store the actual data separately
  for (const auto tid : make_range(dataSize()))
    for (auto & data : currentData(tid))
    {
      // Store the data
      const std::size_t data_start_position = static_cast<std::size_t>(data_stream.tellp());
      data.store(data_stream);
      std::size_t data_size = static_cast<std::size_t>(data_stream.tellp()) - data_start_position;
 
      // Store name, size, type hash, and type in the header
      mooseAssert(data.name().size(), "Empty name");
      std::string name = data.name();
      std::string type = data.typeId().name();
      std::size_t type_hash_code = data.typeId().hash_code();
      bool has_context = data.hasContext();
      dataStore(header_stream, name, nullptr);
      dataStore(header_stream, data_size, nullptr);
      dataStore(header_stream, type_hash_code, nullptr);
      dataStore(header_stream, type, nullptr);
      dataStore(header_stream, has_context, nullptr);
    }
}

Referenced by MooseApp::backup(), MooseApp::backup(), write(), and MooseApp::writeRestartableMetaData().

Member Data Documentation

_data

const std::variant<RestartableDataMap *, std::vector<RestartableDataMap> *> RestartableDataIO::_data

protectedinherited

The data we wish to act on This is a variant so that we can act on threaded and non-threaded data.

Definition at line 79 of file RestartableDataIO.h.

Referenced by RestartableDataIO::currentData(), and RestartableDataIO::dataSize().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

_prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

CURRENT_BACKUP_FILE_VERSION

const unsigned int RestartableDataIO::CURRENT_BACKUP_FILE_VERSION = 4

staticprotectedinherited

The current version for the backup file.

Definition at line 82 of file RestartableDataIO.h.

Referenced by RestartableDataReader::readHeader().

---

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

• include/restart/RestartableDataWriter.h
• src/restart/RestartableDataWriter.C