1/*
2 * Copyright (c) 2011-2015 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder. You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Copyright (c) 2006 The Regents of The University of Michigan
15 * All rights reserved.
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions are
19 * met: redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer;
21 * redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution;
24 * neither the name of the copyright holders nor the names of its
25 * contributors may be used to endorse or promote products derived from
26 * this software without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 *
40 * Authors: Ali Saidi
41 * Andreas Hansson
42 * William Wang
43 */
44
45/**
46 * @file
47 * Definition of a crossbar object.
48 */
49
50#include "base/misc.hh"
51#include "base/trace.hh"
52#include "debug/AddrRanges.hh"
53#include "debug/CoherentXBar.hh"
54#include "mem/coherent_xbar.hh"
55#include "sim/system.hh"
56
57CoherentXBar::CoherentXBar(const CoherentXBarParams *p)
58 : BaseXBar(p), system(p->system), snoopFilter(p->snoop_filter),
59 snoopResponseLatency(p->snoop_response_latency)
60{
61 // create the ports based on the size of the master and slave
62 // vector ports, and the presence of the default port, the ports
63 // are enumerated starting from zero
64 for (int i = 0; i < p->port_master_connection_count; ++i) {
65 std::string portName = csprintf("%s.master[%d]", name(), i);
66 MasterPort* bp = new CoherentXBarMasterPort(portName, *this, i);
67 masterPorts.push_back(bp);
68 reqLayers.push_back(new ReqLayer(*bp, *this,
69 csprintf(".reqLayer%d", i)));
70 snoopLayers.push_back(new SnoopRespLayer(*bp, *this,
71 csprintf(".snoopLayer%d", i)));
72 }
73
74 // see if we have a default slave device connected and if so add
75 // our corresponding master port
76 if (p->port_default_connection_count) {
77 defaultPortID = masterPorts.size();
78 std::string portName = name() + ".default";
79 MasterPort* bp = new CoherentXBarMasterPort(portName, *this,
80 defaultPortID);
81 masterPorts.push_back(bp);
82 reqLayers.push_back(new ReqLayer(*bp, *this, csprintf(".reqLayer%d",
83 defaultPortID)));
84 snoopLayers.push_back(new SnoopRespLayer(*bp, *this,
85 csprintf(".snoopLayer%d",
86 defaultPortID)));
87 }
88
89 // create the slave ports, once again starting at zero
90 for (int i = 0; i < p->port_slave_connection_count; ++i) {
91 std::string portName = csprintf("%s.slave[%d]", name(), i);
92 QueuedSlavePort* bp = new CoherentXBarSlavePort(portName, *this, i);
93 slavePorts.push_back(bp);
94 respLayers.push_back(new RespLayer(*bp, *this,
95 csprintf(".respLayer%d", i)));
96 snoopRespPorts.push_back(new SnoopRespPort(*bp, *this));
97 }
98
|
138}
139
140bool
141CoherentXBar::recvTimingReq(PacketPtr pkt, PortID slave_port_id)
142{
143 // @todo temporary hack to deal with memory corruption issue until
144 // 4-phase transactions are complete
145 for (int x = 0; x < pendingDelete.size(); x++)
146 delete pendingDelete[x];
147 pendingDelete.clear();
148
149 // determine the source port based on the id
150 SlavePort *src_port = slavePorts[slave_port_id];
151
152 // remember if the packet is an express snoop
153 bool is_express_snoop = pkt->isExpressSnoop();
154 bool is_inhibited = pkt->memInhibitAsserted();
155 // for normal requests, going downstream, the express snoop flag
156 // and the inhibited flag should always be the same
157 assert(is_express_snoop == is_inhibited);
158
159 // determine the destination based on the address
160 PortID master_port_id = findPort(pkt->getAddr());
161
162 // test if the crossbar should be considered occupied for the current
163 // port, and exclude express snoops from the check
164 if (!is_express_snoop && !reqLayers[master_port_id]->tryTiming(src_port)) {
165 DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x BUSY\n",
166 src_port->name(), pkt->cmdString(), pkt->getAddr());
167 return false;
168 }
169
170 DPRINTF(CoherentXBar, "recvTimingReq: src %s %s expr %d 0x%x\n",
171 src_port->name(), pkt->cmdString(), is_express_snoop,
172 pkt->getAddr());
173
174 // store size and command as they might be modified when
175 // forwarding the packet
176 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
177 unsigned int pkt_cmd = pkt->cmdToIndex();
178
179 // store the old header delay so we can restore it if needed
180 Tick old_header_delay = pkt->headerDelay;
181
182 // a request sees the frontend and forward latency
183 Tick xbar_delay = (frontendLatency + forwardLatency) * clockPeriod();
184
185 // set the packet header and payload delay
186 calcPacketTiming(pkt, xbar_delay);
187
188 // determine how long to be crossbar layer is busy
189 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay;
190
191 if (!system->bypassCaches()) {
192 assert(pkt->snoopDelay == 0);
193
194 // the packet is a memory-mapped request and should be
195 // broadcasted to our snoopers but the source
196 if (snoopFilter) {
197 // check with the snoop filter where to forward this packet
198 auto sf_res = snoopFilter->lookupRequest(pkt, *src_port);
199 // the time required by a packet to be delivered through
200 // the xbar has to be charged also with to lookup latency
201 // of the snoop filter
202 pkt->headerDelay += sf_res.second * clockPeriod();
203 DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x"\
204 " SF size: %i lat: %i\n", src_port->name(),
205 pkt->cmdString(), pkt->getAddr(), sf_res.first.size(),
206 sf_res.second);
207 forwardTiming(pkt, slave_port_id, sf_res.first);
208 } else {
209 forwardTiming(pkt, slave_port_id);
210 }
211
212 // add the snoop delay to our header delay, and then reset it
213 pkt->headerDelay += pkt->snoopDelay;
214 pkt->snoopDelay = 0;
215 }
216
217 // forwardTiming snooped into peer caches of the sender, and if
218 // this is a clean evict, but the packet is found in a cache, do
219 // not forward it
220 if (pkt->cmd == MemCmd::CleanEvict && pkt->isBlockCached()) {
221 DPRINTF(CoherentXBar, "recvTimingReq: Clean evict 0x%x still cached, "
222 "not forwarding\n", pkt->getAddr());
223
224 // update the layer state and schedule an idle event
225 reqLayers[master_port_id]->succeededTiming(packetFinishTime);
226 pendingDelete.push_back(pkt);
227 return true;
228 }
229
230 // remember if the packet will generate a snoop response
231 const bool expect_snoop_resp = !is_inhibited && pkt->memInhibitAsserted();
232 const bool expect_response = pkt->needsResponse() &&
233 !pkt->memInhibitAsserted();
234
235 // since it is a normal request, attempt to send the packet
236 bool success = masterPorts[master_port_id]->sendTimingReq(pkt);
237
238 if (snoopFilter && !system->bypassCaches()) {
239 // Let the snoop filter know about the success of the send operation
240 snoopFilter->finishRequest(!success, pkt);
241 }
242
243 // check if we were successful in sending the packet onwards
244 if (!success) {
245 // express snoops and inhibited packets should never be forced
246 // to retry
247 assert(!is_express_snoop);
248 assert(!pkt->memInhibitAsserted());
249
250 // restore the header delay
251 pkt->headerDelay = old_header_delay;
252
253 DPRINTF(CoherentXBar, "recvTimingReq: src %s %s 0x%x RETRY\n",
254 src_port->name(), pkt->cmdString(), pkt->getAddr());
255
256 // update the layer state and schedule an idle event
257 reqLayers[master_port_id]->failedTiming(src_port,
258 clockEdge(Cycles(1)));
259 } else {
260 // express snoops currently bypass the crossbar state entirely
261 if (!is_express_snoop) {
262 // if this particular request will generate a snoop
263 // response
264 if (expect_snoop_resp) {
265 // we should never have an exsiting request outstanding
266 assert(outstandingSnoop.find(pkt->req) ==
267 outstandingSnoop.end());
268 outstandingSnoop.insert(pkt->req);
269
270 // basic sanity check on the outstanding snoops
271 panic_if(outstandingSnoop.size() > 512,
272 "Outstanding snoop requests exceeded 512\n");
273 }
274
275 // remember where to route the normal response to
276 if (expect_response || expect_snoop_resp) {
277 assert(routeTo.find(pkt->req) == routeTo.end());
278 routeTo[pkt->req] = slave_port_id;
279
280 panic_if(routeTo.size() > 512,
281 "Routing table exceeds 512 packets\n");
282 }
283
284 // update the layer state and schedule an idle event
285 reqLayers[master_port_id]->succeededTiming(packetFinishTime);
286 }
287
288 // stats updates only consider packets that were successfully sent
289 pktCount[slave_port_id][master_port_id]++;
290 pktSize[slave_port_id][master_port_id] += pkt_size;
291 transDist[pkt_cmd]++;
292
293 if (is_express_snoop)
294 snoops++;
295 }
296
297 return success;
298}
299
300bool
301CoherentXBar::recvTimingResp(PacketPtr pkt, PortID master_port_id)
302{
303 // determine the source port based on the id
304 MasterPort *src_port = masterPorts[master_port_id];
305
306 // determine the destination
307 const auto route_lookup = routeTo.find(pkt->req);
308 assert(route_lookup != routeTo.end());
309 const PortID slave_port_id = route_lookup->second;
310 assert(slave_port_id != InvalidPortID);
311 assert(slave_port_id < respLayers.size());
312
313 // test if the crossbar should be considered occupied for the
314 // current port
315 if (!respLayers[slave_port_id]->tryTiming(src_port)) {
316 DPRINTF(CoherentXBar, "recvTimingResp: src %s %s 0x%x BUSY\n",
317 src_port->name(), pkt->cmdString(), pkt->getAddr());
318 return false;
319 }
320
321 DPRINTF(CoherentXBar, "recvTimingResp: src %s %s 0x%x\n",
322 src_port->name(), pkt->cmdString(), pkt->getAddr());
323
324 // store size and command as they might be modified when
325 // forwarding the packet
326 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
327 unsigned int pkt_cmd = pkt->cmdToIndex();
328
329 // a response sees the response latency
330 Tick xbar_delay = responseLatency * clockPeriod();
331
332 // set the packet header and payload delay
333 calcPacketTiming(pkt, xbar_delay);
334
335 // determine how long to be crossbar layer is busy
336 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay;
337
338 if (snoopFilter && !system->bypassCaches()) {
339 // let the snoop filter inspect the response and update its state
340 snoopFilter->updateResponse(pkt, *slavePorts[slave_port_id]);
341 }
342
343 // send the packet through the destination slave port and pay for
344 // any outstanding header delay
345 Tick latency = pkt->headerDelay;
346 pkt->headerDelay = 0;
347 slavePorts[slave_port_id]->schedTimingResp(pkt, curTick() + latency);
348
349 // remove the request from the routing table
350 routeTo.erase(route_lookup);
351
352 respLayers[slave_port_id]->succeededTiming(packetFinishTime);
353
354 // stats updates
355 pktCount[slave_port_id][master_port_id]++;
356 pktSize[slave_port_id][master_port_id] += pkt_size;
357 transDist[pkt_cmd]++;
358
359 return true;
360}
361
362void
363CoherentXBar::recvTimingSnoopReq(PacketPtr pkt, PortID master_port_id)
364{
365 DPRINTF(CoherentXBar, "recvTimingSnoopReq: src %s %s 0x%x\n",
366 masterPorts[master_port_id]->name(), pkt->cmdString(),
367 pkt->getAddr());
368
369 // update stats here as we know the forwarding will succeed
370 transDist[pkt->cmdToIndex()]++;
371 snoops++;
372
373 // we should only see express snoops from caches
374 assert(pkt->isExpressSnoop());
375
376 // set the packet header and payload delay, for now use forward latency
377 // @todo Assess the choice of latency further
378 calcPacketTiming(pkt, forwardLatency * clockPeriod());
379
380 // remeber if the packet is inhibited so we can see if it changes
381 const bool is_inhibited = pkt->memInhibitAsserted();
382
383 assert(pkt->snoopDelay == 0);
384
385 if (snoopFilter) {
386 // let the Snoop Filter work its magic and guide probing
387 auto sf_res = snoopFilter->lookupSnoop(pkt);
388 // the time required by a packet to be delivered through
389 // the xbar has to be charged also with to lookup latency
390 // of the snoop filter
391 pkt->headerDelay += sf_res.second * clockPeriod();
392 DPRINTF(CoherentXBar, "recvTimingSnoopReq: src %s %s 0x%x"\
393 " SF size: %i lat: %i\n", masterPorts[master_port_id]->name(),
394 pkt->cmdString(), pkt->getAddr(), sf_res.first.size(),
395 sf_res.second);
396
397 // forward to all snoopers
398 forwardTiming(pkt, InvalidPortID, sf_res.first);
399 } else {
400 forwardTiming(pkt, InvalidPortID);
401 }
402
403 // add the snoop delay to our header delay, and then reset it
404 pkt->headerDelay += pkt->snoopDelay;
405 pkt->snoopDelay = 0;
406
407 // if we can expect a response, remember how to route it
408 if (!is_inhibited && pkt->memInhibitAsserted()) {
409 assert(routeTo.find(pkt->req) == routeTo.end());
410 routeTo[pkt->req] = master_port_id;
411 }
412
413 // a snoop request came from a connected slave device (one of
414 // our master ports), and if it is not coming from the slave
415 // device responsible for the address range something is
416 // wrong, hence there is nothing further to do as the packet
417 // would be going back to where it came from
418 assert(master_port_id == findPort(pkt->getAddr()));
419}
420
421bool
422CoherentXBar::recvTimingSnoopResp(PacketPtr pkt, PortID slave_port_id)
423{
424 // determine the source port based on the id
425 SlavePort* src_port = slavePorts[slave_port_id];
426
427 // get the destination
428 const auto route_lookup = routeTo.find(pkt->req);
429 assert(route_lookup != routeTo.end());
430 const PortID dest_port_id = route_lookup->second;
431 assert(dest_port_id != InvalidPortID);
432
433 // determine if the response is from a snoop request we
434 // created as the result of a normal request (in which case it
435 // should be in the outstandingSnoop), or if we merely forwarded
436 // someone else's snoop request
437 const bool forwardAsSnoop = outstandingSnoop.find(pkt->req) ==
438 outstandingSnoop.end();
439
440 // test if the crossbar should be considered occupied for the
441 // current port, note that the check is bypassed if the response
442 // is being passed on as a normal response since this is occupying
443 // the response layer rather than the snoop response layer
444 if (forwardAsSnoop) {
445 assert(dest_port_id < snoopLayers.size());
446 if (!snoopLayers[dest_port_id]->tryTiming(src_port)) {
447 DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x BUSY\n",
448 src_port->name(), pkt->cmdString(), pkt->getAddr());
449 return false;
450 }
451 } else {
452 // get the master port that mirrors this slave port internally
453 MasterPort* snoop_port = snoopRespPorts[slave_port_id];
454 assert(dest_port_id < respLayers.size());
455 if (!respLayers[dest_port_id]->tryTiming(snoop_port)) {
456 DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x BUSY\n",
457 snoop_port->name(), pkt->cmdString(), pkt->getAddr());
458 return false;
459 }
460 }
461
462 DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x\n",
463 src_port->name(), pkt->cmdString(), pkt->getAddr());
464
465 // store size and command as they might be modified when
466 // forwarding the packet
467 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
468 unsigned int pkt_cmd = pkt->cmdToIndex();
469
470 // responses are never express snoops
471 assert(!pkt->isExpressSnoop());
472
473 // a snoop response sees the snoop response latency, and if it is
474 // forwarded as a normal response, the response latency
475 Tick xbar_delay =
476 (forwardAsSnoop ? snoopResponseLatency : responseLatency) *
477 clockPeriod();
478
479 // set the packet header and payload delay
480 calcPacketTiming(pkt, xbar_delay);
481
482 // determine how long to be crossbar layer is busy
483 Tick packetFinishTime = clockEdge(Cycles(1)) + pkt->payloadDelay;
484
485 // forward it either as a snoop response or a normal response
486 if (forwardAsSnoop) {
487 // this is a snoop response to a snoop request we forwarded,
488 // e.g. coming from the L1 and going to the L2, and it should
489 // be forwarded as a snoop response
490
491 if (snoopFilter) {
492 // update the probe filter so that it can properly track the line
493 snoopFilter->updateSnoopForward(pkt, *slavePorts[slave_port_id],
494 *masterPorts[dest_port_id]);
495 }
496
497 bool success M5_VAR_USED =
498 masterPorts[dest_port_id]->sendTimingSnoopResp(pkt);
499 pktCount[slave_port_id][dest_port_id]++;
500 pktSize[slave_port_id][dest_port_id] += pkt_size;
501 assert(success);
502
503 snoopLayers[dest_port_id]->succeededTiming(packetFinishTime);
504 } else {
505 // we got a snoop response on one of our slave ports,
506 // i.e. from a coherent master connected to the crossbar, and
507 // since we created the snoop request as part of recvTiming,
508 // this should now be a normal response again
509 outstandingSnoop.erase(pkt->req);
510
511 // this is a snoop response from a coherent master, hence it
512 // should never go back to where the snoop response came from,
513 // but instead to where the original request came from
514 assert(slave_port_id != dest_port_id);
515
516 if (snoopFilter) {
517 // update the probe filter so that it can properly track the line
518 snoopFilter->updateSnoopResponse(pkt, *slavePorts[slave_port_id],
519 *slavePorts[dest_port_id]);
520 }
521
522 DPRINTF(CoherentXBar, "recvTimingSnoopResp: src %s %s 0x%x"\
523 " FWD RESP\n", src_port->name(), pkt->cmdString(),
524 pkt->getAddr());
525
526 // as a normal response, it should go back to a master through
527 // one of our slave ports, we also pay for any outstanding
528 // header latency
529 Tick latency = pkt->headerDelay;
530 pkt->headerDelay = 0;
531 slavePorts[dest_port_id]->schedTimingResp(pkt, curTick() + latency);
532
533 respLayers[dest_port_id]->succeededTiming(packetFinishTime);
534 }
535
536 // remove the request from the routing table
537 routeTo.erase(route_lookup);
538
539 // stats updates
540 transDist[pkt_cmd]++;
541 snoops++;
542
543 return true;
544}
545
546
547void
548CoherentXBar::forwardTiming(PacketPtr pkt, PortID exclude_slave_port_id,
549 const std::vector<QueuedSlavePort*>& dests)
550{
551 DPRINTF(CoherentXBar, "%s for %s address %x size %d\n", __func__,
552 pkt->cmdString(), pkt->getAddr(), pkt->getSize());
553
554 // snoops should only happen if the system isn't bypassing caches
555 assert(!system->bypassCaches());
556
557 unsigned fanout = 0;
558
559 for (const auto& p: dests) {
560 // we could have gotten this request from a snooping master
561 // (corresponding to our own slave port that is also in
562 // snoopPorts) and should not send it back to where it came
563 // from
564 if (exclude_slave_port_id == InvalidPortID ||
565 p->getId() != exclude_slave_port_id) {
566 // cache is not allowed to refuse snoop
567 p->sendTimingSnoopReq(pkt);
568 fanout++;
569 }
570 }
571
572 // Stats for fanout of this forward operation
573 snoopFanout.sample(fanout);
574}
575
576void
577CoherentXBar::recvReqRetry(PortID master_port_id)
578{
579 // responses and snoop responses never block on forwarding them,
580 // so the retry will always be coming from a port to which we
581 // tried to forward a request
582 reqLayers[master_port_id]->recvRetry();
583}
584
585Tick
586CoherentXBar::recvAtomic(PacketPtr pkt, PortID slave_port_id)
587{
588 DPRINTF(CoherentXBar, "recvAtomic: packet src %s addr 0x%x cmd %s\n",
589 slavePorts[slave_port_id]->name(), pkt->getAddr(),
590 pkt->cmdString());
591
592 unsigned int pkt_size = pkt->hasData() ? pkt->getSize() : 0;
593 unsigned int pkt_cmd = pkt->cmdToIndex();
594
595 MemCmd snoop_response_cmd = MemCmd::InvalidCmd;
596 Tick snoop_response_latency = 0;
597
598 if (!system->bypassCaches()) {
599 // forward to all snoopers but the source
600 std::pair<MemCmd, Tick> snoop_result;
601 if (snoopFilter) {
602 // check with the snoop filter where to forward this packet
603 auto sf_res =
604 snoopFilter->lookupRequest(pkt, *slavePorts[slave_port_id]);
605 snoop_response_latency += sf_res.second * clockPeriod();
606 DPRINTF(CoherentXBar, "%s: src %s %s 0x%x"\
607 " SF size: %i lat: %i\n", __func__,
608 slavePorts[slave_port_id]->name(), pkt->cmdString(),
609 pkt->getAddr(), sf_res.first.size(), sf_res.second);
610
611 // let the snoop filter know about the success of the send
612 // operation, and do it even before sending it onwards to
613 // avoid situations where atomic upward snoops sneak in
614 // between and change the filter state
615 snoopFilter->finishRequest(false, pkt);
616
617 snoop_result = forwardAtomic(pkt, slave_port_id, InvalidPortID,
618 sf_res.first);
619 } else {
620 snoop_result = forwardAtomic(pkt, slave_port_id);
621 }
622 snoop_response_cmd = snoop_result.first;
623 snoop_response_latency += snoop_result.second;
624 }
625
626 // forwardAtomic snooped into peer caches of the sender, and if
627 // this is a clean evict, but the packet is found in a cache, do
628 // not forward it
629 if (pkt->cmd == MemCmd::CleanEvict && pkt->isBlockCached()) {
630 DPRINTF(CoherentXBar, "recvAtomic: Clean evict 0x%x still cached, "
631 "not forwarding\n", pkt->getAddr());
632 return 0;
633 }
634
635 // even if we had a snoop response, we must continue and also
636 // perform the actual request at the destination
637 PortID master_port_id = findPort(pkt->getAddr());
638
639 // stats updates for the request
640 pktCount[slave_port_id][master_port_id]++;
641 pktSize[slave_port_id][master_port_id] += pkt_size;
642 transDist[pkt_cmd]++;
643
644 // forward the request to the appropriate destination
645 Tick response_latency = masterPorts[master_port_id]->sendAtomic(pkt);
646
647 // if lower levels have replied, tell the snoop filter
648 if (!system->bypassCaches() && snoopFilter && pkt->isResponse()) {
649 snoopFilter->updateResponse(pkt, *slavePorts[slave_port_id]);
650 }
651
652 // if we got a response from a snooper, restore it here
653 if (snoop_response_cmd != MemCmd::InvalidCmd) {
654 // no one else should have responded
655 assert(!pkt->isResponse());
656 pkt->cmd = snoop_response_cmd;
657 response_latency = snoop_response_latency;
658 }
659
660 // add the response data
661 if (pkt->isResponse()) {
662 pkt_size = pkt->hasData() ? pkt->getSize() : 0;
663 pkt_cmd = pkt->cmdToIndex();
664
665 // stats updates
666 pktCount[slave_port_id][master_port_id]++;
667 pktSize[slave_port_id][master_port_id] += pkt_size;
668 transDist[pkt_cmd]++;
669 }
670
671 // @todo: Not setting header time
672 pkt->payloadDelay = response_latency;
673 return response_latency;
674}
675
676Tick
677CoherentXBar::recvAtomicSnoop(PacketPtr pkt, PortID master_port_id)
678{
679 DPRINTF(CoherentXBar, "recvAtomicSnoop: packet src %s addr 0x%x cmd %s\n",
680 masterPorts[master_port_id]->name(), pkt->getAddr(),
681 pkt->cmdString());
682
683 // add the request snoop data
684 snoops++;
685
686 // forward to all snoopers
687 std::pair<MemCmd, Tick> snoop_result;
688 Tick snoop_response_latency = 0;
689 if (snoopFilter) {
690 auto sf_res = snoopFilter->lookupSnoop(pkt);
691 snoop_response_latency += sf_res.second * clockPeriod();
692 DPRINTF(CoherentXBar, "%s: src %s %s 0x%x SF size: %i lat: %i\n",
693 __func__, masterPorts[master_port_id]->name(), pkt->cmdString(),
694 pkt->getAddr(), sf_res.first.size(), sf_res.second);
695 snoop_result = forwardAtomic(pkt, InvalidPortID, master_port_id,
696 sf_res.first);
697 } else {
698 snoop_result = forwardAtomic(pkt, InvalidPortID);
699 }
700 MemCmd snoop_response_cmd = snoop_result.first;
701 snoop_response_latency += snoop_result.second;
702
703 if (snoop_response_cmd != MemCmd::InvalidCmd)
704 pkt->cmd = snoop_response_cmd;
705
706 // add the response snoop data
707 if (pkt->isResponse()) {
708 snoops++;
709 }
710
711 // @todo: Not setting header time
712 pkt->payloadDelay = snoop_response_latency;
713 return snoop_response_latency;
714}
715
716std::pair<MemCmd, Tick>
717CoherentXBar::forwardAtomic(PacketPtr pkt, PortID exclude_slave_port_id,
718 PortID source_master_port_id,
719 const std::vector<QueuedSlavePort*>& dests)
720{
721 // the packet may be changed on snoops, record the original
722 // command to enable us to restore it between snoops so that
723 // additional snoops can take place properly
724 MemCmd orig_cmd = pkt->cmd;
725 MemCmd snoop_response_cmd = MemCmd::InvalidCmd;
726 Tick snoop_response_latency = 0;
727
728 // snoops should only happen if the system isn't bypassing caches
729 assert(!system->bypassCaches());
730
731 unsigned fanout = 0;
732
733 for (const auto& p: dests) {
734 // we could have gotten this request from a snooping master
735 // (corresponding to our own slave port that is also in
736 // snoopPorts) and should not send it back to where it came
737 // from
738 if (exclude_slave_port_id != InvalidPortID &&
739 p->getId() == exclude_slave_port_id)
740 continue;
741
742 Tick latency = p->sendAtomicSnoop(pkt);
743 fanout++;
744
745 // in contrast to a functional access, we have to keep on
746 // going as all snoopers must be updated even if we get a
747 // response
748 if (!pkt->isResponse())
749 continue;
750
751 // response from snoop agent
752 assert(pkt->cmd != orig_cmd);
753 assert(pkt->memInhibitAsserted());
754 // should only happen once
755 assert(snoop_response_cmd == MemCmd::InvalidCmd);
756 // save response state
757 snoop_response_cmd = pkt->cmd;
758 snoop_response_latency = latency;
759
760 if (snoopFilter) {
761 // Handle responses by the snoopers and differentiate between
762 // responses to requests from above and snoops from below
763 if (source_master_port_id != InvalidPortID) {
764 // Getting a response for a snoop from below
765 assert(exclude_slave_port_id == InvalidPortID);
766 snoopFilter->updateSnoopForward(pkt, *p,
767 *masterPorts[source_master_port_id]);
768 } else {
769 // Getting a response for a request from above
770 assert(source_master_port_id == InvalidPortID);
771 snoopFilter->updateSnoopResponse(pkt, *p,
772 *slavePorts[exclude_slave_port_id]);
773 }
774 }
775 // restore original packet state for remaining snoopers
776 pkt->cmd = orig_cmd;
777 }
778
779 // Stats for fanout
780 snoopFanout.sample(fanout);
781
782 // the packet is restored as part of the loop and any potential
783 // snoop response is part of the returned pair
784 return std::make_pair(snoop_response_cmd, snoop_response_latency);
785}
786
787void
788CoherentXBar::recvFunctional(PacketPtr pkt, PortID slave_port_id)
789{
790 if (!pkt->isPrint()) {
791 // don't do DPRINTFs on PrintReq as it clutters up the output
792 DPRINTF(CoherentXBar,
793 "recvFunctional: packet src %s addr 0x%x cmd %s\n",
794 slavePorts[slave_port_id]->name(), pkt->getAddr(),
795 pkt->cmdString());
796 }
797
798 if (!system->bypassCaches()) {
799 // forward to all snoopers but the source
800 forwardFunctional(pkt, slave_port_id);
801 }
802
803 // there is no need to continue if the snooping has found what we
804 // were looking for and the packet is already a response
805 if (!pkt->isResponse()) {
806 // since our slave ports are queued ports we need to check them as well
807 for (const auto& p : slavePorts) {
808 // if we find a response that has the data, then the
809 // downstream caches/memories may be out of date, so simply stop
810 // here
811 if (p->checkFunctional(pkt)) {
812 if (pkt->needsResponse())
813 pkt->makeResponse();
814 return;
815 }
816 }
817
818 PortID dest_id = findPort(pkt->getAddr());
819
820 masterPorts[dest_id]->sendFunctional(pkt);
821 }
822}
823
824void
825CoherentXBar::recvFunctionalSnoop(PacketPtr pkt, PortID master_port_id)
826{
827 if (!pkt->isPrint()) {
828 // don't do DPRINTFs on PrintReq as it clutters up the output
829 DPRINTF(CoherentXBar,
830 "recvFunctionalSnoop: packet src %s addr 0x%x cmd %s\n",
831 masterPorts[master_port_id]->name(), pkt->getAddr(),
832 pkt->cmdString());
833 }
834
835 // forward to all snoopers
836 forwardFunctional(pkt, InvalidPortID);
837}
838
839void
840CoherentXBar::forwardFunctional(PacketPtr pkt, PortID exclude_slave_port_id)
841{
842 // snoops should only happen if the system isn't bypassing caches
843 assert(!system->bypassCaches());
844
845 for (const auto& p: snoopPorts) {
846 // we could have gotten this request from a snooping master
847 // (corresponding to our own slave port that is also in
848 // snoopPorts) and should not send it back to where it came
849 // from
850 if (exclude_slave_port_id == InvalidPortID ||
851 p->getId() != exclude_slave_port_id)
852 p->sendFunctionalSnoop(pkt);
853
854 // if we get a response we are done
855 if (pkt->isResponse()) {
856 break;
857 }
858 }
859}
860
861void
862CoherentXBar::regStats()
863{
864 // register the stats of the base class and our layers
865 BaseXBar::regStats();
866 for (auto l: reqLayers)
867 l->regStats();
868 for (auto l: respLayers)
869 l->regStats();
870 for (auto l: snoopLayers)
871 l->regStats();
872
873 snoops
874 .name(name() + ".snoops")
875 .desc("Total snoops (count)")
876 ;
877
878 snoopFanout
879 .init(0, snoopPorts.size(), 1)
880 .name(name() + ".snoop_fanout")
881 .desc("Request fanout histogram")
882 ;
883}
884
885CoherentXBar *
886CoherentXBarParams::create()
887{
888 return new CoherentXBar(this);
889}
|