Added virtual timer to scale time factors

plugins/org.yakindu.sct.simulation.core/META-INF/MANIFEST.MF

@@ -21,4 +21,5 @@ Export-Package: org.yakindu.sct.simulation.core,
  org.yakindu.sct.simulation.core.launch,
  org.yakindu.sct.simulation.core.runtime,
  org.yakindu.sct.simulation.core.runtime.impl,
+ org.yakindu.sct.simulation.core.runtime.timer,
  org.yakindu.sct.simulation.core.util

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/IExecutionContext.java

@@ -39,7 +39,7 @@ public interface IExecutionContext {
 	 * Returns a readonly (!) List with all currently raised events
 	 */
 	public List<ExecutionEvent> getRaisedEvents();
-	
+
 	/**
 	 * Clears the collection of raised events
 	 */
@@ -49,7 +49,8 @@ public interface IExecutionContext {
 	 * Raises an event with an value, can be null
 	 * 
 	 * @throws ExecutionException
-	 *             if the value is incompatible with the declared event type or the Event can not be found
+	 *             if the value is incompatible with the declared event type or
+	 *             the Event can not be found
 	 */
 	public void raiseEvent(String name, Object value) throws ExecutionException;
 
@@ -62,7 +63,7 @@ public interface IExecutionContext {
 	 * Returns a readonly (!) List of all variables
 	 */
 	public List<ExecutionVariable> getVariables();
-	
+
 	/**
 	 * Declares a new Variable
 	 */
@@ -83,17 +84,18 @@ public interface IExecutionContext {
 	 * Returns a Set with all currently active states
 	 */
 	public Set<RegularState> getActiveLeafStates();
+
 	/**
 	 * Returns a set with all active leaf states including parents
 	 */
 	public Set<RegularState> getAllActiveStates();
-	
+
 	/**
 	 * Returns the active state configuration
 	 */
 	public ExecutionState[] getStateConfiguration();
 
-	public  void initStateConfigurationVector(int size);
+	public void initStateConfigurationVector(int size);
 
 	/**
 	 * Calls a declared operation
@@ -111,5 +113,7 @@ public interface IExecutionContext {
 	public void removeExecutionContextListener(
 			IExecutionContextListener listener);
 
+	public double getTimeScaleFactor();
 
+	public void setTimeScaleFactor(double factor);
 }

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/IExecutionContextListener.java

@@ -29,4 +29,8 @@ public interface IExecutionContextListener {
 	 * called when a variable value changed
 	 */
 	public void variableValueChanged(ExecutionVariable variable);
+	/**
+	 * Called when the timeScaleFactor changed
+	 */
+	public void timeScaleFactorChanged(double oldFactor, double newFactor);
 }

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/impl/AbstractExecutionContext.java

@@ -59,5 +59,13 @@ public abstract class AbstractExecutionContext implements IExecutionContext {
 			}
 		}
 	}
+	
+	public void notifyTimeScaleFactorChanged(double oldFactor, double newFactor) {
+		synchronized (_listeners) {
+			for (IExecutionContextListener listener : _listeners) {
+				listener.timeScaleFactorChanged(oldFactor, newFactor);
+			}
+		}
+	}
 
 }

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/impl/CycleBasedExecutionFacadeController.java

@@ -29,7 +29,7 @@ public class CycleBasedExecutionFacadeController extends
 		AbstractExecutionFacadeController {
 
 	private Timer timer;
-	
+
 	private long cyclePeriod;
 
 	public CycleBasedExecutionFacadeController(IExecutionFacade facade,
@@ -45,7 +45,8 @@ public class CycleBasedExecutionFacadeController extends
 					facade.runCycle();
 					scheduleCycle();
 				}
-			}, cyclePeriod);
+			}, (long) (cyclePeriod * facade.getExecutionContext()
+					.getTimeScaleFactor()));
 	}
 
 	public void start() {

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/impl/EventDrivenExecutionFacadeController.java

@@ -33,7 +33,7 @@ public class EventDrivenExecutionFacadeController extends
 	private Thread cycleRunner;
 
 	private BlockingQueue<ExecutionEvent> events;
-
+	
 	public EventDrivenExecutionFacadeController(IExecutionFacade facade) {
 		super(facade);
 		facade.getExecutionContext().addExecutionContextListener(this);
@@ -80,4 +80,8 @@ public class EventDrivenExecutionFacadeController extends
 			}
 		}
 	}
+
+	public void timeScaleFactorChanged(double oldFactor, double newFactor) {
+		
+	}
 }

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/impl/ExecutionContextImpl.java

@@ -36,11 +36,13 @@ public class ExecutionContextImpl extends AbstractExecutionContext implements
 	private List<ExecutionEvent> declaredEvents;
 	private List<ExecutionEvent> raisedEvents;
 	private ExecutionState[] activeStateConfig;
+	private double timeScaleFactor;
 
 	public ExecutionContextImpl() {
 		variables = new ArrayList<ExecutionVariable>();
 		declaredEvents = new ArrayList<ExecutionEvent>();
 		raisedEvents = new ArrayList<ExecutionEvent>();
+		timeScaleFactor = 1.0d;
 		activeStateConfig = null;
 	}
 
@@ -181,4 +183,14 @@ public class ExecutionContextImpl extends AbstractExecutionContext implements
 		}
 		return result;
 	}
