RestartableDataReader Class Reference

Reader for restartable data written by the RestartableDataWriter. More...

#include <RestartableDataReader.h>

Inheritance diagram for RestartableDataReader:

Classes
struct	HeaderEntry
	Struct that describes data in the header. More...
struct	InputStreams
	Structure that contains the input streams for the reader. More...

Public Member Functions
	RestartableDataReader (MooseApp &app, RestartableDataMap &data, const bool force=false)
	RestartableDataReader (MooseApp &app, std::vector< RestartableDataMap > &data, const bool force=false)
void	setInput (std::unique_ptr< std::stringstream > header_stream, std::unique_ptr< std::stringstream > data_stream)
	Sets the input stream for reading from the stringstreams header_stream and data_stream for the header and data, respectively. More...
void	setInput (const std::filesystem::path &folder_base)
	Sets the input stream for reading to the file with the folder base folder_base. More...
bool	isRestoring () const
InputStreams	clear ()
	Clears the contents of the reader (header stream, data stream, header) More...
void	restore (const DataNames &filter_names={})
	Restores the restartable data. More...
template<typename T , typename... Args>
T &	restoreData (const std::string &data_name, const THREAD_ID tid=0, void *const context=nullptr, Args &&... args)
	Restores the data with name data_name of type T. More...
template<typename T >
bool	hasData (const std::string &data_name, const THREAD_ID tid=0) const
PerfGraph &	perfGraph ()
	Get the PerfGraph. More...
const Parallel::Communicator &	comm () const
processor_id_type	n_processors () const
processor_id_type	processor_id () const
void	setErrorOnLoadWithDifferentNumberOfProcessors (bool value)

Static Public Member Functions
static bool	isAvailable (const std::filesystem::path &folder_base)
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) More...

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. More...
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. More...
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. More...
MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph. More...
const std::string	_prefix
	A prefix to use for all sections. More...
const Parallel::Communicator &	_communicator

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

Private Member Functions
bool	hasData (const std::string &data_name, const std::type_info &type, const THREAD_ID tid) const
std::vector< std::unordered_map< std::string, HeaderEntry > >	readHeader (InputStream &header_input) const
	Internal method for reading the header (stored by RestartableDataWriter) More...
void	deserializeValue (InputStream &data_input, RestartableDataValue &value, const HeaderEntry &header_entry) const
	Internal method for deserializing (restoring from backup into a value) More...
void	requireRestoring () const
	Checks whether or not we're currently restoring and errors if not. More...
const HeaderEntry *	queryHeader (const std::string &data_name, const THREAD_ID tid) const
const HeaderEntry &	getHeader (const std::string &data_name, const THREAD_ID tid) const
bool	isSameType (const HeaderEntry &header_entry, const std::type_info &type) const
RestartableDataValue &	restoreData (const std::string &data_name, std::unique_ptr< RestartableDataValue > value, const THREAD_ID tid)
	Internal method for restoring a new data value. More...

Private Attributes
InputStreams	_streams
	The inputs for reading. More...
std::vector< std::unordered_map< std::string, HeaderEntry > >	_header
	The loaded headers from the restart. More...
bool	_is_restoring
	Whether or not we're currently restoring. More...
bool	_error_on_different_number_of_processors
	Whether or not to error with a different number of processors. More...
const bool	_force
	Whether or not to forcefully attempt to read despite incompatibilities. More...

Detailed Description

Reader for restartable data written by the RestartableDataWriter.

Definition at line 23 of file RestartableDataReader.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

RestartableDataReader() [1/2]

RestartableDataReader::RestartableDataReader	(	MooseApp &	app,
		RestartableDataMap &	data,
		const bool	force = false
	)

Definition at line 25 of file RestartableDataReader.C.

  : RestartableDataIO(app, data),
    _is_restoring(false),
    _error_on_different_number_of_processors(true),
    _force(force)
{
}

RestartableDataReader() [2/2]

RestartableDataReader::RestartableDataReader	(	MooseApp &	app,
		std::vector< RestartableDataMap > &	data,
		const bool	force = false
	)

Definition at line 35 of file RestartableDataReader.C.

  : RestartableDataIO(app, data),
    _is_restoring(false),
    _error_on_different_number_of_processors(true),
    _force(force)
{
}

Member Function Documentation

clear()

RestartableDataReader::InputStreams RestartableDataReader::clear

(

)

Clears the contents of the reader (header stream, data stream, header)

This returns ownership of the resulting input in the event that it should be retained

