Gem5 Interrupt Handling O3

Posted Dec 25, 2021

By Jaehyuk Lee 6 min read

Interrupt makes the commit stage stop further instructions fetching

        
      
template <class Impl>
void
DefaultCommit<Impl>::commit()
{
   if (FullSystem) {
       // Check if we have a interrupt and get read to handle it
       if (cpu->checkInterrupts(cpu->tcBase(0)))
           propagateInterrupt();
   }

        
      
template <class Impl>
void
DefaultCommit<Impl>::propagateInterrupt()
{
   // Don't propagate intterupts if we are currently handling a trap or
   // in draining and the last observable instruction has been committed.
   if (commitStatus[0] == TrapPending || interrupt || trapSquash[0] ||
           tcSquash[0] || drainImminent)
       return;

   // Process interrupts if interrupts are enabled, not in PAL
   // mode, and no other traps or external squashes are currently
   // pending.
   // @todo: Allow other threads to handle interrupts.

   // Get any interrupt that happened
   interrupt = cpu->getInterrupts();

   // Tell fetch that there is an interrupt pending.  This
   // will make fetch wait until it sees a non PAL-mode PC,
   // at which point it stops fetching instructions.
   if (interrupt != NoFault)
       toIEW->commitInfo[0].interruptPending = true;
}

If the commit stage found that the interrupt needs to be handled, through the getInterrupts function, it should first send signal to IEW stage and prevent further instruction fetching until the interrupt is resolved.

Handle interrupt at the time of instruction commit

After commit stage checks possible squash on the threads and presence of interrupt, it tries to commit the instructions.

        
      
template <class Impl>
void
DefaultCommit<Impl>::commitInsts()
{
   ////////////////////////////////////
   // Handle commit
   // Note that commit will be handled prior to putting new
   // instructions in the ROB so that the ROB only tries to commit
   // instructions it has in this current cycle, and not instructions
   // it is writing in during this cycle.  Can't commit and squash
   // things at the same time...
   ////////////////////////////////////

   DPRINTF(Commit, "Trying to commit instructions in the ROB.\n");

   unsigned num_committed = 0;

   DynInstPtr head_inst;

   // Commit as many instructions as possible until the commit bandwidth
   // limit is reached, or it becomes impossible to commit any more.
   while (num_committed < commitWidth) {
       // Check for any interrupt that we've already squashed for
       // and start processing it.
       if (interrupt != NoFault)
           handleInterrupt();

If there were pending interrupt, the instructions cannot be committed.

        
      
template <class Impl>
void
DefaultCommit<Impl>::handleInterrupt()
{
   // Verify that we still have an interrupt to handle
   if (!cpu->checkInterrupts(cpu->tcBase(0))) {
       DPRINTF(Commit, "Pending interrupt is cleared by master before "
               "it got handled. Restart fetching from the orig path.\n");
       toIEW->commitInfo[0].clearInterrupt = true;
       interrupt = NoFault;
       avoidQuiesceLiveLock = true;
       return;
   }

   // Wait until all in flight instructions are finished before enterring
   // the interrupt.
   if (canHandleInterrupts && cpu->instList.empty()) {
       // Squash or record that I need to squash this cycle if
       // an interrupt needed to be handled.
       DPRINTF(Commit, "Interrupt detected.\n");

       // Clear the interrupt now that it's going to be handled
       toIEW->commitInfo[0].clearInterrupt = true;

       assert(!thread[0]->noSquashFromTC);
       thread[0]->noSquashFromTC = true;

       if (cpu->checker) {
           cpu->checker->handlePendingInt();
       }

       // CPU will handle interrupt. Note that we ignore the local copy of
       // interrupt. This is because the local copy may no longer be the
       // interrupt that the interrupt controller thinks is being handled.
       cpu->processInterrupts(cpu->getInterrupts());

       thread[0]->noSquashFromTC = false;

       commitStatus[0] = TrapPending;

       interrupt = NoFault;

       // Generate trap squash event.
       generateTrapEvent(0, interrupt);

       avoidQuiesceLiveLock = false;
   } else {
       DPRINTF(Commit, "Interrupt pending: instruction is %sin "
               "flight, ROB is %sempty\n",
               canHandleInterrupts ? "not " : "",
               cpu->instList.empty() ? "" : "not " );
   }
}

Architecture dependent interrupt checking

        
      
bool
X86ISA::Interrupts::checkInterrupts(ThreadContext *tc) const
{
   RFLAGS rflags = tc->readMiscRegNoEffect(MISCREG_RFLAGS);
   if (pendingUnmaskableInt) {
       DPRINTF(LocalApic, "Reported pending unmaskable interrupt.\n");
       return true;
   }
   if (rflags.intf) {
       if (pendingExtInt) {
           DPRINTF(LocalApic, "Reported pending external interrupt.\n");
           return true;
       }
       if (IRRV > ISRV && bits(IRRV, 7, 4) >
              bits(regs[APIC_TASK_PRIORITY], 7, 4)) {
           DPRINTF(LocalApic, "Reported pending regular interrupt.\n");
           return true;
       }
   }
   return false;
}

Processing interrupt through invoke

        
      
template <class Impl>
void    
FullO3CPU<Impl>::processInterrupts(const Fault &interrupt)
{       
   // Check for interrupts here.  For now can copy the code that
   // exists within isa_fullsys_traits.hh.  Also assume that thread 0
   // is the one that handles the interrupts.
   // @todo: Possibly consolidate the interrupt checking code.
   // @todo: Allow other threads to handle interrupts.
       
   assert(interrupt != NoFault);
   this->interrupts[0]->updateIntrInfo(this->threadContexts[0]);
       
   DPRINTF(O3CPU, "Interrupt %s being handled\n", interrupt->name());
   this->trap(interrupt, 0, nullptr);
}       
 902
template <class Impl>
void
FullO3CPU<Impl>::trap(const Fault &fault, ThreadID tid,
                     const StaticInstPtr &inst)
{       
   // Pass the thread's TC into the invoke method.
   fault->invoke(this->threadContexts[tid], inst);
}      

Generate trap event

        
      
template <class Impl>
void
DefaultCommit<Impl>::generateTrapEvent(ThreadID tid, Fault inst_fault)
{
   DPRINTF(Commit, "Generating trap event for [tid:%i]\n", tid);

   EventFunctionWrapper *trap = new EventFunctionWrapper(
       [this, tid]{ processTrapEvent(tid); },
       "Trap", true, Event::CPU_Tick_Pri);

   Cycles latency = dynamic_pointer_cast<SyscallRetryFault>(inst_fault) ?
                    cpu->syscallRetryLatency : trapLatency;

   cpu->schedule(trap, cpu->clockEdge(latency));
   trapInFlight[tid] = true;
   thread[tid]->trapPending = true;
}

This post is licensed under CC BY 4.0 by the author.