Lines Matching defs:tid
79 for (uint32_t tid = 0; tid < Impl::MaxThreads; tid++) {
80 renameStatus[tid] = Idle;
81 renameMap[tid] = nullptr;
82 instsInProgress[tid] = 0;
83 loadsInProgress[tid] = 0;
84 storesInProgress[tid] = 0;
85 freeEntries[tid] = {0, 0, 0, 0};
86 emptyROB[tid] = true;
87 stalls[tid] = {false, false};
88 serializeInst[tid] = nullptr;
89 serializeOnNextInst[tid] = false;
259 DefaultRename<Impl>::clearStates(ThreadID tid)
261 renameStatus[tid] = Idle;
263 freeEntries[tid].iqEntries = iew_ptr->instQueue.numFreeEntries(tid);
264 freeEntries[tid].lqEntries = iew_ptr->ldstQueue.numFreeLoadEntries(tid);
265 freeEntries[tid].sqEntries = iew_ptr->ldstQueue.numFreeStoreEntries(tid);
266 freeEntries[tid].robEntries = commit_ptr->numROBFreeEntries(tid);
267 emptyROB[tid] = true;
269 stalls[tid].iew = false;
270 serializeInst[tid] = NULL;
272 instsInProgress[tid] = 0;
273 loadsInProgress[tid] = 0;
274 storesInProgress[tid] = 0;
276 serializeOnNextInst[tid] = false;
289 for (ThreadID tid = 0; tid < numThreads; tid++) {
290 renameStatus[tid] = Idle;
292 freeEntries[tid].iqEntries = iew_ptr->instQueue.numFreeEntries(tid);
293 freeEntries[tid].lqEntries = iew_ptr->ldstQueue.numFreeLoadEntries(tid);
294 freeEntries[tid].sqEntries = iew_ptr->ldstQueue.numFreeStoreEntries(tid);
295 freeEntries[tid].robEntries = commit_ptr->numROBFreeEntries(tid);
296 emptyROB[tid] = true;
298 stalls[tid].iew = false;
299 serializeInst[tid] = NULL;
301 instsInProgress[tid] = 0;
302 loadsInProgress[tid] = 0;
303 storesInProgress[tid] = 0;
305 serializeOnNextInst[tid] = false;
321 for (ThreadID tid = 0; tid < numThreads; tid++)
322 renameMap[tid] = &rm_ptr[tid];
343 for (ThreadID tid = 0; tid < numThreads; tid++) {
344 if (instsInProgress[tid] != 0 ||
345 !historyBuffer[tid].empty() ||
346 !skidBuffer[tid].empty() ||
347 !insts[tid].empty() ||
348 (renameStatus[tid] != Idle && renameStatus[tid] != Running))
365 for (ThreadID tid = 0; tid < numThreads; tid++) {
366 assert(historyBuffer[tid].empty());
367 assert(insts[tid].empty());
368 assert(skidBuffer[tid].empty());
369 assert(instsInProgress[tid] == 0);
375 DefaultRename<Impl>::squash(const InstSeqNum &squash_seq_num, ThreadID tid)
377 DPRINTF(Rename, "[tid:%i] [squash sn:%llu] Squashing instructions.\n",
378 tid,squash_seq_num);
383 if (renameStatus[tid] == Blocked ||
384 renameStatus[tid] == Unblocking) {
385 toDecode->renameUnblock[tid] = 1;
388 serializeInst[tid] = NULL;
389 } else if (renameStatus[tid] == SerializeStall) {
390 if (serializeInst[tid]->seqNum <= squash_seq_num) {
391 DPRINTF(Rename, "[tid:%i] [squash sn:%llu] "
393 tid,squash_seq_num);
395 assert(serializeInst[tid]);
398 toDecode->renameUnblock[tid] = 1;
400 serializeInst[tid] = NULL;
405 renameStatus[tid] = Squashing;
409 if (fromDecode->insts[i]->threadNumber == tid &&
419 insts[tid].clear();
422 skidBuffer[tid].clear();
424 doSquash(squash_seq_num, tid);
446 ThreadID tid = *threads++;
448 DPRINTF(Rename, "Processing [tid:%i]\n", tid);
450 status_change = checkSignalsAndUpdate(tid) || status_change;
452 rename(status_change, tid);
467 ThreadID tid = *threads++;
470 if (fromCommit->commitInfo[tid].doneSeqNum != 0 &&
471 !fromCommit->commitInfo[tid].squash &&
472 renameStatus[tid] != Squashing) {
474 removeFromHistory(fromCommit->commitInfo[tid].doneSeqNum,
475 tid);
480 for (ThreadID tid = 0; tid < numThreads; tid++) {
481 instsInProgress[tid] -= fromIEW->iewInfo[tid].dispatched;
482 loadsInProgress[tid] -= fromIEW->iewInfo[tid].dispatchedToLQ;
483 storesInProgress[tid] -= fromIEW->iewInfo[tid].dispatchedToSQ;
484 assert(loadsInProgress[tid] >= 0);
485 assert(storesInProgress[tid] >= 0);
486 assert(instsInProgress[tid] >=0);
493 DefaultRename<Impl>::rename(bool &status_change, ThreadID tid)
502 if (renameStatus[tid] == Blocked) {
504 } else if (renameStatus[tid] == Squashing) {
506 } else if (renameStatus[tid] == SerializeStall) {
513 block(tid);
514 toDecode->renameUnblock[tid] = false;
516 } else if (renameStatus[tid] == Unblocking) {
518 block(tid);
520 toDecode->renameUnblock[tid] = false;
524 if (renameStatus[tid] == Running ||
525 renameStatus[tid] == Idle) {
527 "[tid:%i] "
529 tid);
531 renameInsts(tid);
532 } else if (renameStatus[tid] == Unblocking) {
533 renameInsts(tid);
538 skidInsert(tid);
543 status_change = unblock(tid) || status_change || blockThisCycle;
549 DefaultRename<Impl>::renameInsts(ThreadID tid)
553 int insts_available = renameStatus[tid] == Unblocking ?
554 skidBuffer[tid].size() : insts[tid].size();
559 DPRINTF(Rename, "[tid:%i] Nothing to do, breaking out early.\n",
560 tid);
564 } else if (renameStatus[tid] == Unblocking) {
566 } else if (renameStatus[tid] == Running) {
572 int free_rob_entries = calcFreeROBEntries(tid);
573 int free_iq_entries = calcFreeIQEntries(tid);
586 "[tid:%i] Blocking due to no free ROB/IQ/ entries.\n"
589 tid, free_rob_entries, free_iq_entries);
593 block(tid);
600 "[tid:%i] "
604 tid, insts_available, min_free_entries);
613 InstQueue &insts_to_rename = renameStatus[tid] == Unblocking ?
614 skidBuffer[tid] : insts[tid];
617 "[tid:%i] "
619 tid, insts_available);
622 "[tid:%i] "
625 tid, instsInProgress[tid], fromIEW->iewInfo[tid].dispatched);
628 if (serializeOnNextInst[tid]) {
629 if (emptyROB[tid] && instsInProgress[tid] == 0) {
631 serializeOnNextInst[tid] = false;
640 DPRINTF(Rename, "[tid:%i] Sending instructions to IEW.\n", tid);
651 if (calcFreeLQEntries(tid) <= 0) {
652 DPRINTF(Rename, "[tid:%i] Cannot rename due to no free LQ\n");
660 if (calcFreeSQEntries(tid) <= 0) {
661 DPRINTF(Rename, "[tid:%i] Cannot rename due to no free SQ\n");
670 if (renameStatus[tid] == Unblocking) {
672 "[tid:%i] "
674 tid, inst->seqNum, inst->pcState());
679 "[tid:%i] "
681 tid, inst->seqNum, inst->pcState());
692 "[tid:%i] "
694 tid, inst->seqNum, inst->pcState());
698 if (!renameMap[tid]->canRename(inst->numIntDestRegs(),
737 renameStatus[tid] = SerializeStall;
739 serializeInst[tid] = inst;
752 serializeAfter(insts_to_rename, tid);
760 storesInProgress[tid]++;
762 loadsInProgress[tid]++;
781 instsInProgress[tid] += renamed_insts;
796 block(tid);
797 toDecode->renameUnblock[tid] = false;
803 DefaultRename<Impl>::skidInsert(ThreadID tid)
807 while (!insts[tid].empty()) {
808 inst = insts[tid].front();
810 insts[tid].pop_front();
812 assert(tid == inst->threadNumber);
814 DPRINTF(Rename, "[tid:%i] Inserting [sn:%llu] PC: %s into Rename "
815 "skidBuffer\n", tid, inst->seqNum, inst->pcState());
819 skidBuffer[tid].push_back(inst);
822 if (skidBuffer[tid].size() > skidBufferMax)
826 for (it = skidBuffer[tid].begin(); it != skidBuffer[tid].end(); it++)
828 warn("[tid:%i] %s [sn:%llu].\n", tid,
860 ThreadID tid = *threads++;
862 if (!skidBuffer[tid].empty())
879 ThreadID tid = *threads++;
881 if (renameStatus[tid] == Unblocking) {
910 DefaultRename<Impl>::block(ThreadID tid)
912 DPRINTF(Rename, "[tid:%i] Blocking.\n", tid);
916 skidInsert(tid);
920 if (renameStatus[tid] != Blocked) {
924 if (resumeUnblocking || renameStatus[tid] != Unblocking) {
925 toDecode->renameBlock[tid] = true;
926 toDecode->renameUnblock[tid] = false;
932 if (renameStatus[tid] != SerializeStall) {
934 renameStatus[tid] = Blocked;
944 DefaultRename<Impl>::unblock(ThreadID tid)
946 DPRINTF(Rename, "[tid:%i] Trying to unblock.\n", tid);
949 if (skidBuffer[tid].empty() && renameStatus[tid] != SerializeStall) {
951 DPRINTF(Rename, "[tid:%i] Done unblocking.\n", tid);
953 toDecode->renameUnblock[tid] = true;
956 renameStatus[tid] = Running;
965 DefaultRename<Impl>::doSquash(const InstSeqNum &squashed_seq_num, ThreadID tid)
968 historyBuffer[tid].begin();
974 while (!historyBuffer[tid].empty() &&
976 assert(hb_it != historyBuffer[tid].end());
978 DPRINTF(Rename, "[tid:%i] Removing history entry with sequence "
980 tid, hb_it->instSeqNum, hb_it->archReg.index(),
992 renameMap[tid]->setEntry(hb_it->archReg, hb_it->prevPhysReg);
1004 historyBuffer[tid].erase(hb_it++);
1010 cpu->switchRenameMode(tid, freeList);
1015 DefaultRename<Impl>::removeFromHistory(InstSeqNum inst_seq_num, ThreadID tid)
1017 DPRINTF(Rename, "[tid:%i] Removing a committed instruction from the "
1019 tid, tid, historyBuffer[tid].size(), inst_seq_num);
1022 historyBuffer[tid].end();
1026 if (historyBuffer[tid].empty()) {
1027 DPRINTF(Rename, "[tid:%i] History buffer is empty.\n", tid);
1030 DPRINTF(Rename, "[tid:%i] [sn:%llu] "
1033 tid,inst_seq_num);
1041 while (!historyBuffer[tid].empty() &&
1042 hb_it != historyBuffer[tid].end() &&
1045 DPRINTF(Rename, "[tid:%i] Freeing up older rename of reg %i (%s), "
1047 tid, hb_it->prevPhysReg->index(),
1060 historyBuffer[tid].erase(hb_it--);
1066 DefaultRename<Impl>::renameSrcRegs(const DynInstPtr &inst, ThreadID tid)
1069 RenameMap *map = renameMap[tid];
1102 "[tid:%i] "
1104 tid, src_reg.className(),
1113 "[tid:%i] "
1115 tid, renamed_reg->index(), renamed_reg->flatIndex(),
1121 "[tid:%i] "
1123 tid, renamed_reg->index(), renamed_reg->flatIndex(),
1133 DefaultRename<Impl>::renameDestRegs(const DynInstPtr &inst, ThreadID tid)
1136 RenameMap *map = renameMap[tid];
1154 "[tid:%i] "
1156 tid, dest_reg.index(), dest_reg.className(),
1165 historyBuffer[tid].push_front(hb_entry);
1167 DPRINTF(Rename, "[tid:%i] [sn:%llu] "
1169 tid,(*historyBuffer[tid].begin()).instSeqNum,
1170 historyBuffer[tid].size());
1187 DefaultRename<Impl>::calcFreeROBEntries(ThreadID tid)
1189 int num_free = freeEntries[tid].robEntries -
1190 (instsInProgress[tid] - fromIEW->iewInfo[tid].dispatched);
1192 //DPRINTF(Rename,"[tid:%i] %i rob free\n",tid,num_free);
1199 DefaultRename<Impl>::calcFreeIQEntries(ThreadID tid)
1201 int num_free = freeEntries[tid].iqEntries -
1202 (instsInProgress[tid] - fromIEW->iewInfo[tid].dispatched);
1204 //DPRINTF(Rename,"[tid:%i] %i iq free\n",tid,num_free);
1211 DefaultRename<Impl>::calcFreeLQEntries(ThreadID tid)
1213 int num_free = freeEntries[tid].lqEntries -
1214 (loadsInProgress[tid] - fromIEW->iewInfo[tid].dispatchedToLQ);
1218 freeEntries[tid].lqEntries, loadsInProgress[tid],
1219 fromIEW->iewInfo[tid].dispatchedToLQ);
1225 DefaultRename<Impl>::calcFreeSQEntries(ThreadID tid)
1227 int num_free = freeEntries[tid].sqEntries -
1228 (storesInProgress[tid] - fromIEW->iewInfo[tid].dispatchedToSQ);
1230 "stores dispatchedToSQ: %d\n", freeEntries[tid].sqEntries,
1231 storesInProgress[tid], fromIEW->iewInfo[tid].dispatchedToSQ);
1251 DefaultRename<Impl>::readStallSignals(ThreadID tid)
1253 if (fromIEW->iewBlock[tid]) {
1254 stalls[tid].iew = true;
1257 if (fromIEW->iewUnblock[tid]) {
1258 assert(stalls[tid].iew);
1259 stalls[tid].iew = false;
1265 DefaultRename<Impl>::checkStall(ThreadID tid)
1269 if (stalls[tid].iew) {
1270 DPRINTF(Rename,"[tid:%i] Stall from IEW stage detected.\n", tid);
1272 } else if (calcFreeROBEntries(tid) <= 0) {
1273 DPRINTF(Rename,"[tid:%i] Stall: ROB has 0 free entries.\n", tid);
1275 } else if (calcFreeIQEntries(tid) <= 0) {
1276 DPRINTF(Rename,"[tid:%i] Stall: IQ has 0 free entries.\n", tid);
1278 } else if (calcFreeLQEntries(tid) <= 0 && calcFreeSQEntries(tid) <= 0) {
1279 DPRINTF(Rename,"[tid:%i] Stall: LSQ has 0 free entries.\n", tid);
1281 } else if (renameMap[tid]->numFreeEntries() <= 0) {
1282 DPRINTF(Rename,"[tid:%i] Stall: RenameMap has 0 free entries.\n", tid);
1284 } else if (renameStatus[tid] == SerializeStall &&
1285 (!emptyROB[tid] || instsInProgress[tid])) {
1286 DPRINTF(Rename,"[tid:%i] Stall: Serialize stall and ROB is not "
1288 tid);
1297 DefaultRename<Impl>::readFreeEntries(ThreadID tid)
1299 if (fromIEW->iewInfo[tid].usedIQ)
1300 freeEntries[tid].iqEntries = fromIEW->iewInfo[tid].freeIQEntries;
1302 if (fromIEW->iewInfo[tid].usedLSQ) {
1303 freeEntries[tid].lqEntries = fromIEW->iewInfo[tid].freeLQEntries;
1304 freeEntries[tid].sqEntries = fromIEW->iewInfo[tid].freeSQEntries;
1307 if (fromCommit->commitInfo[tid].usedROB) {
1308 freeEntries[tid].robEntries =
1309 fromCommit->commitInfo[tid].freeROBEntries;
1310 emptyROB[tid] = fromCommit->commitInfo[tid].emptyROB;
1313 DPRINTF(Rename, "[tid:%i] Free IQ: %i, Free ROB: %i, "
1315 tid,
1316 freeEntries[tid].iqEntries,
1317 freeEntries[tid].robEntries,
1318 freeEntries[tid].lqEntries,
1319 freeEntries[tid].sqEntries,
1320 renameMap[tid]->numFreeEntries(),
1321 renameMap[tid]->numFreeIntEntries(),
1322 renameMap[tid]->numFreeFloatEntries(),
1323 renameMap[tid]->numFreeVecEntries(),
1324 renameMap[tid]->numFreePredEntries(),
1325 renameMap[tid]->numFreeCCEntries());
1327 DPRINTF(Rename, "[tid:%i] %i instructions not yet in ROB\n",
1328 tid, instsInProgress[tid]);
1333 DefaultRename<Impl>::checkSignalsAndUpdate(ThreadID tid)
1345 readFreeEntries(tid);
1346 readStallSignals(tid);
1348 if (fromCommit->commitInfo[tid].squash) {
1349 DPRINTF(Rename, "[tid:%i] Squashing instructions due to squash from "
1350 "commit.\n", tid);
1352 squash(fromCommit->commitInfo[tid].doneSeqNum, tid);
1357 if (checkStall(tid)) {
1358 return block(tid);
1361 if (renameStatus[tid] == Blocked) {
1362 DPRINTF(Rename, "[tid:%i] Done blocking, switching to unblocking.\n",
1363 tid);
1365 renameStatus[tid] = Unblocking;
1367 unblock(tid);
1372 if (renameStatus[tid] == Squashing) {
1377 "[tid:%i] Done squashing, switching to serialize.\n", tid);
1379 renameStatus[tid] = SerializeStall;
1383 "[tid:%i] Done squashing, switching to unblocking.\n",
1384 tid);
1385 renameStatus[tid] = Unblocking;
1388 DPRINTF(Rename, "[tid:%i] Done squashing, switching to running.\n",
1389 tid);
1390 renameStatus[tid] = Running;
1395 if (renameStatus[tid] == SerializeStall) {
1397 DPRINTF(Rename, "[tid:%i] Done with serialize stall, switching to "
1398 "unblocking.\n", tid);
1400 DynInstPtr serial_inst = serializeInst[tid];
1402 renameStatus[tid] = Unblocking;
1404 unblock(tid);
1406 DPRINTF(Rename, "[tid:%i] Processing instruction [%lli] with "
1407 "PC %s.\n", tid, serial_inst->seqNum, serial_inst->pcState());
1412 if (!skidBuffer[tid].empty()) {
1413 skidBuffer[tid].push_front(serial_inst);
1415 insts[tid].push_front(serial_inst);
1418 DPRINTF(Rename, "[tid:%i] Instruction must be processed by rename."
1419 " Adding to front of list.\n", tid);
1421 serializeInst[tid] = NULL;
1433 DefaultRename<Impl>::serializeAfter(InstQueue &inst_list, ThreadID tid)
1437 serializeOnNextInst[tid] = true;
1474 for (ThreadID tid = 0; tid < numThreads; tid++) {
1476 buf_it = historyBuffer[tid].begin();
1478 while (buf_it != historyBuffer[tid].end()) {