ns.txt

在网络仿真NS中对延时分析

一，延时分析。包的延时就是指包的接收时间与包的发送时间差。下面给出awk程序，相关的说明看程序里面的注释。
#BEGIN表明这是程序开头执行的一段语句，且只执行一次。
BEGIN {
       #程序初始化，设定一变量以记录目前处理的封包的最大ID号码。在awk环境下变量的使用不需要声明，直接赋值。
   highest_uid = 0;
}
#下面大括号里面的内容会针对要进行处理的记录（也就是我们的trace文件）的每一行都重复执行一次
{
   event = $1;     #$1表示一行的第一栏，是事件的动作。每一栏默认是以空格分隔的。下同。
   time = $2;    #事件发生的时间
   node_nb = $3;        #发生事件的节点号（但是两边夹着“_”，下面一句代码将“_”处理掉）
   node_nb=substr(node_nb,2,1);     #第三栏的内容是形如_0_的节点号码，我只要得出中间的节点号码0，所以要对字符串_0_进行处理。
   trace_type = $4;     #trace文件跟踪事件的层次（指在路由层或mac层等等）
   flag = $5;              #
   uid = $6;        #包的uid号码（普通包头的uid）
   pkt_type = $7;              #包的类型（是信令或是数据）
   pkt_size = $8;    #包的大小（byte）

      #下面的代码记录目前最高的CBR流的packet ID，本来的延迟分析是针对所有的包的（包括信令），这里作了简化，只针对CBR封包，以后大家做延时分析可以做相应的改动即可。
   if ( event=="s" && node_nb==0 && pkt_type=="cbr" && uid > highest_uid )
   {#if判断句的前三个判断条件就不说了，第四个是说每个包的记录次数不超过1
             highest_uid = uid;
   }
   #记录封包的传送时间
   if ( event=="s" && node_nb==0 && pkt_type=="cbr" && uid==highest_uid )
             start_time[uid] = time; # start_time[]表明这是一个数组

#记录封包的接收时间
   if ( event=="r" && node_nb ==2 && pkt_type=="cbr" && uid==highest_uid ) 
             end_time[uid] = time;
}
#END表明这是程序结束前执行的语句，也只执行一次
END {
   #当每行资料都读取完毕后，开始计算有效封包的端到端延迟时间。
   for ( packet_id = 0; packet_id <= highest_uid; packet_id++ )
   {
             start = start_time[packet_id];
             end = end_time[packet_id];
             packet_duration = end - start;
             #只把接收时间大于传送时间的记录打印出来
             if ( start < end ) printf("%d %f\n", packet_id, packet_duration);
   }    
}
   要注意的是上面的awk程序只是在一个层上进行处理的（我是用的mac层），在生成trace文件时把其他层关闭，只留一个层，否则判断条件要多加一个层的判断。下面的其他三个程序也是一样的。
程序写好以后用一个文档保存为pkt_delay和trace文件放于同一文件夹下，然后在终端进入该文件夹，执行：
$：gwak –f delay trace > p
然后在文件p中就保存了两列数据：封包的序号和该封包的传送时间。

二，丢包率分析。
BEGIN {
      #程序初始化，设定变量记录传输以及被丢弃的包的数目
   fsDrops = 0; #被丢弃的包的数目
   numfs0 = 0; #0节点发送的CBR封包的数目
   numfs2 = 0; #2节点接收的CBR封包的数目
}
{
   event = $1;
   time = $2;
   node_nb = $3;
   trace_type = $4;
   flag = $5;
   uid = $6
   pkt_type = $7;
   pkt_size = $8; 

   node_nb=substr(node_nb,2,1);

   #统计节点0发送的CBR封包
   if (node_nb==0 && event== "s" && trace_type== "MAC" && pkt_type== "cbr") 
             numfs0++;
   #统计节点2丢弃的CBR封包
   if (node_nb==2 && event== "r" && trace_type== "MAC" && pkt_type== "cbr") 
             numfs2++;
}

