power: Add support for power models

This patch adds some basic support for power models in gem5.

The power interface is defined so it can interact with thermal
models as well. It implements a simple power evaluator that
can be used for simple power models that express power in the
form of a math expression. These expressions can use stats
within the same SimObject (or down its hierarchy) and some
magic variables such as "temp" for temperature.
In future patches we will extend this functionality to allow
slightly more complex expressions.

The model allows it to be extended to use other kinds of models.

Finally, the thermal model is updated to use the power usage as input.

17 files changed, 1070 insertions, 8 deletions

diff --git a/src/sim/ClockedObject.py b/src/sim/ClockedObject.py
index b933ea07a..e393dc467 100644
--- a/src/sim/ClockedObject.py
+++ b/src/sim/ClockedObject.py
@@ -66,6 +66,9 @@ class ClockedObject(SimObject):
     # parent's clock domain by default
     clk_domain = Param.ClockDomain(Parent.clk_domain, "Clock domain")
 
+    # Power model for this ClockedObject
+    power_model = Param.PowerModel(NULL, "Power model")
+
     # Provide initial power state, should ideally get redefined in startup
     # routine
     default_p_state = Param.PwrState("UNDEFINED", "Default Power State")
diff --git a/src/sim/SConscript b/src/sim/SConscript
index e40c43f0c..22b9ef5cd 100644
--- a/src/sim/SConscript
+++ b/src/sim/SConscript
@@ -70,6 +70,7 @@ Source('linear_solver.cc')
 Source('system.cc')
 Source('dvfs_handler.cc')
 Source('clocked_object.cc')
+Source('mathexpr.cc')
 
 if env['TARGET_ISA'] != 'null':
     SimObject('InstTracer.py')
diff --git a/src/sim/clocked_object.cc b/src/sim/clocked_object.cc
index 9a682a4ce..e679f03a0 100644
--- a/src/sim/clocked_object.cc
+++ b/src/sim/clocked_object.cc
@@ -41,6 +41,17 @@
 #include "sim/clocked_object.hh"
 
 #include "base/misc.hh"
+#include "sim/power/power_model.hh"
+
+ClockedObject::ClockedObject(const ClockedObjectParams *p) :
+    SimObject(p), Clocked(*p->clk_domain),
+    _currPwrState(p->default_p_state),
+    prvEvalTick(0)
+{
+    // Register the power_model with the object
+    if (p->power_model)
+        p->power_model->setClockedObject(this);
+}
 
 void
 ClockedObject::serialize(CheckpointOut &cp) const
