Simple Data Link Protocols

Transcription

1 Simple Data Link Protocols Goals 1) Become familiar with Network Simulator 2 2) Simulate Stop & wait and Sliding Window 3) Investigate the effect of channel with loss on link utilization Introduction Data Link Layer deals with the algorithms required to achieve reliable, efficient peer to peer communication using the physical layer. These algorithms are designed to provide appropriate services to the network layer such as acknowledged connection oriented services. Several algorithms can be used to provide such a service and the objective of this exercise is to study the concepts of these algorithms. To provide a reliable service in which the data link at the transmitter node can be perfectly sure about the delivery of each frame to the destination, it should receive a feedback from the receiver acknowledging the correct reception of the transmitted frame. This acknowledgement (ACK) can also be used to control the data flow from the source to the destination. A transmitter would not send frames until it receives permission from destination (an ACK for the previous frame) and therefore cannot overflow the receiver. The simplest protocol that can be used for these purposes is called Stop and Wait. In this protocol, the transmitter sends one frame and then waits for an ACK from the receiver before sending the next frame. To avoid a deadlock which can be caused by a lost frame or a lost ACK, the transmitter can use a timer. When the delay in receiving the ACK exceeds a certain amount (time-out), the transmitter assumes something (the packet or its ACK) has been lost and re-transmits the frame. This protocol works well if the propagation time (the time it takes for the frame to propagate from source to destination) is small compared to the frame time span. There are many situations in which this is a valid assumption. However, when the propagation delay is no longer a negligible factor, this protocol is Dr. M. R. Pakravan 1

2 a wasteful protocol that uses the system resources inefficiently. The window-based protocols can be used to increase the efficiency of the system by allowing the transmission of a few packets (As much as specified by the transmitter window size) before allowing the reception of an ACK from the receiver. This would create a pipeline of un-acknowledged frames at the transmitter. The Go Back-N and Selective Repeat protocols are two protocols that can increase the efficiency of the transmission using this concept. In Go Back-N protocol, the transmitter would go back N frames and re-start the transmission again if it does not receive neither an ACK for a frame nor a negative acknowledgement (NACK) for it. In Selective Repeat, the transmitter would only send those frames which have timed out on ACK or have received a NACK for them. Appropriate use of timers in these protocols would prevent deadlocks. In this exercise, we try to become familiar with the network simulator NS package and learn to use it properly to investigate the properties of data link layer protocols. I) Stop and Wait Protocol In this part we want to run a simulation to investigate the dependency of link utilization on the frame length in Stop and Wait protocol. We use NS to generate an output file containing two columns. The first column is frame length and the second column is the transmitter bandwidth for that frame length. Link utilization is defined as: Transmitter bandwidth Link bandwidth Where for a special time interval T you can find the Transmitter bandwidth as follow: Number of frames sent during T Number of bytes in each frame To get a correct result T should be large enough compared to link delay. You will set the link bandwidth yourself and therefore, the link bandwidth is also known. Now you can write a small program in MATLAB to find link utilization and plot it. In first step you should write a Tcl (pronounced "tickle", not T-c-l!) script, you can write it in any text editor such as Notepad++ and save it with tcl extension (*.tcl). At the first line of your code, create a new simulator object by this command: (Be careful of Capital letters. Tcl is a case sensitive language!) #Make New Simulator set ns [new Simulator] Dr. M. R. Pakravan 2

