sim: Move paramIn/Out definition to header file

This patch is moving the definitions of paramIn/Out templates to
the header file. In this way we gain:

1) We don't have to do explicit instantiation anymore for user defined
types. This spares us from including data type header files into
serialize.cc

2) We can overload show/parseParam for BitUnions or any other type
that requires special handling when serializing. Just by overloading
the two templates we get all the containers' (list, vector, array..)
serialization for free

2) gtest: With the idea of adding unit tests for Serializable objects,
we can avoid importing serialize.cc and just redefine Serializable
methods in the test source, implementing a Serializable stub

Change-Id: I45a9bb87d5ef886a3668fd477005cd105f612e36
Signed-off-by: Giacomo Travaglini <giacomo.travaglini@arm.com>
Reviewed-on: https://gem5-review.googlesource.com/c/13635
Reviewed-by: Gabe Black <gabeblack@google.com>
Maintainer: Andreas Sandberg <andreas.sandberg@arm.com>

1 files changed, 15 insertions, 414 deletions

diff --git a/src/sim/serialize.cc b/src/sim/serialize.cc
index a03a396b3..095a44c34 100644
--- a/src/sim/serialize.cc
+++ b/src/sim/serialize.cc
@@ -57,12 +57,8 @@
 #include <string>
 #include <vector>
 
-#include "arch/generic/vec_reg.hh"
-#include "base/framebuffer.hh"
 #include "base/inifile.hh"
-#include "base/logging.hh"
 #include "base/output.hh"
-#include "base/str.hh"
 #include "base/trace.hh"
 #include "debug/Checkpoint.hh"
 #include "sim/eventq.hh"
@@ -75,412 +71,11 @@
 
 using namespace std;
 
-//
-// The base implementations use to_number for parsing and '<<' for
-// displaying, suitable for integer types.
-//
-template <class T>
-bool
-parseParam(const string &s, T &value)
-{
-    return to_number(s, value);
-}
-
-template <class T>
-void
-showParam(CheckpointOut &os, const T &value)
-{
-    os << value;
-}
-
-//
-// Template specializations:
-// - char (8-bit integer)
-// - floating-point types
-// - bool
-// - string
-//
-
-// Treat 8-bit ints (chars) as ints on output, not as chars
-template <>
-void
-showParam(CheckpointOut &os, const char &value)
-{
-    os << (int)value;
-}
-
-
-template <>
-void
-showParam(CheckpointOut &os, const signed char &value)
-{
-    os << (int)value;
-}
-
-
-template <>
-void
-showParam(CheckpointOut &os, const unsigned char &value)
-{
-    os << (unsigned int)value;
-}
-
-
-template <>
-bool
-parseParam(const string &s, float &value)
-{
-    return to_number(s, value);
-}
-
-template <>
-bool
-parseParam(const string &s, double &value)
-{
-    return to_number(s, value);
-}
-
-template <>
-bool
-parseParam(const string &s, bool &value)
-{
-    return to_bool(s, value);
-}
-
-// Display bools as strings
-template <>
-void
-showParam(CheckpointOut &os, const bool &value)
-{
-    os << (value ? "true" : "false");
-}
-
-
-// String requires no processing to speak of
-template <>
-bool
-parseParam(const string &s, string &value)
-{
-    value = s;
-    return true;
-}
-
 int Serializable::ckptMaxCount = 0;
 int Serializable::ckptCount = 0;
 int Serializable::ckptPrevCount = -1;
 std::stack<std::string> Serializable::path;
 
