ns2模拟仿真实验

内容：
编写TCL脚本，搭建如下图所示的一个网络，共6个节点，其中2、3节点用做ftp服务器和客户端，4、5节点用做cbr流量的源和目的，而0、1节点用做转发设备。各节点间的链路属性见图。

模拟时间设为13秒钟，在0.1秒开始产生cbr流量，在1.0秒开发发送发ftp流量；8.0秒ftp流量结束，12.0秒cbr流量结束。编写脚本（可用shell，awk，或perl等）分析模拟日志文件，统计每0.5s内0、1节点间链路通过的分组数以及字节数。
设计与实现过程

1.仿真脚本代码如下：
#create a simulator object /创建模拟器对象
set ns [new Simulator]; #模拟器对象赋值给变量ns

#Define different colors for data flows (for NAM)
$ns color 1 Yellow
$ns color 2 Purple
#给NAM定义不同的数据流

#Open the NAM trace file
set nf [open out.nam w]; #打开out.nam文件，一般都是在执行程序的时候自动生成的
$ns namtrace-all $nf

#Open the Trace file
set tf [open out.tr w]; #打开out.tr文件
$ns trace-all $tf
#两个文件主要都是用来记录封包传输过程的

#Define a 'finish' procedure /定义finish程序，在后面执行的时候会用到
proc finish {} {
global ns nf tf
$ns flush-trace
close $nf; #关闭nam文件
close $tf; #关闭trace 文件 (在后面调用的时候，是在程序结束的时候，所以前面生成的两个文件必须要关闭)
exec nam out.nam &
#以后台方式执行nam
exit 0
}

#Create six nodes /创建六个节点 ,从n0到n5
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]

#Create links between the nodes /创建结点之间的链路，而链路的创建都是基于题目要求的基础之上
$ns duplex-link $n0 $n2 1.5Mb 10ms DropTail /设置0、1结点之间的带宽为1.5MB，发送时延为10ms，采用DropTail(队尾丢弃算法)管理机制
$ns duplex-link $n0 $n4 1.5Mb 10ms DropTail
$ns duplex-link $n1 $n3 1.5Mb 10ms DropTail
$ns duplex-link $n1 $n5 1.5Mb 10ms DropTail
$ns duplex-link $n1 $n0 2Mb 20ms DropTail

#Give node position (for NAM) /根据题目图示要求，给NAM创建的节点位置如下
$ns duplex-link-op $n2 $n0 orient right-down
$ns duplex-link-op $n4 $n0 orient right-up
$ns duplex-link-op $n0 $n1 orient right
$ns duplex-link-op $n0 $n1 orient right
$ns duplex-link-op $n1 $n3 orient right-up
$ns duplex-link-op $n1 $n5 orient right-down

#Set Queue Size of link (n0-n1) to 10 /设置n0到n1之间的队列大小为10个分组大小
$ns queue-limit $n1 $n0 10

#Setup a TCP connection /建立TCP连接（FTP应用程序建构在TCP上）
set tcp [new Agent/TCP]
$tcp set class_ 2
$ns attach-agent $n2 $tcp /在节点2使用TCP agent产生“tcp”发送TCP的封包
set sink [new Agent/TCPSink]
$ns attach-agent $n3 $sink /在节点3使用TCP sink接收TCP的数据，并产生ACK返回发送端，最后释放接收的TCP封包
$ns connect $tcp $sink /连接2个agent，建立联机
$tcp set fid_ 1; #NAM中，TCP的连接用黄色的数据流表示

#Setup a UDP connection /建立UDP连接，CBR应用程序建构在UDP上
set udp [new Agent/UDP]
$ns attach-agent $n4 $udp /节点4使用UDP agent产生“udp”发送UDP的封包
set null [new Agent/Null]
$ns attach-agent $n3 $null
set null [new Agent/Null]
$ns attach-agent $n5 $null
$ns connect $udp $null
$udp set fid_ 2; #NAM中，UDP的连接用紫色的数据流表示
#TCP与UDP的建立中，agent是一个代理，用来作为网络层的传输与接收

#Setup a FTP over TCP connection /在TCP连接上建立FTP
set ftp [new Application/FTP]
$ftp attach-agent $tcp
$ftp set type_ FTP