3 The next step is to command NS to generate output files. Usually two output file formats are produced by NS (NAM and trace files). The NAM file will be the input to another program called NAM to show a graphical representation of the packet flow. The trace type is a file recording all the parameters during simulation. The NAM and trace files usually have large sizes especially when the simulation duration is long. Therefore, if you command NS to create these files, you should wait a while to allow the simulation to finish its job and produce the files. These files should be opened at the beginning of the script and they are closed at the end of the script. #Nam output file set namfile [open output.nam w] #trace output file set tracefile[open trace.tr w] You will also need other output text files that should be filled by your code manually. Open them as follows: #Output files to store Link Utilization set transmitterbw1 [open part1.txt w] set transmitterbw2 [open part2.txt w] Now, write a procedure and call it at the end of the simulation to close the output files and run NAM to see the output: #To finish the job by removing all the traces and closing output files proc finish {} { global ns namfile transmitterbw1 transmitterbw2 tracefile $ns flushtrace close $transmitterbw1 close $transmitterbw2 close $tracefile close $namfile exec nam out.nam & exit 0 } Add this command to your code to write all packets properties and conditions in NAM file. #Let the nam output file trace the entire process $ns namtraceall $namfile Dr. M. R. Pakravan 3

4 The next step is to define a network with 3 nodes. In our scenario, node n(0) sends data link frames to node n(1) using the stop & wait protocol, as well node n(2) sends data link frames to node n(1) using the sliding window protocol. At this step, we will create the entire topology, but just one of the links is active for testing the stop & wait protocol (n(0)-n(1)). In the following figure, you see the topology of the network: The following lines define nodes for your network: #define three nodes set n(0) [$ns node] set n(1) [$ns node] set n(2) [$ns node] You can set the color of the nodes with the following codes: $n(0) color "red" $n(2) color "black" $n(1) color "blue" Also, you can add annotations to the nodes. To do so, use: $ns at 0.0 "$n(0) label Stop-Wait-Sender" $ns at 0.0 "$n(2) label Sliding-Win-Sender" $ns at 0.0 "$n(1) label Receiver" Dr. M. R. Pakravan 4

5 Two nodes n(0) and n(1) are connected by a duplex-link with a 2Mb bandwidth, 2ms delay and DropTail queue format. The link n(1)-n(2) is also duplex, DropTail link with a bandwidth of 2Mb and delay of 2ms (refer to ns2 documents for further details about these specifications). set LineBW(1) 0.5Mb set LineDelay(1) 10ms set LineBW(2) 0.5Mb set LineDelay(2) 10ms #define link between nodes $ns duplex-link $n(0) $n(1) $LineBW(1) $LineDelay(1) DropTail $ns duplex-link $n(2) $n(1) $LineBW(2) $LineDelay(2) DropTail The following lines set the link position in network animator. #set the link position in network animator $ns duplex-link-op $n(0) $n(1) orient right $ns duplex-link-op $n(0) $n(1) color "black" $ns duplex-link-op $n(2) $n(1) orient left $ns duplex-link-op $n(2) $n(1) color "black" To send and receive data you need to put agents over nodes. NS does not support agents in Data link layer; however, it has TCP and UDP agents in transport layer. Transport layer and data link Layer have some common tasks such as flow control; therefore, TCP agents can also implement the sliding window protocol and act the same as sliding window agents. However, they do not have a constant window size and change their window size dynamically. In this part we want a Stop and Wait agent. This is like a sliding window agent with a window size of 1. By a little trick you can make a TCP agent act like this. Just set its maximum window size to 1 so that it cannot increase its window size or decrease it and it will have the constant window size equal to 1. There are some other parameters related to a TCP source. Here are some of them: maxcwnd_: maximum congestion window size windowinit_: initial window size in slow start seqno_ : highest sequence number for data from data source to TCP ack_ : highest ack seen from receiver Dr. M. R. Pakravan 5

