coherent_xbar.cc revision 10883
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 crossbar object. 48 */ 49 50#include "base/misc.hh" 51#include "base/trace.hh" 52#include "debug/AddrRanges.hh" 53#include "debug/CoherentXBar.hh" 54#include "mem/coherent_xbar.hh" 55#include "sim/system.hh" 56 57CoherentXBar::CoherentXBar(const CoherentXBarParams *p) 58 : BaseXBar(p), system(p->system), snoopFilter(p->snoop_filter), 59 snoopResponseLatency(p->snoop_response_latency) 60{ 61 // create the ports based on the size of the master and slave 62 // vector ports, and the presence of the default port, the ports 63 // are enumerated starting from zero 64 for (int i = 0; i < p->port_master_connection_count; ++i) { 65 std::string portName = csprintf("%s.master[%d]", name(), i); 66 MasterPort* bp = new CoherentXBarMasterPort(portName, *this, i); 67 masterPorts.push_back(bp); 68 reqLayers.push_back(new ReqLayer(*bp, *this, 69 csprintf(".reqLayer%d", i))); 70 snoopLayers.push_back(new SnoopRespLayer(*bp, *this, 71 csprintf(".snoopLayer%d", i))); 72 } 73 74 // see if we have a default slave device connected and if so add 75 // our corresponding master port 76 if (p->port_default_connection_count) { 77 defaultPortID = masterPorts.size(); 78 std::string portName = name() + ".default"; 79 MasterPort* bp = new CoherentXBarMasterPort(portName, *this, 80 defaultPortID); 81 masterPorts.push_back(bp); 82 reqLayers.push_back(new ReqLayer(*bp, *this, csprintf(".reqLayer%d", 83 defaultPortID))); 84 snoopLayers.push_back(new SnoopRespLayer(*bp, *this, 85 csprintf(".snoopLayer%d", 86 defaultPortID))); 87 } 88 89 // create the slave ports, once again starting at zero 90 for (int i = 0; i < p->port_slave_connection_count; ++i) { 91 std::string portName = csprintf("%s.slave[%d]", name(), i); 92 SlavePort* bp = new CoherentXBarSlavePort(portName, *this, i); 93 slavePorts.push_back(bp); 94 respLayers.push_back(new RespLayer(*bp, *this, 95 csprintf(".respLayer%d", i))); 96 snoopRespPorts.push_back(new SnoopRespPort(*bp, *this)); 97 } 98 99 if (snoopFilter) 100 snoopFilter->setSlavePorts(slavePorts); 101 102 clearPortCache(); 103} 104 105CoherentXBar::~CoherentXBar() 106{ 107 for (auto l: reqLayers) 108 delete l; 109 for (auto l: respLayers) 110 delete l; 111 for (auto l: snoopLayers) 112 delete l; 113 for (auto p: snoopRespPorts) 114 delete p; 115} 116 117void 118CoherentXBar::init() 119{ 120 // the base class is responsible for determining the block size 121 BaseXBar::init(); 122 123 // iterate over our slave ports and determine which of our 124 // neighbouring master ports are snooping and add them as snoopers 125 for (const auto& p: slavePorts) { 126 // check if the connected master port is snooping 127 if (p->isSnooping()) { 128 DPRINTF(AddrRanges, "Adding snooping master %s\n", 129 p->getMasterPort().name()); 130 snoopPorts.push_back(p); 131 } 132 } 133 134 if (snoopPorts.empty()) 135 warn("CoherentXBar %s has no snooping ports attached!\n", name()); 136} 137 138bool 139CoherentXBar::recvTimingReq(PacketPtr pkt, PortID slave_port_id) 140{ 141 // @todo temporary hack to deal with memory corruption issue until 142 // 4-phase transactions are complete 143 for (int x = 0; x < pendingDelete.size(); x++) 144 delete pendingDelete[x]; 145 pendingDelete.clear(); 146 147 // determine the source port based on the id 148 SlavePort *src_port = slavePorts[slave_port_id]; 149 150 // remember if the packet is an express snoop 151 bool is_express_snoop = pkt->isExpressSnoop(); 152 bool is_inhibited = pkt->memInhibitAsserted(); 153 // for normal requests, going downstream, the express snoop flag 154 // and the inhibited flag should always be the same 155 assert(is_express_snoop == is_inhibited); 156 157 // determine the destination based on the address 158 PortID master_port_id = findPort(pkt->getAddr()); 159 160 // test if the crossbar should be considered occupied for the current 161 // port, and exclude express snoops from the check 162 if (!is_express_snoop && !reqLayers[master_port_id]->tryTiming(src_port)) { 163 DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x BUSY\n", 164 src_port->name(), pkt->cmdString(), pkt->getAddr()); 165 return false; 166 } 167 168 DPRINTF(CoherentXBar, "recvTimingReq: src %s %s expr %d 0x%x\n", 169 src_port->name(), pkt->cmdString(), is_express_snoop, 170 pkt->getAddr()); 171 172 // store size and command as they might be modified when 173 // forwarding the packet 174 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 175 unsigned int pkt_cmd = pkt->cmdToIndex(); 176 177 // store the old header delay so we can restore it if needed 178 Tick old_header_delay = pkt->headerDelay; 179 180 // a request sees the frontend and forward latency 181 Tick xbar_delay = (frontendLatency + forwardLatency) * clockPeriod(); 182 183 // set the packet header and payload delay 184 calcPacketTiming(pkt, xbar_delay); 185 186 // determine how long to be crossbar layer is busy 187 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 188 189 if (!system->bypassCaches()) { 190 // the packet is a memory-mapped request and should be 191 // broadcasted to our snoopers but the source 192 if (snoopFilter) { 193 // check with the snoop filter where to forward this packet 194 auto sf_res = snoopFilter->lookupRequest(pkt, *src_port); 195 // If SnoopFilter is enabled, the total time required by a packet 196 // to be delivered through the xbar has to be charged also with 197 // to lookup latency of the snoop filter (sf_res.second). 198 pkt->headerDelay += sf_res.second * clockPeriod(); 199 packetFinishTime += sf_res.second * clockPeriod(); 200 DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x"\ 201 " SF size: %i lat: %i\n", src_port->name(), 202 pkt->cmdString(), pkt->getAddr(), sf_res.first.size(), 203 sf_res.second); 204 forwardTiming(pkt, slave_port_id, sf_res.first); 205 } else { 206 forwardTiming(pkt, slave_port_id); 207 } 208 } 209 210 // forwardTiming snooped into peer caches of the sender, and if 211 // this is a clean evict, but the packet is found in a cache, do 212 // not forward it 213 if (pkt->cmd == MemCmd::CleanEvict && pkt->isBlockCached()) { 214 DPRINTF(CoherentXBar, "recvTimingReq: Clean evict 0x%x still cached, " 215 "not forwarding\n", pkt->getAddr()); 216 217 // update the layer state and schedule an idle event 218 reqLayers[master_port_id]->succeededTiming(packetFinishTime); 219 pendingDelete.push_back(pkt); 220 return true; 221 } 222 223 // remember if the packet will generate a snoop response 224 const bool expect_snoop_resp = !is_inhibited && pkt->memInhibitAsserted(); 225 const bool expect_response = pkt->needsResponse() && 226 !pkt->memInhibitAsserted(); 227 228 // Note: Cannot create a copy of the full packet, here. 229 MemCmd orig_cmd(pkt->cmd); 230 231 // since it is a normal request, attempt to send the packet 232 bool success = masterPorts[master_port_id]->sendTimingReq(pkt); 233 234 if (snoopFilter && !system->bypassCaches()) { 235 // The packet may already be overwritten by the sendTimingReq function. 236 // The snoop filter needs to see the original request *and* the return 237 // status of the send operation, so we need to recreate the original 238 // request. Atomic mode does not have the issue, as there the send 239 // operation and the response happen instantaneously and don't need two 240 // phase tracking. 241 MemCmd tmp_cmd(pkt->cmd); 242 pkt->cmd = orig_cmd; 243 // Let the snoop filter know about the success of the send operation 244 snoopFilter->updateRequest(pkt, *src_port, !success); 245 pkt->cmd = tmp_cmd; 246 } 247 248 // check if we were successful in sending the packet onwards 249 if (!success) { 250 // express snoops and inhibited packets should never be forced 251 // to retry 252 assert(!is_express_snoop); 253 assert(!pkt->memInhibitAsserted()); 254 255 // restore the header delay 256 pkt->headerDelay = old_header_delay; 257 258 DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x RETRY\n", 259 src_port->name(), pkt->cmdString(), pkt->getAddr()); 260 261 // update the layer state and schedule an idle event 262 reqLayers[master_port_id]->failedTiming(src_port, 263 clockEdge(Cycles(1))); 264 } else { 265 // express snoops currently bypass the crossbar state entirely 266 if (!is_express_snoop) { 267 // if this particular request will generate a snoop 268 // response 269 if (expect_snoop_resp) { 270 // we should never have an exsiting request outstanding 271 assert(outstandingSnoop.find(pkt->req) == 272 outstandingSnoop.end()); 273 outstandingSnoop.insert(pkt->req); 274 275 // basic sanity check on the outstanding snoops 276 panic_if(outstandingSnoop.size() > 512, 277 "Outstanding snoop requests exceeded 512\n"); 278 } 279 280 // remember where to route the normal response to 281 if (expect_response || expect_snoop_resp) { 282 assert(routeTo.find(pkt->req) == routeTo.end()); 283 routeTo[pkt->req] = slave_port_id; 284 285 panic_if(routeTo.size() > 512, 286 "Routing table exceeds 512 packets\n"); 287 } 288 289 // update the layer state and schedule an idle event 290 reqLayers[master_port_id]->succeededTiming(packetFinishTime); 291 } 292 293 // stats updates only consider packets that were successfully sent 294 pktCount[slave_port_id][master_port_id]++; 295 pktSize[slave_port_id][master_port_id] += pkt_size; 296 transDist[pkt_cmd]++; 297 298 if (is_express_snoop) 299 snoops++; 300 } 301 302 return success; 303} 304 305bool 306CoherentXBar::recvTimingResp(PacketPtr pkt, PortID master_port_id) 307{ 308 // determine the source port based on the id 309 MasterPort *src_port = masterPorts[master_port_id]; 310 311 // determine the destination 312 const auto route_lookup = routeTo.find(pkt->req); 313 assert(route_lookup != routeTo.end()); 314 const PortID slave_port_id = route_lookup->second; 315 assert(slave_port_id != InvalidPortID); 316 assert(slave_port_id < respLayers.size()); 317 318 // test if the crossbar should be considered occupied for the 319 // current port 320 if (!respLayers[slave_port_id]->tryTiming(src_port)) { 321 DPRINTF(CoherentXBar, "recvTimingResp: src %s %s 0x%x BUSY\n", 322 src_port->name(), pkt->cmdString(), pkt->getAddr()); 323 return false; 324 } 325 326 DPRINTF(CoherentXBar, "recvTimingResp: src %s %s 0x%x\n", 327 src_port->name(), pkt->cmdString(), pkt->getAddr()); 328 329 // store size and command as they might be modified when 330 // forwarding the packet 331 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 332 unsigned int pkt_cmd = pkt->cmdToIndex(); 333 334 // a response sees the response latency 335 Tick xbar_delay = responseLatency * clockPeriod(); 336 337 // set the packet header and payload delay 338 calcPacketTiming(pkt, xbar_delay); 339 340 // determine how long to be crossbar layer is busy 341 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 342 343 if (snoopFilter && !system->bypassCaches()) { 344 // let the snoop filter inspect the response and update its state 345 snoopFilter->updateResponse(pkt, *slavePorts[slave_port_id]); 346 } 347 348 // send the packet through the destination slave port 349 bool success M5_VAR_USED = slavePorts[slave_port_id]->sendTimingResp(pkt); 350 351 // currently it is illegal to block responses... can lead to 352 // deadlock 353 assert(success); 354 355 // remove the request from the routing table 356 routeTo.erase(route_lookup); 357 358 respLayers[slave_port_id]->succeededTiming(packetFinishTime); 359 360 // stats updates 361 pktCount[slave_port_id][master_port_id]++; 362 pktSize[slave_port_id][master_port_id] += pkt_size; 363 transDist[pkt_cmd]++; 364 365 return true; 366} 367 368void 369CoherentXBar::recvTimingSnoopReq(PacketPtr pkt, PortID master_port_id) 370{ 371 DPRINTF(CoherentXBar, "recvTimingSnoopReq: src %s %s 0x%x\n", 372 masterPorts[master_port_id]->name(), pkt->cmdString(), 373 pkt->getAddr()); 374 375 // update stats here as we know the forwarding will succeed 376 transDist[pkt->cmdToIndex()]++; 377 snoops++; 378 379 // we should only see express snoops from caches 380 assert(pkt->isExpressSnoop()); 381 382 // remeber if the packet is inhibited so we can see if it changes 383 const bool is_inhibited = pkt->memInhibitAsserted(); 384 385 if (snoopFilter) { 386 // let the Snoop Filter work its magic and guide probing 387 auto sf_res = snoopFilter->lookupSnoop(pkt); 388 // No timing here: packetFinishTime += sf_res.second * clockPeriod(); 389 DPRINTF(CoherentXBar, "recvTimingSnoopReq: src %s %s 0x%x"\ 390 " SF size: %i lat: %i\n", masterPorts[master_port_id]->name(), 391 pkt->cmdString(), pkt->getAddr(), sf_res.first.size(), 392 sf_res.second); 393 394 // forward to all snoopers 395 forwardTiming(pkt, InvalidPortID, sf_res.first); 396 } else { 397 forwardTiming(pkt, InvalidPortID); 398 } 399 400 // if we can expect a response, remember how to route it 401 if (!is_inhibited && pkt->memInhibitAsserted()) { 402 assert(routeTo.find(pkt->req) == routeTo.end()); 403 routeTo[pkt->req] = master_port_id; 404 } 405 406 // a snoop request came from a connected slave device (one of 407 // our master ports), and if it is not coming from the slave 408 // device responsible for the address range something is 409 // wrong, hence there is nothing further to do as the packet 410 // would be going back to where it came from 411 assert(master_port_id == findPort(pkt->getAddr())); 412} 413 414bool 415CoherentXBar::recvTimingSnoopResp(PacketPtr pkt, PortID slave_port_id) 416{ 417 // determine the source port based on the id 418 SlavePort* src_port = slavePorts[slave_port_id]; 419 420 // get the destination 421 const auto route_lookup = routeTo.find(pkt->req); 422 assert(route_lookup != routeTo.end()); 423 const PortID dest_port_id = route_lookup->second; 424 assert(dest_port_id != InvalidPortID); 425 426 // determine if the response is from a snoop request we 427 // created as the result of a normal request (in which case it 428 // should be in the outstandingSnoop), or if we merely forwarded 429 // someone else's snoop request 430 const bool forwardAsSnoop = outstandingSnoop.find(pkt->req) == 431 outstandingSnoop.end(); 432 433 // test if the crossbar should be considered occupied for the 434 // current port, note that the check is bypassed if the response 435 // is being passed on as a normal response since this is occupying 436 // the response layer rather than the snoop response layer 437 if (forwardAsSnoop) { 438 assert(dest_port_id < snoopLayers.size()); 439 if (!snoopLayers[dest_port_id]->tryTiming(src_port)) { 440 DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x BUSY\n", 441 src_port->name(), pkt->cmdString(), pkt->getAddr()); 442 return false; 443 } 444 } else { 445 // get the master port that mirrors this slave port internally 446 MasterPort* snoop_port = snoopRespPorts[slave_port_id]; 447 assert(dest_port_id < respLayers.size()); 448 if (!respLayers[dest_port_id]->tryTiming(snoop_port)) { 449 DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x BUSY\n", 450 snoop_port->name(), pkt->cmdString(), pkt->getAddr()); 451 return false; 452 } 453 } 454 455 DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x\n", 456 src_port->name(), pkt->cmdString(), pkt->getAddr()); 457 458 // store size and command as they might be modified when 459 // forwarding the packet 460 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 461 unsigned int pkt_cmd = pkt->cmdToIndex(); 462 463 // responses are never express snoops 464 assert(!pkt->isExpressSnoop()); 465 466 // a snoop response sees the snoop response latency, and if it is 467 // forwarded as a normal response, the response latency 468 Tick xbar_delay = 469 (forwardAsSnoop ? snoopResponseLatency : responseLatency) * 470 clockPeriod(); 471 472 // set the packet header and payload delay 473 calcPacketTiming(pkt, xbar_delay); 474 475 // determine how long to be crossbar layer is busy 476 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 477 478 // forward it either as a snoop response or a normal response 479 if (forwardAsSnoop) { 480 // this is a snoop response to a snoop request we forwarded, 481 // e.g. coming from the L1 and going to the L2, and it should 482 // be forwarded as a snoop response 483 484 if (snoopFilter) { 485 // update the probe filter so that it can properly track the line 486 snoopFilter->updateSnoopForward(pkt, *slavePorts[slave_port_id], 487 *masterPorts[dest_port_id]); 488 } 489 490 bool success M5_VAR_USED = 491 masterPorts[dest_port_id]->sendTimingSnoopResp(pkt); 492 pktCount[slave_port_id][dest_port_id]++; 493 pktSize[slave_port_id][dest_port_id] += pkt_size; 494 assert(success); 495 496 snoopLayers[dest_port_id]->succeededTiming(packetFinishTime); 497 } else { 498 // we got a snoop response on one of our slave ports, 499 // i.e. from a coherent master connected to the crossbar, and 500 // since we created the snoop request as part of recvTiming, 501 // this should now be a normal response again 502 outstandingSnoop.erase(pkt->req); 503 504 // this is a snoop response from a coherent master, hence it 505 // should never go back to where the snoop response came from, 506 // but instead to where the original request came from 507 assert(slave_port_id != dest_port_id); 508 509 if (snoopFilter) { 510 // update the probe filter so that it can properly track the line 511 snoopFilter->updateSnoopResponse(pkt, *slavePorts[slave_port_id], 512 *slavePorts[dest_port_id]); 513 } 514 515 DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x"\ 516 " FWD RESP\n", src_port->name(), pkt->cmdString(), 517 pkt->getAddr()); 518 519 // as a normal response, it should go back to a master through 520 // one of our slave ports, at this point we are ignoring the 521 // fact that the response layer could be busy and do not touch 522 // its state 523 bool success M5_VAR_USED = 524 slavePorts[dest_port_id]->sendTimingResp(pkt); 525 526 // @todo Put the response in an internal FIFO and pass it on 527 // to the response layer from there 528 529 // currently it is illegal to block responses... can lead 530 // to deadlock 531 assert(success); 532 533 respLayers[dest_port_id]->succeededTiming(packetFinishTime); 534 } 535 536 // remove the request from the routing table 537 routeTo.erase(route_lookup); 538 539 // stats updates 540 transDist[pkt_cmd]++; 541 snoops++; 542 543 return true; 544} 545 546 547void 548CoherentXBar::forwardTiming(PacketPtr pkt, PortID exclude_slave_port_id, 549 const std::vector<SlavePort*>& dests) 550{ 551 DPRINTF(CoherentXBar, "%s for %s address %x size %d\n", __func__, 552 pkt->cmdString(), pkt->getAddr(), pkt->getSize()); 553 554 // snoops should only happen if the system isn't bypassing caches 555 assert(!system->bypassCaches()); 556 557 unsigned fanout = 0; 558 559 for (const auto& p: dests) { 560 // we could have gotten this request from a snooping master 561 // (corresponding to our own slave port that is also in 562 // snoopPorts) and should not send it back to where it came 563 // from 564 if (exclude_slave_port_id == InvalidPortID || 565 p->getId() != exclude_slave_port_id) { 566 // cache is not allowed to refuse snoop 567 p->sendTimingSnoopReq(pkt); 568 fanout++; 569 } 570 } 571 572 // Stats for fanout of this forward operation 573 snoopFanout.sample(fanout); 574} 575 576void 577CoherentXBar::recvReqRetry(PortID master_port_id) 578{ 579 // responses and snoop responses never block on forwarding them, 580 // so the retry will always be coming from a port to which we 581 // tried to forward a request 582 reqLayers[master_port_id]->recvRetry(); 583} 584 585Tick 586CoherentXBar::recvAtomic(PacketPtr pkt, PortID slave_port_id) 587{ 588 DPRINTF(CoherentXBar, "recvAtomic: packet src %s addr 0x%x cmd %s\n", 589 slavePorts[slave_port_id]->name(), pkt->getAddr(), 590 pkt->cmdString()); 591 592 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 593 unsigned int pkt_cmd = pkt->cmdToIndex(); 594 595 MemCmd snoop_response_cmd = MemCmd::InvalidCmd; 596 Tick snoop_response_latency = 0; 597 598 if (!system->bypassCaches()) { 599 // forward to all snoopers but the source 600 std::pair<MemCmd, Tick> snoop_result; 601 if (snoopFilter) { 602 // check with the snoop filter where to forward this packet 603 auto sf_res = 604 snoopFilter->lookupRequest(pkt, *slavePorts[slave_port_id]); 605 snoop_response_latency += sf_res.second * clockPeriod(); 606 DPRINTF(CoherentXBar, "%s: src %s %s 0x%x"\ 607 " SF size: %i lat: %i\n", __func__, 608 slavePorts[slave_port_id]->name(), pkt->cmdString(), 609 pkt->getAddr(), sf_res.first.size(), sf_res.second); 610 snoop_result = forwardAtomic(pkt, slave_port_id, InvalidPortID, 611 sf_res.first); 612 } else { 613 snoop_result = forwardAtomic(pkt, slave_port_id); 614 } 615 snoop_response_cmd = snoop_result.first; 616 snoop_response_latency += snoop_result.second; 617 } 618 619 // even if we had a snoop response, we must continue and also 620 // perform the actual request at the destination 621 PortID master_port_id = findPort(pkt->getAddr()); 622 623 // stats updates for the request 624 pktCount[slave_port_id][master_port_id]++; 625 pktSize[slave_port_id][master_port_id] += pkt_size; 626 transDist[pkt_cmd]++; 627 628 // forward the request to the appropriate destination 629 Tick response_latency = masterPorts[master_port_id]->sendAtomic(pkt); 630 631 // Lower levels have replied, tell the snoop filter 632 if (snoopFilter && !system->bypassCaches() && pkt->isResponse()) { 633 snoopFilter->updateResponse(pkt, *slavePorts[slave_port_id]); 634 } 635 636 // if we got a response from a snooper, restore it here 637 if (snoop_response_cmd != MemCmd::InvalidCmd) { 638 // no one else should have responded 639 assert(!pkt->isResponse()); 640 pkt->cmd = snoop_response_cmd; 641 response_latency = snoop_response_latency; 642 } 643 644 // add the response data 645 if (pkt->isResponse()) { 646 pkt_size = pkt->hasData() ? pkt->getSize() : 0; 647 pkt_cmd = pkt->cmdToIndex(); 648 649 // stats updates 650 pktCount[slave_port_id][master_port_id]++; 651 pktSize[slave_port_id][master_port_id] += pkt_size; 652 transDist[pkt_cmd]++; 653 } 654 655 // @todo: Not setting header time 656 pkt->payloadDelay = response_latency; 657 return response_latency; 658} 659 660Tick 661CoherentXBar::recvAtomicSnoop(PacketPtr pkt, PortID master_port_id) 662{ 663 DPRINTF(CoherentXBar, "recvAtomicSnoop: packet src %s addr 0x%x cmd %s\n", 664 masterPorts[master_port_id]->name(), pkt->getAddr(), 665 pkt->cmdString()); 666 667 // add the request snoop data 668 snoops++; 669 670 // forward to all snoopers 671 std::pair<MemCmd, Tick> snoop_result; 672 Tick snoop_response_latency = 0; 673 if (snoopFilter) { 674 auto sf_res = snoopFilter->lookupSnoop(pkt); 675 snoop_response_latency += sf_res.second * clockPeriod(); 676 DPRINTF(CoherentXBar, "%s: src %s %s 0x%x SF size: %i lat: %i\n", 677 __func__, masterPorts[master_port_id]->name(), pkt->cmdString(), 678 pkt->getAddr(), sf_res.first.size(), sf_res.second); 679 snoop_result = forwardAtomic(pkt, InvalidPortID, master_port_id, 680 sf_res.first); 681 } else { 682 snoop_result = forwardAtomic(pkt, InvalidPortID); 683 } 684 MemCmd snoop_response_cmd = snoop_result.first; 685 snoop_response_latency += snoop_result.second; 686 687 if (snoop_response_cmd != MemCmd::InvalidCmd) 688 pkt->cmd = snoop_response_cmd; 689 690 // add the response snoop data 691 if (pkt->isResponse()) { 692 snoops++; 693 } 694 695 // @todo: Not setting header time 696 pkt->payloadDelay = snoop_response_latency; 697 return snoop_response_latency; 698} 699 700std::pair<MemCmd, Tick> 701CoherentXBar::forwardAtomic(PacketPtr pkt, PortID exclude_slave_port_id, 702 PortID source_master_port_id, 703 const std::vector<SlavePort*>& dests) 704{ 705 // the packet may be changed on snoops, record the original 706 // command to enable us to restore it between snoops so that 707 // additional snoops can take place properly 708 MemCmd orig_cmd = pkt->cmd; 709 MemCmd snoop_response_cmd = MemCmd::InvalidCmd; 710 Tick snoop_response_latency = 0; 711 712 // snoops should only happen if the system isn't bypassing caches 713 assert(!system->bypassCaches()); 714 715 unsigned fanout = 0; 716 717 for (const auto& p: dests) { 718 // we could have gotten this request from a snooping master 719 // (corresponding to our own slave port that is also in 720 // snoopPorts) and should not send it back to where it came 721 // from 722 if (exclude_slave_port_id != InvalidPortID && 723 p->getId() == exclude_slave_port_id) 724 continue; 725 726 Tick latency = p->sendAtomicSnoop(pkt); 727 fanout++; 728 729 // in contrast to a functional access, we have to keep on 730 // going as all snoopers must be updated even if we get a 731 // response 732 if (!pkt->isResponse()) 733 continue; 734 735 // response from snoop agent 736 assert(pkt->cmd != orig_cmd); 737 assert(pkt->memInhibitAsserted()); 738 // should only happen once 739 assert(snoop_response_cmd == MemCmd::InvalidCmd); 740 // save response state 741 snoop_response_cmd = pkt->cmd; 742 snoop_response_latency = latency; 743 744 if (snoopFilter) { 745 // Handle responses by the snoopers and differentiate between 746 // responses to requests from above and snoops from below 747 if (source_master_port_id != InvalidPortID) { 748 // Getting a response for a snoop from below 749 assert(exclude_slave_port_id == InvalidPortID); 750 snoopFilter->updateSnoopForward(pkt, *p, 751 *masterPorts[source_master_port_id]); 752 } else { 753 // Getting a response for a request from above 754 assert(source_master_port_id == InvalidPortID); 755 snoopFilter->updateSnoopResponse(pkt, *p, 756 *slavePorts[exclude_slave_port_id]); 757 } 758 } 759 // restore original packet state for remaining snoopers 760 pkt->cmd = orig_cmd; 761 } 762 763 // Stats for fanout 764 snoopFanout.sample(fanout); 765 766 // the packet is restored as part of the loop and any potential 767 // snoop response is part of the returned pair 768 return std::make_pair(snoop_response_cmd, snoop_response_latency); 769} 770 771void 772CoherentXBar::recvFunctional(PacketPtr pkt, PortID slave_port_id) 773{ 774 if (!pkt->isPrint()) { 775 // don't do DPRINTFs on PrintReq as it clutters up the output 776 DPRINTF(CoherentXBar, 777 "recvFunctional: packet src %s addr 0x%x cmd %s\n", 778 slavePorts[slave_port_id]->name(), pkt->getAddr(), 779 pkt->cmdString()); 780 } 781 782 if (!system->bypassCaches()) { 783 // forward to all snoopers but the source 784 forwardFunctional(pkt, slave_port_id); 785 } 786 787 // there is no need to continue if the snooping has found what we 788 // were looking for and the packet is already a response 789 if (!pkt->isResponse()) { 790 PortID dest_id = findPort(pkt->getAddr()); 791 792 masterPorts[dest_id]->sendFunctional(pkt); 793 } 794} 795 796void 797CoherentXBar::recvFunctionalSnoop(PacketPtr pkt, PortID master_port_id) 798{ 799 if (!pkt->isPrint()) { 800 // don't do DPRINTFs on PrintReq as it clutters up the output 801 DPRINTF(CoherentXBar, 802 "recvFunctionalSnoop: packet src %s addr 0x%x cmd %s\n", 803 masterPorts[master_port_id]->name(), pkt->getAddr(), 804 pkt->cmdString()); 805 } 806 807 // forward to all snoopers 808 forwardFunctional(pkt, InvalidPortID); 809} 810 811void 812CoherentXBar::forwardFunctional(PacketPtr pkt, PortID exclude_slave_port_id) 813{ 814 // snoops should only happen if the system isn't bypassing caches 815 assert(!system->bypassCaches()); 816 817 for (const auto& p: snoopPorts) { 818 // we could have gotten this request from a snooping master 819 // (corresponding to our own slave port that is also in 820 // snoopPorts) and should not send it back to where it came 821 // from 822 if (exclude_slave_port_id == InvalidPortID || 823 p->getId() != exclude_slave_port_id) 824 p->sendFunctionalSnoop(pkt); 825 826 // if we get a response we are done 827 if (pkt->isResponse()) { 828 break; 829 } 830 } 831} 832 833unsigned int 834CoherentXBar::drain(DrainManager *dm) 835{ 836 // sum up the individual layers 837 unsigned int total = 0; 838 for (auto l: reqLayers) 839 total += l->drain(dm); 840 for (auto l: respLayers) 841 total += l->drain(dm); 842 for (auto l: snoopLayers) 843 total += l->drain(dm); 844 return total; 845} 846 847void 848CoherentXBar::regStats() 849{ 850 // register the stats of the base class and our layers 851 BaseXBar::regStats(); 852 for (auto l: reqLayers) 853 l->regStats(); 854 for (auto l: respLayers) 855 l->regStats(); 856 for (auto l: snoopLayers) 857 l->regStats(); 858 859 snoops 860 .name(name() + ".snoops") 861 .desc("Total snoops (count)") 862 ; 863 864 snoopFanout 865 .init(0, snoopPorts.size(), 1) 866 .name(name() + ".snoop_fanout") 867 .desc("Request fanout histogram") 868 ; 869} 870 871CoherentXBar * 872CoherentXBarParams::create() 873{ 874 return new CoherentXBar(this); 875} 876