#Setup a CBR over UDP connection /在UDP连接上建立CBR
set cbr [new Application/Traffic/CBR]
$cbr attach-agent $udp
$cbr set type_ CBR
$cbr set packet_size_ 1000 /设置一个封包有为1000个字节
$cbr set rate_ 1mb
$cbr set random_ false
#设置了cbr流量的包类型，字节大小，以及传输速率

#Schedule events for the CBR and FTP agents /设置FTP和CBR起止时间
$ns at 0.1 "$cbr start"; #0.1秒产生cbr流量
$ns at 1.0 "$ftp start"; #1.0秒发送ftp流量
$ns at 8.0 "$ftp stop" ; #8.0秒ftp流量结束
$ns at 12.0 "$cbr stop"; #12.0秒cbr流量结束

#Call the finish procedure after 13 seconds of simulation time /13秒后调用前面写出的finish程序

$ns at 13.0 "finish"

#Run the simulation /执行模拟器程序
$ns run

2.仿真过程截图：

① 在0.1秒开始产生cbr流量




②在1.0秒开发发送发ftp流量




在1.5s左右发生丢包事件，ftp数据流和cbr数据流同时竞争网络资源，导致网络拥塞，采用DropTail拥塞控制机制，当对长达到最大值，接下来到达的包就要被丢弃。如下图：




③ 8.0秒ftp流量结束




④ 12.0秒cbr流量结束。




3.产生一个out.tr的仿真过程记录文件，记录封包传送的过程。对该文件内各项内容解释：

文件形式： + 0.1 4 0 cbr 1000 ------- 2 4.0 5.0 0 0

Event

Time

From node

To node

Pkt type

Pkt size

Flags

Fid

Src addr

Dst addr

Seq num

Pkt id

第1个字段表示事件，r表示这个封包被某个节点接受，+表示进入队列，-表示离开队列，d表示封包被队列丢弃；
第2个字段表示事件发生的时间；
第3个字段表示事件发生的开始节点：from node；
第4个字段表示事件发生的结束节点：to node；
第5个字段表示封包的类型；
第6个字段表示封包的大小,单位是byte；
第7个字段表示封包的标记标注；
第8个字段表示封包属于哪一个数据流。即在TCL脚本中所定义的类似$udp set fid_ 2；
第9、10两个字段表示封包的来源端和目的端，格式为a.b，a代表节点编号，b表示端口号；
第11字段表示封包的序号；
第12字段表示封包的id。

4.分析仿真结果， 统计每0.5s内0、1节点间链路通过的分组数以及字节数。
① 用python编写统计脚本，源代码如下：
#!/usr/bin/env python
# coding: utf-8
import sys

#读入文件内容并将字符串内容分割到列表
f = open(sys.argv[1], 'r')
allth = f.read()
f.close()
li = allth.split('\n')

#定义变量
start = (-0.5)
i = 0
tmp = [[] for _ in range(26)]
res = []
pkt = []

#按照每0.5s分割
while i<26:
start += 0.5
end = start + 0.5
for j in li:
j = j.split(' ')
try:
if start <= float(j[1]) < end:
tmp[i].append(j)
else:
continue
except:
continue
i+=1

#计算每一组第六列的和
for k in tmp:
su_m1 = 0.0;
su_m2 = 0.0;
z = ['0', '1']
for l in k:
if l[0] == 'r' and l[2] in z and l[3] in z:
su_m1 += int(l[5])
su_m2 += 1
res.append(su_m1)
pkt.append(su_m2)
#输出结果
start = 0.0
for i in range(26):
fir = start + 0.5*i
las = fir + 0.5
print fir,'~',las,'\t\t'"%d" %pkt[i],'\t\t'"%d" %res[i]
② 脚本运行结果如下：



③ 根据脚本统计结果绘出折线图：

每0.5s内经过0、1结点的分组数：




每0.5s内经过0、1结点的字节数：




从折线图可以直观地看出分组数和字节数大约在0.1s~8.0s内经过的分组数和字节数多，因为此时的ftp数据包和cbr数据包都正在经过0、1节点传送，它们同时竞争网络资源。