+
+	public double getTimeScaleFactor() {
+		return timeScaleFactor;
+	}
+
+	public void setTimeScaleFactor(double factor) {
+		double oldFactor = timeScaleFactor;
+		timeScaleFactor = factor;
+		notifyTimeScaleFactorChanged(oldFactor, factor);
+	}
 }

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/timer/VirtualClock.java

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2012 committers of YAKINDU and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     committers of YAKINDU - initial API and implementation
+ */
+package org.yakindu.sct.simulation.core.runtime.timer;
+
+/**
+ * VirtualClock to be used instead of {@link System}currentTimeMillis. Allows to
+ * scale the time with a given factor.
+ * 
+ * @author andreas muelder - Initial contribution and API
+ * 
+ */
+public class VirtualClock {
+
+	private long virtualTime;
+
+	private long realTime;
+
+	private double factor = 1.0d;
+
+	public void start() {
+		virtualTime = System.currentTimeMillis();
+		realTime = System.currentTimeMillis();
+	}
+
+	public void setFactor(double factor) {
+		virtualTime = getTime();
+		realTime = System.currentTimeMillis();
+		this.factor = factor;
+	}
+
+	public long getTime() {
+		long difference = System.currentTimeMillis() - this.realTime;
+		difference = (long) (difference * factor);
+		return virtualTime + difference;
+	}
+
+	public double getFactor() {
+		return factor;
+	}
+
+}

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/timer/VirtualTimer.java

