ElevatorBank.java

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

package nachos.machine;

import nachos.security.*;
import nachos.threads.KThread;
import nachos.threads.Semaphore;

import java.util.Vector;
import java.util.LinkedList;
import java.util.Iterator;

/**
 * A bank of elevators.
 */
public final class ElevatorBank implements Runnable {
    /** Indicates an elevator intends to move down. */
    public static final int dirDown = -1;
    /** Indicates an elevator intends not to move. */
    public static final int dirNeither = 0;
    /** Indicates an elevator intends to move up. */
    public static final int dirUp = 1;

    /**
     * Allocate a new elevator bank.
     *
     * @param	privilege      	encapsulates privileged access to the Nachos
     *				machine.
     */
    public ElevatorBank(Privilege privilege) {
	System.out.print(" elevators");
	
	this.privilege = privilege;

	simulationStarted = false;
    }

    /**
     * Initialize this elevator bank with the specified number of elevators and
     * the specified number of floors. The software elevator controller must
     * also be specified. This elevator must not already be running a
     * simulation.
     *
     * @param	numElevators	the number of elevators in the bank.
     * @param	numFloors	the number of floors in the bank.
     * @param	controller	the elevator controller.
     */
    public void init(int numElevators, int numFloors,
		     ElevatorControllerInterface controller) {
	Lib.assertTrue(!simulationStarted);
	
	this.numElevators = numElevators;
	this.numFloors = numFloors;

	manager = new ElevatorManager(controller);
	
	elevators = new ElevatorState[numElevators];
	for (int i=0; i<numElevators; i++)
	    elevators[i] = new ElevatorState(0);

	numRiders = 0;
	ridersVector = new Vector<RiderControls>();

	enableGui = false;
	gui = null;
    }

    /**
     * Add a rider to the simulation. This method must not be called after
     * <tt>run()</tt> is called.
     *
     * @param	rider	the rider to add.
     * @param	floor	the floor the rider will start on.
     * @param	stops	the array to pass to the rider's <tt>initialize()</tt>
     *			method.
     * @return	the controls that will be given to the rider.
     */
    public RiderControls addRider(RiderInterface rider,
				  int floor, int[] stops) {
	Lib.assertTrue(!simulationStarted);
	
	RiderControls controls = new RiderState(rider, floor, stops);
	ridersVector.addElement(controls);
	numRiders++;
	return controls;
    }

    /**
     * Create a GUI for this elevator bank.
     */
    public void enableGui() {
	Lib.assertTrue(!simulationStarted);
	Lib.assertTrue(Config.getBoolean("ElevatorBank.allowElevatorGUI"));

	enableGui = true;
    }

    /**
     * Run a simulation. Initialize all elevators and riders, and then
     * fork threads to each of their <tt>run()</tt> methods. Return when the
     * simulation is finished.
     */
    public void run() {
	Lib.assertTrue(!simulationStarted);
	simulationStarted = true;
	
	riders = new RiderState[numRiders];
	ridersVector.toArray(riders);

	if (enableGui) {
	    privilege.doPrivileged(new Runnable() {
		public void run() { initGui(); }
	    });
	}

	for (int i=0; i<numRiders; i++)
	    riders[i].initialize();
	manager.initialize();

	for (int i=0; i<numRiders; i++)
	    riders[i].run();
	manager.run();

	for (int i=0; i<numRiders; i++)
	    riders[i].join();
	manager.join();

	simulationStarted = false;
    }

    private void initGui() {
	int[] numRidersPerFloor = new int[numFloors];
	for (int floor=0; floor<numFloors; floor++)
	    numRidersPerFloor[floor] = 0;
	
	for (int rider=0; rider<numRiders; rider++)
	    numRidersPerFloor[riders[rider].floor]++;
	
	gui = new ElevatorGui(numFloors, numElevators, numRidersPerFloor);
    }	

    /**
     * Tests whether this module is working.
     */
    public static void selfTest() {
	new ElevatorTest().run();
    }

