gem5/util/systemc/sc_gem5_control.hh
Andrew Bardsley 05bba75cdc config: SystemC Gem5Control top level additions
This patch cleans up a few style issues and adds a few capabilities to the
SystemC top level 'Gem5Control/Gem5System' mechanism.  These include:

    1) A space to store/retrieve a version string for a model
    2) A mechanism for registering functions to be called at the end of
        elaboration to perform simulation setup tasks in SystemC
    3) Adding setGDBRemotePort to the Gem5Control
    4) Changing the sc_set_time_resolution behaviour to instead check that
        the SystemC time resolution is already acceptable
2014-12-02 06:08:06 -05:00

168 lines
6.2 KiB
C++

/*
* 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.
*
* Authors: Andrew Bardsley
*/
/**
* @file
*
* Top level definitions for exporting gem5 across a dlopen interface.
*
* Gem5Control should be instantiated once to build the gem5 root.
* Systems from that root's config file can then be instantiated as
* Gem5System's using Gem5Control::makeSystem.
*
* Gem5Control contains a Gem5TopLevelModule which is a SystemC
* module providing the gem5 `simulate' function as its sole
* thread action.
*/
#ifndef __SIM_SC_GEM5_CONTROL_HH__
#define __SIM_SC_GEM5_CONTROL_HH__
#include <string>
#include <vector>
class CxxConfigManager;
namespace Gem5SystemC
{
class Gem5TopLevelModule;
class Gem5Control;
/** Gem5System's wrap CxxConfigManager's instantiating a gem5 System
* object (and its children). New Gem5Systems are created by
* Gem5Control::makeSystem. A new system can have its parameters
* tweaked using setParam{,Vector} before being instantiated using
* Gem5System::instantiate. After instantiation, any external ports
* declared by the system should be visible in SystemC.
*
* It is recommended that a SystemC wrapper sc_module is declared to
* own each Gem5System with the call to Gem5System::instantiate being
* made in that wrapper's constructor
*
* Note that *every* `normal' member function in this class *must*
* be virtual to ensure that references to the functions go through
* the pointer acquired using makeSystem and not looked up as
* name-mangled symbols
*
* */
class Gem5System
{
private:
/** Config management for *just* this system's objects (notably
* excluding root */
CxxConfigManager *manager;
/** The config file prototype for the system */
std::string systemName;
/** The instantiated (in gem5) name of the system */
std::string instanceName;
public:
/** A constructor only used by Gem5Control */
Gem5System(CxxConfigManager *manager_,
const std::string &system_name, const std::string &instance_name);
virtual ~Gem5System();
/** Parameter setting functions callable before instantiate */
virtual void setParam(const std::string &object,
const std::string &param_name, const std::string &param_value);
virtual void setParamVector(const std::string &system_name,
const std::string &param_name,
const std::vector<std::string> &param_values);
/** Build the system's gem5 infrastructure, bind its ports (note
* that all ports *must* be internal to the system), init and
* SimObject::startup the system */
virtual void instantiate();
};
/** Singleton class containing gem5 simulation control.
*
* Note that *every* `normal' member function in this class *must*
* be virtual to ensure that references to the functions go through
* the pointer acquired using makeGem5Control and not looked up as
* name-mangled symbols
*/
class Gem5Control
{
private:
/** Private SystemC module containing top level simulation control */
Gem5TopLevelModule *module;
/** One-time-settable version string */
std::string version;
public:
Gem5Control(const std::string &config_filename);
virtual ~Gem5Control();
/** Set/clear a gem5 debug flag */
virtual void setDebugFlag(const char *flag);
virtual void clearDebugFlag(const char *flag);
/** Choose a base port number for GDB to connect to the model
* (0 disables connections) */
virtual void setRemoteGDBPort(unsigned int port);
/* Register an action to happen at the end of elaboration */
virtual void registerEndOfElaboration(void (*func)());
/** Make a System from the config file description for system
* system_name and call it instance_name in gem5 */
virtual Gem5System *makeSystem(const std::string &system_name,
const std::string &top_instance);
/** set/get version string */
virtual const std::string &getVersion() const;
virtual void setVersion(const std::string &new_version);
};
}
/** Instantiate a Gem5Control. This can be called using dlopen/dlsym
* to kick-start gem5 */
extern "C" Gem5SystemC::Gem5Control *makeGem5Control(
const std::string &config_filename);
#endif // __SIM_SC_GEM5_CONTROL_HH__