derek/gem5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sim: Move paramIn/Out definition to header file

Browse Source 
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>
This commit is contained in:
Giacomo Travaglini
2018-10-17 17:17:48 +01:00
parent f3016e6846
commit 16bf103ad8
2 changed files with 481 additions and 592 deletions
Download Patch File Download Diff File Expand all files Collapse all files

429
src/sim/serialize.cc
View File

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