sim, arch, base: Refactor the base remote GDB class.

[gem5.git] / src / sim / serialize.hh

diff --git a/src/sim/serialize.hh b/src/sim/serialize.hh
index 561cd5508ed058f010191f984a0cab4f4196dd1e..1005d5b97a690163145bc3e41bd95f7fe5d62d9a 100644 (file)
--- a/src/sim/serialize.hh
+++ b/src/sim/serialize.hh
@@ -55,30 +55,20 @@
 #include <list>
 #include <map>
 #include <stack>
+#include <set>
 #include <vector>
 
 #include "base/bitunion.hh"
-#include "base/types.hh"
 
+class CheckpointIn;
 class IniFile;
 class Serializable;
-class CheckpointIn;
 class SimObject;
 class SimObjectResolver;
-class EventQueue;
 
 typedef std::ostream CheckpointOut;
 
 
-/** The current version of the checkpoint format.
- * This should be incremented by 1 and only 1 for every new version, where a new
- * version is defined as a checkpoint created before this version won't work on
- * the current version until the checkpoint format is updated. Adding a new
- * SimObject shouldn't cause the version number to increase, only changes to
- * existing objects such as serializing/unserializing more state, changing sizes
- * of serialized arrays, etc. */
-static const uint64_t gem5CheckpointVersion = 0x000000000000000f;
-
 template <class T>
 void paramOut(CheckpointOut &cp, const std::string &name, const T &param);
 
@@ -100,13 +90,15 @@ void paramIn(CheckpointIn &cp, const std::string &name,
 }
 
 template <class T>
-bool optParamIn(CheckpointIn &cp, const std::string &name, T &param);
+bool optParamIn(CheckpointIn &cp, const std::string &name, T &param,
+                bool warn = true);
 
 template <typename DataType, typename BitUnion>
 bool optParamIn(CheckpointIn &cp, const std::string &name,
-                BitfieldBackend::BitUnionOperators<DataType, BitUnion> &p)
+                BitfieldBackend::BitUnionOperators<DataType, BitUnion> &p,
+                bool warn = true)
 {
-    return optParamIn(cp, name, p.__data);
+    return optParamIn(cp, name, p.__data, warn);
 }
 
 template <class T>
@@ -121,6 +113,10 @@ template <class T>
 void arrayParamOut(CheckpointOut &cp, const std::string &name,
                    const std::list<T> &param);
 
+template <class T>
+void arrayParamOut(CheckpointOut &cp, const std::string &name,
+                   const std::set<T> &param);
+
 template <class T>
 void arrayParamIn(CheckpointIn &cp, const std::string &name,
                   T *param, unsigned size);
@@ -133,6 +129,10 @@ template <class T>
 void arrayParamIn(CheckpointIn &cp, const std::string &name,
                   std::list<T> &param);
 
+template <class T>
+void arrayParamIn(CheckpointIn &cp, const std::string &name,
+                  std::set<T> &param);
+
 void
 objParamIn(CheckpointIn &cp, const std::string &name, SimObject * &param);
 
@@ -173,7 +173,7 @@ objParamIn(CheckpointIn &cp, const std::string &name, SimObject * &param);
     do {                                                \
         event.unserializeSection(cp, #event);           \
         eventQueue()->checkpointReschedule(&event);     \
-    } while(0)
+    } while (0)
 
 #define SERIALIZE_OBJ(obj) obj.serializeSection(cp, #obj)
 #define UNSERIALIZE_OBJ(obj) obj.unserializeSection(cp, #obj)
@@ -321,32 +321,6 @@ class Serializable
         unserializeSection(cp, name.c_str());
     }
 
-    /**
-     * @{
-     * @name Legacy interface
-     *
-     * Interface for objects that insist on changing their state when
-     * serializing. Such state change should be done in drain(),
-     * memWriteback(), or memInvalidate() and not in the serialization
-     * method. In general, if state changes occur in serialize, it
-     * complicates testing since it breaks assumptions about draining
-     * and serialization. It potentially also makes components more
-     * fragile since they there are no ordering guarantees when
-     * serializing SimObjects.
-     *
-     * @warn This interface is considered deprecated and should never
-     * be used.
-     */
-
-    virtual void serializeOld(CheckpointOut &cp) {
-        serialize(cp);
-    }
-    void serializeSectionOld(CheckpointOut &cp, const char *name);
-    void serializeSectionOld(CheckpointOut &cp, const std::string &name) {
-        serializeSectionOld(cp, name.c_str());
-    }
-    /** @} */
-
     /** Get the fully-qualified name of the active section */
     static const std::string &currentSection();
 
@@ -383,6 +357,8 @@ class CheckpointIn
     bool findObj(const std::string &section, const std::string &entry,
                  SimObject *&value);
 
+
+    bool entryExists(const std::string &section, const std::string &entry);
     bool sectionExists(const std::string &section);
 
     // The following static functions have to do with checkpoint