mshr.cc (9724:7c7ed0cae353) mshr.cc (9725:0d4ee33078bb)
1/*
2 * Copyright (c) 2012 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

--- 47 unchanged lines hidden (view full) ---

56#include "base/types.hh"
57#include "debug/Cache.hh"
58#include "mem/cache/cache.hh"
59#include "mem/cache/mshr.hh"
60#include "sim/core.hh"
61
62using namespace std;
63
1/*
2 * Copyright (c) 2012 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

--- 47 unchanged lines hidden (view full) ---

56#include "base/types.hh"
57#include "debug/Cache.hh"
58#include "mem/cache/cache.hh"
59#include "mem/cache/mshr.hh"
60#include "sim/core.hh"
61
62using namespace std;
63
64MSHR::MSHR()
64MSHR::MSHR() : readyTime(0), _isUncacheable(false), downstreamPending(false),
65 pendingDirty(false), postInvalidate(false),
66 postDowngrade(false), queue(NULL), order(0), addr(0), size(0),
67 inService(false), isForward(false), threadNum(InvalidThreadID),
68 data(NULL)
65{
69{
66 inService = false;
67 ntargets = 0;
68 threadNum = InvalidThreadID;
69 targets = new TargetList();
70 deferredTargets = new TargetList();
71}
72
73
74MSHR::TargetList::TargetList()
75 : needsExclusive(false), hasUpgrade(false)
76{}
77
78

--- 131 unchanged lines hidden (view full) ---

210 readyTime = whenReady;
211 order = _order;
212 assert(target);
213 isForward = false;
214 _isUncacheable = target->req->isUncacheable();
215 inService = false;
216 downstreamPending = false;
217 threadNum = 0;
70}
71
72
73MSHR::TargetList::TargetList()
74 : needsExclusive(false), hasUpgrade(false)
75{}
76
77

--- 131 unchanged lines hidden (view full) ---

209 readyTime = whenReady;
210 order = _order;
211 assert(target);
212 isForward = false;
213 _isUncacheable = target->req->isUncacheable();
214 inService = false;
215 downstreamPending = false;
216 threadNum = 0;
218 ntargets = 1;
219 assert(targets->isReset());
217 assert(targets.isReset());
220 // Don't know of a case where we would allocate a new MSHR for a
221 // snoop (mem-side request), so set source according to request here
222 Target::Source source = (target->cmd == MemCmd::HardPFReq) ?
223 Target::FromPrefetcher : Target::FromCPU;
218 // Don't know of a case where we would allocate a new MSHR for a
219 // snoop (mem-side request), so set source according to request here
220 Target::Source source = (target->cmd == MemCmd::HardPFReq) ?
221 Target::FromPrefetcher : Target::FromCPU;
224 targets->add(target, whenReady, _order, source, true);
225 assert(deferredTargets->isReset());
222 targets.add(target, whenReady, _order, source, true);
223 assert(deferredTargets.isReset());
226 data = NULL;
227}
228
229
230void
231MSHR::clearDownstreamPending()
232{
233 assert(downstreamPending);
234 downstreamPending = false;
235 // recursively clear flag on any MSHRs we will be forwarding
236 // responses to
224 data = NULL;
225}
226
227
228void
229MSHR::clearDownstreamPending()
230{
231 assert(downstreamPending);
232 downstreamPending = false;
233 // recursively clear flag on any MSHRs we will be forwarding
234 // responses to
237 targets->clearDownstreamPending();
235 targets.clearDownstreamPending();
238}
239
240bool
241MSHR::markInService(PacketPtr pkt)
242{
243 assert(!inService);
244 if (isForwardNoResponse()) {
245 // we just forwarded the request packet & don't expect a
246 // response, so get rid of it
247 assert(getNumTargets() == 1);
248 popTarget();
249 return true;
250 }
251 inService = true;
236}
237
238bool
239MSHR::markInService(PacketPtr pkt)
240{
241 assert(!inService);
242 if (isForwardNoResponse()) {
243 // we just forwarded the request packet & don't expect a
244 // response, so get rid of it
245 assert(getNumTargets() == 1);
246 popTarget();
247 return true;
248 }
249 inService = true;
252 pendingDirty = (targets->needsExclusive ||
250 pendingDirty = (targets.needsExclusive ||
253 (!pkt->sharedAsserted() && pkt->memInhibitAsserted()));
254 postInvalidate = postDowngrade = false;
255
256 if (!downstreamPending) {
257 // let upstream caches know that the request has made it to a
258 // level where it's going to get a response
251 (!pkt->sharedAsserted() && pkt->memInhibitAsserted()));
252 postInvalidate = postDowngrade = false;
253
254 if (!downstreamPending) {
255 // let upstream caches know that the request has made it to a
256 // level where it's going to get a response
259 targets->clearDownstreamPending();
257 targets.clearDownstreamPending();
260 }
261 return false;
262}
263
264
265void
266MSHR::deallocate()
267{
258 }
259 return false;
260}
261
262
263void
264MSHR::deallocate()
265{
268 assert(targets->empty());
269 targets->resetFlags();
270 assert(deferredTargets->isReset());
271 assert(ntargets == 0);
266 assert(targets.empty());
267 targets.resetFlags();
268 assert(deferredTargets.isReset());
272 inService = false;
273}
274
275/*
276 * Adds a target to an MSHR
277 */
278void
279MSHR::allocateTarget(PacketPtr pkt, Tick whenReady, Counter _order)

