NS Simulation Basic

Common NS classes
- The following figure shows the most commonly used NS classes in writing a network simulation:
- A quick overview on these classes:
  1. Node: simulate routers . They simulate the IP protocol layer.
  2. Links: links are created using the duplex-link method call in an NS simulation object.
  3. Agent/TCP/Reno and Agent/TCP/Tahoe: simulate the Sending TCP protocol layer.
    A Agent/TCP/Reno or Agent/TCP/Tahoe needs to be attached to some Node (see figure)
    
    Also, a Agent/TCP/Reno or Agent/TCP/Tahoe need to be associated with a Agent/TCP/Sink !
  4. Agent/TCP/Sink: simulate the Receiving TCP protocol layer.
    A Agent/TCP/Sink sends ACK packets and needs to be attached to some Node (see figure)
  5. Application/FTP: simulate an continuously transmitting agent that uses a TCP protocol (Tahoe, Reno, or some other version of TCP)
    A Application/FTP needs to be attached to some TCP agent (see figure)
    
    The Application/FTP does not need to be asscoiated with a receiver:
    - The FTP agent triggers the TCP agent to transmit packets
    - TCP packets are acknowledged by the asscociated TCP-Sink
    - When the TCP source receives the ACK, it reports to the associated FTP agent that it can transmit more.

Steps in writing a network simulation in NS

Create the network:
1. Create nodes (routers): click here
2. Connect the nodes with (duplex) links: click here
Define transport sources and sinks at end point nodes
1. Create transport source agents (Agent/TCP/Reno) and transport sink agents (Agent/TCP/Sink)
2. Associate the transport source/sink agent to a end point node
3. Connect a source transport agent to a transport sink agent
Put traffic load (Application/FTP) on the transport sources

Using NS
- In order to use the NS simulator, you need to create a Simulator object
  The Simulator object is the network simulation system and provides many methods needed to construct the network simulation.
- How to create a Simulator object:
  new Simulator
- Example:
  set ns [new Simulator]
  You only need one Simulator object
  
  If you look in the source of a NS script, you will always see this statement at the top of the program !
Creating Nodes in NS
- The Node class in NS is used to simulate routers
- The node must be created through the special method node defined in the Simulator class.
  The following expression will return a Node object in NS that you use to simulate ONE router:
  set ns [new Simulator] [$ns node]
- Use a set command to remember the Node object in some variable (e.g., n0):
  set ns [new Simulator] set n0 [$ns node]
- If you need to create a lot of routers, use a for loop.
  Example: create Nodes n(0), n(1), ..., n(9):
  for {set i 0} {$i < 10} {incr i} {
  set n($i) [$ns node]
  }
