2 * Copyright (c) 2011-2017 ARM Limited
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.
14 * Copyright (c) 2006 The Regents of The University of Michigan
15 * All rights reserved.
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.
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.
47 * Definition of a crossbar object.
50 #include "mem/coherent_xbar.hh"
52 #include "base/logging.hh"
53 #include "base/trace.hh"
54 #include "debug/AddrRanges.hh"
55 #include "debug/CoherentXBar.hh"
56 #include "sim/system.hh"
58 CoherentXBar::CoherentXBar(const CoherentXBarParams
*p
)
59 : BaseXBar(p
), system(p
->system
), snoopFilter(p
->snoop_filter
),
60 snoopResponseLatency(p
->snoop_response_latency
),
61 pointOfCoherency(p
->point_of_coherency
),
62 pointOfUnification(p
->point_of_unification
)
64 // create the ports based on the size of the master and slave
65 // vector ports, and the presence of the default port, the ports
66 // are enumerated starting from zero
67 for (int i
= 0; i
< p
->port_master_connection_count
; ++i
) {
68 std::string portName
= csprintf("%s.master[%d]", name(), i
);
69 MasterPort
* bp
= new CoherentXBarMasterPort(portName
, *this, i
);
70 masterPorts
.push_back(bp
);
71 reqLayers
.push_back(new ReqLayer(*bp
, *this,
72 csprintf(".reqLayer%d", i
)));
73 snoopLayers
.push_back(new SnoopRespLayer(*bp
, *this,
74 csprintf(".snoopLayer%d", i
)));
77 // see if we have a default slave device connected and if so add
78 // our corresponding master port
79 if (p
->port_default_connection_count
) {
80 defaultPortID
= masterPorts
.size();
81 std::string portName
= name() + ".default";
82 MasterPort
* bp
= new CoherentXBarMasterPort(portName
, *this,
84 masterPorts
.push_back(bp
);
85 reqLayers
.push_back(new ReqLayer(*bp
, *this, csprintf(".reqLayer%d",
87 snoopLayers
.push_back(new SnoopRespLayer(*bp
, *this,
88 csprintf(".snoopLayer%d",
92 // create the slave ports, once again starting at zero
93 for (int i
= 0; i
< p
->port_slave_connection_count
; ++i
) {
94 std::string portName
= csprintf("%s.slave[%d]", name(), i
);
95 QueuedSlavePort
* bp
= new CoherentXBarSlavePort(portName
, *this, i
);
96 slavePorts
.push_back(bp
);
97 respLayers
.push_back(new RespLayer(*bp
, *this,
98 csprintf(".respLayer%d", i
)));
99 snoopRespPorts
.push_back(new SnoopRespPort(*bp
, *this));
105 CoherentXBar::~CoherentXBar()
107 for (auto l
: reqLayers
)
109 for (auto l
: respLayers
)
111 for (auto l
: snoopLayers
)
113 for (auto p
: snoopRespPorts
)
122 // iterate over our slave ports and determine which of our
123 // neighbouring master ports are snooping and add them as snoopers
124 for (const auto& p
: slavePorts
) {
125 // check if the connected master port is snooping
126 if (p
->isSnooping()) {
127 DPRINTF(AddrRanges
, "Adding snooping master %s\n",
128 p
->getMasterPort().name());
129 snoopPorts
.push_back(p
);
133 if (snoopPorts
.empty())
134 warn("CoherentXBar %s has no snooping ports attached!\n", name());
136 // inform the snoop filter about the slave ports so it can create
137 // its own internal representation
139 snoopFilter
->setSlavePorts(slavePorts
);
143 CoherentXBar::recvTimingReq(PacketPtr pkt
, PortID slave_port_id
)
145 // determine the source port based on the id
146 SlavePort
*src_port
= slavePorts
[slave_port_id
];
148 // remember if the packet is an express snoop
149 bool is_express_snoop
= pkt
->isExpressSnoop();
150 bool cache_responding
= pkt
->cacheResponding();
151 // for normal requests, going downstream, the express snoop flag
152 // and the cache responding flag should always be the same
153 assert(is_express_snoop
== cache_responding
);
155 // determine the destination based on the address
156 PortID master_port_id
= findPort(pkt
->getAddr());
158 // test if the crossbar should be considered occupied for the current
159 // port, and exclude express snoops from the check
160 if (!is_express_snoop
&& !reqLayers
[master_port_id
]->tryTiming(src_port
)) {
161 DPRINTF(CoherentXBar
, "%s: src %s packet %s BUSY\n", __func__
,
162 src_port
->name(), pkt
->print());
166 DPRINTF(CoherentXBar
, "%s: src %s packet %s\n", __func__
,
167 src_port
->name(), pkt
->print());
169 // store size and command as they might be modified when
170 // forwarding the packet
171 unsigned int pkt_size
= pkt
->hasData() ? pkt
->getSize() : 0;
172 unsigned int pkt_cmd
= pkt
->cmdToIndex();
174 // store the old header delay so we can restore it if needed
175 Tick old_header_delay
= pkt
->headerDelay
;
177 // a request sees the frontend and forward latency
178 Tick xbar_delay
= (frontendLatency
+ forwardLatency
) * clockPeriod();
180 // set the packet header and payload delay
181 calcPacketTiming(pkt
, xbar_delay
);
183 // determine how long to be crossbar layer is busy
184 Tick packetFinishTime
= clockEdge(Cycles(1)) + pkt
->payloadDelay
;
186 if (!system
->bypassCaches()) {
187 assert(pkt
->snoopDelay
== 0);
189 // the packet is a memory-mapped request and should be
190 // broadcasted to our snoopers but the source
192 // check with the snoop filter where to forward this packet
193 auto sf_res
= snoopFilter
->lookupRequest(pkt
, *src_port
);
194 // the time required by a packet to be delivered through
195 // the xbar has to be charged also with to lookup latency
196 // of the snoop filter
197 pkt
->headerDelay
+= sf_res
.second
* clockPeriod();
198 DPRINTF(CoherentXBar
, "%s: src %s packet %s SF size: %i lat: %i\n",
199 __func__
, src_port
->name(), pkt
->print(),
200 sf_res
.first
.size(), sf_res
.second
);
202 if (pkt
->isEviction()) {
203 // for block-evicting packets, i.e. writebacks and
204 // clean evictions, there is no need to snoop up, as
205 // all we do is determine if the block is cached or
206 // not, instead just set it here based on the snoop
208 if (!sf_res
.first
.empty())
209 pkt
->setBlockCached();
211 forwardTiming(pkt
, slave_port_id
, sf_res
.first
);
214 forwardTiming(pkt
, slave_port_id
);
217 // add the snoop delay to our header delay, and then reset it
218 pkt
->headerDelay
+= pkt
->snoopDelay
;
222 // set up a sensible starting point
225 // remember if the packet will generate a snoop response by
226 // checking if a cache set the cacheResponding flag during the
228 const bool expect_snoop_resp
= !cache_responding
&& pkt
->cacheResponding();
229 bool expect_response
= pkt
->needsResponse() && !pkt
->cacheResponding();
231 const bool sink_packet
= sinkPacket(pkt
);
233 // in certain cases the crossbar is responsible for responding
234 bool respond_directly
= false;
235 // store the original address as an address mapper could possibly
236 // modify the address upon a sendTimingRequest
237 const Addr
addr(pkt
->getAddr());
239 DPRINTF(CoherentXBar
, "%s: Not forwarding %s\n", __func__
,
242 // determine if we are forwarding the packet, or responding to
244 if (!pointOfCoherency
|| pkt
->isRead() || pkt
->isWrite()) {
245 // if we are passing on, rather than sinking, a packet to
246 // which an upstream cache has committed to responding,
247 // the line was needs writable, and the responding only
248 // had an Owned copy, so we need to immidiately let the
249 // downstream caches know, bypass any flow control
250 if (pkt
->cacheResponding()) {
251 pkt
->setExpressSnoop();
254 // since it is a normal request, attempt to send the packet
255 success
= masterPorts
[master_port_id
]->sendTimingReq(pkt
);
257 // no need to forward, turn this packet around and respond
259 assert(pkt
->needsResponse());
261 respond_directly
= true;
262 assert(!expect_snoop_resp
);
263 expect_response
= false;
267 if (snoopFilter
&& !system
->bypassCaches()) {
268 // Let the snoop filter know about the success of the send operation
269 snoopFilter
->finishRequest(!success
, addr
, pkt
->isSecure());
272 // check if we were successful in sending the packet onwards
274 // express snoops should never be forced to retry
275 assert(!is_express_snoop
);
277 // restore the header delay
278 pkt
->headerDelay
= old_header_delay
;
280 DPRINTF(CoherentXBar
, "%s: src %s packet %s RETRY\n", __func__
,
281 src_port
->name(), pkt
->print());
283 // update the layer state and schedule an idle event
284 reqLayers
[master_port_id
]->failedTiming(src_port
,
285 clockEdge(Cycles(1)));
287 // express snoops currently bypass the crossbar state entirely
288 if (!is_express_snoop
) {
289 // if this particular request will generate a snoop
291 if (expect_snoop_resp
) {
292 // we should never have an exsiting request outstanding
293 assert(outstandingSnoop
.find(pkt
->req
) ==
294 outstandingSnoop
.end());
295 outstandingSnoop
.insert(pkt
->req
);
297 // basic sanity check on the outstanding snoops
298 panic_if(outstandingSnoop
.size() > 512,
299 "Outstanding snoop requests exceeded 512\n");
302 // remember where to route the normal response to
303 if (expect_response
|| expect_snoop_resp
) {
304 assert(routeTo
.find(pkt
->req
) == routeTo
.end());
305 routeTo
[pkt
->req
] = slave_port_id
;
307 panic_if(routeTo
.size() > 512,
308 "Routing table exceeds 512 packets\n");
311 // update the layer state and schedule an idle event
312 reqLayers
[master_port_id
]->succeededTiming(packetFinishTime
);
315 // stats updates only consider packets that were successfully sent
316 pktCount
[slave_port_id
][master_port_id
]++;
317 pktSize
[slave_port_id
][master_port_id
] += pkt_size
;
318 transDist
[pkt_cmd
]++;
320 if (is_express_snoop
) {
322 snoopTraffic
+= pkt_size
;
327 // queue the packet for deletion
328 pendingDelete
.reset(pkt
);
330 if (respond_directly
) {
331 assert(pkt
->needsResponse());
336 if (snoopFilter
&& !system
->bypassCaches()) {
337 // let the snoop filter inspect the response and update its state
338 snoopFilter
->updateResponse(pkt
, *slavePorts
[slave_port_id
]);
341 Tick response_time
= clockEdge() + pkt
->headerDelay
;
342 pkt
->headerDelay
= 0;
344 slavePorts
[slave_port_id
]->schedTimingResp(pkt
, response_time
);
351 CoherentXBar::recvTimingResp(PacketPtr pkt
, PortID master_port_id
)
353 // determine the source port based on the id
354 MasterPort
*src_port
= masterPorts
[master_port_id
];
356 // determine the destination
357 const auto route_lookup
= routeTo
.find(pkt
->req
);
358 assert(route_lookup
!= routeTo
.end());
359 const PortID slave_port_id
= route_lookup
->second
;
360 assert(slave_port_id
!= InvalidPortID
);
361 assert(slave_port_id
< respLayers
.size());
363 // test if the crossbar should be considered occupied for the
365 if (!respLayers
[slave_port_id
]->tryTiming(src_port
)) {
366 DPRINTF(CoherentXBar
, "%s: src %s packet %s BUSY\n", __func__
,
367 src_port
->name(), pkt
->print());
371 DPRINTF(CoherentXBar
, "%s: src %s packet %s\n", __func__
,
372 src_port
->name(), pkt
->print());
374 // store size and command as they might be modified when
375 // forwarding the packet
376 unsigned int pkt_size
= pkt
->hasData() ? pkt
->getSize() : 0;
377 unsigned int pkt_cmd
= pkt
->cmdToIndex();
379 // a response sees the response latency
380 Tick xbar_delay
= responseLatency
* clockPeriod();
382 // set the packet header and payload delay
383 calcPacketTiming(pkt
, xbar_delay
);
385 // determine how long to be crossbar layer is busy
386 Tick packetFinishTime
= clockEdge(Cycles(1)) + pkt
->payloadDelay
;
388 if (snoopFilter
&& !system
->bypassCaches()) {
389 // let the snoop filter inspect the response and update its state
390 snoopFilter
->updateResponse(pkt
, *slavePorts
[slave_port_id
]);
393 // send the packet through the destination slave port and pay for
394 // any outstanding header delay
395 Tick latency
= pkt
->headerDelay
;
396 pkt
->headerDelay
= 0;
397 slavePorts
[slave_port_id
]->schedTimingResp(pkt
, curTick() + latency
);
399 // remove the request from the routing table
400 routeTo
.erase(route_lookup
);
402 respLayers
[slave_port_id
]->succeededTiming(packetFinishTime
);
405 pktCount
[slave_port_id
][master_port_id
]++;
406 pktSize
[slave_port_id
][master_port_id
] += pkt_size
;
407 transDist
[pkt_cmd
]++;
413 CoherentXBar::recvTimingSnoopReq(PacketPtr pkt
, PortID master_port_id
)
415 DPRINTF(CoherentXBar
, "%s: src %s packet %s\n", __func__
,
416 masterPorts
[master_port_id
]->name(), pkt
->print());
418 // update stats here as we know the forwarding will succeed
419 unsigned int pkt_size
= pkt
->hasData() ? pkt
->getSize() : 0;
420 transDist
[pkt
->cmdToIndex()]++;
422 snoopTraffic
+= pkt_size
;
424 // we should only see express snoops from caches
425 assert(pkt
->isExpressSnoop());
427 // set the packet header and payload delay, for now use forward latency
428 // @todo Assess the choice of latency further
429 calcPacketTiming(pkt
, forwardLatency
* clockPeriod());
431 // remember if a cache has already committed to responding so we
432 // can see if it changes during the snooping
433 const bool cache_responding
= pkt
->cacheResponding();
435 assert(pkt
->snoopDelay
== 0);
438 // let the Snoop Filter work its magic and guide probing
439 auto sf_res
= snoopFilter
->lookupSnoop(pkt
);
440 // the time required by a packet to be delivered through
441 // the xbar has to be charged also with to lookup latency
442 // of the snoop filter
443 pkt
->headerDelay
+= sf_res
.second
* clockPeriod();
444 DPRINTF(CoherentXBar
, "%s: src %s packet %s SF size: %i lat: %i\n",
445 __func__
, masterPorts
[master_port_id
]->name(), pkt
->print(),
446 sf_res
.first
.size(), sf_res
.second
);
448 // forward to all snoopers
449 forwardTiming(pkt
, InvalidPortID
, sf_res
.first
);
451 forwardTiming(pkt
, InvalidPortID
);
454 // add the snoop delay to our header delay, and then reset it
455 pkt
->headerDelay
+= pkt
->snoopDelay
;
458 // if we can expect a response, remember how to route it
459 if (!cache_responding
&& pkt
->cacheResponding()) {
460 assert(routeTo
.find(pkt
->req
) == routeTo
.end());
461 routeTo
[pkt
->req
] = master_port_id
;
464 // a snoop request came from a connected slave device (one of
465 // our master ports), and if it is not coming from the slave
466 // device responsible for the address range something is
467 // wrong, hence there is nothing further to do as the packet
468 // would be going back to where it came from
469 assert(master_port_id
== findPort(pkt
->getAddr()));
473 CoherentXBar::recvTimingSnoopResp(PacketPtr pkt
, PortID slave_port_id
)
475 // determine the source port based on the id
476 SlavePort
* src_port
= slavePorts
[slave_port_id
];
478 // get the destination
479 const auto route_lookup
= routeTo
.find(pkt
->req
);
480 assert(route_lookup
!= routeTo
.end());
481 const PortID dest_port_id
= route_lookup
->second
;
482 assert(dest_port_id
!= InvalidPortID
);
484 // determine if the response is from a snoop request we
485 // created as the result of a normal request (in which case it
486 // should be in the outstandingSnoop), or if we merely forwarded
487 // someone else's snoop request
488 const bool forwardAsSnoop
= outstandingSnoop
.find(pkt
->req
) ==
489 outstandingSnoop
.end();
491 // test if the crossbar should be considered occupied for the
492 // current port, note that the check is bypassed if the response
493 // is being passed on as a normal response since this is occupying
494 // the response layer rather than the snoop response layer
495 if (forwardAsSnoop
) {
496 assert(dest_port_id
< snoopLayers
.size());
497 if (!snoopLayers
[dest_port_id
]->tryTiming(src_port
)) {
498 DPRINTF(CoherentXBar
, "%s: src %s packet %s BUSY\n", __func__
,
499 src_port
->name(), pkt
->print());
503 // get the master port that mirrors this slave port internally
504 MasterPort
* snoop_port
= snoopRespPorts
[slave_port_id
];
505 assert(dest_port_id
< respLayers
.size());
506 if (!respLayers
[dest_port_id
]->tryTiming(snoop_port
)) {
507 DPRINTF(CoherentXBar
, "%s: src %s packet %s BUSY\n", __func__
,
508 snoop_port
->name(), pkt
->print());
513 DPRINTF(CoherentXBar
, "%s: src %s packet %s\n", __func__
,
514 src_port
->name(), pkt
->print());
516 // store size and command as they might be modified when
517 // forwarding the packet
518 unsigned int pkt_size
= pkt
->hasData() ? pkt
->getSize() : 0;
519 unsigned int pkt_cmd
= pkt
->cmdToIndex();
521 // responses are never express snoops
522 assert(!pkt
->isExpressSnoop());
524 // a snoop response sees the snoop response latency, and if it is
525 // forwarded as a normal response, the response latency
527 (forwardAsSnoop
? snoopResponseLatency
: responseLatency
) *
530 // set the packet header and payload delay
531 calcPacketTiming(pkt
, xbar_delay
);
533 // determine how long to be crossbar layer is busy
534 Tick packetFinishTime
= clockEdge(Cycles(1)) + pkt
->payloadDelay
;
536 // forward it either as a snoop response or a normal response
537 if (forwardAsSnoop
) {
538 // this is a snoop response to a snoop request we forwarded,
539 // e.g. coming from the L1 and going to the L2, and it should
540 // be forwarded as a snoop response
543 // update the probe filter so that it can properly track the line
544 snoopFilter
->updateSnoopForward(pkt
, *slavePorts
[slave_port_id
],
545 *masterPorts
[dest_port_id
]);
548 bool success M5_VAR_USED
=
549 masterPorts
[dest_port_id
]->sendTimingSnoopResp(pkt
);
550 pktCount
[slave_port_id
][dest_port_id
]++;
551 pktSize
[slave_port_id
][dest_port_id
] += pkt_size
;
554 snoopLayers
[dest_port_id
]->succeededTiming(packetFinishTime
);
556 // we got a snoop response on one of our slave ports,
557 // i.e. from a coherent master connected to the crossbar, and
558 // since we created the snoop request as part of recvTiming,
559 // this should now be a normal response again
560 outstandingSnoop
.erase(pkt
->req
);
562 // this is a snoop response from a coherent master, hence it
563 // should never go back to where the snoop response came from,
564 // but instead to where the original request came from
565 assert(slave_port_id
!= dest_port_id
);
568 // update the probe filter so that it can properly track the line
569 snoopFilter
->updateSnoopResponse(pkt
, *slavePorts
[slave_port_id
],
570 *slavePorts
[dest_port_id
]);
573 DPRINTF(CoherentXBar
, "%s: src %s packet %s FWD RESP\n", __func__
,
574 src_port
->name(), pkt
->print());
576 // as a normal response, it should go back to a master through
577 // one of our slave ports, we also pay for any outstanding
579 Tick latency
= pkt
->headerDelay
;
580 pkt
->headerDelay
= 0;
581 slavePorts
[dest_port_id
]->schedTimingResp(pkt
, curTick() + latency
);
583 respLayers
[dest_port_id
]->succeededTiming(packetFinishTime
);
586 // remove the request from the routing table
587 routeTo
.erase(route_lookup
);
590 transDist
[pkt_cmd
]++;
592 snoopTraffic
+= pkt_size
;
599 CoherentXBar::forwardTiming(PacketPtr pkt
, PortID exclude_slave_port_id
,
600 const std::vector
<QueuedSlavePort
*>& dests
)
602 DPRINTF(CoherentXBar
, "%s for %s\n", __func__
, pkt
->print());
604 // snoops should only happen if the system isn't bypassing caches
605 assert(!system
->bypassCaches());
609 for (const auto& p
: dests
) {
610 // we could have gotten this request from a snooping master
611 // (corresponding to our own slave port that is also in
612 // snoopPorts) and should not send it back to where it came
614 if (exclude_slave_port_id
== InvalidPortID
||
615 p
->getId() != exclude_slave_port_id
) {
616 // cache is not allowed to refuse snoop
617 p
->sendTimingSnoopReq(pkt
);
622 // Stats for fanout of this forward operation
623 snoopFanout
.sample(fanout
);
627 CoherentXBar::recvReqRetry(PortID master_port_id
)
629 // responses and snoop responses never block on forwarding them,
630 // so the retry will always be coming from a port to which we
631 // tried to forward a request
632 reqLayers
[master_port_id
]->recvRetry();
636 CoherentXBar::recvAtomic(PacketPtr pkt
, PortID slave_port_id
)
638 DPRINTF(CoherentXBar
, "%s: src %s packet %s\n", __func__
,
639 slavePorts
[slave_port_id
]->name(), pkt
->print());
641 unsigned int pkt_size
= pkt
->hasData() ? pkt
->getSize() : 0;
642 unsigned int pkt_cmd
= pkt
->cmdToIndex();
644 MemCmd snoop_response_cmd
= MemCmd::InvalidCmd
;
645 Tick snoop_response_latency
= 0;
647 if (!system
->bypassCaches()) {
648 // forward to all snoopers but the source
649 std::pair
<MemCmd
, Tick
> snoop_result
;
651 // check with the snoop filter where to forward this packet
653 snoopFilter
->lookupRequest(pkt
, *slavePorts
[slave_port_id
]);
654 snoop_response_latency
+= sf_res
.second
* clockPeriod();
655 DPRINTF(CoherentXBar
, "%s: src %s packet %s SF size: %i lat: %i\n",
656 __func__
, slavePorts
[slave_port_id
]->name(), pkt
->print(),
657 sf_res
.first
.size(), sf_res
.second
);
659 // let the snoop filter know about the success of the send
660 // operation, and do it even before sending it onwards to
661 // avoid situations where atomic upward snoops sneak in
662 // between and change the filter state
663 snoopFilter
->finishRequest(false, pkt
->getAddr(), pkt
->isSecure());
665 if (pkt
->isEviction()) {
666 // for block-evicting packets, i.e. writebacks and
667 // clean evictions, there is no need to snoop up, as
668 // all we do is determine if the block is cached or
669 // not, instead just set it here based on the snoop
671 if (!sf_res
.first
.empty())
672 pkt
->setBlockCached();
674 snoop_result
= forwardAtomic(pkt
, slave_port_id
, InvalidPortID
,
678 snoop_result
= forwardAtomic(pkt
, slave_port_id
);
680 snoop_response_cmd
= snoop_result
.first
;
681 snoop_response_latency
+= snoop_result
.second
;
684 // set up a sensible default value
685 Tick response_latency
= 0;
687 const bool sink_packet
= sinkPacket(pkt
);
689 // even if we had a snoop response, we must continue and also
690 // perform the actual request at the destination
691 PortID master_port_id
= findPort(pkt
->getAddr());
694 DPRINTF(CoherentXBar
, "%s: Not forwarding %s\n", __func__
,
697 if (!pointOfCoherency
|| pkt
->isRead() || pkt
->isWrite()) {
698 // forward the request to the appropriate destination
699 response_latency
= masterPorts
[master_port_id
]->sendAtomic(pkt
);
701 // if it does not need a response we sink the packet above
702 assert(pkt
->needsResponse());
708 // stats updates for the request
709 pktCount
[slave_port_id
][master_port_id
]++;
710 pktSize
[slave_port_id
][master_port_id
] += pkt_size
;
711 transDist
[pkt_cmd
]++;
714 // if lower levels have replied, tell the snoop filter
715 if (!system
->bypassCaches() && snoopFilter
&& pkt
->isResponse()) {
716 snoopFilter
->updateResponse(pkt
, *slavePorts
[slave_port_id
]);
719 // if we got a response from a snooper, restore it here
720 if (snoop_response_cmd
!= MemCmd::InvalidCmd
) {
721 // no one else should have responded
722 assert(!pkt
->isResponse());
723 pkt
->cmd
= snoop_response_cmd
;
724 response_latency
= snoop_response_latency
;
727 // add the response data
728 if (pkt
->isResponse()) {
729 pkt_size
= pkt
->hasData() ? pkt
->getSize() : 0;
730 pkt_cmd
= pkt
->cmdToIndex();
733 pktCount
[slave_port_id
][master_port_id
]++;
734 pktSize
[slave_port_id
][master_port_id
] += pkt_size
;
735 transDist
[pkt_cmd
]++;
738 // @todo: Not setting header time
739 pkt
->payloadDelay
= response_latency
;
740 return response_latency
;
744 CoherentXBar::recvAtomicSnoop(PacketPtr pkt
, PortID master_port_id
)
746 DPRINTF(CoherentXBar
, "%s: src %s packet %s\n", __func__
,
747 masterPorts
[master_port_id
]->name(), pkt
->print());
749 // add the request snoop data
750 unsigned int pkt_size
= pkt
->hasData() ? pkt
->getSize() : 0;
752 snoopTraffic
+= pkt_size
;
754 // forward to all snoopers
755 std::pair
<MemCmd
, Tick
> snoop_result
;
756 Tick snoop_response_latency
= 0;
758 auto sf_res
= snoopFilter
->lookupSnoop(pkt
);
759 snoop_response_latency
+= sf_res
.second
* clockPeriod();
760 DPRINTF(CoherentXBar
, "%s: src %s packet %s SF size: %i lat: %i\n",
761 __func__
, masterPorts
[master_port_id
]->name(), pkt
->print(),
762 sf_res
.first
.size(), sf_res
.second
);
763 snoop_result
= forwardAtomic(pkt
, InvalidPortID
, master_port_id
,
766 snoop_result
= forwardAtomic(pkt
, InvalidPortID
);
768 MemCmd snoop_response_cmd
= snoop_result
.first
;
769 snoop_response_latency
+= snoop_result
.second
;
771 if (snoop_response_cmd
!= MemCmd::InvalidCmd
)
772 pkt
->cmd
= snoop_response_cmd
;
774 // add the response snoop data
775 if (pkt
->isResponse()) {
779 // @todo: Not setting header time
780 pkt
->payloadDelay
= snoop_response_latency
;
781 return snoop_response_latency
;
784 std::pair
<MemCmd
, Tick
>
785 CoherentXBar::forwardAtomic(PacketPtr pkt
, PortID exclude_slave_port_id
,
786 PortID source_master_port_id
,
787 const std::vector
<QueuedSlavePort
*>& dests
)
789 // the packet may be changed on snoops, record the original
790 // command to enable us to restore it between snoops so that
791 // additional snoops can take place properly
792 MemCmd orig_cmd
= pkt
->cmd
;
793 MemCmd snoop_response_cmd
= MemCmd::InvalidCmd
;
794 Tick snoop_response_latency
= 0;
796 // snoops should only happen if the system isn't bypassing caches
797 assert(!system
->bypassCaches());
801 for (const auto& p
: dests
) {
802 // we could have gotten this request from a snooping master
803 // (corresponding to our own slave port that is also in
804 // snoopPorts) and should not send it back to where it came
806 if (exclude_slave_port_id
!= InvalidPortID
&&
807 p
->getId() == exclude_slave_port_id
)
810 Tick latency
= p
->sendAtomicSnoop(pkt
);
813 // in contrast to a functional access, we have to keep on
814 // going as all snoopers must be updated even if we get a
816 if (!pkt
->isResponse())
819 // response from snoop agent
820 assert(pkt
->cmd
!= orig_cmd
);
821 assert(pkt
->cacheResponding());
822 // should only happen once
823 assert(snoop_response_cmd
== MemCmd::InvalidCmd
);
824 // save response state
825 snoop_response_cmd
= pkt
->cmd
;
826 snoop_response_latency
= latency
;
829 // Handle responses by the snoopers and differentiate between
830 // responses to requests from above and snoops from below
831 if (source_master_port_id
!= InvalidPortID
) {
832 // Getting a response for a snoop from below
833 assert(exclude_slave_port_id
== InvalidPortID
);
834 snoopFilter
->updateSnoopForward(pkt
, *p
,
835 *masterPorts
[source_master_port_id
]);
837 // Getting a response for a request from above
838 assert(source_master_port_id
== InvalidPortID
);
839 snoopFilter
->updateSnoopResponse(pkt
, *p
,
840 *slavePorts
[exclude_slave_port_id
]);
843 // restore original packet state for remaining snoopers
848 snoopFanout
.sample(fanout
);
850 // the packet is restored as part of the loop and any potential
851 // snoop response is part of the returned pair
852 return std::make_pair(snoop_response_cmd
, snoop_response_latency
);
856 CoherentXBar::recvFunctional(PacketPtr pkt
, PortID slave_port_id
)
858 if (!pkt
->isPrint()) {
859 // don't do DPRINTFs on PrintReq as it clutters up the output
860 DPRINTF(CoherentXBar
, "%s: src %s packet %s\n", __func__
,
861 slavePorts
[slave_port_id
]->name(), pkt
->print());
864 if (!system
->bypassCaches()) {
865 // forward to all snoopers but the source
866 forwardFunctional(pkt
, slave_port_id
);
869 // there is no need to continue if the snooping has found what we
870 // were looking for and the packet is already a response
871 if (!pkt
->isResponse()) {
872 // since our slave ports are queued ports we need to check them as well
873 for (const auto& p
: slavePorts
) {
874 // if we find a response that has the data, then the
875 // downstream caches/memories may be out of date, so simply stop
877 if (p
->checkFunctional(pkt
)) {
878 if (pkt
->needsResponse())
884 PortID dest_id
= findPort(pkt
->getAddr());
886 masterPorts
[dest_id
]->sendFunctional(pkt
);
891 CoherentXBar::recvFunctionalSnoop(PacketPtr pkt
, PortID master_port_id
)
893 if (!pkt
->isPrint()) {
894 // don't do DPRINTFs on PrintReq as it clutters up the output
895 DPRINTF(CoherentXBar
, "%s: src %s packet %s\n", __func__
,
896 masterPorts
[master_port_id
]->name(), pkt
->print());
899 for (const auto& p
: slavePorts
) {
900 if (p
->checkFunctional(pkt
)) {
901 if (pkt
->needsResponse())
907 // forward to all snoopers
908 forwardFunctional(pkt
, InvalidPortID
);
912 CoherentXBar::forwardFunctional(PacketPtr pkt
, PortID exclude_slave_port_id
)
914 // snoops should only happen if the system isn't bypassing caches
915 assert(!system
->bypassCaches());
917 for (const auto& p
: snoopPorts
) {
918 // we could have gotten this request from a snooping master
919 // (corresponding to our own slave port that is also in
920 // snoopPorts) and should not send it back to where it came
922 if (exclude_slave_port_id
== InvalidPortID
||
923 p
->getId() != exclude_slave_port_id
)
924 p
->sendFunctionalSnoop(pkt
);
926 // if we get a response we are done
927 if (pkt
->isResponse()) {
934 CoherentXBar::sinkPacket(const PacketPtr pkt
) const
936 // we can sink the packet if:
937 // 1) the crossbar is the point of coherency, and a cache is
938 // responding after being snooped
939 // 2) the crossbar is the point of coherency, and the packet is a
940 // coherency packet (not a read or a write) that does not
941 // require a response
942 // 3) this is a clean evict or clean writeback, but the packet is
943 // found in a cache above this crossbar
944 // 4) a cache is responding after being snooped, and the packet
945 // either does not need the block to be writable, or the cache
946 // that has promised to respond (setting the cache responding
947 // flag) is providing writable and thus had a Modified block,
948 // and no further action is needed
949 return (pointOfCoherency
&& pkt
->cacheResponding()) ||
950 (pointOfCoherency
&& !(pkt
->isRead() || pkt
->isWrite()) &&
951 !pkt
->needsResponse()) ||
952 (pkt
->isCleanEviction() && pkt
->isBlockCached()) ||
953 (pkt
->cacheResponding() &&
954 (!pkt
->needsWritable() || pkt
->responderHadWritable()));
958 CoherentXBar::regStats()
960 // register the stats of the base class and our layers
961 BaseXBar::regStats();
962 for (auto l
: reqLayers
)
964 for (auto l
: respLayers
)
966 for (auto l
: snoopLayers
)
970 .name(name() + ".snoops")
971 .desc("Total snoops (count)")
975 .name(name() + ".snoopTraffic")
976 .desc("Total snoop traffic (bytes)")
980 .init(0, snoopPorts
.size(), 1)
981 .name(name() + ".snoop_fanout")
982 .desc("Request fanout histogram")
987 CoherentXBarParams::create()
989 return new CoherentXBar(this);