    void postRiderEvent(int event, int floor, int elevator) {
	int direction = dirNeither;
	if (elevator != -1) {
	    Lib.assertTrue(elevator >= 0 && elevator < numElevators);
	    direction = elevators[elevator].direction;
	}

	RiderEvent e = new RiderEvent(event, floor, elevator, direction);
	for (int i=0; i<numRiders; i++) {
	    RiderState rider = riders[i];
	    if ((rider.inElevator && rider.elevator == e.elevator) ||
		(!rider.inElevator && rider.floor == e.floor)) {
		rider.events.add(e);
		rider.schedule(1);
	    }
	}
    }

    private class ElevatorManager implements ElevatorControls {
	ElevatorManager(ElevatorControllerInterface controller) {
	    this.controller = controller;

	    interrupt = new Runnable() { public void run() { interrupt(); }};
	}
	
	public int getNumFloors() {
	    return numFloors;
	}
	
	public int getNumElevators() {
	    return numElevators;
	}
	
	public void setInterruptHandler(Runnable handler) {
	    this.handler = handler;	    
	}
	
	public void openDoors(int elevator) {
	    Lib.assertTrue(elevator >= 0 && elevator < numElevators);
	    postRiderEvent(RiderEvent.eventDoorsOpened,
			   elevators[elevator].openDoors(), elevator);

	    if (gui != null) {
		if (elevators[elevator].direction == dirUp)
		    gui.clearUpButton(elevators[elevator].floor);
		else if (elevators[elevator].direction == dirDown)
		    gui.clearDownButton(elevators[elevator].floor);

		gui.openDoors(elevator);
	    }
	}
			   
        public void closeDoors(int elevator) {
	    Lib.assertTrue(elevator >= 0 && elevator < numElevators);
	    postRiderEvent(RiderEvent.eventDoorsClosed,
			   elevators[elevator].closeDoors(), elevator);

	    if (gui != null)
		gui.closeDoors(elevator);
	}

	public boolean moveTo(int floor, int elevator) {
	    Lib.assertTrue(floor >= 0 && floor < numFloors);
	    Lib.assertTrue(elevator >= 0 && elevator < numElevators);

	    if (!elevators[elevator].moveTo(floor))
		return false;
	    
	    schedule(Stats.ElevatorTicks);
	    return true;
	}
	
	public int getFloor(int elevator) {
	    Lib.assertTrue(elevator >= 0 && elevator < numElevators);
	    return elevators[elevator].floor;
	}
	
	public void setDirectionDisplay(int elevator, int direction) {
	    Lib.assertTrue(elevator >= 0 && elevator < numElevators);
	    elevators[elevator].direction = direction;

	    if (elevators[elevator].doorsOpen) {
		postRiderEvent(RiderEvent.eventDirectionChanged,
			       elevators[elevator].floor, elevator);
	    }

	    if (gui != null) {
		if (elevators[elevator].doorsOpen) {
		    if (direction == dirUp)
			gui.clearUpButton(elevators[elevator].floor);
		    else if (direction == dirDown)
			gui.clearDownButton(elevators[elevator].floor);
		}
	    
		gui.setDirectionDisplay(elevator, direction);
	    }
	}

	public void finish() {
	    finished = true;
	    
	    Lib.assertTrue(KThread.currentThread() == thread);
	    
	    done.V();
	    KThread.finish();
	}
	
	public ElevatorEvent getNextEvent() {
	    if (events.isEmpty())
		return null;
	    else
		return (ElevatorEvent) events.removeFirst();
	}

	void schedule(int when) {
	    privilege.interrupt.schedule(when, "elevator", interrupt);
	}

        void postEvent(int event, int floor, int elevator, boolean schedule) {
	    events.add(new ElevatorEvent(event, floor, elevator));

	    if (schedule)
		schedule(1);
	}

	void interrupt() {
	    for (int i=0; i<numElevators; i++) {
		if (elevators[i].atNextFloor()) {
		    if (gui != null)
			gui.elevatorMoved(elevators[i].floor, i);
		    
		    if (elevators[i].atDestination()) {
			postEvent(ElevatorEvent.eventElevatorArrived,
				  elevators[i].destination, i, false);
		    }
		    else {
			elevators[i].nextETA += Stats.ElevatorTicks;
			privilege.interrupt.schedule(Stats.ElevatorTicks,
						   "elevator",
						   interrupt);
		    }
		}
	    }
	    
	    if (!finished && !events.isEmpty() && handler != null)
		handler.run();
	}

