mem: Implement base QoS Policies.

This patch implements a base fixed priority policy and an ideal
turnaround policy for the QoS memory controller.

Change-Id: I38ce16f845fc0ec86d6fc4cc5dc5406f213a465e
Signed-off-by: Giacomo Travaglini <giacomo.travaglini@arm.com>
Reviewed-on: https://gem5-review.googlesource.com/11972
Maintainer: Nikos Nikoleris <nikos.nikoleris@arm.com>
Reviewed-by: Nikos Nikoleris <nikos.nikoleris@arm.com>

7 files changed, 429 insertions, 0 deletions

diff --git a/src/mem/qos/QoSPolicy.py b/src/mem/qos/QoSPolicy.py
index f2218a725..9ccd98562 100644
--- a/src/mem/qos/QoSPolicy.py
+++ b/src/mem/qos/QoSPolicy.py
@@ -36,6 +36,7 @@
 # Authors: Giacomo Travaglini
 
 from m5.SimObject import *
+from m5.params import *
 
 # QoS scheduler policy used to serve incoming transaction
 class QoSPolicy(SimObject):
@@ -43,3 +44,40 @@ class QoSPolicy(SimObject):
     abstract = True
     cxx_header = "mem/qos/policy.hh"
     cxx_class = 'QoS::Policy'
+
+class QoSFixedPriorityPolicy(QoSPolicy):
+    type = 'QoSFixedPriorityPolicy'
+    cxx_header = "mem/qos/policy_fixed_prio.hh"
+    cxx_class = 'QoS::FixedPriorityPolicy'
+
+    cxx_exports = [
+        PyBindMethod('initMasterName'),
+        PyBindMethod('initMasterObj'),
+    ]
+
+    _mpriorities = None
+
+    def setMasterPriority(self, master, priority):
+        if not self._mpriorities:
+            self._mpriorities = []
+
+        self._mpriorities.append([master, priority])
+
+    def init(self):
+        if not self._mpriorities:
+            print("Error, use setMasterPriority to init masters/priorities\n");
+            exit(1)
+        else:
+            for mprio in self._mpriorities:
+                master = mprio[0]
+                priority = mprio[1]
+                if isinstance(master, basestring):
+                    self.getCCObject().initMasterName(
+                        master, int(priority))
+                else:
+                    self.getCCObject().initMasterObj(
+                        master.getCCObject(), priority)
+
+    # default fixed priority value for non-listed Masters
+    qos_fixed_prio_default_prio = Param.UInt8(0,
+        "Default priority for non-listed Masters")
diff --git a/src/mem/qos/QoSTurnaround.py b/src/mem/qos/QoSTurnaround.py
index 8f9c94296..506be7529 100644
--- a/src/mem/qos/QoSTurnaround.py
+++ b/src/mem/qos/QoSTurnaround.py
@@ -43,3 +43,8 @@ class QoSTurnaroundPolicy(SimObject):
     cxx_header = "mem/qos/turnaround_policy.hh"
     cxx_class = 'QoS::TurnaroundPolicy'
     abstract = True
+
+class QoSTurnaroundPolicyIdeal(QoSTurnaroundPolicy):
+    type = 'QoSTurnaroundPolicyIdeal'
+    cxx_header = "mem/qos/turnaround_policy_ideal.hh"
+    cxx_class = 'QoS::TurnaroundPolicyIdeal'
diff --git a/src/mem/qos/SConscript b/src/mem/qos/SConscript
index 9a9343fc0..23351ca4f 100644
--- a/src/mem/qos/SConscript
+++ b/src/mem/qos/SConscript
@@ -43,6 +43,8 @@ SimObject('QoSPolicy.py')
 SimObject('QoSTurnaround.py')
 
 Source('policy.cc')
+Source('policy_fixed_prio.cc')
+Source('turnaround_policy_ideal.cc')
 Source('q_policy.cc')
 Source('mem_ctrl.cc')
 Source('mem_sink.cc')
