/*

* Copyright 1990-2008, Mark Little, University of Newcastle upon Tyne

* and others contributors as indicated

* by the @authors tag. All rights reserved.

* See the copyright.txt in the distribution for a

* full listing of individual contributors.

* This copyrighted material is made available to anyone wishing to use,

* modify, copy, or redistribute it subject to the terms and conditions

* of the GNU Lesser General Public License, v. 2.1.

* This program is distributed in the hope that it will be useful, but WITHOUT A

* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A

* PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

* You should have received a copy of the GNU Lesser General Public License,

* v.2.1 along with this distribution; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA 02110-1301, USA.

*

* (C) 1990-2008,

*/

/*

* Copyright (C) 1996, 1997, 1998,

*

* Department of Computing Science,

* The University,

* Newcastle upon Tyne,

* UK.

*

* $Id: Scheduler.java,v 1.3 1998/12/07 08:28:10 nmcl Exp $

*/

package org.javasim;

import java.util.NoSuchElementException;

import org.javasim.internal.SimulationProcessIterator;

import org.javasim.internal.SimulationProcessList;

/**

* This is the scheduler: the heart of the simulation system.

*

* Note: unlike in SIMULA, an active process is removed from the simulation

* queue prior to being activated.

*

* @author marklittle

*

*/

public class Scheduler extends Thread

{

/**

* Get the current simulation time.

*

* @return the current simulation time.

*/

public static double currentTime ()

{

return Scheduler.SimulatedTime;

}

/**

* This routine resets the simulation time to zero and removes all

* entries from the scheduler queue (as their times may no longer

* be valid). Whatever operation caused the processes to become

* suspended will raise the RestartSimulation exception, which the

* application should catch. It should then perform any work necessary

* to put the process back in a state ready for restarting the simulation

* before calling Cancel on the process.

*

* @throws SimulationException if an error occurs.

*/

static synchronized void reset () throws SimulationException

{

boolean finished = false;

SimulationProcess tmp = SimulationProcess.current();

// set resetting process to idle

Scheduler.unschedule(tmp); // remove from queue

do

{

try

{

tmp = Scheduler.ReadyQueue.remove();

tmp.deactivate();

}

catch (NoSuchElementException e)

{

finished = true;

}

} while (!finished);

finished = false;

SimulationProcessIterator iter = new SimulationProcessIterator(SimulationProcess.allProcesses);

do

{

try

{

tmp = iter.get();

/*

* Every process must be in Suspend, so we call Resume

* and get each one to check whether the simulation is

* restarting. If it is, it raises an exception and waits

* for the user to cancel the process after setting it

* to become ready to restart.

*/

tmp.resumeProcess();

/*

* Wait for this process to become idle again.

*/

while (!tmp.idle())

Thread.yield();

}

catch (NullPointerException e)

{

finished = true;

}

} while (!finished);

Scheduler.SimulatedTime = 0.0;

SimulationProcess.Current = null;

SimulationProcess.allProcesses = new SimulationProcessList();

}

private Scheduler ()

{

}

/**

* It is possible that the currently active process may remove itself

* from the simulation queue. In which case we don't want to suspend the

* process since it needs to continue to run. The return value indicates

* whether or not to call suspend on the currently active process.

*/

static synchronized boolean schedule () throws SimulationException

{

if (Simulation.isStarted())

{

SimulationProcess p = SimulationProcess.current();

try

{

/*

* For some reason when executing tests in junit an old and dead

* thread appears in the simulation queue. Have only ever seen this

* be a single thread instance, but it is reproducible every time.

*

* https://github.com/nmcl/JavaSim/issues/64

*

* Will try to find out what actually causes this and remove the

* workaround eventually.

*

* https://github.com/nmcl/JavaSim/issues/76

*/

SimulationProcess.Current = Scheduler.ReadyQueue.remove();

boolean done = true;

do

{

if (SimulationProcess.Current != null)

{

if (SimulationProcess.Current.getThreadGroup() == null)

{

SimulationProcess.Current = Scheduler.ReadyQueue.remove();

p = SimulationProcess.current();

done = false;

}

else

done = true;

}

else

throw new NoSuchElementException();

}

while (!done);

}

catch (NoSuchElementException e)

{

System.out.println("Simulation queue empty.");

return false;

}

catch (NullPointerException e)

{

System.out.println("Simulation queue empty.");

return false;

}

if (SimulationProcess.Current.evtime() < 0)

throw new SimulationException("Invalid SimulationProcess wakeup time.");

else

Scheduler.SimulatedTime = SimulationProcess.Current.evtime();

if (p != SimulationProcess.Current)

{

// Simulation.printQueue();

SimulationProcess.Current.resumeProcess();

return true;

}

else

return false;

}

else

throw new SimulationException("Simulation not started.");

}

static synchronized void unschedule (SimulationProcess p)

{

try

{

Scheduler.ReadyQueue.remove(p); // remove from queue

}

catch (NoSuchElementException e)

{

}

p.deactivate();

}

static SimulationProcessList getQueue ()

{

synchronized (theScheduler)

{

return ReadyQueue;

}

}

static double getSimulationTime ()

{

synchronized (theScheduler)

{

return SimulatedTime;

}

}

private static double SimulatedTime = 0.0;

private static SimulationProcessList ReadyQueue = new SimulationProcessList();

static Scheduler theScheduler = new Scheduler();

}