609 lines
20 KiB
Python
609 lines
20 KiB
Python
# Copyright (c) 2014,2019 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.
|
|
#
|
|
# Author: Andrew Bardsley
|
|
|
|
# This script allows .ini and .json system config file generated from a
|
|
# previous gem5 run to be read in and instantiated.
|
|
#
|
|
# This may be useful as a way of allowing variant run scripts (say,
|
|
# with more complicated than usual checkpointing/stats dumping/
|
|
# simulation control) to read pre-described systems from config scripts
|
|
# with better system-description capabilities. Splitting scripts
|
|
# between system construction and run control may allow better
|
|
# debugging.
|
|
|
|
import argparse
|
|
import configparser
|
|
import inspect
|
|
import json
|
|
import re
|
|
import sys
|
|
|
|
import m5
|
|
import m5.ticks as ticks
|
|
|
|
sim_object_classes_by_name = {
|
|
cls.__name__: cls
|
|
for cls in list(m5.objects.__dict__.values())
|
|
if inspect.isclass(cls) and issubclass(cls, m5.objects.SimObject)
|
|
}
|
|
|
|
# Add some parsing functions to Param classes to handle reading in .ini
|
|
# file elements. This could be moved into src/python/m5/params.py if
|
|
# reading .ini files from Python proves to be useful
|
|
|
|
|
|
def no_parser(cls, flags, param):
|
|
raise Exception(
|
|
f"Can't parse string: {str(param)} for parameter class: {cls.__name__}"
|
|
)
|
|
|
|
|
|
def simple_parser(suffix="", cast=lambda i: i):
|
|
def body(cls, flags, param):
|
|
return cls(cast(param + suffix))
|
|
|
|
return body
|
|
|
|
|
|
# def tick_parser(cast=m5.objects.Latency): # lambda i: i):
|
|
def tick_parser(cast=lambda i: i):
|
|
def body(cls, flags, param):
|
|
old_param = param
|
|
ret = cls(cast(str(param) + "t"))
|
|
return ret
|
|
|
|
return body
|
|
|
|
|
|
def addr_range_parser(cls, flags, param):
|
|
sys.stdout.flush()
|
|
_param = param.split(":")
|
|
(start, end) = _param[0:2]
|
|
if len(_param) == 2:
|
|
return m5.objects.AddrRange(start=int(start), end=int(end))
|
|
else:
|
|
assert len(_param) > 2
|
|
intlv_match = _param[2]
|
|
masks = [int(m) for m in _param[3:]]
|
|
return m5.objects.AddrRange(
|
|
start=int(start),
|
|
end=int(end),
|
|
masks=masks,
|
|
intlvMatch=int(intlv_match),
|
|
)
|
|
|
|
|
|
def memory_bandwidth_parser(cls, flags, param):
|
|
# The string will be in tick/byte
|
|
# Convert to byte/tick
|
|
value = 1.0 / float(param)
|
|
# Convert to byte/s
|
|
value = ticks.fromSeconds(value)
|
|
return cls(f"{value:f}B/s")
|
|
|
|
|
|
# These parameters have trickier parsing from .ini files than might be
|
|
# expected
|
|
param_parsers = {
|
|
"Bool": simple_parser(),
|
|
"ParamValue": no_parser,
|
|
"NumericParamValue": simple_parser(cast=int),
|
|
"TickParamValue": tick_parser(),
|
|
"Frequency": tick_parser(cast=m5.objects.Latency),
|
|
"Current": simple_parser(suffix="A"),
|
|
"Voltage": simple_parser(suffix="V"),
|
|
"Enum": simple_parser(),
|
|
"MemorySize": simple_parser(suffix="B"),
|
|
"MemorySize32": simple_parser(suffix="B"),
|
|
"AddrRange": addr_range_parser,
|
|
"String": simple_parser(),
|
|
"MemoryBandwidth": memory_bandwidth_parser,
|
|
"Time": simple_parser(),
|
|
"EthernetAddr": simple_parser(),
|
|
}
|
|
|
|
for name, parser in list(param_parsers.items()):
|
|
setattr(m5.params.__dict__[name], "parse_ini", classmethod(parser))
|
|
|
|
|
|
class PortConnection:
|
|
"""This class is similar to m5.params.PortRef but with just enough
|
|
information for ConfigManager"""
|
|
|
|
def __init__(self, object_name, port_name, index):
|
|
self.object_name = object_name
|
|
self.port_name = port_name
|
|
self.index = index
|
|
|
|
@classmethod
|
|
def from_string(cls, str):
|
|
m = re.match(r"(.*)\.([^.\[]+)(\[(\d+)\])?", str)
|
|
object_name, port_name, whole_index, index = m.groups()
|
|
if index is not None:
|
|
index = int(index)
|
|
else:
|
|
index = 0
|
|
|
|
return PortConnection(object_name, port_name, index)
|
|
|
|
def __str__(self):
|
|
return "%s.%s[%d]" % (self.object_name, self.port_name, self.index)
|
|
|
|
def __cmp__(self, right):
|
|
return cmp(
|
|
(self.object_name, self.port_name, self.index),
|
|
(right.object_name, right.port_name, right.index),
|
|
)
|
|
|
|
|
|
def to_list(v):
|
|
"""Convert any non list to a singleton list"""
|
|
if isinstance(v, list):
|
|
return v
|
|
else:
|
|
return [v]
|
|
|
|
|
|
class ConfigManager:
|
|
"""Manager for parsing a Root configuration from a config file"""
|
|
|
|
def __init__(self, config):
|
|
self.config = config
|
|
self.objects_by_name = {}
|
|
self.flags = config.get_flags()
|
|
|
|
def find_object(self, object_name):
|
|
"""Find and configure (with just non-SimObject parameters)
|
|
a single object"""
|
|
|
|
if object_name == "Null":
|
|
return NULL
|
|
|
|
if object_name in self.objects_by_name:
|
|
return self.objects_by_name[object_name]
|
|
|
|
object_type = self.config.get_param(object_name, "type")
|
|
|
|
if object_type not in sim_object_classes_by_name:
|
|
raise Exception(
|
|
f"No SimObject type {object_type} is available to build: {object_name}"
|
|
)
|
|
|
|
object_class = sim_object_classes_by_name[object_type]
|
|
|
|
parsed_params = {}
|
|
|
|
for param_name, param in list(object_class._params.items()):
|
|
if issubclass(param.ptype, m5.params.ParamValue):
|
|
if isinstance(param, m5.params.VectorParamDesc):
|
|
param_values = self.config.get_param_vector(
|
|
object_name, param_name
|
|
)
|
|
|
|
param_value = [
|
|
param.ptype.parse_ini(self.flags, value)
|
|
for value in param_values
|
|
]
|
|
else:
|
|
param_value = param.ptype.parse_ini(
|
|
self.flags,
|
|
self.config.get_param(object_name, param_name),
|
|
)
|
|
|
|
parsed_params[param_name] = param_value
|
|
|
|
obj = object_class(**parsed_params)
|
|
self.objects_by_name[object_name] = obj
|
|
|
|
return obj
|
|
|
|
def fill_in_simobj_parameters(self, object_name, obj):
|
|
"""Fill in all references to other SimObjects in an objects
|
|
parameters. This relies on all referenced objects having been
|
|
created"""
|
|
|
|
if object_name == "Null":
|
|
return NULL
|
|
|
|
for param_name, param in list(obj.__class__._params.items()):
|
|
if issubclass(param.ptype, m5.objects.SimObject):
|
|
if isinstance(param, m5.params.VectorParamDesc):
|
|
param_values = self.config.get_param_vector(
|
|
object_name, param_name
|
|
)
|
|
|
|
setattr(
|
|
obj,
|
|
param_name,
|
|
[
|
|
(
|
|
self.objects_by_name[name]
|
|
if name != "Null"
|
|
else m5.params.NULL
|
|
)
|
|
for name in param_values
|
|
],
|
|
)
|
|
else:
|
|
param_value = self.config.get_param(
|
|
object_name, param_name
|
|
)
|
|
|
|
if param_value != "Null":
|
|
setattr(
|
|
obj, param_name, self.objects_by_name[param_value]
|
|
)
|
|
|
|
return obj
|
|
|
|
def fill_in_children(self, object_name, obj):
|
|
"""Fill in the children of this object. This relies on all the
|
|
referenced objects having been created"""
|
|
|
|
children = self.config.get_object_children(object_name)
|
|
|
|
for child_name, child_paths in children:
|
|
param = obj.__class__._params.get(child_name, None)
|
|
if child_name == "Null":
|
|
continue
|
|
|
|
if isinstance(child_paths, list):
|
|
child_list = [
|
|
self.objects_by_name[path] for path in child_paths
|
|
]
|
|
else:
|
|
child_list = self.objects_by_name[child_paths]
|
|
|
|
obj.add_child(child_name, child_list)
|
|
|
|
for path in to_list(child_paths):
|
|
self.fill_in_children(path, self.objects_by_name[path])
|
|
|
|
return obj
|
|
|
|
def parse_port_name(self, port):
|
|
"""Parse the name of a port"""
|
|
|
|
m = re.match(r"(.*)\.([^.\[]+)(\[(\d+)\])?", port)
|
|
peer, peer_port, whole_index, index = m.groups()
|
|
if index is not None:
|
|
index = int(index)
|
|
else:
|
|
index = 0
|
|
|
|
return (peer, self.objects_by_name[peer], peer_port, index)
|
|
|
|
def gather_port_connections(self, object_name, obj):
|
|
"""Gather all the port-to-port connections from the named object.
|
|
Returns a list of (PortConnection, PortConnection) with unordered
|
|
(wrt. requestor/responder) connection information"""
|
|
|
|
if object_name == "Null":
|
|
return NULL
|
|
|
|
parsed_ports = []
|
|
for port_name, port in list(obj.__class__._ports.items()):
|
|
# Assume that unnamed ports are unconnected
|
|
peers = self.config.get_port_peers(object_name, port_name)
|
|
|
|
for index, peer in zip(list(range(0, len(peers))), peers):
|
|
parsed_ports.append(
|
|
(
|
|
PortConnection(object_name, port.name, index),
|
|
PortConnection.from_string(peer),
|
|
)
|
|
)
|
|
|
|
return parsed_ports
|
|
|
|
def bind_ports(self, connections):
|
|
"""Bind all ports from the given connection list. Note that the
|
|
connection list *must* list all connections with both
|
|
(responder,requestor) and (requestor,responder) orderings"""
|
|
|
|
# Markup a dict of how many connections are made to each port.
|
|
# This will be used to check that the next-to-be-made connection
|
|
# has a suitable port index
|
|
port_bind_indices = {}
|
|
for from_port, to_port in connections:
|
|
port_bind_indices[(from_port.object_name, from_port.port_name)] = 0
|
|
|
|
def port_has_correct_index(port):
|
|
return (
|
|
port_bind_indices[(port.object_name, port.port_name)]
|
|
== port.index
|
|
)
|
|
|
|
def increment_port_index(port):
|
|
port_bind_indices[(port.object_name, port.port_name)] += 1
|
|
|
|
# Step through the sorted connections. Exactly one of
|
|
# each (responder,requestor) and (requestor,responder) pairs will be
|
|
# bindable because the connections are sorted.
|
|
# For example: port_bind_indices
|
|
# left right left right
|
|
# a.b[0] -> d.f[1] 0 0 X
|
|
# a.b[1] -> e.g 0 0 BIND!
|
|
# e.g -> a.b[1] 1 X 0
|
|
# d.f[0] -> f.h 0 0 BIND!
|
|
# d.f[1] -> a.b[0] 1 0 BIND!
|
|
connections_to_make = []
|
|
for connection in sorted(connections):
|
|
from_port, to_port = connection
|
|
|
|
if port_has_correct_index(from_port) and port_has_correct_index(
|
|
to_port
|
|
):
|
|
connections_to_make.append((from_port, to_port))
|
|
|
|
increment_port_index(from_port)
|
|
increment_port_index(to_port)
|
|
|
|
# Exactly half of the connections (ie. all of them, one per
|
|
# direction) must now have been made
|
|
if (len(connections_to_make) * 2) != len(connections):
|
|
raise Exception("Port bindings can't be ordered")
|
|
|
|
# Actually do the binding
|
|
for from_port, to_port in connections_to_make:
|
|
from_object = self.objects_by_name[from_port.object_name]
|
|
to_object = self.objects_by_name[to_port.object_name]
|
|
|
|
setattr(
|
|
from_object,
|
|
from_port.port_name,
|
|
getattr(to_object, to_port.port_name),
|
|
)
|
|
|
|
def find_all_objects(self):
|
|
"""Find and build all SimObjects from the config file and connect
|
|
their ports together as described. Does not instantiate system"""
|
|
|
|
# Build SimObjects for all sections of the config file
|
|
# populating not-SimObject-valued parameters
|
|
for object_name in self.config.get_all_object_names():
|
|
self.find_object(object_name)
|
|
|
|
# Add children to objects in the hierarchy from root
|
|
self.fill_in_children("root", self.find_object("root"))
|
|
|
|
# Now fill in SimObject-valued parameters in the knowledge that
|
|
# this won't be interpreted as becoming the parent of objects
|
|
# which are already in the root hierarchy
|
|
for name, obj in list(self.objects_by_name.items()):
|
|
self.fill_in_simobj_parameters(name, obj)
|
|
|
|
# Gather a list of all port-to-port connections
|
|
connections = []
|
|
for name, obj in list(self.objects_by_name.items()):
|
|
connections += self.gather_port_connections(name, obj)
|
|
|
|
# Find an acceptable order to bind those port connections and
|
|
# bind them
|
|
self.bind_ports(connections)
|
|
|
|
|
|
class ConfigFile:
|
|
def get_flags(self):
|
|
return set()
|
|
|
|
def load(self, config_file):
|
|
"""Load the named config file"""
|
|
pass
|
|
|
|
def get_all_object_names(self):
|
|
"""Get a list of all the SimObject paths in the configuration"""
|
|
pass
|
|
|
|
def get_param(self, object_name, param_name):
|
|
"""Get a single param or SimObject reference from the configuration
|
|
as a string"""
|
|
pass
|
|
|
|
def get_param_vector(self, object_name, param_name):
|
|
"""Get a vector param or vector of SimObject references from the
|
|
configuration as a list of strings"""
|
|
pass
|
|
|
|
def get_object_children(self, object_name):
|
|
"""Get a list of (name, paths) for each child of this object.
|
|
paths is either a single string object path or a list of object
|
|
paths"""
|
|
pass
|
|
|
|
def get_port_peers(self, object_name, port_name):
|
|
r"""Get the list of connected port names (in the string form
|
|
object.port(\[index\])?) of the port object_name.port_name"""
|
|
pass
|
|
|
|
|
|
class ConfigIniFile(ConfigFile):
|
|
def __init__(self):
|
|
self.parser = configparser.ConfigParser()
|
|
|
|
def load(self, config_file):
|
|
self.parser.read(config_file)
|
|
|
|
def get_all_object_names(self):
|
|
return self.parser.sections()
|
|
|
|
def get_param(self, object_name, param_name):
|
|
return self.parser.get(object_name, param_name)
|
|
|
|
def get_param_vector(self, object_name, param_name):
|
|
return self.parser.get(object_name, param_name).split()
|
|
|
|
def get_object_children(self, object_name):
|
|
if self.parser.has_option(object_name, "children"):
|
|
children = self.parser.get(object_name, "children")
|
|
child_names = children.split()
|
|
else:
|
|
child_names = []
|
|
|
|
def make_path(child_name):
|
|
if object_name == "root":
|
|
return child_name
|
|
else:
|
|
return f"{object_name}.{child_name}"
|
|
|
|
return [(name, make_path(name)) for name in child_names]
|
|
|
|
def get_port_peers(self, object_name, port_name):
|
|
if self.parser.has_option(object_name, port_name):
|
|
peer_string = self.parser.get(object_name, port_name)
|
|
return peer_string.split()
|
|
else:
|
|
return []
|
|
|
|
|
|
class ConfigJsonFile(ConfigFile):
|
|
def __init__(self):
|
|
pass
|
|
|
|
def is_sim_object(self, node):
|
|
return isinstance(node, dict) and "path" in node
|
|
|
|
def find_all_objects(self, node):
|
|
if self.is_sim_object(node):
|
|
self.object_dicts[node["path"]] = node
|
|
|
|
if isinstance(node, list):
|
|
for elem in node:
|
|
self.find_all_objects(elem)
|
|
elif isinstance(node, dict):
|
|
for elem in list(node.values()):
|
|
self.find_all_objects(elem)
|
|
|
|
def load(self, config_file):
|
|
root = json.load(open(config_file))
|
|
self.object_dicts = {}
|
|
self.find_all_objects(root)
|
|
|
|
def get_all_object_names(self):
|
|
return sorted(self.object_dicts.keys())
|
|
|
|
def parse_param_string(self, node):
|
|
if node is None:
|
|
return "Null"
|
|
elif self.is_sim_object(node):
|
|
return node["path"]
|
|
else:
|
|
return str(node)
|
|
|
|
def get_param(self, object_name, param_name):
|
|
obj = self.object_dicts[object_name]
|
|
|
|
return self.parse_param_string(obj[param_name])
|
|
|
|
def get_param_vector(self, object_name, param_name):
|
|
obj = self.object_dicts[object_name]
|
|
|
|
return [self.parse_param_string(p) for p in obj[param_name]]
|
|
|
|
def get_object_children(self, object_name):
|
|
"""It is difficult to tell which elements are children in the
|
|
JSON file as there is no explicit 'children' node. Take any
|
|
element which is a full SimObject description or a list of
|
|
SimObject descriptions. This will not work with a mixed list of
|
|
references and descriptions but that's a scenario that isn't
|
|
possible (very likely?) with gem5's binding/naming rules"""
|
|
obj = self.object_dicts[object_name]
|
|
|
|
children = []
|
|
for name, node in list(obj.items()):
|
|
if self.is_sim_object(node):
|
|
children.append((name, node["path"]))
|
|
elif (
|
|
isinstance(node, list)
|
|
and node != []
|
|
and all([self.is_sim_object(e) for e in node])
|
|
):
|
|
children.append((name, [e["path"] for e in node]))
|
|
|
|
return children
|
|
|
|
def get_port_peers(self, object_name, port_name):
|
|
"""Get the 'peer' element of any node with 'peer' and 'role'
|
|
elements"""
|
|
obj = self.object_dicts[object_name]
|
|
|
|
peers = []
|
|
if (
|
|
port_name in obj
|
|
and "peer" in obj[port_name]
|
|
and "role" in obj[port_name]
|
|
):
|
|
peers = to_list(obj[port_name]["peer"])
|
|
|
|
return peers
|
|
|
|
|
|
parser = argparse.ArgumentParser()
|
|
|
|
parser.add_argument(
|
|
"config_file",
|
|
metavar="config-file.ini",
|
|
help=".ini configuration file to load and run",
|
|
)
|
|
parser.add_argument(
|
|
"--checkpoint-dir",
|
|
type=str,
|
|
default=None,
|
|
help="A checkpoint to directory to restore when starting "
|
|
"the simulation",
|
|
)
|
|
|
|
args = parser.parse_args(sys.argv[1:])
|
|
|
|
if args.config_file.endswith(".ini"):
|
|
config = ConfigIniFile()
|
|
config.load(args.config_file)
|
|
else:
|
|
config = ConfigJsonFile()
|
|
config.load(args.config_file)
|
|
|
|
ticks.fixGlobalFrequency()
|
|
|
|
mgr = ConfigManager(config)
|
|
|
|
mgr.find_all_objects()
|
|
|
|
m5.instantiate(args.checkpoint_dir)
|
|
|
|
exit_event = m5.simulate()
|
|
print("Exiting @ tick %i because %s" % (m5.curTick(), exit_event.getCause()))
|