serialize.cc revision 5543
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
174502SN/AparamOut(ostream &os, const std::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
1834841Ssaidi@eecs.umich.eduarrayParamOut(ostream &os, const std::string &name,
1844841Ssaidi@eecs.umich.edu              const std::vector<T> &param)
1854841Ssaidi@eecs.umich.edu{
1864841Ssaidi@eecs.umich.edu    int size = param.size();
1874841Ssaidi@eecs.umich.edu    os << name << "=";
1884841Ssaidi@eecs.umich.edu    if (size > 0)
1894841Ssaidi@eecs.umich.edu        showParam(os, param[0]);
1904841Ssaidi@eecs.umich.edu    for (int i = 1; i < size; ++i) {
1914841Ssaidi@eecs.umich.edu        os << " ";
1924841Ssaidi@eecs.umich.edu        showParam(os, param[i]);
1934841Ssaidi@eecs.umich.edu    }
1944841Ssaidi@eecs.umich.edu    os << "\n";
1954841Ssaidi@eecs.umich.edu}
1964841Ssaidi@eecs.umich.edu
197217SN/A
198217SN/Atemplate <class T>
199217SN/Avoid
200237SN/AparamIn(Checkpoint *cp, const std::string &section,
201502SN/A        const std::string &name, T &param)
2022SN/A{
203217SN/A    std::string str;
204237SN/A    if (!cp->find(section, name, str) || !parseParam(str, param)) {
205217SN/A        fatal("Can't unserialize '%s:%s'\n", section, name);
206217SN/A    }
2072SN/A}
2082SN/A
209217SN/A
210217SN/Atemplate <class T>
211217SN/Avoid
212217SN/AarrayParamOut(ostream &os, const std::string &name,
213217SN/A              const T *param, int size)
214217SN/A{
215217SN/A    os << name << "=";
216217SN/A    if (size > 0)
217217SN/A        showParam(os, param[0]);
218217SN/A    for (int i = 1; i < size; ++i) {
219217SN/A        os << " ";
220217SN/A        showParam(os, param[i]);
221217SN/A    }
222217SN/A    os << "\n";
223217SN/A}
224217SN/A
225217SN/A
226217SN/Atemplate <class T>
227217SN/Avoid
228237SN/AarrayParamIn(Checkpoint *cp, const std::string &section,
229217SN/A             const std::string &name, T *param, int size)
230217SN/A{
231217SN/A    std::string str;
232237SN/A    if (!cp->find(section, name, str)) {
233217SN/A        fatal("Can't unserialize '%s:%s'\n", section, name);
234217SN/A    }
235217SN/A
236217SN/A    // code below stolen from VectorParam<T>::parse().
237217SN/A    // it would be nice to unify these somehow...
238217SN/A
239217SN/A    vector<string> tokens;
240217SN/A
241217SN/A    tokenize(tokens, str, ' ');
242217SN/A
243217SN/A    // Need this if we were doing a vector
244217SN/A    // value.resize(tokens.size());
245217SN/A
246217SN/A    if (tokens.size() != size) {
247217SN/A        fatal("Array size mismatch on %s:%s'\n", section, name);
248217SN/A    }
249217SN/A
250217SN/A    for (int i = 0; i < tokens.size(); i++) {
251217SN/A        // need to parse into local variable to handle vector<bool>,
252217SN/A        // for which operator[] returns a special reference class
253217SN/A        // that's not the same as 'bool&', (since it's a packed
254217SN/A        // vector)
255217SN/A        T scalar_value;
256217SN/A        if (!parseParam(tokens[i], scalar_value)) {
257217SN/A            string err("could not parse \"");
258217SN/A
259217SN/A            err += str;
260217SN/A            err += "\"";
261217SN/A
262217SN/A            fatal(err);
263217SN/A        }
264217SN/A
265217SN/A        // assign parsed value to vector
266217SN/A        param[i] = scalar_value;
267217SN/A    }
268217SN/A}
269217SN/A
2704841Ssaidi@eecs.umich.edutemplate <class T>
2714841Ssaidi@eecs.umich.eduvoid
2724841Ssaidi@eecs.umich.eduarrayParamIn(Checkpoint *cp, const std::string &section,
2734841Ssaidi@eecs.umich.edu             const std::string &name, std::vector<T> &param)
2744841Ssaidi@eecs.umich.edu{
2754841Ssaidi@eecs.umich.edu    std::string str;
2764841Ssaidi@eecs.umich.edu    if (!cp->find(section, name, str)) {
2774841Ssaidi@eecs.umich.edu        fatal("Can't unserialize '%s:%s'\n", section, name);
2784841Ssaidi@eecs.umich.edu    }
2794841Ssaidi@eecs.umich.edu
2804841Ssaidi@eecs.umich.edu    // code below stolen from VectorParam<T>::parse().
2814841Ssaidi@eecs.umich.edu    // it would be nice to unify these somehow...
2824841Ssaidi@eecs.umich.edu
2834841Ssaidi@eecs.umich.edu    vector<string> tokens;
2844841Ssaidi@eecs.umich.edu
2854841Ssaidi@eecs.umich.edu    tokenize(tokens, str, ' ');
2864841Ssaidi@eecs.umich.edu
2874841Ssaidi@eecs.umich.edu    // Need this if we were doing a vector
2884841Ssaidi@eecs.umich.edu    // value.resize(tokens.size());
2894841Ssaidi@eecs.umich.edu
2904841Ssaidi@eecs.umich.edu    param.resize(tokens.size());
2914841Ssaidi@eecs.umich.edu
2924841Ssaidi@eecs.umich.edu    for (int i = 0; i < tokens.size(); i++) {
2934841Ssaidi@eecs.umich.edu        // need to parse into local variable to handle vector<bool>,
2944841Ssaidi@eecs.umich.edu        // for which operator[] returns a special reference class
2954841Ssaidi@eecs.umich.edu        // that's not the same as 'bool&', (since it's a packed
2964841Ssaidi@eecs.umich.edu        // vector)
2974841Ssaidi@eecs.umich.edu        T scalar_value;
2984841Ssaidi@eecs.umich.edu        if (!parseParam(tokens[i], scalar_value)) {
2994841Ssaidi@eecs.umich.edu            string err("could not parse \"");
3004841Ssaidi@eecs.umich.edu
3014841Ssaidi@eecs.umich.edu            err += str;
3024841Ssaidi@eecs.umich.edu            err += "\"";
3034841Ssaidi@eecs.umich.edu
3044841Ssaidi@eecs.umich.edu            fatal(err);
3054841Ssaidi@eecs.umich.edu        }
3064841Ssaidi@eecs.umich.edu
3074841Ssaidi@eecs.umich.edu        // assign parsed value to vector
3084841Ssaidi@eecs.umich.edu        param[i] = scalar_value;
3094841Ssaidi@eecs.umich.edu    }
3104841Ssaidi@eecs.umich.edu}
3114841Ssaidi@eecs.umich.edu
3124841Ssaidi@eecs.umich.edu
313217SN/A
314237SN/Avoid
315237SN/AobjParamIn(Checkpoint *cp, const std::string &section,
3164000Ssaidi@eecs.umich.edu           const std::string &name, SimObject * &param)
317237SN/A{
318237SN/A    if (!cp->findObj(section, name, param)) {
319237SN/A        fatal("Can't unserialize '%s:%s'\n", section, name);
320237SN/A    }
321237SN/A}
322237SN/A
323237SN/A
3245543Ssaidi@eecs.umich.edu#define INSTANTIATE_PARAM_TEMPLATES(type)                               \
3255543Ssaidi@eecs.umich.edutemplate void                                                           \
3265543Ssaidi@eecs.umich.eduparamOut(ostream &os, const std::string &name, type const &param);      \
3275543Ssaidi@eecs.umich.edutemplate void                                                           \
3285543Ssaidi@eecs.umich.eduparamIn(Checkpoint *cp, const std::string &section,                     \
3295543Ssaidi@eecs.umich.edu        const std::string &name, type & param);                         \
3305543Ssaidi@eecs.umich.edutemplate void                                                           \
3315543Ssaidi@eecs.umich.eduarrayParamOut(ostream &os, const std::string &name,                     \
3325543Ssaidi@eecs.umich.edu              type const *param, int size);                             \
3335543Ssaidi@eecs.umich.edutemplate void                                                           \
3345543Ssaidi@eecs.umich.eduarrayParamIn(Checkpoint *cp, const std::string &section,                \
3354841Ssaidi@eecs.umich.edu             const std::string &name, type *param, int size);           \
3365543Ssaidi@eecs.umich.edutemplate void                                                           \
3375543Ssaidi@eecs.umich.eduarrayParamOut(ostream &os, const std::string &name,                     \
3385543Ssaidi@eecs.umich.edu              const std::vector<type> &param);                          \
3395543Ssaidi@eecs.umich.edutemplate void                                                           \
3405543Ssaidi@eecs.umich.eduarrayParamIn(Checkpoint *cp, const std::string &section,                \
3414841Ssaidi@eecs.umich.edu             const std::string &name, std::vector<type> &param);
342217SN/A
3431642SN/AINSTANTIATE_PARAM_TEMPLATES(signed char)
3441642SN/AINSTANTIATE_PARAM_TEMPLATES(unsigned char)
3451642SN/AINSTANTIATE_PARAM_TEMPLATES(signed short)
3461642SN/AINSTANTIATE_PARAM_TEMPLATES(unsigned short)
3471642SN/AINSTANTIATE_PARAM_TEMPLATES(signed int)
3481642SN/AINSTANTIATE_PARAM_TEMPLATES(unsigned int)
3491642SN/AINSTANTIATE_PARAM_TEMPLATES(signed long)
3501642SN/AINSTANTIATE_PARAM_TEMPLATES(unsigned long)
3511642SN/AINSTANTIATE_PARAM_TEMPLATES(signed long long)
3521642SN/AINSTANTIATE_PARAM_TEMPLATES(unsigned long long)
353219SN/AINSTANTIATE_PARAM_TEMPLATES(bool)
354217SN/AINSTANTIATE_PARAM_TEMPLATES(string)
355217SN/A
356217SN/A
357395SN/A/////////////////////////////
358395SN/A
359395SN/A/// Container for serializing global variables (not associated with
360395SN/A/// any serialized object).
361395SN/Aclass Globals : public Serializable
3622SN/A{
363395SN/A  public:
364512SN/A    const string name() const;
365510SN/A    void serialize(ostream &os);
366395SN/A    void unserialize(Checkpoint *cp);
367395SN/A};
3682SN/A
369395SN/A/// The one and only instance of the Globals class.
370395SN/AGlobals globals;
3712SN/A
372512SN/Aconst string
373395SN/AGlobals::name() const
3742SN/A{
375395SN/A    return "Globals";
3762SN/A}
3772SN/A
3782SN/Avoid
379510SN/AGlobals::serialize(ostream &os)
3802SN/A{
381395SN/A    nameOut(os);
382395SN/A    SERIALIZE_SCALAR(curTick);
383395SN/A
384395SN/A    nameOut(os, "MainEventQueue");
385395SN/A    mainEventQueue.serialize(os);
3862SN/A}
3872SN/A
3882SN/Avoid
389395SN/AGlobals::unserialize(Checkpoint *cp)
3902SN/A{
391395SN/A    const string &section = name();
392395SN/A    UNSERIALIZE_SCALAR(curTick);
3932SN/A
394395SN/A    mainEventQueue.unserialize(cp, "MainEventQueue");
3952SN/A}
3962SN/A
3972SN/Avoid
3982868Sktlim@umich.eduSerializable::serializeAll(const std::string &cpt_dir)
3992SN/A{
4002868Sktlim@umich.edu    setCheckpointDir(cpt_dir);
401449SN/A    string dir = Checkpoint::dir();
402363SN/A    if (mkdir(dir.c_str(), 0775) == -1 && errno != EEXIST)
403449SN/A            fatal("couldn't mkdir %s\n", dir);
404363SN/A
405449SN/A    string cpt_file = dir + Checkpoint::baseFilename;
406395SN/A    ofstream outstream(cpt_file.c_str());
4072SN/A    time_t t = time(NULL);
408395SN/A    outstream << "// checkpoint generated: " << ctime(&t);
4092SN/A
410395SN/A    globals.serialize(outstream);
411395SN/A    SimObject::serializeAll(outstream);
412395SN/A}
4132SN/A
4142797Sktlim@umich.eduvoid
4152868Sktlim@umich.eduSerializable::unserializeAll(const std::string &cpt_dir)
4162797Sktlim@umich.edu{
4172868Sktlim@umich.edu    setCheckpointDir(cpt_dir);
4182797Sktlim@umich.edu    string dir = Checkpoint::dir();
4192797Sktlim@umich.edu    string cpt_file = dir + Checkpoint::baseFilename;
4202797Sktlim@umich.edu    string section = "";
4212797Sktlim@umich.edu
4222797Sktlim@umich.edu    DPRINTFR(Config, "Loading checkpoint dir '%s'\n",
4232797Sktlim@umich.edu             dir);
4242797Sktlim@umich.edu    Checkpoint *cp = new Checkpoint(dir, section);
4252797Sktlim@umich.edu    unserializeGlobals(cp);
4262797Sktlim@umich.edu    SimObject::unserializeAll(cp);
4272797Sktlim@umich.edu}
4282SN/A
429395SN/Avoid
430395SN/ASerializable::unserializeGlobals(Checkpoint *cp)
431395SN/A{
432395SN/A    globals.unserialize(cp);
433395SN/A}
4342SN/A
435449SN/Aconst char *Checkpoint::baseFilename = "m5.cpt";
436449SN/A
437449SN/Astatic string checkpointDirBase;
438294SN/A
4392797Sktlim@umich.eduvoid
4402797Sktlim@umich.edusetCheckpointDir(const std::string &name)
4412797Sktlim@umich.edu{
4422797Sktlim@umich.edu    checkpointDirBase = name;
4432797Sktlim@umich.edu    if (checkpointDirBase[checkpointDirBase.size() - 1] != '/')
4442797Sktlim@umich.edu        checkpointDirBase += "/";
4452797Sktlim@umich.edu}
4462797Sktlim@umich.edu
447294SN/Astring
448449SN/ACheckpoint::dir()
449294SN/A{
450449SN/A    // use csprintf to insert curTick into directory name if it
451449SN/A    // appears to have a format placeholder in it.
452449SN/A    return (checkpointDirBase.find("%") != string::npos) ?
453449SN/A        csprintf(checkpointDirBase, curTick) : checkpointDirBase;
4542SN/A}
4552SN/A
4562SN/Avoid
4572868Sktlim@umich.edudebug_serialize(const std::string &cpt_dir)
4582SN/A{
4592868Sktlim@umich.edu    Serializable::serializeAll(cpt_dir);
4602SN/A}
4612SN/A
4622SN/A
4632SN/A////////////////////////////////////////////////////////////////////////
4642SN/A//
465395SN/A// SerializableClass member definitions
4662SN/A//
4672SN/A////////////////////////////////////////////////////////////////////////
4682SN/A
469395SN/A// Map of class names to SerializableBuilder creation functions.
4702SN/A// Need to make this a pointer so we can force initialization on the
471395SN/A// first reference; otherwise, some SerializableClass constructors
4722SN/A// may be invoked before the classMap constructor.
473395SN/Amap<string,SerializableClass::CreateFunc> *SerializableClass::classMap = 0;
4742SN/A
475395SN/A// SerializableClass constructor: add mapping to classMap
476395SN/ASerializableClass::SerializableClass(const string &className,
4772SN/A                                       CreateFunc createFunc)
4782SN/A{
4792SN/A    if (classMap == NULL)
480395SN/A        classMap = new map<string,SerializableClass::CreateFunc>();
4812SN/A
4822SN/A    if ((*classMap)[className])
4832SN/A    {
4842SN/A        cerr << "Error: simulation object class " << className << " redefined"
4852SN/A             << endl;
4862SN/A        fatal("");
4872SN/A    }
4882SN/A
4892SN/A    // add className --> createFunc to class map
4902SN/A    (*classMap)[className] = createFunc;
4912SN/A}
4922SN/A
4932SN/A
4942SN/A//
4952SN/A//
496395SN/ASerializable *
497395SN/ASerializableClass::createObject(Checkpoint *cp,
498237SN/A                                 const std::string &section)
4992SN/A{
500237SN/A    string className;
5012SN/A
502237SN/A    if (!cp->find(section, "type", className)) {
503395SN/A        fatal("Serializable::create: no 'type' entry in section '%s'.\n",
504237SN/A              section);
5052SN/A    }
5062SN/A
507237SN/A    CreateFunc createFunc = (*classMap)[className];
508237SN/A
509237SN/A    if (createFunc == NULL) {
510395SN/A        fatal("Serializable::create: no create function for class '%s'.\n",
511237SN/A              className);
5122SN/A    }
5132SN/A
514395SN/A    Serializable *object = createFunc(cp, section);
5152SN/A
5162SN/A    assert(object != NULL);
5172SN/A
5182SN/A    return object;
5192SN/A}
5202SN/A
521237SN/A
522395SN/ASerializable *
523395SN/ASerializable::create(Checkpoint *cp, const std::string &section)
524237SN/A{
525395SN/A    Serializable *object = SerializableClass::createObject(cp, section);
526237SN/A    object->unserialize(cp, section);
527237SN/A    return object;
528237SN/A}
529237SN/A
530237SN/A
5312738Sstever@eecs.umich.eduCheckpoint::Checkpoint(const std::string &cpt_dir, const std::string &path)
5322738Sstever@eecs.umich.edu    : db(new IniFile), basePath(path), cptDir(cpt_dir)
533237SN/A{
534449SN/A    string filename = cpt_dir + "/" + Checkpoint::baseFilename;
535237SN/A    if (!db->load(filename)) {
536237SN/A        fatal("Can't load checkpoint file '%s'\n", filename);
537237SN/A    }
538237SN/A}
539237SN/A
540237SN/A
541237SN/Abool
542237SN/ACheckpoint::find(const std::string &section, const std::string &entry,
543237SN/A                 std::string &value)
544237SN/A{
545237SN/A    return db->find(section, entry, value);
546237SN/A}
547237SN/A
548237SN/A
549237SN/Abool
550237SN/ACheckpoint::findObj(const std::string &section, const std::string &entry,
5514000Ssaidi@eecs.umich.edu                    SimObject *&value)
552237SN/A{
553237SN/A    string path;
554237SN/A
555237SN/A    if (!db->find(section, entry, path))
556237SN/A        return false;
557237SN/A
5584000Ssaidi@eecs.umich.edu    value = resolveSimObject(path);
5594000Ssaidi@eecs.umich.edu    return true;
560237SN/A}
561304SN/A
562304SN/A
563304SN/Abool
564304SN/ACheckpoint::sectionExists(const std::string &section)
565304SN/A{
566304SN/A    return db->sectionExists(section);
567304SN/A}
568