cxx_manager.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2014 ARM Limited
 * All rights reserved
 *
 * The license below extends only to copyright in the software and shall
 * not be construed as granting a license to any other intellectual
 * property including but not limited to intellectual property relating
 * to a hardware implementation of the functionality of the software
 * licensed hereunder.  You may use the software subject to the license
 * terms below provided that you ensure that this notice is replicated
 * unmodified and in its entirety in all distributions of the software,
 * modified or unmodified, in source code or in binary form.
 *
 * 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.
 */
 
#ifndef __SIM_CXX_MANAGER_HH__
#define __SIM_CXX_MANAGER_HH__
 
#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>
 
#include "base/cprintf.hh"
#include "sim/cxx_config.hh"
 
namespace gem5
{
 
class CheckpointIn;
 
class CxxConfigManager
{
  protected:
    CxxConfigFileBase &configFile;
 
    CxxConfigParams::Flags flags;
 
  public:
    class Exception : public std::exception
    {
      public:
        std::string name;
        std::string message;
 
      public:
        Exception(const std::string &name_, const std::string &message_) :
            name(name_), message(message_)
        { }
 
        const char *what() const throw() { return message.c_str(); }
 
        ~Exception() throw() { }
    };
 
    struct Renaming
    {
        std::string fromPrefix;
        std::string toPrefix;
 
        Renaming(const std::string &from_prefix,
            const std::string &to_prefix) :
            fromPrefix(from_prefix),
            toPrefix(to_prefix)
        { }
    };
 
  public:
    std::map<std::string, SimObject *> objectsByName;
 
    std::map<std::string, CxxConfigParams *> objectParamsByName;
 
    std::list<SimObject *> objectsInOrder;
 
  protected:
    std::set<std::string> inVisit;
 
    std::list<Renaming> renamings;
 
    void bindPort(SimObject *requestorObject, const std::string &requestPort,
        PortID requestPortIndex, SimObject *responderObject,
        const std::string &responsePort, PortID responsePortIndex);
 
    void bindRequestPort(SimObject *object,
        const CxxConfigDirectoryEntry::PortDesc &port,
        const std::vector<std::string> &peers);
 
    std::string rename(const std::string &from_name);
 
    std::string unRename(const std::string &to_name);
 
  protected:
    void bindAllPorts();
 
    class SimObjectResolver : public gem5::SimObjectResolver
    {
      protected:
        CxxConfigManager &configManager;
 
      public:
        SimObjectResolver(CxxConfigManager &configManager_) :
            configManager(configManager_)
        { }
 
        SimObject *resolveSimObject(const std::string &name)
        { return &(configManager.getObject<SimObject>(name)); }
    };
 
    SimObjectResolver simObjectResolver;
 
  public:
    CxxConfigManager(CxxConfigFileBase &configFile_);
 
    const CxxConfigDirectoryEntry &findObjectType(
        const std::string &object_name, std::string &object_type);
 
    void addRenaming(const Renaming &renaming);
 
  public:
    void bindObjectPorts(SimObject *object);
 
    SimObject *findObject(const std::string &object_name,
        bool visit_children = false);
 
    CxxConfigParams *findObjectParams(const std::string &object_name);
 
    void findTraversalOrder(const std::string &object_name);
 
    template<typename SimObjectType>
    SimObjectType &
    getObject(const std::string &object_name)
    {
        if (objectsByName.find(object_name) == objectsByName.end()) {
            throw Exception("", csprintf("No sim object named: %s",
                object_name));
        }
 
        SimObjectType *object = dynamic_cast<SimObjectType *>(
            objectsByName[object_name]);
 
        if (!object) {
            throw Exception("", csprintf("Sim object: %s  has the wrong"
                " type", object_name));
        }
 
        return *object;
    }
 
    void forEachObject(void (SimObject::*mem_func)());
 
    void findAllObjects();
 
    static void parsePort(const std::string &inp,
        std::string &path, std::string &port, unsigned int &index);
 
    void instantiate(bool build_all = true);
 
    void initState();
 
    void startup();
 
    unsigned int drain();
 
    void drainResume();
 
    void serialize(std::ostream &os);
 
    void loadState(CheckpointIn &checkpoint);
 
    void deleteObjects();
 
    SimObjectResolver &getSimObjectResolver() { return simObjectResolver; }
 
    void setParam(const std::string &object_name,
        const std::string &param_name, const std::string &param_value);
    void setParamVector(const std::string &object_name,
        const std::string &param_name,
        const std::vector<std::string> &param_values);
};
 
} // namespace gem5
 
#endif // __SIM_CXX_MANAGER_HH__