Definition at line 65 of file RestartableDataReader.C.

Referenced by MooseApp::finalizeRestore().

{
  _is_restoring = false;
  _header.clear();
  InputStreams streams;
  std::swap(_streams, streams);
  return streams;
}

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.

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

{
  mooseAssert(dataSize() > tid, "Invalid thread");

  if (std::holds_alternative<RestartableDataMap *>(_data))
    return *std::get<RestartableDataMap *>(_data);
  return (*std::get<std::vector<RestartableDataMap> *>(_data))[tid];
}

dataSize()

std::size_t RestartableDataIO::dataSize ( ) const

protectedinherited

Returns

The size of _data

Definition at line 43 of file RestartableDataIO.C.

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

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

deserializeValue()

void RestartableDataReader::deserializeValue ( InputStream &  data_input, RestartableDataValue &  value, const HeaderEntry &  header_entry  ) const

private

Internal method for deserializing (restoring from backup into a value)

Definition at line 257 of file RestartableDataReader.C.

Referenced by restore(), and restoreData().

{
  mooseAssert(!value.loaded(), value.name() + " is already loaded");

  auto error = [&data_input, &value](auto... args)
  {
    std::stringstream err;
    err << "While loading restartable data\n\n";
    err << "From: ";
    const auto filename = data_input.getFilename();
    if (filename)
      err << std::filesystem::absolute(filename->parent_path());
    else
      err << "memory";
    err << "\nData name: " << value.name();
    err << "\nData type: " << value.type();
    err << "\n\n";
    mooseError(err.str(), args...);
  };

  if (!isSameType(header_entry, value.typeId()))
    error("The stored type of '", header_entry.type, "' does not match");

  auto stream_ptr = data_input.get();
  auto & stream = *stream_ptr;

  stream.seekg(header_entry.position);
  value.load(stream);

  if (stream.tellg() == -1)
    error("An error was encountered when reading from the stream");

  const std::size_t loaded_size = stream.tellg() - header_entry.position;
  if (loaded_size != header_entry.size)
    error("The data read does not match the data stored\n\n",
          "Stored size: ",
          header_entry.size,
          "\nLoaded size: ",
          loaded_size);
}

getHeader()

const RestartableDataReader::HeaderEntry & RestartableDataReader::getHeader ( const std::string &  data_name, const THREAD_ID  tid  ) const

private

Returns

The header entry for the data with name data_name on thread tid.

Requires that restore() is called first to load the headers.

Definition at line 245 of file RestartableDataReader.C.

Referenced by restoreData().

{
  const auto header = queryHeader(data_name, tid);
  if (!header)
    mooseError(
        "RestartableDataReader::getHeader(): Failed to find a header entry for data with name '",
        data_name,
        "'");
  return *header;
}

getRestartableExt()

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

staticinherited

Returns

The common extension for restartable data folders

Definition at line 51 of file RestartableDataIO.C.

Referenced by RestartableDataIO::restartableDataFolder().

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

hasData() [1/2]

template<typename T >

bool RestartableDataReader::hasData ( const std::string &  data_name, const THREAD_ID  tid = 0  ) const

inline

Returns

Whether or not data exists in the headers with the name data_name with type T on thread tid

Requires that restore() is called first to load the headers.

Definition at line 125 of file RestartableDataReader.h.

  {
    return hasData(data_name, typeid(T), tid);
  }

hasData() [2/2]

bool RestartableDataReader::hasData ( const std::string &  data_name, const std::type_info &  type, const THREAD_ID  tid  ) const

private

Returns

Whether or not data exists in the headers with the name data_name with type type on thread tid

Requires that restore() is called first to load the headers.

Definition at line 225 of file RestartableDataReader.C.

{
  if (const auto header = queryHeader(data_name, tid))
    return isSameType(*header, type);
  return false;
}

isAvailable()

bool RestartableDataReader::isAvailable ( const std::filesystem::path &  folder_base )

static

Returns

Whether or not restartable data is available in the folder folder_base

Will error if the header is available and the data is not, or if the data is and the header is not.

Definition at line 302 of file RestartableDataReader.C.

Referenced by MooseUtils::getLatestCheckpointFilePrefix(), and MooseApp::possiblyLoadRestartableMetaData().