@@ -0,0 +1,573 @@
+/*
+ * Copyright (c) 1999, 2004, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.yakindu.sct.simulation.core.runtime.timer;
+
+import java.util.Arrays;
+
+/**
+ * This is a full copy of {@link java.util.Timer}. Some changes made to use the
+ * {@link VirtualClock} instead of {@link System.currentTimeMillies}
+ */
+
+public class VirtualTimer {
+	/**
+	 * The timer task queue. This data structure is shared with the timer
+	 * thread. The timer produces tasks, via its various schedule calls, and the
+	 * timer thread consumes, executing timer tasks as appropriate, and removing
+	 * them from the queue when they're obsolete.
+	 */
+	private TaskQueue queue = new TaskQueue();
+
+	/**
+	 * The timer thread.
+	 */
+
+	private VirtualClock clock = new VirtualClock();
+	{
+		clock.start();
+	}
+
+	public VirtualClock getClock() {
+		return clock;
+	}
+
+	private TimerThread thread = new TimerThread(queue, clock);
+	/**
+	 * This object causes the timer's task execution thread to exit gracefully
+	 * when there are no live references to the Timer object and no tasks in the
+	 * timer queue. It is used in preference to a finalizer on Timer as such a
+	 * finalizer would be susceptible to a subclass's finalizer forgetting to
+	 * call it.
+	 */
+	@SuppressWarnings("unused")
+	private Object threadReaper = new Object() {
+		protected void finalize() throws Throwable {
+			synchronized (queue) {
+				thread.newTasksMayBeScheduled = false;
+				queue.notify(); // In case queue is empty.
+			}
+		}
+	};
+
+	/**
+	 * This ID is used to generate thread names. (It could be replaced by an
+	 * AtomicInteger as soon as they become available.)
+	 */
+	private static int nextSerialNumber = 0;
+
+	private static synchronized int serialNumber() {
+		return nextSerialNumber++;
+	}
+
+	/**
+	 * Creates a new timer. The associated thread does <i>not</i> run as a
+	 * daemon.
+	 * 
+	 * @see Thread
+	 * @see #cancel()
+	 */
+	public VirtualTimer() {
+		this("Timer-" + serialNumber());
+	}
+
+	/**
+	 * Creates a new timer whose associated thread may be specified to run as a
+	 * daemon. A daemon thread is called for if the timer will be used to
+	 * schedule repeating "maintenance activities", which must be performed as
+	 * long as the application is running, but should not prolong the lifetime
+	 * of the application.
+	 * 
+	 * @param isDaemon
+	 *            true if the associated thread should run as a daemon.
+	 * 
+	 * @see Thread
+	 * @see #cancel()
+	 */
+	public VirtualTimer(boolean isDaemon) {
+		this("Timer-" + serialNumber(), isDaemon);
+	}
+
+	/**
+	 * Creates a new timer whose associated thread has the specified name. The
+	 * associated thread does <i>not</i> run as a daemon.
+	 * 
+	 * @param name
+	 *            the name of the associated thread
+	 * @throws NullPointerException
+	 *             if name is null
+	 * @see Thread#getName()
+	 * @see Thread#isDaemon()
+	 * @since 1.5
+	 */
+	public VirtualTimer(String name) {
+		thread.setName(name);
+		thread.start();
+	}
+
+	/**
+	 * Creates a new timer whose associated thread has the specified name, and
+	 * may be specified to run as a daemon.
+	 * 
+	 * @param name
+	 *            the name of the associated thread
+	 * @param isDaemon
+	 *            true if the associated thread should run as a daemon
+	 * @throws NullPointerException
+	 *             if name is null
+	 * @see Thread#getName()
+	 * @see Thread#isDaemon()
+	 * @since 1.5
+	 */
+	public VirtualTimer(String name, boolean isDaemon) {
+		thread.setName(name);
+		thread.setDaemon(isDaemon);
+		thread.start();
+	}
+
+	/**
+	 * Schedules the specified task for execution after the specified delay.
+	 * 
+	 * @param task
+	 *            task to be scheduled.
+	 * @param delay
+	 *            delay in milliseconds before task is to be executed.
+	 * @throws IllegalArgumentException
+	 *             if <tt>delay</tt> is negative, or
+	 *             <tt>delay + System.currentTimeMillis()</tt> is negative.
+	 * @throws IllegalStateException
+	 *             if task was already scheduled or cancelled, or timer was
+	 *             cancelled.
+	 */
+	public void schedule(VirtualTimerTask task, long delay) {
+		if (delay < 0)
+			throw new IllegalArgumentException("Negative delay.");
+		sched(task, clock.getTime() + delay, 0);
+	}
+
+	/**
+	 * Schedules the specified task for repeated <i>fixed-rate execution</i>,
+	 * beginning after the specified delay. Subsequent executions take place at
+	 * approximately regular intervals, separated by the specified period.
+	 * 
+	 * <p>
+	 * In fixed-rate execution, each execution is scheduled relative to the
+	 * scheduled execution time of the initial execution. If an execution is
+	 * delayed for any reason (such as garbage collection or other background
+	 * activity), two or more executions will occur in rapid succession to
+	 * "catch up." In the long run, the frequency of execution will be exactly
+	 * the reciprocal of the specified period (assuming the system clock
+	 * underlying <tt>Object.wait(long)</tt> is accurate).
+	 * 
+	 * <p>
+	 * Fixed-rate execution is appropriate for recurring activities that are
+	 * sensitive to <i>absolute</i> time, such as ringing a chime every hour on
+	 * the hour, or running scheduled maintenance every day at a particular
+	 * time. It is also appropriate for recurring activities where the total
+	 * time to perform a fixed number of executions is important, such as a
+	 * countdown timer that ticks once every second for ten seconds. Finally,
+	 * fixed-rate execution is appropriate for scheduling multiple repeating
+	 * timer tasks that must remain synchronized with respect to one another.
+	 * 
+	 * @param task
+	 *            task to be scheduled.
+	 * @param delay
+	 *            delay in milliseconds before task is to be executed.
+	 * @param period
+	 *            time in milliseconds between successive task executions.
+	 * @throws IllegalArgumentException
+	 *             if <tt>delay</tt> is negative, or
+	 *             <tt>delay + System.currentTimeMillis()</tt> is negative.
+	 * @throws IllegalStateException
+	 *             if task was already scheduled or cancelled, timer was
+	 *             cancelled, or timer thread terminated.
+	 */
+	public void scheduleAtFixedRate(VirtualTimerTask task, long delay,
+			long period) {
+		if (delay < 0)
+			throw new IllegalArgumentException("Negative delay.");
+		if (period <= 0)
+			throw new IllegalArgumentException("Non-positive period.");
+		sched(task, clock.getTime() + delay, period);
+	}
+
+	/**
+	 * Schedule the specified timer task for execution at the specified time
+	 * with the specified period, in milliseconds. If period is positive, the
+	 * task is scheduled for repeated execution; if period is zero, the task is
+	 * scheduled for one-time execution. Time is specified in Date.getTime()
+	 * format. This method checks timer state, task state, and initial execution
+	 * time, but not period.
+	 * 
+	 * @throws IllegalArgumentException
+	 *             if <tt>time()</tt> is negative.
+	 * @throws IllegalStateException
+	 *             if task was already scheduled or cancelled, timer was
+	 *             cancelled, or timer thread terminated.
+	 */
+	private void sched(VirtualTimerTask task, long time, long period) {
+		if (time < 0)
+			throw new IllegalArgumentException("Illegal execution time.");
+
+		synchronized (queue) {
+			if (!thread.newTasksMayBeScheduled)
+				throw new IllegalStateException("Timer already cancelled.");
+
+			synchronized (task.lock) {
+				if (task.state != VirtualTimerTask.VIRGIN)
+					throw new IllegalStateException(
+							"Task already scheduled or cancelled");
+				task.nextExecutionTime = time;
+				task.period = period;
+				task.state = VirtualTimerTask.SCHEDULED;
+			}
+
+			queue.add(task);
+			if (queue.getMin() == task)
+				queue.notify();
+		}
+	}
+
+	/**
+	 * Terminates this timer, discarding any currently scheduled tasks. Does not
+	 * interfere with a currently executing task (if it exists). Once a timer
+	 * has been terminated, its execution thread terminates gracefully, and no
+	 * more tasks may be scheduled on it.
+	 * 
+	 * <p>
+	 * Note that calling this method from within the run method of a timer task
+	 * that was invoked by this timer absolutely guarantees that the ongoing
+	 * task execution is the last task execution that will ever be performed by
+	 * this timer.
+	 * 
+	 * <p>
+	 * This method may be called repeatedly; the second and subsequent calls
+	 * have no effect.
+	 */
+	public void cancel() {
+		synchronized (queue) {
+			thread.newTasksMayBeScheduled = false;
+			queue.clear();
+			queue.notify(); // In case queue was already empty.
+		}
+	}
+
+	/**
+	 * Removes all cancelled tasks from this timer's task queue. <i>Calling this
+	 * method has no effect on the behavior of the timer</i>, but eliminates the
+	 * references to the cancelled tasks from the queue. If there are no
+	 * external references to these tasks, they become eligible for garbage
+	 * collection.
+	 * 
+	 * <p>
+	 * Most programs will have no need to call this method. It is designed for
+	 * use by the rare application that cancels a large number of tasks. Calling
+	 * this method trades time for space: the runtime of the method may be
+	 * proportional to n + c log n, where n is the number of tasks in the queue
+	 * and c is the number of cancelled tasks.
+	 * 
+	 * <p>
+	 * Note that it is permissible to call this method from within a a task
+	 * scheduled on this timer.
+	 * 
+	 * @return the number of tasks removed from the queue.
+	 * @since 1.5
+	 */
+	public int purge() {
+		int result = 0;
+
+		synchronized (queue) {
+			for (int i = queue.size(); i > 0; i--) {
+				if (queue.get(i).state == VirtualTimerTask.CANCELLED) {
+					queue.quickRemove(i);
+					result++;
+				}
+			}
+
+			if (result != 0)
+				queue.heapify();
+		}
+
+		return result;
+	}
+}
+
+/**
+ * This "helper class" implements the timer's task execution thread, which waits
+ * for tasks on the timer queue, executions them when they fire, reschedules
+ * repeating tasks, and removes cancelled tasks and spent non-repeating tasks
+ * from the queue.
+ */
+class TimerThread extends Thread {
+	/**
+	 * This flag is set to false by the reaper to inform us that there are no
+	 * more live references to our Timer object. Once this flag is true and
+	 * there are no more tasks in our queue, there is no work left for us to do,
+	 * so we terminate gracefully. Note that this field is protected by queue's
+	 * monitor!
+	 */
+	boolean newTasksMayBeScheduled = true;
+
+	/**
+	 * Our Timer's queue. We store this reference in preference to a reference
+	 * to the Timer so the reference graph remains acyclic. Otherwise, the Timer
+	 * would never be garbage-collected and this thread would never go away.
+	 */
+	private TaskQueue queue;
+
+	private final VirtualClock clock;
+
+	TimerThread(TaskQueue queue, VirtualClock clock) {
+		this.queue = queue;
+		this.clock = clock;
+	}
+
+	public void run() {
+		try {
+			mainLoop();
+		} finally {
+			// Someone killed this Thread, behave as if Timer cancelled
+			synchronized (queue) {
+				newTasksMayBeScheduled = false;
+				queue.clear(); // Eliminate obsolete references
+			}
+		}
+	}
+
+	/**
+	 * The main timer loop. (See class comment.)
+	 */
+	private void mainLoop() {
+		while (true) {
+			try {
+				VirtualTimerTask task;
+				boolean taskFired;
+				synchronized (queue) {
+					// Wait for queue to become non-empty
+					while (queue.isEmpty() && newTasksMayBeScheduled)
+						queue.wait();
+					if (queue.isEmpty())
+						break; // Queue is empty and will forever remain; die
+
+					// Queue nonempty; look at first evt and do the right thing
+					long currentTime, executionTime;
+					task = queue.getMin();
+					synchronized (task.lock) {
+						if (task.state == VirtualTimerTask.CANCELLED) {
+							queue.removeMin();
+							continue; // No action required, poll queue again
+						}
+						currentTime = clock.getTime();
+						executionTime = task.nextExecutionTime;
+						if (taskFired = (executionTime <= currentTime)) {
+							if (task.period == 0) { // Non-repeating, remove
+								queue.removeMin();
+								task.state = VirtualTimerTask.EXECUTED;
+							} else { // Repeating task, reschedule
+								queue.rescheduleMin(task.period < 0 ? currentTime
+										- task.period
+										: executionTime + task.period);
+							}
+						}
+					}
+					if (!taskFired) {
+						//CHANGED
+						// Task hasn't yet fired; wait
+						// queue.wait((long)((executionTime - currentTime) /
+						// clock.getFactor()));
+						queue.wait(100);
+					}
+				}
+				if (taskFired) {// Task fired; run it, holding no locks
+					task.run();
+				}
+			} catch (InterruptedException e) {
+			}
+		}
+	}
+}
+
+/**
+ * This class represents a timer task queue: a priority queue of
+ * VirtualTimerTasks, ordered on nextExecutionTime. Each Timer object has one of
+ * these, which it shares with its TimerThread. Internally this class uses a
+ * heap, which offers log(n) performance for the add, removeMin and
+ * rescheduleMin operations, and constant time performance for the getMin
+ * operation.
+ */
+class TaskQueue {
+	/**
+	 * Priority queue represented as a balanced binary heap: the two children of
+	 * queue[n] are queue[2*n] and queue[2*n+1]. The priority queue is ordered
+	 * on the nextExecutionTime field: The VirtualTimerTask with the lowest
+	 * nextExecutionTime is in queue[1] (assuming the queue is nonempty). For
+	 * each node n in the heap, and each descendant of n, d, n.nextExecutionTime
+	 * <= d.nextExecutionTime.
+	 */
+	private VirtualTimerTask[] queue = new VirtualTimerTask[128];
+
+	/**
+	 * The number of tasks in the priority queue. (The tasks are stored in
+	 * queue[1] up to queue[size]).
+	 */
+	private int size = 0;
+
+	/**
+	 * Returns the number of tasks currently on the queue.
+	 */
+	int size() {
+		return size;
+	}
+
+	/**
+	 * Adds a new task to the priority queue.
+	 */
+	void add(VirtualTimerTask task) {
+		// Grow backing store if necessary
+		if (size + 1 == queue.length)
+			queue = Arrays.copyOf(queue, 2 * queue.length);
+
+		queue[++size] = task;
+		fixUp(size);
+	}
+
+	/**
+	 * Return the "head task" of the priority queue. (The head task is an task
+	 * with the lowest nextExecutionTime.)
+	 */
+	VirtualTimerTask getMin() {
+		return queue[1];
+	}
+
+	/**
+	 * Return the ith task in the priority queue, where i ranges from 1 (the
+	 * head task, which is returned by getMin) to the number of tasks on the
+	 * queue, inclusive.
+	 */
+	VirtualTimerTask get(int i) {
+		return queue[i];
+	}
+
+	/**
+	 * Remove the head task from the priority queue.
+	 */
+	void removeMin() {
+		queue[1] = queue[size];
+		queue[size--] = null; // Drop extra reference to prevent memory leak
+		fixDown(1);
+	}
+
+	/**
+	 * Removes the ith element from queue without regard for maintaining the
+	 * heap invariant. Recall that queue is one-based, so 1 <= i <= size.
+	 */
+	void quickRemove(int i) {
+		assert i <= size;
+
+		queue[i] = queue[size];
+		queue[size--] = null; // Drop extra ref to prevent memory leak
+	}
+
+	/**
+	 * Sets the nextExecutionTime associated with the head task to the specified
+	 * value, and adjusts priority queue accordingly.
+	 */
+	void rescheduleMin(long newTime) {
+		queue[1].nextExecutionTime = newTime;
+		fixDown(1);
+	}
+
+	/**
+	 * Returns true if the priority queue contains no elements.
+	 */
+	boolean isEmpty() {
+		return size == 0;
+	}
+
+	/**
+	 * Removes all elements from the priority queue.
+	 */
+	void clear() {
+		// Null out task references to prevent memory leak
+		for (int i = 1; i <= size; i++)
+			queue[i] = null;
+
+		size = 0;
+	}
+
+	/**
+	 * Establishes the heap invariant (described above) assuming the heap
+	 * satisfies the invariant except possibly for the leaf-node indexed by k
+	 * (which may have a nextExecutionTime less than its parent's).
+	 * 
+	 * This method functions by "promoting" queue[k] up the hierarchy (by
+	 * swapping it with its parent) repeatedly until queue[k]'s
+	 * nextExecutionTime is greater than or equal to that of its parent.
+	 */
+	private void fixUp(int k) {
+		while (k > 1) {
+			int j = k >> 1;
+			if (queue[j].nextExecutionTime <= queue[k].nextExecutionTime)
+				break;
+			VirtualTimerTask tmp = queue[j];
+			queue[j] = queue[k];
+			queue[k] = tmp;
+			k = j;
+		}
+	}
+
+	/**
+	 * Establishes the heap invariant (described above) in the subtree rooted at
+	 * k, which is assumed to satisfy the heap invariant except possibly for
+	 * node k itself (which may have a nextExecutionTime greater than its
+	 * children's).
+	 * 
+	 * This method functions by "demoting" queue[k] down the hierarchy (by
+	 * swapping it with its smaller child) repeatedly until queue[k]'s
+	 * nextExecutionTime is less than or equal to those of its children.
+	 */
+	private void fixDown(int k) {
+		int j;
+		while ((j = k << 1) <= size && j > 0) {
+			if (j < size
+					&& queue[j].nextExecutionTime > queue[j + 1].nextExecutionTime)
+				j++; // j indexes smallest kid
+			if (queue[k].nextExecutionTime <= queue[j].nextExecutionTime)
+				break;
+			VirtualTimerTask tmp = queue[j];
+			queue[j] = queue[k];
+			queue[k] = tmp;
+			k = j;
+		}
+	}
+
+	/**
+	 * Establishes the heap invariant (described above) in the entire tree,
+	 * assuming nothing about the order of the elements prior to the call.
+	 */
+	void heapify() {
+		for (int i = size / 2; i >= 1; i--)
+			fixDown(i);
+	}
+}

