- 学习在Mininet中使用Python进行自定义拓扑的实现，并会设置交换机和主机之间丢包率、延迟以及链路的带宽，从而对主机的性能进行测试，通过本实验，可以学习到以下知识：
- 设置丢包率、延迟以及链路的带宽；
- 使用iperf测试主机间的带宽性能。
- 学习使用Mininet模拟网络环境，通过在不同节点间发送和接收数据包，测量网络中各个路径的损耗率。同时，探究基于Mininet的路径损耗率测量方法，并分析其实用性。
二、实验内容
2.1 网络性能测试
在Mininet中，可以通过设置带宽，延迟和丢包等参数来模拟不同的网络条件和拥塞控制机制，进而进行网络性能测试，从而优化网络拓扑和协议设计。
2.2 Mininet测量路径损耗率
使用Mininet模拟网络环境，通过在不同节点间发送和接收数据包，测量网络中各个路径的损耗率。同时，探究基于Mininet的路径损耗率测量方法，并分析其实用性。
三、实验步骤
1.Mininet环境配置
（1）从github上获取Mininet.git：
输入命令：git clone https://github.com/mininet/mininet.git
（2）./install.sh -a
①先切换至Mininet/util文件夹
输入命令：cd mininet/util
②./install.sh -a
输入命令：./install.sh -a：（默认安装全部特性）
成功安装：
在安装的过程中，会涉及到组件文件夹的下载（如oflops、oftest、openflow和pox等等）由于shell文件里提供的下载源地址都是来自与github，所以容易造成下载缓慢、安装失败的问题，可以换源以提高下载速率和安装成功率。
但是这里并没有换源，而是挂了梯子，速度还是可以接受的。
（3）安装验证
①输入指令: sudo mn
进入Mininet并创建一个最小的拓扑，此拓扑只有两台主机h1和h2，以及一台交换机s1:
②输入指令：ping all
测试连通性：
成功ping通，测试成功。
③输入指令：exit
退出Mininet：
至此，Mininet已经成功安装。
（4）配置Python3
由于后面还将用到可视化工具miniedit以及使用Python语言撰写脚本，所以我们还需要将虚拟机的python语言环境配置好。
由于Mininet更支持Python2和Python3，而Python2和Python3是不兼容的，为了保持统一性，我们将在本实验中全部使用Python3，以下是配置Python3的步骤与方法：
①查找python版本
输入指令python，发现无法找到指令，查找Python版本为未安装，查找Python3版本为3.8.10。
②将Python指令映射到Python3
输入指令： sudo apt install python-is-python3；
安装软件包，此软件包会将Python指令映射到Python3：
③验证“映射”
现在指令Python与指令Python3都映射到Python3:
注：
在使用Mininet创建了拓扑后，若要进行下一项实验，应输入指令sudo mn -c删除已经创建的拓扑，避免相同名字的端口被占用。
在运行了进程（失败）之后，会显示地址已被占用，无法进行下一次实验。该错误是由于另一个控制器进程（也就是上一次失败的实验）正在使用该地址和端口，或者是由于之前控制器进程意外终止而没有释放该地址和端口，导致新的控制器进程无法绑定。解决该问题的方法是找到占用该地址和端口的控制器进程，并停止该进程。
输入指令sudo lsof -i :<portid>，该指令会输出所有占用<portid>端口的进程信息。根据该信息确定哪个进程是控制器进程，然后使用kill命令停止该进程，
输入指令sudo kill <pid>即可，之后便能继续实验。
2.Mininet可视化演示及基本操作演练
（1）实验目的：
本实验将会利用miniedit.py脚本来实现Mininet的可视化操作，以达到在图形界面上直接设计任意拓扑的目的，并可以生成自定义拓扑的Python脚本，以便后续的操作。
① miniedit的启动方式
② 如何自定义可视化拓扑，并配置设备信息
（2）实验原理
在Mininet2.2.0里配置了可视化工具miniedit，此脚本文件在目录/home/Mininet/Mininet/examples目录下，执行该脚本即可进入可视化页面进行操作。
① 执行可视化脚本文件：
- 先切换至mininet/mininet/examples文件夹
输入命令：cd mininet/mininet/examples
- 执行可视化脚本
输入命令：sudo ./miniedit.py
（注意：Mininet需要在sudo命令下执行）
可视化界面如下：
左栏的组件从上到下依次为：鼠标指针、主机Host、交换机Switch、传统交换机LegacySwitch、网线NetLink和控制器Controller。
②创建、运行简易拓扑：
- 创建拓扑
在MiniEdit中选择左栏的组件，再在右边的空白区域点击，即可部署部件。如图创建一个简易拓扑：【创建方式、连线方式与lab4中的操作类似】
- 修改c0属性
将鼠标指针移到组件图标上方，右键选择Properties即可设置组件的属性，如控制器的属性设置如下图：
- 设置h1的IP
又比如在主机h1的属性里设置IP地址：
点击OK确认修改，在terminal里会出现如下命令行：
- Edit-->Preferences
在Edit菜单来里点击Preferences，
进入界面后可勾选Start CLI选项，之后就能在命令行界面直接对主机等进行操作，也可以更换交换机支持的OF协议版本（可多选）：
点击OK确认修改，在terminal里会出现如下命令行：
- run运行设置的拓扑
点击Run，在terminal里会出现如下命令行：
③可视化界面创建拓扑
在进行可视化设计后，可以在可视化界面选择将设计好的拓扑保存为python脚本，这样之后可以直接通过脚本来操作拓扑，不需要再重新设计：
使用可视化界面创建五种常见的拓扑类型：
- Single类
一个交换机，主机的个数可以任意设定，呈星型；
- linear类：
一个交换机连接一个主机，主机和交换机的个数都可以任意设定，呈直线型；
- tree类：
形似二叉树，拓扑中的交换机呈树杈状分散，最底层的交换机连接两个主机；
- reversed类：
此拓扑类型与single类拓扑一致；
- minimal类：
此类拓扑是最小的、也是默认的拓扑，一般在一个交换机连接两个主机。
3.Mininet命令行操作实验
Mininet自定义拓扑两种实现方式：命令行创建、Python脚本编写。
Mininet是一个可以模拟虚拟网络的工具，支持多种拓扑结构。对于一些特定的需求，我们可以使用自定义拓扑的方式来创建自己所需要的拓扑结构。
（1）查看启动Mininet的相关参数
输入命令：sudo mn -h
比较常用的几个参数有switch、controller、topo和custom。这里进行简要介绍：
| 参数名称 | 功能 |
| switch | 用来指明将要使用什么样的交换机的类型 |
| controller | 用来指明控制器 |
| topo | 用来指明将要使用的拓扑类型 |
| custom | 用来进行用户自定义拓扑，读取python文件中的拓扑 |
其中，常用的拓扑类型一般有五种：single、linear、tree、reversed和minimal。
除了help指令，一些常用的查看信息的指令还有：
| 参数名称 | 功能 |
| nodes | 列出所有结点 |
| net | 列出所有网络链路 |
| dump | 列出结点、链路相关信息 |
| h1 ifconfig -a | 显示h1的网络接口信息 |
| s1 ps -a | 显示s1的所有进程 |
用于测试网络的连通性的指令：
| 参数名称 | 功能 |
| h1 ping h2 | h1 ping h2 |
| h1 ping -c 5 h2 | h1 ping h2，并有-c限定次数 |
| pingall | 所有主机间互ping |
其他命令：
| 参数名称 | 功能 |
| exit | 退出Mininet |
| sudo mn -c | 清除Mininet缓存 |
我们将运用以上部分参数和指令进行实验。
（2）命令行创建拓扑
①创建默认最小拓扑
输入命令：sudo mn --topo minimal
此拓扑只有一个交换机，并连接两个主机。
- 创建single拓扑
输入命令：sudo mn --topo single,4
由于此类拓扑只有一个交换机，所以如果参数是4，代表此拓扑中有4台主机：
- 创建linear拓扑
输入指令sudo mn --topo linear,5
创建线性拓扑，由于线性拓扑的每一台交换机只连接一台主机，所以如果参数是5，代表此拓扑中有5台交换机和5台主机：
- 创建tree拓扑
输入指令sudo mn --topo tree,fanout=2,depth=3
创建树形拓扑，fanout=2代表扇出为2，depth=3代表深度为3：
（3）python脚本文件创建简易拓扑
①创建、编辑python脚本文件
输入命令：touch mytest1.py
输入命令：gedit mytest1.py
编写代码文件，构造一个线性拓扑，每一行的注释如下：
from mininet.net import Mininet
from mininet.topo import LinearTopo
# 导入Mininet和LinearTopo模块
Linear4 = LinearTopo(k=4) # 四个交换机，分别连一个主机
net = Mininet(topo=Linear4) # 创建包含四个交换机的线性拓扑
net.start() # 启动Mininet网络
net.pingAll() # 对所有主机进行ping测试
net.stop() # 关闭Mininet网络②增加修改权限
保存后，输入指令：chmod +x mytest1.py为其增加修改权限，将它修改为可执行文件:
③运行
输入命令：sudo python mytest1.py
结果显示四台主机之间互通性良好，没有丢包。
（4）python脚本文件创建single拓扑
①创建、编辑python脚本文件
构造一个single类的拓扑，每台交换机下连接三台主机：
from mininet.net import Mininet
from mininet.topo import SingleSwitchTopo
# 导入Mininet和LinearTopo模块
Single3 = SingleSwitchTopo(k=3) # 1台交换机下连接3台主机
net = Mininet(topo=Single3) # 创建包含3台交换机的single类拓扑
net.start() # 启动Mininet网络
net.pingAll() # 对所有主机进行ping测试
net.stop() # 关闭Mininet网络②运行测试
赋权后，输入指令sudo python test2.py运行测试：
（5）python脚本文件创建tree拓扑
①创建、编辑python脚本文件
进行树形拓扑的构造：
注意，深度为2代表“树枝”（也就是交换机）的层数，扇出为2表示“结点”（也就是每个分叉处的交换机）要连接两台主机。
from mininet.net import Mininet
from mininet.topolib import TreeTopo
# 导入Mininet和TreeTopo模块
Tree22 = TreeTopo(depth=2,fanout=2) # 深度为2，扇出为2
net = Mininet(topo=Tree22) # 创建深2扇2的树形拓扑
net.start() # 启动Mininet网络
net.pingAll() # 对所有主机进行ping测试
net.stop() # 关闭Mininet网络②运行测试
（6）python脚本文件创建非常见拓扑
①创建、编辑python脚本文件
from mininet.net import Mininet
# 导入Mininet模块
net = Mininet()
# 创建网络节点
c0 = net.addController()
h0 = net.addHost('h0')
s0 = net.addSwitch('s0')
h1 = net.addHost('h1')
# 创建两节点之间的连接
net.addLink(h0, s0)
net.addLink(h1, s0)
# 在接口处配置ip地址
h0.setIP('192.168.1.1', 24)
h1.setIP('192.168.1.2', 24)
# 启动、ping测试、停止
net.start()
net.pingAll()
net.stop()②运行测试
（7）python脚本文件限制拓扑的功能
除了用python编写脚本创建拓扑以外，还可以通过脚本限制拓扑的功能，比如:
使用addHost()函数设置主机的cpu（百分数的形式）；
使用addLink()函数设置带宽bw、延迟delay、最大队列的大小max_queue_size和损耗率loss等。
①创建、编辑python脚本文件
from mininet.net import Mininet
from mininet.node import CPULimitedHost
from mininet.link import TCLink
net = Mininet(host=CPULimitedHost, link=TCLink)
# 创建网络节点
c0 = net.addController()
s0 = net.addSwitch('s0')
h0 = net.addHost('h0')
h1 = net.addHost('h1', cpu=0.5)
h2 = net.addHost('h1', cpu=0.5)
# 主机h1和h2的CPU被限制为50%，即最大只能占用机器一半的CPU资源
net.addLink(s0, h0, bw=10, delay='5ms',
max_queue_size=1000, loss=10, use_htb=True)
# 为交换机s0和主机h0添加一条链路，并设置参数
net.addLink(s0, h1)
net.addLink(s0, h2)
net.start()
net.pingAll()
net.stop()其中，进行限制的参数说明如下：
bw=10：表示链路的带宽为10 Mbps；delay='5ms'：表示链路的时延为5毫秒；m_q_s=1000：表示链路缓冲队列的最大大小为1000个数据包；loss=10：表示链路的数据包丢失率为10%。use_htb=True：表示对链路应用Hierarchical Token Bucket调度算法，将链路带宽分配为一组子队列。HTB算法是一个带宽管理工具，可以通过配置不同数据流量的规则，将带宽分配和管理在网络设备的输出端口上。
通过调整这些参数，可以控制链路的性能，从而影响网络数据传输的效率和可靠性。
②运行测试
4.网络性能测试
（1）设计拓扑
设计一个含有1台交换机和4台主机的拓扑，拓扑图如下：
（2）代码实现checkmininet.py
# 首先导入各类模块：
# 调用mininet的模块
from mininet.topo import Topo
from mininet.net import Mininet
from mininet.node import CPULimitedHost
from mininet.link import TCLink
from mininet.util import dumpNodeConnections
from mininet.log import setLogLevel
# 创建一个拓扑及其构造函数：
class SingleSwitchTopo(Topo):
def __init__(self, n=2, **opts):
Topo.__init__(self, **opts) # 调用父类函数
switch = self.addSwitch('s1') # 添加s1交换机
for h in range(n):
host = self.addHost('h%s' % (h + 1), cpu=.5/n) #每个主机占50/n%的CPU
self.addLink(host, switch, bw=10, delay='5ms', loss=0, max_queue_size=1000, use_htb=True)
#1 0Mbps, 5ms延迟, 0%丢包, 1000字节的大小
def perfTest():
# 创建4个主机的单交换机拓扑
topo = SingleSwitchTopo(n=4)
# 调用Mininet（）的函数设置拓扑，主机，以及链路
net = Mininet(topo=topo,host=CPULimitedHost, link=TCLink)
net.start()
print ("Dumping host connections")
dumpNodeConnections(net.hosts)
print ("Testing network connectivity")
net.pingAll()
print ("Testing bandwidth between h1 and h4")
h1, h4 = net.get('h1', 'h4')
net.iperf((h1, h4))
net.stop()
if __name__=='__main__':
setLogLevel('info')
perfTest()（3）运行测试
首先输出了使用addController函数添加控制器的信息，然后输出了使用addHost和addSwitch函数添加主机和交换机的信息；然后使用addLink为主机和交换机之间设置链路的信息，链路的带宽为10.00Mbit，时延为5ms，丢包率为0，最大队列长度为1000。可以看到，每个主机都与交换机s1相连；使用limitCPU对每个主机进行了CPU资源限制的信息；最后显示了启动控制器、交换机和主机的信息，并显示了链路的带宽、时延和丢包率。可以看到，主机和交换机之间的链路都存在且状态正常。
pingAll对所有主机进行了ping测试，并输出了测试结果，该结果表明12个ping已经全部收到，丢包率为0；接着使用iperf测试了主机h1和主机h4之间的TCP带宽，并输出了测试结果，该结果表明带宽为9.2 Mbits/sec和11.4。
5.Mininet测量路径损耗率
（1）设计拓扑
在SDN环境中，控制器可以通过对交换机下发流表操作来控制交换机的转发行为，此外，还可以利用控制器测量路径的损耗率。在本实验中，基于Mininet脚本，设置特定的交换机间的路径损耗速率，然后编写POX脚本，实现对路径的损耗率的测量。
本实验的拓扑图如下：
本次实验的目的是展示如何通过控制器计算路径损耗速率（h0-s0-s1-h1）。首先，由h0向h1发送数据包，由于在Mininet脚本中设置了连接损耗率，在传输过程中会丢失一些数据包，这里假设控制器预先知道网络拓扑，所以没有显示发现网络的代码以及其他相关代码。控制器将向s0和s1发送flow_stats_request，当控制器接收到来自s0的response时，将特定流的数据包数保存在input_pkts中，当控制器接收到来自s1的response时，将接收到特定流的数据包数保存在output_pkts中，差值就是丢失的数据包数量。
测量路径的损耗率可以通过向网络的某些节点发送测试数据包，并记录这些数据包在传输过程中的丢包率、时延等性能指标来实现。通过分析这些性能指标，可以检测网络中的拥塞、丢包、延迟等问题，并尝试解决这些问题，提高网络的可用性和性能。此外，还可以通过收集大量的性能数据来评估网络的性能水平，帮助网络管理员和研究人员了解网络的运行情况，制定针对性的优化策略，提高网络的可靠性和效率。
而POX是一个开源的SDN控制器，它提供了丰富的编程接口和工具来管理、监控和测试SDN网络。在安装Mininet时，我们也安装了POX，在本次实验中，我们将用到POX。
（2） 代码实现-mymininet.py
#!/usr/bin/env python
# 首先是模块调用：
# 调用关于mininet和time的模块
from mininet.net import Mininet
from mininet.node import Node
from mininet.link import TCLink
from mininet.log import setLogLevel,info
from threading import Timer
from mininet.util import quietRun
from time import sleep
# mynet函数
def myNet(cname='controller', cargs='-v ptcp:'):
# 通过使用OVS抓取来创建网络
# 诊断信息然后开始创建节点,其中有控制器C0和交换机s0,s1,还有主机h0,h1
info( "*** Creating nodes\n" )
controller = Node( 'c0', inNamespace=False )
switch = Node( 's0', inNamespace=False )
switch1 = Node( 's1', inNamespace=False )
h0 = Node( 'h0' )
h1 = Node( 'h1' )
info( "*** Creating links\n" )
# 链路选项设置，丢包以及延迟还有带宽等等
linkopts0=dict(bw=100, delay='1ms', loss=0)
linkopts1=dict(bw=100, delay='1ms', loss=10)
#链路0,1,2分别表示h0和s0，s0和s1，h1和s1的链路并调用以上两行的参数
link0 = TCLink( h0, switch, **linkopts0)
link1 = TCLink( switch, switch1, **linkopts1)
link2 = TCLink( h1, switch1, **linkopts0)
#MAC地址设置
link0.intf2.setMAC("0:0:0:0:0:1")
link1.intf1.setMAC("0:0:0:0:0:2")
link1.intf2.setMAC("0:1:0:0:0:1")
link2.intf2.setMAC("0:1:0:0:0:2")
info( "*** Configuring hosts\n" )
h0.setIP( '192.168.123.1/24' )
h1.setIP( '192.168.123.2/24' )
#通过使用OVS开始网络连接，引号里是指搭建和删除桥梁
info( "*** Starting network using Open vSwitch\n" )
switch.cmd( 'ovs-vsctl del-br dp0' )
switch.cmd( 'ovs-vsctl add-br dp0' )
switch1.cmd( 'ovs-vsctl del-br dp1' )
switch1.cmd( 'ovs-vsctl add-br dp1' )
# 控制器的设置
controller.cmd( cname + ' ' + cargs + '&' )
# 打印出每个交换机的链路信息
for intf in switch.intfs.values():
print (intf)
print (switch.cmd( 'ovs-vsctl add-port dp0 %s' % intf ))
for intf in switch1.intfs.values():
print (intf)
print (switch1.cmd( 'ovs-vsctl add-port dp1 %s' % intf ))
# 控制器和交换机同属根命名空间，可以通过环回接口连接
switch.cmd( 'ovs-vsctl set-controller dp0 tcp:192.168.26.133:6633' )
switch1.cmd( 'ovs-vsctl set-controller dp1 tcp:192.168.26.133:6633' )
#诊断并等待交换机连接上控制器，在连接完成前会一秒一个点
info( '*** Waiting for switch to connect to controller' )
while 'is_connected' not in quietRun( 'ovs-vsctl show' ):
sleep( 1 )
info( '.' )
info( '\n' )
#运行测试20次h0和h1的传输情况
#info( "*** Running test\n" )
h0.cmdPrint( 'ping -Q 0x64 -c 20 ' + h1.IP() )
#休息一秒后关闭网络：删除“桥梁”
sleep( 1 )
info( "*** Stopping network\n" )
controller.cmd( 'kill %' + cname )
switch.cmd( 'ovs-vsctl del-br dp0' )
switch.deleteIntfs()
switch1.cmd( 'ovs-vsctl del-br dp1' )
switch1.deleteIntfs()
info( '\n' )
# 主函数：
if __name__ == '__main__':
setLogLevel( 'info' )
info( '*** Scratch network demo (kernel datapath)\n' )
Mininet.init()
myNet()（3） 代码实现-flow_stats.py
# 首先引入模块：
from pox.core import core
from pox.lib.util import dpidToStr
import pox.openflow.libopenflow_01 as of
from pox.lib.addresses import IPAddr, EthAddr
from pox.openflow.of_json import *
from pox.lib.recoco import Timer
import time
# 进行初始化：
log = core.getLogger()
#初始化网络的参数0
src_dpid = 0
dst_dpid = 0
input_pkts = 0
output_pkts = 0
def getTheTime():
#设定当地时间的函数
flock = time.localtime()
then = "[%s-%s-%s" %(str(flock.tm_year),str(flock.tm_mon),str(flock.tm_mday))
if int(flock.tm_hour)<10:
hrs = "0%s" % (str(flock.tm_hour))
else:
hrs = str(flock.tm_hour)
if int(flock.tm_min)<10:
mins = "0%s" % (str(flock.tm_min))
else:
mins = str(flock.tm_min)
if int(flock.tm_sec)<10:
secs = "0%s" % (str(flock.tm_sec))
else:
secs = str(flock.tm_sec)
then +="]%s.%s.%s" % (hrs,mins,secs)
return then
def _timer_func ():
for connection in core.openflow._connections.values():
connection.send(of.ofp_stats_request(body=of.ofp_flow_stats_request()))
connection.send(of.ofp_stats_request(body=of.ofp_port_stats_request()))
log.debug("Sent %i flow/port stats request(s)", len(core.openflow._connections))
def _handle_flowstats_received (event):
global src_dpid, dst_dpid, input_pkts, output_pkts
for f in event.stats:
if f.match.dl_type==0x0800 and f.match.nw_dst==IPAddr("192.168.123.2") and f.match.nw_tos==0x64 and event.connection.dpid==src_dpid:
input_pkts = f.packet_count
if f.match.dl_type==0x0800 and f.match.nw_dst==IPAddr("192.168.123.2") and f.match.nw_tos==0x64 and event.connection.dpid==dst_dpid:
output_pkts = f.packet_count
if input_pkts !=0:
print(getTheTime(), "Path Loss Rate =", (input_pkts-output_pkts)*1.0/input_pkts*100, "%")
def _handle_portstats_received (event):
stats = flow_stats_to_list(event.stats)
log.debug("PortStatsReceived from %s: %s", dpidToStr(event.connection.dpid), stats)
def _handle_ConnectionUp (event):
global src_dpid, dst_dpid
print("ConnectionUp: ", dpidToStr(event.connection.dpid))
for m in event.connection.features.ports:
if m.name == "s0-eth0":
src_dpid = event.connection.dpid
elif m.name == "s1-eth0":
dst_dpid = event.connection.dpid
msg = of.ofp_flow_mod()
msg.priority =1
msg.idle_timeout = 0
msg.match.in_port =1
msg.actions.append(of.ofp_action_output(port = of.OFPP_ALL))
event.connection.send(msg)
msg = of.ofp_flow_mod()
msg.priority =1
msg.idle_timeout = 0
msg.match.in_port =2
msg.actions.append(of.ofp_action_output(port = of.OFPP_ALL))
event.connection.send(msg)
msg = of.ofp_flow_mod()
msg.priority =10
msg.idle_timeout = 0
msg.hard_timeout = 0
msg.match.dl_type = 0x0800
msg.match.nw_tos = 0x64
msg.match.in_port=1
msg.match.nw_dst = "192.168.123.2"
msg.actions.append(of.ofp_action_output(port = 2))
event.connection.send(msg)
msg = of.ofp_flow_mod()
msg.priority =10
msg.idle_timeout = 0
msg.hard_timeout = 0
msg.match.dl_type = 0x0800
msg.match.nw_tos = 0x64
msg.match.nw_dst = "192.168.123.1"
msg.actions.append(of.ofp_action_output(port = 1))
event.connection.send(msg)
def launch ():
core.openflow.addListenerByName("FlowStatsReceived",
_handle_flowstats_received)
core.openflow.addListenerByName("PortStatsReceived",
_handle_portstats_received)
core.openflow.addListenerByName("ConnectionUp", _handle_ConnectionUp)
# 定时器每5秒执行一次
Timer(1, _timer_func, recurring=True)（4） 运行测试
运行步骤：首先在pox目录下输入指令./pox.py flow_stats启动pox，再在myMininet.py的目录下输入指令sudo ./myMininet.py执行文件。
首先是myMininet.py部分的截图：
测试一共发送了20个请求，收到了18个响应，丢失了10%的数据包，测试总时间为19086ms。最小往返延迟（rtt）是7.692ms，平均往返延迟是12.263ms，最大往返延迟是24.499ms，往返延迟方差为4.816ms。。
从结果中可以看出，目标设备192.168.123.2的网络连通性较好，但仍有一些数据包无法传输。同时，往返延迟较小，说明网络速度相对较快。
接下来是flow_stats.py部分的截图：
控制器通过OpenFlow协议连接到了两个交换机，它们的mac地址分别是00-00-00-00-00-01和00-01-00-00-00-01。“Path Loss Rate”是一种衡量网络性能的指标，表示从一个源到目标之间数据包的损失率。
四、实验总结
通过这次实验，我学习了通过在Mininet中使用Python进行自定义拓扑的实现，了解了设置交换机和主机之间丢包率、延迟以及链路的带宽，从而对主机的性能进行测试。
另外，我还学习了在Mininet中设置丢包率、延迟以及链路的带宽，使用iperf测试主机间的带宽性能。并且使用Mininet模拟网络环境，通过在不同节点间发送和接收数据包，测量网络中各个路径的损耗率。同时，探究基于Mininet的路径损耗率测量方法，并分析其实用性。
2879
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