diff --git a/src/sim/clocked_object.hh b/src/sim/clocked_object.hh
index 1ba5ca617..b88f2435d 100644
--- a/src/sim/clocked_object.hh
+++ b/src/sim/clocked_object.hh
@@ -236,11 +236,7 @@ class ClockedObject
     : public SimObject, public Clocked
 {
   public:
-    ClockedObject(const ClockedObjectParams *p)
-        : SimObject(p), Clocked(*p->clk_domain),
-        _currPwrState(p->default_p_state),
-        prvEvalTick(0)
-    { }
+    ClockedObject(const ClockedObjectParams *p);
 
     /** Parameters of ClockedObject */
     typedef ClockedObjectParams Params;
diff --git a/src/sim/mathexpr.cc b/src/sim/mathexpr.cc
new file mode 100644
index 000000000..5654c80fa
--- /dev/null
+++ b/src/sim/mathexpr.cc
@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2015 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: David Guillen Fandos
+ */
+
+#include "sim/mathexpr.hh"
+
+#include <algorithm>
+#include <regex>
+#include <string>
+
+#include "base/misc.hh"
+
+MathExpr::MathExpr(std::string expr)
+ : ops(
+    std::array<OpSearch, uNeg + 1> {
+      OpSearch {true, bAdd, 0, '+', [] (double a, double b) { return a + b; } },
+      OpSearch {true, bSub, 0, '-', [] (double a, double b) { return a - b; } },
+      OpSearch {true, bMul, 1, '*', [] (double a, double b) { return a * b; } },
+      OpSearch {true, bDiv, 1, '/', [] (double a, double b) { return a / b; } },
+      OpSearch {false,uNeg, 2, '-', [] (double a, double b) { return -b; } },
+      OpSearch {true, bPow, 3, '^', [] (double a, double b) { return std::pow(a,b); } },
+    })
+{
+    // Cleanup
+    expr.erase(remove_if(expr.begin(), expr.end(), isspace), expr.end());
+
+    root = MathExpr::parse(expr);
+    panic_if(!root, "Invalid expression\n");
+}
+
+/**
+ * This function parses a string expression into an expression tree.
+ * It will look for operators in priority order to recursively build the
+ * tree, respecting parenthesization.
+ * Constants can be expressed in any format accepted by std::stod, whereas
+ * variables are essentially [A-Za-z0-9\.$\\]+
+ */
+MathExpr::Node *
+MathExpr::parse(std::string expr) {
+    if (expr.size() == 0)
+        return NULL;
+
+    // From low to high priority
+    int par = 0;
+    for (unsigned p = 0; p < MAX_PRIO; p++) {
+        for (int i = expr.size() - 1; i >= 0; i--) {
+            if (expr[i] == ')')
+                par++;
+            if (expr[i] == '(')
+                par--;
+
+            if (par < 0) return NULL;
+            if (par > 0) continue;
+
+            for (unsigned opt = 0; opt < ops.size(); opt++) {
+                if (ops[opt].priority != p) continue;
+                if (ops[opt].c == expr[i]) {
+                    // Try to parse each side
+                    Node *l = NULL;
+                    if (ops[opt].binary)
+                        l = parse(expr.substr(0, i));
+                    Node *r = parse(expr.substr(i + 1));
+                    if ((l && r) || (!ops[opt].binary && r)) {
+                        // Match!
+                        Node *n = new Node();
+                        n->op = ops[opt].op;
+                        n->l = l;
+                        n->r = r;
+                        return n;
+                    }
+                }
+            }
+        }
+    }
+
+    // Remove trivial parenthesis
+    if (expr.size() >= 2 && expr[0] == '(' && expr[expr.size() - 1] == ')')
+        return parse(expr.substr(1, expr.size() - 2));
+
+    // Match a number
+    {
+        char *sptr;
+        double v = strtod(expr.c_str(), &sptr);
+        if (sptr != expr.c_str()) {
+            Node *n = new Node();
+            n->op = sValue;
+            n->value = v;
+            return n;
+        }
+    }
+
+    // Match a variable
+    {
+        bool contains_non_alpha = false;
+        for (auto & c: expr)
+            contains_non_alpha = contains_non_alpha or
+                !( (c >= 'a' && c <= 'z') ||
+                   (c >= 'A' && c <= 'Z') ||
+                   (c >= '0' && c <= '9') ||
+                   c == '$' || c == '\\' || c == '.' || c == '_');
+
+        if (!contains_non_alpha) {
+            Node * n = new Node();
+            n->op = sVariable;
+            n->variable = expr;
+            return n;
+        }
+    }
+
+    return NULL;
+}
+
+double
+MathExpr::eval(const Node *n, EvalCallback fn) const {
+    if (!n)
+        return 0;
+    else if (n->op == sValue)
+        return n->value;
+    else if (n->op == sVariable)
+        return fn(n->variable);
+
+    for (auto & opt : ops)
+        if (opt.op == n->op)
+            return opt.fn( eval(n->l, fn), eval(n->r, fn) );
+
+    panic("Invalid node!\n");
+    return 0;
+}
+
+std::string
+MathExpr::toStr(Node *n, std::string prefix) const {
+    std::string ret;
+    ret += prefix + "|-- " + n->toStr() + "\n";
+    if (n->r)
+        ret += toStr(n->r, prefix + "|   ");
+    if (n->l)
+        ret += toStr(n->l, prefix + "|   ");
+    return ret;
+}
+
diff --git a/src/sim/mathexpr.hh b/src/sim/mathexpr.hh
new file mode 100644
index 000000000..8f16cc851
--- /dev/null
+++ b/src/sim/mathexpr.hh
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2015 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: David Guillen Fandos
+ */
+
+#ifndef __SIM_MATHEXPR_HH__
+#define __SIM_MATHEXPR_HH__
+
+#include <algorithm>
+#include <functional>
+#include <string>
+
+class MathExpr {
+  public:
+
+    MathExpr(std::string expr);
+
+    typedef std::function<double(std::string)> EvalCallback;
+
+    /**
+     * Prints an ASCII representation of the expression tree
+     *
+     * @return A string containing the ASCII representation of the expression
+     */
+    std::string toStr() const { return toStr(root, ""); }
+
+    /**
+     * Evaluates the expression
+     *
+     * @param fn A callback funcion to evaluate variables
+     *
+     * @return The value for this expression
+     */
+    double eval(EvalCallback fn) const { return eval(root, fn); }
+
+  private:
+    enum Operator {
+        bAdd, bSub, bMul, bDiv, bPow, uNeg, sValue, sVariable, nInvalid
+    };
+
+    // Match operators
+    const int MAX_PRIO = 4;
+    typedef double (*binOp)(double, double);
+    struct OpSearch {
+        bool binary;
+        Operator op;
+        int priority;
+        char c;
+        binOp fn;
+    };
+
+    /** Operator list */
+    std::array<OpSearch, uNeg + 1> ops;
+
+    class Node {
+      public:
+        Node() : op(nInvalid), l(0), r(0), value(0) {}
+        std::string toStr() const {
+            const char opStr[] = {'+', '-', '*', '/', '^', '-'};
+            switch (op) {
+              case nInvalid:
+                return "INVALID";
+              case sVariable:
+                return variable;
+              case sValue:
+                return std::to_string(value);
+              default:
+                return std::string(1, opStr[op]);
+            };
+        }
+
+        Operator op;
+        Node *l, *r;
+        double value;
+        std::string variable;
+    };
+
+    /** Root node */
+    Node * root;
+
+    /** Parse and create nodes from string */
+    Node *parse(std::string expr);
+
+    /** Print tree as string */
+    std::string toStr(Node *n, std::string prefix) const;
+
+    /** Eval a node */
+    double eval(const Node *n, EvalCallback fn) const;
+};
+
+#endif
+
+
diff --git a/src/sim/power/MathExprPowerModel.py b/src/sim/power/MathExprPowerModel.py
new file mode 100644
index 000000000..061f7e767
--- /dev/null
+++ b/src/sim/power/MathExprPowerModel.py
@@ -0,0 +1,52 @@
+# Copyright (c) 2015 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: David Guillen Fandos
+
+from m5.SimObject import SimObject
+from m5.params import *
+from PowerModelState import PowerModelState
+
+# Represents a power model for a simobj
+class MathExprPowerModel(PowerModelState):
+    type = 'MathExprPowerModel'
+    cxx_header = "sim/power/mathexpr_powermodel.hh"
+
+    # Equations for dynamic and static power
+    # Equations may use gem5 stats ie. "1.1*ipc + 2.3*l2_cache.overall_misses"
+    # It is possible to use automatic variables such as "temp"
+    # You may also use stat names (relative path to the simobject)
+    dyn = Param.String("", "Expression for the dynamic power")
+    st = Param.String("", "Expression for the static power")
diff --git a/src/sim/power/PowerModel.py b/src/sim/power/PowerModel.py
new file mode 100644
index 000000000..4e6d496c4
--- /dev/null
+++ b/src/sim/power/PowerModel.py
@@ -0,0 +1,61 @@
+# Copyright (c) 2015 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: David Guillen Fandos
+
+from m5.SimObject import SimObject
+from m5.params import *
+from m5.proxy import Parent
+
+# Represents a power model for a simobj
+# The model itself is also a SimObject so we can make use some
+# nice features available such as Parent.any
+class PowerModel(SimObject):
+    type = 'PowerModel'
+    cxx_header = "sim/power/power_model.hh"
+
+    @classmethod
+    def export_methods(cls, code):
+        code('''
+      double getDynamicPower() const;
+      double getStaticPower() const;
+''')
+
+    # Keep a list of every model for every power state
+    pm = VectorParam.PowerModelState([], "List of per-state power models.")
+
+    # Need a reference to the system so we can query the thermal domain
+    # about temperature (temperature is needed for leakage calculation)
+    subsystem = Param.SubSystem(Parent.any, "subsystem")
diff --git a/src/sim/power/PowerModelState.py b/src/sim/power/PowerModelState.py
new file mode 100644
index 000000000..10b3141d0
--- /dev/null
+++ b/src/sim/power/PowerModelState.py
@@ -0,0 +1,55 @@
+# Copyright (c) 2015 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: David Guillen Fandos
+
+from m5.SimObject import SimObject
+from m5.params import *
+
+# Represents a power model for a simobj
+class PowerModelState(SimObject):
+    type = 'PowerModelState'
+    cxx_header = "sim/power/power_model.hh"
+    abstract = True
+    cxx_class = 'PowerModelState'
+
+    @classmethod
+    def export_methods(cls, code):
+        code('''
+      double getDynamicPower() const;
+      double getStaticPower() const;
+''')
+
+
diff --git a/src/sim/power/SConscript b/src/sim/power/SConscript
index 8ec65519c..2f0eb4fc1 100644
--- a/src/sim/power/SConscript
+++ b/src/sim/power/SConscript
@@ -30,9 +30,14 @@
 
 Import('*')
 
+SimObject('MathExprPowerModel.py')
+SimObject('PowerModel.py')
+SimObject('PowerModelState.py')
 SimObject('ThermalDomain.py')
 SimObject('ThermalModel.py')
 
+Source('power_model.cc')
+Source('mathexpr_powermodel.cc')
 Source('thermal_domain.cc')
 Source('thermal_model.cc')
 
diff --git a/src/sim/power/mathexpr_powermodel.cc b/src/sim/power/mathexpr_powermodel.cc
new file mode 100644
index 000000000..000bcf22d
--- /dev/null
+++ b/src/sim/power/mathexpr_powermodel.cc
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2015 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: David Guillen Fandos
+ */
+
+#include "sim/power/mathexpr_powermodel.hh"
+
+#include "base/statistics.hh"
+#include "params/MathExprPowerModel.hh"
+#include "sim/mathexpr.hh"
+#include "sim/power/thermal_model.hh"
+#include "sim/sim_object.hh"
+
+MathExprPowerModel::MathExprPowerModel(const Params *p)
+    : PowerModelState(p), dyn_expr(p->dyn), st_expr(p->st)
+{
+    // Calculate the name of the object we belong to
+    std::vector<std::string> path;
+    tokenize(path, name(), '.', true);
+    // It's something like xyz.power_model.pm2
+    assert(path.size() > 2);
+    for (unsigned i = 0; i < path.size() - 2; i++)
+        basename += path[i] + ".";
+}
+
+void
+MathExprPowerModel::startup()
+{
+    // Create a map with stats and pointers for quick access
+    // Has to be done here, since we need access to the statsList
+    for (auto & i: Stats::statsList())
+        if (i->name.find(basename) == 0)
+            stats_map[i->name.substr(basename.size())] = i;
+}
+
+double
+MathExprPowerModel::getStatValue(const std::string &name) const
+{
+    using namespace Stats;
+
+    // Automatic variables:
+    if (name == "temp")
+        return _temp;
+
+    // Try to cast the stat, only these are supported right now
+    Info *info = stats_map.at(name);
+
+    ScalarInfo *si = dynamic_cast<ScalarInfo*>(info);
+    if (si)
+        return si->value();
+    FormulaInfo *fi = dynamic_cast<FormulaInfo*>(info);
+    if (fi)
+        return fi->total();
+
+    panic("Unknown stat type!\n");
+}
+
+void
+MathExprPowerModel::regStats()
+{
+    PowerModelState::regStats();
+}
+
+MathExprPowerModel*
+MathExprPowerModelParams::create()
+{
+    return new MathExprPowerModel(this);
+}
diff --git a/src/sim/power/mathexpr_powermodel.hh b/src/sim/power/mathexpr_powermodel.hh
new file mode 100644
index 000000000..43584fbd8
--- /dev/null
+++ b/src/sim/power/mathexpr_powermodel.hh
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2015 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: David Guillen Fandos
+ */
+
+#ifndef __SIM_MATHEXPR_POWERMODEL_PM_HH__
+#define __SIM_MATHEXPR_POWERMODEL_PM_HH__
+
+#include <unordered_map>
+
+#include "base/statistics.hh"
+#include "params/MathExprPowerModel.hh"
+#include "sim/mathexpr.hh"
+#include "sim/power/power_model.hh"
+#include "sim/sim_object.hh"
+
+/**
+ * A Equation power model. The power is represented as a combination
+ * of some stats and automatic variables (like temperature).
+ */
+class MathExprPowerModel : public PowerModelState
+{
+  public:
+
+    typedef MathExprPowerModelParams Params;
+    MathExprPowerModel(const Params *p);
+
+    /**
+     * Get the dynamic power consumption.
+     *
+     * @return Power (Watts) consumed by this object (dynamic component)
+     */
+    double getDynamicPower() const {
+        return dyn_expr.eval(
+            std::bind(&MathExprPowerModel::getStatValue,
+                this, std::placeholders::_1)
+        );
+    }
+
+    /**
+     * Get the static power consumption.
+     *
+     * @return Power (Watts) consumed by this object (static component)
+     */
+    double getStaticPower() const {
+        return st_expr.eval(
+            std::bind(&MathExprPowerModel::getStatValue,
+                this, std::placeholders::_1)
+        );
+    }
+
+    /**
+     * Get the value for a variable (maps to a stat)
+     *
+     * @param name Name of the variable to retrieve the value from
+     *
+     * @return Power (Watts) consumed by this object (static component)
+     */
+    double getStatValue(const std::string & name) const;
+
+    void startup();
+
+    void regStats();
+
+  private:
+
+    // Math expressions for dynamic and static power
+    MathExpr dyn_expr, st_expr;
+
+    // Basename of the object in the gem5 stats hierachy
+    std::string basename;
+
+    // Map that contains relevant stats for this power model
+    std::unordered_map<std::string, Stats::Info*> stats_map;
+};
+
+#endif
diff --git a/src/sim/power/power_model.cc b/src/sim/power/power_model.cc
new file mode 100644
index 000000000..d01084b34
--- /dev/null
+++ b/src/sim/power/power_model.cc
@@ -0,0 +1,138 @@
+/*
+ * Copyright (c) 2015 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: David Guillen Fandos
+ */
+
+#include "sim/power/power_model.hh"
+
+#include "base/statistics.hh"
+#include "params/PowerModel.hh"
+#include "params/PowerModelState.hh"
+#include "sim/sim_object.hh"
+#include "sim/sub_system.hh"
+
+PowerModelState::PowerModelState(const Params *p)
+    : SimObject(p), _temp(0), clocked_object(NULL)
+{
+}
+
+PowerModel::PowerModel(const Params *p)
+    : SimObject(p), states_pm(p->pm), subsystem(p->subsystem),
+      clocked_object(NULL)
+{
+    panic_if(subsystem == NULL,
+             "Subsystem is NULL! This is not acceptable for a PowerModel!\n");
+    subsystem->registerPowerProducer(this);
+}
+
+void
+PowerModel::setClockedObject(ClockedObject * clkobj)
+{
+    this->clocked_object = clkobj;
+
+    for (auto & pms: states_pm)
+        pms->setClockedObject(clkobj);
+}
+
+void
+PowerModel::thermalUpdateCallback(const double & temp)
+{
+    for (auto & pms: states_pm)
+        pms->setTemperature(temp);
+}
+
+void
+PowerModel::regProbePoints()
+{
+    thermalListener.reset(new ThermalProbeListener (
+        *this, this->subsystem->getProbeManager(), "thermalUpdate"
+    ));
+}
+
+PowerModel*
+PowerModelParams::create()
+{
+    return new PowerModel(this);
+}
+
+double
+PowerModel::getDynamicPower() const
+{
+    assert(clocked_object);
+
+    std::vector<double> w = clocked_object->pwrStateWeights();
+
+    // Same number of states (excluding UNDEFINED)
+    assert(w.size() - 1 == states_pm.size());
+
+    // Make sure we have no UNDEFINED state
+    warn_if(w[Enums::PwrState::UNDEFINED] > 0,
+        "SimObject in UNDEFINED power state! Power figures might be wrong!\n");
+
+    double power = 0;
+    for (unsigned i = 0; i < states_pm.size(); i++)
+        if (w[i + 1] > 0.0f)
+            power += states_pm[i]->getDynamicPower() * w[i + 1];
+
+    return power;
+}
+
+double
+PowerModel::getStaticPower() const
+{
+    assert(clocked_object);
+
+    std::vector<double> w = clocked_object->pwrStateWeights();
+
+    // Same number of states (excluding UNDEFINED)
+    assert(w.size() - 1 == states_pm.size());
+
+    // Make sure we have no UNDEFINED state
+    if (w[0] > 0)
+        warn("SimObject in UNDEFINED power state! "
+             "Power figures might be wrong!\n");
+
+    // We have N+1 states, being state #0 the default 'UNDEFINED' state
+    double power = 0;
+    for (unsigned i = 0; i < states_pm.size(); i++)
+        // Don't evaluate power if the object hasn't been in that state
+        // This fixes issues with NaNs and similar.
+        if (w[i + 1] > 0.0f)
+            power += states_pm[i]->getStaticPower() * w[i + 1];
+
+    return power;
+}
diff --git a/src/sim/power/power_model.hh b/src/sim/power/power_model.hh
new file mode 100644
index 000000000..f907597b4
--- /dev/null
+++ b/src/sim/power/power_model.hh
@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 2015 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: David Guillen Fandos
+ */
+
+#ifndef __SIM_POWER_POWER_MODEL_HH__
+#define __SIM_POWER_POWER_MODEL_HH__
+
+#include "base/statistics.hh"
+#include "params/PowerModel.hh"
+#include "params/PowerModelState.hh"
+#include "sim/power/thermal_model.hh"
+#include "sim/probe/probe.hh"
+#include "sim/sim_object.hh"
+
+/**
+ * A PowerModelState is an abstract class used as interface to get power
+ * figures out of SimObjects
+ */
+class PowerModelState : public SimObject
+{
+  public:
+
+    typedef PowerModelStateParams Params;
+    PowerModelState(const Params *p);
+
+    /**
+     * Get the dynamic power consumption.
+     *
+     * @return Power (Watts) consumed by this object (dynamic component)
+     */
+    virtual double getDynamicPower() const = 0;
+
+    /**
+     * Get the static power consumption.
+     *
+     * @return Power (Watts) consumed by this object (static component)
+     */
+    virtual double getStaticPower() const = 0;
+
+    /**
+     * Temperature update.
+     *
+     * @param temp Current temperature of the HW part (Celsius)
+     */
+    virtual void setTemperature(double temp) { _temp = temp; }
+
+    void setClockedObject(ClockedObject * clkobj) {
+        clocked_object = clkobj;
+    }
+
+    void regStats() {
+        dynamicPower
+          .method(this, &PowerModelState::getDynamicPower)
+          .name(params()->name + ".dynamic_power")
+          .desc("Dynamic power for this object (Watts)")
+        ;
+
+        staticPower
+          .method(this, &PowerModelState::getStaticPower)
+          .name(params()->name + ".static_power")
+          .desc("Static power for this object (Watts)")
+        ;
+    }
+
+  protected:
+    Stats::Value dynamicPower, staticPower;
+
+    /** Current temperature */
+    double _temp;
+
+    /** The clocked object we belong to */
+    ClockedObject * clocked_object;
+};
+
+/**
+ * A PowerModel is a class containing a power model for a SimObject.
+ * The PM describes the power consumption for every power state.
+ */
+class PowerModel : public SimObject
+{
+  public:
+
+    typedef PowerModelParams Params;
+    PowerModel(const Params *p);
+
+    /**
+     * Get the dynamic power consumption.
+     *
+     * @return Power (Watts) consumed by this object (dynamic component)
+     */
+    double getDynamicPower() const;
+
+    /**
+     * Get the static power consumption.
+     *
+     * @return Power (Watts) consumed by this object (static component)
+     */
+    double getStaticPower() const;
+
+    void regStats() {
+        dynamicPower
+          .method(this, &PowerModel::getDynamicPower)
+          .name(params()->name + ".dynamic_power")
+          .desc("Dynamic power for this power state")
+        ;
+
+        staticPower
+          .method(this, &PowerModel::getStaticPower)
+          .name(params()->name + ".static_power")
+          .desc("Static power for this power state")
+        ;
+    }
+
+    void setClockedObject(ClockedObject *clkobj);
+
+    virtual void regProbePoints();
+
+    void thermalUpdateCallback(const double & temp);
+
+  protected:
+    /** Listener class to catch thermal events */
+    class ThermalProbeListener : public ProbeListenerArgBase<double>
+    {
+      public:
+        ThermalProbeListener(PowerModel &_pm, ProbeManager *pm,
+                      const std::string &name)
+            : ProbeListenerArgBase(pm, name), pm(_pm) {}
+
+        void notify(const double &temp)
+        {
+            pm.thermalUpdateCallback(temp);
+        }
+
+      protected:
+        PowerModel &pm;
+    };
+
+    Stats::Value dynamicPower, staticPower;
+
+    /** Actual power models (one per power state) */
+    std::vector<PowerModelState*> states_pm;
+
+    /** Listener to catch temperature changes in the SubSystem */
+    std::unique_ptr<ThermalProbeListener> thermalListener;
+
+    /** The subsystem this power model belongs to */
+    SubSystem * subsystem;
+
+    /** The clocked object we belong to */
+    ClockedObject * clocked_object;
+};
+
+#endif
diff --git a/src/sim/power/thermal_domain.cc b/src/sim/power/thermal_domain.cc
index 4b840670d..62a0c23f8 100644
--- a/src/sim/power/thermal_domain.cc
+++ b/src/sim/power/thermal_domain.cc
@@ -108,7 +108,8 @@ LinearEquation
 ThermalDomain::getEquation(ThermalNode * tn, unsigned n, double step) const
 {
     LinearEquation eq(n);
+    double power = subsystem->getDynamicPower() + subsystem->getStaticPower();
     if (tn == node)
-        eq[eq.cnt()] = 1.75f; // Fake 1.75 Watts for now, to be changed to PM
+        eq[eq.cnt()] = power;
     return eq;
 }
diff --git a/src/sim/sub_system.cc b/src/sim/sub_system.cc
index 771590cf7..f5c0cc3f8 100644
--- a/src/sim/sub_system.cc
+++ b/src/sim/sub_system.cc
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014 ARM Limited
+ * Copyright (c) 2014-2015 ARM Limited
  * All rights reserved
  *
  * The license below extends only to copyright in the software and shall
@@ -37,8 +37,11 @@
  * Authors: Geoffrey Blake
  */
 
+#include "sim/sub_system.hh"
+
 #include "params/SubSystem.hh"
 #include "sim/sub_system.hh"
+#include "sim/power/power_model.hh"
 #include "sim/power/thermal_domain.hh"
 
 SubSystem::SubSystem(const Params *p)
@@ -49,6 +52,24 @@ SubSystem::SubSystem(const Params *p)
         p->thermal_domain->setSubSystem(this);
 }
 