{
  const auto header_path = restartableDataFile(folder_base);
  const auto data_path = restartableDataFile(folder_base);

  const auto available = [](const auto & filename)
  { return MooseUtils::pathExists(filename) && MooseUtils::checkFileReadable(filename); };

  const bool header_available = available(header_path);
  const bool data_available = available(data_path);

  if (header_available != data_available)
    mooseError("The restart ",
               header_available ? "header" : "data",
               " is available but the corresponding ",
               header_available ? "data" : "header",
               " is not available\n\n",
               "Header (",
               header_available ? "available" : "missing",
               "): ",
               std::filesystem::absolute(header_path),
               "\nData (",
               data_available ? "available" : "missing",
               "): ",
               std::filesystem::absolute(header_path));

  return header_available && data_available;
}

isRestoring()

bool RestartableDataReader::isRestoring ( ) const

inline

Returns

Whether or not this reader is currently restoring

Definition at line 55 of file RestartableDataReader.h.

Referenced by MooseApp::finalizeRestore().

{ return _streams.data != nullptr; }

isSameType()

bool RestartableDataReader::isSameType ( const HeaderEntry &  header_entry, const std::type_info &  type  ) const

private

Returns

Whether or not the type type is the same as the type in header_entry

We need this because this check depends on whether or not we do a string comparison

Definition at line 342 of file RestartableDataReader.C.

Referenced by deserializeValue(), and hasData().

{
#ifndef RESTARTABLE_SKIP_CHECK_HASH_CODE
  if (header_entry.type_hash_code == type.hash_code())
    return true;
#endif
  return header_entry.type == type.name();
}

perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 78 of file PerfGraphInterface.C.

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

{
  return _pg_moose_app.perfGraph();
}

queryHeader()

const RestartableDataReader::HeaderEntry * RestartableDataReader::queryHeader ( const std::string &  data_name, const THREAD_ID  tid  ) const

private

Returns

The header entry for the data with name data_name on thread tid if it exists, and nullptr otherwise.

Requires that restore() is called first to load the headers.

Definition at line 235 of file RestartableDataReader.C.

Referenced by getHeader(), and hasData().

{
  requireRestoring();
  const auto it = _header[tid].find(data_name);
  if (it == _header[tid].end())
    return nullptr;
  return &it->second;
}

readHeader()

std::vector< std::unordered_map< std::string, RestartableDataReader::HeaderEntry > > RestartableDataReader::readHeader ( InputStream &  header_input ) const

private

Internal method for reading the header (stored by RestartableDataWriter)

Definition at line 75 of file RestartableDataReader.C.

Referenced by restore().

{
  std::vector<std::unordered_map<std::string, RestartableDataReader::HeaderEntry>> header;

  auto stream_ptr = header_input.get();
  auto & stream = *stream_ptr;

  stream.seekg(0);

  const auto error = [&header_input](auto... args)
  {
    std::stringstream err_prefix;
    err_prefix << "While reading restartable data in ";
    const auto filename = header_input.getFilename();
    if (filename)
      err_prefix << std::filesystem::absolute(filename->parent_path());
    else
      err_prefix << "memory";
    err_prefix << ":\n\n";

    mooseError(err_prefix.str(), args...);
  };

  // ID
  char this_id[2];
  stream.read(this_id, 2);
  if (this_id[0] != 'R' || this_id[1] != 'D')
    error("The data is invalid or corrupted (unexpected header)");

  // File version
  std::remove_const<decltype(CURRENT_BACKUP_FILE_VERSION)>::type this_file_version;
  dataLoad(stream, this_file_version, nullptr);
  if (this_file_version != CURRENT_BACKUP_FILE_VERSION)
    error("There is a mismatch in the backup version\n\n",
          "Current backup version: ",
          CURRENT_BACKUP_FILE_VERSION,
          "\nLoaded backup version: ",
          this_file_version);

  // Type id for a basic type
  std::size_t this_compare_hash_code;
  dataLoad(stream, this_compare_hash_code, nullptr);
#ifndef RESTARTABLE_SKIP_CHECK_HASH_CODE
  if (this_compare_hash_code != typeid(COMPARE_HASH_CODE_TYPE).hash_code() && !_force)
    error("The backup is not compatible\n\nThe hash code check for a basic type (",
          MooseUtils::prettyCppType<COMPARE_HASH_CODE_TYPE>(),
          ") failed.\nIt is possible that this backup was stored with a different architecture or "
          "operating system.\n\nTo forcefully attempt loading the backup, use the command line "
          "option --force-restart");
#else
  (void)_force;
#endif

  // Number of procs
  decltype(n_processors()) this_n_procs = 0;
  dataLoad(stream, this_n_procs, nullptr);
  if (_error_on_different_number_of_processors && this_n_procs != n_processors())
    error("The number of MPI ranks is not consistent\n\nCurrent MPI ranks: ",
          n_processors(),
          "\nLoaded MPI ranks: ",
          this_n_procs);

  // Number of data
  decltype(dataSize()) this_num_data = 0;
  dataLoad(stream, this_num_data, nullptr);
  if (this_num_data != dataSize())
    error("The number of threads is not consistent\n\nCurrent threads: ",
          dataSize(),
          "\nLoaded threads: ",
          this_num_data);

  header.resize(dataSize());

  // Size of data for each thread
  std::vector<std::size_t> tid_n_data(dataSize());
  for (const auto tid : make_range(dataSize()))
    dataLoad(stream, tid_n_data[tid], nullptr);

  // The position of the current data that we're loading
  std::size_t current_data_position = 0;

  // Load the data header for each thread
  for (const auto tid : make_range(dataSize()))
    for (const auto i : make_range(tid_n_data[tid]))
    {
      std::ignore = i;

      std::string name;
      dataLoad(stream, name, nullptr);
      mooseAssert(name.size(), "Empty name");

      mooseAssert(!header[tid].count(name), "Data '" + name + "' is already inserted");
      auto & entry = header[tid][name];

      dataLoad(stream, entry.size, nullptr);
      dataLoad(stream, entry.type_hash_code, nullptr);
      dataLoad(stream, entry.type, nullptr);
      dataLoad(stream, entry.has_context, nullptr);
      entry.position = current_data_position;

      current_data_position += entry.size;
    }

  stream.seekg(0);

  return header;
}

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 53 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 64 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);
}

