计算机网络实验报告Word格式文档下载.docx
《计算机网络实验报告Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《计算机网络实验报告Word格式文档下载.docx（13页珍藏版）》请在冰点文库上搜索。
#include<
iostream>
#include<
time.h>
stdlib.h>
usingnamespacestd;
#defineMAX_PORT_NUM5
classPort
{
public:
floatP;
//站点发包概率0<
P<
1
intApply;
//站点状态0=空闲，1=请求发送
floatPackTime;
intCountPackNum_Suc;
intCountPackNum_Col;
Port（）{P=0.5;
CountPackNum_Suc=0;
CountPackNum_Col=0;
ChangeApply（0）;
}
Port（floatp）{P=p;
voidChangeApply（floatNowTime）;
};
voidPort:
:
ChangeApply（floatNowTime）
floatP1=（rand（）%1000）/1000.0;
if（P1<
P）Apply=1;
elseApply=0;
PackTime=NowTime;
classSlottedAloha
floatSlotTime;
floatNowTime;
intCurrent[MAX_PORT_NUM];
//记录当前时槽内要发送的包，及发包站点，成为“包缓存”
intCountAllPort_suc;
intCountAllPort_all;
SlottedAloha（floatt）{SlotTime=t;
NowTime=0;
CountAllPort_suc=0;
CountAllPort_all=0;
voidALOHA（Portprt[],intn）;
voidSlottedAloha:
ALOHA（Portprt[],intn）
for（inti=0;
;
i++）//用一个死循环代表时间流逝，如果成功发送包达到1000则break
{
NowTime=SlotTime*i;
intPackLen=0;
//记录时槽内要发包的总长度（个数）
for（intk=0;
k<
n;
k++）
{
if（prt[k].Apply==1&
&
prt[k].PackTime==NowTime）{Current[k]=1;
PackLen++;
}
elseCurrent[k]=0;
}
if（PackLen==1）//只有一个包，可以发
for（intk=0;
{
if（Current[k]==1）//从“包缓存”中找出要发的包
{
prt[k].Apply=0;
//发送成功，此站点状态变为空闲
prt[k].ChangeApply（NowTime+SlotTime*（rand（）%n+1））;
//随机下一个发包时间
prt[k].CountPackNum_Suc++;
//成功数++
}
elseif（prt[k].Apply==0）//当前不发又处于空闲的站点就测试下一个时间点是否发包
prt[k].ChangeApply（NowTime+SlotTime）;
}
elseif（PackLen>
1）//有多个包，冲突
k++）//给所有当前冲突的包下一个随机发送时间
if（Current[k]==1）{prt[k].ChangeApply（NowTime+SlotTime*（rand（）%n+1））;
prt[k].CountPackNum_Col++;
}//冲突数++
elseif（prt[k].Apply==0）prt[k].ChangeApply（NowTime+SlotTime）;
}
elseif（PackLen==0）//无包发送
k++）if（prt[k].Apply==0）prt[k].ChangeApply（NowTime+SlotTime）;
CountAllPort_suc=0;
k++）//计算是成功发送包数是否达到1000
CountAllPort_suc+=prt[k].CountPackNum_Suc;
CountAllPort_all+=prt[k].CountPackNum_Suc+prt[k].CountPackNum_Col;
if（CountAllPort_suc>
=1000）break;
}
//——————————————以下是主函数————————————————
intmain（intargc,char*argv[]）
srand（（int）time（0））;
Portprt[3];
prt[0]=Port（0.2）;
prt[1]=Port（0.2）;
prt[2]=Port（0.2）;
//设有三个站点，每个时槽内发包概率为0.2
SlottedAlohaA（1.0）;
//创建时槽，时槽长度为1
A.ALOHA（prt,3）;
floatG,S;
G=A.CountAllPort_all/A.NowTime;
S=A.CountAllPort_suc/A.NowTime;
cout<
<
"
成功发送包"
A.CountAllPort_suc<
个，\n冲突包"
<
A.CountAllPort_all-A.CountAllPort_suc
个，\n总共发送包"
A.CountAllPort_all<
个。
\n"
endl;
每包时尝试次数G="
G<
吞吐量S="
S<
getchar（）;
return0;
实验结果截图：
3.实验总结
这个分槽ALOHA仿真模拟实验难度比较大，就算对此协议比较了解，但要通过编程来实现，也不是容易的事。
况且以前从未做过类似的程序设计，对于我来说是个不小的挑战。
经过很久的设计、讨论和尝试，我总算在截止时间前完成了任务。
我的程序采用循环来代表时间流逝，用随机数来判断站点是否发包，成功地模拟了分槽ALOHA在物理介质的运行情况。
我的主程序比较随意，主要是为了测试，所以没有设多个情况。
默认只有三个站点，每个站点以0.2的概率发包，所以理论的G=0.6，S=0.329，而实际测试情况出入很小，符合理论预期，所以实验结果很成功！
如果进一步修改，可以测试不同的G和S，从而画出曲线，但限于时间和水平（C++中还不知道如何画图），这个环节暂时无法实现。
实验二网络路由层协议模拟实验
网络路由算法是路由器工作的核心，本实验针对因特网常用的距离向量路由算法和链路状态路由算法进行模拟实现，进一步掌握其工作原理及其相关性能。
【实验目的和要求】
1.掌握VB、VC++、VS或JAVA等集成开发环境编写路由仿真程序的方法；
2.理解并掌握距离向量路由协议和链路状态路由协议的工作原理。
（1，2任选其一实现）
1.模拟距离向量路由算法的路由表交换过程，演示每轮交换后路由表的变化。
基本要求（动态生成网络拓扑图，节点间的距离随机生成。
从初始路由表开始，进行交换路由表，演示每轮交换后的路由表的变化。
观察和讨论多少轮交换后路由表稳定）
2.实现链路状态路由算法的模拟。
每个节点生成自己的链路状态分组，依据收到的链路状态表得到整体网络结构，在得到的整体网络结构上用最短路径算法，生成每个节点的路由表）
1.编程语言C/C++/C#/Java等均可；
我选择的实验1，模拟距离向量路由算法。
矢量路由算法是这样工作的：
每个路由维护一张表（即一个矢量），列出了当前已知到每个目标的最佳距离，以及所使用的链路。
这些表通过与邻居之间相互交换信息而不断被更新，最终每个路由器都了解到达每个目的地的最佳链路。
string>
#defineINFINITY-1
#defineMAX_VERTEX_NUM10
typedefenum{DG,DN,UDG,UDN}GraphKind;
//{有向图，有向网，无向图，无向网}
typedefintVRType;
typedefstringVertexType;
structArcCell
VRTypeadj;
//InfoType*info;
};
classMGraph
//private:
VertexTypevexs[MAX_VERTEX_NUM];
ArcCellarc[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
intvexnum;
intarcnum;
GraphKindkind;
//public:
voidCreateGraph_1（）;
boolCheckArc（inta,intb）;
voidMGraph:
CreateGraph_1（）
vexnum=7;
arcnum=11;
i<
7;
i++）vexs[i]='
A'
+i;
i++）arc[i][i].adj=0;
arc[0][1].adj=4;
arc[0][2].adj=INFINITY;
arc[0][3].adj=9;
arc[0][4].adj=2;
arc[0][5].adj=INFINITY;
arc[0][6].adj=INFINITY;
arc[1][2].adj=2;
arc[1][3].adj=1;
arc[1][4].adj=INFINITY;
arc[1][5].adj=INFINITY;
arc[1][6].adj=8;
arc[2][3].adj=INFINITY;
arc[2][4].adj=10;
arc[2][5].adj=INFINITY;
arc[2][6].adj=6;
arc[3][4].adj=7;
arc[3][5].adj=5;
arc[3][6].adj=INFINITY;
arc[4][5].adj=INFINITY;
arc[4][6].adj=INFINITY;
arc[5][6].adj=3;
for（inti=1;
i++）
for（intj=0;
j<
i;
j++）arc[i][j].adj=arc[j][i].adj;
j++）cout<
arc[i][j].adj<
'
'
cout<
\n'
}cout<
boolMGraph:
CheckArc（inta,intb）
if（arc[a][b].adj!
=-1&
arc[a][b].adj!
=0）returntrue;
elsereturnfalse;
structRouterTable
intdistance;
intvia_RouterID;
//记录需经由的最短路径
classRouter
RouterTabletable[MAX_VERTEX_NUM];
//记录此路由节点到其他节点的最短路径，下标为其他节点ID，到自己为0
intRouterID;
Router（）{RouterID=-1;
Router（MGraph&
G,intID）;
voidObtainAdjRt（Router&
R,intID,intvexnum）;
voidPrintTable（intvexnum）;
//voidDVR（RouterR[],intRtNum）;
Router:
Router（MGraph&
G,intID）
RouterID=ID;
for（intj=0;
G.vexnum;
j++）
table[j].distance=G.arc[ID][j].adj;
if（table[j].distance==-1）table[j].via_RouterID=-1;
elsetable[j].via_RouterID=j;
voidRouter:
ObtainAdjRt（Router&
R,intID,intvexnum）//获取路由表的函数，R是自己的邻居节点
vexnum;
if（table[j].distance==-1&
R.table[j].distance>
0）{table[j].distance=table[R.RouterID].distance+R.table[j].distance;
table[j].via_RouterID=R.RouterID;
elseif（table[j].distance>
R.table[j].distance&
R.table[j].distance!
=-1）//如果邻居节点有到j节点更短的距离
{if（table[j].distance>
table[R.RouterID].distance+R.table[j].distance）
{table[j].distance=table[R.RouterID].distance+R.table[j].distance;
PrintTable（intvexnum）//输出这个路由器的路由表
table[i].distance<
via:
char（'
+table[i].via_RouterID）<
voidDVR（RouterR[],MGraph&
G,intRtNum）//距离矢量路由算法
RtNum;
i++）//此循环为了让每个路由器访问一遍邻节点
j++）//如果j号路由是i号路由的邻节点
if（G.CheckArc（i,j））{R[i].ObtainAdjRt（R[j],j,RtNum）;
}//则i路由获取j路由的路由表
MGraphG;
G.CreateGraph_1（）;
Routerrt[7];
rt[i]=Router（G,i）;
intSwapNum=10;
SwapNum;
i++）//做SwapNum次交换
DVR（rt,G,7）;
rt[0].PrintTable（7）;
//输出第0号路由（A）的路由表
（由于已经得到了最优的路由表，所以没有更新）
本实验的过程比较顺利，网络的拓扑图是采用邻接矩阵存储，因为网络拓扑一般比较稠密。
实验结果很正确，可以快速得到所有路由的最优路由表。
首先得益于这个算法的优秀，其次是我事先留作测试用的网络比较小，一个路由节点做一次就可以得到最优路由表了，导致不能观看到路由表的更新。
通过本次试验，我加深了对距离向量路由算法的理解，同时也锻炼了编程技术。
升级会员 