* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
- * Authors: Erik Hallnor
+ * Authors: Nathan Binkert
+ * Erik Hallnor
* Steve Reinhardt
*/
#define __SERIALIZE_HH__
-#include <list>
#include <iostream>
+#include <list>
#include <map>
+#include <vector>
-#include "sim/host.hh"
-#include "sim/configfile.hh"
+#include "base/types.hh"
+class IniFile;
class Serializable;
class Checkpoint;
+class SimObject;
template <class T>
void paramOut(std::ostream &os, const std::string &name, const T ¶m);
void paramIn(Checkpoint *cp, const std::string §ion,
const std::string &name, T ¶m);
+template <class T>
+bool optParamIn(Checkpoint *cp, const std::string §ion,
+ const std::string &name, T ¶m);
+
+template <class T>
+void arrayParamOut(std::ostream &os, const std::string &name,
+ const T *param, unsigned size);
+
+template <class T>
+void arrayParamOut(std::ostream &os, const std::string &name,
+ const std::vector<T> ¶m);
+
template <class T>
void arrayParamOut(std::ostream &os, const std::string &name,
- const T *param, int size);
+ const std::list<T> ¶m);
template <class T>
void arrayParamIn(Checkpoint *cp, const std::string §ion,
- const std::string &name, T *param, int size);
+ const std::string &name, T *param, unsigned size);
+
+template <class T>
+void arrayParamIn(Checkpoint *cp, const std::string §ion,
+ const std::string &name, std::vector<T> ¶m);
+
+template <class T>
+void arrayParamIn(Checkpoint *cp, const std::string §ion,
+ const std::string &name, std::list<T> ¶m);
void
objParamIn(Checkpoint *cp, const std::string §ion,
- const std::string &name, Serializable * ¶m);
+ const std::string &name, SimObject * ¶m);
//
// These macros are streamlined to use in serialize/unserialize
// functions. It's assumed that serialize() has a parameter 'os' for
// the ostream, and unserialize() has parameters 'cp' and 'section'.
-#define SERIALIZE_SCALAR(scalar) paramOut(os, #scalar, scalar)
+#define SERIALIZE_SCALAR(scalar) paramOut(os, #scalar, scalar)
-#define UNSERIALIZE_SCALAR(scalar) paramIn(cp, section, #scalar, scalar)
+#define UNSERIALIZE_SCALAR(scalar) paramIn(cp, section, #scalar, scalar)
+#define UNSERIALIZE_OPT_SCALAR(scalar) optParamIn(cp, section, #scalar, scalar)
// ENUMs are like SCALARs, but we cast them to ints on the way out
-#define SERIALIZE_ENUM(scalar) paramOut(os, #scalar, (int)scalar)
+#define SERIALIZE_ENUM(scalar) paramOut(os, #scalar, (int)scalar)
-#define UNSERIALIZE_ENUM(scalar) \
- do { \
- int tmp; \
- paramIn(cp, section, #scalar, tmp); \
- scalar = (typeof(scalar))tmp; \
+#define UNSERIALIZE_ENUM(scalar) \
+ do { \
+ int tmp; \
+ paramIn(cp, section, #scalar, tmp); \
+ scalar = (typeof(scalar))tmp; \
} while (0)
-#define SERIALIZE_ARRAY(member, size) \
+#define SERIALIZE_ARRAY(member, size) \
arrayParamOut(os, #member, member, size)
-#define UNSERIALIZE_ARRAY(member, size) \
+#define UNSERIALIZE_ARRAY(member, size) \
arrayParamIn(cp, section, #member, member, size)
-#define SERIALIZE_OBJPTR(objptr) paramOut(os, #objptr, (objptr)->name())
+#define SERIALIZE_OBJPTR(objptr) paramOut(os, #objptr, (objptr)->name())
-#define UNSERIALIZE_OBJPTR(objptr) \
- do { \
- Serializable *sptr; \
- objParamIn(cp, section, #objptr, sptr); \
- objptr = dynamic_cast<typeof(objptr)>(sptr); \
+#define UNSERIALIZE_OBJPTR(objptr) \
+ do { \
+ SimObject *sptr; \
+ objParamIn(cp, section, #objptr, sptr); \
+ objptr = dynamic_cast<typeof(objptr)>(sptr); \
} while (0)
/*
void nameOut(std::ostream &os, const std::string &_name);
public:
- Serializable() {}
- virtual ~Serializable() {}
+ Serializable();
+ virtual ~Serializable();
// manditory virtual function, so objects must provide names
virtual const std::string name() const = 0;
- virtual void serialize(std::ostream &os) {}
- virtual void unserialize(Checkpoint *cp, const std::string §ion) {}
+ virtual void serialize(std::ostream &os);
+ virtual void unserialize(Checkpoint *cp, const std::string §ion);
- static Serializable *create(Checkpoint *cp,
- const std::string §ion);
+ static Serializable *create(Checkpoint *cp, const std::string §ion);
static int ckptCount;
static int ckptMaxCount;
static int ckptPrevCount;
- static void serializeAll();
+ static void serializeAll(const std::string &cpt_dir);
static void unserializeGlobals(Checkpoint *cp);
};
// an optional config hierarchy node (specified by the third
// argument). A pointer to the new SerializableBuilder is returned.
typedef Serializable *(*CreateFunc)(Checkpoint *cp,
- const std::string §ion);
+ const std::string §ion);
static std::map<std::string,CreateFunc> *classMap;
// create Serializable given name of class and pointer to
// configuration hierarchy node
static Serializable *createObject(Checkpoint *cp,
- const std::string §ion);
+ const std::string §ion);
};
//
// SerializableBuilder and SerializableClass objects
//
-#define REGISTER_SERIALIZEABLE(CLASS_NAME, OBJ_CLASS) \
-SerializableClass the##OBJ_CLASS##Class(CLASS_NAME, \
+#define REGISTER_SERIALIZEABLE(CLASS_NAME, OBJ_CLASS) \
+SerializableClass the##OBJ_CLASS##Class(CLASS_NAME, \
OBJ_CLASS::createForUnserialize);
class Checkpoint
private:
IniFile *db;
- const std::string basePath;
- const ConfigNode *configNode;
- std::map<std::string, Serializable*> objMap;
public:
- Checkpoint(const std::string &cpt_dir, const std::string &path,
- const ConfigNode *_configNode);
+ Checkpoint(const std::string &cpt_dir);
const std::string cptDir;
std::string &value);
bool findObj(const std::string §ion, const std::string &entry,
- Serializable *&value);
+ SimObject *&value);
bool sectionExists(const std::string §ion);
// The following static functions have to do with checkpoint
// creation rather than restoration. This class makes a handy
- // namespace for them though.
+ // namespace for them though. Currently no Checkpoint object is
+ // created on serialization (only unserialization) so we track the
+ // directory name as a global. It would be nice to change this
+ // someday
+
+ private:
+ // current directory we're serializing into.
+ static std::string currentDirectory;
+
+ public:
+ // Set the current directory. This function takes care of
+ // inserting curTick() if there's a '%d' in the argument, and
+ // appends a '/' if necessary. The final name is returned.
+ static std::string setDir(const std::string &base_name);
// Export current checkpoint directory name so other objects can
// derive filenames from it (e.g., memory). The return value is
// 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__