blob: 9ade6914779558617fa496d139f2d5a86edcd9ca [file] [log] [blame] [edit]
/*
* Copyright (c) 2018-2020 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.
*/
#include "mem/qos/mem_sink.hh"
#include "base/logging.hh"
#include "base/trace.hh"
#include "debug/Drain.hh"
#include "debug/QOS.hh"
#include "mem/qos/q_policy.hh"
#include "params/QoSMemSinkInterface.hh"
namespace gem5
{
namespace memory
{
namespace qos
{
MemSinkCtrl::MemSinkCtrl(const QoSMemSinkCtrlParams &p)
: MemCtrl(p), requestLatency(p.request_latency),
responseLatency(p.response_latency),
memoryPacketSize(p.memory_packet_size),
readBufferSize(p.read_buffer_size),
writeBufferSize(p.write_buffer_size), port(name() + ".port", *this),
interface(p.interface),
retryRdReq(false), retryWrReq(false), nextRequest(0), nextReqEvent(*this),
stats(this)
{
// Resize read and write queue to allocate space
// for configured QoS priorities
readQueue.resize(numPriorities());
writeQueue.resize(numPriorities());
interface->setMemCtrl(this);
}
MemSinkCtrl::~MemSinkCtrl()
{}
void
MemSinkCtrl::init()
{
MemCtrl::init();
// Allow unconnected memories as this is used in several ruby
// systems at the moment
if (port.isConnected()) {
port.sendRangeChange();
}
}
bool
MemSinkCtrl::readQueueFull(const uint64_t packets) const
{
return (totalReadQueueSize + packets > readBufferSize);
}
bool
MemSinkCtrl::writeQueueFull(const uint64_t packets) const
{
return (totalWriteQueueSize + packets > writeBufferSize);
}
Tick
MemSinkCtrl::recvAtomic(PacketPtr pkt)
{
panic_if(pkt->cacheResponding(),
"%s Should not see packets where cache is responding\n",
__func__);
interface->access(pkt);
return responseLatency;
}
void
MemSinkCtrl::recvFunctional(PacketPtr pkt)
{
pkt->pushLabel(name());
interface->functionalAccess(pkt);
pkt->popLabel();
}
Port &
MemSinkCtrl::getPort(const std::string &interface, PortID idx)
{
if (interface != "port") {
return MemCtrl::getPort(interface, idx);
} else {
return port;
}
}
bool
MemSinkCtrl::recvTimingReq(PacketPtr pkt)
{
// Request accepted
bool req_accepted = true;
panic_if(!(pkt->isRead() || pkt->isWrite()),
"%s. Should only see "
"read and writes at memory controller\n",
__func__);
panic_if(pkt->cacheResponding(),
"%s. Should not see packets where cache is responding\n",
__func__);
DPRINTF(QOS,
"%s: REQUESTOR %s request %s addr %lld size %d\n",
__func__,
_system->getRequestorName(pkt->req->requestorId()),
pkt->cmdString(), pkt->getAddr(), pkt->getSize());
uint64_t required_entries = divCeil(pkt->getSize(), memoryPacketSize);
assert(required_entries);
// Schedule packet
uint8_t pkt_priority = qosSchedule({&readQueue, &writeQueue},
memoryPacketSize, pkt);
if (pkt->isRead()) {
if (readQueueFull(required_entries)) {
DPRINTF(QOS,
"%s Read queue full, not accepting\n", __func__);
// Remember that we have to retry this port
retryRdReq = true;
stats.numReadRetries++;
req_accepted = false;
} else {
// Enqueue the incoming packet into corresponding
// QoS priority queue
readQueue.at(pkt_priority).push_back(pkt);
queuePolicy->enqueuePacket(pkt);
}
} else {
if (writeQueueFull(required_entries)) {
DPRINTF(QOS,
"%s Write queue full, not accepting\n", __func__);
// Remember that we have to retry this port
retryWrReq = true;
stats.numWriteRetries++;
req_accepted = false;
} else {
// Enqueue the incoming packet into corresponding QoS
// priority queue
writeQueue.at(pkt_priority).push_back(pkt);
queuePolicy->enqueuePacket(pkt);
}
}
if (req_accepted) {
// The packet is accepted - log it
logRequest(pkt->isRead()? READ : WRITE,
pkt->req->requestorId(),
pkt->qosValue(),
pkt->getAddr(),
required_entries);
}
// Check if we have to process next request event
if (!nextReqEvent.scheduled()) {
DPRINTF(QOS,
"%s scheduling next request at "
"time %d (next is %d)\n", __func__,
std::max(curTick(), nextRequest), nextRequest);
schedule(nextReqEvent, std::max(curTick(), nextRequest));
}
return req_accepted;
}
void
MemSinkCtrl::processNextReqEvent()
{
PacketPtr pkt = nullptr;
// Evaluate bus direction
busStateNext = selectNextBusState();
// Record turnaround stats and update current state direction
recordTurnaroundStats(busState, busStateNext);
// Set current bus state
setCurrentBusState();
// Access current direction buffer
std::vector<PacketQueue>* queue_ptr = (busState == READ ? &readQueue :
&writeQueue);
DPRINTF(QOS,
"%s DUMPING %s queues status\n", __func__,
(busState == WRITE ? "WRITE" : "READ"));
if (debug::QOS) {
for (uint8_t i = 0; i < numPriorities(); ++i) {
std::string plist = "";
for (auto& e : (busState == WRITE ? writeQueue[i]: readQueue[i])) {
plist += (std::to_string(e->req->requestorId())) + " ";
}
DPRINTF(QOS,
"%s priority Queue [%i] contains %i elements, "
"packets are: [%s]\n", __func__, i,
busState == WRITE ? writeQueueSizes[i] :
readQueueSizes[i],
plist);
}
}
uint8_t curr_prio = numPriorities();
for (auto queue = (*queue_ptr).rbegin();
queue != (*queue_ptr).rend(); ++queue) {
curr_prio--;
DPRINTF(QOS,
"%s checking %s queue [%d] priority [%d packets]\n",
__func__, (busState == READ? "READ" : "WRITE"),
curr_prio, queue->size());
if (!queue->empty()) {
// Call the queue policy to select packet from priority queue
auto p_it = queuePolicy->selectPacket(&(*queue));
pkt = *p_it;
queue->erase(p_it);
DPRINTF(QOS,
"%s scheduling packet address %d for requestor %s from "
"priority queue %d\n", __func__, pkt->getAddr(),
_system->getRequestorName(pkt->req->requestorId()),
curr_prio);
break;
}
}
assert(pkt);
// Setup next request service time - do it here as retry request
// hands over control to the port
nextRequest = curTick() + requestLatency;
uint64_t removed_entries = divCeil(pkt->getSize(), memoryPacketSize);
DPRINTF(QOS,
"%s scheduled packet address %d for requestor %s size is %d, "
"corresponds to %d memory packets\n", __func__, pkt->getAddr(),
_system->getRequestorName(pkt->req->requestorId()),
pkt->getSize(), removed_entries);
// Schedule response
panic_if(!pkt->needsResponse(),
"%s response not required\n", __func__);
// Do the actual memory access which also turns the packet
// into a response
interface->access(pkt);
// Log the response
logResponse(pkt->isRead()? READ : WRITE,
pkt->req->requestorId(),
pkt->qosValue(),
pkt->getAddr(),
removed_entries, responseLatency);
// Schedule the response
port.schedTimingResp(pkt, curTick() + responseLatency);
DPRINTF(QOS,
"%s response scheduled at time %d\n",
__func__, curTick() + responseLatency);
// Finally - handle retry requests - this handles control
// to the port, so do it last
if (busState == READ && retryRdReq) {
retryRdReq = false;
port.sendRetryReq();
} else if (busState == WRITE && retryWrReq) {
retryWrReq = false;
port.sendRetryReq();
}
// Check if we have to schedule another request event
if ((totalReadQueueSize || totalWriteQueueSize) &&
!nextReqEvent.scheduled()) {
schedule(nextReqEvent, curTick() + requestLatency);
DPRINTF(QOS,
"%s scheduling next request event at tick %d\n",
__func__, curTick() + requestLatency);
}
}
DrainState
MemSinkCtrl::drain()
{
if (totalReadQueueSize || totalWriteQueueSize) {
DPRINTF(Drain,
"%s queues have requests, waiting to drain\n",
__func__);
return DrainState::Draining;
} else {
return DrainState::Drained;
}
}
MemSinkCtrl::MemSinkCtrlStats::MemSinkCtrlStats(statistics::Group *parent)
: statistics::Group(parent),
ADD_STAT(numReadRetries, statistics::units::Count::get(),
"Number of read retries"),
ADD_STAT(numWriteRetries, statistics::units::Count::get(),
"Number of write retries")
{
}
MemSinkCtrl::MemoryPort::MemoryPort(const std::string& n,
MemSinkCtrl& m)
: QueuedResponsePort(n, queue, true),
mem(m), queue(mem, *this, true)
{}
AddrRangeList
MemSinkCtrl::MemoryPort::getAddrRanges() const
{
AddrRangeList ranges;
ranges.push_back(mem.interface->getAddrRange());
return ranges;
}
Tick
MemSinkCtrl::MemoryPort::recvAtomic(PacketPtr pkt)
{
return mem.recvAtomic(pkt);
}
void
MemSinkCtrl::MemoryPort::recvFunctional(PacketPtr pkt)
{
pkt->pushLabel(mem.name());
if (!queue.trySatisfyFunctional(pkt)) {
// Default implementation of SimpleTimingPort::recvFunctional()
// calls recvAtomic() and throws away the latency; we can save a
// little here by just not calculating the latency.
mem.recvFunctional(pkt);
}
pkt->popLabel();
}
bool
MemSinkCtrl::MemoryPort::recvTimingReq(PacketPtr pkt)
{
return mem.recvTimingReq(pkt);
}
MemSinkInterface::MemSinkInterface(const QoSMemSinkInterfaceParams &_p)
: AbstractMemory(_p)
{
}
} // namespace qos
} // namespace memory
} // namespace gem5