serialize.cc revision 6227
12SN/A/*
21762SN/A * Copyright (c) 2002-2005 The Regents of The University of Michigan
32SN/A * All rights reserved.
42SN/A *
52SN/A * Redistribution and use in source and binary forms, with or without
62SN/A * modification, are permitted provided that the following conditions are
72SN/A * met: redistributions of source code must retain the above copyright
82SN/A * notice, this list of conditions and the following disclaimer;
92SN/A * redistributions in binary form must reproduce the above copyright
102SN/A * notice, this list of conditions and the following disclaimer in the
112SN/A * documentation and/or other materials provided with the distribution;
122SN/A * neither the name of the copyright holders nor the names of its
132SN/A * contributors may be used to endorse or promote products derived from
142SN/A * this software without specific prior written permission.
152SN/A *
162SN/A * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
172SN/A * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
182SN/A * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
192SN/A * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
202SN/A * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
212SN/A * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
222SN/A * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
232SN/A * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
242SN/A * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
252SN/A * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
262SN/A * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
272665Ssaidi@eecs.umich.edu *
282760Sbinkertn@umich.edu * Authors: Nathan Binkert
292760Sbinkertn@umich.edu *          Erik Hallnor
302665Ssaidi@eecs.umich.edu *          Steve Reinhardt
312SN/A */
322SN/A
332SN/A#include <sys/time.h>
34363SN/A#include <sys/types.h>
35363SN/A#include <sys/stat.h>
361354SN/A#include <errno.h>
372SN/A
382SN/A#include <fstream>
392SN/A#include <list>
402SN/A#include <string>
412SN/A#include <vector>
422SN/A
43363SN/A#include "base/inifile.hh"
4456SN/A#include "base/misc.hh"
451388SN/A#include "base/output.hh"
46217SN/A#include "base/str.hh"
47363SN/A#include "base/trace.hh"
4856SN/A#include "sim/eventq.hh"
4956SN/A#include "sim/serialize.hh"
5056SN/A#include "sim/sim_events.hh"
511638SN/A#include "sim/sim_exit.hh"
5256SN/A#include "sim/sim_object.hh"
532SN/A
542356SN/A// For stat reset hack
552356SN/A#include "sim/stat_control.hh"
562356SN/A
572SN/Ausing namespace std;
582SN/A
594000Ssaidi@eecs.umich.eduextern SimObject *resolveSimObject(const string &);
604000Ssaidi@eecs.umich.edu
614762Snate@binkert.org//
624762Snate@binkert.org// The base implementations use to_number for parsing and '<<' for
634762Snate@binkert.org// displaying, suitable for integer types.
644762Snate@binkert.org//
654762Snate@binkert.orgtemplate <class T>
664762Snate@binkert.orgbool
674762Snate@binkert.orgparseParam(const string &s, T &value)
684762Snate@binkert.org{
694762Snate@binkert.org    return to_number(s, value);
704762Snate@binkert.org}
714762Snate@binkert.org
724762Snate@binkert.orgtemplate <class T>
734762Snate@binkert.orgvoid
744762Snate@binkert.orgshowParam(ostream &os, const T &value)
754762Snate@binkert.org{
764762Snate@binkert.org    os << value;
774762Snate@binkert.org}
784762Snate@binkert.org
794762Snate@binkert.org//
804762Snate@binkert.org// Template specializations:
814762Snate@binkert.org// - char (8-bit integer)
824762Snate@binkert.org// - floating-point types
834762Snate@binkert.org// - bool
844762Snate@binkert.org// - string
854762Snate@binkert.org//
864762Snate@binkert.org
874762Snate@binkert.org// Treat 8-bit ints (chars) as ints on output, not as chars
884762Snate@binkert.orgtemplate <>
894762Snate@binkert.orgvoid
904762Snate@binkert.orgshowParam(ostream &os, const char &value)
914762Snate@binkert.org{
924762Snate@binkert.org    os << (int)value;
934762Snate@binkert.org}
944762Snate@binkert.org
954762Snate@binkert.org
964762Snate@binkert.orgtemplate <>
974762Snate@binkert.orgvoid
984762Snate@binkert.orgshowParam(ostream &os, const unsigned char &value)
994762Snate@binkert.org{
1004762Snate@binkert.org    os << (unsigned int)value;
1014762Snate@binkert.org}
1024762Snate@binkert.org
1034762Snate@binkert.org
1044762Snate@binkert.org// Use sscanf() for FP types as to_number() only handles integers
1054762Snate@binkert.orgtemplate <>
1064762Snate@binkert.orgbool
1074762Snate@binkert.orgparseParam(const string &s, float &value)
1084762Snate@binkert.org{
1094762Snate@binkert.org    return (sscanf(s.c_str(), "%f", &value) == 1);
1104762Snate@binkert.org}
1114762Snate@binkert.org
1124762Snate@binkert.orgtemplate <>
1134762Snate@binkert.orgbool
1144762Snate@binkert.orgparseParam(const string &s, double &value)
1154762Snate@binkert.org{
1164762Snate@binkert.org    return (sscanf(s.c_str(), "%lf", &value) == 1);
1174762Snate@binkert.org}
1184762Snate@binkert.org
1194762Snate@binkert.orgtemplate <>
1204762Snate@binkert.orgbool
1214762Snate@binkert.orgparseParam(const string &s, bool &value)
1224762Snate@binkert.org{
1234762Snate@binkert.org    const string &ls = to_lower(s);
1244762Snate@binkert.org
1254762Snate@binkert.org    if (ls == "true") {
1264762Snate@binkert.org        value = true;
1274762Snate@binkert.org        return true;
1284762Snate@binkert.org    }
1294762Snate@binkert.org
1304762Snate@binkert.org    if (ls == "false") {
1314762Snate@binkert.org        value = false;
1324762Snate@binkert.org        return true;
1334762Snate@binkert.org    }
1344762Snate@binkert.org
1354762Snate@binkert.org    return false;
1364762Snate@binkert.org}
1374762Snate@binkert.org
1384762Snate@binkert.org// Display bools as strings
1394762Snate@binkert.orgtemplate <>
1404762Snate@binkert.orgvoid
1414762Snate@binkert.orgshowParam(ostream &os, const bool &value)
1424762Snate@binkert.org{
1434762Snate@binkert.org    os << (value ? "true" : "false");
1444762Snate@binkert.org}
1454762Snate@binkert.org
1464762Snate@binkert.org
1474762Snate@binkert.org// String requires no processing to speak of
1484762Snate@binkert.orgtemplate <>
1494762Snate@binkert.orgbool
1504762Snate@binkert.orgparseParam(const string &s, string &value)
1514762Snate@binkert.org{
1524762Snate@binkert.org    value = s;
1534762Snate@binkert.org    return true;
1544762Snate@binkert.org}
1554762Snate@binkert.org
1562287SN/Aint Serializable::ckptMaxCount = 0;
1572287SN/Aint Serializable::ckptCount = 0;
1582287SN/Aint Serializable::ckptPrevCount = -1;
1591637SN/A
1602SN/Avoid
161395SN/ASerializable::nameOut(ostream &os)
1622SN/A{
163217SN/A    os << "\n[" << name() << "]\n";
1642SN/A}
1652SN/A
1662SN/Avoid
167395SN/ASerializable::nameOut(ostream &os, const string &_name)
1682SN/A{
169217SN/A    os << "\n[" << _name << "]\n";
1702SN/A}
1712SN/A
172217SN/Atemplate <class T>
1732SN/Avoid
1746225Snate@binkert.orgparamOut(ostream &os, const string &name, const T &param)
1752SN/A{
176217SN/A    os << name << "=";
177217SN/A    showParam(os, param);
178217SN/A    os << "\n";
1792SN/A}
1802SN/A
1814841Ssaidi@eecs.umich.edutemplate <class T>
1824841Ssaidi@eecs.umich.eduvoid
1836225Snate@binkert.orgarrayParamOut(ostream &os, const string &name, const vector<T> &param)
1844841Ssaidi@eecs.umich.edu{
1856227Snate@binkert.org    typename vector<T>::size_type size = param.size();
1864841Ssaidi@eecs.umich.edu    os << name << "=";
1874841Ssaidi@eecs.umich.edu    if (size > 0)
1884841Ssaidi@eecs.umich.edu        showParam(os, param[0]);
1896227Snate@binkert.org    for (typename vector<T>::size_type i = 1; i < size; ++i) {
1904841Ssaidi@eecs.umich.edu        os << " ";
1914841Ssaidi@eecs.umich.edu        showParam(os, param[i]);
1924841Ssaidi@eecs.umich.edu    }
1934841Ssaidi@eecs.umich.edu    os << "\n";
1944841Ssaidi@eecs.umich.edu}
1954841Ssaidi@eecs.umich.edu
196217SN/A
197217SN/Atemplate <class T>
198217SN/Avoid
1996225Snate@binkert.orgparamIn(Checkpoint *cp, const string &section, const string &name, T &param)
2002SN/A{
2016225Snate@binkert.org    string str;
202237SN/A    if (!cp->find(section, name, str) || !parseParam(str, param)) {
203217SN/A        fatal("Can't unserialize '%s:%s'\n", section, name);
204217SN/A    }
2052SN/A}
2062SN/A
207217SN/A
208217SN/Atemplate <class T>
209217SN/Avoid
2106227Snate@binkert.orgarrayParamOut(ostream &os, const string &name, const T *param, unsigned size)
211217SN/A{
212217SN/A    os << name << "=";
213217SN/A    if (size > 0)
214217SN/A        showParam(os, param[0]);
2156227Snate@binkert.org    for (unsigned i = 1; i < size; ++i) {
216217SN/A        os << " ";
217217SN/A        showParam(os, param[i]);
218217SN/A    }
219217SN/A    os << "\n";
220217SN/A}
221217SN/A
222217SN/A
223217SN/Atemplate <class T>
224217SN/Avoid
2256225Snate@binkert.orgarrayParamIn(Checkpoint *cp, const string &section, const string &name,
2266227Snate@binkert.org             T *param, unsigned size)
227217SN/A{
2286225Snate@binkert.org    string str;
229237SN/A    if (!cp->find(section, name, str)) {
230217SN/A        fatal("Can't unserialize '%s:%s'\n", section, name);
231217SN/A    }
232217SN/A
233217SN/A    // code below stolen from VectorParam<T>::parse().
234217SN/A    // it would be nice to unify these somehow...
235217SN/A
236217SN/A    vector<string> tokens;
237217SN/A
238217SN/A    tokenize(tokens, str, ' ');
239217SN/A
240217SN/A    // Need this if we were doing a vector
241217SN/A    // value.resize(tokens.size());
242217SN/A
243217SN/A    if (tokens.size() != size) {
244217SN/A        fatal("Array size mismatch on %s:%s'\n", section, name);
245217SN/A    }
246217SN/A
2476227Snate@binkert.org    for (vector<string>::size_type i = 0; i < tokens.size(); i++) {
248217SN/A        // need to parse into local variable to handle vector<bool>,
249217SN/A        // for which operator[] returns a special reference class
250217SN/A        // that's not the same as 'bool&', (since it's a packed
251217SN/A        // vector)
252217SN/A        T scalar_value;
253217SN/A        if (!parseParam(tokens[i], scalar_value)) {
254217SN/A            string err("could not parse \"");
255217SN/A
256217SN/A            err += str;
257217SN/A            err += "\"";
258217SN/A
259217SN/A            fatal(err);
260217SN/A        }
261217SN/A
262217SN/A        // assign parsed value to vector
263217SN/A        param[i] = scalar_value;
264217SN/A    }
265217SN/A}
266217SN/A
2674841Ssaidi@eecs.umich.edutemplate <class T>
2684841Ssaidi@eecs.umich.eduvoid
2696225Snate@binkert.orgarrayParamIn(Checkpoint *cp, const string &section,
2706225Snate@binkert.org             const string &name, vector<T> &param)
2714841Ssaidi@eecs.umich.edu{
2726225Snate@binkert.org    string str;
2734841Ssaidi@eecs.umich.edu    if (!cp->find(section, name, str)) {
2744841Ssaidi@eecs.umich.edu        fatal("Can't unserialize '%s:%s'\n", section, name);
2754841Ssaidi@eecs.umich.edu    }
2764841Ssaidi@eecs.umich.edu
2774841Ssaidi@eecs.umich.edu    // code below stolen from VectorParam<T>::parse().
2784841Ssaidi@eecs.umich.edu    // it would be nice to unify these somehow...
2794841Ssaidi@eecs.umich.edu
2804841Ssaidi@eecs.umich.edu    vector<string> tokens;
2814841Ssaidi@eecs.umich.edu
2824841Ssaidi@eecs.umich.edu    tokenize(tokens, str, ' ');
2834841Ssaidi@eecs.umich.edu
2844841Ssaidi@eecs.umich.edu    // Need this if we were doing a vector
2854841Ssaidi@eecs.umich.edu    // value.resize(tokens.size());
2864841Ssaidi@eecs.umich.edu
2874841Ssaidi@eecs.umich.edu    param.resize(tokens.size());
2884841Ssaidi@eecs.umich.edu
2896227Snate@binkert.org    for (vector<string>::size_type i = 0; i < tokens.size(); i++) {
2904841Ssaidi@eecs.umich.edu        // need to parse into local variable to handle vector<bool>,
2914841Ssaidi@eecs.umich.edu        // for which operator[] returns a special reference class
2924841Ssaidi@eecs.umich.edu        // that's not the same as 'bool&', (since it's a packed
2934841Ssaidi@eecs.umich.edu        // vector)
2944841Ssaidi@eecs.umich.edu        T scalar_value;
2954841Ssaidi@eecs.umich.edu        if (!parseParam(tokens[i], scalar_value)) {
2964841Ssaidi@eecs.umich.edu            string err("could not parse \"");
2974841Ssaidi@eecs.umich.edu
2984841Ssaidi@eecs.umich.edu            err += str;
2994841Ssaidi@eecs.umich.edu            err += "\"";
3004841Ssaidi@eecs.umich.edu
3014841Ssaidi@eecs.umich.edu            fatal(err);
3024841Ssaidi@eecs.umich.edu        }
3034841Ssaidi@eecs.umich.edu
3044841Ssaidi@eecs.umich.edu        // assign parsed value to vector
3054841Ssaidi@eecs.umich.edu        param[i] = scalar_value;
3064841Ssaidi@eecs.umich.edu    }
3074841Ssaidi@eecs.umich.edu}
3084841Ssaidi@eecs.umich.edu
309237SN/Avoid
3106225Snate@binkert.orgobjParamIn(Checkpoint *cp, const string &section,
3116225Snate@binkert.org           const string &name, SimObject * &param)
312237SN/A{
313237SN/A    if (!cp->findObj(section, name, param)) {
314237SN/A        fatal("Can't unserialize '%s:%s'\n", section, name);
315237SN/A    }
316237SN/A}
317237SN/A
318237SN/A
3195543Ssaidi@eecs.umich.edu#define INSTANTIATE_PARAM_TEMPLATES(type)                               \
3205543Ssaidi@eecs.umich.edutemplate void                                                           \
3216225Snate@binkert.orgparamOut(ostream &os, const string &name, type const &param);           \
3225543Ssaidi@eecs.umich.edutemplate void                                                           \
3236225Snate@binkert.orgparamIn(Checkpoint *cp, const string &section,                          \
3246225Snate@binkert.org        const string &name, type & param);                              \
3255543Ssaidi@eecs.umich.edutemplate void                                                           \
3266225Snate@binkert.orgarrayParamOut(ostream &os, const string &name,                          \
3276227Snate@binkert.org              type const *param, unsigned size);                        \
3285543Ssaidi@eecs.umich.edutemplate void                                                           \
3296225Snate@binkert.orgarrayParamIn(Checkpoint *cp, const string &section,                     \
3306227Snate@binkert.org             const string &name, type *param, unsigned size);           \
3315543Ssaidi@eecs.umich.edutemplate void                                                           \
3326225Snate@binkert.orgarrayParamOut(ostream &os, const string &name,                          \
3336225Snate@binkert.org              const vector<type> &param);                               \
3345543Ssaidi@eecs.umich.edutemplate void                                                           \
3356225Snate@binkert.orgarrayParamIn(Checkpoint *cp, const string &section,                     \
3366225Snate@binkert.org             const string &name, vector<type> &param);
337217SN/A
3381642SN/AINSTANTIATE_PARAM_TEMPLATES(signed char)
3391642SN/AINSTANTIATE_PARAM_TEMPLATES(unsigned char)
3401642SN/AINSTANTIATE_PARAM_TEMPLATES(signed short)
3411642SN/AINSTANTIATE_PARAM_TEMPLATES(unsigned short)
3421642SN/AINSTANTIATE_PARAM_TEMPLATES(signed int)
3431642SN/AINSTANTIATE_PARAM_TEMPLATES(unsigned int)
3441642SN/AINSTANTIATE_PARAM_TEMPLATES(signed long)
3451642SN/AINSTANTIATE_PARAM_TEMPLATES(unsigned long)
3461642SN/AINSTANTIATE_PARAM_TEMPLATES(signed long long)
3471642SN/AINSTANTIATE_PARAM_TEMPLATES(unsigned long long)
348219SN/AINSTANTIATE_PARAM_TEMPLATES(bool)
3495992Snate@binkert.orgINSTANTIATE_PARAM_TEMPLATES(float)
3505992Snate@binkert.orgINSTANTIATE_PARAM_TEMPLATES(double)
351217SN/AINSTANTIATE_PARAM_TEMPLATES(string)
352217SN/A
353217SN/A
354395SN/A/////////////////////////////
355395SN/A
356395SN/A/// Container for serializing global variables (not associated with
357395SN/A/// any serialized object).
358395SN/Aclass Globals : public Serializable
3592SN/A{
360395SN/A  public:
361512SN/A    const string name() const;
362510SN/A    void serialize(ostream &os);
363395SN/A    void unserialize(Checkpoint *cp);
364395SN/A};
3652SN/A
366395SN/A/// The one and only instance of the Globals class.
367395SN/AGlobals globals;
3682SN/A
369512SN/Aconst string
370395SN/AGlobals::name() const
3712SN/A{
372395SN/A    return "Globals";
3732SN/A}
3742SN/A
3752SN/Avoid
376510SN/AGlobals::serialize(ostream &os)
3772SN/A{
378395SN/A    nameOut(os);
379395SN/A    SERIALIZE_SCALAR(curTick);
380395SN/A
381395SN/A    nameOut(os, "MainEventQueue");
382395SN/A    mainEventQueue.serialize(os);
3832SN/A}
3842SN/A
3852SN/Avoid
386395SN/AGlobals::unserialize(Checkpoint *cp)
3872SN/A{
388395SN/A    const string &section = name();
389395SN/A    UNSERIALIZE_SCALAR(curTick);
3902SN/A
391395SN/A    mainEventQueue.unserialize(cp, "MainEventQueue");
3922SN/A}
3932SN/A
3945739Snate@binkert.orgSerializable::Serializable()
3955739Snate@binkert.org{
3965739Snate@binkert.org}
3975739Snate@binkert.org
3985739Snate@binkert.orgSerializable::~Serializable()
3995739Snate@binkert.org{
4005739Snate@binkert.org}
4015739Snate@binkert.org
4025739Snate@binkert.orgvoid
4036225Snate@binkert.orgSerializable::serialize(ostream &os)
4045739Snate@binkert.org{
4055739Snate@binkert.org}
4065739Snate@binkert.org
4075739Snate@binkert.orgvoid
4086225Snate@binkert.orgSerializable::unserialize(Checkpoint *cp, const string &section)
4095739Snate@binkert.org{
4105739Snate@binkert.org}
4115739Snate@binkert.org
4122SN/Avoid
4136225Snate@binkert.orgSerializable::serializeAll(const string &cpt_dir)
4142SN/A{
4152868Sktlim@umich.edu    setCheckpointDir(cpt_dir);
416449SN/A    string dir = Checkpoint::dir();
417363SN/A    if (mkdir(dir.c_str(), 0775) == -1 && errno != EEXIST)
418449SN/A            fatal("couldn't mkdir %s\n", dir);
419363SN/A
420449SN/A    string cpt_file = dir + Checkpoint::baseFilename;
421395SN/A    ofstream outstream(cpt_file.c_str());
4222SN/A    time_t t = time(NULL);
4235581Ssaidi@eecs.umich.edu    if (!outstream.is_open())
4245581Ssaidi@eecs.umich.edu        fatal("Unable to open file %s for writing\n", cpt_file.c_str());
425395SN/A    outstream << "// checkpoint generated: " << ctime(&t);
4262SN/A
427395SN/A    globals.serialize(outstream);
428395SN/A    SimObject::serializeAll(outstream);
429395SN/A}
4302SN/A
4312797Sktlim@umich.eduvoid
4326225Snate@binkert.orgSerializable::unserializeAll(const string &cpt_dir)
4332797Sktlim@umich.edu{
4342868Sktlim@umich.edu    setCheckpointDir(cpt_dir);
4352797Sktlim@umich.edu    string dir = Checkpoint::dir();
4362797Sktlim@umich.edu    string cpt_file = dir + Checkpoint::baseFilename;
4372797Sktlim@umich.edu    string section = "";
4382797Sktlim@umich.edu
4392797Sktlim@umich.edu    DPRINTFR(Config, "Loading checkpoint dir '%s'\n",
4402797Sktlim@umich.edu             dir);
4412797Sktlim@umich.edu    Checkpoint *cp = new Checkpoint(dir, section);
4422797Sktlim@umich.edu    unserializeGlobals(cp);
4432797Sktlim@umich.edu    SimObject::unserializeAll(cp);
4442797Sktlim@umich.edu}
4452SN/A
446395SN/Avoid
447395SN/ASerializable::unserializeGlobals(Checkpoint *cp)
448395SN/A{
449395SN/A    globals.unserialize(cp);
450395SN/A}
4512SN/A
452449SN/Aconst char *Checkpoint::baseFilename = "m5.cpt";
453449SN/A
454449SN/Astatic string checkpointDirBase;
455294SN/A
4562797Sktlim@umich.eduvoid
4576225Snate@binkert.orgsetCheckpointDir(const string &name)
4582797Sktlim@umich.edu{
4592797Sktlim@umich.edu    checkpointDirBase = name;
4602797Sktlim@umich.edu    if (checkpointDirBase[checkpointDirBase.size() - 1] != '/')
4612797Sktlim@umich.edu        checkpointDirBase += "/";
4622797Sktlim@umich.edu}
4632797Sktlim@umich.edu
464294SN/Astring
465449SN/ACheckpoint::dir()
466294SN/A{
467449SN/A    // use csprintf to insert curTick into directory name if it
468449SN/A    // appears to have a format placeholder in it.
469449SN/A    return (checkpointDirBase.find("%") != string::npos) ?
470449SN/A        csprintf(checkpointDirBase, curTick) : checkpointDirBase;
4712SN/A}
4722SN/A
4732SN/Avoid
4746225Snate@binkert.orgdebug_serialize(const string &cpt_dir)
4752SN/A{
4762868Sktlim@umich.edu    Serializable::serializeAll(cpt_dir);
4772SN/A}
4782SN/A
4792SN/A
4802SN/A////////////////////////////////////////////////////////////////////////
4812SN/A//
482395SN/A// SerializableClass member definitions
4832SN/A//
4842SN/A////////////////////////////////////////////////////////////////////////
4852SN/A
486395SN/A// Map of class names to SerializableBuilder creation functions.
4872SN/A// Need to make this a pointer so we can force initialization on the
488395SN/A// first reference; otherwise, some SerializableClass constructors
4892SN/A// may be invoked before the classMap constructor.
4906225Snate@binkert.orgmap<string, SerializableClass::CreateFunc> *SerializableClass::classMap = 0;
4912SN/A
492395SN/A// SerializableClass constructor: add mapping to classMap
493395SN/ASerializableClass::SerializableClass(const string &className,
4946225Snate@binkert.org                                     CreateFunc createFunc)
4952SN/A{
4962SN/A    if (classMap == NULL)
4976225Snate@binkert.org        classMap = new map<string, SerializableClass::CreateFunc>();
4982SN/A
4992SN/A    if ((*classMap)[className])
5006225Snate@binkert.org        fatal("Error: simulation object class %s redefined\n", className);
5012SN/A
5022SN/A    // add className --> createFunc to class map
5032SN/A    (*classMap)[className] = createFunc;
5042SN/A}
5052SN/A
5062SN/A//
5072SN/A//
508395SN/ASerializable *
5096225Snate@binkert.orgSerializableClass::createObject(Checkpoint *cp, const string &section)
5102SN/A{
511237SN/A    string className;
5122SN/A
513237SN/A    if (!cp->find(section, "type", className)) {
514395SN/A        fatal("Serializable::create: no 'type' entry in section '%s'.\n",
515237SN/A              section);
5162SN/A    }
5172SN/A
518237SN/A    CreateFunc createFunc = (*classMap)[className];
519237SN/A
520237SN/A    if (createFunc == NULL) {
521395SN/A        fatal("Serializable::create: no create function for class '%s'.\n",
522237SN/A              className);
5232SN/A    }
5242SN/A
525395SN/A    Serializable *object = createFunc(cp, section);
5262SN/A
5272SN/A    assert(object != NULL);
5282SN/A
5292SN/A    return object;
5302SN/A}
5312SN/A
532237SN/A
533395SN/ASerializable *
5346225Snate@binkert.orgSerializable::create(Checkpoint *cp, const string &section)
535237SN/A{
536395SN/A    Serializable *object = SerializableClass::createObject(cp, section);
537237SN/A    object->unserialize(cp, section);
538237SN/A    return object;
539237SN/A}
540237SN/A
541237SN/A
5426225Snate@binkert.orgCheckpoint::Checkpoint(const string &cpt_dir, const string &path)
5432738Sstever@eecs.umich.edu    : db(new IniFile), basePath(path), cptDir(cpt_dir)
544237SN/A{
545449SN/A    string filename = cpt_dir + "/" + Checkpoint::baseFilename;
546237SN/A    if (!db->load(filename)) {
547237SN/A        fatal("Can't load checkpoint file '%s'\n", filename);
548237SN/A    }
549237SN/A}
550237SN/A
551237SN/A
552237SN/Abool
5536225Snate@binkert.orgCheckpoint::find(const string &section, const string &entry, string &value)
554237SN/A{
555237SN/A    return db->find(section, entry, value);
556237SN/A}
557237SN/A
558237SN/A
559237SN/Abool
5606225Snate@binkert.orgCheckpoint::findObj(const string &section, const string &entry,
5614000Ssaidi@eecs.umich.edu                    SimObject *&value)
562237SN/A{
563237SN/A    string path;
564237SN/A
565237SN/A    if (!db->find(section, entry, path))
566237SN/A        return false;
567237SN/A
5684000Ssaidi@eecs.umich.edu    value = resolveSimObject(path);
5694000Ssaidi@eecs.umich.edu    return true;
570237SN/A}
571304SN/A
572304SN/A
573304SN/Abool
5746225Snate@binkert.orgCheckpoint::sectionExists(const string &section)
575304SN/A{
576304SN/A    return db->sectionExists(section);
577304SN/A}
578