decode_impl.hh revision 8665:e75d9251f7e6
1/* 2 * Copyright (c) 2004-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: Kevin Lim 29 */ 30 31#include "arch/types.hh" 32#include "base/trace.hh" 33#include "config/full_system.hh" 34#include "config/the_isa.hh" 35#include "cpu/o3/decode.hh" 36#include "cpu/inst_seq.hh" 37#include "debug/Activity.hh" 38#include "debug/Decode.hh" 39#include "params/DerivO3CPU.hh" 40 41using namespace std; 42 43template<class Impl> 44DefaultDecode<Impl>::DefaultDecode(O3CPU *_cpu, DerivO3CPUParams *params) 45 : cpu(_cpu), 46 renameToDecodeDelay(params->renameToDecodeDelay), 47 iewToDecodeDelay(params->iewToDecodeDelay), 48 commitToDecodeDelay(params->commitToDecodeDelay), 49 fetchToDecodeDelay(params->fetchToDecodeDelay), 50 decodeWidth(params->decodeWidth), 51 numThreads(params->numThreads) 52{ 53 _status = Inactive; 54 55 // Setup status, make sure stall signals are clear. 56 for (ThreadID tid = 0; tid < numThreads; ++tid) { 57 decodeStatus[tid] = Idle; 58 59 stalls[tid].rename = false; 60 stalls[tid].iew = false; 61 stalls[tid].commit = false; 62 } 63 64 // @todo: Make into a parameter 65 skidBufferMax = (fetchToDecodeDelay * params->fetchWidth) + decodeWidth; 66} 67 68template <class Impl> 69std::string 70DefaultDecode<Impl>::name() const 71{ 72 return cpu->name() + ".decode"; 73} 74 75template <class Impl> 76void 77DefaultDecode<Impl>::regStats() 78{ 79 decodeIdleCycles 80 .name(name() + ".IdleCycles") 81 .desc("Number of cycles decode is idle") 82 .prereq(decodeIdleCycles); 83 decodeBlockedCycles 84 .name(name() + ".BlockedCycles") 85 .desc("Number of cycles decode is blocked") 86 .prereq(decodeBlockedCycles); 87 decodeRunCycles 88 .name(name() + ".RunCycles") 89 .desc("Number of cycles decode is running") 90 .prereq(decodeRunCycles); 91 decodeUnblockCycles 92 .name(name() + ".UnblockCycles") 93 .desc("Number of cycles decode is unblocking") 94 .prereq(decodeUnblockCycles); 95 decodeSquashCycles 96 .name(name() + ".SquashCycles") 97 .desc("Number of cycles decode is squashing") 98 .prereq(decodeSquashCycles); 99 decodeBranchResolved 100 .name(name() + ".BranchResolved") 101 .desc("Number of times decode resolved a branch") 102 .prereq(decodeBranchResolved); 103 decodeBranchMispred 104 .name(name() + ".BranchMispred") 105 .desc("Number of times decode detected a branch misprediction") 106 .prereq(decodeBranchMispred); 107 decodeControlMispred 108 .name(name() + ".ControlMispred") 109 .desc("Number of times decode detected an instruction incorrectly" 110 " predicted as a control") 111 .prereq(decodeControlMispred); 112 decodeDecodedInsts 113 .name(name() + ".DecodedInsts") 114 .desc("Number of instructions handled by decode") 115 .prereq(decodeDecodedInsts); 116 decodeSquashedInsts 117 .name(name() + ".SquashedInsts") 118 .desc("Number of squashed instructions handled by decode") 119 .prereq(decodeSquashedInsts); 120} 121 122template<class Impl> 123void 124DefaultDecode<Impl>::setTimeBuffer(TimeBuffer<TimeStruct> *tb_ptr) 125{ 126 timeBuffer = tb_ptr; 127 128 // Setup wire to write information back to fetch. 129 toFetch = timeBuffer->getWire(0); 130 131 // Create wires to get information from proper places in time buffer. 132 fromRename = timeBuffer->getWire(-renameToDecodeDelay); 133 fromIEW = timeBuffer->getWire(-iewToDecodeDelay); 134 fromCommit = timeBuffer->getWire(-commitToDecodeDelay); 135} 136 137template<class Impl> 138void 139DefaultDecode<Impl>::setDecodeQueue(TimeBuffer<DecodeStruct> *dq_ptr) 140{ 141 decodeQueue = dq_ptr; 142 143 // Setup wire to write information to proper place in decode queue. 144 toRename = decodeQueue->getWire(0); 145} 146 147template<class Impl> 148void 149DefaultDecode<Impl>::setFetchQueue(TimeBuffer<FetchStruct> *fq_ptr) 150{ 151 fetchQueue = fq_ptr; 152 153 // Setup wire to read information from fetch queue. 154 fromFetch = fetchQueue->getWire(-fetchToDecodeDelay); 155} 156 157template<class Impl> 158void 159DefaultDecode<Impl>::setActiveThreads(std::list<ThreadID> *at_ptr) 160{ 161 activeThreads = at_ptr; 162} 163 164template <class Impl> 165bool 166DefaultDecode<Impl>::drain() 167{ 168 // Decode is done draining at any time. 169 cpu->signalDrained(); 170 return true; 171} 172 173template <class Impl> 174void 175DefaultDecode<Impl>::takeOverFrom() 176{ 177 _status = Inactive; 178 179 // Be sure to reset state and clear out any old instructions. 180 for (ThreadID tid = 0; tid < numThreads; ++tid) { 181 decodeStatus[tid] = Idle; 182 183 stalls[tid].rename = false; 184 stalls[tid].iew = false; 185 stalls[tid].commit = false; 186 while (!insts[tid].empty()) 187 insts[tid].pop(); 188 while (!skidBuffer[tid].empty()) 189 skidBuffer[tid].pop(); 190 branchCount[tid] = 0; 191 } 192 wroteToTimeBuffer = false; 193} 194 195template<class Impl> 196bool 197DefaultDecode<Impl>::checkStall(ThreadID tid) const 198{ 199 bool ret_val = false; 200 201 if (stalls[tid].rename) { 202 DPRINTF(Decode,"[tid:%i]: Stall fom Rename stage detected.\n", tid); 203 ret_val = true; 204 } else if (stalls[tid].iew) { 205 DPRINTF(Decode,"[tid:%i]: Stall fom IEW stage detected.\n", tid); 206 ret_val = true; 207 } else if (stalls[tid].commit) { 208 DPRINTF(Decode,"[tid:%i]: Stall fom Commit stage detected.\n", tid); 209 ret_val = true; 210 } 211 212 return ret_val; 213} 214 215template<class Impl> 216inline bool 217DefaultDecode<Impl>::fetchInstsValid() 218{ 219 return fromFetch->size > 0; 220} 221 222template<class Impl> 223bool 224DefaultDecode<Impl>::block(ThreadID tid) 225{ 226 DPRINTF(Decode, "[tid:%u]: Blocking.\n", tid); 227 228 // Add the current inputs to the skid buffer so they can be 229 // reprocessed when this stage unblocks. 230 skidInsert(tid); 231 232 // If the decode status is blocked or unblocking then decode has not yet 233 // signalled fetch to unblock. In that case, there is no need to tell 234 // fetch to block. 235 if (decodeStatus[tid] != Blocked) { 236 // Set the status to Blocked. 237 decodeStatus[tid] = Blocked; 238 239 if (decodeStatus[tid] != Unblocking) { 240 toFetch->decodeBlock[tid] = true; 241 wroteToTimeBuffer = true; 242 } 243 244 return true; 245 } 246 247 return false; 248} 249 250template<class Impl> 251bool 252DefaultDecode<Impl>::unblock(ThreadID tid) 253{ 254 // Decode is done unblocking only if the skid buffer is empty. 255 if (skidBuffer[tid].empty()) { 256 DPRINTF(Decode, "[tid:%u]: Done unblocking.\n", tid); 257 toFetch->decodeUnblock[tid] = true; 258 wroteToTimeBuffer = true; 259 260 decodeStatus[tid] = Running; 261 return true; 262 } 263 264 DPRINTF(Decode, "[tid:%u]: Currently unblocking.\n", tid); 265 266 return false; 267} 268 269template<class Impl> 270void 271DefaultDecode<Impl>::squash(DynInstPtr &inst, ThreadID tid) 272{ 273 DPRINTF(Decode, "[tid:%i]: [sn:%i] Squashing due to incorrect branch " 274 "prediction detected at decode.\n", tid, inst->seqNum); 275 276 // Send back mispredict information. 277 toFetch->decodeInfo[tid].branchMispredict = true; 278 toFetch->decodeInfo[tid].predIncorrect = true; 279 toFetch->decodeInfo[tid].squash = true; 280 toFetch->decodeInfo[tid].doneSeqNum = inst->seqNum; 281 toFetch->decodeInfo[tid].nextPC = inst->branchTarget(); 282 toFetch->decodeInfo[tid].branchTaken = inst->pcState().branching(); 283 toFetch->decodeInfo[tid].squashInst = inst; 284 285 InstSeqNum squash_seq_num = inst->seqNum; 286 287 // Might have to tell fetch to unblock. 288 if (decodeStatus[tid] == Blocked || 289 decodeStatus[tid] == Unblocking) { 290 toFetch->decodeUnblock[tid] = 1; 291 } 292 293 // Set status to squashing. 294 decodeStatus[tid] = Squashing; 295 296 for (int i=0; i<fromFetch->size; i++) { 297 if (fromFetch->insts[i]->threadNumber == tid && 298 fromFetch->insts[i]->seqNum > squash_seq_num) { 299 fromFetch->insts[i]->setSquashed(); 300 } 301 } 302 303 // Clear the instruction list and skid buffer in case they have any 304 // insts in them. 305 while (!insts[tid].empty()) { 306 insts[tid].pop(); 307 } 308 309 while (!skidBuffer[tid].empty()) { 310 skidBuffer[tid].pop(); 311 } 312 313 // Squash instructions up until this one 314 cpu->removeInstsUntil(squash_seq_num, tid); 315} 316 317template<class Impl> 318unsigned 319DefaultDecode<Impl>::squash(ThreadID tid) 320{ 321 DPRINTF(Decode, "[tid:%i]: Squashing.\n",tid); 322 323 if (decodeStatus[tid] == Blocked || 324 decodeStatus[tid] == Unblocking) { 325#if !FULL_SYSTEM 326 // In syscall emulation, we can have both a block and a squash due 327 // to a syscall in the same cycle. This would cause both signals to 328 // be high. This shouldn't happen in full system. 329 // @todo: Determine if this still happens. 330 if (toFetch->decodeBlock[tid]) { 331 toFetch->decodeBlock[tid] = 0; 332 } else { 333 toFetch->decodeUnblock[tid] = 1; 334 } 335#else 336 toFetch->decodeUnblock[tid] = 1; 337#endif 338 } 339 340 // Set status to squashing. 341 decodeStatus[tid] = Squashing; 342 343 // Go through incoming instructions from fetch and squash them. 344 unsigned squash_count = 0; 345 346 for (int i=0; i<fromFetch->size; i++) { 347 if (fromFetch->insts[i]->threadNumber == tid) { 348 fromFetch->insts[i]->setSquashed(); 349 squash_count++; 350 } 351 } 352 353 // Clear the instruction list and skid buffer in case they have any 354 // insts in them. 355 while (!insts[tid].empty()) { 356 insts[tid].pop(); 357 } 358 359 while (!skidBuffer[tid].empty()) { 360 skidBuffer[tid].pop(); 361 } 362 363 return squash_count; 364} 365 366template<class Impl> 367void 368DefaultDecode<Impl>::skidInsert(ThreadID tid) 369{ 370 DynInstPtr inst = NULL; 371 372 while (!insts[tid].empty()) { 373 inst = insts[tid].front(); 374 375 insts[tid].pop(); 376 377 assert(tid == inst->threadNumber); 378 379 DPRINTF(Decode,"Inserting [sn:%lli] PC: %s into decode skidBuffer %i\n", 380 inst->seqNum, inst->pcState(), inst->threadNumber); 381 382 skidBuffer[tid].push(inst); 383 } 384 385 // @todo: Eventually need to enforce this by not letting a thread 386 // fetch past its skidbuffer 387 assert(skidBuffer[tid].size() <= skidBufferMax); 388} 389 390template<class Impl> 391bool 392DefaultDecode<Impl>::skidsEmpty() 393{ 394 list<ThreadID>::iterator threads = activeThreads->begin(); 395 list<ThreadID>::iterator end = activeThreads->end(); 396 397 while (threads != end) { 398 ThreadID tid = *threads++; 399 if (!skidBuffer[tid].empty()) 400 return false; 401 } 402 403 return true; 404} 405 406template<class Impl> 407void 408DefaultDecode<Impl>::updateStatus() 409{ 410 bool any_unblocking = false; 411 412 list<ThreadID>::iterator threads = activeThreads->begin(); 413 list<ThreadID>::iterator end = activeThreads->end(); 414 415 while (threads != end) { 416 ThreadID tid = *threads++; 417 418 if (decodeStatus[tid] == Unblocking) { 419 any_unblocking = true; 420 break; 421 } 422 } 423 424 // Decode will have activity if it's unblocking. 425 if (any_unblocking) { 426 if (_status == Inactive) { 427 _status = Active; 428 429 DPRINTF(Activity, "Activating stage.\n"); 430 431 cpu->activateStage(O3CPU::DecodeIdx); 432 } 433 } else { 434 // If it's not unblocking, then decode will not have any internal 435 // activity. Switch it to inactive. 436 if (_status == Active) { 437 _status = Inactive; 438 DPRINTF(Activity, "Deactivating stage.\n"); 439 440 cpu->deactivateStage(O3CPU::DecodeIdx); 441 } 442 } 443} 444 445template <class Impl> 446void 447DefaultDecode<Impl>::sortInsts() 448{ 449 int insts_from_fetch = fromFetch->size; 450 for (int i = 0; i < insts_from_fetch; ++i) { 451 insts[fromFetch->insts[i]->threadNumber].push(fromFetch->insts[i]); 452 } 453} 454 455template<class Impl> 456void 457DefaultDecode<Impl>::readStallSignals(ThreadID tid) 458{ 459 if (fromRename->renameBlock[tid]) { 460 stalls[tid].rename = true; 461 } 462 463 if (fromRename->renameUnblock[tid]) { 464 assert(stalls[tid].rename); 465 stalls[tid].rename = false; 466 } 467 468 if (fromIEW->iewBlock[tid]) { 469 stalls[tid].iew = true; 470 } 471 472 if (fromIEW->iewUnblock[tid]) { 473 assert(stalls[tid].iew); 474 stalls[tid].iew = false; 475 } 476 477 if (fromCommit->commitBlock[tid]) { 478 stalls[tid].commit = true; 479 } 480 481 if (fromCommit->commitUnblock[tid]) { 482 assert(stalls[tid].commit); 483 stalls[tid].commit = false; 484 } 485} 486 487template <class Impl> 488bool 489DefaultDecode<Impl>::checkSignalsAndUpdate(ThreadID tid) 490{ 491 // Check if there's a squash signal, squash if there is. 492 // Check stall signals, block if necessary. 493 // If status was blocked 494 // Check if stall conditions have passed 495 // if so then go to unblocking 496 // If status was Squashing 497 // check if squashing is not high. Switch to running this cycle. 498 499 // Update the per thread stall statuses. 500 readStallSignals(tid); 501 502 // Check squash signals from commit. 503 if (fromCommit->commitInfo[tid].squash) { 504 505 DPRINTF(Decode, "[tid:%u]: Squashing instructions due to squash " 506 "from commit.\n", tid); 507 508 squash(tid); 509 510 return true; 511 } 512 513 // Check ROB squash signals from commit. 514 if (fromCommit->commitInfo[tid].robSquashing) { 515 DPRINTF(Decode, "[tid:%u]: ROB is still squashing.\n", tid); 516 517 // Continue to squash. 518 decodeStatus[tid] = Squashing; 519 520 return true; 521 } 522 523 if (checkStall(tid)) { 524 return block(tid); 525 } 526 527 if (decodeStatus[tid] == Blocked) { 528 DPRINTF(Decode, "[tid:%u]: Done blocking, switching to unblocking.\n", 529 tid); 530 531 decodeStatus[tid] = Unblocking; 532 533 unblock(tid); 534 535 return true; 536 } 537 538 if (decodeStatus[tid] == Squashing) { 539 // Switch status to running if decode isn't being told to block or 540 // squash this cycle. 541 DPRINTF(Decode, "[tid:%u]: Done squashing, switching to running.\n", 542 tid); 543 544 decodeStatus[tid] = Running; 545 546 return false; 547 } 548 549 // If we've reached this point, we have not gotten any signals that 550 // cause decode to change its status. Decode remains the same as before. 551 return false; 552} 553 554template<class Impl> 555void 556DefaultDecode<Impl>::tick() 557{ 558 wroteToTimeBuffer = false; 559 560 bool status_change = false; 561 562 toRenameIndex = 0; 563 564 list<ThreadID>::iterator threads = activeThreads->begin(); 565 list<ThreadID>::iterator end = activeThreads->end(); 566 567 sortInsts(); 568 569 //Check stall and squash signals. 570 while (threads != end) { 571 ThreadID tid = *threads++; 572 573 DPRINTF(Decode,"Processing [tid:%i]\n",tid); 574 status_change = checkSignalsAndUpdate(tid) || status_change; 575 576 decode(status_change, tid); 577 } 578 579 if (status_change) { 580 updateStatus(); 581 } 582 583 if (wroteToTimeBuffer) { 584 DPRINTF(Activity, "Activity this cycle.\n"); 585 586 cpu->activityThisCycle(); 587 } 588} 589 590template<class Impl> 591void 592DefaultDecode<Impl>::decode(bool &status_change, ThreadID tid) 593{ 594 // If status is Running or idle, 595 // call decodeInsts() 596 // If status is Unblocking, 597 // buffer any instructions coming from fetch 598 // continue trying to empty skid buffer 599 // check if stall conditions have passed 600 601 if (decodeStatus[tid] == Blocked) { 602 ++decodeBlockedCycles; 603 } else if (decodeStatus[tid] == Squashing) { 604 ++decodeSquashCycles; 605 } 606 607 // Decode should try to decode as many instructions as its bandwidth 608 // will allow, as long as it is not currently blocked. 609 if (decodeStatus[tid] == Running || 610 decodeStatus[tid] == Idle) { 611 DPRINTF(Decode, "[tid:%u]: Not blocked, so attempting to run " 612 "stage.\n",tid); 613 614 decodeInsts(tid); 615 } else if (decodeStatus[tid] == Unblocking) { 616 // Make sure that the skid buffer has something in it if the 617 // status is unblocking. 618 assert(!skidsEmpty()); 619 620 // If the status was unblocking, then instructions from the skid 621 // buffer were used. Remove those instructions and handle 622 // the rest of unblocking. 623 decodeInsts(tid); 624 625 if (fetchInstsValid()) { 626 // Add the current inputs to the skid buffer so they can be 627 // reprocessed when this stage unblocks. 628 skidInsert(tid); 629 } 630 631 status_change = unblock(tid) || status_change; 632 } 633} 634 635template <class Impl> 636void 637DefaultDecode<Impl>::decodeInsts(ThreadID tid) 638{ 639 // Instructions can come either from the skid buffer or the list of 640 // instructions coming from fetch, depending on decode's status. 641 int insts_available = decodeStatus[tid] == Unblocking ? 642 skidBuffer[tid].size() : insts[tid].size(); 643 644 if (insts_available == 0) { 645 DPRINTF(Decode, "[tid:%u] Nothing to do, breaking out" 646 " early.\n",tid); 647 // Should I change the status to idle? 648 ++decodeIdleCycles; 649 return; 650 } else if (decodeStatus[tid] == Unblocking) { 651 DPRINTF(Decode, "[tid:%u] Unblocking, removing insts from skid " 652 "buffer.\n",tid); 653 ++decodeUnblockCycles; 654 } else if (decodeStatus[tid] == Running) { 655 ++decodeRunCycles; 656 } 657 658 DynInstPtr inst; 659 660 std::queue<DynInstPtr> 661 &insts_to_decode = decodeStatus[tid] == Unblocking ? 662 skidBuffer[tid] : insts[tid]; 663 664 DPRINTF(Decode, "[tid:%u]: Sending instruction to rename.\n",tid); 665 666 while (insts_available > 0 && toRenameIndex < decodeWidth) { 667 assert(!insts_to_decode.empty()); 668 669 inst = insts_to_decode.front(); 670 671 insts_to_decode.pop(); 672 673 DPRINTF(Decode, "[tid:%u]: Processing instruction [sn:%lli] with " 674 "PC %s\n", tid, inst->seqNum, inst->pcState()); 675 676 if (inst->isSquashed()) { 677 DPRINTF(Decode, "[tid:%u]: Instruction %i with PC %s is " 678 "squashed, skipping.\n", 679 tid, inst->seqNum, inst->pcState()); 680 681 ++decodeSquashedInsts; 682 683 --insts_available; 684 685 continue; 686 } 687 688 // Also check if instructions have no source registers. Mark 689 // them as ready to issue at any time. Not sure if this check 690 // should exist here or at a later stage; however it doesn't matter 691 // too much for function correctness. 692 if (inst->numSrcRegs() == 0) { 693 inst->setCanIssue(); 694 } 695 696 // This current instruction is valid, so add it into the decode 697 // queue. The next instruction may not be valid, so check to 698 // see if branches were predicted correctly. 699 toRename->insts[toRenameIndex] = inst; 700 701 ++(toRename->size); 702 ++toRenameIndex; 703 ++decodeDecodedInsts; 704 --insts_available; 705 706#if TRACING_ON 707 inst->decodeTick = curTick(); 708#endif 709 710 // Ensure that if it was predicted as a branch, it really is a 711 // branch. 712 if (inst->readPredTaken() && !inst->isControl()) { 713 panic("Instruction predicted as a branch!"); 714 715 ++decodeControlMispred; 716 717 // Might want to set some sort of boolean and just do 718 // a check at the end 719 squash(inst, inst->threadNumber); 720 721 break; 722 } 723 724 // Go ahead and compute any PC-relative branches. 725 if (inst->isDirectCtrl() && inst->isUncondCtrl()) { 726 ++decodeBranchResolved; 727 728 if (!(inst->branchTarget() == inst->readPredTarg())) { 729 ++decodeBranchMispred; 730 731 // Might want to set some sort of boolean and just do 732 // a check at the end 733 squash(inst, inst->threadNumber); 734 TheISA::PCState target = inst->branchTarget(); 735 736 DPRINTF(Decode, "[sn:%i]: Updating predictions: PredPC: %s\n", 737 inst->seqNum, target); 738 //The micro pc after an instruction level branch should be 0 739 inst->setPredTarg(target); 740 break; 741 } 742 } 743 } 744 745 // If we didn't process all instructions, then we will need to block 746 // and put all those instructions into the skid buffer. 747 if (!insts_to_decode.empty()) { 748 block(tid); 749 } 750 751 // Record that decode has written to the time buffer for activity 752 // tracking. 753 if (toRenameIndex) { 754 wroteToTimeBuffer = true; 755 } 756} 757