config: Add the ability to read a config file using C++ and Python

This patch adds the ability to load in config.ini files generated from
gem5 into another instance of gem5 built without Python configuration
support. The intended use case is for configuring gem5 when it is a
library embedded in another simulation system.

A parallel config file reader is also provided purely in Python to
demonstrate the approach taken and to provided similar functionality
for as-yet-unknown use models. The Python configuration file reader
can read both .ini and .json files.

C++ configuration file reading:

A command line option has been added for scons to enable C++ configuration
file reading: --with-cxx-config

There is an example in util/cxx_config that shows C++ configuration in action.
util/cxx_config/README explains how to build the example.

Configuration is achieved by the object CxxConfigManager. It handles
reading object descriptions from a CxxConfigFileBase object which
wraps a config file reader. The wrapper class CxxIniFile is provided
which wraps an IniFile for reading .ini files. Reading .json files
from C++ would be possible with a similar wrapper and a JSON parser.

After reading object descriptions, CxxConfigManager creates
SimObjectParam-derived objects from the classes in the (generated with this
patch) directory build/ARCH/cxx_config

CxxConfigManager can then build SimObjects from those SimObjectParams (in an
order dictated by the SimObject-value parameters on other objects) and bind
ports of the produced SimObjects.

A minimal set of instantiate-replacing member functions are provided by
CxxConfigManager and few of the member functions of SimObject (such as drain)
are extended onto CxxConfigManager.

Python configuration file reading (configs/example/read_config.py):

A Python version of the reader is also supplied with a similar interface to
CxxConfigFileBase (In Python: ConfigFile) to config file readers.

The Python config file reading will handle both .ini and .json files.

The object construction strategy is slightly different in Python from the C++
reader as you need to avoid objects prematurely becoming the children of other
objects when setting parameters.

Port binding also needs to be strictly in the same port-index order as the
original instantiation.

1 files changed, 531 insertions, 0 deletions

diff --git a/configs/example/read_config.py b/configs/example/read_config.py
new file mode 100644
index 000000000..ecb2950e6
--- /dev/null
+++ b/configs/example/read_config.py
@@ -0,0 +1,531 @@
+# 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.
+#
+# 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 m5.objects.__dict__.itervalues()
+    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('Can\'t parse string: %s for parameter'
+        ' class: %s' % (str(param), 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()
+    low, high = param.split(':')
+    return m5.objects.AddrRange(long(low), long(high))
+
+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('%fB/s' % value)
+
+# These parameters have trickier parsing from .ini files than might be
+#   expected
+param_parsers = {
+    'Bool': simple_parser(),
+    'ParamValue': no_parser,
+    'NumericParamValue': simple_parser(cast=long),
+    'TickParamValue': tick_parser(),
+    'Frequency': tick_parser(cast=m5.objects.Latency),
+    '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()
+    }
+
+for name, parser in param_parsers.iteritems():
+    setattr(m5.params.__dict__[name], 'parse_ini', classmethod(parser))
+
+class PortConnection(object):
+    """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('(.*)\.([^.\[]+)(\[(\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(object):
+    """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('No SimObject type %s is available to'
+                ' build: %s' % (object_type, object_name))
+
+        object_class = sim_object_classes_by_name[object_type]
+
+        parsed_params = {}
+
+        for param_name, param in object_class._params.iteritems():
+            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 obj.__class__._params.iteritems():
+            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]
+                        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 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('(.*)\.([^.\[]+)(\[(\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. master/slave) connection information"""
+
+        if object_name == 'Null':
+            return NULL
+
+        parsed_ports = []
+        for port_name, port in obj.__class__._ports.iteritems():
+            # Assume that unnamed ports are unconnected
+            peers = self.config.get_port_peers(object_name, port_name)
+
+            for index, peer in zip(xrange(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 (slave,master)
+        and (master,slave) 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 (slave,master) and (master,slave) 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 self.objects_by_name.iteritems():
+            self.fill_in_simobj_parameters(name, obj)
+
+        # Gather a list of all port-to-port connections
+        connections = []
+        for name, obj in self.objects_by_name.iteritems():
+            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(object):
+    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):
+        """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 '%s.%s' % (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 node.itervalues():
+                self.find_all_objects(elem)
+
+    def load(self, config_file):
+        root = json.load(open(config_file, 'r'))
+        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 obj.iteritems():
+            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')
+
+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()
+
+exit_event = m5.simulate()
+print 'Exiting @ tick %i because %s' % (
+    m5.curTick(), exit_event.getCause())