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`. More...

std::vector< std::filesystem::path >	write (const std::filesystem::path &folder_base)
	Writes the restartable data to the folder with base `folder_base`. More...

PerfGraph &	perfGraph ()
	Get the PerfGraph. More...

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

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.

Referenced by RestartableDataReader::restore(), RestartableDataReader::restoreData(), and 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(), RestartableDataReader::readHeader(), RestartableDataReader::restore(), and write().

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

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

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

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

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

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

◆ write() [1/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.

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

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

◆ write() [2/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;
 }

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

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

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

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

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Typedef Documentation

◆ COMPARE_HASH_CODE_TYPE

Constructor & Destructor Documentation

◆ RestartableDataWriter() [1/2]

◆ RestartableDataWriter() [2/2]

Member Function Documentation

◆ currentData()

◆ dataSize()

◆ getRestartableExt()

◆ perfGraph()

◆ registerTimedSection() [1/2]

◆ registerTimedSection() [2/2]

◆ restartableDataFile() [1/2]

◆ restartableDataFile() [2/2]

◆ restartableDataFolder()

◆ restartableHeaderFile() [1/2]

◆ restartableHeaderFile() [2/2]

◆ timedSectionName()

◆ validParams()

◆ write() [1/2]

◆ write() [2/2]

Member Data Documentation

◆ _data

◆ _pg_moose_app

◆ _prefix

◆ CURRENT_BACKUP_FILE_VERSION