Creating Links in NS
- Links in NS are used to provide connectivity between Nodes (routers)
- Links is not implemented as a class, but as a part of the Simulator object
- Links have a number of properties:
  1. Duplex (bi-directional) or Simplex (uni-directional)
    BTW, a duplex link is actually 2 simplex links..
  2. Bandwidth (data transmission rate)
    Units: b (#bits/sec), Mb (#Megabits/sec)
  3. Propagation delay
    Units: s (seconds), ms (milliseconds)
  4. Queue management: specifies how packets in the queue are managed
    Some commonly used values:
    - DropTail: drop the last arriving packet when queue is full
    - RED: Random Early Drop method (this method tries to break the TCP Synchronization Syndrome)
    - DDR: Deficit Round Robin method (research material)
    - FQ: Fair Queuing method (research material)
    - SFQ: Stochastic Fair Queuing method (research material)
    We will mostly use DropTail
- Example: duplex (bi-directional) link, 10 Mbps, 10 msec delay
  set n0 [$ns node]
  set n1 [$ns node] $ns duplex-link $n0 $n1 10Mb 10ms DropTail
NS Programming trick: More flexible way to create links
- Often, you want to experiment with the same network configuration but using different bottleneck link capacities.
  For example, the bottleneck link is f times the normal bandwidth in other network links
- Trick:
  set bw 10
  set f 0.5 $ns duplex-link $n0 $n1 [expr $bw]Mb 10ms DropTail
  $ns duplex-link $n0 $n1 [expr $f*$bw]Mb 10ms DropTail
Link: Changing its buffer size
- You can change the buffer size of one particular link using the $ns queue-limit method
- Example: set the queue length to 10 packets
  $ns duplex-link $n0 $n1 10Mb 10ms DropTail $ns queue-limit $n0 $n1 10
Link: Changing the default buffer size of all links
- Links in NS are created with a certain default queue size
- Each class (DropTail, RED, FQ, etc) of queue has its own default queue size
- You can change the buffer size of a class of queue using the set queue-limit command in the class Queue/QUEUE-CLASS
- Example: set the default queue length of DropTail queues to 10 packets
  Queue/DropTail set queue-limit $n0 $n1 10
Routing in NS
- After you created the nodes and connected them through links, NS will provide Internet routing automatically
- So, after created the nodes and connected them through links, you have an Internet.
- All you need to do now is:
  - Add transport protocol to the end point nodes (no need to do so to intermediate nodes)
  - Add traffic (load)

Transport Layer Protocol modules

For one reason or another, the transport protocol modules in NS are called agents
There are an ever increasing number of sending transport agents (because people are developing new TCP transmission protocols to improve network performance.
There are 2 receiving transport agents that sends back ACKs to the sending agent.
The most commonly used sending transport protocol modules are:
Agent/TCP/Tahoe: TCP Tahoe

Agent/TCP/Reno: TCP Reno

Agent/TCP/Newreno: Improved TCP Reno that paces the transmission interval

Agent/TCP/Vegas: TCP Vegas
Example:
set tcp1 [new Agent/TCP/Reno]

The most commonly used receiving transport protocol modules are:

Agent/TCPSink: sends ACK packet immediately after receiving a packet
Agent/TCPSink/DelAck: ACK is delayed. Receiver sends ACK packet after receiving 2 packets or after a certain delay (tries to reduce number of ACK packets)

Example:

  set sink1 [new Agent/TCPSink]

Connecting Transport Protocol Agents to Nodes
- Transport agents are end points of communication
  They can be attached to any Node object
- You can attach multiple Transport agents to one Node object
- The attach-agent command in a Simulator object is used to associate a Transport agents to a Node:
  $ns attach-agent NODE TCP-Agent
- Example:
  set ns [new Simulator] set node1 [$ns node]
  set tcp1 [new Agent/TCP/Reno] $ns attach-agent $node1 $tcp1

Connecting a Sending Transport Agent to a Receiving Transport Agent

Transport agents are end points of communication
We need to tell NS the destination of each sending Transport Agent.

The destination must be a receiving Transport Agent.
In order to tell NS where to transmit the packets, we need to connect a sending communication end points to a receiving communication end points
This is done through the NS method: connect SOURCE DESTINATION

Example:

  set ns [new Simulator]       

  set tcp1 [new Agent/TCP/Reno]

  set sink1 [new Agent/TCPSink]       

  (tcp1 and sink1 must also be attached to nodes, this step is omitted)    

  $ns connect  $tcp1  $sink1

This will make NS route all packets from the source tcp1 towards the destination sink1

Some Parameters of the TCP module
- After a TCP agent has been created, you can set some of its parameters (using the set command of the TCP agent)
- The most useful parameters are:
  1. packetSize_: the packet size used by TCP (default packet size is 1000 bytes)
  2. maxcwnd_: the maximum of CWND (0 means infinite)
  3. window_: the Advertised Window size
- Example:
  set tcp1 [new Agent/TCP/Reno] $tcp1 set packetSize_ 552
- NOTE: recall that the set method without arguments will return the value of the variable !
  Example:
  set tcp1 [new Agent/TCP/Reno] set pksize [$tcp1 set packetSize_] // get packetzise used
Generating Traffic for TCP
- The standard traffic generator for TCP protocol is the FTP application.
- The FTP application transmits continuously - as long as the TCP protocol permits.
- FTP application are created using:
  new Application/FTP
- Example:
  set ftp1 [new Application/FTP]
Associating FTP Traffic Generator with a TCP protocl module
- You need to associate a FTP traffic generator with a sending TCP module
- The association is made using the attach-agent method defined in the Application/FTP class.
- Example:
  set tcp1 [new Agent/TCP/Reno]
  set ftp1 [new Application/FTP] $ftp1 attach-agent $tcp1
Starting the FTP traffic generator
- The FTP traffic generator is run (started) using the start method defined in the Application/FTP class.
- Example:
  set ftp1 [new Application/FTP] $ftp1 start // Start the FTP application
Stopping the FTP traffic generator
- The FTP traffic generator canbe stopped using the stap method defined in the Application/FTP class.
- Example:
  set ftp1 [new Application/FTP] $ftp1 stop // Stop the FTP application
- NOTE: the TCP module does not need to be stopped and in fact, cannot be stopped.
  When the FTP traffic generator stops generating traffic, TCP will have no data to send and will "go quiet".
  
  You can start the FTP again after stopping it.

http://www.mathcs.emory.edu/~cheung/Courses/558-old/Syllabus/90-NS/2-NS-Prog/ns.html#links

秒客网

NS Simulation Basic

NS Simulation Basic

相关文章