+++ /dev/null
-/*
- * Copyright (c) 2003-2005 The BISON Project
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program 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 Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- */
-
-package peersim.edsim;
-
-import java.util.Arrays;
-
-import peersim.Simulator;
-import peersim.config.*;
-import peersim.core.*;
-import psgsim.PSGSimulator;
-
-/**
- * Event-driven simulator engine. It is a fully static singleton class. For an
- * event driven simulation the configuration has to describe a set of
- * {@link Protocol}s, a set of {@link Control}s and their ordering and a set of
- * initializers and their ordering. See parameters {@value #PAR_INIT},
- * {@value #PAR_CTRL}.
- * <p>
- * One experiment run by {@link #nextExperiment} works as follows. First the
- * initializers are run in the specified order. Then the first execution of all
- * specified controls is scheduled in the event queue. This scheduling is
- * defined by the {@link Scheduler} parameters of each control component. After
- * this, the first event is taken from the event queue. If the event wraps a
- * control, the control is executed, otherwise the event is delivered to the
- * destination protocol, that must implement {@link EDProtocol}. This is
- * iterated while the current time is less than {@value #PAR_ENDTIME} or the
- * queue becomes empty. If more control events fall at the same time point, then
- * the order given in the configuration is respected. If more non-control events
- * fall at the same time point, they are processed in a random order.
- * <p>
- * The engine also provides the interface to add events to the queue. Note that
- * this engine does not explicitly run the protocols. In all cases at least one
- * control or initializer has to be defined that sends event(s) to protocols.
- * <p>
- * Controls can be scheduled (using the {@link Scheduler} parameters in the
- * configuration) to run after the experiment has finished. That is, each
- * experiment is finished by running the controls that are scheduled to be run
- * after the experiment.
- * <p>
- * Any control can interrupt an experiment at any time it is executed by
- * returning true in method {@link Control#execute}. However, the controls
- * scheduled to run after the experiment are still executed completely,
- * irrespective of their return value and even if the experiment was
- * interrupted.
- * <p>
- * {@link CDScheduler} has to be mentioned that is a control that can bridge the
- * gap between {@link peersim.cdsim} and the event driven engine. It can wrap
- * {@link peersim.cdsim.CDProtocol} appropriately so that the execution of the
- * cycles are scheduled in configurable ways for each node individually. In some
- * cases this can add a more fine-grained control and more realism to
- * {@link peersim.cdsim.CDProtocol} simulations, at the cost of some loss in
- * performance.
- * <p>
- * When protocols at different nodes send messages to each other, they might
- * want to use a model of the transport layer so that in the simulation message
- * delay and message omissions can be modeled in a modular way. This
- * functionality is implemented in package {@link peersim.transport}.
- *
- * @see Configuration
- */
-public class EDSimulator {
-
- // ---------------------------------------------------------------------
- // Parameters
- // ---------------------------------------------------------------------
-
- /**
- * The ending time for simulation. Only events that have a strictly smaller
- * value are executed. It must be positive. Although in principle negative
- * timestamps could be allowed, we assume time will be positive.
- *
- * @config
- */
- public static final String PAR_ENDTIME = "simulation.endtime";
-
- /**
- * This parameter specifies how often the simulator should log the current
- * time on the standard error. The time is logged only if there were events
- * in the respective interval, and only the time of some actual event is
- * printed. That is, the actual log is not guaranteed to happen in identical
- * intervals of time. It is merely a way of seeing whether the simulation
- * progresses and how fast...
- *
- * @config
- */
- private static final String PAR_LOGTIME = "simulation.logtime";
-
- /**
- * This parameter specifies the event queue to be used. It must be an
- * implementation of interface {@link PriorityQ}. If it is not defined, the
- * internal implementation is used.
- *
- * @config
- */
- private static final String PAR_PQ = "simulation.eventqueue";
-
- /**
- * This is the prefix for initializers. These have to be of type
- * {@link Control}. They are run at the beginning of each experiment, in the
- * order specified by the configuration.
- *
- * @see Configuration
- * @config
- * @config
- */
- private static final String PAR_INIT = "init";
-
- /**
- * This is the prefix for {@link Control} components. They are run at the
- * time points defined by the {@link Scheduler} associated to them. If some
- * controls have to be executed at the same time point, they are executed in
- * the order specified in the configuration.
- *
- * @see Configuration
- * @config
- */
- private static final String PAR_CTRL = "control";
-
- // ---------------------------------------------------------------------
- // Fields
- // ---------------------------------------------------------------------
-
- /** Maximum time for simulation */
- private static long endtime;
-
- /** Log time */
- private static long logtime;
-
- /** holds the modifiers of this simulation */
- private static Control[] controls = null;
-
- /** Holds the control schedulers of this simulation */
- private static Scheduler[] ctrlSchedules = null;
-
- /** Ordered list of events (heap) */
- private static PriorityQ heap = null;
-
- private static long nextlog = 0;
-
- // =============== initialization ======================================
- // =====================================================================
-
- /** to prevent construction */
- private EDSimulator() {
- }
-
- // ---------------------------------------------------------------------
- // Private methods
- // ---------------------------------------------------------------------
-
- /**
- * Load and run initializers.
- */
- private static void runInitializers() {
-
- Object[] inits = Configuration.getInstanceArray(PAR_INIT);
- String names[] = Configuration.getNames(PAR_INIT);
-
- for (int i = 0; i < inits.length; ++i) {
-
- System.err.println("- Running initializer " + names[i] + ": "
- + inits[i].getClass());
- ((Control) inits[i]).execute();
- }
- }
-
- // --------------------------------------------------------------------
-
- private static void scheduleControls() {
- // load controls
- String[] names = Configuration.getNames(PAR_CTRL);
- controls = new Control[names.length];
- ctrlSchedules = new Scheduler[names.length];
- for (int i = 0; i < names.length; ++i) {
- controls[i] = (Control) Configuration.getInstance(names[i]);
- ctrlSchedules[i] = new Scheduler(names[i], false);
- }
- System.err.println("EDSimulator: loaded controls "
- + Arrays.asList(names));
-
- // Schedule controls execution
- if (controls.length > heap.maxPriority() + 1)
- throw new IllegalArgumentException("Too many control objects");
- for (int i = 0; i < controls.length; i++) {
- new ControlEvent(controls[i], ctrlSchedules[i], i);
- }
- }
-
- // ---------------------------------------------------------------------
-
- /**
- * Adds a new event to be scheduled, specifying the number of time units of
- * delay, and the execution order parameter.
- *
- * @param time
- * The actual time at which the next event should be scheduled.
- * @param order
- * The index used to specify the order in which control events
- * should be executed, if they happen to be at the same time,
- * which is typically the case.
- * @param event
- * The control event
- */
- static void addControlEvent(long time, int order, ControlEvent event) {
- // we don't check whether time is negative or in the past: we trust
- // the caller, which must be from this package
- if (time >= endtime)
- return;
- heap.add(time, event, null, (byte) 0, order);
- }
-
- // ---------------------------------------------------------------------
-
- /**
- * This method is used to check whether the current configuration can be
- * used for event driven simulations. It checks for the existence of config
- * parameter {@value #PAR_ENDTIME}.
- */
- public static final boolean isConfigurationEventDriven() {
- return Configuration.contains(PAR_ENDTIME);
- }
-
- // ---------------------------------------------------------------------
-
- /**
- * Execute and remove the next event from the ordered event list.
- *
- * @return true if the execution should be stopped.
- */
- private static boolean executeNext() {
- PriorityQ.Event ev = heap.removeFirst();
- if (ev == null) {
- System.err.println("EDSimulator: queue is empty, quitting"
- + " at time " + CommonState.getTime());
- return true;
- }
-
- long time = ev.time;
-
- if (time >= nextlog) {
- // System.err.println("Current time: " + time);
- // seemingly complicated: to prevent overflow
- while (time - nextlog >= logtime)
- nextlog += logtime;
- if (endtime - nextlog >= logtime)
- nextlog += logtime;
- else
- nextlog = endtime;
- }
- if (time >= endtime) {
- System.err.println("EDSimulator: reached end time, quitting,"
- + " leaving " + heap.size()
- + " unprocessed events in the queue");
- return true;
- }
-
- CommonState.setTime(time);
- int pid = ev.pid;
- if (ev.node == null) {
- // might be control event; handled through a special method
- ControlEvent ctrl = null;
- try {
- ctrl = (ControlEvent) ev.event;
- } catch (ClassCastException e) {
- throw new RuntimeException(
- "No destination specified (null) for event " + ev);
- }
- return ctrl.execute();
- } else if (ev.node != Network.prototype && ev.node.isUp()) {
- CommonState.setPid(pid);
- CommonState.setNode(ev.node);
- if (ev.event instanceof NextCycleEvent) {
- NextCycleEvent nce = (NextCycleEvent) ev.event;
- nce.execute();
- } else {
- EDProtocol prot = null;
- try {
- prot = (EDProtocol) ev.node.getProtocol(pid);
- // System.out.println("prot "+prot.getClass().getName());
- } catch (ClassCastException e) {
- e.printStackTrace();
- throw new IllegalArgumentException("Protocol "
- + Configuration.lookupPid(pid)
- + " does not implement EDProtocol; "
- + ev.event.getClass());
- }
- prot.processEvent(ev.node, pid, ev.event);
- }
- }
-
- return false;
- }
-
- // ---------------------------------------------------------------------
- // Public methods
- // ---------------------------------------------------------------------
-
- /**
- * Runs an experiment, resetting everything except the random seed.
- */
- public static void nextExperiment() {
- // Reading parameter
- if (Configuration.contains(PAR_PQ))
- heap = (PriorityQ) Configuration.getInstance(PAR_PQ);
- else
- heap = new Heap();
- endtime = Configuration.getLong(PAR_ENDTIME);
- if (CommonState.getEndTime() < 0) // not initialized yet
- CommonState.setEndTime(endtime);
- if (heap.maxTime() < endtime)
- throw new IllegalParameterException(PAR_ENDTIME,
- "End time is too large: configured event queue only"
- + " supports " + heap.maxTime());
- logtime = Configuration.getLong(PAR_LOGTIME, Long.MAX_VALUE);
-
- // initialization
- System.err.println("EDSimulator: resetting");
- CommonState.setPhase(CommonState.PHASE_UNKNOWN);
- CommonState.setTime(0); // needed here
- controls = null;
- ctrlSchedules = null;
- nextlog = 0;
- Network.reset();
- System.err.println("EDSimulator: running initializers");
- runInitializers();
- scheduleControls();
- // Perform the actual simulation; executeNext() will tell when to
- // stop.
- boolean exit = false;
- while (!exit) {
- exit = executeNext();
- }
-
- // analysis after the simulation
- CommonState.setPhase(CommonState.POST_SIMULATION);
- for (int j = 0; j < controls.length; ++j) {
- if (ctrlSchedules[j].fin)
- controls[j].execute();
- }
-
- }
-
- // ---------------------------------------------------------------------
-
- /**
- * Adds a new event to be scheduled, specifying the number of time units of
- * delay, and the node and the protocol identifier to which the event will
- * be delivered.
- *
- * @param delay
- * The number of time units before the event is scheduled. Has to
- * be non-negative.
- * @param event
- * The object associated to this event
- * @param node
- * The node associated to the event.
- * @param pid
- * The identifier of the protocol to which the event will be
- * delivered
- */
- public static void add(long delay, Object event, Node node, int pid) {
- //if (event instanceof NextCycleEvent)
- //System.err.println("************* edsim delay="+delay +" pid="+pid+" event="+event+" time="+CommonState.getTime());
- if (Simulator.getSimID() == 2){
- PSGSimulator.add(delay, event, node, pid);
- }
-
- else {
- if (delay < 0)
- throw new IllegalArgumentException("Protocol "
- + node.getProtocol(pid) + " is trying to add event "
- + event + " with a negative delay: " + delay);
- if (pid > Byte.MAX_VALUE)
- throw new IllegalArgumentException(
- "This version does not support more than "
- + Byte.MAX_VALUE + " protocols");
-
- long time = CommonState.getTime();
- if (endtime - time > delay) // check like this to deal with overflow
- heap.add(time + delay, event, node, (byte) pid);
- }
- }
-
-}
