cpu/o3/rob_impl.hh

69         for (ThreadID tid = 0; tid < numThreads; tid++) {
70             maxEntries[tid] = numEntries;
80         for (ThreadID tid = 0; tid < numThreads; tid++) {
81             maxEntries[tid] = part_amt;
90         for (ThreadID tid = 0; tid < numThreads; tid++) {
91             maxEntries[tid] = threshold;
95     for (ThreadID tid = numThreads; tid < Impl::MaxThreads; tid++) {
96         maxEntries[tid] = 0;
106     for (ThreadID tid = 0; tid  < Impl::MaxThreads; tid++) {
107         threadEntries[tid] = 0;
108         squashIt[tid] = instList[tid].end();
109         squashedSeqNum[tid] = 0;
110         doneSquashing[tid] = true;
139     for (ThreadID tid = 0; tid  < numThreads; tid++)
140         assert(instList[tid].empty());
162             ThreadID tid = *threads++;
165                 maxEntries[tid] = numEntries / active_threads;
168                 maxEntries[tid] = numEntries;
191     for (ThreadID tid = 0; tid < numThreads; tid++)
192         total += countInsts(tid);
199 ROB<Impl>::countInsts(ThreadID tid)
201     return instList[tid].size();
216     ThreadID tid = inst->threadNumber;
218     instList[tid].push_back(inst);
222         head = instList[tid].begin();
228     tail = instList[tid].end();
234     ++threadEntries[tid];
238     DPRINTF(ROB, "[tid:%i] Now has %d instructions.\n", tid, threadEntries[tid]);
243 ROB<Impl>::retireHead(ThreadID tid)
250     InstIt head_it = instList[tid].begin();
253     instList[tid].erase(head_it);
257     DPRINTF(ROB, "[tid:%i] Retiring head instruction, "
258             "instruction PC %s, [sn:%llu]\n", tid, head_inst->pcState(),
262     --threadEntries[tid];
278 ROB<Impl>::isHeadReady(ThreadID tid)
281     if (threadEntries[tid] != 0) {
282         return instList[tid].front()->readyToCommit();
297         ThreadID tid = *threads++;
299         if (isHeadReady(tid)) {
316 ROB<Impl>::numFreeEntries(ThreadID tid)
318     return maxEntries[tid] - threadEntries[tid];
323 ROB<Impl>::doSquash(ThreadID tid)
326     DPRINTF(ROB, "[tid:%i] Squashing instructions until [sn:%llu].\n",
327             tid, squashedSeqNum[tid]);
329     assert(squashIt[tid] != instList[tid].end());
331     if ((*squashIt[tid])->seqNum < squashedSeqNum[tid]) {
332         DPRINTF(ROB, "[tid:%i] Done squashing instructions.\n",
333                 tid);
335         squashIt[tid] = instList[tid].end();
337         doneSquashing[tid] = true;
345          squashIt[tid] != instList[tid].end() &&
346          (*squashIt[tid])->seqNum > squashedSeqNum[tid];
349         DPRINTF(ROB, "[tid:%i] Squashing instruction PC %s, seq num %i.\n",
350                 (*squashIt[tid])->threadNumber,
351                 (*squashIt[tid])->pcState(),
352                 (*squashIt[tid])->seqNum);
356         (*squashIt[tid])->setSquashed();
358         (*squashIt[tid])->setCanCommit();
361         if (squashIt[tid] == instList[tid].begin()) {
365             squashIt[tid] = instList[tid].end();
367             doneSquashing[tid] = true;
372         InstIt tail_thread = instList[tid].end();
375         if ((*squashIt[tid]) == (*tail_thread))
378         squashIt[tid]--;
383     if ((*squashIt[tid])->seqNum <= squashedSeqNum[tid]) {
384         DPRINTF(ROB, "[tid:%i] Done squashing instructions.\n",
385                 tid);
387         squashIt[tid] = instList[tid].end();
389         doneSquashing[tid] = true;
410         ThreadID tid = *threads++;
412         if (instList[tid].empty())
416             head = instList[tid].begin();
422         InstIt head_thread = instList[tid].begin();
451         ThreadID tid = *threads++;
453         if (instList[tid].empty()) {
460             tail = instList[tid].end();
468         InstIt tail_thread = instList[tid].end();
480 ROB<Impl>::squash(InstSeqNum squash_num, ThreadID tid)
482     if (isEmpty(tid)) {
492     robStatus[tid] = ROBSquashing;
494     doneSquashing[tid] = false;
496     squashedSeqNum[tid] = squash_num;
498     if (!instList[tid].empty()) {
499         InstIt tail_thread = instList[tid].end();
502         squashIt[tid] = tail_thread;
504         doSquash(tid);
510 ROB<Impl>::readHeadInst(ThreadID tid)
512     if (threadEntries[tid] != 0) {
513         InstIt head_thread = instList[tid].begin();
525 ROB<Impl>::readTailInst(ThreadID tid)
527     InstIt tail_thread = instList[tid].end();
549 ROB<Impl>::findInst(ThreadID tid, InstSeqNum squash_inst)
551     for (InstIt it = instList[tid].begin(); it != instList[tid].end(); it++) {