From 70718a9feed127d42f8aa3780894bb599c1f1fd1 Mon Sep 17 00:00:00 2001 From: Giacomo Travaglini Date: Thu, 10 May 2018 17:07:42 +0100 Subject: [PATCH] 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 Reviewed-on: https://gem5-review.googlesource.com/11972 Maintainer: Nikos Nikoleris Reviewed-by: Nikos Nikoleris --- src/mem/qos/QoSPolicy.py | 38 +++++++++ src/mem/qos/QoSTurnaround.py | 5 ++ src/mem/qos/SConscript | 2 + src/mem/qos/policy_fixed_prio.cc | 101 +++++++++++++++++++++++ src/mem/qos/policy_fixed_prio.hh | 105 ++++++++++++++++++++++++ src/mem/qos/turnaround_policy_ideal.cc | 106 +++++++++++++++++++++++++ src/mem/qos/turnaround_policy_ideal.hh | 72 +++++++++++++++++ 7 files changed, 429 insertions(+) create mode 100644 src/mem/qos/policy_fixed_prio.cc create mode 100644 src/mem/qos/policy_fixed_prio.hh create mode 100644 src/mem/qos/turnaround_policy_ideal.cc create mode 100644 src/mem/qos/turnaround_policy_ideal.hh 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 +#include + +#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(master, priority)); +} + +void +FixedPriorityPolicy::initMasterObj(const SimObject* master, uint8_t priority) +{ + priorityMap.insert( + this->pair(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 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_ */ -- 2.30.2