	void initialize() {
	    controller.initialize(this);
	}

	void run() {
	    thread = new KThread(controller);
	    thread.setName("elevator controller");
	    thread.fork();
	}

	void join() {
	    postEvent(ElevatorEvent.eventRidersDone, -1, -1, true);
	    done.P();
	}
	    
	ElevatorControllerInterface controller;
	Runnable interrupt;
	KThread thread;

	Runnable handler = null;
	LinkedList<ElevatorEvent> events = new LinkedList<ElevatorEvent>();
	Semaphore done = new Semaphore(0);
	boolean finished = false;
    }

    private class ElevatorState {
	ElevatorState(int floor) {
	    this.floor = floor;
	    destination = floor;
	}

	int openDoors() {
	    Lib.assertTrue(!doorsOpen && !moving);
	    doorsOpen = true;
	    return floor;
	}

	int closeDoors() {
	    Lib.assertTrue(doorsOpen);
	    doorsOpen = false;
	    return floor;
	}

	boolean moveTo(int newDestination) {
	    Lib.assertTrue(!doorsOpen);

	    if (!moving) {
		// can't move to current floor
		if (floor == newDestination)
		    return false;
		
		destination = newDestination;
		nextETA = Machine.timer().getTime() + Stats.ElevatorTicks;

		moving = true;
		return true;
	    }
	    else {
		// moving, shouldn't be at destination
		Lib.assertTrue(floor != destination);

		// make sure it's ok to stop
		if ((destination > floor && newDestination <= floor) ||
		    (destination < floor && newDestination >= floor))
		    return false;

		destination = newDestination;
		return true;		
	    }
	}

	boolean enter(RiderState rider, int onFloor) {
	    Lib.assertTrue(!riders.contains(rider));
	    
	    if (!doorsOpen || moving || onFloor != floor ||
		riders.size() == maxRiders)
		return false;

	    riders.addElement(rider);
	    return true;
	}

	boolean exit(RiderState rider, int onFloor) {
	    Lib.assertTrue(riders.contains(rider));
	    
	    if (!doorsOpen || moving || onFloor != floor)
		return false;

	    riders.removeElement(rider);
	    return true;
	}

	boolean atNextFloor() {
	    if (!moving || Machine.timer().getTime() < nextETA)
		return false;

	    Lib.assertTrue(destination != floor);
	    if (destination > floor)
		floor++;
	    else
		floor--;

	    for (Iterator i=riders.iterator(); i.hasNext(); ) {
		RiderState rider = (RiderState) i.next();

		rider.floor = floor;
	    }

	    return true;
	}

	boolean atDestination() {
	    if (!moving || destination != floor)
		return false;

	    moving = false;
	    return true;
	}

        static final int maxRiders = 4;

	int floor, destination;
	long nextETA;
	
	boolean doorsOpen = false, moving = false;
	int direction = dirNeither;
	public Vector<RiderState> riders = new Vector<RiderState>();
    }

    private class RiderState implements RiderControls {
	RiderState(RiderInterface rider, int floor, int[] stops) {
	    this.rider = rider;
	    this.floor = floor;
	    this.stops = stops;

	    interrupt = new Runnable() { public void run() { interrupt(); }};
	}
	
	public int getNumFloors() {
	    return numFloors;
	}
	
	public int getNumElevators() {
	    return numElevators;
	}
	
	public void setInterruptHandler(Runnable handler) {
	    this.handler = handler;
	}
	
	public int getFloor() {
	    return floor;
	}

	public int[] getFloors() {
	    int[] array = new int[floors.size()];
	    for (int i=0; i<array.length; i++)
		array[i] = ((Integer) floors.elementAt(i)).intValue();

	    return array;
	}
	
	public int getDirectionDisplay(int elevator) {
	    Lib.assertTrue(elevator >= 0 && elevator < numElevators);
	    return elevators[elevator].direction;
	}
	
