create new tag
, view all tags

Offered Traffic Vs Average End-to-End Delay: Network Performance Analysis via Batch Simulation

I think we are now fairly convinced that our packet-switching network models are sufficiently accurate. We will now depart from the graphical interface (Tkenv) to command-line interface to quickly run a series of simulations and collect data to plot the end-to-end delay performance of the network under varying network loading conditions. We will change the offered load to the network by increasing or decreasing the average idle time (iaTime) between two generated packets in the packet generator (app_gen) module.

Since in this network all generated packets go through the link connecting the two routers (and this link is the slowest one, bottleneck link), I can calculate the iaTime easily for a desired network utilization (an example of calculation of interarrival times for varying the offered link load is given in this experiment handout):

Link Utilization iaTime (sec)
0.1 0.152
0.2 0.072
0.3 0.045
0.4 0.032
0.5 0.024
0.6 0.019
0.7 0.015
0.8 0.012
0.9 0.010
1.0 0.008
We do the following:
  • In the omnetpp.ini file, below the lines
        [Run 1]
        description="10% router-to-router link utilization"
        pkswitch_net.**.iaTime = exponential(0.152) # seconds
we add these:
        [Run 2]
        description="20% router-to-router link utilization"
        pkswitch_net.**.iaTime = exponential(0.072) # seconds

        [Run 3]
        description="30% router-to-router link utilization"
        pkswitch_net.**.iaTime = exponential(0.045) # seconds

        [Run 4]
        description="40% router-to-router link utilization"
        pkswitch_net.**.iaTime = exponential(0.032) # seconds

        [Run 5]
        description="50% router-to-router link utilization"
        pkswitch_net.**.iaTime = exponential(0.024) # seconds

        [Run 6]
        description="60% router-to-router link utilization"
        pkswitch_net.**.iaTime = exponential(0.019) # seconds

        [Run 7]
        description="70% router-to-router link utilization"
        pkswitch_net.**.iaTime = exponential(0.015) # seconds

        [Run 8]
        description="80% router-to-router link utilization"
        pkswitch_net.**.iaTime = exponential(0.012) # seconds

        [Run 9]
        description="90% router-to-router link utilization"
        pkswitch_net.**.iaTime = exponential(0.010) # seconds

        [Run 10]
        description="100% router-to-router link utilization" 
        pkswitch_net.**.iaTime = exponential(0.008) # seconds
  • Add this line under the [Cmdenv] section: runs-to-execute = 1-10
  • Increase the queue size in the nodes to a large number: pkswitch_net.**.pk_queue[*].pkCapacity = 10000
  • Regenerate the Makefile to be used for creating the command line version of the executable: opp_makemake -N -f -u Cmdenv
  • make
We can now run the series of simulations: ./pkswitch_net. One by one runs 1 to 10 will be executed and the results will be collected in the file omnetpp.sca. Note that this time no graphical interface should appear.

Plotting the Offered Traffic Vs End-to-End Delay Graph

The file omnetpp.sca now has all the data we need. As shown earlier, we can use the scalars tool to view the results, but the use of this tool for producing offered traffic Vs end-to-end delay graph is probably too cumbersome. Instead, I use the following method:

  • I extract the end-to-end delay data (for host[0]) by using the grep command and save it into a data file:
    grep "pk delay.mean" omnetpp.sca | grep "host\[0\]" > eedelay.dat. Then, I edit the eedelay.dat file to add the offered load column. The file now contains the following lines:
    0.1 scalar "pkswitch_net.host[0].app_sink"  "pk delay.mean"         0.0137880775656
    0.2 scalar "pkswitch_net.host[0].app_sink"  "pk delay.mean"         0.0154726901039
    0.3 scalar "pkswitch_net.host[0].app_sink"  "pk delay.mean"         0.017864469539
    0.4 scalar "pkswitch_net.host[0].app_sink"  "pk delay.mean"         0.0215439720413
    0.5 scalar "pkswitch_net.host[0].app_sink"  "pk delay.mean"         0.028736402964
    0.6 scalar "pkswitch_net.host[0].app_sink"  "pk delay.mean"         0.0539841456299
    0.7 scalar "pkswitch_net.host[0].app_sink"  "pk delay.mean"         5.70626146644
    0.8 scalar "pkswitch_net.host[0].app_sink"  "pk delay.mean"         22.5703755572
    0.9 scalar "pkswitch_net.host[0].app_sink"  "pk delay.mean"         33.8499295391
    1.0 scalar "pkswitch_net.host[0].app_sink"  "pk delay.mean"         44.6701518211
  • it is easy to use gnuplot to produce the desired graph:
    1. Start gnuplot: gnuplot
    2. plot "eedelay.dat" using 1:5 with linespoints
  • and finally produce the graph:
Is the shape of the curve as expected? If we draw the delay graphs for the other hosts should they look similar? What do you think? In queueing theory, we learn that if the link utilization approaches to 100%, delay should approach to infinity. We see that this is not the case in this graph. Why?

We will now go to the next tutorial in which we will use some larger topologies to continue with our experiments.

Topic revision: r1 - 2013-03-10 - AhmetSekercioglu
This site is powered by the TWiki collaboration platformCopyright © 2008-2018 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding TWiki? Send feedback