Overview | Package | Class | Tree | Deprecated | Index | Help
| SSJ V. 2.1.1.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## umontreal.iro.lecuyer.simprocs
Class SimProcess

    java.lang.Object
      umontreal.iro.lecuyer.simprocs.SimProcess

    public class SimProcess

extends Object

This abstract class provides process scheduling tools. Each type of process should be defined as a subclass of the class `SimProcess`, and must provide an implementation of the method `actions` which describes the life of a process of this class. Whenever a process instance starts, its `actions` method begins executing.

Just like an event, a process must first be constructed, then scheduled. Scheduling a process is equivalent to placing an event in the event list that will start this process when the simulation clock reaches the specified time. The `toString` method can be overridden to return information about the process. This information will be returned when formating the event list as a string, if the process is delayed.

A process can be in one of the following states: `INITIAL`, `EXECUTING`, `DELAYED`, `SUSPENDED`, and `DEAD` . At most one process can be in the `EXECUTING` state at any given time, and when there is one, this executing process (called the current process) is said to have control and is executing one of the instructions of its `actions` method. A process that has been constructed but not yet scheduled is in the `INITIAL` state. A process is in the `DELAYED` state if there is a planned event in the event list to activate it (give it control). When a process is scheduled, it is placed in the `DELAYED` state. It is in the `SUSPENDED` state if it is waiting to be reactivated (i.e., obtain control) without having an event to do so in the event list. A process can suspends itself by calling `suspend` directly or indirectly (e.g., by requesting a busy `Resource`). Usually, a `SUSPENDED` process must be reactivated by another process or event via the `resume` method. A process in the `DEAD` state no longer exists.

To construct new processes, the user needs to extend `SimProcess`

Note: the user needs to ensure that the `actions` method of any process can be terminated, i.e., no infinite loops. For exemple, using threads process-oriented simulator, if such a method never terminates, threads will not be recycled, causing memory problems.

Field Summary
`static int` | `DEAD` The process has terminated its execution.
`static int` | `DELAYED` The process is not executing but has an event in the event list to reactivate it later on.
`static int` | `EXECUTING` The process is the one currently executing its `actions` method.
`static int` | `INITIAL` The process has been created but not yet scheduled.
`static double` | `STARTING`
`static int` | `SUSPENDED` The process is not executing and will have to be reactivated by another process or event later on.
`static double` | `WAITING`

Constructor Summary
`SimProcess()` Constructs a new process without scheduling it and associate this new process with the default simulator, you can get additional knowledge with `Simulator` static methods.
`SimProcess(ProcessSimulator sim)` Constructs a new process assiciate with `sim` without scheduling it.

Method Summary
`void` | `actions()` This is the method that is called when this process is executing.
`boolean` | `cancel()` Cancel the activating event that was supposed to resume this process, and place the process in the `SUSPENDED` state.
`void` | `delay(double delay)` Suspends the execution of the currently executing process and schedules it to resume its execution in `delay` units of simulation time.
`double` | `getDelay()` If the process is in the `DELAYED` state, returns the remaining time until the planned occurrence of its activating event.
`int` | `getState()` Returns the state of the process.
`static void` | `init()` Deprecated.
`boolean` | `isAlive()` Returns `true` if the process is alive, otherwise `false`.
`void` | `kill()` Terminates the life of this process and sets its state to `DEAD`, after canceling its activating event if there is one.
`double` | `priority()` Return priority of the current variable.
`void` | `reschedule(double delay)` If the process is in the `DELAYED` state, removes it from the event list and reschedules it in `delay` units of time.
`void` | `resume()` Places this process at the beginning of the event list to resume its execution.
`void` | `schedule(double delay)` Schedules the process to start in `delay` time units.
`Event` | `scheduledEvent()` Returns the Event associated with the current variable.
`void` | `scheduleNext()` Schedules this process to start at the current time, by placing it at the beginning of the event list.
`void` | `setPriority(double priority)` Set the priority assigned to the current variable in the simulation.
`void` | `setScheduledEvent(Event scheduledEvent)` Sets the event associate to the current variable.
`void` | `suspend()` This method can only be invoked for the `EXECUTING` or a `DELAYED` process.

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### INITIAL

    public static final int INITIAL

  The process has been created but not yet scheduled.

  See Also:
    Constant Field Values

### EXECUTING

    public static final int EXECUTING

  The process is the one currently executing its `actions` method.

  See Also:
    Constant Field Values

### DELAYED

    public static final int DELAYED

  The process is not executing but has an event in the event list to reactivate it later on.

  See Also:
    Constant Field Values

