Modify handling of serialize:dir parameter to make it more useful.

Move global checkpoint-related functions and vars into Checkpoint class (as statics).

arch/alpha/pseudo_inst.cc:
dev/disk_image.cc:
    Move global checkpoint-related functions and vars
    into Checkpoint class (as statics).
sim/serialize.cc:
    Move global checkpoint-related functions and vars
    into Checkpoint class (as statics).

    Checkpoint constructor now takes checkpoint directory name instead
    of file name.

    Make serialize:dir parameter actually set checkpoint directory name
    instead of directory in which checkpoint directory is created.  If
    the value contains a '%', the curTick value is sprintf'd into the
    format to create the directory name.  The default is backwards compatible
    with the old fixed name ("m5.%012d").
sim/serialize.hh:
    Move global checkpoint-related functions and vars
    into Checkpoint class (as statics).

    Checkpoint constructor now takes checkpoint directory name instead
    of file name.

--HG--
extra : convert_revision : d0aa87b62911f405a4f5811271b9e6351fdd9fe4

2 files changed, 40 insertions, 23 deletions

diff --git a/sim/serialize.cc b/sim/serialize.cc
index 95aacc361..33956c6e7 100644
--- a/sim/serialize.cc
+++ b/sim/serialize.cc
@@ -222,11 +222,11 @@ Globals::unserialize(Checkpoint *cp)
 void
 Serializable::serializeAll()
 {
-    string dir = CheckpointDir();
+    string dir = Checkpoint::dir();
     if (mkdir(dir.c_str(), 0775) == -1 && errno != EEXIST)
-            warn("could mkdir %s\n", dir);
+            fatal("couldn't mkdir %s\n", dir);
 
-    string cpt_file = dir + "m5.cpt";
+    string cpt_file = dir + Checkpoint::baseFilename;
     ofstream outstream(cpt_file.c_str());
     time_t t = time(NULL);
     outstream << "// checkpoint generated: " << ctime(&t);
@@ -273,19 +273,21 @@ SerializeEvent::process()
         schedule(curTick + repeat);
 }
 
-string __CheckpointDirBase;
+const char *Checkpoint::baseFilename = "m5.cpt";
+
+static string checkpointDirBase;
 
 string
-CheckpointDir()
+Checkpoint::dir()
 {
-    if (__CheckpointDirBase.empty())
-        return __CheckpointDirBase;
-
-    return csprintf("%s/m5.%012d/", __CheckpointDirBase, curTick);
+    // use csprintf to insert curTick into directory name if it
+    // appears to have a format placeholder in it.
+    return (checkpointDirBase.find("%") != string::npos) ?
+        csprintf(checkpointDirBase, curTick) : checkpointDirBase;
 }
 
 void
-SetupCheckpoint(Tick when, Tick period)
+Checkpoint::setup(Tick when, Tick period)
 {
     new SerializeEvent(when, period);
 }
@@ -304,8 +306,9 @@ class SerializeParamContext : public ParamContext
 SerializeParamContext serialParams("serialize");
 
 Param<string> serialize_dir(&serialParams,
-                             "dir",
-                             "dir to stick checkpoint in", ".");
+                            "dir",
+                            "dir to stick checkpoint in "
+                            "(sprintf format with cycle #)", "m5.%012d");
 
 Param<Counter> serialize_cycle(&serialParams,
                                 "cycle",
@@ -330,9 +333,14 @@ SerializeParamContext::~SerializeParamContext()
 void
 SerializeParamContext::checkParams()
 {
-    __CheckpointDirBase = serialize_dir;
+    checkpointDirBase = serialize_dir;
+    // guarantee that directory ends with a '/'
+    if (checkpointDirBase[checkpointDirBase.size() - 1] != '/') {
+        checkpointDirBase += "/";
+    }
+
     if (serialize_cycle > 0)
-        SetupCheckpoint(serialize_cycle, serialize_period);
+        Checkpoint::setup(serialize_cycle, serialize_period);
 }
 
 void
@@ -415,10 +423,11 @@ Serializable::create(Checkpoint *cp, const std::string &section)
 }
 
 
-Checkpoint::Checkpoint(const std::string &filename, const std::string &path,
+Checkpoint::Checkpoint(const std::string &cpt_dir, const std::string &path,
                        const ConfigNode *_configNode)
     : db(new IniFile), basePath(path), configNode(_configNode)
 {
+    string filename = cpt_dir + "/" + Checkpoint::baseFilename;
     if (!db->load(filename)) {
         fatal("Can't load checkpoint file '%s'\n", filename);
     }
diff --git a/sim/serialize.hh b/sim/serialize.hh
index 60e06f94b..32802409d 100644
--- a/sim/serialize.hh
+++ b/sim/serialize.hh
@@ -207,7 +207,7 @@ class Checkpoint
     std::map<std::string, Serializable*> objMap;
 
   public:
-    Checkpoint(const std::string &filename, const std::string &path,
+    Checkpoint(const std::string &cpt_dir, const std::string &path,
                const ConfigNode *_configNode);
 
     bool find(const std::string &section, const std::string &entry,
@@ -217,14 +217,22 @@ class Checkpoint
                  Serializable *&value);
 
     bool sectionExists(const std::string &section);
-};
 
+    // The following static functions have to do with checkpoint
+    // creation rather than restoration.  This class makes a handy
+    // namespace for them though.
 
-//
-// Export checkpoint filename param so other objects can derive
-// filenames from it (e.g., memory).
-//
-std::string CheckpointDir();
-void SetupCheckpoint(Tick when, Tick period = 0);
+    // Export current checkpoint directory name so other objects can
+    // derive filenames from it (e.g., memory).  The return value is
+    // guaranteed to end in '/' so filenames can be directly appended.
+    // This function is only valid while a checkpoint is being created.
+    static std::string dir();
+
+    // Filename for base checkpoint file within directory.
+    static const char *baseFilename;
+
+    // Set up a checkpoint creation event or series of events.
+    static void setup(Tick when, Tick period = 0);
+};
 
 #endif // __SERIALIZE_HH__