requireRestoring()

void RestartableDataReader::requireRestoring ( ) const

private

Checks whether or not we're currently restoring and errors if not.

Definition at line 332 of file RestartableDataReader.C.

Referenced by queryHeader().

{
  if (!_is_restoring)
    mooseError(
        "The RestartableDataReader is not available for querying as it is not currently restoring");
  mooseAssert(_streams.header, "Header not available");
  mooseAssert(_streams.data, "Data not available");
}

restartableDataFile() [1/2]

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

staticinherited

Returns

The filename for the restartable data

Definition at line 58 of file RestartableDataIO.C.

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

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

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.

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

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

restartableHeaderFile() [1/2]

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

staticinherited

Returns

The filename for the restartable header

Definition at line 65 of file RestartableDataIO.C.

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

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

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();
}

restore()

void RestartableDataReader::restore

(

const DataNames &

filter_names = {}

)

Restores the restartable data.

The input must be set via setInput() first.

A handle to the input is still kept after this restore is called! In order to remove that handle, you must call clear()!

Parameters

filter_names

A list of data names to only restore. If not provided, restores all.

Definition at line 184 of file RestartableDataReader.C.

Referenced by MooseApp::possiblyLoadRestartableMetaData(), and MooseApp::restore().

{
  if (!_streams.header || !_streams.data)
    mooseError("RestartableDataReader::restore(): Cannot restore because an input was not set");

  _is_restoring = true;

  // Set everything as not loaded
  for (const auto tid : make_range(dataSize()))
    for (auto & value : currentData(tid))
      value.setNotLoaded({});

  // Read the header
  _header = readHeader(*_streams.header);

  for (const auto tid : index_range(_header))
  {
    auto & data = currentData(tid);
    const auto & header = _header[tid];

    // TODO: Think about what to do with missing data
    // Load the data in the order that it was requested
    for (auto & value : data)
    {
      const auto & name = value.name();

      auto find_header = header.find(name);
      if (find_header == header.end())
        continue;

      auto & header_entry = find_header->second;

      // Only restore values if we're either recovering or the data isn't filtered out
      const auto is_data_in_filter = filter_names.find(name) != filter_names.end();
      if (!is_data_in_filter)
        deserializeValue(*_streams.data, value, header_entry);
    }
  }
}

restoreData() [1/2]

template<typename T , typename... Args>

T & RestartableDataReader::restoreData	(	const std::string &	data_name,
		const THREAD_ID	tid = 0,
		void *const	context = nullptr,
		Args &&...	args
	)

Restores the data with name data_name of type T.

This is used to restore data that was never declared in the restart, but was stored in the backup. You cannot call this if the data has already been declared or restored.

Requires that restore() is called first to load the headers.

Parameters

