noncoherent_xbar.cc revision 11793
1/* 2 * Copyright (c) 2011-2015 ARM Limited 3 * All rights reserved 4 * 5 * The license below extends only to copyright in the software and shall 6 * not be construed as granting a license to any other intellectual 7 * property including but not limited to intellectual property relating 8 * to a hardware implementation of the functionality of the software 9 * licensed hereunder. You may use the software subject to the license 10 * terms below provided that you ensure that this notice is replicated 11 * unmodified and in its entirety in all distributions of the software, 12 * modified or unmodified, in source code or in binary form. 13 * 14 * Copyright (c) 2006 The Regents of The University of Michigan 15 * All rights reserved. 16 * 17 * Redistribution and use in source and binary forms, with or without 18 * modification, are permitted provided that the following conditions are 19 * met: redistributions of source code must retain the above copyright 20 * notice, this list of conditions and the following disclaimer; 21 * redistributions in binary form must reproduce the above copyright 22 * notice, this list of conditions and the following disclaimer in the 23 * documentation and/or other materials provided with the distribution; 24 * neither the name of the copyright holders nor the names of its 25 * contributors may be used to endorse or promote products derived from 26 * this software without specific prior written permission. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 39 * 40 * Authors: Ali Saidi 41 * Andreas Hansson 42 * William Wang 43 */ 44 45/** 46 * @file 47 * Definition of a non-coherent crossbar object. 48 */ 49 50#include "mem/noncoherent_xbar.hh" 51 52#include "base/misc.hh" 53#include "base/trace.hh" 54#include "debug/NoncoherentXBar.hh" 55#include "debug/XBar.hh" 56 57NoncoherentXBar::NoncoherentXBar(const NoncoherentXBarParams *p) 58 : BaseXBar(p) 59{ 60 // create the ports based on the size of the master and slave 61 // vector ports, and the presence of the default port, the ports 62 // are enumerated starting from zero 63 for (int i = 0; i < p->port_master_connection_count; ++i) { 64 std::string portName = csprintf("%s.master[%d]", name(), i); 65 MasterPort* bp = new NoncoherentXBarMasterPort(portName, *this, i); 66 masterPorts.push_back(bp); 67 reqLayers.push_back(new ReqLayer(*bp, *this, 68 csprintf(".reqLayer%d", i))); 69 } 70 71 // see if we have a default slave device connected and if so add 72 // our corresponding master port 73 if (p->port_default_connection_count) { 74 defaultPortID = masterPorts.size(); 75 std::string portName = name() + ".default"; 76 MasterPort* bp = new NoncoherentXBarMasterPort(portName, *this, 77 defaultPortID); 78 masterPorts.push_back(bp); 79 reqLayers.push_back(new ReqLayer(*bp, *this, csprintf(".reqLayer%d", 80 defaultPortID))); 81 } 82 83 // create the slave ports, once again starting at zero 84 for (int i = 0; i < p->port_slave_connection_count; ++i) { 85 std::string portName = csprintf("%s.slave[%d]", name(), i); 86 QueuedSlavePort* bp = new NoncoherentXBarSlavePort(portName, *this, i); 87 slavePorts.push_back(bp); 88 respLayers.push_back(new RespLayer(*bp, *this, 89 csprintf(".respLayer%d", i))); 90 } 91 92 clearPortCache(); 93} 94 95NoncoherentXBar::~NoncoherentXBar() 96{ 97 for (auto l: reqLayers) 98 delete l; 99 for (auto l: respLayers) 100 delete l; 101} 102 103bool 104NoncoherentXBar::recvTimingReq(PacketPtr pkt, PortID slave_port_id) 105{ 106 // determine the source port based on the id 107 SlavePort *src_port = slavePorts[slave_port_id]; 108 109 // we should never see express snoops on a non-coherent crossbar 110 assert(!pkt->isExpressSnoop()); 111 112 // determine the destination based on the address 113 PortID master_port_id = findPort(pkt->getAddr()); 114 115 // test if the layer should be considered occupied for the current 116 // port 117 if (!reqLayers[master_port_id]->tryTiming(src_port)) { 118 DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x BUSY\n", 119 src_port->name(), pkt->cmdString(), pkt->getAddr()); 120 return false; 121 } 122 123 DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x\n", 124 src_port->name(), pkt->cmdString(), pkt->getAddr()); 125 126 // store size and command as they might be modified when 127 // forwarding the packet 128 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 129 unsigned int pkt_cmd = pkt->cmdToIndex(); 130 131 // store the old header delay so we can restore it if needed 132 Tick old_header_delay = pkt->headerDelay; 133 134 // a request sees the frontend and forward latency 135 Tick xbar_delay = (frontendLatency + forwardLatency) * clockPeriod(); 136 137 // set the packet header and payload delay 138 calcPacketTiming(pkt, xbar_delay); 139 140 // determine how long to be crossbar layer is busy 141 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 142 143 // before forwarding the packet (and possibly altering it), 144 // remember if we are expecting a response 145 const bool expect_response = pkt->needsResponse() && 146 !pkt->cacheResponding(); 147 148 // since it is a normal request, attempt to send the packet 149 bool success = masterPorts[master_port_id]->sendTimingReq(pkt); 150 151 if (!success) { 152 DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x RETRY\n", 153 src_port->name(), pkt->cmdString(), pkt->getAddr()); 154 155 // restore the header delay as it is additive 156 pkt->headerDelay = old_header_delay; 157 158 // occupy until the header is sent 159 reqLayers[master_port_id]->failedTiming(src_port, 160 clockEdge(Cycles(1))); 161 162 return false; 163 } 164 165 // remember where to route the response to 166 if (expect_response) { 167 assert(routeTo.find(pkt->req) == routeTo.end()); 168 routeTo[pkt->req] = slave_port_id; 169 } 170 171 reqLayers[master_port_id]->succeededTiming(packetFinishTime); 172 173 // stats updates 174 pktCount[slave_port_id][master_port_id]++; 175 pktSize[slave_port_id][master_port_id] += pkt_size; 176 transDist[pkt_cmd]++; 177 178 return true; 179} 180 181bool 182NoncoherentXBar::recvTimingResp(PacketPtr pkt, PortID master_port_id) 183{ 184 // determine the source port based on the id 185 MasterPort *src_port = masterPorts[master_port_id]; 186 187 // determine the destination 188 const auto route_lookup = routeTo.find(pkt->req); 189 assert(route_lookup != routeTo.end()); 190 const PortID slave_port_id = route_lookup->second; 191 assert(slave_port_id != InvalidPortID); 192 assert(slave_port_id < respLayers.size()); 193 194 // test if the layer should be considered occupied for the current 195 // port 196 if (!respLayers[slave_port_id]->tryTiming(src_port)) { 197 DPRINTF(NoncoherentXBar, "recvTimingResp: src %s %s 0x%x BUSY\n", 198 src_port->name(), pkt->cmdString(), pkt->getAddr()); 199 return false; 200 } 201 202 DPRINTF(NoncoherentXBar, "recvTimingResp: src %s %s 0x%x\n", 203 src_port->name(), pkt->cmdString(), pkt->getAddr()); 204 205 // store size and command as they might be modified when 206 // forwarding the packet 207 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 208 unsigned int pkt_cmd = pkt->cmdToIndex(); 209 210 // a response sees the response latency 211 Tick xbar_delay = responseLatency * clockPeriod(); 212 213 // set the packet header and payload delay 214 calcPacketTiming(pkt, xbar_delay); 215 216 // determine how long to be crossbar layer is busy 217 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 218 219 // send the packet through the destination slave port, and pay for 220 // any outstanding latency 221 Tick latency = pkt->headerDelay; 222 pkt->headerDelay = 0; 223 slavePorts[slave_port_id]->schedTimingResp(pkt, curTick() + latency); 224 225 // remove the request from the routing table 226 routeTo.erase(route_lookup); 227 228 respLayers[slave_port_id]->succeededTiming(packetFinishTime); 229 230 // stats updates 231 pktCount[slave_port_id][master_port_id]++; 232 pktSize[slave_port_id][master_port_id] += pkt_size; 233 transDist[pkt_cmd]++; 234 235 return true; 236} 237 238void 239NoncoherentXBar::recvReqRetry(PortID master_port_id) 240{ 241 // responses never block on forwarding them, so the retry will 242 // always be coming from a port to which we tried to forward a 243 // request 244 reqLayers[master_port_id]->recvRetry(); 245} 246 247Tick 248NoncoherentXBar::recvAtomic(PacketPtr pkt, PortID slave_port_id) 249{ 250 DPRINTF(NoncoherentXBar, "recvAtomic: packet src %s addr 0x%x cmd %s\n", 251 slavePorts[slave_port_id]->name(), pkt->getAddr(), 252 pkt->cmdString()); 253 254 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 255 unsigned int pkt_cmd = pkt->cmdToIndex(); 256 257 // determine the destination port 258 PortID master_port_id = findPort(pkt->getAddr()); 259 260 // stats updates for the request 261 pktCount[slave_port_id][master_port_id]++; 262 pktSize[slave_port_id][master_port_id] += pkt_size; 263 transDist[pkt_cmd]++; 264 265 // forward the request to the appropriate destination 266 Tick response_latency = masterPorts[master_port_id]->sendAtomic(pkt); 267 268 // add the response data 269 if (pkt->isResponse()) { 270 pkt_size = pkt->hasData() ? pkt->getSize() : 0; 271 pkt_cmd = pkt->cmdToIndex(); 272 273 // stats updates 274 pktCount[slave_port_id][master_port_id]++; 275 pktSize[slave_port_id][master_port_id] += pkt_size; 276 transDist[pkt_cmd]++; 277 } 278 279 // @todo: Not setting first-word time 280 pkt->payloadDelay = response_latency; 281 return response_latency; 282} 283 284void 285NoncoherentXBar::recvFunctional(PacketPtr pkt, PortID slave_port_id) 286{ 287 if (!pkt->isPrint()) { 288 // don't do DPRINTFs on PrintReq as it clutters up the output 289 DPRINTF(NoncoherentXBar, 290 "recvFunctional: packet src %s addr 0x%x cmd %s\n", 291 slavePorts[slave_port_id]->name(), pkt->getAddr(), 292 pkt->cmdString()); 293 } 294 295 // since our slave ports are queued ports we need to check them as well 296 for (const auto& p : slavePorts) { 297 // if we find a response that has the data, then the 298 // downstream caches/memories may be out of date, so simply stop 299 // here 300 if (p->checkFunctional(pkt)) { 301 if (pkt->needsResponse()) 302 pkt->makeResponse(); 303 return; 304 } 305 } 306 307 // determine the destination port 308 PortID dest_id = findPort(pkt->getAddr()); 309 310 // forward the request to the appropriate destination 311 masterPorts[dest_id]->sendFunctional(pkt); 312} 313 314NoncoherentXBar* 315NoncoherentXBarParams::create() 316{ 317 return new NoncoherentXBar(this); 318} 319 320void 321NoncoherentXBar::regStats() 322{ 323 // register the stats of the base class and our layers 324 BaseXBar::regStats(); 325 for (auto l: reqLayers) 326 l->regStats(); 327 for (auto l: respLayers) 328 l->regStats(); 329} 330