-template <class T>
-void
-paramOut(CheckpointOut &os, const string &name, const T &param)
-{
-    os << name << "=";
-    showParam(os, param);
-    os << "\n";
-}
-
-template <class T>
-void
-arrayParamOut(CheckpointOut &os, const string &name, const vector<T> &param)
-{
-    typename vector<T>::size_type size = param.size();
-    os << name << "=";
-    if (size > 0)
-        showParam(os, param[0]);
-    for (typename vector<T>::size_type i = 1; i < size; ++i) {
-        os << " ";
-        showParam(os, param[i]);
-    }
-    os << "\n";
-}
-
-template <class T>
-void
-arrayParamOut(CheckpointOut &os, const string &name, const list<T> &param)
-{
-    typename list<T>::const_iterator it = param.begin();
-
-    os << name << "=";
-    if (param.size() > 0)
-        showParam(os, *it);
-    it++;
-    while (it != param.end()) {
-        os << " ";
-        showParam(os, *it);
-        it++;
-    }
-    os << "\n";
-}
-
-template <class T>
-void
-arrayParamOut(CheckpointOut &os, const string &name, const set<T> &param)
-{
-    typename set<T>::const_iterator it = param.begin();
-
-    os << name << "=";
-    if (param.size() > 0)
-        showParam(os, *it);
-    it++;
-    while (it != param.end()) {
-        os << " ";
-        showParam(os, *it);
-        it++;
-    }
-    os << "\n";
-}
-
-template <class T>
-void
-paramIn(CheckpointIn &cp, const string &name, T &param)
-{
-    const string &section(Serializable::currentSection());
-    string str;
-    if (!cp.find(section, name, str) || !parseParam(str, param)) {
-        fatal("Can't unserialize '%s:%s'\n", section, name);
-    }
-}
-
-template <class T>
-bool
-optParamIn(CheckpointIn &cp, const string &name, T &param, bool warn)
-{
-    const string &section(Serializable::currentSection());
-    string str;
-    if (!cp.find(section, name, str) || !parseParam(str, param)) {
-        if (warn)
-            warn("optional parameter %s:%s not present\n", section, name);
-        return false;
-    } else {
-        return true;
-    }
-}
-
-template <class T>
-void
-arrayParamOut(CheckpointOut &os, const string &name,
-              const T *param, unsigned size)
-{
-    os << name << "=";
-    if (size > 0)
-        showParam(os, param[0]);
-    for (unsigned i = 1; i < size; ++i) {
-        os << " ";
-        showParam(os, param[i]);
-    }
-    os << "\n";
-}
-
-
-template <class T>
-void
-arrayParamIn(CheckpointIn &cp, const string &name, T *param, unsigned size)
-{
-    const string &section(Serializable::currentSection());
-    string str;
-    if (!cp.find(section, name, str)) {
-        fatal("Can't unserialize '%s:%s'\n", section, name);
-    }
-
-    // code below stolen from VectorParam<T>::parse().
-    // it would be nice to unify these somehow...
-
-    vector<string> tokens;
-
-    tokenize(tokens, str, ' ');
-
-    // Need this if we were doing a vector
-    // value.resize(tokens.size());
-
-    if (tokens.size() != size) {
-        fatal("Array size mismatch on %s:%s'\n", section, name);
-    }
-
-    for (vector<string>::size_type i = 0; i < tokens.size(); i++) {
-        // need to parse into local variable to handle vector<bool>,
-        // for which operator[] returns a special reference class
-        // that's not the same as 'bool&', (since it's a packed
-        // vector)
-        T scalar_value;
-        if (!parseParam(tokens[i], scalar_value)) {
-            string err("could not parse \"");
-
-            err += str;
-            err += "\"";
-
-            fatal(err);
-        }
-
-        // assign parsed value to vector
-        param[i] = scalar_value;
-    }
-}
-
-template <class T>
-void
-arrayParamIn(CheckpointIn &cp, const string &name, vector<T> &param)
-{
-    const string &section(Serializable::currentSection());
-    string str;
-    if (!cp.find(section, name, str)) {
-        fatal("Can't unserialize '%s:%s'\n", section, name);
-    }
-
-    // code below stolen from VectorParam<T>::parse().
-    // it would be nice to unify these somehow...
-
-    vector<string> tokens;
-
-    tokenize(tokens, str, ' ');
-
-    // Need this if we were doing a vector
-    // value.resize(tokens.size());
-
-    param.resize(tokens.size());
-
-    for (vector<string>::size_type i = 0; i < tokens.size(); i++) {
-        // need to parse into local variable to handle vector<bool>,
-        // for which operator[] returns a special reference class
-        // that's not the same as 'bool&', (since it's a packed
-        // vector)
-        T scalar_value;
-        if (!parseParam(tokens[i], scalar_value)) {
-            string err("could not parse \"");
-
-            err += str;
-            err += "\"";
-
-            fatal(err);
-        }
-
-        // assign parsed value to vector
-        param[i] = scalar_value;
-    }
-}
-
-template <class T>
-void
-arrayParamIn(CheckpointIn &cp, const string &name, list<T> &param)
-{
-    const string &section(Serializable::currentSection());
-    string str;
-    if (!cp.find(section, name, str)) {
-        fatal("Can't unserialize '%s:%s'\n", section, name);
-    }
-    param.clear();
-
-    vector<string> tokens;
-    tokenize(tokens, str, ' ');
-
-    for (vector<string>::size_type i = 0; i < tokens.size(); i++) {
-        T scalar_value;
-        if (!parseParam(tokens[i], scalar_value)) {
-            string err("could not parse \"");
-
-            err += str;
-            err += "\"";
-
-            fatal(err);
-        }
-
-        // assign parsed value to vector
-        param.push_back(scalar_value);
-    }
-}
-
-template <class T>
-void
-arrayParamIn(CheckpointIn &cp, const string &name, set<T> &param)
-{
-    const string &section(Serializable::currentSection());
-    string str;
-    if (!cp.find(section, name, str)) {
-        fatal("Can't unserialize '%s:%s'\n", section, name);
-    }
-    param.clear();
-
-    vector<string> tokens;
-    tokenize(tokens, str, ' ');
-
-    for (vector<string>::size_type i = 0; i < tokens.size(); i++) {
-        T scalar_value;
-        if (!parseParam(tokens[i], scalar_value)) {
-            string err("could not parse \"");
-
-            err += str;
-            err += "\"";
-
-            fatal(err);
-        }
-
-        // assign parsed value to vector
-        param.insert(scalar_value);
-    }
-}
-
-
-void
-objParamIn(CheckpointIn &cp, const string &name, SimObject * &param)
-{
-    const string &section(Serializable::currentSection());
-    if (!cp.findObj(section, name, param)) {
-        fatal("Can't unserialize '%s:%s'\n", section, name);
-    }
-}
-
-
-#define INSTANTIATE_PARAM_TEMPLATES(type)                               \
-    template void                                                       \
-    paramOut(CheckpointOut &os, const string &name, type const &param); \
-    template void                                                       \
-    paramIn(CheckpointIn &cp, const string &name, type & param);        \
-    template bool                                                       \
-    optParamIn(CheckpointIn &cp, const string &name, type & param,      \
-               bool warn);                                              \
-    template void                                                       \
-    arrayParamOut(CheckpointOut &os, const string &name,                \
-                  type const *param, unsigned size);                    \
-    template void                                                       \
-    arrayParamIn(CheckpointIn &cp, const string &name,                  \
-                 type *param, unsigned size);                           \
-    template void                                                       \
-    arrayParamOut(CheckpointOut &os, const string &name,                \
-                  const vector<type> &param);                           \
-    template void                                                       \
-    arrayParamIn(CheckpointIn &cp, const string &name,                  \
-                 vector<type> &param);                                  \
-    template void                                                       \
-    arrayParamOut(CheckpointOut &os, const string &name,                \
-                  const list<type> &param);                             \
-    template void                                                       \
-    arrayParamIn(CheckpointIn &cp, const string &name,                  \
-                 list<type> &param);
-
-INSTANTIATE_PARAM_TEMPLATES(char)
-INSTANTIATE_PARAM_TEMPLATES(signed char)
-INSTANTIATE_PARAM_TEMPLATES(unsigned char)
-INSTANTIATE_PARAM_TEMPLATES(signed short)
-INSTANTIATE_PARAM_TEMPLATES(unsigned short)
-INSTANTIATE_PARAM_TEMPLATES(signed int)
-INSTANTIATE_PARAM_TEMPLATES(unsigned int)
-INSTANTIATE_PARAM_TEMPLATES(signed long)
-INSTANTIATE_PARAM_TEMPLATES(unsigned long)
-INSTANTIATE_PARAM_TEMPLATES(signed long long)
-INSTANTIATE_PARAM_TEMPLATES(unsigned long long)
-INSTANTIATE_PARAM_TEMPLATES(bool)
-INSTANTIATE_PARAM_TEMPLATES(float)
-INSTANTIATE_PARAM_TEMPLATES(double)
-INSTANTIATE_PARAM_TEMPLATES(string)
-INSTANTIATE_PARAM_TEMPLATES(Pixel)
-INSTANTIATE_PARAM_TEMPLATES(VecRegContainer<8>)
-INSTANTIATE_PARAM_TEMPLATES(VecRegContainer<16>)
-
-// set is only used with strings and furthermore doesn't agree with Pixel
-template void
-arrayParamOut(CheckpointOut &, const string &, const set<string> &);
-template void
-arrayParamIn(CheckpointIn &, const string &, set<string> &);
-
 /////////////////////////////
 
 /// Container for serializing global variables (not associated with
