Major changes to how SimObjects are created and initialized. Almost all

creation and initialization now happens in python.  Parameter objects
are generated and initialized by python.  The .ini file is now solely for
debugging purposes and is not used in construction of the objects in any
way.

--HG--
extra : convert_revision : 7e722873e417cb3d696f2e34c35ff488b7bff4ed

1 files changed, 0 insertions, 740 deletions

diff --git a/src/sim/param.hh b/src/sim/param.hh
deleted file mode 100644
index dff0fa72d..000000000
--- a/src/sim/param.hh
+++ /dev/null
@@ -1,740 +0,0 @@
-/*
- * Copyright (c) 2002-2005 The Regents of The University of Michigan
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met: redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer;
- * redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution;
- * neither the name of the copyright holders nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (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: Steve Reinhardt
- */
-
-#ifndef __SIM_PARAM_HH__
-#define __SIM_PARAM_HH__
-
-#include <iostream>
-#include <list>
-#include <string>
-#include <vector>
-
-#include "sim/startup.hh"
-
-// forward decls
-class IniFile;
-class BaseParam;
-class SimObject;
-
-//
-// The context of a parameter definition... usually a subclass of
-// SimObjectBuilder (which derives from ParamContext), but abstracted
-// here to support more global simulator control parameters as well.
-//
-class ParamContext : protected StartupCallback
-{
-  protected:
-
-    // .ini file (database) for parameter lookup... initialized on call
-    // to parseParams()
-    IniFile *iniFilePtr;
-
-    // .ini file section for parameter lookup
-    const std::string iniSection;
-
-    typedef std::vector<BaseParam *> ParamList;
-
-    // list of parameters defined in this context
-    ParamList *paramList;
-
-    ParamList *getParamList() {
-        if (!paramList)
-            paramList = new ParamList;
-        return paramList;
-    }
-
-  public:
-
-    /// Constructor.
-    /// @param _iniSection Name of .ini section corresponding to this context.
-    /// @param _initPhase Initialization phase  (see InitPhase).
-    ParamContext(const std::string &_iniSection);
-    virtual ~ParamContext() {}
-
-    // add a parameter to the context... called from the parameter
-    // object's constructor (see BaseParam::BaseParam())
-    void addParam(BaseParam *);
-
-    // call parse() on all params in this context to convert string
-    // representations to parameter values
-    virtual void parseParams(IniFile &iniFile);
-
-    // Check parameter values for validity & consistency. Default
-    // implementation is no-op; derive subclass & override to add
-    // actual functionality here
-    virtual void checkParams();
-
-    // Clean up at end of execution: close file descriptors, etc.
-    // Default implementation is no-op; derive subclass & override to
-    // add actual functionality here
-    virtual void cleanup();
-
-    // dump parameter descriptions
-    void describeParams(std::ostream &);
-
-    // Display the parameters & values used
-    void showParams(std::ostream &);
-
-    // print context information for parameter error
-    virtual void printErrorProlog(std::ostream &);
-
-    // generate the name for this instance of this context (used as a
-    // prefix to create unique names in resolveSimObject()
-    virtual const std::string &getInstanceName() { return iniSection; }
-};
-
-
-//
-// Base class for all parameter objects
-//
-class BaseParam
-{
-  public:
-
-    ParamContext *context;
-    std::string name;
-    std::string description;	// text description for help message
-    bool wasSet;	// true if parameter was set by user
-    bool hasDefault;	// true if parameter has default value
-
-    BaseParam(ParamContext *_context, const std::string &_name,
-              const std::string &_description, bool _hasDefault)
-        : context(_context), name(_name), description(_description),
-          wasSet(false), hasDefault(_hasDefault)
-    {
-        context->addParam(this);
-    }
-
-    virtual ~BaseParam() {}
-
-    // a parameter is valid only if its value was set by the user or
-    // it has a default value
-    bool isValid() const
-    {
-        return (wasSet || hasDefault);
-    }
-
-    // set value by parsing string
-    virtual void parse(const std::string &s) = 0;
-
-    // display value to stream
-    virtual void showValue(std::ostream &) const = 0;
-
-    // display type to stream
-    virtual void showType(std::ostream &) const = 0;
-
-    // signal parse or usage error
-    virtual void die(const std::string &err) const;
-};
-
-//
-// Template classes to specialize parameters to specific types.
-//
-// Param<T> is for single-valued (scalar) parameters of type T.
-// VectorParam<T> is for multi-valued (vector) parameters of type T.
-// These are specified in the .ini file as a space-delimited list of
-// arguments.
-//
-template <class T>
-class Param : public BaseParam
-{
-  protected:
-
-    T value;
-
-  public:
-
-    // Param with default value: set value to default
-    Param(ParamContext *context,
-          const std::string &name, const std::string &description, T dfltValue)
-        : BaseParam(context, name, description, true),
-          value(dfltValue)
-    {
-    }
-
-    // Param with no default value: leave value uninitialized
-    Param(ParamContext *context,
-          const std::string &name, const std::string &description)
-        : BaseParam(context, name, description, false)
-    {
-    }
-
-    virtual ~Param() {}
-
-    operator T&()
-    {
-        // if we attempt to reference an invalid parameter (i.e., one
-        // with no default value that was not set by the user), die.
-        if (!isValid())
-            die("not found");
-        return value;
-    }
-
-    T returnValue() const { return value; }
-
-    // display value to stream
-    virtual void showValue(std::ostream &os) const;
-
-    // display type to stream
-    virtual void showType(std::ostream &) const;
-
-    // set value by parsing string
-    virtual void parse(const std::string &s);
-};
-
-
-//
-// Template class for vector-valued parameters (lists)
-//
-template <class T>
-class VectorParam : public BaseParam
-{
-  protected:
-
-    std::vector<T> value;
-
-  public:
-
-    typedef typename std::vector<T>::size_type size_type;
-
-    // Param with default value: set value to default
-    VectorParam(ParamContext *context, const std::string &name,
-                const std::string &description,
-                const std::vector<T> &dfltValue)
-        : BaseParam(context, name, description, true),
-          value(dfltValue)
-    {
-    }
-
-    // Param with no default value: leave value uninitialized
-    VectorParam(ParamContext *context,
-                const std::string &name, const std::string &description)
-        : BaseParam(context, name, description, false)
-    {
-    }
-
-    virtual ~VectorParam() {}
-
-    // basic vector access methods
-    size_type size() const
-    {
-        if (!isValid())
-            die("not found");
-        return value.size();
-    }
-
-    const T &operator[](size_type n) const
-    {
-        if (!isValid())
-            die("not found");
-        return value[n];
-    }
-
-    // return reference to value vector
-    operator std::vector<T>&()
-    {
-        if (!isValid())
-            die("not found");
-        return value;
-    }
-
-    // display value to stream
-    virtual void showValue(std::ostream &os) const;
-
-    // display type to stream
-    virtual void showType(std::ostream &) const;
-
-    // set value by parsing string
-    virtual void parse(const std::string &s);
-};
-
-//
-// Specialization of Param<int> and VectorParam<int> to handle
-// enumerated types is done in two ways, using SimpleEnumParam and
-// MappedEnumParam (and their vector counterparts,
-// SimpleEnumVectorParam and MappedEnumVectorParam).  SimpleEnumParam
-// takes an array of strings and maps them to integers based on array
-// index.  MappedEnumParam takes an array of string-to-int mappings,
-// allowing for mapping strings to non-contiguous integer values, or
-// mapping multiple strings to the same integer value.
-//
-// Both SimpleEnumParam and MappedEnumParam are implemented using a
-// single template class, EnumParam<Map>, which takes the type of the map
-// as a parameter (const char * or EnumParamMap).  Similarly,
-// SimpleEnumVectorParam and MappedEnumVectorParam are both
-// implemented using EnumVectorParam<Map>.
-//
-template <class Map>
-class EnumParam : public Param<int>
-{
-    const int num_values;
-    const Map *map;
-
-  public:
-
-    // Param with default value: set value to default
-    EnumParam(ParamContext *context,
-              const std::string &name, const std::string &description,
-              const Map *_map, int _num_values,
-              int dfltValue)
-        : Param<int>(context, name, description, dfltValue),
-          num_values(_num_values), map(_map)
-    {
-    }
-
-    // Param with no default value: leave value uninitialized
-    EnumParam(ParamContext *context,
-              const std::string &name, const std::string &description,
-              const Map *_map, int _num_values)
-        : Param<int>(context, name, description),
-          num_values(_num_values), map(_map)
-    {
-    }
-
-    virtual ~EnumParam() {}
-
-    // display value to stream
-    virtual void showValue(std::ostream &os) const;
-
-    // display type to stream
-    virtual void showType(std::ostream &) const;
-
-    // set value by parsing string
-    virtual void parse(const std::string &s);
-};
-
-//
-// Vector counterpart to SimpleEnumParam
-//
-template <class Map>
-class EnumVectorParam : public VectorParam<int>
-{
-    const int num_values;
-    const Map *map;
-
-  public:
-
-    // Param with default value: set value to default
-    EnumVectorParam(ParamContext *context,
-                    const std::string &name, const std::string &description,
-                    const Map *_map, int _num_values,
-                    std::vector<int> &dfltValue)
-        : VectorParam<int>(context, name, description, dfltValue),
-          num_values(_num_values), map(_map)
-    {
-    }
-
-    // Param with no default value: leave value uninitialized
-    EnumVectorParam(ParamContext *context,
-                    const std::string &name, const std::string &description,
-                    const Map *_map, int _num_values)
-        : VectorParam<int>(context, name, description),
-          num_values(_num_values), map(_map)
-    {
-    }
-
-    virtual ~EnumVectorParam() {}
-
-    // display value to stream
-    virtual void showValue(std::ostream &os) const;
-
-    // display type to stream
-    virtual void showType(std::ostream &) const;
-
-    // set value by parsing string
-    virtual void parse(const std::string &s);
-};
-
-// Specialize EnumParam for a particular enumeration type ENUM
-// (automates casting to get value of enum type)
-
-template <class ENUM>
-class SimpleEnumParam : public EnumParam<const char *>
-{
-  public:
-
-    SimpleEnumParam(ParamContext *context,
-                    const std::string &name, const std::string &description,
-                    const char **_map, int _num_values,
-                    ENUM dfltValue)
-        : EnumParam<const char *>(context, name, description,
-                                  _map, _num_values, (int)dfltValue)
-    {
-    }
-
-    SimpleEnumParam(ParamContext *context,
-                    const std::string &name, const std::string &description,
-                    const char **_map, int _num_values)
-        : EnumParam<const char *>(context, name, description,
-                                  _map, _num_values)
-    {
-    }
-
-    operator ENUM() const
-    {
-        if (!isValid())
-            die("not found");
-        return (ENUM)value;
-    }
-};
-
-
-// Specialize EnumParam for a particular enumeration type ENUM
-// (automates casting to get value of enum type)
-
-template <class ENUM>
-class SimpleEnumVectorParam : public EnumVectorParam<const char *>
-{
-  public:
-
-    // skip default value constructor: too much pain to convert
-    // vector<ENUM> initializer to vector<int>
-
-
-    SimpleEnumVectorParam(ParamContext *context,
-                          const std::string &name,
-                          const std::string &description,
-                          const char **_map, int _num_values)
-        : EnumVectorParam<const char *>(context, name, description,
-                                        _map, _num_values)
-    {
-    }
-
-    ENUM operator[](size_type n)
-    {
-        if (!isValid())
-            die("not found");
-        return (ENUM)value[n];
-    }
-};
-
-
-//
-// Handle enums via string-to-int map (see comment above).
-//
-
-// An array of string-to-int mappings must be supplied using the
-// following type.
-typedef struct {
-    const char *name;
-    int value;
-} EnumParamMap;
-
-// Specialize EnumParam for a particular enumeration type ENUM
-// (automates casting to get value of enum type)
-
-template <class ENUM>
-class MappedEnumParam : public EnumParam<EnumParamMap>
-{
-  public:
-
-    MappedEnumParam(ParamContext *context,
-                    const std::string &name, const std::string &description,
-                    const EnumParamMap *_map, int _num_values,
-                    ENUM dfltValue)
-        : EnumParam<EnumParamMap>(context, name, description,
-                                  _map, _num_values, (int)dfltValue)
-    {
-    }
-
-    MappedEnumParam(ParamContext *context,
-                    const std::string &name, const std::string &description,
-                    const EnumParamMap *_map, int _num_values)
-        : EnumParam<EnumParamMap>(context, name, description,
-                                  _map, _num_values)
-    {
-    }
-
-    operator ENUM()
-    {
-        if (!isValid())
-            die("not found");
-        return (ENUM)value[this->n];
-    }
-};
-
-
-// Specialize EnumParam for a particular enumeration type ENUM
-// (automates casting to get value of enum type)
-
-template <class ENUM>
-class MappedEnumVectorParam : public EnumVectorParam<EnumParamMap>
-{
-  public:
-
-    // skip default value constructor: too much pain to convert
-    // vector<ENUM> initializer to vector<int>
-
-
-    MappedEnumVectorParam(ParamContext *context,
-                          const std::string &name,
-                          const std::string &description,
-                          const EnumParamMap *_map, int _num_values)
-        : EnumVectorParam<EnumParamMap>(context, name, description,
-                                        _map, _num_values)
-    {
-    }
-
-    ENUM operator[](size_type n)
-    {
-        if (!isValid())
-            die("not found");
-        return (ENUM)value[n];
-    }
-};
-
-
-//
-// Parameters that point to other simulation objects (e.g. caches,
-// busses, etc.) are handled by specializing SimObjectBaseParam to the
-// specific subtype.  The main purpose of SimObjectBaseParam is to
-// provide a place to stick several helper functions common to all
-// SimObject-derived parameters.
-//
-class SimObjectBaseParam : public BaseParam
-{
-  public:
-
-    SimObjectBaseParam(ParamContext *context, const std::string &name,
-                       const std::string &description, bool hasDefault)
-        : BaseParam(context, name, description, hasDefault)
-    {
-    }
-
-    virtual ~SimObjectBaseParam() {}
-
-    // helper function for SimObjectParam<T>::showValue()
-    void showValue(std::ostream &os, SimObject *obj) const;
-
-    // helper function for SimObjectParam<T>::parse()
-    void parse(const std::string &s, SimObject *&value);
-
-    // helper function for SimObjectParam<T>::parse()
-    void parse(const std::string &s, std::vector<SimObject *>&value_vec);
-};
-
-
-//
-// Parameter to a specific type of SimObject.  Note that T must be a
-// pointer to a class derived from SimObject (e.g., <CPU *>).
-//
-
-template <class T> class SimObjectParam;
-
-template <class T>
-class SimObjectParam<T *> : public SimObjectBaseParam
-{
-  protected:
-
-    T *value;
-
-  public:
-
-    // initialization w/o default
-    SimObjectParam(ParamContext *context,
-                   const std::string &name, const std::string &description)
-        : SimObjectBaseParam(context, name, description, false)
-    {
-    }
-
-    // initialization wit=h default
-    SimObjectParam(ParamContext *context,
-                   const std::string &name, const std::string &description,
-                   T *dfltValue)
-        : SimObjectBaseParam(context, name, description, true),
-          value(dfltValue)
-    {
-    }
-
-    virtual ~SimObjectParam() {}
-
-    // convert to pointer
-    operator T*()
-    {
-        if (!isValid())
-            die("not found");
-        return value;
-    }
-
-    T *operator->() const
-    {
-        if (!isValid())
-            die("not found");
-        return value;
-    }
-
-    // display value to stream
-    virtual void showValue(std::ostream &os) const
-    {
-        SimObjectBaseParam::showValue(os, value);
-    }
-
-    // display type to stream: see REGISTER_SIM_OBJECT macro in
-    // sim_object.hh for declaration
-    virtual void showType(std::ostream &os) const;
-
-    // set value by parsing string
-    virtual void parse(const std::string &s)
-    {
-        SimObject *so_ptr;
-        // first parse to generic SimObject *
-        SimObjectBaseParam::parse(s, so_ptr);
-        // now dynamic_cast to specific derived type
-        value = dynamic_cast<T *>(so_ptr);
-        // check for failure of dynamic_cast
-        if (value == NULL && so_ptr != NULL)
-            die("not of appropriate type");
-    }
-};
-
-
-//
-// Vector counterpart to SimObjectParam<T>
-//
-
-template <class T> class SimObjectVectorParam;
-
-template <class T>
-class SimObjectVectorParam<T *> : public SimObjectBaseParam
-{
-  protected:
-
-    std::vector<T *> value;
-
-  public:
-
-    typedef typename std::vector<T *>::size_type size_type;
-
-    SimObjectVectorParam(ParamContext *context,
-                         const std::string &name,
-                         const std::string &description)
-        : SimObjectBaseParam(context, name, description, false)
-    {
-    }
-
-    SimObjectVectorParam(ParamContext *context,
-                         const std::string &name,
-                         const std::string &description,
-                         std::vector<T *> dfltValue)
-        : SimObjectBaseParam(context, name, description, true),
-          value(dfltValue)
-    {
-    }
-
-    virtual ~SimObjectVectorParam() {}
-
-    // basic vector access methods
-    size_type size() const
-    {
-        if (!isValid())
-            die("not found");
-        return value.size();
-    }
-
-    T *&operator[](size_type n)
-    {
-        if (!isValid())
-            die("not found");
-        return value[n];
-    }
-
-    // return reference to value vector
-    operator std::vector<T *>&()
-    {
-        if (!isValid())
-            die("not found");
-        return value;
-    }
-
-    // display value to stream
-    virtual void showValue(std::ostream &os) const
-    {
-        for (int i = 0; i < value.size(); i++) {
-            if (i != 0)
-                os << " ";
-            SimObjectBaseParam::showValue(os, value[i]);
-        }
-    }
-
-    // display type to stream: see
-    virtual void showType(std::ostream &os) const;
-
-    // set value by parsing string
-    virtual void parse(const std::string &s)
-    {
-        std::vector<SimObject *> so_ptr_vec;
-        // first parse to generic SimObject * vector (from SimObjectBaseParam)
-        SimObjectBaseParam::parse(s, so_ptr_vec);
-
-        value.resize(so_ptr_vec.size());
-
-        for (int i = 0; i < so_ptr_vec.size(); ++i) {
-            // now dynamic_cast to specific derived type
-            value[i] = dynamic_cast<T *>(so_ptr_vec[i]);
-            // check for failure of dynamic_cast
-            if (value[i] == NULL && so_ptr_vec[i] != NULL)
-                die("not of appropriate type");
-        }
-    }
-};
-
-//
-// Macro to define showType() methods for SimObjectParam &
-// SimObjectVectorParam.  Can't do this automatically as it requires a
-// string name for the type, which you can't get from a template
-// argument.  For concrete derived SimObject types, this macro is
-// automatically invoked by REGISTER_SIM_OBJECT() (see sim_object.hh).
-//
-#define DEFINE_SIM_OBJECT_CLASS_NAME(CLASS_NAME, OBJ_CLASS)		\
-template<>								\
-void									\
-SimObjectParam<OBJ_CLASS *>::showType(std::ostream &os)	const		\
-{									\
-    os << CLASS_NAME;							\
-}									\
-                                                                        \
-template<>								\
-void									\
-SimObjectVectorParam<OBJ_CLASS *>::showType(std::ostream &os) const	\
-{									\
-    os << "vector of " << CLASS_NAME;					\
-}
-
-
-//
-// Declarations for low-level parsing & displaying functions.  These
-// are used internally, but should not be used directly by clients of
-// the parameter mechanism, but are declared here so they can be
-// shared with the serialization code (see sim/serialize.cc).
-template <class T> bool parseParam(const std::string &str, T &data);
-template <class T> void showParam(std::ostream &os, const T &data);
-
-void parseTime(const std::vector<int> &time, struct tm *tm);
-#endif // _SIM_PARAM_HH_