Simulator

java.lang.Object
- sime.Simulator

```
public class Simulator
extends java.lang.Object
```
The main class of a simple simulator for TCP congestion control.
Check also the design documentation for this simulator.
The simulator provides the system clock ticks for time progression and orchestrates the work of the network nodes. The simulated network consists of the network elements of sender-host, router, and receiver-host, connected in a chain as follows:
```
  SENDER <-> NETWORK/ROUTER <-> RECEIVER 
 
```
The sender host sends only data segments and the receiver host only replies with acknowledgments. In other words, for simplicity we assume unidirectional transmission.

By default, the simulator reports the values of the congestion control parameters for every iteration:
1. Iteration number (starting value 1), which is also the simulation clock, in the units of round-trip times (RTTs)
2. Congestion window size in this iteration
3. Effective window size in this iteration
4. Flight size (the number of unacknowledged bytes) in this iteration
5. Slow start threshold size in this iteration
At the end of the simulation, the utilization of the sender is reported.

You can turn ON or OFF different levels of reporting by modifying the variable currentReportingLevel.

Only a few parameters can be controlled in this simulator. Rather than have a flexible, multifunctional network simulator that takes long time to understand and use, this simulator is simple for an undergraduate student to understand and use during a semester-long course. The students can modify it with modest effort and study several interesting simulation scenarios described in the design documentation.
Author:

Ivan Marsic

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`currentReportingLevel` This field specifies the current reporting level(s) for this simulator. The minimum possible reporting is obtained by setting the zero value.
`private double`	`currentTime` Simulation iterations represent the clock ticks for the simulation.
`private Link`	`link1` The communication link that connects `senderEndpt` to `router`.
`private Link`	`link2` The communication link that connects `receiverEndpt` to `router`.
`private Endpoint`	`receiverEndpt`
`static int`	`REPORTING_LINKS` Simulator's reporting flag: Reports the activities of communicaTtion links (`Link`).
`static int`	`REPORTING_RECEIVERS` Simulator's reporting flag: Reports the activities of `Receiver`.
`static int`	`REPORTING_ROUTERS` Simulator's reporting flag: Reports the activities of `Router`.
`static int`	`REPORTING_RTO_ESTIMATE` Simulator's reporting flag: Reports the activities of `RTOEstimator`.
`static int`	`REPORTING_SENDERS` Simulator's reporting flag: Reports the activities of `Sender` and its `SenderState`.
`static int`	`REPORTING_SIMULATOR` Simulator's reporting flag: Reports the activities of the simulator runtime environment.
`private Router`	`router` The router that intermediated between the TCP endpoints.
`private Endpoint`	`senderEndpt` Two endpoints of the TCP connection that will be simulated.
`private java.util.ArrayList<TimerSimulated>`	`timers` An array of timers that the simulator has currently registered, which are associated with `TimedComponent`. To deal with concurrent events, it is recommended that timers are fired (if expired) after the component's functional operation is called.
`static int`	`TOTAL_DATA_LENGTH` Total data length to send (in bytes).

Constructor Summary

Constructors
Constructor and Description
`Simulator(java.lang.String tcpSenderVersion_, int bufferSize_, int rcvWindow_)` Constructor of the simple TCP congestion control simulator.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`cancelTimeout(TimerSimulated timer_)` Allows a component to cancel a running timer.
`void`	`checkExpiredTimers(TimedComponent component_)` The simulator checks if any running timers expired because the simulation clock has ticked.
`double`	`getCurrentTime()` Returns the current "time" since the start of the simulation.
`double`	`getTimeIncrement()` Time increment ("tick") for the simulation clock.
`static void`	`main(java.lang.String[] argv_)` The main method.
`void`	`run(java.nio.ByteBuffer inputBuffer_, int num_iter_)` Runs the simulator for the given number of transmission rounds (iterations), starting with the current iteration stored in the parameter `currentTime`. Reports the outcomes of the individual transmissions.
`TimerSimulated`	`setTimeoutAt(TimerSimulated timer_)` Allows a component to start a timer running.

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

- Field Detail
  - currentReportingLevel
```
public static int currentReportingLevel
```
    This field specifies the current reporting level(s) for this simulator.
    The minimum possible reporting is obtained by setting the zero value.
  - currentTime
```
private double currentTime
```
    Simulation iterations represent the clock ticks for the simulation. Each iteration is a transmission round, which is one RTT cycle long. The initial value by default equals "1.0".
  - link1
```
private Link link1
```
    The communication link that connects senderEndpt to router.
  - link2
```
private Link link2
```
    The communication link that connects receiverEndpt to router.
  - receiverEndpt
```
private Endpoint receiverEndpt
```
  - REPORTING_LINKS
```
public static final int REPORTING_LINKS
```
    Simulator's reporting flag:
    Reports the activities of communicaTtion links (Link).
    
    See Also:
    Constant Field Values
  - REPORTING_RECEIVERS
```
public static final int REPORTING_RECEIVERS
```
    Simulator's reporting flag:
    Reports the activities of Receiver.
    
    See Also:
    Constant Field Values
  - REPORTING_ROUTERS
```
public static final int REPORTING_ROUTERS
```
    Simulator's reporting flag:
    Reports the activities of Router.
    
    See Also:
    Constant Field Values
  - REPORTING_RTO_ESTIMATE
```
public static final int REPORTING_RTO_ESTIMATE
```
    Simulator's reporting flag:
    Reports the activities of RTOEstimator.
    
    See Also:
    Constant Field Values
  - REPORTING_SENDERS
