1/* 2 * Copyright (c) 2012 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) 2004-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: Kevin Lim 41 * Korey Sewell 42 */ 43 44#ifndef __CPU_O3_ROB_IMPL_HH__ 45#define __CPU_O3_ROB_IMPL_HH__ 46 47#include <list> 48 49#include "cpu/o3/rob.hh" 50#include "debug/Fetch.hh" 51#include "debug/ROB.hh"
| 1/* 2 * Copyright (c) 2012 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) 2004-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: Kevin Lim 41 * Korey Sewell 42 */ 43 44#ifndef __CPU_O3_ROB_IMPL_HH__ 45#define __CPU_O3_ROB_IMPL_HH__ 46 47#include <list> 48 49#include "cpu/o3/rob.hh" 50#include "debug/Fetch.hh" 51#include "debug/ROB.hh"
|
| 52#include "params/DerivO3CPU.hh"
|
52 53using namespace std; 54 55template <class Impl>
| 53 54using namespace std; 55 56template <class Impl>
|
56ROB<Impl>::ROB(O3CPU *_cpu, unsigned _numEntries, unsigned _squashWidth, 57 std::string _smtROBPolicy, unsigned _smtROBThreshold, 58 ThreadID _numThreads)
| 57ROB<Impl>::ROB(O3CPU *_cpu, DerivO3CPUParams *params)
|
59 : cpu(_cpu),
| 58 : cpu(_cpu),
|
60 numEntries(_numEntries), 61 squashWidth(_squashWidth),
| 59 numEntries(params->numROBEntries), 60 squashWidth(params->squashWidth),
|
62 numInstsInROB(0),
| 61 numInstsInROB(0),
|
63 numThreads(_numThreads)
| 62 numThreads(params->numThreads)
|
64{
| 63{
|
65 std::string policy = _smtROBPolicy;
| 64 std::string policy = params->smtROBPolicy;
|
66 67 //Convert string to lowercase 68 std::transform(policy.begin(), policy.end(), policy.begin(), 69 (int(*)(int)) tolower); 70 71 //Figure out rob policy 72 if (policy == "dynamic") { 73 robPolicy = Dynamic; 74 75 //Set Max Entries to Total ROB Capacity 76 for (ThreadID tid = 0; tid < numThreads; tid++) { 77 maxEntries[tid] = numEntries; 78 } 79 80 } else if (policy == "partitioned") { 81 robPolicy = Partitioned; 82 DPRINTF(Fetch, "ROB sharing policy set to Partitioned\n"); 83 84 //@todo:make work if part_amt doesnt divide evenly. 85 int part_amt = numEntries / numThreads; 86 87 //Divide ROB up evenly 88 for (ThreadID tid = 0; tid < numThreads; tid++) { 89 maxEntries[tid] = part_amt; 90 } 91 92 } else if (policy == "threshold") { 93 robPolicy = Threshold; 94 DPRINTF(Fetch, "ROB sharing policy set to Threshold\n"); 95
| 65 66 //Convert string to lowercase 67 std::transform(policy.begin(), policy.end(), policy.begin(), 68 (int(*)(int)) tolower); 69 70 //Figure out rob policy 71 if (policy == "dynamic") { 72 robPolicy = Dynamic; 73 74 //Set Max Entries to Total ROB Capacity 75 for (ThreadID tid = 0; tid < numThreads; tid++) { 76 maxEntries[tid] = numEntries; 77 } 78 79 } else if (policy == "partitioned") { 80 robPolicy = Partitioned; 81 DPRINTF(Fetch, "ROB sharing policy set to Partitioned\n"); 82 83 //@todo:make work if part_amt doesnt divide evenly. 84 int part_amt = numEntries / numThreads; 85 86 //Divide ROB up evenly 87 for (ThreadID tid = 0; tid < numThreads; tid++) { 88 maxEntries[tid] = part_amt; 89 } 90 91 } else if (policy == "threshold") { 92 robPolicy = Threshold; 93 DPRINTF(Fetch, "ROB sharing policy set to Threshold\n"); 94
|
96 int threshold = _smtROBThreshold;;
| 95 int threshold = params->smtROBThreshold;;
|
97 98 //Divide up by threshold amount 99 for (ThreadID tid = 0; tid < numThreads; tid++) { 100 maxEntries[tid] = threshold; 101 } 102 } else { 103 assert(0 && "Invalid ROB Sharing Policy.Options Are:{Dynamic," 104 "Partitioned, Threshold}"); 105 } 106 107 resetState(); 108} 109 110template <class Impl> 111void 112ROB<Impl>::resetState() 113{ 114 for (ThreadID tid = 0; tid < numThreads; tid++) { 115 doneSquashing[tid] = true; 116 threadEntries[tid] = 0; 117 squashIt[tid] = instList[tid].end(); 118 squashedSeqNum[tid] = 0; 119 } 120 numInstsInROB = 0; 121 122 // Initialize the "universal" ROB head & tail point to invalid 123 // pointers 124 head = instList[0].end(); 125 tail = instList[0].end(); 126} 127 128template <class Impl> 129std::string 130ROB<Impl>::name() const 131{ 132 return cpu->name() + ".rob"; 133} 134 135template <class Impl> 136void 137ROB<Impl>::setActiveThreads(list<ThreadID> *at_ptr) 138{ 139 DPRINTF(ROB, "Setting active threads list pointer.\n"); 140 activeThreads = at_ptr; 141} 142 143template <class Impl> 144void 145ROB<Impl>::drainSanityCheck() const 146{ 147 for (ThreadID tid = 0; tid < numThreads; tid++) 148 assert(instList[tid].empty()); 149 assert(isEmpty()); 150} 151 152template <class Impl> 153void 154ROB<Impl>::takeOverFrom() 155{ 156 resetState(); 157} 158 159template <class Impl> 160void 161ROB<Impl>::resetEntries() 162{ 163 if (robPolicy != Dynamic || numThreads > 1) { 164 int active_threads = activeThreads->size(); 165 166 list<ThreadID>::iterator threads = activeThreads->begin(); 167 list<ThreadID>::iterator end = activeThreads->end(); 168 169 while (threads != end) { 170 ThreadID tid = *threads++; 171 172 if (robPolicy == Partitioned) { 173 maxEntries[tid] = numEntries / active_threads; 174 } else if (robPolicy == Threshold && active_threads == 1) { 175 maxEntries[tid] = numEntries; 176 } 177 } 178 } 179} 180 181template <class Impl> 182int 183ROB<Impl>::entryAmount(ThreadID num_threads) 184{ 185 if (robPolicy == Partitioned) { 186 return numEntries / num_threads; 187 } else { 188 return 0; 189 } 190} 191 192template <class Impl> 193int 194ROB<Impl>::countInsts() 195{ 196 int total = 0; 197 198 for (ThreadID tid = 0; tid < numThreads; tid++) 199 total += countInsts(tid); 200 201 return total; 202} 203 204template <class Impl> 205int 206ROB<Impl>::countInsts(ThreadID tid) 207{ 208 return instList[tid].size(); 209} 210 211template <class Impl> 212void 213ROB<Impl>::insertInst(DynInstPtr &inst) 214{ 215 assert(inst); 216 217 robWrites++; 218 219 DPRINTF(ROB, "Adding inst PC %s to the ROB.\n", inst->pcState()); 220 221 assert(numInstsInROB != numEntries); 222 223 ThreadID tid = inst->threadNumber; 224 225 instList[tid].push_back(inst); 226 227 //Set Up head iterator if this is the 1st instruction in the ROB 228 if (numInstsInROB == 0) { 229 head = instList[tid].begin(); 230 assert((*head) == inst); 231 } 232 233 //Must Decrement for iterator to actually be valid since __.end() 234 //actually points to 1 after the last inst 235 tail = instList[tid].end(); 236 tail--; 237 238 inst->setInROB(); 239 240 ++numInstsInROB; 241 ++threadEntries[tid]; 242 243 assert((*tail) == inst); 244 245 DPRINTF(ROB, "[tid:%i] Now has %d instructions.\n", tid, threadEntries[tid]); 246} 247 248template <class Impl> 249void 250ROB<Impl>::retireHead(ThreadID tid) 251{ 252 robWrites++; 253 254 assert(numInstsInROB > 0); 255 256 // Get the head ROB instruction. 257 InstIt head_it = instList[tid].begin(); 258 259 DynInstPtr head_inst = (*head_it); 260 261 assert(head_inst->readyToCommit()); 262 263 DPRINTF(ROB, "[tid:%u]: Retiring head instruction, " 264 "instruction PC %s, [sn:%lli]\n", tid, head_inst->pcState(), 265 head_inst->seqNum); 266 267 --numInstsInROB; 268 --threadEntries[tid]; 269 270 head_inst->clearInROB(); 271 head_inst->setCommitted(); 272 273 instList[tid].erase(head_it); 274 275 //Update "Global" Head of ROB 276 updateHead(); 277 278 // @todo: A special case is needed if the instruction being 279 // retired is the only instruction in the ROB; otherwise the tail 280 // iterator will become invalidated. 281 cpu->removeFrontInst(head_inst); 282} 283 284template <class Impl> 285bool 286ROB<Impl>::isHeadReady(ThreadID tid) 287{ 288 robReads++; 289 if (threadEntries[tid] != 0) { 290 return instList[tid].front()->readyToCommit(); 291 } 292 293 return false; 294} 295 296template <class Impl> 297bool 298ROB<Impl>::canCommit() 299{ 300 //@todo: set ActiveThreads through ROB or CPU 301 list<ThreadID>::iterator threads = activeThreads->begin(); 302 list<ThreadID>::iterator end = activeThreads->end(); 303 304 while (threads != end) { 305 ThreadID tid = *threads++; 306 307 if (isHeadReady(tid)) { 308 return true; 309 } 310 } 311 312 return false; 313} 314 315template <class Impl> 316unsigned 317ROB<Impl>::numFreeEntries() 318{ 319 return numEntries - numInstsInROB; 320} 321 322template <class Impl> 323unsigned 324ROB<Impl>::numFreeEntries(ThreadID tid) 325{ 326 return maxEntries[tid] - threadEntries[tid]; 327} 328 329template <class Impl> 330void 331ROB<Impl>::doSquash(ThreadID tid) 332{ 333 robWrites++; 334 DPRINTF(ROB, "[tid:%u]: Squashing instructions until [sn:%i].\n", 335 tid, squashedSeqNum[tid]); 336 337 assert(squashIt[tid] != instList[tid].end()); 338 339 if ((*squashIt[tid])->seqNum < squashedSeqNum[tid]) { 340 DPRINTF(ROB, "[tid:%u]: Done squashing instructions.\n", 341 tid); 342 343 squashIt[tid] = instList[tid].end(); 344 345 doneSquashing[tid] = true; 346 return; 347 } 348 349 bool robTailUpdate = false; 350 351 for (int numSquashed = 0; 352 numSquashed < squashWidth && 353 squashIt[tid] != instList[tid].end() && 354 (*squashIt[tid])->seqNum > squashedSeqNum[tid]; 355 ++numSquashed) 356 { 357 DPRINTF(ROB, "[tid:%u]: Squashing instruction PC %s, seq num %i.\n", 358 (*squashIt[tid])->threadNumber, 359 (*squashIt[tid])->pcState(), 360 (*squashIt[tid])->seqNum); 361 362 // Mark the instruction as squashed, and ready to commit so that 363 // it can drain out of the pipeline. 364 (*squashIt[tid])->setSquashed(); 365 366 (*squashIt[tid])->setCanCommit(); 367 368 369 if (squashIt[tid] == instList[tid].begin()) { 370 DPRINTF(ROB, "Reached head of instruction list while " 371 "squashing.\n"); 372 373 squashIt[tid] = instList[tid].end(); 374 375 doneSquashing[tid] = true; 376 377 return; 378 } 379 380 InstIt tail_thread = instList[tid].end(); 381 tail_thread--; 382 383 if ((*squashIt[tid]) == (*tail_thread)) 384 robTailUpdate = true; 385 386 squashIt[tid]--; 387 } 388 389 390 // Check if ROB is done squashing. 391 if ((*squashIt[tid])->seqNum <= squashedSeqNum[tid]) { 392 DPRINTF(ROB, "[tid:%u]: Done squashing instructions.\n", 393 tid); 394 395 squashIt[tid] = instList[tid].end(); 396 397 doneSquashing[tid] = true; 398 } 399 400 if (robTailUpdate) { 401 updateTail(); 402 } 403} 404 405 406template <class Impl> 407void 408ROB<Impl>::updateHead() 409{ 410 InstSeqNum lowest_num = 0; 411 bool first_valid = true; 412 413 // @todo: set ActiveThreads through ROB or CPU 414 list<ThreadID>::iterator threads = activeThreads->begin(); 415 list<ThreadID>::iterator end = activeThreads->end(); 416 417 while (threads != end) { 418 ThreadID tid = *threads++; 419 420 if (instList[tid].empty()) 421 continue; 422 423 if (first_valid) { 424 head = instList[tid].begin(); 425 lowest_num = (*head)->seqNum; 426 first_valid = false; 427 continue; 428 } 429 430 InstIt head_thread = instList[tid].begin(); 431 432 DynInstPtr head_inst = (*head_thread); 433 434 assert(head_inst != 0); 435 436 if (head_inst->seqNum < lowest_num) { 437 head = head_thread; 438 lowest_num = head_inst->seqNum; 439 } 440 } 441 442 if (first_valid) { 443 head = instList[0].end(); 444 } 445 446} 447 448template <class Impl> 449void 450ROB<Impl>::updateTail() 451{ 452 tail = instList[0].end(); 453 bool first_valid = true; 454 455 list<ThreadID>::iterator threads = activeThreads->begin(); 456 list<ThreadID>::iterator end = activeThreads->end(); 457 458 while (threads != end) { 459 ThreadID tid = *threads++; 460 461 if (instList[tid].empty()) { 462 continue; 463 } 464 465 // If this is the first valid then assign w/out 466 // comparison 467 if (first_valid) { 468 tail = instList[tid].end(); 469 tail--; 470 first_valid = false; 471 continue; 472 } 473 474 // Assign new tail if this thread's tail is younger 475 // than our current "tail high" 476 InstIt tail_thread = instList[tid].end(); 477 tail_thread--; 478 479 if ((*tail_thread)->seqNum > (*tail)->seqNum) { 480 tail = tail_thread; 481 } 482 } 483} 484 485 486template <class Impl> 487void 488ROB<Impl>::squash(InstSeqNum squash_num, ThreadID tid) 489{ 490 if (isEmpty()) { 491 DPRINTF(ROB, "Does not need to squash due to being empty " 492 "[sn:%i]\n", 493 squash_num); 494 495 return; 496 } 497 498 DPRINTF(ROB, "Starting to squash within the ROB.\n"); 499 500 robStatus[tid] = ROBSquashing; 501 502 doneSquashing[tid] = false; 503 504 squashedSeqNum[tid] = squash_num; 505 506 if (!instList[tid].empty()) { 507 InstIt tail_thread = instList[tid].end(); 508 tail_thread--; 509 510 squashIt[tid] = tail_thread; 511 512 doSquash(tid); 513 } 514} 515 516template <class Impl> 517typename Impl::DynInstPtr 518ROB<Impl>::readHeadInst(ThreadID tid) 519{ 520 if (threadEntries[tid] != 0) { 521 InstIt head_thread = instList[tid].begin(); 522 523 assert((*head_thread)->isInROB()==true); 524 525 return *head_thread; 526 } else { 527 return dummyInst; 528 } 529} 530 531template <class Impl> 532typename Impl::DynInstPtr 533ROB<Impl>::readTailInst(ThreadID tid) 534{ 535 InstIt tail_thread = instList[tid].end(); 536 tail_thread--; 537 538 return *tail_thread; 539} 540 541template <class Impl> 542void 543ROB<Impl>::regStats() 544{ 545 using namespace Stats; 546 robReads 547 .name(name() + ".rob_reads") 548 .desc("The number of ROB reads"); 549 550 robWrites 551 .name(name() + ".rob_writes") 552 .desc("The number of ROB writes"); 553} 554 555template <class Impl> 556typename Impl::DynInstPtr 557ROB<Impl>::findInst(ThreadID tid, InstSeqNum squash_inst) 558{ 559 for (InstIt it = instList[tid].begin(); it != instList[tid].end(); it++) { 560 if ((*it)->seqNum == squash_inst) { 561 return *it; 562 } 563 } 564 return NULL; 565} 566 567#endif//__CPU_O3_ROB_IMPL_HH__
| 96 97 //Divide up by threshold amount 98 for (ThreadID tid = 0; tid < numThreads; tid++) { 99 maxEntries[tid] = threshold; 100 } 101 } else { 102 assert(0 && "Invalid ROB Sharing Policy.Options Are:{Dynamic," 103 "Partitioned, Threshold}"); 104 } 105 106 resetState(); 107} 108 109template <class Impl> 110void 111ROB<Impl>::resetState() 112{ 113 for (ThreadID tid = 0; tid < numThreads; tid++) { 114 doneSquashing[tid] = true; 115 threadEntries[tid] = 0; 116 squashIt[tid] = instList[tid].end(); 117 squashedSeqNum[tid] = 0; 118 } 119 numInstsInROB = 0; 120 121 // Initialize the "universal" ROB head & tail point to invalid 122 // pointers 123 head = instList[0].end(); 124 tail = instList[0].end(); 125} 126 127template <class Impl> 128std::string 129ROB<Impl>::name() const 130{ 131 return cpu->name() + ".rob"; 132} 133 134template <class Impl> 135void 136ROB<Impl>::setActiveThreads(list<ThreadID> *at_ptr) 137{ 138 DPRINTF(ROB, "Setting active threads list pointer.\n"); 139 activeThreads = at_ptr; 140} 141 142template <class Impl> 143void 144ROB<Impl>::drainSanityCheck() const 145{ 146 for (ThreadID tid = 0; tid < numThreads; tid++) 147 assert(instList[tid].empty()); 148 assert(isEmpty()); 149} 150 151template <class Impl> 152void 153ROB<Impl>::takeOverFrom() 154{ 155 resetState(); 156} 157 158template <class Impl> 159void 160ROB<Impl>::resetEntries() 161{ 162 if (robPolicy != Dynamic || numThreads > 1) { 163 int active_threads = activeThreads->size(); 164 165 list<ThreadID>::iterator threads = activeThreads->begin(); 166 list<ThreadID>::iterator end = activeThreads->end(); 167 168 while (threads != end) { 169 ThreadID tid = *threads++; 170 171 if (robPolicy == Partitioned) { 172 maxEntries[tid] = numEntries / active_threads; 173 } else if (robPolicy == Threshold && active_threads == 1) { 174 maxEntries[tid] = numEntries; 175 } 176 } 177 } 178} 179 180template <class Impl> 181int 182ROB<Impl>::entryAmount(ThreadID num_threads) 183{ 184 if (robPolicy == Partitioned) { 185 return numEntries / num_threads; 186 } else { 187 return 0; 188 } 189} 190 191template <class Impl> 192int 193ROB<Impl>::countInsts() 194{ 195 int total = 0; 196 197 for (ThreadID tid = 0; tid < numThreads; tid++) 198 total += countInsts(tid); 199 200 return total; 201} 202 203template <class Impl> 204int 205ROB<Impl>::countInsts(ThreadID tid) 206{ 207 return instList[tid].size(); 208} 209 210template <class Impl> 211void 212ROB<Impl>::insertInst(DynInstPtr &inst) 213{ 214 assert(inst); 215 216 robWrites++; 217 218 DPRINTF(ROB, "Adding inst PC %s to the ROB.\n", inst->pcState()); 219 220 assert(numInstsInROB != numEntries); 221 222 ThreadID tid = inst->threadNumber; 223 224 instList[tid].push_back(inst); 225 226 //Set Up head iterator if this is the 1st instruction in the ROB 227 if (numInstsInROB == 0) { 228 head = instList[tid].begin(); 229 assert((*head) == inst); 230 } 231 232 //Must Decrement for iterator to actually be valid since __.end() 233 //actually points to 1 after the last inst 234 tail = instList[tid].end(); 235 tail--; 236 237 inst->setInROB(); 238 239 ++numInstsInROB; 240 ++threadEntries[tid]; 241 242 assert((*tail) == inst); 243 244 DPRINTF(ROB, "[tid:%i] Now has %d instructions.\n", tid, threadEntries[tid]); 245} 246 247template <class Impl> 248void 249ROB<Impl>::retireHead(ThreadID tid) 250{ 251 robWrites++; 252 253 assert(numInstsInROB > 0); 254 255 // Get the head ROB instruction. 256 InstIt head_it = instList[tid].begin(); 257 258 DynInstPtr head_inst = (*head_it); 259 260 assert(head_inst->readyToCommit()); 261 262 DPRINTF(ROB, "[tid:%u]: Retiring head instruction, " 263 "instruction PC %s, [sn:%lli]\n", tid, head_inst->pcState(), 264 head_inst->seqNum); 265 266 --numInstsInROB; 267 --threadEntries[tid]; 268 269 head_inst->clearInROB(); 270 head_inst->setCommitted(); 271 272 instList[tid].erase(head_it); 273 274 //Update "Global" Head of ROB 275 updateHead(); 276 277 // @todo: A special case is needed if the instruction being 278 // retired is the only instruction in the ROB; otherwise the tail 279 // iterator will become invalidated. 280 cpu->removeFrontInst(head_inst); 281} 282 283template <class Impl> 284bool 285ROB<Impl>::isHeadReady(ThreadID tid) 286{ 287 robReads++; 288 if (threadEntries[tid] != 0) { 289 return instList[tid].front()->readyToCommit(); 290 } 291 292 return false; 293} 294 295template <class Impl> 296bool 297ROB<Impl>::canCommit() 298{ 299 //@todo: set ActiveThreads through ROB or CPU 300 list<ThreadID>::iterator threads = activeThreads->begin(); 301 list<ThreadID>::iterator end = activeThreads->end(); 302 303 while (threads != end) { 304 ThreadID tid = *threads++; 305 306 if (isHeadReady(tid)) { 307 return true; 308 } 309 } 310 311 return false; 312} 313 314template <class Impl> 315unsigned 316ROB<Impl>::numFreeEntries() 317{ 318 return numEntries - numInstsInROB; 319} 320 321template <class Impl> 322unsigned 323ROB<Impl>::numFreeEntries(ThreadID tid) 324{ 325 return maxEntries[tid] - threadEntries[tid]; 326} 327 328template <class Impl> 329void 330ROB<Impl>::doSquash(ThreadID tid) 331{ 332 robWrites++; 333 DPRINTF(ROB, "[tid:%u]: Squashing instructions until [sn:%i].\n", 334 tid, squashedSeqNum[tid]); 335 336 assert(squashIt[tid] != instList[tid].end()); 337 338 if ((*squashIt[tid])->seqNum < squashedSeqNum[tid]) { 339 DPRINTF(ROB, "[tid:%u]: Done squashing instructions.\n", 340 tid); 341 342 squashIt[tid] = instList[tid].end(); 343 344 doneSquashing[tid] = true; 345 return; 346 } 347 348 bool robTailUpdate = false; 349 350 for (int numSquashed = 0; 351 numSquashed < squashWidth && 352 squashIt[tid] != instList[tid].end() && 353 (*squashIt[tid])->seqNum > squashedSeqNum[tid]; 354 ++numSquashed) 355 { 356 DPRINTF(ROB, "[tid:%u]: Squashing instruction PC %s, seq num %i.\n", 357 (*squashIt[tid])->threadNumber, 358 (*squashIt[tid])->pcState(), 359 (*squashIt[tid])->seqNum); 360 361 // Mark the instruction as squashed, and ready to commit so that 362 // it can drain out of the pipeline. 363 (*squashIt[tid])->setSquashed(); 364 365 (*squashIt[tid])->setCanCommit(); 366 367 368 if (squashIt[tid] == instList[tid].begin()) { 369 DPRINTF(ROB, "Reached head of instruction list while " 370 "squashing.\n"); 371 372 squashIt[tid] = instList[tid].end(); 373 374 doneSquashing[tid] = true; 375 376 return; 377 } 378 379 InstIt tail_thread = instList[tid].end(); 380 tail_thread--; 381 382 if ((*squashIt[tid]) == (*tail_thread)) 383 robTailUpdate = true; 384 385 squashIt[tid]--; 386 } 387 388 389 // Check if ROB is done squashing. 390 if ((*squashIt[tid])->seqNum <= squashedSeqNum[tid]) { 391 DPRINTF(ROB, "[tid:%u]: Done squashing instructions.\n", 392 tid); 393 394 squashIt[tid] = instList[tid].end(); 395 396 doneSquashing[tid] = true; 397 } 398 399 if (robTailUpdate) { 400 updateTail(); 401 } 402} 403 404 405template <class Impl> 406void 407ROB<Impl>::updateHead() 408{ 409 InstSeqNum lowest_num = 0; 410 bool first_valid = true; 411 412 // @todo: set ActiveThreads through ROB or CPU 413 list<ThreadID>::iterator threads = activeThreads->begin(); 414 list<ThreadID>::iterator end = activeThreads->end(); 415 416 while (threads != end) { 417 ThreadID tid = *threads++; 418 419 if (instList[tid].empty()) 420 continue; 421 422 if (first_valid) { 423 head = instList[tid].begin(); 424 lowest_num = (*head)->seqNum; 425 first_valid = false; 426 continue; 427 } 428 429 InstIt head_thread = instList[tid].begin(); 430 431 DynInstPtr head_inst = (*head_thread); 432 433 assert(head_inst != 0); 434 435 if (head_inst->seqNum < lowest_num) { 436 head = head_thread; 437 lowest_num = head_inst->seqNum; 438 } 439 } 440 441 if (first_valid) { 442 head = instList[0].end(); 443 } 444 445} 446 447template <class Impl> 448void 449ROB<Impl>::updateTail() 450{ 451 tail = instList[0].end(); 452 bool first_valid = true; 453 454 list<ThreadID>::iterator threads = activeThreads->begin(); 455 list<ThreadID>::iterator end = activeThreads->end(); 456 457 while (threads != end) { 458 ThreadID tid = *threads++; 459 460 if (instList[tid].empty()) { 461 continue; 462 } 463 464 // If this is the first valid then assign w/out 465 // comparison 466 if (first_valid) { 467 tail = instList[tid].end(); 468 tail--; 469 first_valid = false; 470 continue; 471 } 472 473 // Assign new tail if this thread's tail is younger 474 // than our current "tail high" 475 InstIt tail_thread = instList[tid].end(); 476 tail_thread--; 477 478 if ((*tail_thread)->seqNum > (*tail)->seqNum) { 479 tail = tail_thread; 480 } 481 } 482} 483 484 485template <class Impl> 486void 487ROB<Impl>::squash(InstSeqNum squash_num, ThreadID tid) 488{ 489 if (isEmpty()) { 490 DPRINTF(ROB, "Does not need to squash due to being empty " 491 "[sn:%i]\n", 492 squash_num); 493 494 return; 495 } 496 497 DPRINTF(ROB, "Starting to squash within the ROB.\n"); 498 499 robStatus[tid] = ROBSquashing; 500 501 doneSquashing[tid] = false; 502 503 squashedSeqNum[tid] = squash_num; 504 505 if (!instList[tid].empty()) { 506 InstIt tail_thread = instList[tid].end(); 507 tail_thread--; 508 509 squashIt[tid] = tail_thread; 510 511 doSquash(tid); 512 } 513} 514 515template <class Impl> 516typename Impl::DynInstPtr 517ROB<Impl>::readHeadInst(ThreadID tid) 518{ 519 if (threadEntries[tid] != 0) { 520 InstIt head_thread = instList[tid].begin(); 521 522 assert((*head_thread)->isInROB()==true); 523 524 return *head_thread; 525 } else { 526 return dummyInst; 527 } 528} 529 530template <class Impl> 531typename Impl::DynInstPtr 532ROB<Impl>::readTailInst(ThreadID tid) 533{ 534 InstIt tail_thread = instList[tid].end(); 535 tail_thread--; 536 537 return *tail_thread; 538} 539 540template <class Impl> 541void 542ROB<Impl>::regStats() 543{ 544 using namespace Stats; 545 robReads 546 .name(name() + ".rob_reads") 547 .desc("The number of ROB reads"); 548 549 robWrites 550 .name(name() + ".rob_writes") 551 .desc("The number of ROB writes"); 552} 553 554template <class Impl> 555typename Impl::DynInstPtr 556ROB<Impl>::findInst(ThreadID tid, InstSeqNum squash_inst) 557{ 558 for (InstIt it = instList[tid].begin(); it != instList[tid].end(); it++) { 559 if ((*it)->seqNum == squash_inst) { 560 return *it; 561 } 562 } 563 return NULL; 564} 565 566#endif//__CPU_O3_ROB_IMPL_HH__
|