blob: 9c250917e64c5471c925bc5882688af7531f6573 [file] [log] [blame]
/*
* 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.
*/
#include "sim/cxx_manager.hh"
#include <cstdlib>
#include <sstream>
#include "base/str.hh"
#include "base/trace.hh"
#include "debug/CxxConfig.hh"
#include "sim/serialize.hh"
#include "sim/sim_object.hh"
namespace gem5
{
CxxConfigManager::CxxConfigManager(CxxConfigFileBase &configFile_) :
configFile(configFile_), flags(configFile_.getFlags()),
simObjectResolver(*this)
{
}
const CxxConfigDirectoryEntry &
CxxConfigManager::findObjectType(const std::string &object_name,
std::string &object_type)
{
if (!configFile.objectExists(object_name))
throw Exception(object_name, "Can't find sim object");
if (!configFile.getParam(object_name, "type", object_type))
throw Exception(object_name, "Sim object has no 'type' field");
if (cxx_config_directory.find(object_type) ==
cxx_config_directory.end())
{
throw Exception(object_name, csprintf(
"No sim object type %s is available", object_type));
}
const CxxConfigDirectoryEntry *entry = cxx_config_directory[object_type];
return *entry;
}
std::string
CxxConfigManager::rename(const std::string &from_name)
{
for (auto i = renamings.begin(); i != renamings.end(); ++ i) {
const Renaming &renaming = *i;
if (from_name.find(renaming.fromPrefix) == 0) {
return renaming.toPrefix +
from_name.substr(renaming.fromPrefix.length());
}
}
return from_name;
}
std::string
CxxConfigManager::unRename(const std::string &to_name)
{
for (auto i = renamings.begin(); i != renamings.end(); ++ i) {
const Renaming &renaming = *i;
if (to_name.find(renaming.toPrefix) == 0) {
return renaming.fromPrefix +
to_name.substr(renaming.toPrefix.length());
}
}
return to_name;
}
static
std::string formatParamList(const std::vector<std::string> &param_values)
{
std::ostringstream params;
auto i = param_values.begin();
auto end_i = param_values.end();
params << '[';
while (i != end_i) {
params << (*i);
++i;
if (i != end_i)
params << ", ";
}
params << ']';
return params.str();
}
SimObject *
CxxConfigManager::findObject(const std::string &object_name,
bool visit_children)
{
std::string instance_name = rename(object_name);
if (object_name == "Null")
return NULL;
/* Already constructed */
if (objectsByName.find(instance_name) != objectsByName.end())
return objectsByName[instance_name];
if (inVisit.find(instance_name) != inVisit.end())
throw Exception(instance_name, "Cycle in configuration");
std::string object_type;
const CxxConfigDirectoryEntry &entry =
findObjectType(object_name, object_type);
SimObject *object = NULL;
CxxConfigParams *object_params = findObjectParams(object_name);
try {
DPRINTF(CxxConfig, "Configuring sim object references for: %s"
" (%s from object %s)\n", instance_name, object_type,
object_name);
/* Remember the path back to the top of the recursion to detect
* cycles */
inVisit.insert(instance_name);
/* Resolve pointed-to SimObjects by recursing into them */
for (auto i = entry.parameters.begin();
i != entry.parameters.end(); ++i)
{
const CxxConfigDirectoryEntry::ParamDesc *param = (*i).second;
if (param->isSimObject) {
if (param->isVector) {
std::vector<std::string> sub_object_names;
if (!configFile.getParamVector(object_name, param->name,
sub_object_names))
{
throw Exception(object_name, csprintf(
"Element not found: %s", param->name));
}
std::vector<SimObject *> sub_objects;
for (auto n = sub_object_names.begin();
n != sub_object_names.end(); ++n)
{
SimObject *sub_object = findObject(*n,
visit_children);
if (sub_object)
sub_objects.push_back(sub_object);
}
if (!object_params->setSimObjectVector(param->name,
sub_objects))
{
throw Exception(object_name, csprintf(
"Can't assign sim object element %s from \"%s\"",
param->name, formatParamList(sub_object_names)));
}
DPRINTF(CxxConfig, "Setting sim object(s): %s.%s=%s\n",
object_name, param->name,
formatParamList(sub_object_names));
} else {
std::string sub_object_name;
if (!configFile.getParam(object_name, param->name,
sub_object_name))
{
throw Exception(object_name, csprintf(
"Element not found: %s", param->name));
}
SimObject *sub_object = findObject(sub_object_name,
visit_children);
if (sub_object) {
if (!object_params->setSimObject(param->name,
sub_object))
{
throw Exception(object_name, csprintf(
"Can't assign sim object element %s from"
" \"%s\"", param->name, sub_object_name));
}
}
DPRINTF(CxxConfig, "Setting sim object(s):"
" %s.%s=%s\n", object_name, param->name,
sub_object_name);
}
}
}
DPRINTF(CxxConfig, "Creating SimObject: %s\n", instance_name);
object = object_params->simObjectCreate();
if (!object) {
throw Exception(object_name, csprintf("Couldn't create object of"
" type: %s", object_type));
}
objectsByName[instance_name] = object;
objectParamsByName[instance_name] = object_params;
if (visit_children) {
std::vector<std::string> children;
configFile.getObjectChildren(object_name, children, true);
/* Visit all your children */
for (auto i = children.begin(); i != children.end(); ++i)
findObject(*i, visit_children);
}
} catch (Exception &) {
delete object_params;
throw;
}
/* Mark that we've exited object
* construction and so 'find'ing this object again won't be a
* configuration loop */
inVisit.erase(object_name);
return object;
}
CxxConfigParams *
CxxConfigManager::findObjectParams(const std::string &object_name)
{
std::string instance_name = rename(object_name);
/* Already constructed */
if (objectParamsByName.find(instance_name) != objectParamsByName.end())
return objectParamsByName[instance_name];
std::string object_type;
const CxxConfigDirectoryEntry &entry =
findObjectType(object_name, object_type);
DPRINTF(CxxConfig, "Configuring parameters of object: %s (%s)\n",
instance_name, object_type);
CxxConfigParams *object_params = entry.makeParamsObject();
try {
/* Fill in the implicit parameters that don't necessarily
* appear in config files */
object_params->setName(instance_name);
/* Fill in parameters */
for (auto i = entry.parameters.begin();
i != entry.parameters.end(); ++i)
{
const CxxConfigDirectoryEntry::ParamDesc *param = (*i).second;
if (!param->isSimObject) {
/* Only handle non-SimObject parameters here (see below) */
if (param->isVector) {
std::vector<std::string> param_values;
if (!configFile.getParamVector(object_name, param->name,
param_values))
{
throw Exception(object_name, csprintf(
"Element not found for parameter: %s",
param->name));
}
if (!object_params->setParamVector(param->name,
param_values, flags))
{
throw Exception(instance_name, csprintf(
"Bad parameter value: .%s=X=\"%s\"",
param->name, formatParamList(param_values)));
}
DPRINTF(CxxConfig, "Setting parameter"
" %s.%s=%s\n", instance_name, param->name,
formatParamList(param_values));
} else {
std::string param_value;
if (!configFile.getParam(object_name, param->name,
param_value))
{
throw Exception(object_name, csprintf(
"Element not found for parameter: %s",
param->name));
}
if (!object_params->setParam(param->name, param_value,
flags))
{
throw Exception(instance_name, csprintf(
"Bad parameter value: .%s=X=\"%s\"",
param->name, param_value));
}
DPRINTF(CxxConfig, "Setting parameter %s.%s=%s\n",
instance_name, param->name, param_value);
}
}
}
/* Find the number of ports that will need binding and set the
* appropriate port_..._connection_count parameters */
for (auto i = entry.ports.begin(); i != entry.ports.end(); ++i) {
const CxxConfigDirectoryEntry::PortDesc *port = (*i).second;
std::vector<std::string> peers;
if (!configFile.getPortPeers(object_name, port->name, peers)) {
DPRINTF(CxxConfig, "Port not found: %s.%s,"
" assuming there are no connections\n",
instance_name, port->name);
}
unsigned int peer_count = peers.size();
/* It would be more efficient to split the peer list and
* save the values for peer binding later but that would
* require another annoying intermediate structure to
* hold for little performance increase */
if (!object_params->setPortConnectionCount(port->name,
peer_count))
{
throw Exception(instance_name, csprintf(
"Unconnected port: %s", port->name));
}
DPRINTF(CxxConfig, "Setting port connection count"
" for: %s.%s to %d\n",
instance_name, port->name, peer_count);
}
/* Set pointed-to SimObjects to NULL */
for (auto i = entry.parameters.begin();
i != entry.parameters.end(); ++i)
{
const CxxConfigDirectoryEntry::ParamDesc *param = (*i).second;
if (param->isSimObject) {
bool ret;
DPRINTF(CxxConfig, "Nulling sim object reference: %s.%s\n",
instance_name, param->name);
if (param->isVector) {
/* Clear the reference list. */
std::vector<SimObject *> empty;
ret = object_params->setSimObjectVector(param->name,
empty);
} else {
ret = object_params->setSimObject(param->name, NULL);
}
if (!ret) {
throw Exception(instance_name, csprintf(
"Error nulling sim object reference(s): %s",
param->name));
}
}
}
} catch (Exception &) {
delete object_params;
throw;
}
objectParamsByName[instance_name] = object_params;
return object_params;
}
void
CxxConfigManager::findAllObjects()
{
std::vector<std::string> objects;
configFile.getAllObjectNames(objects);
/* Set the traversal order for further iterators */
objectsInOrder.clear();
findTraversalOrder("root");
}
void
CxxConfigManager::findTraversalOrder(const std::string &object_name)
{
SimObject *object = findObject(object_name);
if (object) {
objectsInOrder.push_back(object);
std::vector<std::string> children;
configFile.getObjectChildren(object_name, children, true);
/* Visit all your children */
for (auto i = children.begin(); i != children.end(); ++i)
findTraversalOrder(*i);
}
}
void
CxxConfigManager::bindAllPorts()
{
for (auto i = objectsInOrder.begin(); i != objectsInOrder.end(); ++i)
bindObjectPorts(*i);
}
void
CxxConfigManager::bindPort(
SimObject *requestor_object, const std::string &request_port_name,
PortID request_port_index,
SimObject *responder_object, const std::string &response_port_name,
PortID response_port_index)
{
/* FIXME, check response_port_index against connection_count
* defined for port, need getPortConnectionCount and a
* getCxxConfigDirectoryEntry for each object. */
/* It would be nice to be able to catch the errors from these calls. */
Port &request_port = requestor_object->getPort(
request_port_name, request_port_index);
Port &response_port = responder_object->getPort(
response_port_name, response_port_index);
if (request_port.isConnected()) {
throw Exception(requestor_object->name(), csprintf(
"Request port: %s[%d] is already connected\n", request_port_name,
request_port_index));
}
if (response_port.isConnected()) {
throw Exception(responder_object->name(), csprintf(
"Response port: %s[%d] is already connected\n", response_port_name,
response_port_index));
}
DPRINTF(CxxConfig, "Binding port %s.%s[%d]"
" to %s:%s[%d]\n",
requestor_object->name(), request_port_name, request_port_index,
responder_object->name(), response_port_name, response_port_index);
request_port.bind(response_port);
}
void
CxxConfigManager::bindRequestPort(SimObject *object,
const CxxConfigDirectoryEntry::PortDesc &port,
const std::vector<std::string> &peers)
{
unsigned int request_port_index = 0;
for (auto peer_i = peers.begin(); peer_i != peers.end();
++peer_i)
{
const std::string &peer = *peer_i;
std::string response_object_name;
std::string response_port_name;
unsigned int response_port_index;
parsePort(peer, response_object_name, response_port_name,
response_port_index);
std::string response_instance_name = rename(response_object_name);
if (objectsByName.find(response_instance_name)
== objectsByName.end()) {
throw Exception(object->name(), csprintf(
"Can't find response port object: %s",
response_instance_name));
}
SimObject *responder_object = objectsByName[response_instance_name];
bindPort(object, port.name, request_port_index,
responder_object, response_port_name, response_port_index);
request_port_index++;
}
}
void
CxxConfigManager::bindObjectPorts(SimObject *object)
{
/* We may want to separate object->name() from the name in configuration
* later to allow (for example) repetition of fragments of configs */
const std::string &instance_name = object->name();
std::string object_name = unRename(instance_name);
std::string object_type;
const CxxConfigDirectoryEntry &entry =
findObjectType(object_name, object_type);
DPRINTF(CxxConfig, "Binding ports of object: %s (%s)\n",
instance_name, object_type);
for (auto i = entry.ports.begin(); i != entry.ports.end(); ++i) {
const CxxConfigDirectoryEntry::PortDesc *port = (*i).second;
DPRINTF(CxxConfig, "Binding port: %s.%s\n", instance_name,
port->name);
std::vector<std::string> peers;
configFile.getPortPeers(object_name, port->name, peers);
/* Only handle master ports as binding only needs to happen once
* for each observed pair of ports */
if (port->isRequestor) {
if (!port->isVector && peers.size() > 1) {
throw Exception(instance_name, csprintf(
"Too many connections to non-vector port %s (%d)\n",
port->name, peers.size()));
}
bindRequestPort(object, *port, peers);
}
}
}
void
CxxConfigManager::parsePort(const std::string &inp,
std::string &path, std::string &port, unsigned int &index)
{
std::size_t dot_i = inp.rfind('.');
std::size_t open_square_i = inp.rfind('[');
if (dot_i == std::string::npos) {
DPRINTF(CxxConfig, "Bad port string: %s\n", inp);
path = "";
port = "";
index = 0;
} else {
path = std::string(inp, 0, dot_i);
if (open_square_i == std::string::npos) {
/* Singleton port */
port = std::string(inp, dot_i + 1, inp.length() - dot_i);
index = 0;
} else {
/* Vectored port elemnt */
port = std::string(inp, dot_i + 1, (open_square_i - 1) - dot_i);
index = std::atoi(inp.c_str() + open_square_i + 1);
}
}
}
void
CxxConfigManager::forEachObject(void (SimObject::*mem_func)())
{
for (auto i = objectsInOrder.begin(); i != objectsInOrder.end(); ++i)
((*i)->*mem_func)();
}
void
CxxConfigManager::instantiate(bool build_all)
{
if (build_all) {
findAllObjects();
bindAllPorts();
}
DPRINTF(CxxConfig, "Initialising all objects\n");
forEachObject(&SimObject::init);
DPRINTF(CxxConfig, "Registering stats\n");
forEachObject(&SimObject::regStats);
DPRINTF(CxxConfig, "Registering probe points\n");
forEachObject(&SimObject::regProbePoints);
DPRINTF(CxxConfig, "Connecting probe listeners\n");
forEachObject(&SimObject::regProbeListeners);
}
void
CxxConfigManager::initState()
{
DPRINTF(CxxConfig, "Calling initState on all objects\n");
forEachObject(&SimObject::initState);
}
void
CxxConfigManager::startup()
{
DPRINTF(CxxConfig, "Starting up all objects\n");
forEachObject(&SimObject::startup);
}
unsigned int
CxxConfigManager::drain()
{
return DrainManager::instance().tryDrain() ? 0 : 1;
}
void
CxxConfigManager::drainResume()
{
DrainManager::instance().resume();
}
void
CxxConfigManager::serialize(std::ostream &os)
{
for (auto i = objectsInOrder.begin(); i != objectsInOrder.end(); ++ i) {
// (*i)->nameOut(os); FIXME, change access spec. for nameOut
os << '[' << (*i)->name() << "]\n";
(*i)->serialize(os);
}
}
void
CxxConfigManager::loadState(CheckpointIn &checkpoint)
{
for (auto i = objectsInOrder.begin(); i != objectsInOrder.end(); ++ i)
(*i)->loadState(checkpoint);
}
void
CxxConfigManager::deleteObjects()
{
for (auto i = objectsInOrder.rbegin(); i != objectsInOrder.rend(); ++i) {
DPRINTF(CxxConfig, "Freeing sim object: %s\n", (*i)->name());
delete *i;
}
for (auto i = objectParamsByName.rbegin();
i != objectParamsByName.rend(); ++i)
{
CxxConfigParams *params = (*i).second;
DPRINTF(CxxConfig, "Freeing sim object params: %s\n",
params->getName());
delete params;
}
objectsInOrder.clear();
objectsByName.clear();
}
void
CxxConfigManager::setParam(const std::string &object_name,
const std::string &param_name, const std::string &param_value)
{
CxxConfigParams *params = findObjectParams(object_name);
if (!params->setParam(param_name, param_value, flags)) {
throw Exception(object_name, csprintf("Bad parameter value:"
" .%s=X=\"%s\"", param_name, param_value));
} else {
std::string instance_name = rename(object_name);
DPRINTF(CxxConfig, "Setting parameter %s.%s=%s\n",
instance_name, param_name, param_value);
}
}
void
CxxConfigManager::setParamVector(const std::string &object_name,
const std::string &param_name,
const std::vector<std::string> &param_values)
{
CxxConfigParams *params = findObjectParams(object_name);
if (!params->setParamVector(param_name, param_values, flags)) {
throw Exception(object_name, csprintf("Bad vector parameter value:"
" .%s=X=\"%s\"", param_name, formatParamList(param_values)));
} else {
std::string instance_name = rename(object_name);
DPRINTF(CxxConfig, "Setting parameter %s.%s=\"%s\"\n",
instance_name, param_name, formatParamList(param_values));
}
}
void CxxConfigManager::addRenaming(const Renaming &renaming)
{
renamings.push_back(renaming);
}
} // namespace gem5