lsq_impl.hh revision 3647:8121d4503cbc
1/* 2 * Copyright (c) 2005-2006 The Regents of The University of Michigan 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are 7 * met: redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer; 9 * redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution; 12 * neither the name of the copyright holders nor the names of its 13 * contributors may be used to endorse or promote products derived from 14 * this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 * Authors: Korey Sewell 29 */ 30 31#include <algorithm> 32#include <list> 33#include <string> 34 35#include "cpu/o3/lsq.hh" 36 37template <class Impl> 38Tick 39LSQ<Impl>::DcachePort::recvAtomic(PacketPtr pkt) 40{ 41 panic("O3CPU model does not work with atomic mode!"); 42 return curTick; 43} 44 45template <class Impl> 46void 47LSQ<Impl>::DcachePort::recvFunctional(PacketPtr pkt) 48{ 49 DPRINTF(LSQ, "LSQ doesn't update things on a recvFunctional."); 50} 51 52template <class Impl> 53void 54LSQ<Impl>::DcachePort::recvStatusChange(Status status) 55{ 56 if (status == RangeChange) { 57 if (!snoopRangeSent) { 58 snoopRangeSent = true; 59 sendStatusChange(Port::RangeChange); 60 } 61 return; 62 } 63 panic("O3CPU doesn't expect recvStatusChange callback!"); 64} 65 66template <class Impl> 67bool 68LSQ<Impl>::DcachePort::recvTiming(PacketPtr pkt) 69{ 70 if (pkt->isResponse()) { 71 lsq->thread[pkt->req->getThreadNum()].completeDataAccess(pkt); 72 } 73 else { 74 //else it is a coherence request, maybe you need to do something 75 warn("Recieved a coherence request (Invalidate?), 03CPU doesn't" 76 "update LSQ for these\n"); 77 } 78 return true; 79} 80 81template <class Impl> 82void 83LSQ<Impl>::DcachePort::recvRetry() 84{ 85 if (lsq->retryTid == -1) 86 { 87 //Squashed, so drop it 88 return; 89 } 90 lsq->thread[lsq->retryTid].recvRetry(); 91 // Speculatively clear the retry Tid. This will get set again if 92 // the LSQUnit was unable to complete its access. 93 lsq->retryTid = -1; 94} 95 96template <class Impl> 97LSQ<Impl>::LSQ(Params *params) 98 : dcachePort(this), LQEntries(params->LQEntries), 99 SQEntries(params->SQEntries), numThreads(params->numberOfThreads), 100 retryTid(-1) 101{ 102 DPRINTF(LSQ, "Creating LSQ object.\n"); 103 104 dcachePort.snoopRangeSent = false; 105 106 //**********************************************/ 107 //************ Handle SMT Parameters ***********/ 108 //**********************************************/ 109 std::string policy = params->smtLSQPolicy; 110 111 //Convert string to lowercase 112 std::transform(policy.begin(), policy.end(), policy.begin(), 113 (int(*)(int)) tolower); 114 115 //Figure out fetch policy 116 if (policy == "dynamic") { 117 lsqPolicy = Dynamic; 118 119 maxLQEntries = LQEntries; 120 maxSQEntries = SQEntries; 121 122 DPRINTF(LSQ, "LSQ sharing policy set to Dynamic\n"); 123 124 } else if (policy == "partitioned") { 125 lsqPolicy = Partitioned; 126 127 //@todo:make work if part_amt doesnt divide evenly. 128 maxLQEntries = LQEntries / numThreads; 129 maxSQEntries = SQEntries / numThreads; 130 131 DPRINTF(Fetch, "LSQ sharing policy set to Partitioned: " 132 "%i entries per LQ | %i entries per SQ", 133 maxLQEntries,maxSQEntries); 134 135 } else if (policy == "threshold") { 136 lsqPolicy = Threshold; 137 138 assert(params->smtLSQThreshold > LQEntries); 139 assert(params->smtLSQThreshold > SQEntries); 140 141 //Divide up by threshold amount 142 //@todo: Should threads check the max and the total 143 //amount of the LSQ 144 maxLQEntries = params->smtLSQThreshold; 145 maxSQEntries = params->smtLSQThreshold; 146 147 DPRINTF(LSQ, "LSQ sharing policy set to Threshold: " 148 "%i entries per LQ | %i entries per SQ", 149 maxLQEntries,maxSQEntries); 150 151 } else { 152 assert(0 && "Invalid LSQ Sharing Policy.Options Are:{Dynamic," 153 "Partitioned, Threshold}"); 154 } 155 156 //Initialize LSQs 157 for (int tid=0; tid < numThreads; tid++) { 158 thread[tid].init(params, this, maxLQEntries, maxSQEntries, tid); 159 thread[tid].setDcachePort(&dcachePort); 160 } 161} 162 163 164template<class Impl> 165std::string 166LSQ<Impl>::name() const 167{ 168 return iewStage->name() + ".lsq"; 169} 170 171template<class Impl> 172void 173LSQ<Impl>::regStats() 174{ 175 //Initialize LSQs 176 for (int tid=0; tid < numThreads; tid++) { 177 thread[tid].regStats(); 178 } 179} 180 181template<class Impl> 182void 183LSQ<Impl>::setActiveThreads(std::list<unsigned> *at_ptr) 184{ 185 activeThreads = at_ptr; 186 assert(activeThreads != 0); 187} 188 189template<class Impl> 190void 191LSQ<Impl>::setCPU(O3CPU *cpu_ptr) 192{ 193 cpu = cpu_ptr; 194 195 dcachePort.setName(name()); 196 197 for (int tid=0; tid < numThreads; tid++) { 198 thread[tid].setCPU(cpu_ptr); 199 } 200} 201 202template<class Impl> 203void 204LSQ<Impl>::setIEW(IEW *iew_ptr) 205{ 206 iewStage = iew_ptr; 207 208 for (int tid=0; tid < numThreads; tid++) { 209 thread[tid].setIEW(iew_ptr); 210 } 211} 212 213template <class Impl> 214void 215LSQ<Impl>::switchOut() 216{ 217 for (int tid = 0; tid < numThreads; tid++) { 218 thread[tid].switchOut(); 219 } 220} 221 222template <class Impl> 223void 224LSQ<Impl>::takeOverFrom() 225{ 226 for (int tid = 0; tid < numThreads; tid++) { 227 thread[tid].takeOverFrom(); 228 } 229} 230 231template <class Impl> 232int 233LSQ<Impl>::entryAmount(int num_threads) 234{ 235 if (lsqPolicy == Partitioned) { 236 return LQEntries / num_threads; 237 } else { 238 return 0; 239 } 240} 241 242template <class Impl> 243void 244LSQ<Impl>::resetEntries() 245{ 246 if (lsqPolicy != Dynamic || numThreads > 1) { 247 int active_threads = (*activeThreads).size(); 248 249 std::list<unsigned>::iterator threads = (*activeThreads).begin(); 250 std::list<unsigned>::iterator list_end = (*activeThreads).end(); 251 252 int maxEntries; 253 254 if (lsqPolicy == Partitioned) { 255 maxEntries = LQEntries / active_threads; 256 } else if (lsqPolicy == Threshold && active_threads == 1) { 257 maxEntries = LQEntries; 258 } else { 259 maxEntries = LQEntries; 260 } 261 262 while (threads != list_end) { 263 resizeEntries(maxEntries,*threads++); 264 } 265 } 266} 267 268template<class Impl> 269void 270LSQ<Impl>::removeEntries(unsigned tid) 271{ 272 thread[tid].clearLQ(); 273 thread[tid].clearSQ(); 274} 275 276template<class Impl> 277void 278LSQ<Impl>::resizeEntries(unsigned size,unsigned tid) 279{ 280 thread[tid].resizeLQ(size); 281 thread[tid].resizeSQ(size); 282} 283 284template<class Impl> 285void 286LSQ<Impl>::tick() 287{ 288 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 289 290 while (active_threads != (*activeThreads).end()) { 291 unsigned tid = *active_threads++; 292 293 thread[tid].tick(); 294 } 295} 296 297template<class Impl> 298void 299LSQ<Impl>::insertLoad(DynInstPtr &load_inst) 300{ 301 unsigned tid = load_inst->threadNumber; 302 303 thread[tid].insertLoad(load_inst); 304} 305 306template<class Impl> 307void 308LSQ<Impl>::insertStore(DynInstPtr &store_inst) 309{ 310 unsigned tid = store_inst->threadNumber; 311 312 thread[tid].insertStore(store_inst); 313} 314 315template<class Impl> 316Fault 317LSQ<Impl>::executeLoad(DynInstPtr &inst) 318{ 319 unsigned tid = inst->threadNumber; 320 321 return thread[tid].executeLoad(inst); 322} 323 324template<class Impl> 325Fault 326LSQ<Impl>::executeStore(DynInstPtr &inst) 327{ 328 unsigned tid = inst->threadNumber; 329 330 return thread[tid].executeStore(inst); 331} 332 333template<class Impl> 334void 335LSQ<Impl>::writebackStores() 336{ 337 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 338 339 while (active_threads != (*activeThreads).end()) { 340 unsigned tid = *active_threads++; 341 342 if (numStoresToWB(tid) > 0) { 343 DPRINTF(Writeback,"[tid:%i] Writing back stores. %i stores " 344 "available for Writeback.\n", tid, numStoresToWB(tid)); 345 } 346 347 thread[tid].writebackStores(); 348 } 349} 350 351template<class Impl> 352bool 353LSQ<Impl>::violation() 354{ 355 /* Answers: Does Anybody Have a Violation?*/ 356 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 357 358 while (active_threads != (*activeThreads).end()) { 359 unsigned tid = *active_threads++; 360 if (thread[tid].violation()) 361 return true; 362 } 363 364 return false; 365} 366 367template<class Impl> 368int 369LSQ<Impl>::getCount() 370{ 371 unsigned total = 0; 372 373 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 374 375 while (active_threads != (*activeThreads).end()) { 376 unsigned tid = *active_threads++; 377 total += getCount(tid); 378 } 379 380 return total; 381} 382 383template<class Impl> 384int 385LSQ<Impl>::numLoads() 386{ 387 unsigned total = 0; 388 389 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 390 391 while (active_threads != (*activeThreads).end()) { 392 unsigned tid = *active_threads++; 393 total += numLoads(tid); 394 } 395 396 return total; 397} 398 399template<class Impl> 400int 401LSQ<Impl>::numStores() 402{ 403 unsigned total = 0; 404 405 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 406 407 while (active_threads != (*activeThreads).end()) { 408 unsigned tid = *active_threads++; 409 total += thread[tid].numStores(); 410 } 411 412 return total; 413} 414 415template<class Impl> 416int 417LSQ<Impl>::numLoadsReady() 418{ 419 unsigned total = 0; 420 421 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 422 423 while (active_threads != (*activeThreads).end()) { 424 unsigned tid = *active_threads++; 425 total += thread[tid].numLoadsReady(); 426 } 427 428 return total; 429} 430 431template<class Impl> 432unsigned 433LSQ<Impl>::numFreeEntries() 434{ 435 unsigned total = 0; 436 437 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 438 439 while (active_threads != (*activeThreads).end()) { 440 unsigned tid = *active_threads++; 441 total += thread[tid].numFreeEntries(); 442 } 443 444 return total; 445} 446 447template<class Impl> 448unsigned 449LSQ<Impl>::numFreeEntries(unsigned tid) 450{ 451 //if( lsqPolicy == Dynamic ) 452 //return numFreeEntries(); 453 //else 454 return thread[tid].numFreeEntries(); 455} 456 457template<class Impl> 458bool 459LSQ<Impl>::isFull() 460{ 461 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 462 463 while (active_threads != (*activeThreads).end()) { 464 unsigned tid = *active_threads++; 465 if (! (thread[tid].lqFull() || thread[tid].sqFull()) ) 466 return false; 467 } 468 469 return true; 470} 471 472template<class Impl> 473bool 474LSQ<Impl>::isFull(unsigned tid) 475{ 476 //@todo: Change to Calculate All Entries for 477 //Dynamic Policy 478 if( lsqPolicy == Dynamic ) 479 return isFull(); 480 else 481 return thread[tid].lqFull() || thread[tid].sqFull(); 482} 483 484template<class Impl> 485bool 486LSQ<Impl>::lqFull() 487{ 488 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 489 490 while (active_threads != (*activeThreads).end()) { 491 unsigned tid = *active_threads++; 492 if (!thread[tid].lqFull()) 493 return false; 494 } 495 496 return true; 497} 498 499template<class Impl> 500bool 501LSQ<Impl>::lqFull(unsigned tid) 502{ 503 //@todo: Change to Calculate All Entries for 504 //Dynamic Policy 505 if( lsqPolicy == Dynamic ) 506 return lqFull(); 507 else 508 return thread[tid].lqFull(); 509} 510 511template<class Impl> 512bool 513LSQ<Impl>::sqFull() 514{ 515 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 516 517 while (active_threads != (*activeThreads).end()) { 518 unsigned tid = *active_threads++; 519 if (!sqFull(tid)) 520 return false; 521 } 522 523 return true; 524} 525 526template<class Impl> 527bool 528LSQ<Impl>::sqFull(unsigned tid) 529{ 530 //@todo: Change to Calculate All Entries for 531 //Dynamic Policy 532 if( lsqPolicy == Dynamic ) 533 return sqFull(); 534 else 535 return thread[tid].sqFull(); 536} 537 538template<class Impl> 539bool 540LSQ<Impl>::isStalled() 541{ 542 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 543 544 while (active_threads != (*activeThreads).end()) { 545 unsigned tid = *active_threads++; 546 if (!thread[tid].isStalled()) 547 return false; 548 } 549 550 return true; 551} 552 553template<class Impl> 554bool 555LSQ<Impl>::isStalled(unsigned tid) 556{ 557 if( lsqPolicy == Dynamic ) 558 return isStalled(); 559 else 560 return thread[tid].isStalled(); 561} 562 563template<class Impl> 564bool 565LSQ<Impl>::hasStoresToWB() 566{ 567 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 568 569 if ((*activeThreads).empty()) 570 return false; 571 572 while (active_threads != (*activeThreads).end()) { 573 unsigned tid = *active_threads++; 574 if (!hasStoresToWB(tid)) 575 return false; 576 } 577 578 return true; 579} 580 581template<class Impl> 582bool 583LSQ<Impl>::willWB() 584{ 585 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 586 587 while (active_threads != (*activeThreads).end()) { 588 unsigned tid = *active_threads++; 589 if (!willWB(tid)) 590 return false; 591 } 592 593 return true; 594} 595 596template<class Impl> 597void 598LSQ<Impl>::dumpInsts() 599{ 600 std::list<unsigned>::iterator active_threads = (*activeThreads).begin(); 601 602 while (active_threads != (*activeThreads).end()) { 603 unsigned tid = *active_threads++; 604 thread[tid].dumpInsts(); 605 } 606} 607