src/cpu/o3/lsq_impl.hh

   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
  37 template<class Impl>
  38 void
  39 LSQ<Impl>::DcachePort::setPeer(Port *port)
  40 {
  41     Port::setPeer(port);
  42
  43 #if FULL_SYSTEM
  44     // Update the ThreadContext's memory ports (Functional/Virtual
  45     // Ports)
  46     lsq->updateMemPorts();
  47 #endif
  48 }
  49
  50 template <class Impl>
  51 Tick
  52 LSQ<Impl>::DcachePort::recvAtomic(PacketPtr pkt)
  53 {
  54     panic("O3CPU model does not work with atomic mode!");
  55     return curTick;
  56 }
  57
  58 template <class Impl>
  59 void
  60 LSQ<Impl>::DcachePort::recvFunctional(PacketPtr pkt)
  61 {
  62     DPRINTF(LSQ, "LSQ doesn't update things on a recvFunctional.");
  63 }
  64
  65 template <class Impl>
  66 void
  67 LSQ<Impl>::DcachePort::recvStatusChange(Status status)
  68 {
  69     if (status == RangeChange) {
  70         if (!snoopRangeSent) {
  71             snoopRangeSent = true;
  72             sendStatusChange(Port::RangeChange);
  73         }
  74         return;
  75     }
  76     panic("O3CPU doesn't expect recvStatusChange callback!");
  77 }
  78
  79 template <class Impl>
  80 bool
  81 LSQ<Impl>::DcachePort::recvTiming(PacketPtr pkt)
  82 {
  83     if (pkt->isResponse()) {
  84         lsq->thread[pkt->req->getThreadNum()].completeDataAccess(pkt);
  85     }
  86     else {
  87         // must be a snoop
  88
  89         // @TODO someday may need to process invalidations in LSQ here
  90         // to provide stronger consistency model
  91     }
  92     return true;
  93 }
  94
  95 template <class Impl>
  96 void
  97 LSQ<Impl>::DcachePort::recvRetry()
  98 {
  99     if (lsq->retryTid == -1)
 100     {
 101         //Squashed, so drop it
 102         return;
 103     }
 104     lsq->thread[lsq->retryTid].recvRetry();
 105     // Speculatively clear the retry Tid.  This will get set again if
 106     // the LSQUnit was unable to complete its access.
 107     lsq->retryTid = -1;
 108 }
 109
 110 template <class Impl>
 111 LSQ<Impl>::LSQ(O3CPU *cpu_ptr, IEW *iew_ptr, Params *params)
 112     : cpu(cpu_ptr), iewStage(iew_ptr), dcachePort(this),
 113       LQEntries(params->LQEntries),
 114       SQEntries(params->SQEntries),
 115       numThreads(params->numberOfThreads),
 116       retryTid(-1)
 117 {
 118     dcachePort.snoopRangeSent = false;
 119
 120     //**********************************************/
 121     //************ Handle SMT Parameters ***********/
 122     //**********************************************/
 123     std::string policy = params->smtLSQPolicy;
 124
 125     //Convert string to lowercase
 126     std::transform(policy.begin(), policy.end(), policy.begin(),
 127                    (int(*)(int)) tolower);
 128
 129     //Figure out fetch policy
 130     if (policy == "dynamic") {
 131         lsqPolicy = Dynamic;
 132
 133         maxLQEntries = LQEntries;
 134         maxSQEntries = SQEntries;
 135
 136         DPRINTF(LSQ, "LSQ sharing policy set to Dynamic\n");
 137     } else if (policy == "partitioned") {
 138         lsqPolicy = Partitioned;
 139
 140         //@todo:make work if part_amt doesnt divide evenly.
 141         maxLQEntries = LQEntries / numThreads;
 142         maxSQEntries = SQEntries / numThreads;
 143
 144         DPRINTF(Fetch, "LSQ sharing policy set to Partitioned: "
 145                 "%i entries per LQ | %i entries per SQ",
 146                 maxLQEntries,maxSQEntries);
 147     } else if (policy == "threshold") {
 148         lsqPolicy = Threshold;
 149
 150         assert(params->smtLSQThreshold > LQEntries);
 151         assert(params->smtLSQThreshold > SQEntries);
 152
 153         //Divide up by threshold amount
 154         //@todo: Should threads check the max and the total
 155         //amount of the LSQ
 156         maxLQEntries  = params->smtLSQThreshold;
 157         maxSQEntries  = params->smtLSQThreshold;
 158
 159         DPRINTF(LSQ, "LSQ sharing policy set to Threshold: "
 160                 "%i entries per LQ | %i entries per SQ",
 161                 maxLQEntries,maxSQEntries);
 162     } else {
 163         assert(0 && "Invalid LSQ Sharing Policy.Options Are:{Dynamic,"
 164                     "Partitioned, Threshold}");
 165     }
 166
 167     //Initialize LSQs
 168     for (int tid=0; tid < numThreads; tid++) {
 169         thread[tid].init(cpu, iew_ptr, params, this,
 170                          maxLQEntries, maxSQEntries, tid);
 171         thread[tid].setDcachePort(&dcachePort);
 172     }
 173 }
 174
 175
 176 template<class Impl>
 177 std::string
 178 LSQ<Impl>::name() const
 179 {
 180     return iewStage->name() + ".lsq";
 181 }
 182
 183 template<class Impl>
 184 void
 185 LSQ<Impl>::regStats()
 186 {
 187     //Initialize LSQs
 188     for (int tid=0; tid < numThreads; tid++) {
 189         thread[tid].regStats();
 190     }
 191 }
 192
 193 template<class Impl>
 194 void
 195 LSQ<Impl>::setActiveThreads(std::list<unsigned> *at_ptr)
 196 {
 197     activeThreads = at_ptr;
 198     assert(activeThreads != 0);
 199 }
 200
 201 template <class Impl>
 202 void
 203 LSQ<Impl>::switchOut()
 204 {
 205     for (int tid = 0; tid < numThreads; tid++) {
 206         thread[tid].switchOut();
 207     }
 208 }
 209
 210 template <class Impl>
 211 void
 212 LSQ<Impl>::takeOverFrom()
 213 {
 214     for (int tid = 0; tid < numThreads; tid++) {
 215         thread[tid].takeOverFrom();
 216     }
 217 }
 218
 219 template <class Impl>
 220 int
 221 LSQ<Impl>::entryAmount(int num_threads)
 222 {
 223     if (lsqPolicy == Partitioned) {
 224         return LQEntries / num_threads;
 225     } else {
 226         return 0;
 227     }
 228 }
 229
 230 template <class Impl>
 231 void
 232 LSQ<Impl>::resetEntries()
 233 {
 234     if (lsqPolicy != Dynamic || numThreads > 1) {
 235         int active_threads = activeThreads->size();
 236
 237         int maxEntries;
 238
 239         if (lsqPolicy == Partitioned) {
 240             maxEntries = LQEntries / active_threads;
 241         } else if (lsqPolicy == Threshold && active_threads == 1) {
 242             maxEntries = LQEntries;
 243         } else {
 244             maxEntries = LQEntries;
 245         }
 246
 247         std::list<unsigned>::iterator threads  = activeThreads->begin();
 248         std::list<unsigned>::iterator end = activeThreads->end();
 249
 250         while (threads != end) {
 251             unsigned tid = *threads++;
 252
 253             resizeEntries(maxEntries, tid);
 254         }
 255     }
 256 }
 257
 258 template<class Impl>
 259 void
 260 LSQ<Impl>::removeEntries(unsigned tid)
 261 {
 262     thread[tid].clearLQ();
 263     thread[tid].clearSQ();
 264 }
 265
 266 template<class Impl>
 267 void
 268 LSQ<Impl>::resizeEntries(unsigned size,unsigned tid)
 269 {
 270     thread[tid].resizeLQ(size);
 271     thread[tid].resizeSQ(size);
 272 }
 273
 274 template<class Impl>
 275 void
 276 LSQ<Impl>::tick()
 277 {
 278     std::list<unsigned>::iterator threads = activeThreads->begin();
 279     std::list<unsigned>::iterator end = activeThreads->end();
 280
 281     while (threads != end) {
 282         unsigned tid = *threads++;
 283
 284         thread[tid].tick();
 285     }
 286 }
 287
 288 template<class Impl>
 289 void
 290 LSQ<Impl>::insertLoad(DynInstPtr &load_inst)
 291 {
 292     unsigned tid = load_inst->threadNumber;
 293
 294     thread[tid].insertLoad(load_inst);
 295 }
 296
 297 template<class Impl>
 298 void
 299 LSQ<Impl>::insertStore(DynInstPtr &store_inst)
 300 {
 301     unsigned tid = store_inst->threadNumber;
 302
 303     thread[tid].insertStore(store_inst);
 304 }
 305
 306 template<class Impl>
 307 Fault
 308 LSQ<Impl>::executeLoad(DynInstPtr &inst)
 309 {
 310     unsigned tid = inst->threadNumber;
 311
 312     return thread[tid].executeLoad(inst);
 313 }
 314
 315 template<class Impl>
 316 Fault
 317 LSQ<Impl>::executeStore(DynInstPtr &inst)
 318 {
 319     unsigned tid = inst->threadNumber;
 320
 321     return thread[tid].executeStore(inst);
 322 }
 323
 324 template<class Impl>
 325 void
 326 LSQ<Impl>::writebackStores()
 327 {
 328     std::list<unsigned>::iterator threads = activeThreads->begin();
 329     std::list<unsigned>::iterator end = activeThreads->end();
 330
 331     while (threads != end) {
 332         unsigned tid = *threads++;
 333
 334         if (numStoresToWB(tid) > 0) {
 335             DPRINTF(Writeback,"[tid:%i] Writing back stores. %i stores "
 336                 "available for Writeback.\n", tid, numStoresToWB(tid));
 337         }
 338
 339         thread[tid].writebackStores();
 340     }
 341 }
 342
 343 template<class Impl>
 344 bool
 345 LSQ<Impl>::violation()
 346 {
 347     /* Answers: Does Anybody Have a Violation?*/
 348     std::list<unsigned>::iterator threads = activeThreads->begin();
 349     std::list<unsigned>::iterator end = activeThreads->end();
 350
 351     while (threads != end) {
 352         unsigned tid = *threads++;
 353
 354         if (thread[tid].violation())
 355             return true;
 356     }
 357
 358     return false;
 359 }
 360
 361 template<class Impl>
 362 int
 363 LSQ<Impl>::getCount()
 364 {
 365     unsigned total = 0;
 366
 367     std::list<unsigned>::iterator threads = activeThreads->begin();
 368     std::list<unsigned>::iterator end = activeThreads->end();
 369
 370     while (threads != end) {
 371         unsigned tid = *threads++;
 372
 373         total += getCount(tid);
 374     }
 375
 376     return total;
 377 }
 378
 379 template<class Impl>
 380 int
 381 LSQ<Impl>::numLoads()
 382 {
 383     unsigned total = 0;
 384
 385     std::list<unsigned>::iterator threads = activeThreads->begin();
 386     std::list<unsigned>::iterator end = activeThreads->end();
 387
 388     while (threads != end) {
 389         unsigned tid = *threads++;
 390
 391         total += numLoads(tid);
 392     }
 393
 394     return total;
 395 }
 396
 397 template<class Impl>
 398 int
 399 LSQ<Impl>::numStores()
 400 {
 401     unsigned total = 0;
 402
 403     std::list<unsigned>::iterator threads = activeThreads->begin();
 404     std::list<unsigned>::iterator end = activeThreads->end();
 405
 406     while (threads != end) {
 407         unsigned tid = *threads++;
 408
 409         total += thread[tid].numStores();
 410     }
 411
 412     return total;
 413 }
 414
 415 template<class Impl>
 416 int
 417 LSQ<Impl>::numLoadsReady()
 418 {
 419     unsigned total = 0;
 420
 421     std::list<unsigned>::iterator threads = activeThreads->begin();
 422     std::list<unsigned>::iterator end = activeThreads->end();
 423
 424     while (threads != end) {
 425         unsigned tid = *threads++;
 426
 427         total += thread[tid].numLoadsReady();
 428     }
 429
 430     return total;
 431 }
 432
 433 template<class Impl>
 434 unsigned
 435 LSQ<Impl>::numFreeEntries()
 436 {
 437     unsigned total = 0;
 438
 439     std::list<unsigned>::iterator threads = activeThreads->begin();
 440     std::list<unsigned>::iterator end = activeThreads->end();
 441
 442     while (threads != end) {
 443         unsigned tid = *threads++;
 444
 445         total += thread[tid].numFreeEntries();
 446     }
 447
 448     return total;
 449 }
 450
 451 template<class Impl>
 452 unsigned
 453 LSQ<Impl>::numFreeEntries(unsigned tid)
 454 {
 455     //if (lsqPolicy == Dynamic)
 456     //return numFreeEntries();
 457     //else
 458         return thread[tid].numFreeEntries();
 459 }
 460
 461 template<class Impl>
 462 bool
 463 LSQ<Impl>::isFull()
 464 {
 465     std::list<unsigned>::iterator threads = activeThreads->begin();
 466     std::list<unsigned>::iterator end = activeThreads->end();
 467
 468     while (threads != end) {
 469         unsigned tid = *threads++;
 470
 471         if (!(thread[tid].lqFull() || thread[tid].sqFull()))
 472             return false;
 473     }
 474
 475     return true;
 476 }
 477
 478 template<class Impl>
 479 bool
 480 LSQ<Impl>::isFull(unsigned tid)
 481 {
 482     //@todo: Change to Calculate All Entries for
 483     //Dynamic Policy
 484     if (lsqPolicy == Dynamic)
 485         return isFull();
 486     else
 487         return thread[tid].lqFull() || thread[tid].sqFull();
 488 }
 489
 490 template<class Impl>
 491 bool
 492 LSQ<Impl>::lqFull()
 493 {
 494     std::list<unsigned>::iterator threads = activeThreads->begin();
 495     std::list<unsigned>::iterator end = activeThreads->end();
 496
 497     while (threads != end) {
 498         unsigned tid = *threads++;
 499
 500         if (!thread[tid].lqFull())
 501             return false;
 502     }
 503
 504     return true;
 505 }
 506
 507 template<class Impl>
 508 bool
 509 LSQ<Impl>::lqFull(unsigned tid)
 510 {
 511     //@todo: Change to Calculate All Entries for
 512     //Dynamic Policy
 513     if (lsqPolicy == Dynamic)
 514         return lqFull();
 515     else
 516         return thread[tid].lqFull();
 517 }
 518
 519 template<class Impl>
 520 bool
 521 LSQ<Impl>::sqFull()
 522 {
 523     std::list<unsigned>::iterator threads = activeThreads->begin();
 524     std::list<unsigned>::iterator end = activeThreads->end();
 525
 526     while (threads != end) {
 527         unsigned tid = *threads++;
 528
 529         if (!sqFull(tid))
 530             return false;
 531     }
 532
 533     return true;
 534 }
 535
 536 template<class Impl>
 537 bool
 538 LSQ<Impl>::sqFull(unsigned tid)
 539 {
 540      //@todo: Change to Calculate All Entries for
 541     //Dynamic Policy
 542     if (lsqPolicy == Dynamic)
 543         return sqFull();
 544     else
 545         return thread[tid].sqFull();
 546 }
 547
 548 template<class Impl>
 549 bool
 550 LSQ<Impl>::isStalled()
 551 {
 552     std::list<unsigned>::iterator threads = activeThreads->begin();
 553     std::list<unsigned>::iterator end = activeThreads->end();
 554
 555     while (threads != end) {
 556         unsigned tid = *threads++;
 557
 558         if (!thread[tid].isStalled())
 559             return false;
 560     }
 561
 562     return true;
 563 }
 564
 565 template<class Impl>
 566 bool
 567 LSQ<Impl>::isStalled(unsigned tid)
 568 {
 569     if (lsqPolicy == Dynamic)
 570         return isStalled();
 571     else
 572         return thread[tid].isStalled();
 573 }
 574
 575 template<class Impl>
 576 bool
 577 LSQ<Impl>::hasStoresToWB()
 578 {
 579     std::list<unsigned>::iterator threads = activeThreads->begin();
 580     std::list<unsigned>::iterator end = activeThreads->end();
 581
 582     if (threads == end)
 583         return false;
 584
 585     while (threads != end) {
 586         unsigned tid = *threads++;
 587
 588         if (!hasStoresToWB(tid))
 589             return false;
 590     }
 591
 592     return true;
 593 }
 594
 595 template<class Impl>
 596 bool
 597 LSQ<Impl>::willWB()
 598 {
 599     std::list<unsigned>::iterator threads = activeThreads->begin();
 600     std::list<unsigned>::iterator end = activeThreads->end();
 601
 602     while (threads != end) {
 603         unsigned tid = *threads++;
 604
 605         if (!willWB(tid))
 606             return false;
 607     }
 608
 609     return true;
 610 }
 611
 612 template<class Impl>
 613 void
 614 LSQ<Impl>::dumpInsts()
 615 {
 616     std::list<unsigned>::iterator threads = activeThreads->begin();
 617     std::list<unsigned>::iterator end = activeThreads->end();
 618
 619     while (threads != end) {
 620         unsigned tid = *threads++;
 621
 622         thread[tid].dumpInsts();
 623     }
 624 }