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()
65{
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;
218 ntargets = 1;
219 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;
224 targets->add(target, whenReady, _order, source, true);
225 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
237 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;
252 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
259 targets->clearDownstreamPending();
260 }
261 return false;
262}
263
264
265void
266MSHR::deallocate()
267{
268 assert(targets->empty());
269 targets->resetFlags();
270 assert(deferredTargets->isReset());
271 assert(ntargets == 0);
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 &&
297 (!deferredTargets->empty() || hasPostInvalidate() ||
298 (pkt->needsExclusive() &&
299 (!isPendingDirty() || hasPostDowngrade() || isForward)))) {
300 // need to put on deferred list
301 if (hasPostInvalidate())
302 replaceUpgrade(pkt);
303 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).
309 targets->add(pkt, whenReady, _order, Target::FromCPU, !inService);
310 }
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()) {
335 targets->replaceUpgrades();
336 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...
347 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);
368 targets->add(cp_pkt, curTick(), _order, Target::FromSnoop,
369 downstreamPending && targets->needsExclusive);
370 ++ntargets;
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{
397 assert(targets->empty());
398 if (deferredTargets->empty()) {
399 return false;
400 }
401
402 // swap targets & deferredTargets lists
403 TargetList *tmp = targets;
404 targets = deferredTargets;
405 deferredTargets = tmp;
406
407 assert(targets->size() == ntargets);
408
409 // clear deferredTargets flags
410 deferredTargets->resetFlags();
411
412 order = targets->front().order;
413 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())
424 && 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.
433 assert(!targets->needsExclusive);
434 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
438 deferredTargets->clearDownstreamPending();
439 // this clears out deferredTargets too
440 targets->splice(targets->end(), *deferredTargets);
441 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 {
456 return (targets->checkFunctional(pkt) ||
457 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);
477 targets->print(os, verbosity, prefix + " ");
478 if (!deferredTargets->empty()) {
479 ccprintf(os, "%s Deferred Targets:\n", prefix);
480 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}
491
492MSHR::~MSHR()
493{
494 delete[] targets;
495 delete[] deferredTargets;
496}