diff --git a/src/mem/qos/policy_fixed_prio.cc b/src/mem/qos/policy_fixed_prio.cc
new file mode 100644
index 000000000..449a25d23
--- /dev/null
+++ b/src/mem/qos/policy_fixed_prio.cc
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2018 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: Matteo Andreozzi
+ */
+
+#include "mem/qos/policy_fixed_prio.hh"
+
+#include <algorithm>
+#include <functional>
+
+#include "mem/request.hh"
+
+namespace QoS {
+
+FixedPriorityPolicy::FixedPriorityPolicy(const Params* p)
+  : Policy(p), defaultPriority(p->qos_fixed_prio_default_prio)
+{}
+
+FixedPriorityPolicy::~FixedPriorityPolicy()
+{}
+
+void
+FixedPriorityPolicy::init()
+{
+}
+
+void
+FixedPriorityPolicy::initMasterName(std::string master, uint8_t priority)
+{
+    priorityMap.insert(
+        this->pair<std::string, uint8_t>(master, priority));
+}
+
+void
+FixedPriorityPolicy::initMasterObj(const SimObject* master, uint8_t priority)
+{
+    priorityMap.insert(
+        this->pair<const SimObject*, uint8_t>(master, priority));
+}
+
+uint8_t
+FixedPriorityPolicy::schedule(const MasterID mId, const uint64_t data)
+{
+    // Reads a packet's MasterID contained in its encapsulated request
+    // if a match is found in the configured priority map, returns the
+    // matching priority, else returns zero
+
+    auto ret = priorityMap.find(mId);
+
+    if (ret != priorityMap.end()) {
+        return ret->second;
+    } else {
+        DPRINTF(QOS, "Master %s (MasterID %d) not present in priorityMap, "
+                     "assigning default priority %d\n",
+                      memCtrl->system()->getMasterName(mId),
+                      mId, defaultPriority);
+        return defaultPriority;
+    }
+}
+
+} // namespace QoS
+
+QoS::FixedPriorityPolicy *
+QoSFixedPriorityPolicyParams::create()
+{
+    return new QoS::FixedPriorityPolicy(this);
+}
diff --git a/src/mem/qos/policy_fixed_prio.hh b/src/mem/qos/policy_fixed_prio.hh
new file mode 100644
index 000000000..08f46a495
--- /dev/null
+++ b/src/mem/qos/policy_fixed_prio.hh
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2018 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: Matteo Andreozzi
+ */
+
+#ifndef __MEM_QOS_POLICY_FIXED_PRIO_HH__
+#define __MEM_QOS_POLICY_FIXED_PRIO_HH__
+
+#include "mem/qos/policy.hh"
+#include "params/QoSFixedPriorityPolicy.hh"
+
+namespace QoS {
+
+/**
+ * Fixed Priority QoS Policy
+ *
+ * Fixed Priority Policy: based on a configured MasterID to priority map,
+ * it returns a fixed QoS priority value: every master has a fixed priority.
+ */
+class FixedPriorityPolicy : public Policy
+{
+    using Params = QoSFixedPriorityPolicyParams;
+
+  public:
+    FixedPriorityPolicy(const Params*);
+    virtual ~FixedPriorityPolicy();
+
+    void init() override;
+
+    /**
+     * Initialize the fixed master's priority by providing
+     * the master's name and priority value.
+     * The master's name has to match a name in the system.
+     *
+     * @param master master's name to lookup.
+     * @param priority priority value for the master
+     */
+    void initMasterName(std::string master, uint8_t priority);
+
+    /**
+     * Initialize the fixed master's priority by providing
+     * the master's SimObject pointer and priority value.
+     *
+     * @param master master's SimObject pointer to lookup.
+     * @param priority priority value for the master
+     */
+    void initMasterObj(const SimObject* master, uint8_t priority);
+
+    /**
+     * Schedules a packet based on fixed priority configuration
+     *
+     * @param mId master id to schedule
+     * @param data data to schedule
+     * @return QoS priority value
+     */
+    virtual uint8_t schedule(const MasterID, const uint64_t) override;
+
+  protected:
+    /** Default fixed priority value for non-listed masters */
+    const uint8_t defaultPriority;
+
+    /**
+     * Priority map, associates configured masters with
+     * a fixed QoS priority value
+     */
+    std::map<MasterID, uint8_t> priorityMap;
+};
+
+} // namespace QoS
+
+#endif // __MEM_QOS_POLICY_FIXED_PRIO_HH__
diff --git a/src/mem/qos/turnaround_policy_ideal.cc b/src/mem/qos/turnaround_policy_ideal.cc
new file mode 100644
index 000000000..a76a2a7ba
--- /dev/null
+++ b/src/mem/qos/turnaround_policy_ideal.cc
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2018 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: Matteo Andreozzi
+ */
+
+#include "turnaround_policy_ideal.hh"
+
+#include "params/QoSTurnaroundPolicyIdeal.hh"
+
+namespace QoS {
+
+TurnaroundPolicyIdeal::TurnaroundPolicyIdeal(const Params* p)
+  : TurnaroundPolicy(p)
+{}
+
+TurnaroundPolicyIdeal::~TurnaroundPolicyIdeal()
+{}
+
+MemCtrl::BusState
+TurnaroundPolicyIdeal::selectBusState()
+{
+    auto bus_state = memCtrl->getBusState();
+    const auto num_priorities = memCtrl->numPriorities();
+
+    // QoS-aware turnaround policy
+    // Loop for every queue in the memory controller.
+    for (uint8_t i = 0; i < num_priorities; i++) {
+
+        // Starting from top priority queues first
+        uint8_t queue_idx = num_priorities - i - 1;
+
+        const uint64_t readq_size = memCtrl->getReadQueueSize(queue_idx);
+        const uint64_t writeq_size = memCtrl->getWriteQueueSize(queue_idx);
+
+        // No data for current priority: both the read queue
+        // and write queue are empty.
+        if ((readq_size == 0) && (writeq_size == 0)) {
+            continue;
+        }
+
+        // Data found - select state
+        if (readq_size == 0) {
+            bus_state = MemCtrl::WRITE;
+        } else if (writeq_size == 0) {
+            bus_state = MemCtrl::READ;
+        } else {
+            // readq_size > 0 && writeq_size > 0
+            bus_state = ((memCtrl->getBusState() == MemCtrl::READ) ?
+                    MemCtrl::WRITE : MemCtrl::READ);
+        }
+
+        DPRINTF(QOS,
+                "QoSMemoryTurnaround::QoSTurnaroundPolicyIdeal - "
+                "QoS priority %d queues %d, %d triggering bus %s "
+                "in state %s\n", queue_idx, readq_size, writeq_size,
+                (bus_state != memCtrl->getBusState()) ?
+                "turnaround" : "staying",
+                (bus_state == MemCtrl::READ)? "READ" : "WRITE");
+        // State selected - exit loop
+        break;
+    }
+
+    return bus_state;
+}
+
+} // namespace QoS
+
+QoS::TurnaroundPolicyIdeal *
+QoSTurnaroundPolicyIdealParams::create()
+{
+    return new QoS::TurnaroundPolicyIdeal(this);
+}
diff --git a/src/mem/qos/turnaround_policy_ideal.hh b/src/mem/qos/turnaround_policy_ideal.hh
new file mode 100644
index 000000000..e28c55cf3
--- /dev/null
+++ b/src/mem/qos/turnaround_policy_ideal.hh
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2018 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: Matteo Andreozzi
+ */
+
+#ifndef __MEM_QOS_TURNAROUND_POLICY_IDEAL_HH_
+#define __MEM_QOS_TURNAROUND_POLICY_IDEAL_HH_
+
+#include "mem/qos/turnaround_policy.hh"
+
+namespace QoS {
+
+/**
+ * Ideal QoS Bus Turnaround policy
+ *
+ * Selects bus state based purely on highest QoS priority
+ * queue with at least one packet. Tie breaks across read
+ * and write queues are resolved by selecting current bus
+ * state.
+ */
+class TurnaroundPolicyIdeal: public TurnaroundPolicy
+{
+  public:
+    TurnaroundPolicyIdeal(const Params*);
+
+    virtual ~TurnaroundPolicyIdeal();
+
+    /**
+     * Bus Selection function.
+     *
+     * @return selected bus state
+     */
+    virtual MemCtrl::BusState selectBusState() override;
+};
+
+} // namespace QoS
+
+#endif /* __MEM_QOS_TURNAROUND_POLICY_IDEAL_HH_ */