coherent_xbar.cc revision 11793:ef606668d247
111723Sar4jc@virginia.edu/* 211723Sar4jc@virginia.edu * Copyright (c) 2011-2016 ARM Limited 311723Sar4jc@virginia.edu * All rights reserved 411723Sar4jc@virginia.edu * 511723Sar4jc@virginia.edu * The license below extends only to copyright in the software and shall 611723Sar4jc@virginia.edu * not be construed as granting a license to any other intellectual 711723Sar4jc@virginia.edu * property including but not limited to intellectual property relating 811723Sar4jc@virginia.edu * to a hardware implementation of the functionality of the software 911723Sar4jc@virginia.edu * licensed hereunder. You may use the software subject to the license 1011723Sar4jc@virginia.edu * terms below provided that you ensure that this notice is replicated 1111723Sar4jc@virginia.edu * unmodified and in its entirety in all distributions of the software, 1211723Sar4jc@virginia.edu * modified or unmodified, in source code or in binary form. 1311723Sar4jc@virginia.edu * 1411723Sar4jc@virginia.edu * Copyright (c) 2006 The Regents of The University of Michigan 1511723Sar4jc@virginia.edu * All rights reserved. 1611723Sar4jc@virginia.edu * 1711723Sar4jc@virginia.edu * Redistribution and use in source and binary forms, with or without 1811723Sar4jc@virginia.edu * modification, are permitted provided that the following conditions are 1911723Sar4jc@virginia.edu * met: redistributions of source code must retain the above copyright 2011723Sar4jc@virginia.edu * notice, this list of conditions and the following disclaimer; 2111723Sar4jc@virginia.edu * redistributions in binary form must reproduce the above copyright 2211723Sar4jc@virginia.edu * notice, this list of conditions and the following disclaimer in the 2311723Sar4jc@virginia.edu * documentation and/or other materials provided with the distribution; 2411723Sar4jc@virginia.edu * neither the name of the copyright holders nor the names of its 2511723Sar4jc@virginia.edu * contributors may be used to endorse or promote products derived from 2611723Sar4jc@virginia.edu * this software without specific prior written permission. 2711723Sar4jc@virginia.edu * 2811723Sar4jc@virginia.edu * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 2911723Sar4jc@virginia.edu * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 3011723Sar4jc@virginia.edu * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 3111723Sar4jc@virginia.edu * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 3211723Sar4jc@virginia.edu * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 3311723Sar4jc@virginia.edu * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 3411723Sar4jc@virginia.edu * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 3511723Sar4jc@virginia.edu * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 3611723Sar4jc@virginia.edu * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 3711723Sar4jc@virginia.edu * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 3811723Sar4jc@virginia.edu * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 3911723Sar4jc@virginia.edu * 4011723Sar4jc@virginia.edu * Authors: Ali Saidi 4111723Sar4jc@virginia.edu * Andreas Hansson 4211723Sar4jc@virginia.edu * William Wang 4311723Sar4jc@virginia.edu */ 4411723Sar4jc@virginia.edu 4511854Sbrandon.potter@amd.com/** 4611723Sar4jc@virginia.edu * @file 4711723Sar4jc@virginia.edu * Definition of a crossbar object. 4811800Sbrandon.potter@amd.com */ 4911723Sar4jc@virginia.edu 5011723Sar4jc@virginia.edu#include "mem/coherent_xbar.hh" 5111723Sar4jc@virginia.edu 5211723Sar4jc@virginia.edu#include "base/misc.hh" 5311723Sar4jc@virginia.edu#include "base/trace.hh" 5411851Sbrandon.potter@amd.com#include "debug/AddrRanges.hh" 5511851Sbrandon.potter@amd.com#include "debug/CoherentXBar.hh" 5611723Sar4jc@virginia.edu#include "sim/system.hh" 5711723Sar4jc@virginia.edu 5811723Sar4jc@virginia.eduCoherentXBar::CoherentXBar(const CoherentXBarParams *p) 5911905SBrandon.Potter@amd.com : BaseXBar(p), system(p->system), snoopFilter(p->snoop_filter), 6011905SBrandon.Potter@amd.com snoopResponseLatency(p->snoop_response_latency), 6111905SBrandon.Potter@amd.com pointOfCoherency(p->point_of_coherency) 6211723Sar4jc@virginia.edu{ 6311723Sar4jc@virginia.edu // create the ports based on the size of the master and slave 6411905SBrandon.Potter@amd.com // vector ports, and the presence of the default port, the ports 6511723Sar4jc@virginia.edu // are enumerated starting from zero 6611723Sar4jc@virginia.edu for (int i = 0; i < p->port_master_connection_count; ++i) { 6711905SBrandon.Potter@amd.com std::string portName = csprintf("%s.master[%d]", name(), i); 6811723Sar4jc@virginia.edu MasterPort* bp = new CoherentXBarMasterPort(portName, *this, i); 6911723Sar4jc@virginia.edu masterPorts.push_back(bp); 7011905SBrandon.Potter@amd.com reqLayers.push_back(new ReqLayer(*bp, *this, 7111905SBrandon.Potter@amd.com csprintf(".reqLayer%d", i))); 7211905SBrandon.Potter@amd.com snoopLayers.push_back(new SnoopRespLayer(*bp, *this, 7311905SBrandon.Potter@amd.com csprintf(".snoopLayer%d", i))); 7411723Sar4jc@virginia.edu } 7511723Sar4jc@virginia.edu 7611723Sar4jc@virginia.edu // see if we have a default slave device connected and if so add 7711851Sbrandon.potter@amd.com // our corresponding master port 7811723Sar4jc@virginia.edu if (p->port_default_connection_count) { 7911851Sbrandon.potter@amd.com defaultPortID = masterPorts.size(); 8011723Sar4jc@virginia.edu std::string portName = name() + ".default"; 8111723Sar4jc@virginia.edu MasterPort* bp = new CoherentXBarMasterPort(portName, *this, 8211723Sar4jc@virginia.edu defaultPortID); 8311723Sar4jc@virginia.edu masterPorts.push_back(bp); 8411723Sar4jc@virginia.edu reqLayers.push_back(new ReqLayer(*bp, *this, csprintf(".reqLayer%d", 8511851Sbrandon.potter@amd.com defaultPortID))); 8611723Sar4jc@virginia.edu snoopLayers.push_back(new SnoopRespLayer(*bp, *this, 8711723Sar4jc@virginia.edu csprintf(".snoopLayer%d", 8811723Sar4jc@virginia.edu defaultPortID))); 8911723Sar4jc@virginia.edu } 9011723Sar4jc@virginia.edu 9111723Sar4jc@virginia.edu // create the slave ports, once again starting at zero 9211723Sar4jc@virginia.edu for (int i = 0; i < p->port_slave_connection_count; ++i) { 9311723Sar4jc@virginia.edu std::string portName = csprintf("%s.slave[%d]", name(), i); 9411723Sar4jc@virginia.edu QueuedSlavePort* bp = new CoherentXBarSlavePort(portName, *this, i); 9511723Sar4jc@virginia.edu slavePorts.push_back(bp); 9611723Sar4jc@virginia.edu respLayers.push_back(new RespLayer(*bp, *this, 9711723Sar4jc@virginia.edu csprintf(".respLayer%d", i))); 9811723Sar4jc@virginia.edu snoopRespPorts.push_back(new SnoopRespPort(*bp, *this)); 9911723Sar4jc@virginia.edu } 10011723Sar4jc@virginia.edu 10111723Sar4jc@virginia.edu clearPortCache(); 10211723Sar4jc@virginia.edu} 10311723Sar4jc@virginia.edu 10411723Sar4jc@virginia.eduCoherentXBar::~CoherentXBar() 10511723Sar4jc@virginia.edu{ 10611723Sar4jc@virginia.edu for (auto l: reqLayers) 10711723Sar4jc@virginia.edu delete l; 10811723Sar4jc@virginia.edu for (auto l: respLayers) 10911723Sar4jc@virginia.edu delete l; 11011723Sar4jc@virginia.edu for (auto l: snoopLayers) 11111723Sar4jc@virginia.edu delete l; 11211723Sar4jc@virginia.edu for (auto p: snoopRespPorts) 11311723Sar4jc@virginia.edu delete p; 11411723Sar4jc@virginia.edu} 11511723Sar4jc@virginia.edu 11611723Sar4jc@virginia.eduvoid 11711723Sar4jc@virginia.eduCoherentXBar::init() 11811723Sar4jc@virginia.edu{ 11911723Sar4jc@virginia.edu BaseXBar::init(); 12011723Sar4jc@virginia.edu 12111723Sar4jc@virginia.edu // iterate over our slave ports and determine which of our 12211723Sar4jc@virginia.edu // neighbouring master ports are snooping and add them as snoopers 12311723Sar4jc@virginia.edu for (const auto& p: slavePorts) { 12411723Sar4jc@virginia.edu // check if the connected master port is snooping 12511723Sar4jc@virginia.edu if (p->isSnooping()) { 12611723Sar4jc@virginia.edu DPRINTF(AddrRanges, "Adding snooping master %s\n", 12711723Sar4jc@virginia.edu p->getMasterPort().name()); 12811723Sar4jc@virginia.edu snoopPorts.push_back(p); 12911723Sar4jc@virginia.edu } 13011723Sar4jc@virginia.edu } 13111723Sar4jc@virginia.edu 13211905SBrandon.Potter@amd.com if (snoopPorts.empty()) 13311886Sbrandon.potter@amd.com warn("CoherentXBar %s has no snooping ports attached!\n", name()); 13411723Sar4jc@virginia.edu 13511905SBrandon.Potter@amd.com // inform the snoop filter about the slave ports so it can create 13611886Sbrandon.potter@amd.com // its own internal representation 13711723Sar4jc@virginia.edu if (snoopFilter) 13811723Sar4jc@virginia.edu snoopFilter->setSlavePorts(slavePorts); 13911905SBrandon.Potter@amd.com} 14011723Sar4jc@virginia.edu 14111905SBrandon.Potter@amd.combool 14211905SBrandon.Potter@amd.comCoherentXBar::recvTimingReq(PacketPtr pkt, PortID slave_port_id) 14311905SBrandon.Potter@amd.com{ 14411905SBrandon.Potter@amd.com // determine the source port based on the id 14511905SBrandon.Potter@amd.com SlavePort *src_port = slavePorts[slave_port_id]; 14611905SBrandon.Potter@amd.com 14711905SBrandon.Potter@amd.com // remember if the packet is an express snoop 14811905SBrandon.Potter@amd.com bool is_express_snoop = pkt->isExpressSnoop(); 14911905SBrandon.Potter@amd.com bool cache_responding = pkt->cacheResponding(); 15011723Sar4jc@virginia.edu // for normal requests, going downstream, the express snoop flag 15111723Sar4jc@virginia.edu // and the cache responding flag should always be the same 15211723Sar4jc@virginia.edu assert(is_express_snoop == cache_responding); 15311723Sar4jc@virginia.edu 15411723Sar4jc@virginia.edu // determine the destination based on the address 15511723Sar4jc@virginia.edu PortID master_port_id = findPort(pkt->getAddr()); 15611723Sar4jc@virginia.edu 15711723Sar4jc@virginia.edu // test if the crossbar should be considered occupied for the current 15811723Sar4jc@virginia.edu // port, and exclude express snoops from the check 15911723Sar4jc@virginia.edu if (!is_express_snoop && !reqLayers[master_port_id]->tryTiming(src_port)) { 16011723Sar4jc@virginia.edu DPRINTF(CoherentXBar, "%s: src %s packet %s BUSY\n", __func__, 16111723Sar4jc@virginia.edu src_port->name(), pkt->print()); 16211723Sar4jc@virginia.edu return false; 16311723Sar4jc@virginia.edu } 16411723Sar4jc@virginia.edu 16511723Sar4jc@virginia.edu DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__, 16611723Sar4jc@virginia.edu src_port->name(), pkt->print()); 16711723Sar4jc@virginia.edu 16811723Sar4jc@virginia.edu // store size and command as they might be modified when 16911723Sar4jc@virginia.edu // forwarding the packet 17011723Sar4jc@virginia.edu unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 17111723Sar4jc@virginia.edu unsigned int pkt_cmd = pkt->cmdToIndex(); 17211723Sar4jc@virginia.edu 17311723Sar4jc@virginia.edu // store the old header delay so we can restore it if needed 17411905SBrandon.Potter@amd.com Tick old_header_delay = pkt->headerDelay; 17511723Sar4jc@virginia.edu 17611723Sar4jc@virginia.edu // a request sees the frontend and forward latency 17711723Sar4jc@virginia.edu Tick xbar_delay = (frontendLatency + forwardLatency) * clockPeriod(); 17811723Sar4jc@virginia.edu 17911723Sar4jc@virginia.edu // set the packet header and payload delay 18011723Sar4jc@virginia.edu calcPacketTiming(pkt, xbar_delay); 18111723Sar4jc@virginia.edu 18211723Sar4jc@virginia.edu // determine how long to be crossbar layer is busy 18311723Sar4jc@virginia.edu Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 18411723Sar4jc@virginia.edu 18511723Sar4jc@virginia.edu if (!system->bypassCaches()) { 18611723Sar4jc@virginia.edu assert(pkt->snoopDelay == 0); 18711723Sar4jc@virginia.edu 18811723Sar4jc@virginia.edu // the packet is a memory-mapped request and should be 18911723Sar4jc@virginia.edu // broadcasted to our snoopers but the source 19011723Sar4jc@virginia.edu if (snoopFilter) { 19111723Sar4jc@virginia.edu // check with the snoop filter where to forward this packet 19211723Sar4jc@virginia.edu auto sf_res = snoopFilter->lookupRequest(pkt, *src_port); 19311723Sar4jc@virginia.edu // the time required by a packet to be delivered through 19411723Sar4jc@virginia.edu // the xbar has to be charged also with to lookup latency 19511723Sar4jc@virginia.edu // of the snoop filter 19611723Sar4jc@virginia.edu pkt->headerDelay += sf_res.second * clockPeriod(); 19711723Sar4jc@virginia.edu DPRINTF(CoherentXBar, "%s: src %s packet %s SF size: %i lat: %i\n", 19811723Sar4jc@virginia.edu __func__, src_port->name(), pkt->print(), 19911723Sar4jc@virginia.edu sf_res.first.size(), sf_res.second); 20011723Sar4jc@virginia.edu 20111723Sar4jc@virginia.edu if (pkt->isEviction()) { 20211723Sar4jc@virginia.edu // for block-evicting packets, i.e. writebacks and 20311723Sar4jc@virginia.edu // clean evictions, there is no need to snoop up, as 20411723Sar4jc@virginia.edu // all we do is determine if the block is cached or 20511723Sar4jc@virginia.edu // not, instead just set it here based on the snoop 20611723Sar4jc@virginia.edu // filter result 20711723Sar4jc@virginia.edu if (!sf_res.first.empty()) 20811723Sar4jc@virginia.edu pkt->setBlockCached(); 20911723Sar4jc@virginia.edu } else { 21011723Sar4jc@virginia.edu forwardTiming(pkt, slave_port_id, sf_res.first); 21111723Sar4jc@virginia.edu } 21211723Sar4jc@virginia.edu } else { 21311723Sar4jc@virginia.edu forwardTiming(pkt, slave_port_id); 21411723Sar4jc@virginia.edu } 21511723Sar4jc@virginia.edu 21611723Sar4jc@virginia.edu // add the snoop delay to our header delay, and then reset it 21711723Sar4jc@virginia.edu pkt->headerDelay += pkt->snoopDelay; 21811723Sar4jc@virginia.edu pkt->snoopDelay = 0; 21911723Sar4jc@virginia.edu } 22011723Sar4jc@virginia.edu 22111723Sar4jc@virginia.edu // set up a sensible starting point 22211723Sar4jc@virginia.edu bool success = true; 22311723Sar4jc@virginia.edu 22411723Sar4jc@virginia.edu // remember if the packet will generate a snoop response by 22511905SBrandon.Potter@amd.com // checking if a cache set the cacheResponding flag during the 22611723Sar4jc@virginia.edu // snooping above 22711723Sar4jc@virginia.edu const bool expect_snoop_resp = !cache_responding && pkt->cacheResponding(); 22811723Sar4jc@virginia.edu bool expect_response = pkt->needsResponse() && !pkt->cacheResponding(); 22911723Sar4jc@virginia.edu 23011851Sbrandon.potter@amd.com const bool sink_packet = sinkPacket(pkt); 23111723Sar4jc@virginia.edu 23211806Sar4jc@virginia.edu // in certain cases the crossbar is responsible for responding 23311806Sar4jc@virginia.edu bool respond_directly = false; 23411806Sar4jc@virginia.edu // store the original address as an address mapper could possibly 23511806Sar4jc@virginia.edu // modify the address upon a sendTimingRequest 23611806Sar4jc@virginia.edu const Addr addr(pkt->getAddr()); 23711806Sar4jc@virginia.edu if (sink_packet) { 23811806Sar4jc@virginia.edu DPRINTF(CoherentXBar, "%s: Not forwarding %s\n", __func__, 23911723Sar4jc@virginia.edu pkt->print()); 24011723Sar4jc@virginia.edu } else { 24111723Sar4jc@virginia.edu // determine if we are forwarding the packet, or responding to 24211851Sbrandon.potter@amd.com // it 24311723Sar4jc@virginia.edu if (!pointOfCoherency || pkt->isRead() || pkt->isWrite()) { 24411723Sar4jc@virginia.edu // if we are passing on, rather than sinking, a packet to 24511723Sar4jc@virginia.edu // which an upstream cache has committed to responding, 24611723Sar4jc@virginia.edu // the line was needs writable, and the responding only 24711723Sar4jc@virginia.edu // had an Owned copy, so we need to immidiately let the 24811851Sbrandon.potter@amd.com // downstream caches know, bypass any flow control 24911723Sar4jc@virginia.edu if (pkt->cacheResponding()) { 25011723Sar4jc@virginia.edu pkt->setExpressSnoop(); 25111723Sar4jc@virginia.edu } 25211723Sar4jc@virginia.edu 25311723Sar4jc@virginia.edu // since it is a normal request, attempt to send the packet 25411723Sar4jc@virginia.edu success = masterPorts[master_port_id]->sendTimingReq(pkt); 25511723Sar4jc@virginia.edu } else { 25611723Sar4jc@virginia.edu // no need to forward, turn this packet around and respond 25711723Sar4jc@virginia.edu // directly 258 assert(pkt->needsResponse()); 259 260 respond_directly = true; 261 assert(!expect_snoop_resp); 262 expect_response = false; 263 } 264 } 265 266 if (snoopFilter && !system->bypassCaches()) { 267 // Let the snoop filter know about the success of the send operation 268 snoopFilter->finishRequest(!success, addr, pkt->isSecure()); 269 } 270 271 // check if we were successful in sending the packet onwards 272 if (!success) { 273 // express snoops should never be forced to retry 274 assert(!is_express_snoop); 275 276 // restore the header delay 277 pkt->headerDelay = old_header_delay; 278 279 DPRINTF(CoherentXBar, "%s: src %s packet %s RETRY\n", __func__, 280 src_port->name(), pkt->print()); 281 282 // update the layer state and schedule an idle event 283 reqLayers[master_port_id]->failedTiming(src_port, 284 clockEdge(Cycles(1))); 285 } else { 286 // express snoops currently bypass the crossbar state entirely 287 if (!is_express_snoop) { 288 // if this particular request will generate a snoop 289 // response 290 if (expect_snoop_resp) { 291 // we should never have an exsiting request outstanding 292 assert(outstandingSnoop.find(pkt->req) == 293 outstandingSnoop.end()); 294 outstandingSnoop.insert(pkt->req); 295 296 // basic sanity check on the outstanding snoops 297 panic_if(outstandingSnoop.size() > 512, 298 "Outstanding snoop requests exceeded 512\n"); 299 } 300 301 // remember where to route the normal response to 302 if (expect_response || expect_snoop_resp) { 303 assert(routeTo.find(pkt->req) == routeTo.end()); 304 routeTo[pkt->req] = slave_port_id; 305 306 panic_if(routeTo.size() > 512, 307 "Routing table exceeds 512 packets\n"); 308 } 309 310 // update the layer state and schedule an idle event 311 reqLayers[master_port_id]->succeededTiming(packetFinishTime); 312 } 313 314 // stats updates only consider packets that were successfully sent 315 pktCount[slave_port_id][master_port_id]++; 316 pktSize[slave_port_id][master_port_id] += pkt_size; 317 transDist[pkt_cmd]++; 318 319 if (is_express_snoop) { 320 snoops++; 321 snoopTraffic += pkt_size; 322 } 323 } 324 325 if (sink_packet) 326 // queue the packet for deletion 327 pendingDelete.reset(pkt); 328 329 if (respond_directly) { 330 assert(pkt->needsResponse()); 331 assert(success); 332 333 pkt->makeResponse(); 334 335 if (snoopFilter && !system->bypassCaches()) { 336 // let the snoop filter inspect the response and update its state 337 snoopFilter->updateResponse(pkt, *slavePorts[slave_port_id]); 338 } 339 340 Tick response_time = clockEdge() + pkt->headerDelay; 341 pkt->headerDelay = 0; 342 343 slavePorts[slave_port_id]->schedTimingResp(pkt, response_time); 344 } 345 346 return success; 347} 348 349bool 350CoherentXBar::recvTimingResp(PacketPtr pkt, PortID master_port_id) 351{ 352 // determine the source port based on the id 353 MasterPort *src_port = masterPorts[master_port_id]; 354 355 // determine the destination 356 const auto route_lookup = routeTo.find(pkt->req); 357 assert(route_lookup != routeTo.end()); 358 const PortID slave_port_id = route_lookup->second; 359 assert(slave_port_id != InvalidPortID); 360 assert(slave_port_id < respLayers.size()); 361 362 // test if the crossbar should be considered occupied for the 363 // current port 364 if (!respLayers[slave_port_id]->tryTiming(src_port)) { 365 DPRINTF(CoherentXBar, "%s: src %s packet %s BUSY\n", __func__, 366 src_port->name(), pkt->print()); 367 return false; 368 } 369 370 DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__, 371 src_port->name(), pkt->print()); 372 373 // store size and command as they might be modified when 374 // forwarding the packet 375 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 376 unsigned int pkt_cmd = pkt->cmdToIndex(); 377 378 // a response sees the response latency 379 Tick xbar_delay = responseLatency * clockPeriod(); 380 381 // set the packet header and payload delay 382 calcPacketTiming(pkt, xbar_delay); 383 384 // determine how long to be crossbar layer is busy 385 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 386 387 if (snoopFilter && !system->bypassCaches()) { 388 // let the snoop filter inspect the response and update its state 389 snoopFilter->updateResponse(pkt, *slavePorts[slave_port_id]); 390 } 391 392 // send the packet through the destination slave port and pay for 393 // any outstanding header delay 394 Tick latency = pkt->headerDelay; 395 pkt->headerDelay = 0; 396 slavePorts[slave_port_id]->schedTimingResp(pkt, curTick() + latency); 397 398 // remove the request from the routing table 399 routeTo.erase(route_lookup); 400 401 respLayers[slave_port_id]->succeededTiming(packetFinishTime); 402 403 // stats updates 404 pktCount[slave_port_id][master_port_id]++; 405 pktSize[slave_port_id][master_port_id] += pkt_size; 406 transDist[pkt_cmd]++; 407 408 return true; 409} 410 411void 412CoherentXBar::recvTimingSnoopReq(PacketPtr pkt, PortID master_port_id) 413{ 414 DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__, 415 masterPorts[master_port_id]->name(), pkt->print()); 416 417 // update stats here as we know the forwarding will succeed 418 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 419 transDist[pkt->cmdToIndex()]++; 420 snoops++; 421 snoopTraffic += pkt_size; 422 423 // we should only see express snoops from caches 424 assert(pkt->isExpressSnoop()); 425 426 // set the packet header and payload delay, for now use forward latency 427 // @todo Assess the choice of latency further 428 calcPacketTiming(pkt, forwardLatency * clockPeriod()); 429 430 // remember if a cache has already committed to responding so we 431 // can see if it changes during the snooping 432 const bool cache_responding = pkt->cacheResponding(); 433 434 assert(pkt->snoopDelay == 0); 435 436 if (snoopFilter) { 437 // let the Snoop Filter work its magic and guide probing 438 auto sf_res = snoopFilter->lookupSnoop(pkt); 439 // the time required by a packet to be delivered through 440 // the xbar has to be charged also with to lookup latency 441 // of the snoop filter 442 pkt->headerDelay += sf_res.second * clockPeriod(); 443 DPRINTF(CoherentXBar, "%s: src %s packet %s SF size: %i lat: %i\n", 444 __func__, masterPorts[master_port_id]->name(), pkt->print(), 445 sf_res.first.size(), sf_res.second); 446 447 // forward to all snoopers 448 forwardTiming(pkt, InvalidPortID, sf_res.first); 449 } else { 450 forwardTiming(pkt, InvalidPortID); 451 } 452 453 // add the snoop delay to our header delay, and then reset it 454 pkt->headerDelay += pkt->snoopDelay; 455 pkt->snoopDelay = 0; 456 457 // if we can expect a response, remember how to route it 458 if (!cache_responding && pkt->cacheResponding()) { 459 assert(routeTo.find(pkt->req) == routeTo.end()); 460 routeTo[pkt->req] = master_port_id; 461 } 462 463 // a snoop request came from a connected slave device (one of 464 // our master ports), and if it is not coming from the slave 465 // device responsible for the address range something is 466 // wrong, hence there is nothing further to do as the packet 467 // would be going back to where it came from 468 assert(master_port_id == findPort(pkt->getAddr())); 469} 470 471bool 472CoherentXBar::recvTimingSnoopResp(PacketPtr pkt, PortID slave_port_id) 473{ 474 // determine the source port based on the id 475 SlavePort* src_port = slavePorts[slave_port_id]; 476 477 // get the destination 478 const auto route_lookup = routeTo.find(pkt->req); 479 assert(route_lookup != routeTo.end()); 480 const PortID dest_port_id = route_lookup->second; 481 assert(dest_port_id != InvalidPortID); 482 483 // determine if the response is from a snoop request we 484 // created as the result of a normal request (in which case it 485 // should be in the outstandingSnoop), or if we merely forwarded 486 // someone else's snoop request 487 const bool forwardAsSnoop = outstandingSnoop.find(pkt->req) == 488 outstandingSnoop.end(); 489 490 // test if the crossbar should be considered occupied for the 491 // current port, note that the check is bypassed if the response 492 // is being passed on as a normal response since this is occupying 493 // the response layer rather than the snoop response layer 494 if (forwardAsSnoop) { 495 assert(dest_port_id < snoopLayers.size()); 496 if (!snoopLayers[dest_port_id]->tryTiming(src_port)) { 497 DPRINTF(CoherentXBar, "%s: src %s packet %s BUSY\n", __func__, 498 src_port->name(), pkt->print()); 499 return false; 500 } 501 } else { 502 // get the master port that mirrors this slave port internally 503 MasterPort* snoop_port = snoopRespPorts[slave_port_id]; 504 assert(dest_port_id < respLayers.size()); 505 if (!respLayers[dest_port_id]->tryTiming(snoop_port)) { 506 DPRINTF(CoherentXBar, "%s: src %s packet %s BUSY\n", __func__, 507 snoop_port->name(), pkt->print()); 508 return false; 509 } 510 } 511 512 DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__, 513 src_port->name(), pkt->print()); 514 515 // store size and command as they might be modified when 516 // forwarding the packet 517 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 518 unsigned int pkt_cmd = pkt->cmdToIndex(); 519 520 // responses are never express snoops 521 assert(!pkt->isExpressSnoop()); 522 523 // a snoop response sees the snoop response latency, and if it is 524 // forwarded as a normal response, the response latency 525 Tick xbar_delay = 526 (forwardAsSnoop ? snoopResponseLatency : responseLatency) * 527 clockPeriod(); 528 529 // set the packet header and payload delay 530 calcPacketTiming(pkt, xbar_delay); 531 532 // determine how long to be crossbar layer is busy 533 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 534 535 // forward it either as a snoop response or a normal response 536 if (forwardAsSnoop) { 537 // this is a snoop response to a snoop request we forwarded, 538 // e.g. coming from the L1 and going to the L2, and it should 539 // be forwarded as a snoop response 540 541 if (snoopFilter) { 542 // update the probe filter so that it can properly track the line 543 snoopFilter->updateSnoopForward(pkt, *slavePorts[slave_port_id], 544 *masterPorts[dest_port_id]); 545 } 546 547 bool success M5_VAR_USED = 548 masterPorts[dest_port_id]->sendTimingSnoopResp(pkt); 549 pktCount[slave_port_id][dest_port_id]++; 550 pktSize[slave_port_id][dest_port_id] += pkt_size; 551 assert(success); 552 553 snoopLayers[dest_port_id]->succeededTiming(packetFinishTime); 554 } else { 555 // we got a snoop response on one of our slave ports, 556 // i.e. from a coherent master connected to the crossbar, and 557 // since we created the snoop request as part of recvTiming, 558 // this should now be a normal response again 559 outstandingSnoop.erase(pkt->req); 560 561 // this is a snoop response from a coherent master, hence it 562 // should never go back to where the snoop response came from, 563 // but instead to where the original request came from 564 assert(slave_port_id != dest_port_id); 565 566 if (snoopFilter) { 567 // update the probe filter so that it can properly track the line 568 snoopFilter->updateSnoopResponse(pkt, *slavePorts[slave_port_id], 569 *slavePorts[dest_port_id]); 570 } 571 572 DPRINTF(CoherentXBar, "%s: src %s packet %s FWD RESP\n", __func__, 573 src_port->name(), pkt->print()); 574 575 // as a normal response, it should go back to a master through 576 // one of our slave ports, we also pay for any outstanding 577 // header latency 578 Tick latency = pkt->headerDelay; 579 pkt->headerDelay = 0; 580 slavePorts[dest_port_id]->schedTimingResp(pkt, curTick() + latency); 581 582 respLayers[dest_port_id]->succeededTiming(packetFinishTime); 583 } 584 585 // remove the request from the routing table 586 routeTo.erase(route_lookup); 587 588 // stats updates 589 transDist[pkt_cmd]++; 590 snoops++; 591 snoopTraffic += pkt_size; 592 593 return true; 594} 595 596 597void 598CoherentXBar::forwardTiming(PacketPtr pkt, PortID exclude_slave_port_id, 599 const std::vector<QueuedSlavePort*>& dests) 600{ 601 DPRINTF(CoherentXBar, "%s for %s\n", __func__, pkt->print()); 602 603 // snoops should only happen if the system isn't bypassing caches 604 assert(!system->bypassCaches()); 605 606 unsigned fanout = 0; 607 608 for (const auto& p: dests) { 609 // we could have gotten this request from a snooping master 610 // (corresponding to our own slave port that is also in 611 // snoopPorts) and should not send it back to where it came 612 // from 613 if (exclude_slave_port_id == InvalidPortID || 614 p->getId() != exclude_slave_port_id) { 615 // cache is not allowed to refuse snoop 616 p->sendTimingSnoopReq(pkt); 617 fanout++; 618 } 619 } 620 621 // Stats for fanout of this forward operation 622 snoopFanout.sample(fanout); 623} 624 625void 626CoherentXBar::recvReqRetry(PortID master_port_id) 627{ 628 // responses and snoop responses never block on forwarding them, 629 // so the retry will always be coming from a port to which we 630 // tried to forward a request 631 reqLayers[master_port_id]->recvRetry(); 632} 633 634Tick 635CoherentXBar::recvAtomic(PacketPtr pkt, PortID slave_port_id) 636{ 637 DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__, 638 slavePorts[slave_port_id]->name(), pkt->print()); 639 640 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 641 unsigned int pkt_cmd = pkt->cmdToIndex(); 642 643 MemCmd snoop_response_cmd = MemCmd::InvalidCmd; 644 Tick snoop_response_latency = 0; 645 646 if (!system->bypassCaches()) { 647 // forward to all snoopers but the source 648 std::pair<MemCmd, Tick> snoop_result; 649 if (snoopFilter) { 650 // check with the snoop filter where to forward this packet 651 auto sf_res = 652 snoopFilter->lookupRequest(pkt, *slavePorts[slave_port_id]); 653 snoop_response_latency += sf_res.second * clockPeriod(); 654 DPRINTF(CoherentXBar, "%s: src %s packet %s SF size: %i lat: %i\n", 655 __func__, slavePorts[slave_port_id]->name(), pkt->print(), 656 sf_res.first.size(), sf_res.second); 657 658 // let the snoop filter know about the success of the send 659 // operation, and do it even before sending it onwards to 660 // avoid situations where atomic upward snoops sneak in 661 // between and change the filter state 662 snoopFilter->finishRequest(false, pkt->getAddr(), pkt->isSecure()); 663 664 snoop_result = forwardAtomic(pkt, slave_port_id, InvalidPortID, 665 sf_res.first); 666 } else { 667 snoop_result = forwardAtomic(pkt, slave_port_id); 668 } 669 snoop_response_cmd = snoop_result.first; 670 snoop_response_latency += snoop_result.second; 671 } 672 673 // set up a sensible default value 674 Tick response_latency = 0; 675 676 const bool sink_packet = sinkPacket(pkt); 677 678 // even if we had a snoop response, we must continue and also 679 // perform the actual request at the destination 680 PortID master_port_id = findPort(pkt->getAddr()); 681 682 if (sink_packet) { 683 DPRINTF(CoherentXBar, "%s: Not forwarding %s\n", __func__, 684 pkt->print()); 685 } else { 686 if (!pointOfCoherency || pkt->isRead() || pkt->isWrite()) { 687 // forward the request to the appropriate destination 688 response_latency = masterPorts[master_port_id]->sendAtomic(pkt); 689 } else { 690 // if it does not need a response we sink the packet above 691 assert(pkt->needsResponse()); 692 693 pkt->makeResponse(); 694 } 695 } 696 697 // stats updates for the request 698 pktCount[slave_port_id][master_port_id]++; 699 pktSize[slave_port_id][master_port_id] += pkt_size; 700 transDist[pkt_cmd]++; 701 702 703 // if lower levels have replied, tell the snoop filter 704 if (!system->bypassCaches() && snoopFilter && pkt->isResponse()) { 705 snoopFilter->updateResponse(pkt, *slavePorts[slave_port_id]); 706 } 707 708 // if we got a response from a snooper, restore it here 709 if (snoop_response_cmd != MemCmd::InvalidCmd) { 710 // no one else should have responded 711 assert(!pkt->isResponse()); 712 pkt->cmd = snoop_response_cmd; 713 response_latency = snoop_response_latency; 714 } 715 716 // add the response data 717 if (pkt->isResponse()) { 718 pkt_size = pkt->hasData() ? pkt->getSize() : 0; 719 pkt_cmd = pkt->cmdToIndex(); 720 721 // stats updates 722 pktCount[slave_port_id][master_port_id]++; 723 pktSize[slave_port_id][master_port_id] += pkt_size; 724 transDist[pkt_cmd]++; 725 } 726 727 // @todo: Not setting header time 728 pkt->payloadDelay = response_latency; 729 return response_latency; 730} 731 732Tick 733CoherentXBar::recvAtomicSnoop(PacketPtr pkt, PortID master_port_id) 734{ 735 DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__, 736 masterPorts[master_port_id]->name(), pkt->print()); 737 738 // add the request snoop data 739 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 740 snoops++; 741 snoopTraffic += pkt_size; 742 743 // forward to all snoopers 744 std::pair<MemCmd, Tick> snoop_result; 745 Tick snoop_response_latency = 0; 746 if (snoopFilter) { 747 auto sf_res = snoopFilter->lookupSnoop(pkt); 748 snoop_response_latency += sf_res.second * clockPeriod(); 749 DPRINTF(CoherentXBar, "%s: src %s packet %s SF size: %i lat: %i\n", 750 __func__, masterPorts[master_port_id]->name(), pkt->print(), 751 sf_res.first.size(), sf_res.second); 752 snoop_result = forwardAtomic(pkt, InvalidPortID, master_port_id, 753 sf_res.first); 754 } else { 755 snoop_result = forwardAtomic(pkt, InvalidPortID); 756 } 757 MemCmd snoop_response_cmd = snoop_result.first; 758 snoop_response_latency += snoop_result.second; 759 760 if (snoop_response_cmd != MemCmd::InvalidCmd) 761 pkt->cmd = snoop_response_cmd; 762 763 // add the response snoop data 764 if (pkt->isResponse()) { 765 snoops++; 766 } 767 768 // @todo: Not setting header time 769 pkt->payloadDelay = snoop_response_latency; 770 return snoop_response_latency; 771} 772 773std::pair<MemCmd, Tick> 774CoherentXBar::forwardAtomic(PacketPtr pkt, PortID exclude_slave_port_id, 775 PortID source_master_port_id, 776 const std::vector<QueuedSlavePort*>& dests) 777{ 778 // the packet may be changed on snoops, record the original 779 // command to enable us to restore it between snoops so that 780 // additional snoops can take place properly 781 MemCmd orig_cmd = pkt->cmd; 782 MemCmd snoop_response_cmd = MemCmd::InvalidCmd; 783 Tick snoop_response_latency = 0; 784 785 // snoops should only happen if the system isn't bypassing caches 786 assert(!system->bypassCaches()); 787 788 unsigned fanout = 0; 789 790 for (const auto& p: dests) { 791 // we could have gotten this request from a snooping master 792 // (corresponding to our own slave port that is also in 793 // snoopPorts) and should not send it back to where it came 794 // from 795 if (exclude_slave_port_id != InvalidPortID && 796 p->getId() == exclude_slave_port_id) 797 continue; 798 799 Tick latency = p->sendAtomicSnoop(pkt); 800 fanout++; 801 802 // in contrast to a functional access, we have to keep on 803 // going as all snoopers must be updated even if we get a 804 // response 805 if (!pkt->isResponse()) 806 continue; 807 808 // response from snoop agent 809 assert(pkt->cmd != orig_cmd); 810 assert(pkt->cacheResponding()); 811 // should only happen once 812 assert(snoop_response_cmd == MemCmd::InvalidCmd); 813 // save response state 814 snoop_response_cmd = pkt->cmd; 815 snoop_response_latency = latency; 816 817 if (snoopFilter) { 818 // Handle responses by the snoopers and differentiate between 819 // responses to requests from above and snoops from below 820 if (source_master_port_id != InvalidPortID) { 821 // Getting a response for a snoop from below 822 assert(exclude_slave_port_id == InvalidPortID); 823 snoopFilter->updateSnoopForward(pkt, *p, 824 *masterPorts[source_master_port_id]); 825 } else { 826 // Getting a response for a request from above 827 assert(source_master_port_id == InvalidPortID); 828 snoopFilter->updateSnoopResponse(pkt, *p, 829 *slavePorts[exclude_slave_port_id]); 830 } 831 } 832 // restore original packet state for remaining snoopers 833 pkt->cmd = orig_cmd; 834 } 835 836 // Stats for fanout 837 snoopFanout.sample(fanout); 838 839 // the packet is restored as part of the loop and any potential 840 // snoop response is part of the returned pair 841 return std::make_pair(snoop_response_cmd, snoop_response_latency); 842} 843 844void 845CoherentXBar::recvFunctional(PacketPtr pkt, PortID slave_port_id) 846{ 847 if (!pkt->isPrint()) { 848 // don't do DPRINTFs on PrintReq as it clutters up the output 849 DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__, 850 slavePorts[slave_port_id]->name(), pkt->print()); 851 } 852 853 if (!system->bypassCaches()) { 854 // forward to all snoopers but the source 855 forwardFunctional(pkt, slave_port_id); 856 } 857 858 // there is no need to continue if the snooping has found what we 859 // were looking for and the packet is already a response 860 if (!pkt->isResponse()) { 861 // since our slave ports are queued ports we need to check them as well 862 for (const auto& p : slavePorts) { 863 // if we find a response that has the data, then the 864 // downstream caches/memories may be out of date, so simply stop 865 // here 866 if (p->checkFunctional(pkt)) { 867 if (pkt->needsResponse()) 868 pkt->makeResponse(); 869 return; 870 } 871 } 872 873 PortID dest_id = findPort(pkt->getAddr()); 874 875 masterPorts[dest_id]->sendFunctional(pkt); 876 } 877} 878 879void 880CoherentXBar::recvFunctionalSnoop(PacketPtr pkt, PortID master_port_id) 881{ 882 if (!pkt->isPrint()) { 883 // don't do DPRINTFs on PrintReq as it clutters up the output 884 DPRINTF(CoherentXBar, "%s: src %s packet %s\n", __func__, 885 masterPorts[master_port_id]->name(), pkt->print()); 886 } 887 888 for (const auto& p : slavePorts) { 889 if (p->checkFunctional(pkt)) { 890 if (pkt->needsResponse()) 891 pkt->makeResponse(); 892 return; 893 } 894 } 895 896 // forward to all snoopers 897 forwardFunctional(pkt, InvalidPortID); 898} 899 900void 901CoherentXBar::forwardFunctional(PacketPtr pkt, PortID exclude_slave_port_id) 902{ 903 // snoops should only happen if the system isn't bypassing caches 904 assert(!system->bypassCaches()); 905 906 for (const auto& p: snoopPorts) { 907 // we could have gotten this request from a snooping master 908 // (corresponding to our own slave port that is also in 909 // snoopPorts) and should not send it back to where it came 910 // from 911 if (exclude_slave_port_id == InvalidPortID || 912 p->getId() != exclude_slave_port_id) 913 p->sendFunctionalSnoop(pkt); 914 915 // if we get a response we are done 916 if (pkt->isResponse()) { 917 break; 918 } 919 } 920} 921 922bool 923CoherentXBar::sinkPacket(const PacketPtr pkt) const 924{ 925 // we can sink the packet if: 926 // 1) the crossbar is the point of coherency, and a cache is 927 // responding after being snooped 928 // 2) the crossbar is the point of coherency, and the packet is a 929 // coherency packet (not a read or a write) that does not 930 // require a response 931 // 3) this is a clean evict or clean writeback, but the packet is 932 // found in a cache above this crossbar 933 // 4) a cache is responding after being snooped, and the packet 934 // either does not need the block to be writable, or the cache 935 // that has promised to respond (setting the cache responding 936 // flag) is providing writable and thus had a Modified block, 937 // and no further action is needed 938 return (pointOfCoherency && pkt->cacheResponding()) || 939 (pointOfCoherency && !(pkt->isRead() || pkt->isWrite()) && 940 !pkt->needsResponse()) || 941 (pkt->isCleanEviction() && pkt->isBlockCached()) || 942 (pkt->cacheResponding() && 943 (!pkt->needsWritable() || pkt->responderHadWritable())); 944} 945 946void 947CoherentXBar::regStats() 948{ 949 // register the stats of the base class and our layers 950 BaseXBar::regStats(); 951 for (auto l: reqLayers) 952 l->regStats(); 953 for (auto l: respLayers) 954 l->regStats(); 955 for (auto l: snoopLayers) 956 l->regStats(); 957 958 snoops 959 .name(name() + ".snoops") 960 .desc("Total snoops (count)") 961 ; 962 963 snoopTraffic 964 .name(name() + ".snoopTraffic") 965 .desc("Total snoop traffic (bytes)") 966 ; 967 968 snoopFanout 969 .init(0, snoopPorts.size(), 1) 970 .name(name() + ".snoop_fanout") 971 .desc("Request fanout histogram") 972 ; 973} 974 975CoherentXBar * 976CoherentXBarParams::create() 977{ 978 return new CoherentXBar(this); 979} 980