+double
+SubSystem::getDynamicPower() const
+{
+    double ret = 0.0f;
+    for (auto &obj: powerProducers)
+        ret += obj->getDynamicPower();
+    return ret;
+}
+
+double
+SubSystem::getStaticPower() const
+{
+    double ret = 0.0f;
+    for (auto &obj: powerProducers)
+        ret += obj->getStaticPower();
+    return ret;
+}
+
 SubSystem *
 SubSystemParams::create()
 {
diff --git a/src/sim/sub_system.hh b/src/sim/sub_system.hh
index 6e35be676..ec25d7056 100644
--- a/src/sim/sub_system.hh
+++ b/src/sim/sub_system.hh
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014 ARM Limited
+ * Copyright (c) 2014-2015 ARM Limited
  * All rights reserved
  *
  * The license below extends only to copyright in the software and shall
@@ -45,10 +45,14 @@
 #ifndef __SIM_SUB_SYSTEM_HH__
 #define __SIM_SUB_SYSTEM_HH__
 
+#include <vector>
+
 #include "params/SubSystem.hh"
 #include "sim/power/thermal_domain.hh"
 #include "sim/sim_object.hh"
 
+class PowerModel;
+
 /**
  * The SubSystem simobject does nothing, it is just a container for
  * other simobjects used by the configuration system
@@ -58,6 +62,17 @@ class SubSystem : public SimObject
   public:
     typedef SubSystemParams Params;
     SubSystem(const Params *p);
+
+    double getDynamicPower() const;
+
+    double getStaticPower() const;
+
+    void registerPowerProducer(PowerModel *pm) {
+        powerProducers.push_back(pm);
+    }
+
+  protected:
+    std::vector<PowerModel*> powerProducers;
 };
 
 #endif