6 To create a TCP agent, use the following command: #Create a TCP agent set tcp(1) [new Agent/TCP] Now attach the agent to desired node (here for example n (0)): $ns attach-agent $n(0) $tcp(1) The required parameters of the TCP agent can be set as follows: $tcp(1) set window_ 1 #this command set the upper bound on advertised window 1 $tcp(1) set maxcwnd_ 1 #this command set maximum congestion window size 1 $tcp(1) set maxseq_ #this command set highest sequence number for data from data source to TCP to All agents require a source to generate traffic for them. FTP application can be used for this purpose. You should first create an FTP application with constant bit rate (CBR) and then, attach it to your TCP agent using the following lines: #generate traffic and attach it to agent set ftp(1) [new Application/FTP] $ftp(1) attach-agent $tcp(1) Note that you need two instances of FTP application, one for each TCP agent. You also need an agent in receiver that acts as traffic sink. It receives packets and sends acknowledgements. Two of such agents should be created and both should be connected to n(1). For instance: #create an agent for receiver and attach it to agent set tcpsnk(1) [new Agent/TCPSink] $ns attach-agent $n(1) $tcpsnk(1) #connect 2 TCP agents to each other $ns connect $tcp(1) $tcpsnk(1) You can also change the color of the frames (for a better visualization) using the following lines: $ns color 1 red $tcp(1) set fid_ 1 Dr. M. R. Pakravan 6

7 Additionally, some initializations are also required: #set header size to 40 byte set headersize 40 #set frame length to 30 byte set framelen 30 #set the time interval to 2 second set timeinterval 2.0 set firstacknum(1) [$tcp(1) set ack_] set lastacknum(1) [$tcp(1) set ack_] #set packet size $tcp(1) set packetsize_ $framelen Now, write a procedure which is called every 2 seconds to record the transmitter bandwidth. To find the source bandwidth you can use the following approach: Each ack that a TCP source receives has a sequence number. In reality, the sequence number is not a large number so it will wrap around after a while. But you can set the maximum sequence number for the TCP source to a large enough number so that it will not wrap around. The change in sequence number of ack packets in any time interval equals to the number of packets received during that timeinterval. The record procedure is called once in the main program and it will call itself again and again. In this procedure, the number of received bytes in a 2 sec interval and the frame length are written to a file. The frame length is then incremented for the next interval. This procedure could be written using the following lines: #Procedure to record the events proc record {} { #Define global variables global transmitterbw1 framelen tcp ns firstacknum lastacknum headersize timeinterval n #Get the ack number of current frame set lastacknum(1) [$tcp(1) set ack_ ] #Compare this ack number with the one regarding 2 seconds before in order to determine transmitter bandwidth set bw(1) [expr ($lastacknum(1)+1-$firstacknum(1))*($framelen + $headersize)*8] set now [$ns now] #Fill the respective text files with transmitterbw1 puts $transmitterbw1 "[expr ($framelen+$headersize)] [expr ($bw(1))/($timeinterval)] $now*" #Record this ack number for next loop: set firstacknum(1) $lastacknum(1) Dr. M. R. Pakravan 7

8 #Increasing the frame length for next packet: set framelen [expr ($framelen+10)] $tcp(1) set packetsize_ $framelen #Execute this proc every 2 second (timeinterval=2) $ns at [expr $now+$timeinterval] "record" } According to all of these, first, you should start FTP applications (in the first part of the exercise, you just need the FTP application to be turned on between n(0) and n(1), in the rest of the exercise, you will need to turn on the next one), then the record procedure should be called and finally, the finish procedure should be executed at the end of simulation time. By these lines, you can execute all of the mentioned tasks in the right time and then start the simulation: $ns at 1.0 "$ftp(1) start" $ns at 3.0 "record" $ns at "finish" $ns run Note: To save more points in the output file we have adapted such a big number for Simulation time. So it may take a long time for the simulation to be finished because NS wants to create a large file for NAM. If you want the simulation to run much faster, don t command NS to generate any NAM output file. You can see the simulation timer in Command DOS environment or in UNIX terminal Using puts $now. At the end of the simulation you can see the generated text file (for the connection between nodes n(0) and n(1)) in addition to the automatically generated Trace file. Use MATLAB to normalize the second column of the text file by the link bandwidth and plot it versus the first column (frame length). Find link utilization for link delays of 1ms, 10ms, 20ms, 30ms and 50ms and then plot link utilization versus link delay. Find link utilization for bandwidths of 1Mb, 10Mb, 20Mb, 30Mb, 40Mb and 50Mb with link delay of 10 ms and then plot link utilization against link bandwidth. II) Sliding Window Protocol Using stop and wait protocols for links with high delay wastes much time due to waiting for the acknowledgements. For achieving better efficiency, we can use Sliding window protocols instead. Create tcp (2) between node (2) (as the source node) and node (1) (as the sink node). In this part, we want to find the relation between link utilization and window size for the sliding window protocol. The Dr. M. R. Pakravan 8

