mshr.cc revision 10582:c04dc66e4316
112855Sgabeblack@google.com/* 212855Sgabeblack@google.com * Copyright (c) 2012-2013 ARM Limited 312855Sgabeblack@google.com * All rights reserved. 412855Sgabeblack@google.com * 512855Sgabeblack@google.com * The license below extends only to copyright in the software and shall 612855Sgabeblack@google.com * not be construed as granting a license to any other intellectual 712855Sgabeblack@google.com * property including but not limited to intellectual property relating 812855Sgabeblack@google.com * to a hardware implementation of the functionality of the software 912855Sgabeblack@google.com * licensed hereunder. You may use the software subject to the license 1012855Sgabeblack@google.com * terms below provided that you ensure that this notice is replicated 1112855Sgabeblack@google.com * unmodified and in its entirety in all distributions of the software, 1212855Sgabeblack@google.com * modified or unmodified, in source code or in binary form. 1312855Sgabeblack@google.com * 1412855Sgabeblack@google.com * Copyright (c) 2002-2005 The Regents of The University of Michigan 1512855Sgabeblack@google.com * Copyright (c) 2010 Advanced Micro Devices, Inc. 1612855Sgabeblack@google.com * All rights reserved. 1712855Sgabeblack@google.com * 1812855Sgabeblack@google.com * Redistribution and use in source and binary forms, with or without 1912855Sgabeblack@google.com * modification, are permitted provided that the following conditions are 2012855Sgabeblack@google.com * met: redistributions of source code must retain the above copyright 2112855Sgabeblack@google.com * notice, this list of conditions and the following disclaimer; 2212855Sgabeblack@google.com * redistributions in binary form must reproduce the above copyright 2312855Sgabeblack@google.com * notice, this list of conditions and the following disclaimer in the 2412855Sgabeblack@google.com * documentation and/or other materials provided with the distribution; 2512855Sgabeblack@google.com * neither the name of the copyright holders nor the names of its 2612855Sgabeblack@google.com * contributors may be used to endorse or promote products derived from 2712855Sgabeblack@google.com * this software without specific prior written permission. 2812855Sgabeblack@google.com * 2912855Sgabeblack@google.com * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 3012855Sgabeblack@google.com * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 3112855Sgabeblack@google.com * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 3212855Sgabeblack@google.com * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 3312855Sgabeblack@google.com * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 3412855Sgabeblack@google.com * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 3512855Sgabeblack@google.com * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 3612855Sgabeblack@google.com * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 3712855Sgabeblack@google.com * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 3812855Sgabeblack@google.com * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 3912855Sgabeblack@google.com * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 4012855Sgabeblack@google.com * 4112855Sgabeblack@google.com * Authors: Erik Hallnor 4212855Sgabeblack@google.com * Dave Greene 4312855Sgabeblack@google.com */ 4412855Sgabeblack@google.com 4512855Sgabeblack@google.com/** 4612855Sgabeblack@google.com * @file 4712855Sgabeblack@google.com * Miss Status and Handling Register (MSHR) definitions. 4812855Sgabeblack@google.com */ 4912855Sgabeblack@google.com 5012855Sgabeblack@google.com#include <algorithm> 5112855Sgabeblack@google.com#include <cassert> 5212855Sgabeblack@google.com#include <string> 5312855Sgabeblack@google.com#include <vector> 5412855Sgabeblack@google.com 5512855Sgabeblack@google.com#include "base/misc.hh" 5612855Sgabeblack@google.com#include "base/types.hh" 5712855Sgabeblack@google.com#include "debug/Cache.hh" 5812855Sgabeblack@google.com#include "mem/cache/cache.hh" 5912855Sgabeblack@google.com#include "mem/cache/mshr.hh" 6012855Sgabeblack@google.com#include "sim/core.hh" 6112855Sgabeblack@google.com 6212855Sgabeblack@google.comusing namespace std; 6312855Sgabeblack@google.com 6412855Sgabeblack@google.comMSHR::MSHR() : readyTime(0), _isUncacheable(false), downstreamPending(false), 6512855Sgabeblack@google.com pendingDirty(false), 6612855Sgabeblack@google.com postInvalidate(false), postDowngrade(false), 6712855Sgabeblack@google.com queue(NULL), order(0), addr(0), 6812855Sgabeblack@google.com size(0), isSecure(false), inService(false), 6912855Sgabeblack@google.com isForward(false), threadNum(InvalidThreadID), data(NULL) 7012855Sgabeblack@google.com{ 71} 72 73 74MSHR::TargetList::TargetList() 75 : needsExclusive(false), hasUpgrade(false) 76{} 77 78 79inline void 80MSHR::TargetList::add(PacketPtr pkt, Tick readyTime, 81 Counter order, Target::Source source, bool markPending) 82{ 83 if (source != Target::FromSnoop) { 84 if (pkt->needsExclusive()) { 85 needsExclusive = true; 86 } 87 88 // StoreCondReq is effectively an upgrade if it's in an MSHR 89 // since it would have been failed already if we didn't have a 90 // read-only copy 91 if (pkt->isUpgrade() || pkt->cmd == MemCmd::StoreCondReq) { 92 hasUpgrade = true; 93 } 94 } 95 96 if (markPending) { 97 // Iterate over the SenderState stack and see if we find 98 // an MSHR entry. If we do, set the downstreamPending 99 // flag. Otherwise, do nothing. 100 MSHR *mshr = pkt->findNextSenderState<MSHR>(); 101 if (mshr != NULL) { 102 assert(!mshr->downstreamPending); 103 mshr->downstreamPending = true; 104 } 105 } 106 107 push_back(Target(pkt, readyTime, order, source, markPending)); 108} 109 110 111static void 112replaceUpgrade(PacketPtr pkt) 113{ 114 if (pkt->cmd == MemCmd::UpgradeReq) { 115 pkt->cmd = MemCmd::ReadExReq; 116 DPRINTF(Cache, "Replacing UpgradeReq with ReadExReq\n"); 117 } else if (pkt->cmd == MemCmd::SCUpgradeReq) { 118 pkt->cmd = MemCmd::SCUpgradeFailReq; 119 DPRINTF(Cache, "Replacing SCUpgradeReq with SCUpgradeFailReq\n"); 120 } else if (pkt->cmd == MemCmd::StoreCondReq) { 121 pkt->cmd = MemCmd::StoreCondFailReq; 122 DPRINTF(Cache, "Replacing StoreCondReq with StoreCondFailReq\n"); 123 } 124} 125 126 127void 128MSHR::TargetList::replaceUpgrades() 129{ 130 if (!hasUpgrade) 131 return; 132 133 Iterator end_i = end(); 134 for (Iterator i = begin(); i != end_i; ++i) { 135 replaceUpgrade(i->pkt); 136 } 137 138 hasUpgrade = false; 139} 140 141 142void 143MSHR::TargetList::clearDownstreamPending() 144{ 145 Iterator end_i = end(); 146 for (Iterator i = begin(); i != end_i; ++i) { 147 if (i->markedPending) { 148 // Iterate over the SenderState stack and see if we find 149 // an MSHR entry. If we find one, clear the 150 // downstreamPending flag by calling 151 // clearDownstreamPending(). This recursively clears the 152 // downstreamPending flag in all caches this packet has 153 // passed through. 154 MSHR *mshr = i->pkt->findNextSenderState<MSHR>(); 155 if (mshr != NULL) { 156 mshr->clearDownstreamPending(); 157 } 158 } 159 } 160} 161 162 163bool 164MSHR::TargetList::checkFunctional(PacketPtr pkt) 165{ 166 Iterator end_i = end(); 167 for (Iterator i = begin(); i != end_i; ++i) { 168 if (pkt->checkFunctional(i->pkt)) { 169 return true; 170 } 171 } 172 173 return false; 174} 175 176 177void 178MSHR::TargetList:: 179print(std::ostream &os, int verbosity, const std::string &prefix) const 180{ 181 ConstIterator end_i = end(); 182 for (ConstIterator i = begin(); i != end_i; ++i) { 183 const char *s; 184 switch (i->source) { 185 case Target::FromCPU: 186 s = "FromCPU"; 187 break; 188 case Target::FromSnoop: 189 s = "FromSnoop"; 190 break; 191 case Target::FromPrefetcher: 192 s = "FromPrefetcher"; 193 break; 194 default: 195 s = ""; 196 break; 197 } 198 ccprintf(os, "%s%s: ", prefix, s); 199 i->pkt->print(os, verbosity, ""); 200 } 201} 202 203 204void 205MSHR::allocate(Addr _addr, int _size, PacketPtr target, Tick whenReady, 206 Counter _order) 207{ 208 addr = _addr; 209 size = _size; 210 isSecure = target->isSecure(); 211 readyTime = whenReady; 212 order = _order; 213 assert(target); 214 isForward = false; 215 _isUncacheable = target->req->isUncacheable(); 216 inService = false; 217 downstreamPending = false; 218 threadNum = 0; 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 252 assert(pkt != NULL); 253 inService = true; 254 pendingDirty = targets.needsExclusive || 255 (!pkt->sharedAsserted() && pkt->memInhibitAsserted()); 256 postInvalidate = postDowngrade = false; 257 258 if (!downstreamPending) { 259 // let upstream caches know that the request has made it to a 260 // level where it's going to get a response 261 targets.clearDownstreamPending(); 262 } 263 return false; 264} 265 266 267void 268MSHR::deallocate() 269{ 270 assert(targets.empty()); 271 targets.resetFlags(); 272 assert(deferredTargets.isReset()); 273 inService = false; 274} 275 276/* 277 * Adds a target to an MSHR 278 */ 279void 280MSHR::allocateTarget(PacketPtr pkt, Tick whenReady, Counter _order) 281{ 282 // if there's a request already in service for this MSHR, we will 283 // have to defer the new target until after the response if any of 284 // the following are true: 285 // - there are other targets already deferred 286 // - there's a pending invalidate to be applied after the response 287 // comes back (but before this target is processed) 288 // - this target requires an exclusive block and either we're not 289 // getting an exclusive block back or we have already snooped 290 // another read request that will downgrade our exclusive block 291 // to shared 292 293 // assume we'd never issue a prefetch when we've got an 294 // outstanding miss 295 assert(pkt->cmd != MemCmd::HardPFReq); 296 297 if (inService && 298 (!deferredTargets.empty() || hasPostInvalidate() || 299 (pkt->needsExclusive() && 300 (!isPendingDirty() || hasPostDowngrade() || isForward)))) { 301 // need to put on deferred list 302 if (hasPostInvalidate()) 303 replaceUpgrade(pkt); 304 deferredTargets.add(pkt, whenReady, _order, Target::FromCPU, true); 305 } else { 306 // No request outstanding, or still OK to append to 307 // outstanding request: append to regular target list. Only 308 // mark pending if current request hasn't been issued yet 309 // (isn't in service). 310 targets.add(pkt, whenReady, _order, Target::FromCPU, !inService); 311 } 312} 313 314bool 315MSHR::handleSnoop(PacketPtr pkt, Counter _order) 316{ 317 DPRINTF(Cache, "%s for %s address %x size %d\n", __func__, 318 pkt->cmdString(), pkt->getAddr(), pkt->getSize()); 319 if (!inService || (pkt->isExpressSnoop() && downstreamPending)) { 320 // Request has not been issued yet, or it's been issued 321 // locally but is buffered unissued at some downstream cache 322 // which is forwarding us this snoop. Either way, the packet 323 // we're snooping logically precedes this MSHR's request, so 324 // the snoop has no impact on the MSHR, but must be processed 325 // in the standard way by the cache. The only exception is 326 // that if we're an L2+ cache buffering an UpgradeReq from a 327 // higher-level cache, and the snoop is invalidating, then our 328 // buffered upgrades must be converted to read exclusives, 329 // since the upper-level cache no longer has a valid copy. 330 // That is, even though the upper-level cache got out on its 331 // local bus first, some other invalidating transaction 332 // reached the global bus before the upgrade did. 333 if (pkt->needsExclusive()) { 334 targets.replaceUpgrades(); 335 deferredTargets.replaceUpgrades(); 336 } 337 338 return false; 339 } 340 341 // From here on down, the request issued by this MSHR logically 342 // precedes the request we're snooping. 343 if (pkt->needsExclusive()) { 344 // snooped request still precedes the re-request we'll have to 345 // issue for deferred targets, if any... 346 deferredTargets.replaceUpgrades(); 347 } 348 349 if (hasPostInvalidate()) { 350 // a prior snoop has already appended an invalidation, so 351 // logically we don't have the block anymore; no need for 352 // further snooping. 353 return true; 354 } 355 356 if (isPendingDirty() || pkt->isInvalidate()) { 357 // We need to save and replay the packet in two cases: 358 // 1. We're awaiting an exclusive copy, so ownership is pending, 359 // and we need to respond after we receive data. 360 // 2. It's an invalidation (e.g., UpgradeReq), and we need 361 // to forward the snoop up the hierarchy after the current 362 // transaction completes. 363 364 // Actual target device (typ. a memory) will delete the 365 // packet on reception, so we need to save a copy here. 366 367 // Clear flags and also allocate new data as the original 368 // packet data storage may have been deleted by the time we 369 // get to send this packet. 370 PacketPtr cp_pkt = new Packet(pkt, true, true); 371 targets.add(cp_pkt, curTick(), _order, Target::FromSnoop, 372 downstreamPending && targets.needsExclusive); 373 374 if (isPendingDirty()) { 375 pkt->assertMemInhibit(); 376 pkt->setSupplyExclusive(); 377 } 378 379 if (pkt->needsExclusive()) { 380 // This transaction will take away our pending copy 381 postInvalidate = true; 382 } 383 } 384 385 if (!pkt->needsExclusive()) { 386 // This transaction will get a read-shared copy, downgrading 387 // our copy if we had an exclusive one 388 postDowngrade = true; 389 pkt->assertShared(); 390 } 391 392 return true; 393} 394 395 396bool 397MSHR::promoteDeferredTargets() 398{ 399 assert(targets.empty()); 400 if (deferredTargets.empty()) { 401 return false; 402 } 403 404 // swap targets & deferredTargets lists 405 std::swap(targets, deferredTargets); 406 407 // clear deferredTargets flags 408 deferredTargets.resetFlags(); 409 410 order = targets.front().order; 411 readyTime = std::max(curTick(), targets.front().readyTime); 412 413 return true; 414} 415 416 417void 418MSHR::handleFill(Packet *pkt, CacheBlk *blk) 419{ 420 if (!pkt->sharedAsserted() 421 && !(hasPostInvalidate() || hasPostDowngrade()) 422 && deferredTargets.needsExclusive) { 423 // We got an exclusive response, but we have deferred targets 424 // which are waiting to request an exclusive copy (not because 425 // of a pending invalidate). This can happen if the original 426 // request was for a read-only (non-exclusive) block, but we 427 // got an exclusive copy anyway because of the E part of the 428 // MOESI/MESI protocol. Since we got the exclusive copy 429 // there's no need to defer the targets, so move them up to 430 // the regular target list. 431 assert(!targets.needsExclusive); 432 targets.needsExclusive = true; 433 // if any of the deferred targets were upper-level cache 434 // requests marked downstreamPending, need to clear that 435 assert(!downstreamPending); // not pending here anymore 436 deferredTargets.clearDownstreamPending(); 437 // this clears out deferredTargets too 438 targets.splice(targets.end(), deferredTargets); 439 deferredTargets.resetFlags(); 440 } 441} 442 443 444bool 445MSHR::checkFunctional(PacketPtr pkt) 446{ 447 // For printing, we treat the MSHR as a whole as single entity. 448 // For other requests, we iterate over the individual targets 449 // since that's where the actual data lies. 450 if (pkt->isPrint()) { 451 pkt->checkFunctional(this, addr, isSecure, size, NULL); 452 return false; 453 } else { 454 return (targets.checkFunctional(pkt) || 455 deferredTargets.checkFunctional(pkt)); 456 } 457} 458 459 460void 461MSHR::print(std::ostream &os, int verbosity, const std::string &prefix) const 462{ 463 ccprintf(os, "%s[%x:%x](%s) %s %s %s state: %s %s %s %s %s\n", 464 prefix, addr, addr+size-1, 465 isSecure ? "s" : "ns", 466 isForward ? "Forward" : "", 467 isForwardNoResponse() ? "ForwNoResp" : "", 468 needsExclusive() ? "Excl" : "", 469 _isUncacheable ? "Unc" : "", 470 inService ? "InSvc" : "", 471 downstreamPending ? "DwnPend" : "", 472 hasPostInvalidate() ? "PostInv" : "", 473 hasPostDowngrade() ? "PostDowngr" : ""); 474 475 ccprintf(os, "%s Targets:\n", prefix); 476 targets.print(os, verbosity, prefix + " "); 477 if (!deferredTargets.empty()) { 478 ccprintf(os, "%s Deferred Targets:\n", prefix); 479 deferredTargets.print(os, verbosity, prefix + " "); 480 } 481} 482 483std::string 484MSHR::print() const 485{ 486 ostringstream str; 487 print(str); 488 return str.str(); 489} 490