5a1eb9049d
Can now serialize & unserialize DmaRequestEvents and DmaTransferEvents. Also support serialize/unserialize of pointers to SimObjects and other Serializable objects. arch/alpha/alpha_memory.cc: arch/alpha/alpha_memory.hh: arch/alpha/isa_traits.hh: cpu/exec_context.cc: cpu/exec_context.hh: cpu/simple_cpu/simple_cpu.hh: dev/alpha_access.h: dev/alpha_console.cc: dev/alpha_console.hh: dev/console.cc: dev/console.hh: unserialize() now takes a Checkpoint* instead of an IniFile*. cpu/simple_cpu/simple_cpu.cc: unserialize() now takes a Checkpoint* instead of an IniFile*. Put ExecContext in its own section so its _status fields doesn't conflict. sim/eventq.cc: sim/eventq.hh: unserialize() now takes a Checkpoint* instead of an IniFile*. Events get serialized by the event queue only if they're marked as AutoSerialize... others are assumed to be serialized by something else (e.g. an owning SimObject) or to not matter. sim/param.cc: Shift 'const' in case T is a ptr type. sim/serialize.cc: sim/serialize.hh: Define Checkpoint object to encapsulate everything you need to know about a checkpoint. Use it to allow lookups of named Serializable objects (and SimObjects) during unserialization. unserialize() now takes a Checkpoint* instead of an IniFile*. --HG-- extra : convert_revision : 8e6baab32405f8f548bb67a097b2f713296537a5
505 lines
12 KiB
C++
505 lines
12 KiB
C++
/*
|
|
* Copyright (c) 2003 The Regents of The University of Michigan
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are
|
|
* met: redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer;
|
|
* redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution;
|
|
* neither the name of the copyright holders nor the names of its
|
|
* contributors may be used to endorse or promote products derived from
|
|
* this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <sys/time.h>
|
|
|
|
#include <fstream>
|
|
#include <list>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "base/misc.hh"
|
|
#include "base/str.hh"
|
|
|
|
#include "sim/eventq.hh"
|
|
#include "sim/param.hh"
|
|
#include "sim/serialize.hh"
|
|
#include "base/inifile.hh"
|
|
#include "sim/sim_events.hh"
|
|
#include "sim/sim_object.hh"
|
|
#include "base/trace.hh"
|
|
#include "sim/config_node.hh"
|
|
|
|
using namespace std;
|
|
|
|
Serializer *Serializeable::serializer = NULL;
|
|
|
|
Serializeable::Serializeable(const string &n)
|
|
: objName(n), serialized(false)
|
|
{ }
|
|
|
|
Serializeable::~Serializeable()
|
|
{ }
|
|
|
|
void
|
|
Serializeable::mark()
|
|
{
|
|
if (!serialized)
|
|
serializer->add_object(this);
|
|
|
|
serialized = true;
|
|
}
|
|
|
|
void
|
|
Serializeable::nameOut(ostream &os)
|
|
{
|
|
os << "\n[" << name() << "]\n";
|
|
}
|
|
|
|
void
|
|
Serializeable::nameOut(ostream &os, const string &_name)
|
|
{
|
|
os << "\n[" << _name << "]\n";
|
|
}
|
|
|
|
template <class T>
|
|
void
|
|
paramOut(ostream &os, const std::string &name, const T& param)
|
|
{
|
|
os << name << "=";
|
|
showParam(os, param);
|
|
os << "\n";
|
|
}
|
|
|
|
|
|
template <class T>
|
|
void
|
|
paramIn(Checkpoint *cp, const std::string §ion,
|
|
const std::string &name, T& param)
|
|
{
|
|
std::string str;
|
|
if (!cp->find(section, name, str) || !parseParam(str, param)) {
|
|
fatal("Can't unserialize '%s:%s'\n", section, name);
|
|
}
|
|
}
|
|
|
|
|
|
template <class T>
|
|
void
|
|
arrayParamOut(ostream &os, const std::string &name,
|
|
const T *param, int size)
|
|
{
|
|
os << name << "=";
|
|
if (size > 0)
|
|
showParam(os, param[0]);
|
|
for (int i = 1; i < size; ++i) {
|
|
os << " ";
|
|
showParam(os, param[i]);
|
|
}
|
|
os << "\n";
|
|
}
|
|
|
|
|
|
template <class T>
|
|
void
|
|
arrayParamIn(Checkpoint *cp, const std::string §ion,
|
|
const std::string &name, T *param, int size)
|
|
{
|
|
std::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 (int 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;
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
objParamIn(Checkpoint *cp, const std::string §ion,
|
|
const std::string &name, Serializeable * ¶m)
|
|
{
|
|
if (!cp->findObj(section, name, param)) {
|
|
fatal("Can't unserialize '%s:%s'\n", section, name);
|
|
}
|
|
}
|
|
|
|
|
|
#define INSTANTIATE_PARAM_TEMPLATES(type) \
|
|
template void \
|
|
paramOut(ostream &os, const std::string &name, type const ¶m); \
|
|
template void \
|
|
paramIn(Checkpoint *cp, const std::string §ion, \
|
|
const std::string &name, type & param); \
|
|
template void \
|
|
arrayParamOut(ostream &os, const std::string &name, \
|
|
type const *param, int size); \
|
|
template void \
|
|
arrayParamIn(Checkpoint *cp, const std::string §ion, \
|
|
const std::string &name, type *param, int size);
|
|
|
|
|
|
INSTANTIATE_PARAM_TEMPLATES(int8_t)
|
|
INSTANTIATE_PARAM_TEMPLATES(uint8_t)
|
|
INSTANTIATE_PARAM_TEMPLATES(int16_t)
|
|
INSTANTIATE_PARAM_TEMPLATES(uint16_t)
|
|
INSTANTIATE_PARAM_TEMPLATES(int32_t)
|
|
INSTANTIATE_PARAM_TEMPLATES(uint32_t)
|
|
INSTANTIATE_PARAM_TEMPLATES(int64_t)
|
|
INSTANTIATE_PARAM_TEMPLATES(uint64_t)
|
|
INSTANTIATE_PARAM_TEMPLATES(bool)
|
|
INSTANTIATE_PARAM_TEMPLATES(string)
|
|
|
|
|
|
#if 0
|
|
// unneeded?
|
|
void
|
|
Serializeable::childOut(const string &name, Serializeable *child)
|
|
{
|
|
child->mark();
|
|
if (child->name() == "")
|
|
panic("child is unnamed");
|
|
|
|
out() << name << "=" << child->name() << "\n";
|
|
}
|
|
#endif
|
|
|
|
void
|
|
Serializeable::setName(const string &name)
|
|
{
|
|
if (objName != "") {
|
|
cprintf("Renaming object '%s' to '%s'.\n", objName, name);
|
|
}
|
|
|
|
objName = name;
|
|
}
|
|
|
|
Serializer::Serializer()
|
|
{ }
|
|
|
|
Serializer::~Serializer()
|
|
{ }
|
|
|
|
ostream &
|
|
Serializer::out() const
|
|
{
|
|
if (!output)
|
|
panic("must set output before serializing");
|
|
|
|
return *output;
|
|
}
|
|
|
|
void
|
|
Serializer::add_object(Serializeable *obj)
|
|
{
|
|
objects.push_back(obj);
|
|
}
|
|
|
|
void
|
|
Serializer::add_objects()
|
|
{
|
|
mainEventQueue.mark();
|
|
|
|
SimObject::SimObjectList::iterator i = SimObject::simObjectList.begin();
|
|
SimObject::SimObjectList::iterator end = SimObject::simObjectList.end();
|
|
|
|
while (i != end) {
|
|
(*i)->mark();
|
|
++i;
|
|
}
|
|
}
|
|
|
|
void
|
|
Serializer::serialize(const string &f)
|
|
{
|
|
if (Serializeable::serializer != NULL)
|
|
panic("in process of serializing!");
|
|
|
|
Serializeable::serializer = this;
|
|
|
|
file = f;
|
|
string cpt_file = file + ".cpt";
|
|
output = new ofstream(cpt_file.c_str());
|
|
time_t t = time(NULL);
|
|
*output << "// checkpoint generated: " << ctime(&t);
|
|
|
|
serlist_t list;
|
|
|
|
add_objects();
|
|
while (!objects.empty()) {
|
|
Serializeable *serial = objects.front();
|
|
DPRINTF(Serialize, "Naming children of %s\n", serial->name());
|
|
serial->nameChildren();
|
|
objects.pop_front();
|
|
list.push_back(serial);
|
|
}
|
|
|
|
while (!list.empty()) {
|
|
list.front()->serialized = false;
|
|
list.pop_front();
|
|
}
|
|
|
|
add_objects();
|
|
while (!objects.empty()) {
|
|
Serializeable *obj = objects.front();
|
|
DPRINTF(Serialize, "Serializing %s\n", obj->name());
|
|
obj->nameOut(out());
|
|
obj->serialize(out());
|
|
objects.pop_front();
|
|
list.push_back(obj);
|
|
}
|
|
|
|
while (!list.empty()) {
|
|
list.front()->serialized = false;
|
|
list.pop_front();
|
|
}
|
|
|
|
Serializeable::serializer = NULL;
|
|
|
|
delete output;
|
|
output = NULL;
|
|
file = "";
|
|
}
|
|
|
|
class SerializeEvent : public Event
|
|
{
|
|
protected:
|
|
string file;
|
|
|
|
public:
|
|
SerializeEvent(EventQueue *q, Tick when, const string &file);
|
|
~SerializeEvent();
|
|
|
|
virtual void process();
|
|
virtual void serialize(std::ostream &os);
|
|
};
|
|
|
|
SerializeEvent::SerializeEvent(EventQueue *q, Tick when, const string &f)
|
|
: Event(q), file(f)
|
|
{
|
|
setFlags(AutoDelete);
|
|
schedule(when);
|
|
}
|
|
|
|
SerializeEvent::~SerializeEvent()
|
|
{
|
|
}
|
|
|
|
void
|
|
SerializeEvent::process()
|
|
{
|
|
Serializer serial;
|
|
serial.serialize(file);
|
|
new SimExitEvent("Serialization caused exit");
|
|
}
|
|
|
|
void
|
|
SerializeEvent::serialize(ostream &os)
|
|
{
|
|
panic("Cannot serialize the SerializeEvent");
|
|
}
|
|
|
|
class SerializeParamContext : public ParamContext
|
|
{
|
|
private:
|
|
SerializeEvent *event;
|
|
|
|
public:
|
|
SerializeParamContext(const string §ion);
|
|
~SerializeParamContext();
|
|
void checkParams();
|
|
};
|
|
|
|
SerializeParamContext serialParams("serialize");
|
|
|
|
Param<Counter> serialize_cycle(&serialParams,
|
|
"cycle",
|
|
"cycle to serialize",
|
|
0);
|
|
|
|
Param<string> serialize_file(&serialParams,
|
|
"file",
|
|
"file to write to", "");
|
|
|
|
// Copy filename into regular string so we can export it without
|
|
// having to include param.hh all over the place.
|
|
string serializeFilename;
|
|
|
|
SerializeParamContext::SerializeParamContext(const string §ion)
|
|
: ParamContext(section), event(NULL)
|
|
{ }
|
|
|
|
SerializeParamContext::~SerializeParamContext()
|
|
{
|
|
}
|
|
|
|
void
|
|
SerializeParamContext::checkParams()
|
|
{
|
|
serializeFilename = serialize_file;
|
|
if (!serializeFilename.empty() && serialize_cycle > 0)
|
|
event = new SerializeEvent(&mainEventQueue, serialize_cycle,
|
|
serializeFilename);
|
|
}
|
|
|
|
void
|
|
debug_serialize(const char *file)
|
|
{
|
|
Serializer serial;
|
|
serial.serialize(file);
|
|
new SimExitEvent("Serialization caused exit");
|
|
}
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// SerializeableClass member definitions
|
|
//
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
// Map of class names to SerializeableBuilder creation functions.
|
|
// Need to make this a pointer so we can force initialization on the
|
|
// first reference; otherwise, some SerializeableClass constructors
|
|
// may be invoked before the classMap constructor.
|
|
map<string,SerializeableClass::CreateFunc> *SerializeableClass::classMap = 0;
|
|
|
|
// SerializeableClass constructor: add mapping to classMap
|
|
SerializeableClass::SerializeableClass(const string &className,
|
|
CreateFunc createFunc)
|
|
{
|
|
if (classMap == NULL)
|
|
classMap = new map<string,SerializeableClass::CreateFunc>();
|
|
|
|
if ((*classMap)[className])
|
|
{
|
|
cerr << "Error: simulation object class " << className << " redefined"
|
|
<< endl;
|
|
fatal("");
|
|
}
|
|
|
|
// add className --> createFunc to class map
|
|
(*classMap)[className] = createFunc;
|
|
}
|
|
|
|
|
|
//
|
|
//
|
|
Serializeable *
|
|
SerializeableClass::createObject(Checkpoint *cp,
|
|
const std::string §ion)
|
|
{
|
|
string className;
|
|
|
|
if (!cp->find(section, "type", className)) {
|
|
fatal("Serializeable::create: no 'type' entry in section '%s'.\n",
|
|
section);
|
|
}
|
|
|
|
CreateFunc createFunc = (*classMap)[className];
|
|
|
|
if (createFunc == NULL) {
|
|
fatal("Serializeable::create: no create function for class '%s'.\n",
|
|
className);
|
|
}
|
|
|
|
Serializeable *object = createFunc(cp, section);
|
|
|
|
assert(object != NULL);
|
|
|
|
return object;
|
|
}
|
|
|
|
|
|
Serializeable *
|
|
Serializeable::create(Checkpoint *cp, const std::string §ion)
|
|
{
|
|
Serializeable *object = SerializeableClass::createObject(cp, section);
|
|
object->unserialize(cp, section);
|
|
return object;
|
|
}
|
|
|
|
|
|
Checkpoint::Checkpoint(const std::string &filename, const std::string &path,
|
|
const ConfigNode *_configNode)
|
|
: db(new IniFile), basePath(path), configNode(_configNode)
|
|
{
|
|
if (!db->load(filename)) {
|
|
fatal("Can't load checkpoint file '%s'\n", filename);
|
|
}
|
|
|
|
mainEventQueue.unserialize(this, "MainEventQueue");
|
|
}
|
|
|
|
|
|
bool
|
|
Checkpoint::find(const std::string §ion, const std::string &entry,
|
|
std::string &value)
|
|
{
|
|
return db->find(section, entry, value);
|
|
}
|
|
|
|
|
|
bool
|
|
Checkpoint::findObj(const std::string §ion, const std::string &entry,
|
|
Serializeable *&value)
|
|
{
|
|
string path;
|
|
|
|
if (!db->find(section, entry, path))
|
|
return false;
|
|
|
|
if ((value = configNode->resolveSimObject(path)) != NULL)
|
|
return true;
|
|
|
|
if ((value = objMap[path]) != NULL)
|
|
return true;
|
|
|
|
return false;
|
|
}
|