9 approach is the same as the first part except that we record the window size instead of frame length and the window size is incremented each time the record procedure is called. To do so, we add details to our simulation by making a data link connection between n(1) and n(2), using sliding window protocol instead of stop and wait protocol. We increase the window size in each call of the record procedure. Therefore, it should be modified as follows (note that stop and wait is just a sliding window protocol with window size equal to 1): #Procedure to record the events proc record {} { #Define global variables global transmitterbw2 framelen tcp ns firstacknum lastacknum headersize timeinterval n #Get the ack number of current frame set lastacknum(2) [$tcp(2) set ack_ ] #Compare this ack number with the one regarding 2 seconds before in order to determine transmitter bandwidth set bw(2) [expr ($lastacknum(2)+1-$firstacknum(2))*($framelen + $headersize)*8] set now [$ns now] set wind [$tcp(2) set window_] set maxwind [$tcp(2) set maxcwnd_] #Fill the respective text files with transmitterbw2 puts $transmitterbw2 "$wind [expr ($bw(2))/($timeinterval)] $now*" #Record this ack number for next loop: set firstacknum(2) $lastacknum(2) #Increasing the window size for next packet: $tcp(2) set window_ [expr ($wind+1)] $tcp(2) set maxcwnd_ [expr ($maxwind+1)] #Execute this proc every 2 second (timeinterval=2) Dr. M. R. Pakravan 9

10 $ns at [expr $now+$timeinterval] "record" } Note: real size of a TCP packet is not what you have set with packetsize_ parameter. There is an overhead. Set the size of packets to a number and run the simulation. In the NAM window right click on a packet and monitor it. Nam will show you the real size of the packet and you can find out how many overhead bytes are present. If you don t consider this overhead you will never have the link utilization equal to one. Run NS and use the output file to plot the link utilization versus window size. III) Stop & Wait vs. Sliding Window Protocol In this part, we want to compare sliding window protocol with stop and wait protocol. To do this, we should turn on both FTP application, tcp(1) between n(0) and n(1) as well tcp(2) between n(2) and n(1). Dr. M. R. Pakravan 10

11 For this, you can use: $ns at 1.0 "$ftp(1) start" $ns at 1.0 "$ftp(2) start" $ns at 3.0 "record" $ns at "finish" $ns run Now, we want to vary frame length and calculate link utilization of both protocols. For this, you should set the window size and maximum window size of stop and wait protocol to 1. For sliding window protocol, you should set window size and maximum window size to 2, 4, 6 and 8. (You should do the simulation four times for these amounts of window size). To do so, you can use the following code: $tcp(1) set window_ 1 #this command set the upper bound on advertised window 1 $tcp(1) set maxcwnd_ 1 #this command set maximum congestion window size 1 $tcp(1) set maxseq_ #this command set highest sequence number for data from data source to TCP to $tcp(2) set window_ 2 #this command set the upper bound on advertised window 1 $tcp(2) set maxcwnd_ 2 #this command set maximum congestion window size 1 $tcp(2) set maxseq_ #this command set highest sequence number for data from data source to TCP to Now, you should write a procedure to change frame length (window size is fixed) and calculate link utilization of both protocols. You can use the procedure used in part I and modify it with for command. The structure of for command in NS is as follow: for {set i 1} {$i<3} {incr i} { #Get the ack number of current frame set lastacknum($i) [$tcp($i) set ack_ ] #Compare this ack number with the one regarding 2 seconds before in order to determine transmitter bandwidth set bw($i) [expr ($lastacknum($i)+1-$firstacknum($i))*($framelen + $headersize)*8] } Dr. M. R. Pakravan 11

