coherent_xbar.cc revision 11196
12497SN/A/* 210719SMarco.Balboni@ARM.com * Copyright (c) 2011-2015 ARM Limited 38711SN/A * All rights reserved 48711SN/A * 58711SN/A * The license below extends only to copyright in the software and shall 68711SN/A * not be construed as granting a license to any other intellectual 78711SN/A * property including but not limited to intellectual property relating 88711SN/A * to a hardware implementation of the functionality of the software 98711SN/A * licensed hereunder. You may use the software subject to the license 108711SN/A * terms below provided that you ensure that this notice is replicated 118711SN/A * unmodified and in its entirety in all distributions of the software, 128711SN/A * modified or unmodified, in source code or in binary form. 138711SN/A * 142497SN/A * Copyright (c) 2006 The Regents of The University of Michigan 152497SN/A * All rights reserved. 162497SN/A * 172497SN/A * Redistribution and use in source and binary forms, with or without 182497SN/A * modification, are permitted provided that the following conditions are 192497SN/A * met: redistributions of source code must retain the above copyright 202497SN/A * notice, this list of conditions and the following disclaimer; 212497SN/A * redistributions in binary form must reproduce the above copyright 222497SN/A * notice, this list of conditions and the following disclaimer in the 232497SN/A * documentation and/or other materials provided with the distribution; 242497SN/A * neither the name of the copyright holders nor the names of its 252497SN/A * contributors may be used to endorse or promote products derived from 262497SN/A * this software without specific prior written permission. 272497SN/A * 282497SN/A * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 292497SN/A * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 302497SN/A * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 312497SN/A * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 322497SN/A * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 332497SN/A * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 342497SN/A * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 352497SN/A * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 362497SN/A * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 372497SN/A * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 382497SN/A * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 392665SN/A * 402665SN/A * Authors: Ali Saidi 418715SN/A * Andreas Hansson 428922SN/A * William Wang 432497SN/A */ 442497SN/A 452497SN/A/** 462982SN/A * @file 4710405Sandreas.hansson@arm.com * Definition of a crossbar object. 482497SN/A */ 492497SN/A 502846SN/A#include "base/misc.hh" 512548SN/A#include "base/trace.hh" 5210405Sandreas.hansson@arm.com#include "debug/AddrRanges.hh" 5310405Sandreas.hansson@arm.com#include "debug/CoherentXBar.hh" 5410405Sandreas.hansson@arm.com#include "mem/coherent_xbar.hh" 559524SN/A#include "sim/system.hh" 562497SN/A 5710405Sandreas.hansson@arm.comCoherentXBar::CoherentXBar(const CoherentXBarParams *p) 5810719SMarco.Balboni@ARM.com : BaseXBar(p), system(p->system), snoopFilter(p->snoop_filter), 5910719SMarco.Balboni@ARM.com snoopResponseLatency(p->snoop_response_latency) 607523SN/A{ 618851SN/A // create the ports based on the size of the master and slave 628948SN/A // vector ports, and the presence of the default port, the ports 638948SN/A // are enumerated starting from zero 648851SN/A for (int i = 0; i < p->port_master_connection_count; ++i) { 659095SN/A std::string portName = csprintf("%s.master[%d]", name(), i); 6610405Sandreas.hansson@arm.com MasterPort* bp = new CoherentXBarMasterPort(portName, *this, i); 678922SN/A masterPorts.push_back(bp); 689715SN/A reqLayers.push_back(new ReqLayer(*bp, *this, 699715SN/A csprintf(".reqLayer%d", i))); 7010713Sandreas.hansson@arm.com snoopLayers.push_back(new SnoopRespLayer(*bp, *this, 7110713Sandreas.hansson@arm.com csprintf(".snoopLayer%d", i))); 728851SN/A } 738851SN/A 748948SN/A // see if we have a default slave device connected and if so add 758948SN/A // our corresponding master port 768915SN/A if (p->port_default_connection_count) { 779031SN/A defaultPortID = masterPorts.size(); 789095SN/A std::string portName = name() + ".default"; 7910405Sandreas.hansson@arm.com MasterPort* bp = new CoherentXBarMasterPort(portName, *this, 809036SN/A defaultPortID); 818922SN/A masterPorts.push_back(bp); 829715SN/A reqLayers.push_back(new ReqLayer(*bp, *this, csprintf(".reqLayer%d", 839715SN/A defaultPortID))); 8410713Sandreas.hansson@arm.com snoopLayers.push_back(new SnoopRespLayer(*bp, *this, 8510713Sandreas.hansson@arm.com csprintf(".snoopLayer%d", 8610713Sandreas.hansson@arm.com defaultPortID))); 878915SN/A } 888915SN/A 898948SN/A // create the slave ports, once again starting at zero 908851SN/A for (int i = 0; i < p->port_slave_connection_count; ++i) { 919095SN/A std::string portName = csprintf("%s.slave[%d]", name(), i); 9210888Sandreas.hansson@arm.com QueuedSlavePort* bp = new CoherentXBarSlavePort(portName, *this, i); 938922SN/A slavePorts.push_back(bp); 949715SN/A respLayers.push_back(new RespLayer(*bp, *this, 959715SN/A csprintf(".respLayer%d", i))); 969716SN/A snoopRespPorts.push_back(new SnoopRespPort(*bp, *this)); 978851SN/A } 988851SN/A 997523SN/A clearPortCache(); 1007523SN/A} 1017523SN/A 10210405Sandreas.hansson@arm.comCoherentXBar::~CoherentXBar() 1039715SN/A{ 10410405Sandreas.hansson@arm.com for (auto l: reqLayers) 10510405Sandreas.hansson@arm.com delete l; 10610405Sandreas.hansson@arm.com for (auto l: respLayers) 10710405Sandreas.hansson@arm.com delete l; 10810405Sandreas.hansson@arm.com for (auto l: snoopLayers) 10910405Sandreas.hansson@arm.com delete l; 11010405Sandreas.hansson@arm.com for (auto p: snoopRespPorts) 11110405Sandreas.hansson@arm.com delete p; 1129715SN/A} 1139715SN/A 1142568SN/Avoid 11510405Sandreas.hansson@arm.comCoherentXBar::init() 1162568SN/A{ 1179278SN/A // the base class is responsible for determining the block size 11810405Sandreas.hansson@arm.com BaseXBar::init(); 1199278SN/A 1208948SN/A // iterate over our slave ports and determine which of our 1218948SN/A // neighbouring master ports are snooping and add them as snoopers 12210405Sandreas.hansson@arm.com for (const auto& p: slavePorts) { 1239088SN/A // check if the connected master port is snooping 12410405Sandreas.hansson@arm.com if (p->isSnooping()) { 12510405Sandreas.hansson@arm.com DPRINTF(AddrRanges, "Adding snooping master %s\n", 12610405Sandreas.hansson@arm.com p->getMasterPort().name()); 12710405Sandreas.hansson@arm.com snoopPorts.push_back(p); 1288711SN/A } 1298711SN/A } 1302568SN/A 1319036SN/A if (snoopPorts.empty()) 13210405Sandreas.hansson@arm.com warn("CoherentXBar %s has no snooping ports attached!\n", name()); 13311133Sandreas.hansson@arm.com 13411133Sandreas.hansson@arm.com // inform the snoop filter about the slave ports so it can create 13511133Sandreas.hansson@arm.com // its own internal representation 13611133Sandreas.hansson@arm.com if (snoopFilter) 13711133Sandreas.hansson@arm.com snoopFilter->setSlavePorts(slavePorts); 1383244SN/A} 1393244SN/A 1408948SN/Abool 14110405Sandreas.hansson@arm.comCoherentXBar::recvTimingReq(PacketPtr pkt, PortID slave_port_id) 1423244SN/A{ 1438975SN/A // determine the source port based on the id 1449032SN/A SlavePort *src_port = slavePorts[slave_port_id]; 1453244SN/A 1469091SN/A // remember if the packet is an express snoop 1479091SN/A bool is_express_snoop = pkt->isExpressSnoop(); 14810656Sandreas.hansson@arm.com bool is_inhibited = pkt->memInhibitAsserted(); 14910656Sandreas.hansson@arm.com // for normal requests, going downstream, the express snoop flag 15010656Sandreas.hansson@arm.com // and the inhibited flag should always be the same 15110656Sandreas.hansson@arm.com assert(is_express_snoop == is_inhibited); 1529091SN/A 1539612SN/A // determine the destination based on the address 1549712SN/A PortID master_port_id = findPort(pkt->getAddr()); 1559612SN/A 15610405Sandreas.hansson@arm.com // test if the crossbar should be considered occupied for the current 1579033SN/A // port, and exclude express snoops from the check 1589715SN/A if (!is_express_snoop && !reqLayers[master_port_id]->tryTiming(src_port)) { 15910405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x BUSY\n", 1608949SN/A src_port->name(), pkt->cmdString(), pkt->getAddr()); 1613244SN/A return false; 1623244SN/A } 1633244SN/A 16410405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvTimingReq: src %s %s expr %d 0x%x\n", 1659091SN/A src_port->name(), pkt->cmdString(), is_express_snoop, 1669091SN/A pkt->getAddr()); 1675197SN/A 1689712SN/A // store size and command as they might be modified when 1699712SN/A // forwarding the packet 1709712SN/A unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 1719712SN/A unsigned int pkt_cmd = pkt->cmdToIndex(); 1729712SN/A 17310719SMarco.Balboni@ARM.com // store the old header delay so we can restore it if needed 17410719SMarco.Balboni@ARM.com Tick old_header_delay = pkt->headerDelay; 17510719SMarco.Balboni@ARM.com 17610719SMarco.Balboni@ARM.com // a request sees the frontend and forward latency 17710719SMarco.Balboni@ARM.com Tick xbar_delay = (frontendLatency + forwardLatency) * clockPeriod(); 17810719SMarco.Balboni@ARM.com 17910719SMarco.Balboni@ARM.com // set the packet header and payload delay 18010719SMarco.Balboni@ARM.com calcPacketTiming(pkt, xbar_delay); 18110719SMarco.Balboni@ARM.com 18210719SMarco.Balboni@ARM.com // determine how long to be crossbar layer is busy 18310719SMarco.Balboni@ARM.com Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 1844912SN/A 18510821Sandreas.hansson@arm.com if (!system->bypassCaches()) { 18611127Sandreas.hansson@arm.com assert(pkt->snoopDelay == 0); 18711127Sandreas.hansson@arm.com 1888979SN/A // the packet is a memory-mapped request and should be 1898979SN/A // broadcasted to our snoopers but the source 19010402SN/A if (snoopFilter) { 19110402SN/A // check with the snoop filter where to forward this packet 19210402SN/A auto sf_res = snoopFilter->lookupRequest(pkt, *src_port); 19311126Sandreas.hansson@arm.com // the time required by a packet to be delivered through 19411126Sandreas.hansson@arm.com // the xbar has to be charged also with to lookup latency 19511126Sandreas.hansson@arm.com // of the snoop filter 19610719SMarco.Balboni@ARM.com pkt->headerDelay += sf_res.second * clockPeriod(); 19710405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x"\ 19810402SN/A " SF size: %i lat: %i\n", src_port->name(), 19910402SN/A pkt->cmdString(), pkt->getAddr(), sf_res.first.size(), 20010402SN/A sf_res.second); 20111196Sali.jafri@arm.com 20211196Sali.jafri@arm.com if (pkt->evictingBlock()) { 20311196Sali.jafri@arm.com // for block-evicting packets, i.e. writebacks and 20411196Sali.jafri@arm.com // clean evictions, there is no need to snoop up, as 20511196Sali.jafri@arm.com // all we do is determine if the block is cached or 20611196Sali.jafri@arm.com // not, instead just set it here based on the snoop 20711196Sali.jafri@arm.com // filter result 20811196Sali.jafri@arm.com if (!sf_res.first.empty()) 20911196Sali.jafri@arm.com pkt->setBlockCached(); 21011196Sali.jafri@arm.com } else { 21111196Sali.jafri@arm.com forwardTiming(pkt, slave_port_id, sf_res.first); 21211196Sali.jafri@arm.com } 21310402SN/A } else { 21410402SN/A forwardTiming(pkt, slave_port_id); 21510402SN/A } 21611127Sandreas.hansson@arm.com 21711127Sandreas.hansson@arm.com // add the snoop delay to our header delay, and then reset it 21811127Sandreas.hansson@arm.com pkt->headerDelay += pkt->snoopDelay; 21911127Sandreas.hansson@arm.com pkt->snoopDelay = 0; 2208979SN/A } 2218948SN/A 22210883Sali.jafri@arm.com // forwardTiming snooped into peer caches of the sender, and if 22310883Sali.jafri@arm.com // this is a clean evict, but the packet is found in a cache, do 22410883Sali.jafri@arm.com // not forward it 22510883Sali.jafri@arm.com if (pkt->cmd == MemCmd::CleanEvict && pkt->isBlockCached()) { 22610883Sali.jafri@arm.com DPRINTF(CoherentXBar, "recvTimingReq: Clean evict 0x%x still cached, " 22710883Sali.jafri@arm.com "not forwarding\n", pkt->getAddr()); 22810883Sali.jafri@arm.com 22910883Sali.jafri@arm.com // update the layer state and schedule an idle event 23010883Sali.jafri@arm.com reqLayers[master_port_id]->succeededTiming(packetFinishTime); 23111190Sandreas.hansson@arm.com 23211190Sandreas.hansson@arm.com // queue the packet for deletion 23311190Sandreas.hansson@arm.com pendingDelete.reset(pkt); 23411190Sandreas.hansson@arm.com 23510883Sali.jafri@arm.com return true; 23610883Sali.jafri@arm.com } 23710883Sali.jafri@arm.com 23810656Sandreas.hansson@arm.com // remember if the packet will generate a snoop response 23910656Sandreas.hansson@arm.com const bool expect_snoop_resp = !is_inhibited && pkt->memInhibitAsserted(); 24010656Sandreas.hansson@arm.com const bool expect_response = pkt->needsResponse() && 24110656Sandreas.hansson@arm.com !pkt->memInhibitAsserted(); 2428915SN/A 2439612SN/A // since it is a normal request, attempt to send the packet 2449712SN/A bool success = masterPorts[master_port_id]->sendTimingReq(pkt); 2458948SN/A 24610821Sandreas.hansson@arm.com if (snoopFilter && !system->bypassCaches()) { 24710402SN/A // Let the snoop filter know about the success of the send operation 24811131Sandreas.hansson@arm.com snoopFilter->finishRequest(!success, pkt); 24910402SN/A } 25010402SN/A 25110656Sandreas.hansson@arm.com // check if we were successful in sending the packet onwards 25210656Sandreas.hansson@arm.com if (!success) { 25310656Sandreas.hansson@arm.com // express snoops and inhibited packets should never be forced 25410656Sandreas.hansson@arm.com // to retry 25510656Sandreas.hansson@arm.com assert(!is_express_snoop); 25610656Sandreas.hansson@arm.com assert(!pkt->memInhibitAsserted()); 25710656Sandreas.hansson@arm.com 25810719SMarco.Balboni@ARM.com // restore the header delay 25910719SMarco.Balboni@ARM.com pkt->headerDelay = old_header_delay; 26010656Sandreas.hansson@arm.com 26110656Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x RETRY\n", 26210656Sandreas.hansson@arm.com src_port->name(), pkt->cmdString(), pkt->getAddr()); 26310656Sandreas.hansson@arm.com 26410656Sandreas.hansson@arm.com // update the layer state and schedule an idle event 26510656Sandreas.hansson@arm.com reqLayers[master_port_id]->failedTiming(src_port, 26610719SMarco.Balboni@ARM.com clockEdge(Cycles(1))); 2679091SN/A } else { 26810656Sandreas.hansson@arm.com // express snoops currently bypass the crossbar state entirely 26910656Sandreas.hansson@arm.com if (!is_express_snoop) { 27010656Sandreas.hansson@arm.com // if this particular request will generate a snoop 27110656Sandreas.hansson@arm.com // response 27210656Sandreas.hansson@arm.com if (expect_snoop_resp) { 27310656Sandreas.hansson@arm.com // we should never have an exsiting request outstanding 27410656Sandreas.hansson@arm.com assert(outstandingSnoop.find(pkt->req) == 27510656Sandreas.hansson@arm.com outstandingSnoop.end()); 27610656Sandreas.hansson@arm.com outstandingSnoop.insert(pkt->req); 2778948SN/A 27810656Sandreas.hansson@arm.com // basic sanity check on the outstanding snoops 27910656Sandreas.hansson@arm.com panic_if(outstandingSnoop.size() > 512, 28010656Sandreas.hansson@arm.com "Outstanding snoop requests exceeded 512\n"); 28110656Sandreas.hansson@arm.com } 2828948SN/A 28310656Sandreas.hansson@arm.com // remember where to route the normal response to 28410656Sandreas.hansson@arm.com if (expect_response || expect_snoop_resp) { 28510656Sandreas.hansson@arm.com assert(routeTo.find(pkt->req) == routeTo.end()); 28610656Sandreas.hansson@arm.com routeTo[pkt->req] = slave_port_id; 2879549SN/A 28810656Sandreas.hansson@arm.com panic_if(routeTo.size() > 512, 28910656Sandreas.hansson@arm.com "Routing table exceeds 512 packets\n"); 29010656Sandreas.hansson@arm.com } 2918948SN/A 29210405Sandreas.hansson@arm.com // update the layer state and schedule an idle event 2939715SN/A reqLayers[master_port_id]->succeededTiming(packetFinishTime); 2949091SN/A } 2958975SN/A 29610656Sandreas.hansson@arm.com // stats updates only consider packets that were successfully sent 2979712SN/A pktCount[slave_port_id][master_port_id]++; 29810405Sandreas.hansson@arm.com pktSize[slave_port_id][master_port_id] += pkt_size; 2999712SN/A transDist[pkt_cmd]++; 30010656Sandreas.hansson@arm.com 30110656Sandreas.hansson@arm.com if (is_express_snoop) 30210656Sandreas.hansson@arm.com snoops++; 3039712SN/A } 3049712SN/A 3059091SN/A return success; 3068975SN/A} 3078975SN/A 3088975SN/Abool 30910405Sandreas.hansson@arm.comCoherentXBar::recvTimingResp(PacketPtr pkt, PortID master_port_id) 3108975SN/A{ 3118975SN/A // determine the source port based on the id 3129032SN/A MasterPort *src_port = masterPorts[master_port_id]; 3138975SN/A 31410656Sandreas.hansson@arm.com // determine the destination 31510656Sandreas.hansson@arm.com const auto route_lookup = routeTo.find(pkt->req); 31610656Sandreas.hansson@arm.com assert(route_lookup != routeTo.end()); 31710656Sandreas.hansson@arm.com const PortID slave_port_id = route_lookup->second; 31810572Sandreas.hansson@arm.com assert(slave_port_id != InvalidPortID); 31910572Sandreas.hansson@arm.com assert(slave_port_id < respLayers.size()); 3209713SN/A 32110405Sandreas.hansson@arm.com // test if the crossbar should be considered occupied for the 32210405Sandreas.hansson@arm.com // current port 3239715SN/A if (!respLayers[slave_port_id]->tryTiming(src_port)) { 32410405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvTimingResp: src %s %s 0x%x BUSY\n", 3258975SN/A src_port->name(), pkt->cmdString(), pkt->getAddr()); 3268975SN/A return false; 3278975SN/A } 3288975SN/A 32910405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvTimingResp: src %s %s 0x%x\n", 3308975SN/A src_port->name(), pkt->cmdString(), pkt->getAddr()); 3318975SN/A 3329712SN/A // store size and command as they might be modified when 3339712SN/A // forwarding the packet 3349712SN/A unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 3359712SN/A unsigned int pkt_cmd = pkt->cmdToIndex(); 3369712SN/A 33710719SMarco.Balboni@ARM.com // a response sees the response latency 33810719SMarco.Balboni@ARM.com Tick xbar_delay = responseLatency * clockPeriod(); 33910719SMarco.Balboni@ARM.com 34010719SMarco.Balboni@ARM.com // set the packet header and payload delay 34110719SMarco.Balboni@ARM.com calcPacketTiming(pkt, xbar_delay); 34210719SMarco.Balboni@ARM.com 34310719SMarco.Balboni@ARM.com // determine how long to be crossbar layer is busy 34410719SMarco.Balboni@ARM.com Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 3458975SN/A 34610821Sandreas.hansson@arm.com if (snoopFilter && !system->bypassCaches()) { 34710402SN/A // let the snoop filter inspect the response and update its state 34810402SN/A snoopFilter->updateResponse(pkt, *slavePorts[slave_port_id]); 34910402SN/A } 35010402SN/A 35110888Sandreas.hansson@arm.com // send the packet through the destination slave port and pay for 35210888Sandreas.hansson@arm.com // any outstanding header delay 35310888Sandreas.hansson@arm.com Tick latency = pkt->headerDelay; 35410888Sandreas.hansson@arm.com pkt->headerDelay = 0; 35510888Sandreas.hansson@arm.com slavePorts[slave_port_id]->schedTimingResp(pkt, curTick() + latency); 3568975SN/A 35710656Sandreas.hansson@arm.com // remove the request from the routing table 35810656Sandreas.hansson@arm.com routeTo.erase(route_lookup); 35910656Sandreas.hansson@arm.com 3609715SN/A respLayers[slave_port_id]->succeededTiming(packetFinishTime); 3618975SN/A 3629712SN/A // stats updates 3639712SN/A pktCount[slave_port_id][master_port_id]++; 36410405Sandreas.hansson@arm.com pktSize[slave_port_id][master_port_id] += pkt_size; 3659712SN/A transDist[pkt_cmd]++; 3669712SN/A 3678975SN/A return true; 3688975SN/A} 3698975SN/A 3708975SN/Avoid 37110405Sandreas.hansson@arm.comCoherentXBar::recvTimingSnoopReq(PacketPtr pkt, PortID master_port_id) 3728975SN/A{ 37310405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvTimingSnoopReq: src %s %s 0x%x\n", 3749032SN/A masterPorts[master_port_id]->name(), pkt->cmdString(), 3758975SN/A pkt->getAddr()); 3768975SN/A 3779712SN/A // update stats here as we know the forwarding will succeed 3789712SN/A transDist[pkt->cmdToIndex()]++; 37910405Sandreas.hansson@arm.com snoops++; 3809712SN/A 3818975SN/A // we should only see express snoops from caches 3828975SN/A assert(pkt->isExpressSnoop()); 3838975SN/A 38411127Sandreas.hansson@arm.com // set the packet header and payload delay, for now use forward latency 38511127Sandreas.hansson@arm.com // @todo Assess the choice of latency further 38611127Sandreas.hansson@arm.com calcPacketTiming(pkt, forwardLatency * clockPeriod()); 38711127Sandreas.hansson@arm.com 38810656Sandreas.hansson@arm.com // remeber if the packet is inhibited so we can see if it changes 38910656Sandreas.hansson@arm.com const bool is_inhibited = pkt->memInhibitAsserted(); 3909032SN/A 39111127Sandreas.hansson@arm.com assert(pkt->snoopDelay == 0); 39211127Sandreas.hansson@arm.com 39310402SN/A if (snoopFilter) { 39410402SN/A // let the Snoop Filter work its magic and guide probing 39510402SN/A auto sf_res = snoopFilter->lookupSnoop(pkt); 39611126Sandreas.hansson@arm.com // the time required by a packet to be delivered through 39711126Sandreas.hansson@arm.com // the xbar has to be charged also with to lookup latency 39811126Sandreas.hansson@arm.com // of the snoop filter 39911126Sandreas.hansson@arm.com pkt->headerDelay += sf_res.second * clockPeriod(); 40010405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvTimingSnoopReq: src %s %s 0x%x"\ 40110402SN/A " SF size: %i lat: %i\n", masterPorts[master_port_id]->name(), 40210402SN/A pkt->cmdString(), pkt->getAddr(), sf_res.first.size(), 40310402SN/A sf_res.second); 40410402SN/A 40510402SN/A // forward to all snoopers 40610402SN/A forwardTiming(pkt, InvalidPortID, sf_res.first); 40710402SN/A } else { 40810402SN/A forwardTiming(pkt, InvalidPortID); 40910402SN/A } 4108975SN/A 41111127Sandreas.hansson@arm.com // add the snoop delay to our header delay, and then reset it 41211127Sandreas.hansson@arm.com pkt->headerDelay += pkt->snoopDelay; 41311127Sandreas.hansson@arm.com pkt->snoopDelay = 0; 41411127Sandreas.hansson@arm.com 41510656Sandreas.hansson@arm.com // if we can expect a response, remember how to route it 41610656Sandreas.hansson@arm.com if (!is_inhibited && pkt->memInhibitAsserted()) { 41710656Sandreas.hansson@arm.com assert(routeTo.find(pkt->req) == routeTo.end()); 41810656Sandreas.hansson@arm.com routeTo[pkt->req] = master_port_id; 41910656Sandreas.hansson@arm.com } 42010656Sandreas.hansson@arm.com 4218975SN/A // a snoop request came from a connected slave device (one of 4228975SN/A // our master ports), and if it is not coming from the slave 4238975SN/A // device responsible for the address range something is 4248975SN/A // wrong, hence there is nothing further to do as the packet 4258975SN/A // would be going back to where it came from 4269032SN/A assert(master_port_id == findPort(pkt->getAddr())); 4278975SN/A} 4288975SN/A 4298975SN/Abool 43010405Sandreas.hansson@arm.comCoherentXBar::recvTimingSnoopResp(PacketPtr pkt, PortID slave_port_id) 4318975SN/A{ 4328975SN/A // determine the source port based on the id 4339032SN/A SlavePort* src_port = slavePorts[slave_port_id]; 4348975SN/A 43510656Sandreas.hansson@arm.com // get the destination 43610656Sandreas.hansson@arm.com const auto route_lookup = routeTo.find(pkt->req); 43710656Sandreas.hansson@arm.com assert(route_lookup != routeTo.end()); 43810656Sandreas.hansson@arm.com const PortID dest_port_id = route_lookup->second; 43910572Sandreas.hansson@arm.com assert(dest_port_id != InvalidPortID); 4409714SN/A 4419714SN/A // determine if the response is from a snoop request we 4429714SN/A // created as the result of a normal request (in which case it 44310656Sandreas.hansson@arm.com // should be in the outstandingSnoop), or if we merely forwarded 4449714SN/A // someone else's snoop request 44510656Sandreas.hansson@arm.com const bool forwardAsSnoop = outstandingSnoop.find(pkt->req) == 44610656Sandreas.hansson@arm.com outstandingSnoop.end(); 4479714SN/A 44810405Sandreas.hansson@arm.com // test if the crossbar should be considered occupied for the 44910405Sandreas.hansson@arm.com // current port, note that the check is bypassed if the response 45010405Sandreas.hansson@arm.com // is being passed on as a normal response since this is occupying 45110405Sandreas.hansson@arm.com // the response layer rather than the snoop response layer 4529715SN/A if (forwardAsSnoop) { 45310572Sandreas.hansson@arm.com assert(dest_port_id < snoopLayers.size()); 4549715SN/A if (!snoopLayers[dest_port_id]->tryTiming(src_port)) { 45510405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x BUSY\n", 4569715SN/A src_port->name(), pkt->cmdString(), pkt->getAddr()); 4579715SN/A return false; 4589715SN/A } 4599716SN/A } else { 4609716SN/A // get the master port that mirrors this slave port internally 4619716SN/A MasterPort* snoop_port = snoopRespPorts[slave_port_id]; 46210572Sandreas.hansson@arm.com assert(dest_port_id < respLayers.size()); 4639716SN/A if (!respLayers[dest_port_id]->tryTiming(snoop_port)) { 46410405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x BUSY\n", 4659716SN/A snoop_port->name(), pkt->cmdString(), pkt->getAddr()); 4669716SN/A return false; 4679716SN/A } 4688975SN/A } 4698975SN/A 47010405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x\n", 4718975SN/A src_port->name(), pkt->cmdString(), pkt->getAddr()); 4728975SN/A 4739712SN/A // store size and command as they might be modified when 4749712SN/A // forwarding the packet 4759712SN/A unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 4769712SN/A unsigned int pkt_cmd = pkt->cmdToIndex(); 4779712SN/A 4788975SN/A // responses are never express snoops 4798975SN/A assert(!pkt->isExpressSnoop()); 4808975SN/A 48110719SMarco.Balboni@ARM.com // a snoop response sees the snoop response latency, and if it is 48210719SMarco.Balboni@ARM.com // forwarded as a normal response, the response latency 48310719SMarco.Balboni@ARM.com Tick xbar_delay = 48410719SMarco.Balboni@ARM.com (forwardAsSnoop ? snoopResponseLatency : responseLatency) * 48510719SMarco.Balboni@ARM.com clockPeriod(); 48610719SMarco.Balboni@ARM.com 48710719SMarco.Balboni@ARM.com // set the packet header and payload delay 48810719SMarco.Balboni@ARM.com calcPacketTiming(pkt, xbar_delay); 48910719SMarco.Balboni@ARM.com 49010719SMarco.Balboni@ARM.com // determine how long to be crossbar layer is busy 49110719SMarco.Balboni@ARM.com Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay; 4928975SN/A 4939714SN/A // forward it either as a snoop response or a normal response 4949714SN/A if (forwardAsSnoop) { 4959714SN/A // this is a snoop response to a snoop request we forwarded, 4969714SN/A // e.g. coming from the L1 and going to the L2, and it should 4979714SN/A // be forwarded as a snoop response 49810402SN/A 49910402SN/A if (snoopFilter) { 50010402SN/A // update the probe filter so that it can properly track the line 50110402SN/A snoopFilter->updateSnoopForward(pkt, *slavePorts[slave_port_id], 50210402SN/A *masterPorts[dest_port_id]); 50310402SN/A } 50410402SN/A 5059712SN/A bool success M5_VAR_USED = 5069712SN/A masterPorts[dest_port_id]->sendTimingSnoopResp(pkt); 5079712SN/A pktCount[slave_port_id][dest_port_id]++; 50810405Sandreas.hansson@arm.com pktSize[slave_port_id][dest_port_id] += pkt_size; 5098975SN/A assert(success); 5109714SN/A 5119715SN/A snoopLayers[dest_port_id]->succeededTiming(packetFinishTime); 5123244SN/A } else { 5138975SN/A // we got a snoop response on one of our slave ports, 51410405Sandreas.hansson@arm.com // i.e. from a coherent master connected to the crossbar, and 51510405Sandreas.hansson@arm.com // since we created the snoop request as part of recvTiming, 51610405Sandreas.hansson@arm.com // this should now be a normal response again 51710656Sandreas.hansson@arm.com outstandingSnoop.erase(pkt->req); 5188948SN/A 51910656Sandreas.hansson@arm.com // this is a snoop response from a coherent master, hence it 52010656Sandreas.hansson@arm.com // should never go back to where the snoop response came from, 52110656Sandreas.hansson@arm.com // but instead to where the original request came from 5229712SN/A assert(slave_port_id != dest_port_id); 5238948SN/A 52410402SN/A if (snoopFilter) { 52510402SN/A // update the probe filter so that it can properly track the line 52610402SN/A snoopFilter->updateSnoopResponse(pkt, *slavePorts[slave_port_id], 52710402SN/A *slavePorts[dest_port_id]); 52810402SN/A } 52910402SN/A 53010405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x"\ 53110402SN/A " FWD RESP\n", src_port->name(), pkt->cmdString(), 53210402SN/A pkt->getAddr()); 53310402SN/A 5349714SN/A // as a normal response, it should go back to a master through 53510888Sandreas.hansson@arm.com // one of our slave ports, we also pay for any outstanding 53610888Sandreas.hansson@arm.com // header latency 53710888Sandreas.hansson@arm.com Tick latency = pkt->headerDelay; 53810888Sandreas.hansson@arm.com pkt->headerDelay = 0; 53910888Sandreas.hansson@arm.com slavePorts[dest_port_id]->schedTimingResp(pkt, curTick() + latency); 5409716SN/A 5419716SN/A respLayers[dest_port_id]->succeededTiming(packetFinishTime); 5423244SN/A } 5433244SN/A 54410656Sandreas.hansson@arm.com // remove the request from the routing table 54510656Sandreas.hansson@arm.com routeTo.erase(route_lookup); 54610656Sandreas.hansson@arm.com 5479712SN/A // stats updates 5489712SN/A transDist[pkt_cmd]++; 54910405Sandreas.hansson@arm.com snoops++; 5509712SN/A 5518948SN/A return true; 5528948SN/A} 5538948SN/A 5543210SN/A 5558948SN/Avoid 55610405Sandreas.hansson@arm.comCoherentXBar::forwardTiming(PacketPtr pkt, PortID exclude_slave_port_id, 55710888Sandreas.hansson@arm.com const std::vector<QueuedSlavePort*>& dests) 5588948SN/A{ 55910405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "%s for %s address %x size %d\n", __func__, 5609663SN/A pkt->cmdString(), pkt->getAddr(), pkt->getSize()); 5619663SN/A 5629524SN/A // snoops should only happen if the system isn't bypassing caches 5639524SN/A assert(!system->bypassCaches()); 5649524SN/A 56510401SN/A unsigned fanout = 0; 56610401SN/A 56710405Sandreas.hansson@arm.com for (const auto& p: dests) { 5688948SN/A // we could have gotten this request from a snooping master 5698948SN/A // (corresponding to our own slave port that is also in 5708948SN/A // snoopPorts) and should not send it back to where it came 5718948SN/A // from 5729031SN/A if (exclude_slave_port_id == InvalidPortID || 5738948SN/A p->getId() != exclude_slave_port_id) { 5748948SN/A // cache is not allowed to refuse snoop 5758975SN/A p->sendTimingSnoopReq(pkt); 57610401SN/A fanout++; 5778948SN/A } 5788948SN/A } 57910401SN/A 58010401SN/A // Stats for fanout of this forward operation 58110401SN/A snoopFanout.sample(fanout); 5822497SN/A} 5832497SN/A 5849092SN/Avoid 58510713Sandreas.hansson@arm.comCoherentXBar::recvReqRetry(PortID master_port_id) 5869092SN/A{ 5879093SN/A // responses and snoop responses never block on forwarding them, 5889093SN/A // so the retry will always be coming from a port to which we 5899093SN/A // tried to forward a request 5909715SN/A reqLayers[master_port_id]->recvRetry(); 5919092SN/A} 5929092SN/A 5939036SN/ATick 59410405Sandreas.hansson@arm.comCoherentXBar::recvAtomic(PacketPtr pkt, PortID slave_port_id) 5952657SN/A{ 59610405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvAtomic: packet src %s addr 0x%x cmd %s\n", 5979032SN/A slavePorts[slave_port_id]->name(), pkt->getAddr(), 5988949SN/A pkt->cmdString()); 5998915SN/A 60010405Sandreas.hansson@arm.com unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0; 60110405Sandreas.hansson@arm.com unsigned int pkt_cmd = pkt->cmdToIndex(); 6029712SN/A 6038979SN/A MemCmd snoop_response_cmd = MemCmd::InvalidCmd; 6048979SN/A Tick snoop_response_latency = 0; 6058979SN/A 60610821Sandreas.hansson@arm.com if (!system->bypassCaches()) { 6078979SN/A // forward to all snoopers but the source 60810402SN/A std::pair<MemCmd, Tick> snoop_result; 60910402SN/A if (snoopFilter) { 61010402SN/A // check with the snoop filter where to forward this packet 61110402SN/A auto sf_res = 61210402SN/A snoopFilter->lookupRequest(pkt, *slavePorts[slave_port_id]); 61310402SN/A snoop_response_latency += sf_res.second * clockPeriod(); 61410405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "%s: src %s %s 0x%x"\ 61510402SN/A " SF size: %i lat: %i\n", __func__, 61610402SN/A slavePorts[slave_port_id]->name(), pkt->cmdString(), 61710402SN/A pkt->getAddr(), sf_res.first.size(), sf_res.second); 61811130Sali.jafri@arm.com 61911130Sali.jafri@arm.com // let the snoop filter know about the success of the send 62011130Sali.jafri@arm.com // operation, and do it even before sending it onwards to 62111130Sali.jafri@arm.com // avoid situations where atomic upward snoops sneak in 62211130Sali.jafri@arm.com // between and change the filter state 62311131Sandreas.hansson@arm.com snoopFilter->finishRequest(false, pkt); 62411130Sali.jafri@arm.com 62510402SN/A snoop_result = forwardAtomic(pkt, slave_port_id, InvalidPortID, 62610402SN/A sf_res.first); 62710402SN/A } else { 62810402SN/A snoop_result = forwardAtomic(pkt, slave_port_id); 62910402SN/A } 6308979SN/A snoop_response_cmd = snoop_result.first; 63110402SN/A snoop_response_latency += snoop_result.second; 6328979SN/A } 6338915SN/A 63411130Sali.jafri@arm.com // forwardAtomic snooped into peer caches of the sender, and if 63511130Sali.jafri@arm.com // this is a clean evict, but the packet is found in a cache, do 63611130Sali.jafri@arm.com // not forward it 63711130Sali.jafri@arm.com if (pkt->cmd == MemCmd::CleanEvict && pkt->isBlockCached()) { 63811130Sali.jafri@arm.com DPRINTF(CoherentXBar, "recvAtomic: Clean evict 0x%x still cached, " 63911130Sali.jafri@arm.com "not forwarding\n", pkt->getAddr()); 64011130Sali.jafri@arm.com return 0; 64111130Sali.jafri@arm.com } 64211130Sali.jafri@arm.com 6438948SN/A // even if we had a snoop response, we must continue and also 6448948SN/A // perform the actual request at the destination 64510405Sandreas.hansson@arm.com PortID master_port_id = findPort(pkt->getAddr()); 64610405Sandreas.hansson@arm.com 64710405Sandreas.hansson@arm.com // stats updates for the request 64810405Sandreas.hansson@arm.com pktCount[slave_port_id][master_port_id]++; 64910405Sandreas.hansson@arm.com pktSize[slave_port_id][master_port_id] += pkt_size; 65010405Sandreas.hansson@arm.com transDist[pkt_cmd]++; 6518948SN/A 6528948SN/A // forward the request to the appropriate destination 65310405Sandreas.hansson@arm.com Tick response_latency = masterPorts[master_port_id]->sendAtomic(pkt); 6548948SN/A 65511130Sali.jafri@arm.com // if lower levels have replied, tell the snoop filter 65611130Sali.jafri@arm.com if (!system->bypassCaches() && snoopFilter && pkt->isResponse()) { 65710402SN/A snoopFilter->updateResponse(pkt, *slavePorts[slave_port_id]); 65810402SN/A } 65910402SN/A 6608948SN/A // if we got a response from a snooper, restore it here 6618948SN/A if (snoop_response_cmd != MemCmd::InvalidCmd) { 6628948SN/A // no one else should have responded 6638948SN/A assert(!pkt->isResponse()); 6648948SN/A pkt->cmd = snoop_response_cmd; 6658948SN/A response_latency = snoop_response_latency; 6668948SN/A } 6678948SN/A 6689712SN/A // add the response data 66910405Sandreas.hansson@arm.com if (pkt->isResponse()) { 67010405Sandreas.hansson@arm.com pkt_size = pkt->hasData() ? pkt->getSize() : 0; 67110405Sandreas.hansson@arm.com pkt_cmd = pkt->cmdToIndex(); 67210405Sandreas.hansson@arm.com 67310405Sandreas.hansson@arm.com // stats updates 67410405Sandreas.hansson@arm.com pktCount[slave_port_id][master_port_id]++; 67510405Sandreas.hansson@arm.com pktSize[slave_port_id][master_port_id] += pkt_size; 67610405Sandreas.hansson@arm.com transDist[pkt_cmd]++; 67710405Sandreas.hansson@arm.com } 6789712SN/A 67910694SMarco.Balboni@ARM.com // @todo: Not setting header time 68010694SMarco.Balboni@ARM.com pkt->payloadDelay = response_latency; 6818948SN/A return response_latency; 6828948SN/A} 6838948SN/A 6848948SN/ATick 68510405Sandreas.hansson@arm.comCoherentXBar::recvAtomicSnoop(PacketPtr pkt, PortID master_port_id) 6868948SN/A{ 68710405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "recvAtomicSnoop: packet src %s addr 0x%x cmd %s\n", 6889032SN/A masterPorts[master_port_id]->name(), pkt->getAddr(), 6898949SN/A pkt->cmdString()); 6908948SN/A 6919712SN/A // add the request snoop data 69210405Sandreas.hansson@arm.com snoops++; 6939712SN/A 6948948SN/A // forward to all snoopers 69510402SN/A std::pair<MemCmd, Tick> snoop_result; 69610402SN/A Tick snoop_response_latency = 0; 69710402SN/A if (snoopFilter) { 69810402SN/A auto sf_res = snoopFilter->lookupSnoop(pkt); 69910402SN/A snoop_response_latency += sf_res.second * clockPeriod(); 70010405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, "%s: src %s %s 0x%x SF size: %i lat: %i\n", 70110402SN/A __func__, masterPorts[master_port_id]->name(), pkt->cmdString(), 70210402SN/A pkt->getAddr(), sf_res.first.size(), sf_res.second); 70310402SN/A snoop_result = forwardAtomic(pkt, InvalidPortID, master_port_id, 70410402SN/A sf_res.first); 70510402SN/A } else { 70610402SN/A snoop_result = forwardAtomic(pkt, InvalidPortID); 70710402SN/A } 7088948SN/A MemCmd snoop_response_cmd = snoop_result.first; 70910402SN/A snoop_response_latency += snoop_result.second; 7108948SN/A 7118948SN/A if (snoop_response_cmd != MemCmd::InvalidCmd) 7128948SN/A pkt->cmd = snoop_response_cmd; 7138948SN/A 7149712SN/A // add the response snoop data 71510401SN/A if (pkt->isResponse()) { 71610405Sandreas.hansson@arm.com snoops++; 71710401SN/A } 7189712SN/A 71910694SMarco.Balboni@ARM.com // @todo: Not setting header time 72010694SMarco.Balboni@ARM.com pkt->payloadDelay = snoop_response_latency; 7218948SN/A return snoop_response_latency; 7228948SN/A} 7238948SN/A 7248948SN/Astd::pair<MemCmd, Tick> 72510405Sandreas.hansson@arm.comCoherentXBar::forwardAtomic(PacketPtr pkt, PortID exclude_slave_port_id, 72610402SN/A PortID source_master_port_id, 72710888Sandreas.hansson@arm.com const std::vector<QueuedSlavePort*>& dests) 7288948SN/A{ 7299032SN/A // the packet may be changed on snoops, record the original 7309032SN/A // command to enable us to restore it between snoops so that 7318948SN/A // additional snoops can take place properly 7324626SN/A MemCmd orig_cmd = pkt->cmd; 7334879SN/A MemCmd snoop_response_cmd = MemCmd::InvalidCmd; 7344879SN/A Tick snoop_response_latency = 0; 7353662SN/A 7369524SN/A // snoops should only happen if the system isn't bypassing caches 7379524SN/A assert(!system->bypassCaches()); 7389524SN/A 73910401SN/A unsigned fanout = 0; 74010401SN/A 74110405Sandreas.hansson@arm.com for (const auto& p: dests) { 7428915SN/A // we could have gotten this request from a snooping master 7438915SN/A // (corresponding to our own slave port that is also in 7448915SN/A // snoopPorts) and should not send it back to where it came 7458915SN/A // from 74610402SN/A if (exclude_slave_port_id != InvalidPortID && 74710402SN/A p->getId() == exclude_slave_port_id) 74810402SN/A continue; 74910401SN/A 75010402SN/A Tick latency = p->sendAtomicSnoop(pkt); 75110402SN/A fanout++; 75210402SN/A 75310402SN/A // in contrast to a functional access, we have to keep on 75410402SN/A // going as all snoopers must be updated even if we get a 75510402SN/A // response 75610402SN/A if (!pkt->isResponse()) 75710402SN/A continue; 75810402SN/A 75910402SN/A // response from snoop agent 76010402SN/A assert(pkt->cmd != orig_cmd); 76110402SN/A assert(pkt->memInhibitAsserted()); 76210402SN/A // should only happen once 76310402SN/A assert(snoop_response_cmd == MemCmd::InvalidCmd); 76410402SN/A // save response state 76510402SN/A snoop_response_cmd = pkt->cmd; 76610402SN/A snoop_response_latency = latency; 76710402SN/A 76810402SN/A if (snoopFilter) { 76910402SN/A // Handle responses by the snoopers and differentiate between 77010402SN/A // responses to requests from above and snoops from below 77110402SN/A if (source_master_port_id != InvalidPortID) { 77210402SN/A // Getting a response for a snoop from below 77310402SN/A assert(exclude_slave_port_id == InvalidPortID); 77410402SN/A snoopFilter->updateSnoopForward(pkt, *p, 77510402SN/A *masterPorts[source_master_port_id]); 77610402SN/A } else { 77710402SN/A // Getting a response for a request from above 77810402SN/A assert(source_master_port_id == InvalidPortID); 77910402SN/A snoopFilter->updateSnoopResponse(pkt, *p, 78010402SN/A *slavePorts[exclude_slave_port_id]); 7814626SN/A } 7824626SN/A } 78310402SN/A // restore original packet state for remaining snoopers 78410402SN/A pkt->cmd = orig_cmd; 7854626SN/A } 7864626SN/A 78710401SN/A // Stats for fanout 78810401SN/A snoopFanout.sample(fanout); 78910401SN/A 7908948SN/A // the packet is restored as part of the loop and any potential 7918948SN/A // snoop response is part of the returned pair 7928948SN/A return std::make_pair(snoop_response_cmd, snoop_response_latency); 7932497SN/A} 7942497SN/A 7952497SN/Avoid 79610405Sandreas.hansson@arm.comCoherentXBar::recvFunctional(PacketPtr pkt, PortID slave_port_id) 7972497SN/A{ 7988663SN/A if (!pkt->isPrint()) { 7998663SN/A // don't do DPRINTFs on PrintReq as it clutters up the output 80010405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, 8018949SN/A "recvFunctional: packet src %s addr 0x%x cmd %s\n", 8029032SN/A slavePorts[slave_port_id]->name(), pkt->getAddr(), 8038663SN/A pkt->cmdString()); 8048663SN/A } 8058663SN/A 80610821Sandreas.hansson@arm.com if (!system->bypassCaches()) { 8078979SN/A // forward to all snoopers but the source 8089032SN/A forwardFunctional(pkt, slave_port_id); 8098979SN/A } 8104912SN/A 8118948SN/A // there is no need to continue if the snooping has found what we 8128948SN/A // were looking for and the packet is already a response 8138948SN/A if (!pkt->isResponse()) { 81410888Sandreas.hansson@arm.com // since our slave ports are queued ports we need to check them as well 81510888Sandreas.hansson@arm.com for (const auto& p : slavePorts) { 81610888Sandreas.hansson@arm.com // if we find a response that has the data, then the 81710888Sandreas.hansson@arm.com // downstream caches/memories may be out of date, so simply stop 81810888Sandreas.hansson@arm.com // here 81910888Sandreas.hansson@arm.com if (p->checkFunctional(pkt)) { 82010888Sandreas.hansson@arm.com if (pkt->needsResponse()) 82110888Sandreas.hansson@arm.com pkt->makeResponse(); 82210888Sandreas.hansson@arm.com return; 82310888Sandreas.hansson@arm.com } 82410888Sandreas.hansson@arm.com } 82510888Sandreas.hansson@arm.com 8269031SN/A PortID dest_id = findPort(pkt->getAddr()); 8278948SN/A 8288948SN/A masterPorts[dest_id]->sendFunctional(pkt); 8298948SN/A } 8308948SN/A} 8318948SN/A 8328948SN/Avoid 83310405Sandreas.hansson@arm.comCoherentXBar::recvFunctionalSnoop(PacketPtr pkt, PortID master_port_id) 8348948SN/A{ 8358948SN/A if (!pkt->isPrint()) { 8368948SN/A // don't do DPRINTFs on PrintReq as it clutters up the output 83710405Sandreas.hansson@arm.com DPRINTF(CoherentXBar, 8388949SN/A "recvFunctionalSnoop: packet src %s addr 0x%x cmd %s\n", 8399032SN/A masterPorts[master_port_id]->name(), pkt->getAddr(), 8408948SN/A pkt->cmdString()); 8418948SN/A } 8428948SN/A 84311188Sandreas.sandberg@arm.com for (const auto& p : slavePorts) { 84411188Sandreas.sandberg@arm.com if (p->checkFunctional(pkt)) { 84511188Sandreas.sandberg@arm.com if (pkt->needsResponse()) 84611188Sandreas.sandberg@arm.com pkt->makeResponse(); 84711188Sandreas.sandberg@arm.com return; 84811188Sandreas.sandberg@arm.com } 84911188Sandreas.sandberg@arm.com } 85011188Sandreas.sandberg@arm.com 8518948SN/A // forward to all snoopers 8529031SN/A forwardFunctional(pkt, InvalidPortID); 8538948SN/A} 8548948SN/A 8558948SN/Avoid 85610405Sandreas.hansson@arm.comCoherentXBar::forwardFunctional(PacketPtr pkt, PortID exclude_slave_port_id) 8578948SN/A{ 8589524SN/A // snoops should only happen if the system isn't bypassing caches 8599524SN/A assert(!system->bypassCaches()); 8609524SN/A 86110405Sandreas.hansson@arm.com for (const auto& p: snoopPorts) { 8628915SN/A // we could have gotten this request from a snooping master 8638915SN/A // (corresponding to our own slave port that is also in 8648915SN/A // snoopPorts) and should not send it back to where it came 8658915SN/A // from 8669031SN/A if (exclude_slave_port_id == InvalidPortID || 8678948SN/A p->getId() != exclude_slave_port_id) 8688948SN/A p->sendFunctionalSnoop(pkt); 8698915SN/A 8708948SN/A // if we get a response we are done 8718948SN/A if (pkt->isResponse()) { 8728948SN/A break; 8738915SN/A } 8743650SN/A } 8752497SN/A} 8762497SN/A 8779712SN/Avoid 87810405Sandreas.hansson@arm.comCoherentXBar::regStats() 8799712SN/A{ 88010405Sandreas.hansson@arm.com // register the stats of the base class and our layers 88110405Sandreas.hansson@arm.com BaseXBar::regStats(); 88210405Sandreas.hansson@arm.com for (auto l: reqLayers) 88310405Sandreas.hansson@arm.com l->regStats(); 88410405Sandreas.hansson@arm.com for (auto l: respLayers) 88510405Sandreas.hansson@arm.com l->regStats(); 88610405Sandreas.hansson@arm.com for (auto l: snoopLayers) 88710405Sandreas.hansson@arm.com l->regStats(); 8889712SN/A 88910405Sandreas.hansson@arm.com snoops 89010405Sandreas.hansson@arm.com .name(name() + ".snoops") 89110401SN/A .desc("Total snoops (count)") 89210401SN/A ; 89310401SN/A 89410401SN/A snoopFanout 89510401SN/A .init(0, snoopPorts.size(), 1) 89610401SN/A .name(name() + ".snoop_fanout") 89710401SN/A .desc("Request fanout histogram") 89810401SN/A ; 8999712SN/A} 9009712SN/A 90110405Sandreas.hansson@arm.comCoherentXBar * 90210405Sandreas.hansson@arm.comCoherentXBarParams::create() 9032497SN/A{ 90410405Sandreas.hansson@arm.com return new CoherentXBar(this); 9052497SN/A} 906