```
public static final int REPORTING_SENDERS
```
    Simulator's reporting flag:
    Reports the activities of Sender and its SenderState.
    
    See Also:
    Constant Field Values
  - REPORTING_SIMULATOR
```
public static final int REPORTING_SIMULATOR
```
    Simulator's reporting flag:
    Reports the activities of the simulator runtime environment.
    
    See Also:
    Constant Field Values
  - router
```
private Router router
```
    The router that intermediated between the TCP endpoints.
  - senderEndpt
```
private Endpoint senderEndpt
```
    Two endpoints of the TCP connection that will be simulated.
  - timers
```
private java.util.ArrayList<TimerSimulated> timers
```
    An array of timers that the simulator has currently registered, which are associated with TimedComponent.
    To deal with concurrent events, it is recommended that timers are fired (if expired) after the component's functional operation is called. See the design documentation for more details.
    
    See Also:
    TimedComponent
  - TOTAL_DATA_LENGTH
```
public static final int TOTAL_DATA_LENGTH
```
    Total data length to send (in bytes). In reality, this data should be read from a file or another input stream.
    
    See Also:
    Constant Field Values
- Constructor Detail
  - Simulator
```
public Simulator(java.lang.String tcpSenderVersion_,
         int bufferSize_,
         int rcvWindow_)
```
    Constructor of the simple TCP congestion control simulator. Configures the network model: Sender, Router, and Receiver. The input arguments are used to set up the router, so that it represents the bottleneck resource.
    
    Parameters:
    tcpSenderVersion_ - the TCP version of the sending endpoint—one of: "Tahoe", "Reno", or "NewReno")
    bufferSize_ - the memory size for the Router to queue incoming packets
    rcvWindow_ - the size of the receive buffer for the Receiver
- Method Detail
  - cancelTimeout
```
public void cancelTimeout(TimerSimulated timer_)
                   throws java.lang.NullPointerException,
                          java.lang.IllegalArgumentException
```
    Allows a component to cancel a running timer.
    
    Parameters:
    timer_ - a running timer to be cancelled.
    
    Throws:
    
    java.lang.NullPointerException
    
    java.lang.IllegalArgumentException
  - checkExpiredTimers
```
public void checkExpiredTimers(TimedComponent component_)
```
    The simulator checks if any running timers expired because the simulation clock has ticked. If yes, it fires a timeout event by calling the callback.
    
    Note that to deal with with synchronization between concurrent events, the caller decides which timers will be checked when. It is just to expect the caller to know such information. In the current implementation, this method is called from Endpoint.send(NetworkElement, Packet) and Endpoint.handle(NetworkElement, Packet).
    
    Parameters:
    component_ - the timed component for which to check the expired timers
  - getCurrentTime
```
public double getCurrentTime()
```
    Returns the current "time" since the start of the simulation. The time is currently measured in the integer multiples of the simulation clock "ticks".
    
    Returns:
    Returns the current iteration of this simulation session.
  - getTimeIncrement
```
public double getTimeIncrement()
```
    Time increment ("tick") for the simulation clock. Right now we simply assume that each round takes 1 RTT (and lasts unspecified number of seconds).
    
    Returns:
    the time increment (in ticks) for a round of simulation.
  - main
```
public static void main(java.lang.String[] argv_)
```
    The main method. Takes the number of iterations as the input and runs the simulator. To run this program, two arguments must be entered:
```
 TCP-sender-version (one of Tahoe/Reno/NewReno) AND number-of-iterations
 
```
    Parameters:
    argv_ - Input argument(s) should contain the version of the TCP sender (Tahoe/Reno/NewReno) and the number of iterations to run.
  - run
```
public void run(java.nio.ByteBuffer inputBuffer_,
       int num_iter_)
```
    Runs the simulator for the given number of transmission rounds (iterations), starting with the current iteration stored in the parameter currentTime.
    Reports the outcomes of the individual transmissions. At the end, reports the overall sender utilization.
    
    Note: The router is invoked to relay only the packets (and it may drop some of them). For the sake of simplicity, the acknowledgment segments simply bypass the router, so they are never dropped.
    
    Parameters:
    inputBuffer_ - the input bytestream to be transported to the receiving endpoint
    num_iter_ - the number of iterations (transmission rounds) to run the simulator
  - setTimeoutAt
```
public TimerSimulated setTimeoutAt(TimerSimulated timer_)
                            throws java.lang.NullPointerException,
                                   java.lang.IllegalArgumentException
```
    Allows a component to start a timer running. The timer will fire at a specified time. The timer can be cancelled by calling the method cancelTimeout(TimerSimulated).
    
    Note that the timer object is cloned here, because the caller may keep reusing the original timer object, as is done in, e.g., Sender.startRTOtimer().
    
    Parameters:
    timer_ - a timer to start counting down on the simulated time.
    
    Returns:
    the handle on the timer, so the caller can cancel this timer if needed
    
    Throws:
    
    java.lang.NullPointerException
    
    java.lang.IllegalArgumentException

Class Simulator

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

currentReportingLevel

currentTime

link1

link2

receiverEndpt

REPORTING_LINKS

REPORTING_RECEIVERS

REPORTING_ROUTERS

REPORTING_RTO_ESTIMATE

REPORTING_SENDERS

REPORTING_SIMULATOR

router

senderEndpt

timers

TOTAL_DATA_LENGTH

Constructor Detail

Simulator

Method Detail

cancelTimeout

checkExpiredTimers

getCurrentTime

getTimeIncrement

main

run

setTimeoutAt