simeventscheduler.java

p2p仿真

/*
 * @(#)SimEventScheduler.java	ver 1.2  6/20/2005
 *
 * Copyright 2005 Weishuai Yang ([e-mail]). 
 * All rights reserved.
 * 
 */

package gps.event;

import java.util.PriorityQueue;
import java.util.logging.Logger;


/**
 * Discrete event driver. It maintains an event queue for events to 
 * be triggered; provides functions for adding and canceling events;
 * also maintains current virtual time.
 *
 * @author  Weishuai Yang
 * @version 1.2,  6/20/2005
 */

public final class SimEventScheduler {
	/**
	 * singleton instance
	 */
	private static SimEventScheduler mInstance = null;
	
	/**
	 * To achieve best performance, a priority queue based on heap is used 
	 * so that all the events don't have to be sorted every time.
	 */	
	private	PriorityQueue mEventQueue = null; 

	/**
	 * current time stamp
	 */
	private double current = 0;
	
	/**
	 * event logger
	 */
	private static Logger mLog = Logger.getLogger(SimEventScheduler.class.getCanonicalName());
	/**
	 * trace logger
	 */
	private static Logger mTraceLog = Logger.getLogger("Trace");

	
	/**
	 * initialize event queue 
	 *
	 */
	private SimEventScheduler() {
		mEventQueue = new PriorityQueue(300);  //set initial capacity
	}

	/**
	 * gets event log
	 */
	public static Logger getEventLog(){
		return mLog;
	}


	/**
	 * adds a SimEvent to the event queue
	 *
	 * @param e the new event to be added to the queue
	 */
	public synchronized boolean enqueue(SimEvent e) {
		if(e.getTimeStamp()<current){
			mLog.warning("trying to insert an event scheduled at past: " + e );
			return false;
		}
		//this remove operation is a little bit tricky.
		//refer to SimEvent.CompareTo() 
		mEventQueue.remove(e);

		e.setEventID();
		mLog.info(e.format("E"));
		return mEventQueue.offer(e);
	}

	/**
	 * gets a most prioriety SimEvent from the heap queue. 
	 * @return event on the head of the queue, null if no events in the queue
	 */
	public synchronized SimEvent dequeue() {
		SimEvent e= (SimEvent)mEventQueue.poll();

		if(e==null) return null;
		
		if(e.getTimeStamp()<current){
			return null;
		}

		current = e.getTimeStamp();
		mLog.info(e.format("D"));
		return e;
	}

	/**
	 * cancels a scheduled event, and remove it from the queue
	 *
	 * @param e event to be canceled
	 */
	public synchronized boolean cancel(SimEvent e) {
	    if(e==null) return false;
	    if(e.getTimeStamp()<current) return false;
		mLog.info(e.format("C"));
		return mEventQueue.remove(e);
	}

	/**
	 * gets current virtual time in simulation. 
	 * @return current virtual time
	 */
	public synchronized double getCurrent(){
		return current;
	}

	/**
	 * gets scheduler singleton instance 
	 * @return singleton instance
	 */
	public static synchronized SimEventScheduler getInstance() {
		if(mInstance==null)
			mInstance=new SimEventScheduler();
		return mInstance;
	}
	

	/**
	 * empties the event queue, logs discharged events in event log
	 *
	 */
	public synchronized void discharge(){
		SimEvent e=null;		
		while (true) {
			e = (SimEvent)mEventQueue.poll();
			if (e != null){
				mLog.info(e.format("U"));
			}
			else return;
		} 
	}
	
	/**
	 * empties the event queue without log, and reset current time to 0.
	 *
	 */
	public synchronized void reset(){
		mEventQueue.clear();
		current = 0;
	}
	/**
	 * for test purpose
	 * @param args inputs
	 */
	public static void main(String[] args) {
		/*
	    SimEvent e1=new SimEvent(1, 0, (SimEventHandler)null, null);
		SimEvent e2=new SimEvent(1, 0, (SimEventHandler)null, null);
		SimEventScheduler mScheduler=SimEventScheduler.getInstance();
		mScheduler.enqueue(e1);
		mScheduler.enqueue(e2);
		mScheduler.discharge();
		*/
	}
}