### SUSPENDED

    public static final int SUSPENDED

  The process is not executing and will have to be reactivated by another process or event later on.

  See Also:
    Constant Field Values

### DEAD

    public static final int DEAD

  The process has terminated its execution.

  See Also:
    Constant Field Values

### STARTING

    public static final double STARTING

See Also:
  Constant Field Values

### WAITING

    public static final double WAITING

See Also:
  Constant Field Values

Constructor Detail

### SimProcess

    public SimProcess()

  Constructs a new process without scheduling it and associate this new process with the default simulator, you can get additional knowledge with `Simulator` static methods. It will have to be scheduled later on. The process is in the `INITIAL` state.

### SimProcess

    public SimProcess(ProcessSimulator sim)

  Constructs a new process assiciate with `sim` without scheduling it. It will have to be scheduled later on. The process is in the `INITIAL` state.

  Parameters:
    `sim` - Link the current variable to ProcessSimulator `sim`

Method Detail

### schedule

    public void schedule(double delay)

  Schedules the process to start in `delay` time units. This puts the process in the `DELAYED` state.

  Parameters:
    `delay` - delay, in simulation time, before the process starts

### scheduleNext

    public void scheduleNext()

  Schedules this process to start at the current time, by placing it at the beginning of the event list. This puts the process in the `DELAYED` state.

### scheduledEvent

    public Event scheduledEvent()

  Returns the Event associated with the current variable.

### setScheduledEvent

    public void setScheduledEvent(Event scheduledEvent)

  Sets the event associate to the current variable.

  Parameters:
    `scheduledEvent` - new scheduledEvent for the current variable

### priority

    public double priority()

  Return priority of the current variable.

  Returns:
    priority of the current variable.

### setPriority

    public void setPriority(double priority)

  Set the priority assigned to the current variable in the simulation. This method should never be called after the event was scheduled, otherwise the events would not execute in ascending priority order anymore.

  Parameters:
    `priority` - priority assigned to the current variable in the simulation

### isAlive

    public final boolean isAlive()

  Returns `true` if the process is alive, otherwise `false`.

  Returns:
    `true` if the process is not in the `DEAD` state

### getState

    public int getState()

  Returns the state of the process.

  Returns:
    one of the process states `INITIAL`, `EXECUTING`, `DELAYED`, `SUSPENDED`, or `DEAD`.

### getDelay

    public double getDelay()

  If the process is in the `DELAYED` state, returns the remaining time until the planned occurrence of its activating event. Otherwise, an illegal state exception will be thrown printing an error message.

  Returns:
    remaining delay before the process starts
  Throws:
    `IllegalStateException` - if the process is not in `DELAYED` state

### reschedule

    public void reschedule(double delay)

  If the process is in the `DELAYED` state, removes it from the event list and reschedules it in `delay` units of time. Example: If the process `p` has called `delay` `(5.0)` at time 10.0, and another process invokes `reschedule` `(p, 6.2)` at time 13.5, then the process `p` will resume at time 13.5 + 6.2 = 19.7.

  Parameters:
    `delay` - new delay, in simulation time units, before the process starts or is resumed

### resume

    public void resume()

  Places this process at the beginning of the event list to resume its execution. If the process was `DELAYED`, cancels its earlier activating event.

### cancel

    public boolean cancel()

  Cancel the activating event that was supposed to resume this process, and place the process in the `SUSPENDED` state. This method can be invoked only for a process in the `DELAYED` state.

  Returns:
    `true` if the process was canceled successfully

### delay

    public void delay(double delay)

  Suspends the execution of the currently executing process and schedules it to resume its execution in `delay` units of simulation time. It becomes in the `DELAYED` state. Only the process in the `EXECUTING` state can call this method.

### suspend

    public void suspend()

  This method can only be invoked for the `EXECUTING` or a `DELAYED` process. If the process is `EXECUTING`, suspends execution. If the process is `DELAYED`, cancels its activating event. This places the process in the `SUSPENDED` state.

### kill

    public void kill()

  Terminates the life of this process and sets its state to `DEAD`, after canceling its activating event if there is one.

### actions

    public void actions()

  This is the method that is called when this process is executing. Every subclass of `SimProcess` that is to be instantiated must provide an implementation of this method.

### init

    @Deprecated
    public static void init()

  Deprecated.

  This method calls `ProcessSimulator.initDefault()`, which initializes the default simulator to use processes.

Overview | Package | Class | Tree | Deprecated | Index | Help
| SSJ V. 2.1.1.
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

To submit a bug or ask questions, send an e-mail to Pierre L'Ecuyer.