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.

18 files changed, 1198 insertions, 8 deletions

diff --git a/src/doc/power_thermal_model.doxygen b/src/doc/power_thermal_model.doxygen
new file mode 100644
index 000000000..8b636ab23
--- /dev/null
+++ b/src/doc/power_thermal_model.doxygen
@@ -0,0 +1,128 @@
+# Copyright (c) 2016 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: David Guillen Fandos
+
+/*! \page gem5PowerModel Gem5 Power & Thermal model
+
+  \tableofcontents
+
+  This document gives an overview of the power and thermal modelling
+  infrastructure in Gem5. The purpose is to give a high level view of
+  all the pieces involved and how they interact with each other and
+  the simulator.
+
+  \section gem5_PM_CD Class overview
+
+  Classes involved in the power model are:
+
+    - PowerModel: Represents a power model for a hardware component.
+
+    - PowerModelState: Represents a power model for a hardware component
+      in a certain power state. It is an abstract class that defines an
+      interface that must be implemented for each model.
+
+    - MathExprPowerModel: Simple implementation of PowerModelState that
+      assumes that power can be modeled using a simple power
+
+  Classes involved in the thermal model are:
+
+    - ThermalModel: Contains the system thermal model logic and state.
+      It performs the power query and temperature update. It also enables
+      gem5 to query for temperature (for OS reporting).
+
+    - ThermalDomain: Represents an entity that generates heat. It's
+      essentially a group of SimObjects grouped under a SubSystem component
+      that have its own thermal behaviour.
+
+    - ThermalNode: Represents a node in the thermal circuital equivalent.
+      The node has a temperature and interacts with other nodes through
+      connections (thermal resistors and capacitors).
+
+    - ThermalReference: Temperature reference for the thermal model
+      (essentially a thermal node with a fixed temperature), can be used
+      to model air or any other constant temperature domains.
+
+    - ThermalEntity: A thermal component that connects two thermal nodes
+      and models a thermal impedance between them. This class is just an
+      abstract interface.
+
+    - ThermalResistor: Implements ThermalEntity to model a thermal resistance
+      between the two nodes it connects. Thermal resistances model the
+      capacity of a material to transfer heat (units in K/W).
+
+    - ThermalCapacitor. Implements ThermalEntity to model a thermal
+      capacitance. Thermal capacitors are used to model material's thermal
+      capacitance, this is, the ability to change a certain material
+      temperature (units in J/K).
+
+  \section gem5_thermal Thermal model
+
+  The thermal model works by creating a circuital equivalent of the
+  simulated platform. Each node in the circuit has a temperature (as
+  voltage equivalent) and power flows between nodes (as current in a
+  circuit).
+
+  To build this equivalent temperature model the platform is required
+  to group the power actors (any component that has a power model)
+  under SubSystems and attach ThermalDomains to those subsystems.
+  Other components might also be created (like ThermalReferences) and
+  connected all together by creating thermal entities (capacitors and
+  resistors).
+
+  Last step to conclude the thermal model is to create the ThermalModel
+  instance itself and attach all the instances used to it, so it can
+  properly update them at runtime. Only one thermal model instance is
+  supported right now and it will automatically report temperature when
+  appropriate (ie. platform sensor devices).
+
+  \section gem5_power Power model
+
+  Every ClockedObject has a power model associated. If this power model is
+  non-null power will be calculated at every stats dump (although it might
+  be possible to force power evaluation at any other point, if the power
+  model uses the stats, it is a good idea to keep both events in sync).
+  The definition of a power model is quite vague in the sense that it is
+  as flexible as users want it to be. The only enforced contraints so far
+  is the fact that a power model has several power state models, one for
+  each possible power state for that hardware block. When it comes to compute
+  power consumption the power is just the weighted average of each power model.
+
+  A power state model is essentially an interface that allows us to define two
+  power functions for dynamic and static. As an example implementation a class
+  called MathExprPowerModel has been provided. This implementation allows the
+  user to define a power model as an equation involving several statistics.
+  There's also some automatic (or "magic") variables such as "temp", which
+  reports temperature.
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