plugins/org.yakindu.sct.simulation.core/src/org/yakindu/sct/simulation/core/runtime/timer/VirtualTimerTask.java

@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 1999, 2004, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package org.yakindu.sct.simulation.core.runtime.timer;
+
+import java.util.TimerTask;
+
+/**
+ * This is a full copy of {@link TimerTask} to allow access from VirtualTimer to
+ * package visible elements.
+ */
+
+public abstract class VirtualTimerTask implements Runnable {
+	/**
+	 * This object is used to control access to the TimerTask internals.
+	 */
+	final Object lock = new Object();
+
+	/**
+	 * The state of this task, chosen from the constants below.
+	 */
+	int state = VIRGIN;
+
+	/**
+	 * This task has not yet been scheduled.
+	 */
+	static final int VIRGIN = 0;
+
+	/**
+	 * This task is scheduled for execution. If it is a non-repeating task, it
+	 * has not yet been executed.
+	 */
+	static final int SCHEDULED = 1;
+
+	/**
+	 * This non-repeating task has already executed (or is currently executing)
+	 * and has not been cancelled.
+	 */
+	static final int EXECUTED = 2;
+
+	/**
+	 * This task has been cancelled (with a call to TimerTask.cancel).
+	 */
+	static final int CANCELLED = 3;
+
+	/**
+	 * Next execution time for this task in the format returned by
+	 * System.currentTimeMillis, assuming this task is scheduled for execution.
+	 * For repeating tasks, this field is updated prior to each task execution.
+	 */
+	long nextExecutionTime;
+
+	/**
+	 * Period in milliseconds for repeating tasks. A positive value indicates
+	 * fixed-rate execution. A negative value indicates fixed-delay execution. A
+	 * value of 0 indicates a non-repeating task.
+	 */
+	long period = 0;
+
+	/**
+	 * Creates a new timer task.
+	 */
+	protected VirtualTimerTask() {
+	}
+
+	/**
+	 * The action to be performed by this timer task.
+	 */
+	public abstract void run();
+
+	/**
+	 * Cancels this timer task. If the task has been scheduled for one-time
+	 * execution and has not yet run, or has not yet been scheduled, it will
+	 * never run. If the task has been scheduled for repeated execution, it will
+	 * never run again. (If the task is running when this call occurs, the task
+	 * will run to completion, but will never run again.)
+	 * 
+	 * <p>
+	 * Note that calling this method from within the <tt>run</tt> method of a
+	 * repeating timer task absolutely guarantees that the timer task will not
+	 * run again.
+	 * 
+	 * <p>
+	 * This method may be called repeatedly; the second and subsequent calls
+	 * have no effect.
+	 * 
+	 * @return true if this task is scheduled for one-time execution and has not
+	 *         yet run, or this task is scheduled for repeated execution.
+	 *         Returns false if the task was scheduled for one-time execution
+	 *         and has already run, or if the task was never scheduled, or if
+	 *         the task was already cancelled. (Loosely speaking, this method
+	 *         returns <tt>true</tt> if it prevents one or more scheduled
+	 *         executions from taking place.)
+	 */
+	public boolean cancel() {
+		synchronized (lock) {
+			boolean result = (state == SCHEDULED);
+			state = CANCELLED;
+			return result;
+		}
+	}
+
+	/**
+	 * Returns the <i>scheduled</i> execution time of the most recent
+	 * <i>actual</i> execution of this task. (If this method is invoked while
+	 * task execution is in progress, the return value is the scheduled
+	 * execution time of the ongoing task execution.)
+	 * 
+	 * <p>
+	 * This method is typically invoked from within a task's run method, to
+	 * determine whether the current execution of the task is sufficiently
+	 * timely to warrant performing the scheduled activity:
+	 * 
+	 * <pre>
+	 * public void run() {
+	 * 	if (surrentTimeMillis() - scheduledExecutionTime() &gt;= MAX_TARDINESS)
+	 * 		return; // Too late; skip this execution.
+	 * 	// Perform the task
+	 * }
+	 * </pre>
+	 * 
+	 * This method is typically <i>not</i> used in conjunction with
+	 * <i>fixed-delay execution</i> repeating tasks, as their scheduled
+	 * execution times are allowed to drift over time, and so are not terribly
+	 * significant.
+	 * 
+	 * @return the time at which the most recent execution of this task was
+	 *         scheduled to occur, in the format returned by Date.getTime(). The
+	 *         return value is undefined if the task has yet to commence its
+	 *         first execution.
+	 * @see Date#getTime()
+	 */
+	public long scheduledExecutionTime() {
+		synchronized (lock) {
+			return (period < 0 ? nextExecutionTime + period : nextExecutionTime
+					- period);
+		}
+	}
+}

