sim/serialize.hh

   1 /*
   2  * Copyright (c) 2003 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 /* @file
  30  * Serialization Interface Declarations
  31  */
  32
  33 #ifndef __SERIALIZE_HH__
  34 #define __SERIALIZE_HH__
  35
  36
  37 #include <list>
  38 #include <iostream>
  39
  40 #include "sim/host.hh"
  41 #include "sim/configfile.hh"
  42
  43 class IniFile;
  44
  45 /*
  46  * Basic support for object serialization.
  47  */
  48 class Serializeable
  49 {
  50   public:
  51     // To allow other classes to do some of the serialization work.
  52     class Proxy {
  53       private:
  54         Serializeable *obj;
  55
  56         // Make it so only Serializables can construct one of these.
  57         Proxy(Serializeable *o) : obj(o) {};
  58
  59         friend class Serializeable;
  60
  61       public:
  62         template <class T>
  63         void paramOut(const std::string &name, const T& param) const {
  64             obj->paramOut(name, param);
  65         };
  66     };
  67
  68     friend class Serializer;
  69     friend class Proxy;
  70
  71   private:
  72     Proxy proxy;
  73
  74   protected:
  75     const Proxy &getProxy() { return(proxy); };
  76
  77     // object name: should be unique
  78     std::string objName;
  79
  80     bool serialized;
  81     static Serializer *serializer;
  82
  83     void mark();
  84     void nameOut();
  85     void nameOut(const std::string &_name);
  86     void childOut(const std::string &name, Serializeable *child);
  87     template <class T>
  88     void paramOut(const std::string &name, const T& param);
  89
  90     std::ostream &out() const;
  91
  92   public:
  93     Serializeable(const std::string &n);
  94     virtual ~Serializeable();
  95
  96     void setName(const std::string &name);
  97
  98     // return name
  99     const std::string &name() const { return objName; }
 100
 101     virtual void nameChildren() {}
 102     virtual void serialize() {}
 103     virtual void unserialize(IniFile &db, const std::string &category,
 104                              ConfigNode *node = NULL)
 105     {
 106         std::cout << name() << " is being unserialized" << std::endl;
 107     }
 108 };
 109
 110 class Serializer
 111 {
 112     friend class Serializeable;
 113
 114   protected:
 115     typedef std::list<Serializeable *> serlist_t;
 116     serlist_t objects;
 117     std::string file;
 118     std::ostream *output;
 119     std::ostream &out() const;
 120
 121   public:
 122     Serializer();
 123     virtual ~Serializer();
 124
 125   private:
 126     void add_object(Serializeable *obj);
 127     void add_objects();
 128
 129   public:
 130     void serialize(const std::string &file);
 131     const std::string &filename() const { return file; }
 132 };
 133
 134 template <class T>
 135 inline void
 136 Serializeable::paramOut(const std::string &name, const T& param)
 137 {
 138     out() << name << "=" << param << "\n";
 139 }
 140
 141 template <> void
 142 Serializeable::paramOut(const std::string &name, const uint64_t& param);
 143
 144
 145 //
 146 // A SerializeableBuilder serves as an evaluation context for a set of
 147 // parameters that describe a specific instance of a Serializeable.  This
 148 // evaluation context corresponds to a section in the .ini file (as
 149 // with the base ParamContext) plus an optional node in the
 150 // configuration hierarchy (the configNode member) for resolving
 151 // Serializeable references.  SerializeableBuilder is an abstract superclass;
 152 // derived classes specialize the class for particular subclasses of
 153 // Serializeable (e.g., BaseCache).
 154 //
 155 // For typical usage, see the definition of
 156 // SerializeableClass::createObject().
 157 //
 158 class SerializeableBuilder
 159 {
 160   public:
 161
 162     SerializeableBuilder() {}
 163
 164     virtual ~SerializeableBuilder() {}
 165
 166     // Create the actual Serializeable corresponding to the parameter
 167     // values in this context.  This function is overridden in derived
 168     // classes to call a specific constructor for a particular
 169     // subclass of Serializeable.
 170     virtual Serializeable *create() = 0;
 171 };
 172
 173 //
 174 // An instance of SerializeableClass corresponds to a class derived from
 175 // Serializeable.  The SerializeableClass instance serves to bind the string
 176 // name (found in the config file) to a function that creates an
 177 // instance of the appropriate derived class.
 178 //
 179 // This would be much cleaner in Smalltalk or Objective-C, where types
 180 // are first-class objects themselves.
 181 //
 182 class SerializeableClass
 183 {
 184   public:
 185
 186     // Type CreateFunc is a pointer to a function that creates a new
 187     // simulation object builder based on a .ini-file parameter
 188     // section (specified by the first string argument), a unique name
 189     // for the object (specified by the second string argument), and
 190     // an optional config hierarchy node (specified by the third
 191     // argument).  A pointer to the new SerializeableBuilder is returned.
 192     typedef SerializeableBuilder *(*CreateFunc)();
 193
 194     static std::map<std::string,CreateFunc> *classMap;
 195
 196     // Constructor.  For example:
 197     //
 198     // SerializeableClass baseCacheSerializeableClass("BaseCacheSerializeable",
 199     //                         newBaseCacheSerializeableBuilder);
 200     //
 201     SerializeableClass(const std::string &className, CreateFunc createFunc);
 202
 203     // create Serializeable given name of class and pointer to
 204     // configuration hierarchy node
 205     static Serializeable *createObject(IniFile &configDB,
 206                                        const std::string &configClassName);
 207
 208 };
 209
 210 //
 211 // Macros to encapsulate the magic of declaring & defining
 212 // SerializeableBuilder and SerializeableClass objects
 213 //
 214
 215 #define CREATE_SERIALIZEABLE(OBJ_CLASS)                         \
 216 OBJ_CLASS *OBJ_CLASS##Builder::create()
 217
 218 #define REGISTER_SERIALIZEABLE(CLASS_NAME, OBJ_CLASS)           \
 219 class OBJ_CLASS##Builder : public SerializeableBuilder          \
 220 {                                                               \
 221   public:                                                       \
 222                                                                 \
 223     OBJ_CLASS##Builder() {}                                     \
 224     virtual ~OBJ_CLASS##Builder() {}                            \
 225                                                                 \
 226     OBJ_CLASS *create();                                        \
 227 };                                                              \
 228                                                                 \
 229                                                                 \
 230 SerializeableBuilder *                                          \
 231 new##OBJ_CLASS##Builder()                                       \
 232 {                                                               \
 233     return new OBJ_CLASS##Builder();                            \
 234 }                                                               \
 235                                                                 \
 236 SerializeableClass the##OBJ_CLASS##Class(CLASS_NAME,            \
 237                                      new##OBJ_CLASS##Builder);
 238
 239
 240
 241 #endif // __SERIALIZE_HH__