END {
   average=0; #average用于记录丢包率
   fsDrops = numfs0-numfs2; #丢包数目
   average=fsDrops/numfs0;     #丢包率
   printf("number of packets sent:%d lost_rate:%d\n", numfs0, average);   #打印发送封包数目和丢包率
}
程序写好以后用一个文档保存为drop和trace文件放于同一文件夹下，然后在终端进入该文件夹，执行：
$：gwak –f drop trace > d
文件d中记录了两个数据：发送封包数目和丢包率。

三，延时抖动分析
在这里特别提一下，所用的延时抖动分析的模型是：（封包n2的延时－封包n1的延时）/（n2的包序号－n1的包序号）。
BEGIN {
       #程序初始化，设定一变量以记录目前处理过的最高封包序号。
   highest_uid = 0;
}
{
   event = $1;
   time = $2;
   node_nb = $3;
   node_nb=substr(node_nb,2,1);
   trace_type = $4;
   flag = $5;
   uid = $6
   pkt_type = $7;
   pkt_size = $8; 

      #记录目前最高的CBR封包的ID
   if ( event=="s" && node_nb==0 && pkt_type=="cbr" && uid > highest_uid )
   {
             highest_uid = uid;
   }
   #记录CBR封包的发送时间
   if ( event=="s" && node_nb==0 && pkt_type=="cbr" && uid==highest_uid )
             start_time[uid] = time;

       #记录CBR封包的接收时间
   if ( event=="r" && node_nb ==2 && pkt_type=="cbr" && uid==highest_uid ) 
             end_time[uid] = time;
}

END {
       # 初始化抖动延时所需的变量
   last_seqno = 0;
   last_delay = 0;
   seqno_diff = 0;
       #当资料行全部读取后，开始计算有效封包的端到端延迟时间
   for ( packet_id = 0; packet_id <= highest_uid; packet_id++ ) 
   {
             start = start_time[packet_id];
             end = end_time[packet_id];
             packet_duration =end - start;
             #只把接收时间大于发送时间的记录列出来
             if ( start < end ) 
             {
                  # 得到了delay值(packet_duration)后计算jitter
                  seqno_diff = packet_id - last_seqno;
                  delay_diff = packet_duration - last_delay;
                  if (seqno_diff == 0) 
                  {
                        jitter =0;
                  } 
                  else
                  {
                        jitter = delay_diff/seqno_diff;
                  }
         #将有效封包序号以及延时抖动打印出来
                  printf("%d %f\n", packet_id, jitter);
                  last_seqno = packet_id;
                  last_delay = packet_duration;
             }
   }
}
程序写好以后用一个文档保存为jitter和trace文件放于同一文件夹下，然后在终端进入该文件夹，执行：
$：gwak –f jitter trace > j
文件j中记录了有效封包序号以及延时抖动的情况。

四，网络吞吐量分析
网络的吞吐量是网络性能的一个重要参数，是指在不丢包的情况下单位时间内通过的数据包数量，单位是字节每秒或比特每秒。计算其吞吐量是一件复杂的事情，这里的模型是从第一个包发送后，每个包都叠加累算。可能模型不够精准，只是大概的反映，目的只是想让大家了解如何写awk的网络吞吐量分析程序。大家切勿借用本模型在要发表的论文上做分析。
BEGIN {
   init=0;
   i=0;
}
{
   event = $1;
   time = $2;
   node_nb = $3;
   node_nb=substr(node_nb,2,1);
   trace_type = $4;
   flag = $5;
   uid = $6
   pkt_type = $7;
   pkt_size = $8;

if(event=="r" && node_nb==2 && pkt_type=="cbr" ) 
   {
             pkt_byte_sum[i+1]=pkt_byte_sum+ pkt_size;
             if(init==0)
             {
                  start_time = time;
                  init = 1;
             }
             end_time = time;
             i = i+1;
   }
}
END {
      #为了画图方便，把第一笔记录的throughput设为零，以表示传输开始
   printf("%.2f\t%.2f\n", end_time[0], 0);
   for(j=1 ; j<i ; j++)
   {
             th = pkt_byte_sum[j] / (end_time[j] - start_time)*8/1000;
             printf("%.2f\t%.2f\n", end_time[j], th);
   }
      #看图方便，把最后一笔记录的throughput设置为零，以表示传输
   printf("%.2f\t%.2f\n", end_time[i-1], 0);
}