---

interrupt.h

Go to the documentation of this file.

// interrupt.h 
//      Data structures to emulate low-level interrupt hardware.
//
//      The hardware provides a routine (SetLevel) to enable or disable
//      interrupts.
//
//      In order to emulate the hardware, we need to keep track of all
//      interrupts the hardware devices would cause, and when they
//      are supposed to occur.  
//
//      This module also keeps track of simulated time.  Time advances
//      only when the following occur: 
//              interrupts are re-enabled
//              a user instruction is executed
//              there is nothing in the ready queue
//
//      As a result, unlike real hardware, interrupts (and thus time-slice 
//      context switches) cannot occur anywhere in the code where interrupts
//      are enabled, but rather only at those places in the code where 
//      simulated time advances (so that it becomes time to invoke an
//      interrupt in the hardware simulation).
//
//      NOTE: this means that incorrectly synchronized code may work
//      fine on this hardware simulation (even with randomized time slices),
//      but it wouldn't work on real hardware.  (Just because we can't
//      always detect when your program would fail in real life, does not 
//      mean it's ok to write incorrectly synchronized code!)
//
//  DO NOT CHANGE -- part of the machine emulation
//
// Copyright (c) 1992-1996 The Regents of the University of California.
// All rights reserved.  See copyright.h for copyright notice and limitation 
// of liability and disclaimer of warranty provisions.

#ifndef INTERRUPT_H
#define INTERRUPT_H

#include "copyright.h"
#include "list.h"
#include "callback.h"

enum IntStatus { IntOff, IntOn };

enum MachineStatus {IdleMode, SystemMode, UserMode};

enum IntType { TimerInt, DiskInt, ConsoleWriteInt, ConsoleReadInt, 
                        ElevatorInt, NetworkSendInt, NetworkRecvInt};


class PendingInterrupt {
  public:
    PendingInterrupt(CallBackObj *callOnInt, int time, IntType kind);

    CallBackObj *callOnInterrupt;

    
    int when;                   
    IntType type;               
};


class Interrupt {
  public:
    Interrupt();                
    ~Interrupt();               
    
    IntStatus SetLevel(IntStatus level);

    void Enable() { (void) SetLevel(IntOn); }
    IntStatus getLevel() {return level;}
    
    void Idle();                



    void Halt();                
    
    void YieldOnReturn();       


    MachineStatus getStatus() { return status; } 
    void setStatus(MachineStatus st) { status = st; }

    bool AnyFutureInterrupts() { return !pending->IsEmpty(); }

    void DumpState();           
    

    // NOTE: the following are internal to the hardware simulation code.
    // DO NOT call these directly.  I should make them "private",
    // but they need to be public since they are called by the
    // hardware device simulators.

    void Schedule(CallBackObj *callTo, int when, IntType type);
    
    void OneTick();             //"< Advance simulated time

  private:
    IntStatus level;            
    SortedList<PendingInterrupt *> *pending;            
    bool inHandler;             
    bool yieldOnReturn;         

    MachineStatus status;       

    // these functions are internal to the interrupt simulation code

    bool CheckIfDue(bool advanceClock); 

    void ChangeLevel(IntStatus old,     
                        IntStatus now); 
};

#endif 

---