12 Then, you should plot link utilization versus frame length for the stop and wait and the sliding window protocols in a single figure. (Four separate figures for the window size equals to 2, 4, 6 and 8). IV) Sliding Window Protocol with lossy channel In this part, we want to find the dependence of link utilization to frame length in the presence of error. We should first create a data-link connection with sliding window protocol, and with a window size of 5 and variable frame size between nodes n(1) and n(0). Additionally, we need a loss link with a drop rate of The channel between n(1) and n(2) is without loss and the protocol is also sliding window with a constant size of window and equals to 5. To do this, we can insert a loss module that drops packets with a programmable statistical characteristic using the following commands and add it to our existing link between n(1) and n(0): #Loss parameters set loss_module [new ErrorModel] #set Drop rate Dr. M. R. Pakravan 12

13 $loss_module set rate_ 0.01 $loss_module set min_ 0 $loss_module set max_ 1 # Uniform random variable (means choosing a packet for dropping is uniform in time): $loss_module ranvar [new RandomVariable/Uniform] $loss_module drop-target [new Agent/Null] # a complete packet should be dropped not bytes or bits, etc: $loss_module unit pkt # Loss module starts working at time = 0.01 (s) between node 0 and 1: $ns at 0.01 "$ns lossmodel $loss_module $n(1) $n(0)" The other point is that TCP changes its window size whenever an error occurs. If you want a constant window size, you can write a routine that sets the window size for the TCP source periodically and does not let it change when an error occurs: #Constant Window Size For Lossy Channel proc windconst {} { global tcp ns file1 for {set i 1} {$i<3} {incr i} { $tcp($i) set maxcwnd_ 5 # maximum congestion window $tcp($i) set windowinit_ 5 # initial window size $tcp($i) set window_ 5 # window size $tcp($i) set cwnd_ 5 #congestion window } set now [$ns now] $ns at [expr $now+0.01] "windconst" } Dr. M. R. Pakravan 13

14 You can call this procedure in the main program once and it will call itself periodically. $ns at 1.01 "windconst" Vary the size of frame and find the link utilization of lossy channel for drop rates of 0.01, 0.1, 0.2 and 0.5 and then plot link utilization of lossy channel (for the respective drop rate values) and the channel without loss versus frame length in a figure. V) How to Read a Trace File Open the trace file. You will see that it contains 12 columns, each of which records a parameter. Here is a sample selection of this file: r tcp tcp d tcp r tcp ack ack r ack ack ack As you can see, each row represents an event and the details of the event characteristics are listed in each row using the following format: Event Time From node To node Pkt type Pkt size Flags Fid Src addr Dst addr Seq num Pkt id Event: this field can take four values r : receive + :en queue - : de queue d :drop Dr. M. R. Pakravan 14

15 Time: the time at which the event occurred From node: number of the input node of the link at which the event occurred To node: number of the output node of the link at which the event occurred Packet type: type of the packet.it can be tcp, ack or any other acceptable type. Packet size: size of packet in bytes Flags: means no flag has been set. ---A--- means congestion window reduced. Flow id: users can specify an id for each flow. this id can be used to specify a color for each flow. Src address: source address of the packet in the form of node.port Dst address: destination address of the packet in the form of node.port Seq number: the sequence number of packet in network layer Packet id: a unique number given to each packet As it is hard to read this file by MATLAB, you may prefer to use the text files instead. VI) Experiment Report: You should prepare a proper explanatory report for this assignment. Then you should pack this report, as well as the scripts and output files (trace and NAM) for each part, zip them and upload one file in the courseware. The received folder should contain: The scripts written for each part, The output files (trace and NAM files) for each part, Written MATLAB files as well as acquired figures, Your report (both MS word and PDF format) that contains the results of the simulations in the form of plots and some snapshots from NAM output. Please kindly that for each part, you should analyze the results you have found and explain how they are related to the theories discussed in the class. Dr. M. R. Pakravan 15