	public RiderEvent getNextEvent() {
	    if (events.isEmpty())
		return null;
	    else
		return (RiderEvent) events.removeFirst();
	}

	public boolean pressDirectionButton(boolean up) {
	    if (up)
		return pressUpButton();
	    else
		return pressDownButton();
	}
	
	public boolean pressUpButton() {
	    Lib.assertTrue(!inElevator && floor < numFloors-1);

	    for (int elevator=0; elevator<numElevators; elevator++) {
		if (elevators[elevator].doorsOpen &&
		    elevators[elevator].direction == ElevatorBank.dirUp &&
		    elevators[elevator].floor == floor)
		    return false;
	    }
	    
	    manager.postEvent(ElevatorEvent.eventUpButtonPressed,
			      floor, -1, true);

	    if (gui != null)
		gui.pressUpButton(floor);

	    return true;
	}
	
	public boolean pressDownButton() {
	    Lib.assertTrue(!inElevator && floor > 0);
	    
	    for (int elevator=0; elevator<numElevators; elevator++) {
		if (elevators[elevator].doorsOpen &&
		    elevators[elevator].direction == ElevatorBank.dirDown &&
		    elevators[elevator].floor == floor)
		    return false;
	    }
	    
	    manager.postEvent(ElevatorEvent.eventDownButtonPressed,
			      floor, -1, true);

	    if (gui != null)
		gui.pressDownButton(floor);

	    return true;
	}
	
	public boolean enterElevator(int elevator) {
	    Lib.assertTrue(!inElevator &&
		       elevator >= 0 && elevator < numElevators);	    
	    if (!elevators[elevator].enter(this, floor))
		return false;

	    if (gui != null)
		gui.enterElevator(floor, elevator);

	    inElevator = true;
	    this.elevator = elevator;
	    return true;	    
	}
	
	public boolean pressFloorButton(int floor) {
	    Lib.assertTrue(inElevator && floor >= 0 && floor < numFloors);

	    if (elevators[elevator].doorsOpen &&
		elevators[elevator].floor == floor)
		return false;
	    
	    manager.postEvent(ElevatorEvent.eventFloorButtonPressed,
			      floor, elevator, true);

	    if (gui != null)
		gui.pressFloorButton(floor, elevator);

	    return true;
	}
	    
	public boolean exitElevator(int floor) {
	    Lib.assertTrue(inElevator && floor >= 0 && floor < numFloors);

	    if (!elevators[elevator].exit(this, floor))
		return false;

	    inElevator = false;
	    floors.add(new Integer(floor));

	    if (gui != null)
		gui.exitElevator(floor, elevator);

	    return true;
	}

	public void finish() {
	    finished = true;
	    
	    int[] floors = getFloors();
	    Lib.assertTrue(floors.length == stops.length);
	    for (int i=0; i<floors.length; i++)
		Lib.assertTrue(floors[i] == stops[i]);
	    
	    Lib.assertTrue(KThread.currentThread() == thread);
	    
	    done.V();
	    KThread.finish();
	}

	void schedule(int when) {
	    privilege.interrupt.schedule(when, "rider", interrupt);
	}

	void interrupt() {
	    if (!finished && !events.isEmpty() && handler != null)
		handler.run();
	}

	void initialize() {
	    rider.initialize(this, stops);
	}

	void run() {
	    thread = new KThread(rider);
	    thread.setName("rider");
	    thread.fork();
	}

	void join() {
	    done.P();
	}

    	RiderInterface rider;
	boolean inElevator = false, finished = false;
	int floor, elevator;
	int[] stops;
	Runnable interrupt, handler = null;
	LinkedList<RiderEvent> events = new LinkedList<RiderEvent>();
	Vector<Integer> floors = new Vector<Integer>();
	Semaphore done = new Semaphore(0);
	KThread thread;
    }

    private int numFloors, numElevators;
    private ElevatorManager manager;
    private ElevatorState[] elevators;

    private int numRiders;
    private Vector<RiderControls> ridersVector;
    private RiderState[] riders;
    
    private boolean simulationStarted, enableGui;
    private Privilege privilege;
    private ElevatorGui gui;
}