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() : 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)
69{
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;
217 assert(targets.isReset());
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;
222 targets.add(target, whenReady, _order, source, true);
223 assert(deferredTargets.isReset());
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
235 targets.clearDownstreamPending();
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;
250 pendingDirty = (targets.needsExclusive ||
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
257 targets.clearDownstreamPending();
258 }
259 return false;
260}
261
262
263void
264MSHR::deallocate()
265{
266 assert(targets.empty());
267 targets.resetFlags();
268 assert(deferredTargets.isReset());
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 &&
294 (!deferredTargets.empty() || hasPostInvalidate() ||
295 (pkt->needsExclusive() &&
296 (!isPendingDirty() || hasPostDowngrade() || isForward)))) {
297 // need to put on deferred list
298 if (hasPostInvalidate())
299 replaceUpgrade(pkt);
300 deferredTargets.add(pkt, whenReady, _order, Target::FromCPU, true);
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).
306 targets.add(pkt, whenReady, _order, Target::FromCPU, !inService);
307 }
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()) {
330 targets.replaceUpgrades();
331 deferredTargets.replaceUpgrades();
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...
342 deferredTargets.replaceUpgrades();
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);
363 targets.add(cp_pkt, curTick(), _order, Target::FromSnoop,
364 downstreamPending && targets.needsExclusive);
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{
391 assert(targets.empty());
392 if (deferredTargets.empty()) {
393 return false;
394 }
395
396 // swap targets & deferredTargets lists
397 std::swap(targets, deferredTargets);
398
399 // clear deferredTargets flags
400 deferredTargets.resetFlags();
401
402 order = targets.front().order;
403 readyTime = std::max(curTick(), targets.front().readyTime);
404
405 return true;
406}
407
408
409void
410MSHR::handleFill(Packet *pkt, CacheBlk *blk)
411{
412 if (!pkt->sharedAsserted()
413 && !(hasPostInvalidate() || hasPostDowngrade())
414 && deferredTargets.needsExclusive) {
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.
423 assert(!targets.needsExclusive);
424 targets.needsExclusive = true;
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
428 deferredTargets.clearDownstreamPending();
429 // this clears out deferredTargets too
430 targets.splice(targets.end(), deferredTargets);
431 deferredTargets.resetFlags();
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 {
446 return (targets.checkFunctional(pkt) ||
447 deferredTargets.checkFunctional(pkt));
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);
467 targets.print(os, verbosity, prefix + " ");
468 if (!deferredTargets.empty()) {
469 ccprintf(os, "%s Deferred Targets:\n", prefix);
470 deferredTargets.print(os, verbosity, prefix + " ");
471 }
472}
473
474std::string
475MSHR::print() const
476{
477 ostringstream str;
478 print(str);
479 return str.str();
480}