src/cpu/o3/lsq_impl.hh

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