From a257eef1d25f753dd87265acc4c0f1c935172443 Mon Sep 17 00:00:00 2001 From: "Bobby R. Bruce" Date: Mon, 20 Apr 2020 16:59:46 -0700 Subject: [PATCH] misc,sim: Tagged API methods in sim/serialize.hh Within this some light refactoring has been carried out to avoid accessing member variable directly and removing some unused/unneeded ones from the codebase. Change-Id: I458494f6466628b213816c81f6a8ce42fb91dc3f Issue-on: https://gem5.atlassian.net/browse/GEM5-172 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/27989 Reviewed-by: Bobby R. Bruce Maintainer: Bobby R. Bruce Tested-by: kokoro --- src/dev/storage/disk_image.cc | 2 +- src/doxygen/group_definitions.hh | 6 + src/mem/physical.cc | 2 +- src/mem/ruby/system/RubySystem.cc | 2 +- src/sim/serialize.cc | 10 +- src/sim/serialize.hh | 238 +++++++++++++++++++++++++++--- 6 files changed, 232 insertions(+), 28 deletions(-) diff --git a/src/dev/storage/disk_image.cc b/src/dev/storage/disk_image.cc index 1578ea30f..319bccf13 100644 --- a/src/dev/storage/disk_image.cc +++ b/src/dev/storage/disk_image.cc @@ -444,7 +444,7 @@ CowDiskImage::unserialize(CheckpointIn &cp) { string cowFilename; UNSERIALIZE_SCALAR(cowFilename); - cowFilename = cp.cptDir + "/" + cowFilename; + cowFilename = cp.getCptDir() + "/" + cowFilename; open(cowFilename); } diff --git a/src/doxygen/group_definitions.hh b/src/doxygen/group_definitions.hh index 8b3e14cd5..e8a1cd903 100644 --- a/src/doxygen/group_definitions.hh +++ b/src/doxygen/group_definitions.hh @@ -3,3 +3,9 @@ * * These methods relate to the "Drainable" interface. */ + +/** + * @defgroup api_serialize The Serialize API. + * + * These methods related to the "Serialize" interface. + */ diff --git a/src/mem/physical.cc b/src/mem/physical.cc index b4246a302..4bd812c21 100644 --- a/src/mem/physical.cc +++ b/src/mem/physical.cc @@ -401,7 +401,7 @@ PhysicalMemory::unserializeStore(CheckpointIn &cp) string filename; UNSERIALIZE_SCALAR(filename); - string filepath = cp.cptDir + "/" + filename; + string filepath = cp.getCptDir() + "/" + filename; // mmap memoryfile gzFile compressed_mem = gzopen(filepath.c_str(), "rb"); diff --git a/src/mem/ruby/system/RubySystem.cc b/src/mem/ruby/system/RubySystem.cc index 57d49667e..c28f8801d 100644 --- a/src/mem/ruby/system/RubySystem.cc +++ b/src/mem/ruby/system/RubySystem.cc @@ -331,7 +331,7 @@ RubySystem::unserialize(CheckpointIn &cp) UNSERIALIZE_SCALAR(cache_trace_file); UNSERIALIZE_SCALAR(cache_trace_size); - cache_trace_file = cp.cptDir + "/" + cache_trace_file; + cache_trace_file = cp.getCptDir() + "/" + cache_trace_file; readCompressedTrace(cache_trace_file, uncompressed_trace, cache_trace_size); diff --git a/src/sim/serialize.cc b/src/sim/serialize.cc index 6a71dd2d4..4bb2ab5ff 100644 --- a/src/sim/serialize.cc +++ b/src/sim/serialize.cc @@ -66,9 +66,9 @@ using namespace std; -int Serializable::ckptMaxCount = 0; -int Serializable::ckptCount = 0; -int Serializable::ckptPrevCount = -1; +int ckptMaxCount = 0; +int ckptCount = 0; +int ckptPrevCount = -1; std::stack Serializable::path; ///////////////////////////// @@ -266,9 +266,9 @@ CheckpointIn::dir() } CheckpointIn::CheckpointIn(const string &cpt_dir, SimObjectResolver &resolver) - : db(new IniFile), objNameResolver(resolver), cptDir(setDir(cpt_dir)) + : db(new IniFile), objNameResolver(resolver), _cptDir(setDir(cpt_dir)) { - string filename = cptDir + "/" + CheckpointIn::baseFilename; + string filename = getCptDir() + "/" + CheckpointIn::baseFilename; if (!db->load(filename)) { fatal("Can't load checkpoint file '%s'\n", filename); } diff --git a/src/sim/serialize.hh b/src/sim/serialize.hh index 92b14a9ff..1f31dd203 100644 --- a/src/sim/serialize.hh +++ b/src/sim/serialize.hh @@ -72,11 +72,17 @@ class CheckpointIn SimObjectResolver &objNameResolver; + const std::string _cptDir; + public: CheckpointIn(const std::string &cpt_dir, SimObjectResolver &resolver); ~CheckpointIn(); - const std::string cptDir; + /** + * @ingroup api_serialize + * @{ + */ + const std::string getCptDir() { return _cptDir; } bool find(const std::string §ion, const std::string &entry, std::string &value); @@ -84,9 +90,9 @@ class CheckpointIn bool findObj(const std::string §ion, const std::string &entry, SimObject *&value); - bool entryExists(const std::string §ion, const std::string &entry); bool sectionExists(const std::string §ion); + /** @}*/ //end of api_checkout group // The following static functions have to do with checkpoint // creation rather than restoration. This class makes a handy @@ -99,16 +105,28 @@ class CheckpointIn // current directory we're serializing into. static std::string currentDirectory; + public: - // Set the current directory. This function takes care of - // inserting curTick() if there's a '%d' in the argument, and - // appends a '/' if necessary. The final name is returned. + /** + * Set the current directory + * + * This function takes care of inserting curTick() if there's a '%d' in the + * argument, and appends a '/' if necessary. The final name is returned. + * + * @ingroup api_serialize + */ static std::string setDir(const std::string &base_name); - // Export current checkpoint directory name so other objects can - // derive filenames from it (e.g., memory). The return value is - // guaranteed to end in '/' so filenames can be directly appended. - // This function is only valid while a checkpoint is being created. + /** + * Get the current checkout directory name + * + * This function exports the current checkout point directory name so other + * objects can derive filenames from it (e.g., memory). The return value is + * guaranteed to end in '/' so filenames can be directly appended. This + * function is only valid while a checkpoint is being created. + * + * @ingroup api_serialize + */ static std::string dir(); // Filename for base checkpoint file within directory. @@ -167,6 +185,10 @@ class Serializable */ class ScopedCheckpointSection { public: + /** + * @ingroup api_serialize + * @{ + */ template ScopedCheckpointSection(CP &cp, const char *name) { pushName(name); @@ -178,6 +200,7 @@ class Serializable pushName(name.c_str()); nameOut(cp); } + /** @}*/ //end of api_serialize group ~ScopedCheckpointSection(); @@ -195,6 +218,9 @@ class Serializable }; public: + /** + * @ingroup api_serialize + */ Serializable(); virtual ~Serializable(); @@ -204,6 +230,8 @@ class Serializable * Output an object's state into the current checkpoint section. * * @param cp Checkpoint state + * + * @ingroup api_serialize */ virtual void serialize(CheckpointOut &cp) const = 0; @@ -213,6 +241,8 @@ class Serializable * Read an object's state from the current checkpoint section. * * @param cp Checkpoint state + * + * @ingroup api_serialize */ virtual void unserialize(CheckpointIn &cp) = 0; @@ -226,9 +256,14 @@ class Serializable * * @param cp Checkpoint state * @param name Name to append to the active path + * + * @ingroup api_serialize */ void serializeSection(CheckpointOut &cp, const char *name) const; + /** + * @ingroup api_serialize + */ void serializeSection(CheckpointOut &cp, const std::string &name) const { serializeSection(cp, name.c_str()); } @@ -242,37 +277,54 @@ class Serializable * * @param cp Checkpoint state * @param name Name to append to the active path + * + * @ingroup api_serialize */ void unserializeSection(CheckpointIn &cp, const char *name); + /** + * @ingroup api_serialize + */ void unserializeSection(CheckpointIn &cp, const std::string &name) { unserializeSection(cp, name.c_str()); } - /** Get the fully-qualified name of the active section */ + /** + * Gets the fully-qualified name of the active section + * + * @ingroup api_serialize + */ static const std::string ¤tSection(); - static int ckptCount; - static int ckptMaxCount; - static int ckptPrevCount; + /** + * @ingroup api_serialize + */ static void serializeAll(const std::string &cpt_dir); + + /** + * @ingroup api_serialize + */ static void unserializeGlobals(CheckpointIn &cp); private: static std::stack path; }; -// -// The base implementations use to_number for parsing and '<<' for -// displaying, suitable for integer types. -// +/** + * @ingroup api_serialize + */ template bool parseParam(const std::string &s, T &value) { + // The base implementations use to_number for parsing and '<<' for + // displaying, suitable for integer types. return to_number(s, value); } +/** + * @ingroup api_serialize + */ template void showParam(CheckpointOut &os, const T &value) @@ -280,6 +332,9 @@ showParam(CheckpointOut &os, const T &value) os << value; } +/** + * @ingroup api_serialize + */ template bool parseParam(const std::string &s, BitUnionType &value) @@ -291,6 +346,9 @@ parseParam(const std::string &s, BitUnionType &value) return res; } +/** + * @ingroup api_serialize + */ template void showParam(CheckpointOut &os, const BitUnionType &value) @@ -304,14 +362,20 @@ showParam(CheckpointOut &os, const BitUnionType &value) static_cast(storage) : storage); } -// Treat 8-bit ints (chars) as ints on output, not as chars +/** + * @ingroup api_serialize + */ template <> inline void showParam(CheckpointOut &os, const char &value) { + // Treat 8-bit ints (chars) as ints on output, not as chars os << (int)value; } +/** + * @ingroup api_serialize + */ template <> inline void showParam(CheckpointOut &os, const signed char &value) @@ -319,6 +383,9 @@ showParam(CheckpointOut &os, const signed char &value) os << (int)value; } +/** + * @ingroup api_serialize + */ template <> inline void showParam(CheckpointOut &os, const unsigned char &value) @@ -326,6 +393,9 @@ showParam(CheckpointOut &os, const unsigned char &value) os << (unsigned int)value; } +/** + * @ingroup api_serialize + */ template <> inline bool parseParam(const std::string &s, float &value) @@ -333,6 +403,9 @@ parseParam(const std::string &s, float &value) return to_number(s, value); } +/** + * @ingroup api_serialize + */ template <> inline bool parseParam(const std::string &s, double &value) @@ -340,6 +413,9 @@ parseParam(const std::string &s, double &value) return to_number(s, value); } +/** + * @ingroup api_serialize + */ template <> inline bool parseParam(const std::string &s, bool &value) @@ -347,23 +423,32 @@ parseParam(const std::string &s, bool &value) return to_bool(s, value); } -// Display bools as strings +/** + * @ingroup api_serialize + */ template <> inline void showParam(CheckpointOut &os, const bool &value) { + // Display bools as strings os << (value ? "true" : "false"); } -// String requires no processing to speak of +/** + * @ingroup api_serialize + */ template <> inline bool parseParam(const std::string &s, std::string &value) { + // String requires no processing to speak of value = s; return true; } +/** + * @ingroup api_serialize + */ template void paramOut(CheckpointOut &os, const std::string &name, const T ¶m) @@ -373,6 +458,9 @@ paramOut(CheckpointOut &os, const std::string &name, const T ¶m) os << "\n"; } +/** + * @ingroup api_serialize + */ template void paramIn(CheckpointIn &cp, const std::string &name, T ¶m) @@ -384,6 +472,9 @@ paramIn(CheckpointIn &cp, const std::string &name, T ¶m) } } +/** + * @ingroup api_serialize + */ template bool optParamIn(CheckpointIn &cp, const std::string &name, @@ -400,6 +491,9 @@ optParamIn(CheckpointIn &cp, const std::string &name, } } +/** + * @ingroup api_serialize + */ template void arrayParamOut(CheckpointOut &os, const std::string &name, @@ -416,6 +510,9 @@ arrayParamOut(CheckpointOut &os, const std::string &name, os << "\n"; } +/** + * @ingroup api_serialize + */ template void arrayParamOut(CheckpointOut &os, const std::string &name, @@ -435,6 +532,9 @@ arrayParamOut(CheckpointOut &os, const std::string &name, os << "\n"; } +/** + * @ingroup api_serialize + */ template void arrayParamOut(CheckpointOut &os, const std::string &name, @@ -454,6 +554,9 @@ arrayParamOut(CheckpointOut &os, const std::string &name, os << "\n"; } +/** + * @ingroup api_serialize + */ template void arrayParamOut(CheckpointOut &os, const std::string &name, @@ -477,6 +580,8 @@ arrayParamOut(CheckpointOut &os, const std::string &name, * @param name Name of the container. * @param param The array container. * @param size The expected number of entries to be extracted. + * + * @ingroup api_serialize */ template void @@ -523,6 +628,9 @@ arrayParamIn(CheckpointIn &cp, const std::string &name, } } +/** + * @ingroup api_serialize + */ template void arrayParamIn(CheckpointIn &cp, const std::string &name, std::vector ¶m) @@ -565,6 +673,9 @@ arrayParamIn(CheckpointIn &cp, const std::string &name, std::vector ¶m) } } +/** + * @ingroup api_serialize + */ template void arrayParamIn(CheckpointIn &cp, const std::string &name, std::list ¶m) @@ -595,6 +706,9 @@ arrayParamIn(CheckpointIn &cp, const std::string &name, std::list ¶m) } } +/** + * @ingroup api_serialize + */ template void arrayParamIn(CheckpointIn &cp, const std::string &name, std::set ¶m) @@ -628,6 +742,10 @@ arrayParamIn(CheckpointIn &cp, const std::string &name, std::set ¶m) void debug_serialize(const std::string &cpt_dir); + +/** + * @ingroup api_serialize + */ void objParamIn(CheckpointIn &cp, const std::string &name, SimObject * ¶m); @@ -635,14 +753,43 @@ objParamIn(CheckpointIn &cp, const std::string &name, SimObject * ¶m); // These macros are streamlined to use in serialize/unserialize // functions. It's assumed that serialize() has a parameter 'os' for // the ostream, and unserialize() has parameters 'cp' and 'section'. + + +/** + * \def SERIALIZE_SCALER(scaler) + * + * @ingroup api_serialize + */ #define SERIALIZE_SCALAR(scalar) paramOut(cp, #scalar, scalar) +/** + * \def UNSERIALIZE_SCALER(scalar) + * + * @ingroup api_serialize + */ #define UNSERIALIZE_SCALAR(scalar) paramIn(cp, #scalar, scalar) + +/** + * \def UNSERIALIZE_OPT_SCALAR(scalar) + * + * @ingroup api_serialize + */ #define UNSERIALIZE_OPT_SCALAR(scalar) optParamIn(cp, #scalar, scalar) // ENUMs are like SCALARs, but we cast them to ints on the way out + +/** + * \def SERIALIZE_ENUM(scalar) + * + * @ingroup api_serialize + */ #define SERIALIZE_ENUM(scalar) paramOut(cp, #scalar, (int)scalar) +/** + * \def UNSERIALIZE_ENUM(scaler) + * + * @ingroup api_serialize + */ #define UNSERIALIZE_ENUM(scalar) \ do { \ int tmp; \ @@ -650,31 +797,82 @@ objParamIn(CheckpointIn &cp, const std::string &name, SimObject * ¶m); scalar = static_cast(tmp); \ } while (0) +/** + * \def SERIALIZE_ARRAY(member, size) + * + * @ingroup api_serialize + */ #define SERIALIZE_ARRAY(member, size) \ arrayParamOut(cp, #member, member, size) +/** + * \def UNSERIALIZE_ARRAY(member, size) + * + * @ingroup api_serialize + */ #define UNSERIALIZE_ARRAY(member, size) \ arrayParamIn(cp, #member, member, size) +/** + * \def SERIALIZE_CONTAINER(member) + * + * @ingroup api_serialize + */ #define SERIALIZE_CONTAINER(member) \ arrayParamOut(cp, #member, member) +/** + * \def UNSERIALIZE_CONTAINER(member) + * + * @ingroup api_serialize + */ #define UNSERIALIZE_CONTAINER(member) \ arrayParamIn(cp, #member, member) +/** + * \def SERIALIZE_EVENT(event) + * + * @ingroup api_serialize + */ #define SERIALIZE_EVENT(event) event.serializeSection(cp, #event); +/** + * \def UNSERIALIZE_EVENT(event) + * + * @ingroup api_serialize + */ #define UNSERIALIZE_EVENT(event) \ do { \ event.unserializeSection(cp, #event); \ eventQueue()->checkpointReschedule(&event); \ } while (0) +/** + * \def SERIALIZE_OBJ(obj) + * + * @ingroup api_serialize + */ #define SERIALIZE_OBJ(obj) obj.serializeSection(cp, #obj) + +/** + * \def UNSERIALIZE_OBJ(obj) + * + * @ingroup api_serialize + */ #define UNSERIALIZE_OBJ(obj) obj.unserializeSection(cp, #obj) +/** + * \def SERIALIZE_OBJPTR(objptr) + * + * @ingroup api_serialize + */ #define SERIALIZE_OBJPTR(objptr) paramOut(cp, #objptr, (objptr)->name()) +/** + * \def UNSERIALIZE_OBJPTR(objptr) + * + * @ingroup api_serialize + */ #define UNSERIALIZE_OBJPTR(objptr) \ do { \ SimObject *sptr; \ -- 2.30.2