From 66df7b7fd4c471cb71e77fa78902d354a3521174 Mon Sep 17 00:00:00 2001
From: Andreas Hansson <andreas.hansson@arm.com>
Date: Thu, 16 Oct 2014 05:49:37 -0400
Subject: 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.
---
 util/cxx_config/Makefile |  65 ++++++++++
 util/cxx_config/README   |  44 +++++++
 util/cxx_config/main.cc  | 319 +++++++++++++++++++++++++++++++++++++++++++++++
 util/cxx_config/stats.cc | 115 +++++++++++++++++
 util/cxx_config/stats.hh |  61 +++++++++
 5 files changed, 604 insertions(+)
 create mode 100644 util/cxx_config/Makefile
 create mode 100644 util/cxx_config/README
 create mode 100644 util/cxx_config/main.cc
 create mode 100644 util/cxx_config/stats.cc
 create mode 100644 util/cxx_config/stats.hh

(limited to 'util/cxx_config')

diff --git a/util/cxx_config/Makefile b/util/cxx_config/Makefile
new file mode 100644
index 000000000..e8f491225
--- /dev/null
+++ b/util/cxx_config/Makefile
@@ -0,0 +1,65 @@
+# 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
+
+ARCH = ARM
+VARIANT = opt
+
+CXXFLAGS = -I../../build/$(ARCH) -L../../build/$(ARCH)
+CXXFLAGS += -std=c++0x
+LIBS = -lgem5_$(VARIANT)
+
+## You may also need protobuf flags
+# CXXFLAGS += $(shell pkg-config --cflags --libs-only-L protobuf)
+# LIBS += $(shell pkg-config --libs protobuf)
+
+ALL = gem5.$(VARIANT).cxx
+
+all: $(ALL)
+
+.cc.o:
+	$(CXX) $(CXXFLAGS) -c -o $@ $<
+
+stats.o: stats.cc stats.hh
+main.o: main.cc stats.hh
+
+gem5.$(VARIANT).cxx: main.o stats.o
+	$(CXX) $(CXXFLAGS) -o $@ $^ $(LIBS)
+
+clean:
+	$(RM) $(ALL)
+	$(RM) *.o
+	$(RM) -r m5out
diff --git a/util/cxx_config/README b/util/cxx_config/README
new file mode 100644
index 000000000..a80f7ad8f
--- /dev/null
+++ b/util/cxx_config/README
@@ -0,0 +1,44 @@
+This directory contains a demo of C++ configuration of gem5.  The intention
+is to provide a mechanism to allow pre-generated config.ini files generated
+by Python-based gem5 to be reloaded in library-base versions of gem5
+embedded in other systems using C++ calls for simulation control.
+
+This demo implements a few of the simulation control mechanisms of the Python
+gem5 on top of a C++ configured system.
+
+Read main.cc for more details of the implementation.
+
+To build:
+
+First build gem5 as a library with cxx-config support and (optionally)
+without python.  Also build a normal gem5 (cxx-config not needed, Python
+needed):
+
+> cd ../..
+> scons build/ARM/gem5.opt
+> scons --with-cxx-config --without-python build/ARM/libgem5_opt.so
+> cd util/cxx_config
+
+Then edit Makefile to set the paths for PYTHON and run make
+
+> make
+
+Make a config file for the C++-configured gem5 using normal gem5
+
+> ../../build/ARM/gem5.opt ../../configs/example/se.py -c \
+>       ../../tests/test-progs/hello/bin/arm/linux/hello
+
+The binary 'gem5.opt.cxx' can now be used to load in the generated config
+file from the previous normal gem5 run.
+
+Try:
+
+> ./gem5.opt.cxx m5out/config.ini
+
+This should print:
+
+> Hello world!
+
+The .ini file can also be read by the Python .ini file reader example:
+
+> ../../build/ARM/gem5.opt ../../configs/example/read_config.py m5out/config.ini
diff --git a/util/cxx_config/main.cc b/util/cxx_config/main.cc
new file mode 100644
index 000000000..a9a86b424
--- /dev/null
+++ b/util/cxx_config/main.cc
@@ -0,0 +1,319 @@
+/*
+ * 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
+ *
+ *  C++-only configuration and instantiation support.  This allows a
+ *  config to be read back from a .ini and instantiated without
+ *  Python.  Useful if you want to embed gem5 within a larger system
+ *  without carrying the integration cost of the fully-featured
+ *  configuration system.
+ *
+ *  This file contains a demonstration main using CxxConfigManager.
+ *  Build with something like:
+ *
+ *      scons --without-python build/ARM/libgem5_opt.so
+ *
+ *      g++ -DTRACING_ON -std=c++0x -Ibuild/ARM src/sim/cxx_main.cc \
+ *          -o gem5cxx.opt -Lbuild/ARM -lgem5_opt
+ */
+
+#include <cstdlib>
+#include <iostream>
+#include <sstream>
+
+#include "base/inifile.hh"
+#include "base/statistics.hh"
+#include "base/str.hh"
+#include "base/trace.hh"
+#include "cpu/base.hh"
+#include "sim/cxx_config_ini.hh"
+#include "sim/cxx_manager.hh"
+#include "sim/init_signals.hh"
+#include "sim/serialize.hh"
+#include "sim/simulate.hh"
+#include "sim/stat_control.hh"
+#include "sim/system.hh"
+#include "stats.hh"
+
+void
+usage(const std::string &prog_name)
+{
+    std::cerr << "Usage: " << prog_name << (
+        " <config-file.ini> [ <option> ]\n\n"
+        "OPTIONS:\n"
+        "    -p <object> <param> <value>  -- set a parameter\n"
+        "    -v <object> <param> <values> -- set a vector parameter from"
+        " a comma\n"
+        "                                    separated values string\n"
+        "    -d <flag>                    -- set a debug flag (-<flag>\n"
+        "                                    clear a flag)\n"
+        "    -s <dir> <ticks>             -- save checkpoint to dir after"
+        " the given\n"
+        "                                    number of ticks\n"
+        "    -r <dir>                     -- restore checkpoint to dir\n"
+        "    -c <from> <to> <ticks>       -- switch from cpu 'from' to cpu"
+        " 'to' after\n"
+        "                                    the given number of ticks\n"
+        "\n"
+        );
+
+    std::exit(EXIT_FAILURE);
+}
+
+int
+main(int argc, char **argv)
+{
+    std::string prog_name(argv[0]);
+    unsigned int arg_ptr = 1;
+
+    if (argc == 1)
+        usage(prog_name);
+
+    cxxConfigInit();
+
+    initSignals();
+
+    setClockFrequency(1000000000000);
+    curEventQueue(getEventQueue(0));
+
+    Stats::initSimStats();
+    Stats::registerHandlers(CxxConfig::statsReset, CxxConfig::statsDump);
+
+    Trace::enabled = true;
+    setDebugFlag("Terminal");
+    // setDebugFlag("CxxConfig");
+
+    const std::string config_file(argv[arg_ptr]);
+
+    CxxConfigFileBase *conf = new CxxIniFile();
+
+    if (!conf->load(config_file.c_str())) {
+        std::cerr << "Can't open config file: " << config_file << '\n';
+        return EXIT_FAILURE;
+    }
+    arg_ptr++;
+
+    CxxConfigManager *config_manager = new CxxConfigManager(*conf);
+
+    bool checkpoint_restore = false;
+    bool checkpoint_save = false;
+    bool switch_cpus = false;
+    std::string checkpoint_dir = "";
+    std::string from_cpu = "";
+    std::string to_cpu = "";
+    Tick pre_run_time = 1000000;
+    Tick pre_switch_time = 1000000;
+
+    try {
+        while (arg_ptr < argc) {
+            std::string option(argv[arg_ptr]);
+            arg_ptr++;
+            unsigned num_args = argc - arg_ptr;
+
+            if (option == "-p") {
+                if (num_args < 3)
+                    usage(prog_name);
+                config_manager->setParam(argv[arg_ptr], argv[arg_ptr + 1],
+                    argv[arg_ptr + 2]);
+                arg_ptr += 3;
+            } else if (option == "-v") {
+                std::vector<std::string> values;
+
+                if (num_args < 3)
+                    usage(prog_name);
+                tokenize(values, argv[arg_ptr + 2], ',');
+                config_manager->setParamVector(argv[arg_ptr],
+                    argv[arg_ptr + 1], values);
+                arg_ptr += 3;
+            } else if (option == "-d") {
+                if (num_args < 1)
+                    usage(prog_name);
+                if (argv[arg_ptr][0] == '-')
+                    clearDebugFlag(argv[arg_ptr] + 1);
+                else
+                    setDebugFlag(argv[arg_ptr]);
+                arg_ptr++;
+            } else if (option == "-r") {
+                if (num_args < 1)
+                    usage(prog_name);
+                checkpoint_dir = argv[arg_ptr];
+                checkpoint_restore = true;
+                arg_ptr++;
+            } else if (option == "-s") {
+                if (num_args < 2)
+                    usage(prog_name);
+                checkpoint_dir = argv[arg_ptr];
+                std::istringstream(argv[arg_ptr + 1]) >> pre_run_time;
+                checkpoint_save = true;
+                arg_ptr += 2;
+            } else if (option == "-c") {
+                if (num_args < 3)
+                    usage(prog_name);
+                switch_cpus = true;
+                from_cpu = argv[arg_ptr];
+                to_cpu = argv[arg_ptr + 1];
+                std::istringstream(argv[arg_ptr + 2]) >> pre_switch_time;
+                arg_ptr += 3;
+            } else {
+                usage(prog_name);
+            }
+        }
+    } catch (CxxConfigManager::Exception &e) {
+        std::cerr << e.name << ": " << e.message << "\n";
+        return EXIT_FAILURE;
+    }
+
+    if (checkpoint_save && checkpoint_restore) {
+        std::cerr << "Don't try and save and restore a checkpoint in the"
+            " same run\n";
+        return EXIT_FAILURE;
+    }
+
+    CxxConfig::statsEnable();
+    getEventQueue(0)->dump();
+
+    try {
+        config_manager->instantiate();
+        if (!checkpoint_restore) {
+            config_manager->initState();
+            config_manager->startup();
+        }
+    } catch (CxxConfigManager::Exception &e) {
+        std::cerr << "Config problem in sim object " << e.name
+            << ": " << e.message << "\n";
+
+        return EXIT_FAILURE;
+    }
+
+    GlobalSimLoopExitEvent *exit_event = NULL;
+
+    if (checkpoint_save) {
+
+        exit_event = simulate(pre_run_time);
+
+        DrainManager drain_manager;
+        unsigned int drain_count = 1;
+        do {
+            drain_count = config_manager->drain(&drain_manager);
+
+            std::cerr << "Draining " << drain_count << '\n';
+
+            if (drain_count > 0) {
+                drain_manager.setCount(drain_count);
+                exit_event = simulate();
+            }
+        } while (drain_count > 0);
+
+        std::cerr << "Simulation stop at tick " << curTick()
+            << ", cause: " << exit_event->getCause() << '\n';
+
+        std::cerr << "Checkpointing\n";
+
+        /* FIXME, this should really be serialising just for
+         *  config_manager rather than using serializeAll's ugly
+         *  SimObject static object list */
+        Serializable::serializeAll(checkpoint_dir);
+
+        std::cerr << "Completed checkpoint\n";
+
+        config_manager->drainResume();
+    }
+
+    if (checkpoint_restore) {
+        std::cerr << "Restoring checkpoint\n";
+
+        Checkpoint *checkpoint = new Checkpoint(checkpoint_dir,
+            config_manager->getSimObjectResolver());
+
+        Serializable::unserializeGlobals(checkpoint);
+        config_manager->loadState(checkpoint);
+
+        config_manager->drainResume();
+
+        std::cerr << "Restored from checkpoint\n";
+    }
+
+    if (switch_cpus) {
+        exit_event = simulate(pre_switch_time);
+
+        std::cerr << "Switching CPU\n";
+
+        /* Assume the system is called system */
+        System &system = config_manager->getObject<System>("system");
+        BaseCPU &old_cpu = config_manager->getObject<BaseCPU>(from_cpu);
+        BaseCPU &new_cpu = config_manager->getObject<BaseCPU>(to_cpu);
+
+        DrainManager drain_manager;
+        unsigned int drain_count = 1;
+        do {
+            drain_count = config_manager->drain(&drain_manager);
+
+            std::cerr << "Draining " << drain_count << '\n';
+
+            if (drain_count > 0) {
+                drain_manager.setCount(drain_count);
+                exit_event = simulate();
+            }
+        } while (drain_count > 0);
+
+        old_cpu.switchOut();
+        system.setMemoryMode(Enums::timing);
+        new_cpu.takeOverFrom(&old_cpu);
+        config_manager->drainResume();
+
+        std::cerr << "Switched CPU\n";
+    }
+
+    exit_event = simulate();
+
+    std::cerr << "Exit at tick " << curTick()
+        << ", cause: " << exit_event->getCause() << '\n';
+
+    getEventQueue(0)->dump();
+
+#if TRY_CLEAN_DELETE
+    config_manager->deleteObjects();
+#endif
+
+    delete config_manager;
+
+    return EXIT_SUCCESS;
+}
diff --git a/util/cxx_config/stats.cc b/util/cxx_config/stats.cc
new file mode 100644
index 000000000..ef5d9b5d3
--- /dev/null
+++ b/util/cxx_config/stats.cc
@@ -0,0 +1,115 @@
+/*
+ * 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
+ *
+ *  C++-only configuration stats handling example
+ *
+ *  Register with: Stats::registerHandlers(statsReset, statsDump)
+ */
+
+#include "base/statistics.hh"
+#include "stats.hh"
+
+namespace CxxConfig
+{
+
+void statsPrepare()
+{
+    std::list<Stats::Info *> stats = Stats::statsList();
+
+    /* gather_stats -> prepare */
+    for (auto i = stats.begin(); i != stats.end(); ++i)
+        (*i)->prepare();
+}
+
+void statsDump()
+{
+    std::cerr << "Stats dump\n";
+
+    Stats::processDumpQueue();
+
+    std::list<Stats::Info *> stats = Stats::statsList();
+
+    statsPrepare();
+
+    /* gather_stats -> convert_value */
+    for (auto i = stats.begin(); i != stats.end(); ++i) {
+        Stats::Info *stat = *i;
+
+        Stats::ScalarInfo *scalar = dynamic_cast<Stats::ScalarInfo *>(stat);
+        Stats::VectorInfo *vector = dynamic_cast<Stats::VectorInfo *>(stat);
+
+        if (scalar) {
+            std::cerr << "SCALAR " << stat->name << ' '
+                << scalar->value() << '\n';
+        } else if (vector) {
+            Stats::VResult results = vector->value();
+
+            unsigned int index = 0;
+            for (auto e = results.begin(); e != results.end(); ++e) {
+                std::cerr << "VECTOR " << stat->name << '[' << index
+                    << "] " << (*e) << '\n';
+                index++;
+            }
+            std::cerr << "VTOTAL " << stat->name << ' '
+                << vector->total() << '\n';
+        } else {
+            std::cerr << "?????? " << stat->name << '\n';
+        }
+    }
+}
+
+void statsReset()
+{
+    std::cerr << "Stats reset\n";
+
+    Stats::processResetQueue();
+}
+
+void statsEnable()
+{
+    std::list<Stats::Info *> stats = Stats::statsList();
+
+    for (auto i = stats.begin(); i != stats.end(); ++i)
+        (*i)->enable();
+}
+
+}
diff --git a/util/cxx_config/stats.hh b/util/cxx_config/stats.hh
new file mode 100644
index 000000000..360cb6293
--- /dev/null
+++ b/util/cxx_config/stats.hh
@@ -0,0 +1,61 @@
+/*
+ * 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
+ *
+ *  C++-only configuration stats handling example
+ *
+ *  Register with: Stats::registerHandlers(statsReset, statsDump)
+ */
+
+#ifndef __UTIL_CXX_CONFIG_STATS_H__
+#define __UTIL_CXX_CONFIG_STATS_H__
+
+namespace CxxConfig
+{
+
+void statsDump();
+void statsReset();
+void statsEnable();
+void statsPrepare();
+
+}
+
+#endif // __UTIL_CXX_CONFIG_STATS_H__
-- 
cgit v1.2.3