data_name	The name of the data
tid	The thread
context	The data context (if any)
args	Arguments to forward to the constructor of the object

Returns

The restored data

Definition at line 220 of file RestartableDataReader.h.

{
  std::unique_ptr<RestartableDataValue> T_data =
      std::make_unique<RestartableData<T>>(data_name, context, std::forward<Args>(args)...);
  auto & value = restoreData(data_name, std::move(T_data), tid);
  auto T_value = dynamic_cast<RestartableData<T> *>(&value);
  mooseAssert(T_value, "Bad cast");
  return T_value->set();
}

restoreData() [2/2]

RestartableDataValue & RestartableDataReader::restoreData ( const std::string &  data_name, std::unique_ptr< RestartableDataValue >  value, const THREAD_ID  tid  )

private

Internal method for restoring a new data value.

Definition at line 353 of file RestartableDataReader.C.

{
  auto & data_map = currentData(tid);
  if (data_map.hasData(data_name))
    mooseError("RestartableDataReader::restoreData(): Cannot declare restartable data '",
               data_name,
               "' because it has already been declared");

  const auto & header = getHeader(data_name, tid);
  auto & added_value = currentData(tid).addData(std::move(value));
  deserializeValue(*_streams.data, added_value, header);
  return added_value;
}

setErrorOnLoadWithDifferentNumberOfProcessors()

void RestartableDataReader::setErrorOnLoadWithDifferentNumberOfProcessors ( bool  value )

inline

Definition at line 104 of file RestartableDataReader.h.

Referenced by MooseApp::possiblyLoadRestartableMetaData().

  {
    _error_on_different_number_of_processors = value;
  }

setInput() [1/2]

void RestartableDataReader::setInput	(	std::unique_ptr< std::stringstream >	header_stream,
		std::unique_ptr< std::stringstream >	data_stream
	)

Sets the input stream for reading from the stringstreams header_stream and data_stream for the header and data, respectively.

Definition at line 46 of file RestartableDataReader.C.

Referenced by MooseApp::possiblyLoadRestartableMetaData(), and MooseApp::restore().

{
  mooseAssert(!_streams.header, "Header input already set");
  mooseAssert(!_streams.data, "Data stream already set");
  _streams.header = std::make_unique<StringInputStream>(std::move(header_stream));
  _streams.data = std::make_unique<StringInputStream>(std::move(data_stream));
}

setInput() [2/2]

void RestartableDataReader::setInput

(

const std::filesystem::path &

folder_base

)

Sets the input stream for reading to the file with the folder base folder_base.

Definition at line 56 of file RestartableDataReader.C.

{
  mooseAssert(!_streams.header, "Header input already set");
  mooseAssert(!_streams.data, "Data stream already set");
  _streams.header = std::make_unique<FileInputStream>(restartableHeaderFile(folder_base));
  _streams.data = std::make_unique<FileInputStream>(restartableDataFile(folder_base));
}

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 47 of file PerfGraphInterface.C.

Referenced by PerfGraphInterface::registerTimedSection().

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

validParams()

InputParameters PerfGraphInterface::validParams ( )

staticinherited

Definition at line 16 of file PerfGraphInterface.C.

Referenced by Convergence::validParams().

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

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().

_error_on_different_number_of_processors

bool RestartableDataReader::_error_on_different_number_of_processors

private

Whether or not to error with a different number of processors.

Definition at line 212 of file RestartableDataReader.h.

Referenced by readHeader(), and setErrorOnLoadWithDifferentNumberOfProcessors().

_force

const bool RestartableDataReader::_force

private

Whether or not to forcefully attempt to read despite incompatibilities.

Definition at line 215 of file RestartableDataReader.h.

Referenced by readHeader().

_header

std::vector<std::unordered_map<std::string, HeaderEntry> > RestartableDataReader::_header

private

The loaded headers from the restart.

Definition at line 206 of file RestartableDataReader.h.

Referenced by clear(), queryHeader(), and restore().

_is_restoring

bool RestartableDataReader::_is_restoring

private

Whether or not we're currently restoring.

Definition at line 209 of file RestartableDataReader.h.

Referenced by clear(), requireRestoring(), and restore().

_pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 124 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 127 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

_streams

InputStreams RestartableDataReader::_streams

private

The inputs for reading.

Definition at line 203 of file RestartableDataReader.h.

Referenced by clear(), isRestoring(), requireRestoring(), restore(), restoreData(), and setInput().

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 readHeader(), and RestartableDataWriter::write().

---

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

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