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 Tick
  39 LSQ<Impl>::DcachePort::recvAtomic(PacketPtr pkt)
  40 {
  41     panic("O3CPU model does not work with atomic mode!");
  42     return curTick;
  43 }
  44
  45 template <class Impl>
  46 void
  47 LSQ<Impl>::DcachePort::recvFunctional(PacketPtr pkt)
  48 {
  49     DPRINTF(LSQ, "LSQ doesn't update things on a recvFunctional.");
  50 }
  51
  52 template <class Impl>
  53 void
  54 LSQ<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
  66 template <class Impl>
  67 bool
  68 LSQ<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
  81 template <class Impl>
  82 void
  83 LSQ<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
  96 template <class Impl>
  97 LSQ<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
 164 template<class Impl>
 165 std::string
 166 LSQ<Impl>::name() const
 167 {
 168     return iewStage->name() + ".lsq";
 169 }
 170
 171 template<class Impl>
 172 void
 173 LSQ<Impl>::regStats()
 174 {
 175     //Initialize LSQs
 176     for (int tid=0; tid < numThreads; tid++) {
 177         thread[tid].regStats();
 178     }
 179 }
 180
 181 template<class Impl>
 182 void
 183 LSQ<Impl>::setActiveThreads(std::list<unsigned> *at_ptr)
 184 {
 185     activeThreads = at_ptr;
 186     assert(activeThreads != 0);
 187 }
 188
 189 template<class Impl>
 190 void
 191 LSQ<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
 202 template<class Impl>
 203 void
 204 LSQ<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
 213 template <class Impl>
 214 void
 215 LSQ<Impl>::switchOut()
 216 {
 217     for (int tid = 0; tid < numThreads; tid++) {
 218         thread[tid].switchOut();
 219     }
 220 }
 221
 222 template <class Impl>
 223 void
 224 LSQ<Impl>::takeOverFrom()
 225 {
 226     for (int tid = 0; tid < numThreads; tid++) {
 227         thread[tid].takeOverFrom();
 228     }
 229 }
 230
 231 template <class Impl>
 232 int
 233 LSQ<Impl>::entryAmount(int num_threads)
 234 {
 235     if (lsqPolicy == Partitioned) {
 236         return LQEntries / num_threads;
 237     } else {
 238         return 0;
 239     }
 240 }
 241
 242 template <class Impl>
 243 void
 244 LSQ<Impl>::resetEntries()
 245 {
 246     if (lsqPolicy != Dynamic || numThreads > 1) {
 247         int active_threads = activeThreads->size();
 248
 249         int maxEntries;
 250
 251         if (lsqPolicy == Partitioned) {
 252             maxEntries = LQEntries / active_threads;
 253         } else if (lsqPolicy == Threshold && active_threads == 1) {
 254             maxEntries = LQEntries;
 255         } else {
 256             maxEntries = LQEntries;
 257         }
 258
 259         std::list<unsigned>::iterator threads  = activeThreads->begin();
 260         std::list<unsigned>::iterator end = activeThreads->end();
 261
 262         while (threads != end) {
 263             unsigned tid = *threads++;
 264
 265             resizeEntries(maxEntries, tid);
 266         }
 267     }
 268 }
 269
 270 template<class Impl>
 271 void
 272 LSQ<Impl>::removeEntries(unsigned tid)
 273 {
 274     thread[tid].clearLQ();
 275     thread[tid].clearSQ();
 276 }
 277
 278 template<class Impl>
 279 void
 280 LSQ<Impl>::resizeEntries(unsigned size,unsigned tid)
 281 {
 282     thread[tid].resizeLQ(size);
 283     thread[tid].resizeSQ(size);
 284 }
 285
 286 template<class Impl>
 287 void
 288 LSQ<Impl>::tick()
 289 {
 290     std::list<unsigned>::iterator threads = activeThreads->begin();
 291     std::list<unsigned>::iterator end = activeThreads->end();
 292
 293     while (threads != end) {
 294         unsigned tid = *threads++;
 295
 296         thread[tid].tick();
 297     }
 298 }
 299
 300 template<class Impl>
 301 void
 302 LSQ<Impl>::insertLoad(DynInstPtr &load_inst)
 303 {
 304     unsigned tid = load_inst->threadNumber;
 305
 306     thread[tid].insertLoad(load_inst);
 307 }
 308
 309 template<class Impl>
 310 void
 311 LSQ<Impl>::insertStore(DynInstPtr &store_inst)
 312 {
 313     unsigned tid = store_inst->threadNumber;
 314
 315     thread[tid].insertStore(store_inst);
 316 }
 317
 318 template<class Impl>
 319 Fault
 320 LSQ<Impl>::executeLoad(DynInstPtr &inst)
 321 {
 322     unsigned tid = inst->threadNumber;
 323
 324     return thread[tid].executeLoad(inst);
 325 }
 326
 327 template<class Impl>
 328 Fault
 329 LSQ<Impl>::executeStore(DynInstPtr &inst)
 330 {
 331     unsigned tid = inst->threadNumber;
 332
 333     return thread[tid].executeStore(inst);
 334 }
 335
 336 template<class Impl>
 337 void
 338 LSQ<Impl>::writebackStores()
 339 {
 340     std::list<unsigned>::iterator threads = activeThreads->begin();
 341     std::list<unsigned>::iterator end = activeThreads->end();
 342
 343     while (threads != end) {
 344         unsigned tid = *threads++;
 345
 346         if (numStoresToWB(tid) > 0) {
 347             DPRINTF(Writeback,"[tid:%i] Writing back stores. %i stores "
 348                 "available for Writeback.\n", tid, numStoresToWB(tid));
 349         }
 350
 351         thread[tid].writebackStores();
 352     }
 353 }
 354
 355 template<class Impl>
 356 bool
 357 LSQ<Impl>::violation()
 358 {
 359     /* Answers: Does Anybody Have a Violation?*/
 360     std::list<unsigned>::iterator threads = activeThreads->begin();
 361     std::list<unsigned>::iterator end = activeThreads->end();
 362
 363     while (threads != end) {
 364         unsigned tid = *threads++;
 365
 366         if (thread[tid].violation())
 367             return true;
 368     }
 369
 370     return false;
 371 }
 372
 373 template<class Impl>
 374 int
 375 LSQ<Impl>::getCount()
 376 {
 377     unsigned total = 0;
 378
 379     std::list<unsigned>::iterator threads = activeThreads->begin();
 380     std::list<unsigned>::iterator end = activeThreads->end();
 381
 382     while (threads != end) {
 383         unsigned tid = *threads++;
 384
 385         total += getCount(tid);
 386     }
 387
 388     return total;
 389 }
 390
 391 template<class Impl>
 392 int
 393 LSQ<Impl>::numLoads()
 394 {
 395     unsigned total = 0;
 396
 397     std::list<unsigned>::iterator threads = activeThreads->begin();
 398     std::list<unsigned>::iterator end = activeThreads->end();
 399
 400     while (threads != end) {
 401         unsigned tid = *threads++;
 402
 403         total += numLoads(tid);
 404     }
 405
 406     return total;
 407 }
 408
 409 template<class Impl>
 410 int
 411 LSQ<Impl>::numStores()
 412 {
 413     unsigned total = 0;
 414
 415     std::list<unsigned>::iterator threads = activeThreads->begin();
 416     std::list<unsigned>::iterator end = activeThreads->end();
 417
 418     while (threads != end) {
 419         unsigned tid = *threads++;
 420
 421         total += thread[tid].numStores();
 422     }
 423
 424     return total;
 425 }
 426
 427 template<class Impl>
 428 int
 429 LSQ<Impl>::numLoadsReady()
 430 {
 431     unsigned total = 0;
 432
 433     std::list<unsigned>::iterator threads = activeThreads->begin();
 434     std::list<unsigned>::iterator end = activeThreads->end();
 435
 436     while (threads != end) {
 437         unsigned tid = *threads++;
 438
 439         total += thread[tid].numLoadsReady();
 440     }
 441
 442     return total;
 443 }
 444
 445 template<class Impl>
 446 unsigned
 447 LSQ<Impl>::numFreeEntries()
 448 {
 449     unsigned total = 0;
 450
 451     std::list<unsigned>::iterator threads = activeThreads->begin();
 452     std::list<unsigned>::iterator end = activeThreads->end();
 453
 454     while (threads != end) {
 455         unsigned tid = *threads++;
 456
 457         total += thread[tid].numFreeEntries();
 458     }
 459
 460     return total;
 461 }
 462
 463 template<class Impl>
 464 unsigned
 465 LSQ<Impl>::numFreeEntries(unsigned tid)
 466 {
 467     //if( lsqPolicy == Dynamic )
 468     //return numFreeEntries();
 469     //else
 470         return thread[tid].numFreeEntries();
 471 }
 472
 473 template<class Impl>
 474 bool
 475 LSQ<Impl>::isFull()
 476 {
 477     std::list<unsigned>::iterator threads = activeThreads->begin();
 478     std::list<unsigned>::iterator end = activeThreads->end();
 479
 480     while (threads != end) {
 481         unsigned tid = *threads++;
 482
 483         if (!(thread[tid].lqFull() || thread[tid].sqFull()))
 484             return false;
 485     }
 486
 487     return true;
 488 }
 489
 490 template<class Impl>
 491 bool
 492 LSQ<Impl>::isFull(unsigned tid)
 493 {
 494     //@todo: Change to Calculate All Entries for
 495     //Dynamic Policy
 496     if (lsqPolicy == Dynamic)
 497         return isFull();
 498     else
 499         return thread[tid].lqFull() || thread[tid].sqFull();
 500 }
 501
 502 template<class Impl>
 503 bool
 504 LSQ<Impl>::lqFull()
 505 {
 506     std::list<unsigned>::iterator threads = activeThreads->begin();
 507     std::list<unsigned>::iterator end = activeThreads->end();
 508
 509     while (threads != end) {
 510         unsigned tid = *threads++;
 511
 512         if (!thread[tid].lqFull())
 513             return false;
 514     }
 515
 516     return true;
 517 }
 518
 519 template<class Impl>
 520 bool
 521 LSQ<Impl>::lqFull(unsigned tid)
 522 {
 523     //@todo: Change to Calculate All Entries for
 524     //Dynamic Policy
 525     if( lsqPolicy == Dynamic )
 526         return lqFull();
 527     else
 528         return thread[tid].lqFull();
 529 }
 530
 531 template<class Impl>
 532 bool
 533 LSQ<Impl>::sqFull()
 534 {
 535     std::list<unsigned>::iterator threads = activeThreads->begin();
 536     std::list<unsigned>::iterator end = activeThreads->end();
 537
 538     while (threads != end) {
 539         unsigned tid = *threads++;
 540
 541         if (!sqFull(tid))
 542             return false;
 543     }
 544
 545     return true;
 546 }
 547
 548 template<class Impl>
 549 bool
 550 LSQ<Impl>::sqFull(unsigned tid)
 551 {
 552      //@todo: Change to Calculate All Entries for
 553     //Dynamic Policy
 554     if( lsqPolicy == Dynamic )
 555         return sqFull();
 556     else
 557         return thread[tid].sqFull();
 558 }
 559
 560 template<class Impl>
 561 bool
 562 LSQ<Impl>::isStalled()
 563 {
 564     std::list<unsigned>::iterator threads = activeThreads->begin();
 565     std::list<unsigned>::iterator end = activeThreads->end();
 566
 567     while (threads != end) {
 568         unsigned tid = *threads++;
 569
 570         if (!thread[tid].isStalled())
 571             return false;
 572     }
 573
 574     return true;
 575 }
 576
 577 template<class Impl>
 578 bool
 579 LSQ<Impl>::isStalled(unsigned tid)
 580 {
 581     if( lsqPolicy == Dynamic )
 582         return isStalled();
 583     else
 584         return thread[tid].isStalled();
 585 }
 586
 587 template<class Impl>
 588 bool
 589 LSQ<Impl>::hasStoresToWB()
 590 {
 591     std::list<unsigned>::iterator threads = activeThreads->begin();
 592     std::list<unsigned>::iterator end = activeThreads->end();
 593
 594     if (threads == end)
 595         return false;
 596
 597     while (threads != end) {
 598         unsigned tid = *threads++;
 599
 600         if (!hasStoresToWB(tid))
 601             return false;
 602     }
 603
 604     return true;
 605 }
 606
 607 template<class Impl>
 608 bool
 609 LSQ<Impl>::willWB()
 610 {
 611     std::list<unsigned>::iterator threads = activeThreads->begin();
 612     std::list<unsigned>::iterator end = activeThreads->end();
 613
 614     while (threads != end) {
 615         unsigned tid = *threads++;
 616
 617         if (!willWB(tid))
 618             return false;
 619     }
 620
 621     return true;
 622 }
 623
 624 template<class Impl>
 625 void
 626 LSQ<Impl>::dumpInsts()
 627 {
 628     std::list<unsigned>::iterator threads = activeThreads->begin();
 629     std::list<unsigned>::iterator end = activeThreads->end();
 630
 631     while (threads != end) {
 632         unsigned tid = *threads++;
 633
 634         thread[tid].dumpInsts();
 635     }
 636 }