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.

void	setInput (const std::filesystem::path &folder_base)
	Sets the input stream for reading to the file with the folder base `folder_base`.

bool	isRestoring () const

bool	restoreDataIfAvailable (RestartableDataValue &value, const THREAD_ID tid, Moose::PassKey< MooseApp >)
	Restores `value` in place from the open reader if it is present in the checkpoint and has not yet been loaded.

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

void	restore (const DataNames &filter_names={})
	Restores the restartable data.

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.

template<typename T >
bool	hasData (const std::string &data_name, const THREAD_ID tid=0) const

PerfGraph &	perfGraph ()
	Get the PerfGraph.

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)

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.

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)

void	deserializeValue (InputStream &data_input, RestartableDataValue &value, const HeaderEntry &header_entry) const
	Internal method for deserializing (restoring from backup into a value)

void	requireRestoring () const
	Checks whether or not we're currently restoring and errors if not.

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.

Private Attributes
InputStreams	_streams
	The inputs for reading.

std::vector< std::unordered_map< std::string, HeaderEntry > >	_header
	The loaded headers from the restart.

bool	_is_restoring
	Whether or not we're currently restoring.

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

const bool	_force
	Whether or not to forcefully attempt to read despite incompatibilities.

Detailed Description

Reader for restartable data written by the RestartableDataWriter.

Definition at line 24 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.

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

Referenced by MooseApp::finalizeRestore().

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

◆ 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.

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

Referenced by restoreData(), and restoreDataIfAvailable().

◆ 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.

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

Referenced by restoreData().

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

◆ hasData() [1/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;
}

◆ hasData() [2/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 139 of file RestartableDataReader.h.

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

Referenced by hasData().

◆ 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.

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

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

◆ isRestoring()

bool RestartableDataReader::isRestoring ( ) const

inline

Returns: Whether or not this reader is currently restoring

Definition at line 56 of file RestartableDataReader.h.

56{ return _streams.data != nullptr; }

RestartableDataReader::InputStreams::data

std::unique_ptr< InputStream > data

Definition RestartableDataReader.h:39

Referenced by MooseApp::finalizeRestore(), and restoreDataIfAvailable().

◆ 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 356 of file RestartableDataReader.C.

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

Referenced by deserializeValue(), and hasData().

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

◆ 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.

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

Referenced by getHeader(), hasData(), and restoreDataIfAvailable().

◆ 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.

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

◆ 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.

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

Referenced by queryHeader().

◆ 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 isAvailable(), RestartableDataIO::restartableDataFile(), setInput(), and RestartableDataWriter::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(), setInput(), and RestartableDataWriter::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();
}

◆ 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.

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

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

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

Referenced by restoreData().

◆ 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 367 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;
}

◆ restoreDataIfAvailable()

bool RestartableDataReader::restoreDataIfAvailable	(	RestartableDataValue &	value,
		const THREAD_ID	tid,
		Moose::PassKey< MooseApp >
	)

Restores value in place from the open reader if it is present in the checkpoint and has not yet been loaded.

Used to recover data (e.g. reporter values) that is declared after the bulk restore pass while the reader window is still open.

Requires that restore() has been called.

Returns: Whether or not the value was restored

Definition at line 342 of file RestartableDataReader.C.

{
  if (!isRestoring() || value.loaded())
    return false;
  const auto * const header_entry = queryHeader(value.name(), tid);
  if (!header_entry)
    return false;
  deserializeValue(*_streams.data, value, *header_entry);
  return true;
}

Referenced by MooseApp::restoreDataIfAvailable().

◆ setErrorOnLoadWithDifferentNumberOfProcessors()

void RestartableDataReader::setErrorOnLoadWithDifferentNumberOfProcessors ( bool value )

inline

Definition at line 118 of file RestartableDataReader.h.

  {
    _error_on_different_number_of_processors = value;
  }

Referenced by MooseApp::possiblyLoadRestartableMetaData().

◆ setInput() [1/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));
}

◆ setInput() [2/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.

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

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

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

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 226 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 229 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 220 of file RestartableDataReader.h.

Referenced by clear(), and queryHeader().

◆ _is_restoring

bool RestartableDataReader::_is_restoring

private

Whether or not we're currently restoring.

Definition at line 223 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 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().

◆ _streams

InputStreams RestartableDataReader::_streams

private

The inputs for reading.

Definition at line 217 of file RestartableDataReader.h.

Referenced by clear(), isRestoring(), requireRestoring(), restore(), restoreData(), restoreDataIfAvailable(), setInput(), 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().

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

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

Classes

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ COMPARE_HASH_CODE_TYPE

Constructor & Destructor Documentation

◆ RestartableDataReader() [1/2]

◆ RestartableDataReader() [2/2]

Member Function Documentation

◆ clear()

◆ currentData()

◆ dataSize()

◆ deserializeValue()

◆ getHeader()

◆ getRestartableExt()

◆ hasData() [1/2]

◆ hasData() [2/2]

◆ isAvailable()

◆ isRestoring()

◆ isSameType()

◆ perfGraph()

◆ queryHeader()

◆ readHeader()

◆ registerTimedSection() [1/2]

◆ registerTimedSection() [2/2]

◆ requireRestoring()

◆ restartableDataFile() [1/2]

◆ restartableDataFile() [2/2]

◆ restartableDataFolder()

◆ restartableHeaderFile() [1/2]

◆ restartableHeaderFile() [2/2]

◆ restore()

◆ restoreData() [1/2]

◆ restoreData() [2/2]

◆ restoreDataIfAvailable()

◆ setErrorOnLoadWithDifferentNumberOfProcessors()

◆ setInput() [1/2]

◆ setInput() [2/2]

◆ timedSectionName()

◆ validParams()

Member Data Documentation

◆ _data

◆ _error_on_different_number_of_processors

◆ _force

◆ _header

◆ _is_restoring

◆ _pg_moose_app

◆ _prefix

◆ _streams

◆ CURRENT_BACKUP_FILE_VERSION