@@ -645,12 +240,6 @@ Serializable::ScopedCheckpointSection::nameOut(CheckpointOut &cp)
     cp << "\n[" << Serializable::currentSection() << "]\n";
 }
 
-void
-debug_serialize(const string &cpt_dir)
-{
-    Serializable::serializeAll(cpt_dir);
-}
-
 const std::string &
 Serializable::currentSection()
 {
@@ -681,7 +270,6 @@ CheckpointIn::dir()
     return currentDirectory;
 }
 
-
 CheckpointIn::CheckpointIn(const string &cpt_dir, SimObjectResolver &resolver)
     : db(new IniFile), objNameResolver(resolver), cptDir(setDir(cpt_dir))
 {
@@ -708,7 +296,6 @@ CheckpointIn::find(const string &section, const string &entry, string &value)
     return db->find(section, entry, value);
 }
 
-
 bool
 CheckpointIn::findObj(const string &section, const string &entry,
                     SimObject *&value)
@@ -722,9 +309,23 @@ CheckpointIn::findObj(const string &section, const string &entry,
     return true;
 }
 
-
 bool
 CheckpointIn::sectionExists(const string &section)
 {
     return db->sectionExists(section);
 }
+
+void
+objParamIn(CheckpointIn &cp, const string &name, SimObject * &param)
+{
+    const string &section(Serializable::currentSection());
+    if (!cp.findObj(section, name, param)) {
+        fatal("Can't unserialize '%s:%s'\n", section, name);
+    }
+}
+
+void
+debug_serialize(const string &cpt_dir)
+{
+    Serializable::serializeAll(cpt_dir);
+}