noncoherent_xbar.cc revision 11284
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 "base/misc.hh" 51#include "base/trace.hh" 52#include "debug/NoncoherentXBar.hh" 53#include "debug/XBar.hh" 54#include "mem/noncoherent_xbar.hh" 55 56NoncoherentXBar::NoncoherentXBar(const NoncoherentXBarParams *p) 57 : BaseXBar(p) 58{ 59 // create the ports based on the size of the master and slave 60 // vector ports, and the presence of the default port, the ports 61 // are enumerated starting from zero 62 for (int i = 0; i < p->port_master_connection_count; ++i) { 63 std::string portName = csprintf("%s.master[%d]", name(), i); 64 MasterPort* bp = new NoncoherentXBarMasterPort(portName, *this, i); 65 masterPorts.push_back(bp); 66 reqLayers.push_back(new ReqLayer(*bp, *this, 67 csprintf(".reqLayer%d", i))); 68 } 69 70 // see if we have a default slave device connected and if so add 71 // our corresponding master port 72 if (p->port_default_connection_count) { 73 defaultPortID = masterPorts.size(); 74 std::string portName = name() + ".default"; 75 MasterPort* bp = new NoncoherentXBarMasterPort(portName, *this, 76 defaultPortID); 77 masterPorts.push_back(bp); 78 reqLayers.push_back(new ReqLayer(*bp, *this, csprintf(".reqLayer%d", 79 defaultPortID))); 80 } 81 82 // create the slave ports, once again starting at zero 83 for (int i = 0; i < p->port_slave_connection_count; ++i) { 84 std::string portName = csprintf("%s.slave[%d]", name(), i); 85 QueuedSlavePort* bp = new NoncoherentXBarSlavePort(portName, *this, i); 86 slavePorts.push_back(bp); 87 respLayers.push_back(new RespLayer(*bp, *this, 88 csprintf(".respLayer%d", i))); 89 } 90 91 clearPortCache(); 92} 93 94NoncoherentXBar::~NoncoherentXBar() 95{ 96 for (auto l: reqLayers) 97 delete l; 98 for (auto l: respLayers) 99 delete l; 100} 101 102bool 103NoncoherentXBar::recvTimingReq(PacketPtr pkt, PortID slave_port_id) 104{ 105 // determine the source port based on the id 106 SlavePort *src_port = slavePorts[slave_port_id]; 107 108 // we should never see express snoops on a non-coherent crossbar 109 assert(!pkt->isExpressSnoop()); 110 111 // determine the destination based on the address 112 PortID master_port_id = findPort(pkt->getAddr()); 113 114 // test if the layer should be considered occupied for the current 115 // port 116 if (!reqLayers[master_port_id]->tryTiming(src_port)) { 117 DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x BUSY\n", 118 src_port->name(), pkt->cmdString(), pkt->getAddr()); 119 return false; 120 } 121 122 DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x\n", 123 src_port->name(), pkt->cmdString(), pkt->getAddr()); 124 125 // store size and command as they might be modified when 126 // forwarding the packet 127 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 128 unsigned int pkt_cmd = pkt->cmdToIndex(); 129 130 // store the old header delay so we can restore it if needed 131 Tick old_header_delay = pkt->headerDelay; 132 133 // a request sees the frontend and forward latency 134 Tick xbar_delay = (frontendLatency + forwardLatency) * clockPeriod(); 135 136 // set the packet header and payload delay 137 calcPacketTiming(pkt, xbar_delay); 138 139 // determine how long to be crossbar layer is busy 140 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 141 142 // before forwarding the packet (and possibly altering it), 143 // remember if we are expecting a response 144 const bool expect_response = pkt->needsResponse() && 145 !pkt->cacheResponding(); 146 147 // since it is a normal request, attempt to send the packet 148 bool success = masterPorts[master_port_id]->sendTimingReq(pkt); 149 150 if (!success) { 151 DPRINTF(NoncoherentXBar, "recvTimingReq: src %s %s 0x%x RETRY\n", 152 src_port->name(), pkt->cmdString(), pkt->getAddr()); 153 154 // restore the header delay as it is additive 155 pkt->headerDelay = old_header_delay; 156 157 // occupy until the header is sent 158 reqLayers[master_port_id]->failedTiming(src_port, 159 clockEdge(Cycles(1))); 160 161 return false; 162 } 163 164 // remember where to route the response to 165 if (expect_response) { 166 assert(routeTo.find(pkt->req) == routeTo.end()); 167 routeTo[pkt->req] = slave_port_id; 168 } 169 170 reqLayers[master_port_id]->succeededTiming(packetFinishTime); 171 172 // stats updates 173 pktCount[slave_port_id][master_port_id]++; 174 pktSize[slave_port_id][master_port_id] += pkt_size; 175 transDist[pkt_cmd]++; 176 177 return true; 178} 179 180bool 181NoncoherentXBar::recvTimingResp(PacketPtr pkt, PortID master_port_id) 182{ 183 // determine the source port based on the id 184 MasterPort *src_port = masterPorts[master_port_id]; 185 186 // determine the destination 187 const auto route_lookup = routeTo.find(pkt->req); 188 assert(route_lookup != routeTo.end()); 189 const PortID slave_port_id = route_lookup->second; 190 assert(slave_port_id != InvalidPortID); 191 assert(slave_port_id < respLayers.size()); 192 193 // test if the layer should be considered occupied for the current 194 // port 195 if (!respLayers[slave_port_id]->tryTiming(src_port)) { 196 DPRINTF(NoncoherentXBar, "recvTimingResp: src %s %s 0x%x BUSY\n", 197 src_port->name(), pkt->cmdString(), pkt->getAddr()); 198 return false; 199 } 200 201 DPRINTF(NoncoherentXBar, "recvTimingResp: src %s %s 0x%x\n", 202 src_port->name(), pkt->cmdString(), pkt->getAddr()); 203 204 // store size and command as they might be modified when 205 // forwarding the packet 206 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 207 unsigned int pkt_cmd = pkt->cmdToIndex(); 208 209 // a response sees the response latency 210 Tick xbar_delay = responseLatency * clockPeriod(); 211 212 // set the packet header and payload delay 213 calcPacketTiming(pkt, xbar_delay); 214 215 // determine how long to be crossbar layer is busy 216 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 217 218 // send the packet through the destination slave port, and pay for 219 // any outstanding latency 220 Tick latency = pkt->headerDelay; 221 pkt->headerDelay = 0; 222 slavePorts[slave_port_id]->schedTimingResp(pkt, curTick() + latency); 223 224 // remove the request from the routing table 225 routeTo.erase(route_lookup); 226 227 respLayers[slave_port_id]->succeededTiming(packetFinishTime); 228 229 // stats updates 230 pktCount[slave_port_id][master_port_id]++; 231 pktSize[slave_port_id][master_port_id] += pkt_size; 232 transDist[pkt_cmd]++; 233 234 return true; 235} 236 237void 238NoncoherentXBar::recvReqRetry(PortID master_port_id) 239{ 240 // responses never block on forwarding them, so the retry will 241 // always be coming from a port to which we tried to forward a 242 // request 243 reqLayers[master_port_id]->recvRetry(); 244} 245 246Tick 247NoncoherentXBar::recvAtomic(PacketPtr pkt, PortID slave_port_id) 248{ 249 DPRINTF(NoncoherentXBar, "recvAtomic: packet src %s addr 0x%x cmd %s\n", 250 slavePorts[slave_port_id]->name(), pkt->getAddr(), 251 pkt->cmdString()); 252 253 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 254 unsigned int pkt_cmd = pkt->cmdToIndex(); 255 256 // determine the destination port 257 PortID master_port_id = findPort(pkt->getAddr()); 258 259 // stats updates for the request 260 pktCount[slave_port_id][master_port_id]++; 261 pktSize[slave_port_id][master_port_id] += pkt_size; 262 transDist[pkt_cmd]++; 263 264 // forward the request to the appropriate destination 265 Tick response_latency = masterPorts[master_port_id]->sendAtomic(pkt); 266 267 // add the response data 268 if (pkt->isResponse()) { 269 pkt_size = pkt->hasData() ? pkt->getSize() : 0; 270 pkt_cmd = pkt->cmdToIndex(); 271 272 // stats updates 273 pktCount[slave_port_id][master_port_id]++; 274 pktSize[slave_port_id][master_port_id] += pkt_size; 275 transDist[pkt_cmd]++; 276 } 277 278 // @todo: Not setting first-word time 279 pkt->payloadDelay = response_latency; 280 return response_latency; 281} 282 283void 284NoncoherentXBar::recvFunctional(PacketPtr pkt, PortID slave_port_id) 285{ 286 if (!pkt->isPrint()) { 287 // don't do DPRINTFs on PrintReq as it clutters up the output 288 DPRINTF(NoncoherentXBar, 289 "recvFunctional: packet src %s addr 0x%x cmd %s\n", 290 slavePorts[slave_port_id]->name(), pkt->getAddr(), 291 pkt->cmdString()); 292 } 293 294 // since our slave ports are queued ports we need to check them as well 295 for (const auto& p : slavePorts) { 296 // if we find a response that has the data, then the 297 // downstream caches/memories may be out of date, so simply stop 298 // here 299 if (p->checkFunctional(pkt)) { 300 if (pkt->needsResponse()) 301 pkt->makeResponse(); 302 return; 303 } 304 } 305 306 // determine the destination port 307 PortID dest_id = findPort(pkt->getAddr()); 308 309 // forward the request to the appropriate destination 310 masterPorts[dest_id]->sendFunctional(pkt); 311} 312 313NoncoherentXBar* 314NoncoherentXBarParams::create() 315{ 316 return new NoncoherentXBar(this); 317} 318 319void 320NoncoherentXBar::regStats() 321{ 322 // register the stats of the base class and our layers 323 BaseXBar::regStats(); 324 for (auto l: reqLayers) 325 l->regStats(); 326 for (auto l: respLayers) 327 l->regStats(); 328} 329