p1/machine/Interrupt.java

// PART OF THE MACHINE SIMULATION. DO NOT CHANGE.

package nachos.machine;

import nachos.security.*;

import java.util.TreeSet;
import java.util.Iterator;
import java.util.SortedSet;

/**
 * The <tt>Interrupt</tt> class emulates low-level interrupt hardware. The
 * hardware provides a method (<tt>setStatus()</tt>) to enable or disable
 * interrupts.
 *
 * <p>
 * In order to emulate the hardware, we need to keep track of all pending
 * interrupts the hardware devices would cause, and when they are supposed to
 * occur.
 *
 * <p>
 * This module also keeps track of simulated time. Time advances only when the
 * following occur:
 * <ul>
 * <li>interrupts are enabled, when they were previously disabled
 * <li>a MIPS instruction is executed
 * </ul>
 *
 * <p>
 * As a result, unlike real hardware, interrupts (including time-slice context
 * switches) cannot occur just 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 for the hardware simulation to invoke an
 * interrupt handler).
 *
 * <p>
 * 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. But even though Nachos can't always detect when your program
 * would fail in real life, you should still write properly synchronized code.
 */
public final class Interrupt {
    /**
     * Allocate a new interrupt controller.
     *
     * @param	privilege      	encapsulates privileged access to the Nachos
     *				machine.
     */
    public Interrupt(Privilege privilege) {
	System.out.print(" interrupt");
	
	this.privilege = privilege;
	privilege.interrupt = new InterruptPrivilege();
	
	enabled = false;
	pending = new TreeSet<PendingInterrupt>();
    }

    /**
     * Enable interrupts. This method has the same effect as
     * <tt>setStatus(true)</tt>.
     */    
    public void enable() {
	setStatus(true);
    }

    /**
     * Disable interrupts and return the old interrupt state. This method has
     * the same effect as <tt>setStatus(false)</tt>.
     *
     * @return	<tt>true</tt> if interrupts were enabled.
     */
    public boolean disable() {
	return setStatus(false);
    }

    /**
     * Restore interrupts to the specified status. This method has the same
     * effect as <tt>setStatus(<i>status</i>)</tt>.
     *
     * @param	status	<tt>true</tt> to enable interrupts.
     */
    public void restore(boolean status) {
	setStatus(status);
    }

    /**
     * Set the interrupt status to be enabled (<tt>true</tt>) or disabled
     * (<tt>false</tt>) and return the previous status. If the interrupt
     * status changes from disabled to enabled, the simulated time is advanced.
     *
     * @param	status		<tt>true</tt> to enable interrupts.
     * @return			<tt>true</tt> if interrupts were enabled.
     */
    public boolean setStatus(boolean status) {
	boolean oldStatus = enabled;
	enabled = status;
	
	if (oldStatus == false && status == true)
	    tick(true);

	return oldStatus;
    }

    /**
     * Tests whether interrupts are enabled.
     *
     * @return	<tt>true</tt> if interrupts are enabled.
     */
    public boolean enabled() {
	return enabled;
    }

    /**
     * Tests whether interrupts are disabled.
     *
     * @return <tt>true</tt> if interrupts are disabled.
     */
    public boolean disabled() {
	return !enabled;
    }

    private void schedule(long when, String type, Runnable handler) {
	Lib.assertTrue(when>0);
	
	long time = privilege.stats.totalTicks + when;
	PendingInterrupt toOccur = new PendingInterrupt(time, type, handler);

	Lib.debug(dbgInt,
		  "Scheduling the " + type +
		  " interrupt handler at time = " + time);

	pending.add(toOccur);
    }

    private void tick(boolean inKernelMode) {
	Stats stats = privilege.stats;

	if (inKernelMode) {
	    stats.kernelTicks += Stats.KernelTick;
	    stats.totalTicks += Stats.KernelTick;
	}
	else {
	    stats.userTicks += Stats.UserTick;
	    stats.totalTicks += Stats.UserTick;
	}

	if (Lib.test(dbgInt))
	    System.out.println("== Tick " + stats.totalTicks + " ==");

	enabled = false;
	checkIfDue();
	enabled = true;
    }

    private void checkIfDue() {
	long time = privilege.stats.totalTicks;

	Lib.assertTrue(disabled());

	if (Lib.test(dbgInt))
	    print();

	if (pending.isEmpty())
	    return;

	if (((PendingInterrupt) pending.first()).time > time)
	    return;

	Lib.debug(dbgInt, "Invoking interrupt handlers at time = " + time);
	
	while (!pending.isEmpty() &&
	       ((PendingInterrupt) pending.first()).time <= time) {
	    PendingInterrupt next = (PendingInterrupt) pending.first();
	    pending.remove(next);

	    Lib.assertTrue(next.time <= time);

	    if (privilege.processor != null)
		privilege.processor.flushPipe();

	    Lib.debug(dbgInt, "  " + next.type);
			
	    next.handler.run();
	}

	Lib.debug(dbgInt, "  (end of list)");
    }

    private void print() {
	System.out.println("Time: " + privilege.stats.totalTicks
			   + ", interrupts " + (enabled ? "on" : "off"));
	System.out.println("Pending interrupts:");

	for (Iterator i=pending.iterator(); i.hasNext(); ) {
	    PendingInterrupt toOccur = (PendingInterrupt) i.next();
	    System.out.println("  " + toOccur.type +
			       ", scheduled at " + toOccur.time);
	}

	System.out.println("  (end of list)");
    }

    private class PendingInterrupt implements Comparable {
	PendingInterrupt(long time, String type, Runnable handler) {
	    this.time = time;
	    this.type = type;
	    this.handler = handler;
	    this.id = numPendingInterruptsCreated++;
	}

	public int compareTo(Object o) {
	    PendingInterrupt toOccur = (PendingInterrupt) o;

	    // can't return 0 for unequal objects, so check all fields
	    if (time < toOccur.time)
		return -1;
	    else if (time > toOccur.time)
		return 1;
	    else if (id < toOccur.id)
		return -1;
	    else if (id > toOccur.id)
		return 1;
	    else
		return 0;
	}

	long time;
	String type;
	Runnable handler;

	private long id;
    }
    
    private long numPendingInterruptsCreated = 0;

    private Privilege privilege;

    private boolean enabled;
    private TreeSet<PendingInterrupt> pending;

    private static final char dbgInt = 'i';

    private class InterruptPrivilege implements Privilege.InterruptPrivilege {
	public void schedule(long when, String type, Runnable handler) {
	    Interrupt.this.schedule(when, type, handler);
	}

	public void tick(boolean inKernelMode) {
	    Interrupt.this.tick(inKernelMode);
	}
    }
}