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

## avrora.sim.clock
Class IntervalSynchronizer

    java.lang.Object
      avrora.sim.clock.Synchronizer
          avrora.sim.clock.IntervalSynchronizer

public class IntervalSynchronizer
extends Synchronizer

The `IntervalSynchronizer` class implements a global timer among multiple simulators by inserting periodic events into the queue of each simulator.

Nested Class Summary
`protected class` | `IntervalSynchronizer.SynchEvent` The `SynchEvent` class represents an event that is inserted into the event queue of each simulator at the same global time.

Field Summary
`protected Simulator.Event` | `action`
`protected java.lang.Object` | `condition`
`protected int` | `goal`
`protected int` | `meet_count`
`protected long` | `period` `period` is the number of cycles on a member local clock per cycle on the global clock.
`protected java.util.HashMap` | `threadMap`
`protected int` | `wait_count`
`protected avrora.sim.clock.IntervalSynchronizer.WaitSlot` | `waitSlotList`

Constructor Summary
`IntervalSynchronizer(long p, Simulator.Event a)` The constructor for the `IntervalSynchronizer` class creates a new synchronizer with the specified period, that will fire the specified event each time all threads meet at a synchronization point.

Method Summary
`void` | `addNode(Simulation.Node t)` The `addNode()` method adds a node to this synchronization group.
`void` | `adjustPeriod(long nperiod)` The `adjustPeriod()` method can be used to adjust the period of synchronization while the simulation is executing.
`protected avrora.sim.clock.IntervalSynchronizer.WaitSlot` | `checkWaiters()`
`protected avrora.sim.clock.IntervalSynchronizer.WaitSlot` | `insertWaiter(IntervalSynchronizer.SynchEvent event, long time)`
`void` | `join()` The `join()` method will block the caller until all of the threads in this synchronization interval have terminated, either through `stop()` being called, or terminating normally such as through a timeout.
`void` | `pause()` The `pause()` method temporarily pauses the simulation.
`void` | `removeNode(Simulation.Node t)` The `removeNode()` method removes a node from this synchronization group, and wakes any nodes that might be waiting on it.
`protected boolean` | `signalOthers()` The `signalOthers()` method is used to check whether the thread that has just arrived should signal other threads to continue.
`void` | `start()` The `start()` method starts the threads executing, and the synchronizer will add whatever synchronization to their execution that is necessary to preserve the global timing properties of simulation.
`protected boolean` | `stillWaiting(avrora.sim.clock.IntervalSynchronizer.WaitSlot w)`
`void` | `stop()` The `stop()` method will terminate all the simulation threads.
`void` | `synch(long globalTime)` The `synch()` method will pause all of the nodes at the same global time.
`void` | `waitForNeighbors(long time)` The `waitForNeighbors()` method is called from within the execution of a node when that node needs to wait for its neighbors to catch up to it in execution time.

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

Field Detail

### period

    protected long period

  `period` is the number of cycles on a member local clock per cycle on the global clock. Some re-coding must be done if microcontrollers running at difference speeds are to be accurately simulated.

### threadMap

    protected final java.util.HashMap threadMap

### action

    protected final Simulator.Event action

### condition

    protected final java.lang.Object condition

### goal

    protected int goal

### meet_count

    protected int meet_count

### wait_count

    protected int wait_count

### waitSlotList

    protected avrora.sim.clock.IntervalSynchronizer.WaitSlot waitSlotList

Constructor Detail

### IntervalSynchronizer

    public IntervalSynchronizer(long p,
                                Simulator.Event a)

  The constructor for the `IntervalSynchronizer` class creates a new synchronizer with the specified period, that will fire the specified event each time all threads meet at a synchronization point.

Parameters:
  `p` - the period in clock cycles which to synchronize the threads
  `a` - the event to fire each time all threads meet at a synchronization point

Method Detail

### signalOthers

    protected boolean signalOthers()

  The `signalOthers()` method is used to check whether the thread that has just arrived should signal other threads to continue.

  Returns:
    true if this thread signalled the others to continue; false if this thread should stop and wait for the other threads before continuing

### start

    public void start()

  The `start()` method starts the threads executing, and the synchronizer will add whatever synchronization to their execution that is necessary to preserve the global timing properties of simulation.

  Specified by:
    `start` in class `Synchronizer`

### join

    public void join()
              throws java.lang.InterruptedException

  The `join()` method will block the caller until all of the threads in this synchronization interval have terminated, either through `stop()` being called, or terminating normally such as through a timeout.

  Specified by:
    `join` in class `Synchronizer`
  Throws:
    `java.lang.InterruptedException`

### stop

    public void stop()

  The `stop()` method will terminate all the simulation threads. It is not guaranteed to stop all the simulation threads at the same global time.

  Specified by:
    `stop` in class `Synchronizer`

### pause

    public void pause()

  The `pause()` method temporarily pauses the simulation. The nodes are not guaranteed to stop at the same global time. This method will return when all threads in the simulation have been paused and will no longer make progress until the `start()` method is called again.

  Specified by:
    `pause` in class `Synchronizer`

### synch

    public void synch(long globalTime)

  The `synch()` method will pause all of the nodes at the same global time. This method can only be called when the simulation is paused. It will run all threads forward until the global time specified and pause them.

  Specified by:
    `synch` in class `Synchronizer`
  Parameters:
    `globalTime` - the global time in clock cycles to run all threads ahead to

### addNode

    public void addNode(Simulation.Node t)

  The `addNode()` method adds a node to this synchronization group. This method should only be called before the `start()` method is called.

  Specified by:
    `addNode` in class `Synchronizer`
  Parameters:
    `t` - the simulator representing the node to add to this group

### removeNode

    public void removeNode(Simulation.Node t)

  The `removeNode()` method removes a node from this synchronization group, and wakes any nodes that might be waiting on it.

  Specified by:
    `removeNode` in class `Synchronizer`
  Parameters:
    `t` - the simulator thread to remove from this synchronization group

### waitForNeighbors

    public void waitForNeighbors(long time)

  The `waitForNeighbors()` method is called from within the execution of a node when that node needs to wait for its neighbors to catch up to it in execution time. The node will be blocked until the other nodes in other threads catch up in global time.

  Specified by:
    `waitForNeighbors` in class `Synchronizer`

### insertWaiter

    protected avrora.sim.clock.IntervalSynchronizer.WaitSlot insertWaiter(IntervalSynchronizer.SynchEvent event,
                                                                          long time)

### checkWaiters

    protected avrora.sim.clock.IntervalSynchronizer.WaitSlot checkWaiters()

### stillWaiting

    protected boolean stillWaiting(avrora.sim.clock.IntervalSynchronizer.WaitSlot w)

### adjustPeriod

    public void adjustPeriod(long nperiod)

  The `adjustPeriod()` method can be used to adjust the period of synchronization while the simulation is executing. This is useful for adaptive types of synchronization, for example when the latency between beginning the first transmission and reception is larger than subsequent transmissions (e.g. implementing partial preamble loss). Care should be taken when calling this method! It should only be called at times when the simulation is guaranteed to be stopped at the same global time; i.e. either at a meet point or while it has been pause()'d and synch()'d.

  Parameters:
    `nperiod` - the new period in cycles

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