plugins/org.yakindu.sct.simulation.ui/plugin.xml

@@ -56,10 +56,10 @@
        point="org.eclipse.ui.views">
     <view
           allowMultiple="false"
-          class="org.yakindu.sct.simulation.ui.view.DeclarationView"
+          class="org.yakindu.sct.simulation.ui.view.SimulationView"
           icon="icons/Declarations-View-16.gif"
           id="org.yakindu.sct.simulation.ui.declarationview"
-          name="Declarations View"
+          name="Simulation View"
           restorable="true">
     </view>
  </extension>

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/DeclarationImages.java

@@ -9,7 +9,7 @@ import org.eclipse.swt.graphics.Image;
  * @author andreas muelder - Initial contribution and API
  * 
  */
-public enum DeclarationImages {
+public enum SimulationImages {
 
 	EVENT("icons/Event.gif"),
 	
@@ -27,7 +27,7 @@ public enum DeclarationImages {
 
 	private final String path;
 
-	private DeclarationImages(String path) {
+	private SimulationImages(String path) {
 		this.path = path;
 	}
 

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/launch/tabs/StatechartLaunchConfigurationTab.java

@@ -32,7 +32,7 @@ import org.eclipse.swt.widgets.Listener;
 import org.eclipse.swt.widgets.Text;
 import org.eclipse.ui.dialogs.ResourceListSelectionDialog;
 import org.yakindu.sct.simulation.core.launch.IStatechartLaunchParameters;
-import org.yakindu.sct.simulation.ui.DeclarationImages;
+import org.yakindu.sct.simulation.ui.SimulationImages;
 
 /**
  * @author andreas muelder - Initial contribution and API
@@ -56,8 +56,8 @@ public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
 
 	private void createFileSelectionGroup(Composite comp) {
 		createModelFileGroup(comp);
-		createCyclePeriodGroup(comp);
 		createExecutionTypeControls(comp);
+		createCyclePeriodGroup(comp);
 	}
 
 	private void createExecutionTypeControls(Composite parent) {
@@ -68,10 +68,12 @@ public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
 		btnCycle = new Button(propertyGroup, SWT.RADIO);
 		btnCycle.setText("cycle based");
 		btnCycle.addListener(SWT.Selection, new UpdateListener());
+		btnCycle.addListener(SWT.Selection, new EnableStateListener());
 		GridDataFactory.fillDefaults().applyTo(btnCycle);
 		btnEvent = new Button(propertyGroup, SWT.RADIO);
 		btnEvent.setText("event driven");
 		btnEvent.addListener(SWT.Selection, new UpdateListener());
+		btnCycle.addListener(SWT.Selection, new EnableStateListener());
 		GridDataFactory.fillDefaults().applyTo(btnEvent);
 	}
 
@@ -130,6 +132,7 @@ public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
 					DEFAULT_IS_CYCLE_BASED));
 			btnEvent.setSelection(configuration.getAttribute(IS_EVENT_DRIVEN,
 					DEFAULT_IS_EVENT_DRIVEN));
+			cyclePeriod.setEnabled(btnCycle.getSelection());
 		} catch (CoreException e) {
 			e.printStackTrace();
 		}
@@ -154,7 +157,7 @@ public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
 
 	@Override
 	public Image getImage() {
-		return DeclarationImages.LAUNCHER_ICON.image();
+		return SimulationImages.LAUNCHER_ICON.image();
 	}
 
 	@Override
@@ -187,6 +190,12 @@ public class StatechartLaunchConfigurationTab extends JavaLaunchTab implements
 		return true;
 	}
 
+	private class EnableStateListener implements Listener {
+		public void handleEvent(Event event) {
+			cyclePeriod.setEnabled(btnCycle.getSelection());
+		}
+	}
+
 	private class UpdateListener implements Listener {
 
 		public void handleEvent(Event event) {

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/ExecutionContextContentProvider.java

@@ -130,6 +130,9 @@ public class ExecutionContextContentProvider implements ITreeContentProvider,
 
 	public void eventRaised(ExecutionEvent event) {
 	}
+	public void timeScaleFactorChanged(double oldFactor, double newFactor) {
+	}
+
 
 	public void variableValueChanged(ExecutionVariable variable) {
 		Display.getDefault().asyncExec(new Runnable() {
@@ -197,5 +200,5 @@ public class ExecutionContextContentProvider implements ITreeContentProvider,
 		}
 
 	}
-
+	
 }

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/ExecutionContextLabelProvider.java

@@ -17,7 +17,7 @@ import org.eclipse.swt.custom.StyleRange;
 import org.yakindu.sct.simulation.core.runtime.impl.AbstractSlot;
 import org.yakindu.sct.simulation.core.runtime.impl.ExecutionEvent;
 import org.yakindu.sct.simulation.core.runtime.impl.ExecutionVariable;
-import org.yakindu.sct.simulation.ui.DeclarationImages;
+import org.yakindu.sct.simulation.ui.SimulationImages;
 import org.yakindu.sct.simulation.ui.view.ExecutionContextContentProvider.Container;
 
 /**
@@ -68,17 +68,17 @@ public class ExecutionContextLabelProvider extends StyledCellLabelProvider {
 			cell.setText(event.getSimpleName());
 			cell.setStyleRanges(new StyleRange[] { style1 });
 			if (event.getName().contains("time_event")) {
-				cell.setImage(DeclarationImages.TIMEEVENT.image());
+				cell.setImage(SimulationImages.TIMEEVENT.image());
 			} else {
-				cell.setImage(DeclarationImages.EVENT.image());
+				cell.setImage(SimulationImages.EVENT.image());
 			}
 		} else if (element instanceof ExecutionVariable) {
 			ExecutionVariable variable = (ExecutionVariable) element;
 			cell.setText(variable.getSimpleName());
-			cell.setImage(DeclarationImages.VARIABLE.image());
+			cell.setImage(SimulationImages.VARIABLE.image());
 		} else if (element instanceof Container) {
 			cell.setText(((Container) element).name);
-			cell.setImage(DeclarationImages.SCOPE.image());
+			cell.setImage(SimulationImages.SCOPE.image());
 		}
 	}
 

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/DeclarationView.java

@@ -15,13 +15,12 @@ import org.eclipse.debug.core.DebugEvent;
 import org.eclipse.debug.core.DebugPlugin;
 import org.eclipse.debug.core.IDebugEventSetListener;
 import org.eclipse.debug.core.model.IDebugTarget;
-import org.eclipse.debug.ui.AbstractDebugView;
 import org.eclipse.debug.ui.DebugUITools;
 import org.eclipse.debug.ui.contexts.DebugContextEvent;
 import org.eclipse.debug.ui.contexts.IDebugContextListener;
 import org.eclipse.jface.action.IAction;
-import org.eclipse.jface.action.IMenuManager;
 import org.eclipse.jface.action.IToolBarManager;
+import org.eclipse.jface.layout.GridDataFactory;
 import org.eclipse.jface.viewers.ISelectionChangedListener;
 import org.eclipse.jface.viewers.IStructuredSelection;
 import org.eclipse.jface.viewers.SelectionChangedEvent;
@@ -29,8 +28,18 @@ import org.eclipse.jface.viewers.TreeViewer;
 import org.eclipse.jface.viewers.TreeViewerColumn;
 import org.eclipse.jface.viewers.Viewer;
 import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.ui.forms.widgets.Section;
+import org.eclipse.ui.part.ViewPart;
 import org.yakindu.sct.simulation.core.debugmodel.SCTDebugTarget;
 import org.yakindu.sct.simulation.core.runtime.IExecutionContext;
 import org.yakindu.sct.simulation.core.runtime.IExecutionFacade;
@@ -48,13 +57,13 @@ import org.yakindu.sct.simulation.ui.view.editing.RealEditingSupport;
  * @author andreas muelder - Initial contribution and API
  * 
  */
-public class DeclarationView extends AbstractDebugView implements
-		IDebugContextListener, IDebugEventSetListener {
+public class SimulationView extends ViewPart implements IDebugContextListener,
+		IDebugEventSetListener {
 
 	private TreeViewer viewer;
 	private SCTDebugTarget debugTarget;
 
-	public DeclarationView() {
+	public SimulationView() {
 		DebugUITools.getDebugContextManager().addDebugContextListener(this);
 		DebugPlugin.getDefault().addDebugEventListener(this);
 	}
@@ -67,6 +76,44 @@ public class DeclarationView extends AbstractDebugView implements
 	}
 
 	@Override
+	public void createPartControl(Composite parent) {
+		parent.setLayout(new FillLayout(SWT.VERTICAL));
+		createViewer(parent);
+		createTimeScalingControls(parent);
+		hookActions();
+	}
+
+	@Override
+	public void setFocus() {
+		viewer.getTree().setFocus();
+	}
+
+	private void createTimeScalingControls(Composite parent) {
+		FormToolkit kit = new FormToolkit(Display.getDefault());
+		Section section = kit.createSection(parent, Section.TITLE_BAR);
+		section.setText("scaled real-time");
+		Composite client = kit.createComposite(section);
+		client.setLayout(new GridLayout(3, false));
+		section.setClient(client);
+		Label label = kit.createLabel(client, "scale factor: ");
+		GridDataFactory.fillDefaults().grab(true, false).applyTo(label);
+		final Text scaleFactor = kit.createText(client, "1.0");
+		GridDataFactory.fillDefaults().grab(true, false).applyTo(scaleFactor);
+		Button setScale = kit.createButton(client, "apply", SWT.PUSH);
+		setScale.addSelectionListener(new SelectionAdapter() {
+			public void widgetSelected(SelectionEvent e) {
+				try {
+					double factor = Double.parseDouble(scaleFactor.getText());
+					IExecutionFacade facade = (IExecutionFacade) debugTarget
+							.getAdapter(IExecutionFacade.class);
+					facade.getExecutionContext().setTimeScaleFactor(factor);
+				} catch (NumberFormatException ex) {
+				}
+			}
+		});
+		GridDataFactory.fillDefaults().applyTo(setScale);
+	}
+
 	protected Viewer createViewer(Composite parent) {
 		viewer = new TreeViewer(parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL
 				| SWT.FULL_SELECTION);
@@ -147,31 +194,14 @@ public class DeclarationView extends AbstractDebugView implements
 
 	}
 
-	@Override
-	protected void createActions() {
+	protected void hookActions() {
+		IToolBarManager mgr = getViewSite().getActionBars().getToolBarManager();
 		IAction collapse = new CollapseAllAction(viewer);
-		setAction("CollapseAll", collapse);
+		mgr.add(collapse);
 		IAction expand = new ExpandAllAction(viewer);
-		setAction("ExpandAll", expand);
+		mgr.add(expand);
 		IAction hideTimeEvent = new HideTimeEventsAction(true);
-		setAction("HideTimeEvent", hideTimeEvent);
-	}
-
-	@Override
-	protected String getHelpContextId() {
-		return null;
-	}
-
-	@Override
-	protected void fillContextMenu(IMenuManager menu) {
-
-	}
-
-	@Override
-	protected void configureToolBar(IToolBarManager tbm) {
-		tbm.add(getAction("CollapseAll"));
-		tbm.add(getAction("ExpandAll"));
-		tbm.add(getAction("HideTimeEvent"));
+		mgr.add(hideTimeEvent);
 	}
 
 }

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/actions/CollapseAllAction.java

@@ -12,7 +12,7 @@ package org.yakindu.sct.simulation.ui.view.actions;
 
 import org.eclipse.jface.action.Action;
 import org.eclipse.jface.viewers.TreeViewer;
-import org.yakindu.sct.simulation.ui.DeclarationImages;
+import org.yakindu.sct.simulation.ui.SimulationImages;
 /**
  * 
  * @author andreas muelder - Initial contribution and API
@@ -26,7 +26,7 @@ public class CollapseAllAction extends Action {
 		super("Collapse all");
 		fViewer = viewer;
 		setToolTipText("Collapse all");
-		setImageDescriptor(DeclarationImages.COLLAPSE_ALL.imageDescriptor());
+		setImageDescriptor(SimulationImages.COLLAPSE_ALL.imageDescriptor());
 	}
 
 	public void run() {

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/actions/ExpandAllAction.java

@@ -12,7 +12,7 @@ package org.yakindu.sct.simulation.ui.view.actions;
 
 import org.eclipse.jface.action.Action;
 import org.eclipse.jface.viewers.TreeViewer;
-import org.yakindu.sct.simulation.ui.DeclarationImages;
+import org.yakindu.sct.simulation.ui.SimulationImages;
 
 /**
  * 
@@ -27,7 +27,7 @@ public class ExpandAllAction extends Action {
 		super("Expand all");
 		fViewer = viewer;
 		setToolTipText("Expand all");
-		setImageDescriptor(DeclarationImages.EXPAND_ALL.imageDescriptor());
+		setImageDescriptor(SimulationImages.EXPAND_ALL.imageDescriptor());
 	}
 
 	public void run() {

plugins/org.yakindu.sct.simulation.ui/src/org/yakindu/sct/simulation/ui/view/actions/HideTimeEventsAction.java

@@ -12,8 +12,8 @@ package org.yakindu.sct.simulation.ui.view.actions;
 
 import org.eclipse.jface.action.Action;
 import org.eclipse.jface.preference.IPreferenceStore;
-import org.yakindu.sct.simulation.ui.DeclarationImages;
 import org.yakindu.sct.simulation.ui.SimulationActivator;
+import org.yakindu.sct.simulation.ui.SimulationImages;
 
 /**
  * 
@@ -27,7 +27,7 @@ public class HideTimeEventsAction extends Action {
 	public HideTimeEventsAction(boolean show) {
 		super("Hide TimeEvents");
 		setToolTipText("Show TimeEvents");
-		setImageDescriptor(DeclarationImages.TIMEEVENT.imageDescriptor());
+		setImageDescriptor(SimulationImages.TIMEEVENT.imageDescriptor());
 		setChecked(getStore().getBoolean(HIDE_KEY));
 	}