--- 9 unchanged lines hidden (view full) ---

289 // another read request that will downgrade our exclusive block
290 // to shared
291
292 // assume we'd never issue a prefetch when we've got an
293 // outstanding miss
294 assert(pkt->cmd != MemCmd::HardPFReq);
295
296 if (inService &&
269 inService = false;
270}
271
272/*
273 * Adds a target to an MSHR
274 */
275void
276MSHR::allocateTarget(PacketPtr pkt, Tick whenReady, Counter _order)

--- 9 unchanged lines hidden (view full) ---

286 // another read request that will downgrade our exclusive block
287 // to shared
288
289 // assume we'd never issue a prefetch when we've got an
290 // outstanding miss
291 assert(pkt->cmd != MemCmd::HardPFReq);
292
293 if (inService &&
297 (!deferredTargets->empty() || hasPostInvalidate() ||
294 (!deferredTargets.empty() || hasPostInvalidate() ||
298 (pkt->needsExclusive() &&
299 (!isPendingDirty() || hasPostDowngrade() || isForward)))) {
300 // need to put on deferred list
301 if (hasPostInvalidate())
302 replaceUpgrade(pkt);
295 (pkt->needsExclusive() &&
296 (!isPendingDirty() || hasPostDowngrade() || isForward)))) {
297 // need to put on deferred list
298 if (hasPostInvalidate())
299 replaceUpgrade(pkt);
303 deferredTargets->add(pkt, whenReady, _order, Target::FromCPU, true);
300 deferredTargets.add(pkt, whenReady, _order, Target::FromCPU, true);
304 } else {
305 // No request outstanding, or still OK to append to
306 // outstanding request: append to regular target list. Only
307 // mark pending if current request hasn't been issued yet
308 // (isn't in service).
301 } else {
302 // No request outstanding, or still OK to append to
303 // outstanding request: append to regular target list. Only
304 // mark pending if current request hasn't been issued yet
305 // (isn't in service).
309 targets->add(pkt, whenReady, _order, Target::FromCPU, !inService);
306 targets.add(pkt, whenReady, _order, Target::FromCPU, !inService);
310 }
307 }
311
312 ++ntargets;
313}
314
315bool
316MSHR::handleSnoop(PacketPtr pkt, Counter _order)
317{
318 DPRINTF(Cache, "%s for %s address %x size %d\n", __func__,
319 pkt->cmdString(), pkt->getAddr(), pkt->getSize());
320 if (!inService || (pkt->isExpressSnoop() && downstreamPending)) {

--- 6 unchanged lines hidden (view full) ---

327 // that if we're an L2+ cache buffering an UpgradeReq from a
328 // higher-level cache, and the snoop is invalidating, then our
329 // buffered upgrades must be converted to read exclusives,
330 // since the upper-level cache no longer has a valid copy.
331 // That is, even though the upper-level cache got out on its
332 // local bus first, some other invalidating transaction
333 // reached the global bus before the upgrade did.
334 if (pkt->needsExclusive()) {
308}
309
310bool
311MSHR::handleSnoop(PacketPtr pkt, Counter _order)
312{
313 DPRINTF(Cache, "%s for %s address %x size %d\n", __func__,
314 pkt->cmdString(), pkt->getAddr(), pkt->getSize());
315 if (!inService || (pkt->isExpressSnoop() && downstreamPending)) {

--- 6 unchanged lines hidden (view full) ---

322 // that if we're an L2+ cache buffering an UpgradeReq from a
323 // higher-level cache, and the snoop is invalidating, then our
324 // buffered upgrades must be converted to read exclusives,
325 // since the upper-level cache no longer has a valid copy.
326 // That is, even though the upper-level cache got out on its
327 // local bus first, some other invalidating transaction
328 // reached the global bus before the upgrade did.
329 if (pkt->needsExclusive()) {
335 targets->replaceUpgrades();
336 deferredTargets->replaceUpgrades();
330 targets.replaceUpgrades();
331 deferredTargets.replaceUpgrades();
337 }
338
339 return false;
340 }
341
342 // From here on down, the request issued by this MSHR logically
343 // precedes the request we're snooping.
344 if (pkt->needsExclusive()) {
345 // snooped request still precedes the re-request we'll have to
346 // issue for deferred targets, if any...
332 }
333
334 return false;
335 }
336
337 // From here on down, the request issued by this MSHR logically
338 // precedes the request we're snooping.
339 if (pkt->needsExclusive()) {
340 // snooped request still precedes the re-request we'll have to
341 // issue for deferred targets, if any...
347 deferredTargets->replaceUpgrades();
342 deferredTargets.replaceUpgrades();
348 }
349
350 if (hasPostInvalidate()) {
351 // a prior snoop has already appended an invalidation, so
352 // logically we don't have the block anymore; no need for
353 // further snooping.
354 return true;
355 }

--- 4 unchanged lines hidden (view full) ---

360 // and we need to respond after we receive data.
361 // 2. It's an invalidation (e.g., UpgradeReq), and we need
362 // to forward the snoop up the hierarchy after the current
363 // transaction completes.
364
365 // Actual target device (typ. a memory) will delete the
366 // packet on reception, so we need to save a copy here.
367 PacketPtr cp_pkt = new Packet(pkt, true);
343 }
344
345 if (hasPostInvalidate()) {
346 // a prior snoop has already appended an invalidation, so
347 // logically we don't have the block anymore; no need for
348 // further snooping.
349 return true;
350 }

--- 4 unchanged lines hidden (view full) ---

355 // and we need to respond after we receive data.
356 // 2. It's an invalidation (e.g., UpgradeReq), and we need
357 // to forward the snoop up the hierarchy after the current
358 // transaction completes.
359
360 // Actual target device (typ. a memory) will delete the
361 // packet on reception, so we need to save a copy here.
362 PacketPtr cp_pkt = new Packet(pkt, true);
368 targets->add(cp_pkt, curTick(), _order, Target::FromSnoop,
369 downstreamPending && targets->needsExclusive);
370 ++ntargets;
363 targets.add(cp_pkt, curTick(), _order, Target::FromSnoop,
364 downstreamPending && targets.needsExclusive);
371
372 if (isPendingDirty()) {
373 pkt->assertMemInhibit();
374 pkt->setSupplyExclusive();
375 }
376
377 if (pkt->needsExclusive()) {
378 // This transaction will take away our pending copy

--- 10 unchanged lines hidden (view full) ---

389
390 return true;
391}
392
393
394bool
395MSHR::promoteDeferredTargets()
396{
365
366 if (isPendingDirty()) {
367 pkt->assertMemInhibit();
368 pkt->setSupplyExclusive();
369 }
370
371 if (pkt->needsExclusive()) {
372 // This transaction will take away our pending copy

--- 10 unchanged lines hidden (view full) ---

383
384 return true;
385}
386
387
388bool
389MSHR::promoteDeferredTargets()
390{
397 assert(targets->empty());
398 if (deferredTargets->empty()) {
391 assert(targets.empty());
392 if (deferredTargets.empty()) {
399 return false;
400 }
401
402 // swap targets & deferredTargets lists
393 return false;
394 }
395
396 // swap targets & deferredTargets lists
403 TargetList *tmp = targets;
404 targets = deferredTargets;
405 deferredTargets = tmp;
397 std::swap(targets, deferredTargets);
406
398
407 assert(targets->size() == ntargets);
408
409 // clear deferredTargets flags
399 // clear deferredTargets flags
410 deferredTargets->resetFlags();
400 deferredTargets.resetFlags();
411
401
412 order = targets->front().order;
413 readyTime = std::max(curTick(), targets->front().readyTime);
402 order = targets.front().order;
403 readyTime = std::max(curTick(), targets.front().readyTime);
414
415 return true;
416}
417
418
419void
420MSHR::handleFill(Packet *pkt, CacheBlk *blk)
421{
422 if (!pkt->sharedAsserted()
423 && !(hasPostInvalidate() || hasPostDowngrade())
404
405 return true;
406}
407
408
409void
410MSHR::handleFill(Packet *pkt, CacheBlk *blk)
411{
412 if (!pkt->sharedAsserted()
413 && !(hasPostInvalidate() || hasPostDowngrade())
424 && deferredTargets->needsExclusive) {
414 && deferredTargets.needsExclusive) {
425 // We got an exclusive response, but we have deferred targets
426 // which are waiting to request an exclusive copy (not because
427 // of a pending invalidate). This can happen if the original
428 // request was for a read-only (non-exclusive) block, but we
429 // got an exclusive copy anyway because of the E part of the
430 // MOESI/MESI protocol. Since we got the exclusive copy
431 // there's no need to defer the targets, so move them up to
432 // the regular target list.
415 // We got an exclusive response, but we have deferred targets
416 // which are waiting to request an exclusive copy (not because
417 // of a pending invalidate). This can happen if the original
418 // request was for a read-only (non-exclusive) block, but we
419 // got an exclusive copy anyway because of the E part of the
420 // MOESI/MESI protocol. Since we got the exclusive copy
421 // there's no need to defer the targets, so move them up to
422 // the regular target list.
433 assert(!targets->needsExclusive);
434 targets->needsExclusive = true;
423 assert(!targets.needsExclusive);
424 targets.needsExclusive = true;
435 // if any of the deferred targets were upper-level cache
436 // requests marked downstreamPending, need to clear that
437 assert(!downstreamPending); // not pending here anymore
425 // if any of the deferred targets were upper-level cache
426 // requests marked downstreamPending, need to clear that
427 assert(!downstreamPending); // not pending here anymore
438 deferredTargets->clearDownstreamPending();
428 deferredTargets.clearDownstreamPending();
439 // this clears out deferredTargets too
429 // this clears out deferredTargets too
440 targets->splice(targets->end(), *deferredTargets);
441 deferredTargets->resetFlags();
430 targets.splice(targets.end(), deferredTargets);
431 deferredTargets.resetFlags();
442 }
443}
444
445
446bool
447MSHR::checkFunctional(PacketPtr pkt)
448{
449 // For printing, we treat the MSHR as a whole as single entity.
450 // For other requests, we iterate over the individual targets
451 // since that's where the actual data lies.
452 if (pkt->isPrint()) {
453 pkt->checkFunctional(this, addr, size, NULL);
454 return false;
455 } else {
432 }
433}
434
435
436bool
437MSHR::checkFunctional(PacketPtr pkt)
438{
439 // For printing, we treat the MSHR as a whole as single entity.
440 // For other requests, we iterate over the individual targets
441 // since that's where the actual data lies.
442 if (pkt->isPrint()) {
443 pkt->checkFunctional(this, addr, size, NULL);
444 return false;
445 } else {
456 return (targets->checkFunctional(pkt) ||
457 deferredTargets->checkFunctional(pkt));
446 return (targets.checkFunctional(pkt) ||
447 deferredTargets.checkFunctional(pkt));
458 }
459}
460
461
462void
463MSHR::print(std::ostream &os, int verbosity, const std::string &prefix) const
464{
465 ccprintf(os, "%s[%x:%x] %s %s %s state: %s %s %s %s %s\n",
466 prefix, addr, addr+size-1,
467 isForward ? "Forward" : "",
468 isForwardNoResponse() ? "ForwNoResp" : "",
469 needsExclusive() ? "Excl" : "",
470 _isUncacheable ? "Unc" : "",
471 inService ? "InSvc" : "",
472 downstreamPending ? "DwnPend" : "",
473 hasPostInvalidate() ? "PostInv" : "",
474 hasPostDowngrade() ? "PostDowngr" : "");
475
476 ccprintf(os, "%s Targets:\n", prefix);
448 }
449}
450
451
452void
453MSHR::print(std::ostream &os, int verbosity, const std::string &prefix) const
454{
455 ccprintf(os, "%s[%x:%x] %s %s %s state: %s %s %s %s %s\n",
456 prefix, addr, addr+size-1,
457 isForward ? "Forward" : "",
458 isForwardNoResponse() ? "ForwNoResp" : "",
459 needsExclusive() ? "Excl" : "",
460 _isUncacheable ? "Unc" : "",
461 inService ? "InSvc" : "",
462 downstreamPending ? "DwnPend" : "",
463 hasPostInvalidate() ? "PostInv" : "",
464 hasPostDowngrade() ? "PostDowngr" : "");
465
466 ccprintf(os, "%s Targets:\n", prefix);
477 targets->print(os, verbosity, prefix + " ");
478 if (!deferredTargets->empty()) {
467 targets.print(os, verbosity, prefix + " ");
468 if (!deferredTargets.empty()) {
479 ccprintf(os, "%s Deferred Targets:\n", prefix);
469 ccprintf(os, "%s Deferred Targets:\n", prefix);
480 deferredTargets->print(os, verbosity, prefix + " ");
470 deferredTargets.print(os, verbosity, prefix + " ");
481 }
482}
483
484std::string
485MSHR::print() const
486{
487 ostringstream str;
488 print(str);
489 return str.str();
490}
471 }
472}
473
474std::string
475MSHR::print() const
476{
477 ostringstream str;
478 print(str);
479 return str.str();
480}
491
492MSHR::~MSHR()
493{
494 delete[] targets;
495 delete[] deferredTargets;
496}