CSMA/CD

本教程通过详细的示例,演示如何建模和分析著名的 Aloha 与 CSMA 信道接入协议。在本课中,你将学习如何:

  • 构建更高级的协议
  • 为多抽头总线设计一个简单的信道接口
  • 执行参数化仿真
  • 将仿真结果与理论预测进行对比分析

你将构建两个模型:一个 Aloha 模型和一个 CSMA 模型。由于 Aloha 是最简单的信道接入方式,我们将先构建 Aloha 模型。

主要任务是设计模型,在多抽头总线链路(多个节点通过共享信道相连)上实现 Aloha 随机信道接入方法和 1-persistent 载波监听多路访问(CSMA)方法。我们将比较这两种方法的性能。

入门

在设计模型之前,你可能希望先了解模型层次结构的概览。

Aloha 和 CSMA 模型的设计策略是采用同一个网络模型。两个网络模型都将使用一个发送数据包的通用发送器节点模型,以及一个执行网络监视的通用接收器节点模型。通过更改节点模型的进程模型属性,可以快速构建使用 Aloha 或 CSMA 特性的新仿真。发送器节点的进程模型各不相同,而接收器节点的进程模型是通用的,保持不变。

图 1:Aloha 与 CSMA 建模层次结构

Aloha 与 CSMA 建模层次结构

设计通用发送器节点模型

关键概念——从理论上讲,Aloha 系统可以只用一个简单的源生成器和一个总线发送器来建模。但通过设计一个更通用的模型,你可以在之后将其复用于 CSMA 模型。

发送器节点必须生成数据包、处理数据包,并将其发送到总线上。这可以用一个简单的源处理器来生成数据包,用另一个处理器执行必要的操作,再用一个总线发送器将数据包发送到总线链路上。

图 2:通用发送器节点模型

通用发送器节点模型

总线发送器还具有内部排队能力——它们会按 FIFO 顺序将所有提交的数据包发送到总线上。

设计 Aloha 发送器进程模型

关键概念——Aloha 发送器进程只需要从生成器接收数据包,并将其发送给发送器。

Aloha 发送器进程只有一个非强制状态:等待来自生成器的数据包到达。由于通用发送器节点不收集统计量,aloha_tx 进程不需要初始化或维护自己的状态变量或全局变量。不过,它需要获取一个定义生成数据包数量的全局属性值。发送器进程将在进入主循环之前获取该值一次。

进程在强制初始化状态开始仿真,然后进入一个非强制的 idle 状态,在那里等待数据包到达。

进程通过 begin simulation interrupt 激活,这样当仿真开始时,FSM 执行强制初始化状态,然后在 idle 状态等待,准备好在第一个数据包到达时进行转移。

图 3:中间阶段的 aloha_tx FSM

中间阶段的 aloha_tx FSM

aloha_tx FSM 中只有一种独特的事件——生成的数据包到达。在非强制 idle 状态,可以通过适当的转移选择性地检测数据包到达中断。

图 4:完整的 aloha_tx FSM

完整的 aloha_tx FSM

数据包到达中断是唯一预期的中断,因此可以安全地省略非强制 idle 状态的默认转移。当数据包到达中断被送达时,FSM 应在 tx_pkt 状态执行相应的执行代码来获取并发送数据包,然后转移回 idle 状态。

设计通用接收器节点模型

关键概念——通用接收器节点模型监视数据包在总线上的移动。

下一步是设计通用接收器节点模型。该模型不需要生成器,因为它只是监视在总线上移动的数据包。该节点模型由一个总线接收器和一个处理器模块组成。

图 5:概念性的通用接收器节点模型

概念性的通用接收器节点模型

设计通用接收器进程模型

关键概念——通用接收器进程模型负责处理接收到的数据包,用于收集统计量。

为了处理接收到的数据包以进行统计收集,cct_rx 进程需要一个非强制状态,在该状态中等待接收无冲突的数据包(如何检测冲突将在本教程后面介绍)。在仿真结束时,该进程记录信道吞吐量和信道流量值以供分析。由于接收器节点进程管理统计收集变量,进程应在仿真开始时初始化这些变量。这就得到了所示的设计。注意转移执行代码中引用了用户定义的 C 函数 proc_pkt() 和 record_stats()(这些函数将在后面编写)。

图 6:完整的 cct_rx FSM

完整的 cct_rx FSM

构建 Aloha 模型

首先创建 Aloha 进程和节点模型。这些模型是后续用于表示 CSMA 系统的增强模型的基础。

构建 Aloha 模型包括以下几个步骤:

  • 创建 Aloha 发送器进程模型
  • 创建通用发送器节点模型
  • 创建通用接收器进程模型
  • 创建通用接收器节点模型
  • 构建网络模型

创建 Aloha 发送器进程模型

首先,你将构建 Aloha 发送器进程模型。

步骤 1:创建 Aloha 发送器进程模型

  1. 如果 Riverbed Modeler 尚未运行,请启动它。

  2. 选择 File > New…,从下拉菜单中选择 Process Model。单击 OK。

    结果: Process Editor Startup Wizard 出现。

  3. 在向导中单击 Quit,从空模型开始。

  4. 使用 Create State 工具按钮,在工作区中放置三个状态。

    图 7:发送器进程模型的初始状态

    发送器进程模型的初始状态

  5. 从左到右对三个状态做如下更改:

    • 5.1 将第一个状态的 name 属性改为 init,status 改为 forced。

    • 5.2 将第二个状态的 name 属性改为 idle。status 保持为 unforced。

    • 5.3 将第三个状态的 name 属性改为 tx_pkt,status 改为 forced。

      图 8:发送器进程模型的状态

      发送器进程模型的状态

接下来,在状态之间添加转移。

步骤 2:在状态之间添加转移

  1. 如图所示绘制三条转移。

    图 9:发送器进程模型的转移

    发送器进程模型的转移

  2. 对于从 idle 到 tx_pkt 的转移,将 condition 属性改为 PKT_ARVL(使用大写字母)。要移动条件标签,左键单击标签并将其拖到新位置。

PKT_ARVL 宏用于判断进程收到的中断是否与在流上到达的数据包相关。在此模型中,中断只预期出现在来自生成器的输入流上,因此该宏不需要进一步判断数据包是在哪个输入流上接收的。

你将在下一步中定义这个宏。

现在可以为进程模型指定代码了。从 Header Block 开始。

步骤 3:指定进程模型代码

  1. 打开 Header Block 并输入以下代码。

    /* Input stream from generator module */
    #define IN_STRM 	0
    
    /* Output stream to bus transmitter module */
    #define OUT_STRM 	0
    
    /* Conditional macros */
    #define PKT_ARVL (op_intrpt_type() == OPC_INTRPT_STRM)
    
    /* Global Variable */
    extern int subm_pkts;
    
  2. 选择 File > Commit,然后选择 File > Close 保存更改。

符号常量 IN_STRM 和 OUT_STRM 将用于调用从流获取数据包或向流发送数据包的 Kernel Procedure。为了实现所需的功能,这些流索引必须与节点级别定义的索引保持一致。

接下来,输入状态变量。

步骤 4:输入状态变量

  1. 打开 State Variable Block 并输入以下信息。

    图 10:State Variable Block 的值

    State Variable Block 的值

    注意: 输入注释时会打开一个单独的文本编辑器。输入完注释后,选择 File > Commit 关闭编辑器。

  2. 单击 OK 关闭对话框。

变量 max_packet_count 将保存仿真中要处理的最大数据包数。该值将从仿真属性中获取,并与数据包计数进行比较。

在 init 状态的 Enter Executives 块中定义该状态的动作。

步骤 5:定义 init 状态的动作

  1. 双击 init 状态的顶部,打开 Enter Executives block 并输入以下代码。

    /* Get the maximum packet count, */
    /* set at simulation run-time */
    op_ima_sim_attr_get_int32 ("max packet count", &max_packet_count);
    
  2. 选择 File > Commit,然后选择 File > Close 保存更改。

接下来,指定 tx_pkt 状态的动作。

步骤 6:指定 tx_pkt 状态的动作

  1. 双击 tx_pkt 状态的顶部,打开 Enter Executives block,并输入以下代码:

    /* Outgoing packet */
    Packet *out_pkt;
    
    /* A packet has arrived for transmission.  Acquire */
    /* the packet from the input stream, send the packet */
    /* and update the global submitted packet counter. */
    out_pkt = op_pk_get (IN_STRM);
    op_pk_send (out_pkt, OUT_STRM);
    ++subm_pkts;
    
    /* Compare the total number of packets submitted with */
    /* the maximum set for this simulation run.  If equal */
    /* end the simulation run. */
    if (subm_pkts == max_packet_count)
          op_sim_end ("max packet count reached.", "", "", "");
    
  2. 选择 File > Commit,然后选择 File > Close 保存更改。

当进程从 Simulation Kernel 收到流中断时,将进入 tx_pkt 状态执行代码。该中断与生成数据包的到达同时发生。完成 tx_pkt 状态的执行代码后,FSM 转移回 idle 状态。由于转移路径中没有其他非强制状态,FSM 在下一次数据包到达之前总是重新进入 idle 状态并等待数据包。

cct_rx 进程模型稍后将声明全局变量 subm_pkts,用于全局累计发送的数据包数量。在 aloha_tx 进程模型中访问该变量的方法,是在模型的 Header Block 中使用 C 语言的 extern 存储类进行声明。

接下来定义将在仿真运行时设置并加载到状态变量 max_packet_count 的全局属性。

步骤 7:定义 max_packet_count 全局属性

  1. 选择 Interfaces > Global Attributes。

  2. 在对话框表格中输入属性 "max packet count",如图所示:

    图 11:定义全局属性

    定义全局属性

  3. 单击 OK 按钮保存更改。

模型现在只剩下模型接口属性尚未定义。

你必须编辑进程接口。

步骤 8:编辑进程接口

  1. 选择 Interfaces > Process Interfaces。
  2. 将 begsim intrpt 属性的初始值改为 enabled。
  3. 将所有属性的 Status 改为 hidden。
  4. 单击 OK 保存更改。

你可能想添加一条注释来描述该进程。完成后,单击 OK 关闭对话框。

步骤 9:添加描述进程的注释

  1. 编译进程模型。提供名称 <initials>_aloha_tx。
  2. 进程模型编译完成后,关闭 Process Model Editor。

创建通用发送器节点模型

现在你将创建一个通用发送器节点模型,它可以支持 Aloha 或 CSMA。

步骤 10:创建通用发送器节点模型

  1. 选择 File > New…,从下拉菜单中选择 Node Model。单击 OK。

  2. 使用相应的工具按钮,创建两个处理器模块和一个总线发送器模块。(显示工具提示以确认你选择的是总线发送器。)

    图 12:通用发送器节点模型的模块

    通用发送器节点模型的模块

  3. 为每个模块设置如上所示的名称属性。

  4. 如上所示,用数据包流连接各模块。

  5. 打开数据包流的属性对话框,确认 src stream 设置为 src stream [0],dest stream 设置为 dest stream [0],与 <initials>_aloha_tx 进程模型 Header Block 中声明的索引一致。

由于你希望为生成器的 interarrival time 属性赋予不同的值,必须将其提升(promote),以便在仿真时更容易设置其值。

步骤 11:提升生成器的间隔时间

  1. 打开 gen 处理器的属性对话框。

  2. 将 process model 属性设置为 simple_source。

  3. 在左列中单击 Packet Interarrival Time 以高亮该属性名称,然后右键单击并从弹出菜单中选择 Promote Attribute to Higher Level。

    结果: 该属性的 Value 单元格中出现 promoted 字样。

    图 13:提升属性

    提升属性

  4. 单击 OK 关闭属性对话框。

你需要将处理器的属性设置为合适的值。

步骤 12:设置处理器的属性

  1. 打开 tx_proc 的属性对话框,将 process model 属性设置为 <initials>_aloha_tx。
  2. 单击 OK 关闭对话框。

增强通用发送器节点模型

你刚刚创建的通用发送器节点模型已经具备底层 aloha_tx 进程模型所需的功能。不过,由于你计划用 CSMA 替换 Aloha 进程模型,为预期的增强功能预留接口是有益的。

增强内容包括一个总线接收器模块(以支持 CSMA 协议最终的完全双工能力),以及一个 sink 处理器,用于接收并销毁接收器模块收到的数据包。增强内容还包括一条非活动(禁用)的统计线,当在 CSMA 模型中启用时,它既向进程(位于 tx_proc 模块中)通报信道的忙状态,又在信道状态改变时向进程提供中断。

图 14:增强后的发送器节点模型

增强后的发送器节点模型

为节点模型添加以下特性:

步骤 13:为节点模型添加特性

  1. 使用相应的工具按钮,添加一个处理器模块和一个总线接收器模块。

    图 15:添加模块

    添加模块

  2. 将新处理器模块的 name 改为 sink,将总线接收器的 name 改为 bus_rx。

  3. 如图所示,用数据包流连接新模块。

  4. 使用 Create Statistic Wire 工具按钮,将 bus_rx 模块与 tx_proc 模块连接。

    图 16:添加统计线

    添加统计线

  5. 打开 statistic wire 的属性对话框,将 rising edge trigger 和 falling edge trigger 属性都改为 disabled。完成后单击 OK 关闭对话框。

仔细检查模块连接,确保模型中的所有对象都按正确的顺序连接:

步骤 14:仔细检查模块连接

  1. 右键单击 tx_proc 模块,从 Object 弹出菜单中选择 Show Connectivity。各对象应按下图所示连接。

    图 17:检查连接性

    检查连接性

  2. 如果连接与图中不符,按如下方式修改连接器:

    • 2.1 右键单击 gen 与 tx_proc 模块之间的数据包流。
    • 2.2 选择 Edit Attributes。
    • 2.3 将 src stream 属性的值改为 src stream [0]。
    • 2.4 单击 OK 关闭 Attributes 对话框。
    • 2.5 右键单击 bus_rx 与 tx_proc 模块之间的统计线。
    • 2.6 选择 Edit Attributes。
    • 2.7 将 dest stat 属性的值改为 instat [0]。
    • 2.8 单击 OK 关闭 Attributes 对话框。

接下来,定义接口属性。

步骤 15:定义接口属性

  1. 选择 Interfaces > Node Interfaces。
  2. 在 Node types 表中,将 mobile 和 satellite 类型的 Supported 值改为 no。
  3. 将所有属性的 Status 改为 hidden,唯一例外是状态为 promoted 的 gen.Packet Interarrival Time。
  4. 如有需要,可以添加一条注释来描述该节点。完成后单击 OK 保存更改。
  5. 将模型保存为 <initials>_cct_tx 并关闭 Node Editor。

创建通用接收器进程与节点模型

接下来,你可以创建通用接收器进程和节点模型。由于接收器进程的唯一目的是统计数据包数量并记录统计量,无论数据包是按照 Aloha 还是 CSMA 信道接入方法发送的,它都可以用来监视网络性能。

步骤 16:创建通用接收器进程模型

  1. 选择 File > New…,从下拉菜单中选择 Process Model。单击 OK。

    结果: Process Editor Startup Wizard 出现。

  2. 在向导中单击 Quit,从空模型开始。

  3. 使用 Create State 工具按钮,在工具窗口中放置两个状态。

  4. 对于初始状态,将 name 属性改为 init,status 改为 forced。

  5. 对于另一个状态,将 name 属性改为 idle。(status 保持为 unforced。)

绘制下图所示的四条状态转移。

图 18:为通用接收器节点添加转移

为通用接收器节点添加转移

步骤 17:为通用接收器节点添加转移

  1. 对于第一条(最上方)从 idle 回到自身的转移,将 condition 属性改为 PKT_RCVD,executive 属性改为 proc_pkt()。
  2. 对于第二条(中间)从 idle 回到自身的转移,将 condition 属性改为 default。
  3. 对于第三条(最下方)从 idle 回到自身的转移,将 condition 属性改为 END_SIM,executive 属性改为 record_stats()。

接下来,输入 Header Block 和状态变量的代码。

步骤 18:输入 Header Block 与状态变量的代码

  1. 使用相应的工具按钮打开 Header Block,输入所示的定义。

    /* Input stream from bus receiver */
    #define IN_STRM 0
    
    /* Conditional macros */
    #define PKT_RCVD (op_intrpt_type () == OPC_INTRPT_STRM)
    #define END_SIM (op_intrpt_type () == OPC_INTRPT_ENDSIM)
    
    /* Global variable */
    int subm_pkts = 0;
    
  2. 选择 File > Commit,然后选择 File > Close 保存 Header Block。

这里定义了来自总线接收器模块的输入流索引(IN_STRM)。PKT_RCVD 宏用于判断送达进程的中断是否为流中断。由于只预期出现一种流中断,因此无需进一步限定。END_SIM 宏用于判断进程收到的中断是否与来自 Simulation Kernel 的仿真结束中断相关。

使用全局变量 subm_pkts 是为了让所有发送节点都能把各自的发送尝试贡献到这个累加器中。在进程模型 Header Block 中声明的变量,在可执行仿真中会作为全局变量运行。

通用接收器进程使用 rcvd_pkts 状态变量记录有效接收数据包的数量。按如下方式定义该变量:

步骤 19:定义 rcvd_pkts 状态变量

  1. 打开 State Variables 块并定义以下变量:

    图 19:定义 rcvd_pkts 状态变量

    定义 rcvd_pkts 状态变量

  2. 保存状态变量块。

接下来,输入定义进程模型功能的代码。

步骤 20:定义进程模型的功能

  1. 打开 Function Block 并输入以下代码:

    /* This function gets the received packet, destroys 	*/
    /* it, and logs the incremented received packet total	*/
    static void proc_pkt (void)
          {
          Packet* in_pkt;
          FIN (proc_pkt());
          /* Get packet from bus receiver input stream */
          in_pkt = op_pk_get (IN_STRM);
    
          /*Destroy the received packet */
          op_pk_destroy (in_pkt);
    
          /* Increment the count of received packet */
          ++rcvd_pkts;
          FOUT;
          }
    
    /* This function writes the end-of-simulation channel 	*/
    /* traffic and channel throughput statistics to a       */
    /* vector file                                         */
    static void record_stats (void)
          {
          double cur_time;
          FIN (record_stats());
          cur_time = op_sim_time();
          /* Record final statistics */
          op_stat_scalar_write ("Channel Traffic G",
               (double) subm_pkts / cur_time);
          op_stat_scalar_write ("Channel Throughput S",
               (double) rcvd_pkts / cur_time);
          FOUT;
          }
    
  2. 选择 File > Commit,然后选择 File > Close 保存 Function Block。

如 Function Block 中所定义,proc_pkt() 函数在每个接收到的数据包到达时获取它、销毁它,并递增接收数据包计数。record_stats() 函数在仿真终止时被调用。

op_stat_scalar_write() 函数将信道吞吐量和信道流量数据发送到该仿真运行的输出向量文件。

init 状态初始化用于统计接收数据包数量的状态变量。按如下方式定义:

步骤 21:定义状态变量的 init 状态

  1. 双击 init 状态的顶部,打开 Enter Executives 块并输入以下代码:

    /* Initialize accumulator */
    rcvd_pkts = 0;
    
  2. 选择 File > Commit,然后选择 File > Close 保存 Enter Executives。

最后,你可以定义进程接口。

步骤 22:定义进程接口

  1. 选择 Interfaces > Process Interfaces。

  2. 将 begsim intrpt 和 endsim intrpt 属性的初始值改为 enabled。

  3. 将所有属性的 Status 改为 hidden。

    图 20:隐藏属性

    隐藏属性

  4. 如有需要,添加一条注释来描述该进程,然后单击 OK 保存更改。

现在编译模型。

步骤 23:编译模型

  1. 单击 Compile Process Model 工具按钮。
  2. 提供文件名 <initials>_cct_rx 并单击 Save 按钮。
  3. 关闭编译对话框和 Process Model Editor。

创建通用接收器节点模型

下一步是创建通用接收器节点模型。

步骤 24:创建通用接收器模型

  1. 选择 File > New…,从下拉菜单中选择 Node Model。单击 OK。

  2. 使用相应的工具按钮,创建一个处理器模块和一个总线接收器模块。(显示工具提示以确认你选择的是总线接收器。)

    图 21:通用接收器节点模型的模块

    通用接收器节点模型的模块

  3. 按图示为每个模块更改 name 属性。

  4. 如图所示,用数据包流连接各模块。

    输入流索引默认为流 0,与 cct_rx 进程模型 Header Block 中声明的索引一致。

  5. 打开处理器的属性对话框,将 process model 属性设置为 <initials>_cct_rx。完成后关闭对话框。

通用接收器节点模型现在只剩下接口属性尚未定义。

步骤 25:设置接口属性

  1. 选择 Interfaces > Node Interfaces。
  2. 在 Node types 表中,将 mobile 和 satellite 类型的 Supported 值改为 no。
  3. 在 Attributes 表中,将所有属性的 Status 改为 hidden。
  4. 如有需要,可以添加一条注释来描述该节点模型。完成后单击 OK 退出对话框。
  5. 将节点模型保存为 <initials>_cct_rx,然后关闭 Node Model Editor。

创建新的链路模型

关键概念——总线链路的行为由其 Transceiver Pipeline 阶段定义。该流水线是一系列 C 或 C++ 过程,可以通过修改它们来自定义链路模型。

在本课中,你将创建一个自定义总线链路模型,其流水线阶段使用默认总线模型(以 dbu_ 模型前缀标识)。下表按功能列出了流水线阶段。

表 1:总线收发器流水线模型阶段

模型 功能
txdel 计算通过总线链路发送数据包所产生的发送时延(发送时延是指在相关总线发送器模块所定义的比特率下发送该数据包所需的时间)。
closure 确定总线上任意两个站点之间的连通性。
propdel 计算给定发送器与接收器之间的传播时延。
coll 判断数据包是否在总线上发生冲突。
error 计算数据包中的比特错误数量。
ecc 拒绝超过纠错阈值的以及任何发生冲突的数据包。

要创建新的总线链路模型:

步骤 26:创建新的总线链路模型

  1. 选择 File > New…,从下拉菜单中选择 Link Model。单击 OK。

  2. 在 Supported link types 表中,将 ptsimp 和 ptdup 类型的 Supported 值改为 no。

    图 22:修改所支持的链路类型

    修改所支持的链路类型

    该链路模型只支持 bus 和 bus tap 类型。

  3. 如有需要,可以添加一条注释来描述该链路。

  4. 将文件保存为 <initials>_cct_link 并关闭 Link Model Editor。

创建网络模型

关键概念——网络模型的构建方式使其可以同时用于分析 Aloha 和 CSMA 协议。做法是定义节点时引用通用节点模型,之后再在节点级别更改所引用的进程模型。

解析 Aloha 模型假设数据包总是以指数分布的到达间隔时间引入网络。但在本教程中,网络模型的节点数量是有限的,它们会在缓冲区中保存数据包,直到先前未完成的事务结束。为了紧密遵循解析模型的假设,总线上必须有大量的发送器节点。

网络模型将在子网内构建,以便可以使用小规模的坐标系统。

步骤 27:创建网络模型

  1. 选择 File > New…,从下拉菜单中选择 Project。单击 OK。
  2. 将项目命名为 <initials>_cct_network,场景命名为 aloha,然后单击 OK。
  3. 在 Startup Wizard 中,使用下表所列的设置。

表 2:Startup Wizard 设置

对话框名称 值
Initial Topology 默认值:Create empty scenario
Choose Network Scale Office(选中 "Use metric units")
Specify Size 700 x 700 Meters
Select Technologies 无
Review 检查各项值,然后单击 Finish

为了更容易地构建网络,你需要一个包含所需对象的自定义调色板。创建调色板的步骤:

步骤 28:创建自定义调色板

  1. 在 Object Palette 中,单击对话框左上角的按钮,切换到图标视图。

    图标视图按钮

  2. 接下来,单击 Configure Palette… 按钮。

  3. 在 Configure Palette 对话框中,单击 Clear。

    结果: 除子网外,所有对象都从调色板中移除。如果你安装了 Wireless 模块,还会看到 mobile 和 satellite 子网。

  4. 单击 Link Models 按钮,然后从可用链路模型列表中添加 <initials>_cct_link。完成后单击 OK 关闭对话框。

  5. 单击 Node Models 按钮,然后从可用节点模型列表中添加 <initials>_cct_rx 和 <initials>_cct_tx。完成后单击 OK 关闭对话框。

  6. 在 Configure Palette 对话框中单击 Save As... 按钮保存 Object Palette。使用 <initials>_cct 作为文件名。

  7. 单击 OK 关闭 Configure Palette 对话框。

    结果: <initials>_cct Object Palette 已可供使用。

不必手工创建整个总线网络,你可以使用快速配置(rapid configuration)快速构建它。

步骤 29:使用快速配置

  1. 选择 Topology > Rapid Configuration…。

  2. 从可用配置菜单中选择 Bus,然后单击 Next…。

  3. 使用下图所示的值完成 Rapid Configuration: Bus 对话框。

    图 23:Rapid Configuration: Bus 对话框

    Rapid Configuration: Bus 对话框

  4. 所有值输入完毕后单击 OK。

    结果: 网络被绘制在工作区中。

  5. 为了更好地查看新网络,在工作区中右键单击并选择 Zoom to All。

    图 24:创建的总线网络

    创建的总线网络

这个网络还需要一个接收器节点。要添加该节点并将其连接到网络:

步骤 30:添加接收器节点

  1. 从 Object Palette 中单击并拖动接收器节点 <initials>_cct_rx 到工作区的左侧。

  2. 单击调色板中的 <initials>_cct_link tap 链路。务必使用 tap 链路。

    图 25:总线 tap 图标

    总线 tap 图标

  3. 从总线向接收器节点绘制一条 tap。务必从总线开始绘制。如果从节点向总线绘制 tap,可能会产生不同的结果。

    图 26:绘制 tap

    绘制 tap

  4. 确认完成的总线模型如下所示:

    图 27:完成的总线模型

    完成的总线模型

  5. 使用默认名称 <initials>_cct_network 保存模型,并关闭 Object Palette。

    警告: 不要退出 Project Editor。

执行 Aloha 仿真

本课的目标是观察协议性能如何随信道流量变化。到达间隔时间输入参数将在一系列仿真中被改变,以产生不同的流量水平,从而产生不同的吞吐量水平。你将运行 12 次仿真,每次使用不同的到达间隔时间值,分析结果并得出结论。

导入并配置仿真序列

步骤 31:导入并配置仿真序列

  1. 选择 Scenarios > Scenario Components > Import…

  2. 从下拉菜单中选择 Simulation Sequence,然后选择 cct_network-CSMA。单击 OK。

  3. 保存项目。

  4. 选择 DES > Configure/Run Discrete Event Simulation (Advanced)。

    结果: Simulation Sequence 对话框打开。注意它显示了一个包含 12 次仿真运行的场景,每次运行都有相应的变化参数。这就是你导入的文件。

    图 28:包含 12 次仿真运行的仿真序列

    包含 12 次仿真运行的仿真序列

    注意: 通常你会打开 Configure/Run DES 对话框(DES > Configure/Run Discrete Event Simulation)并创建具有特定设置的仿真序列文件。为了节省时间,这里提供了一个接近完成的文件。

  5. 右键单击 scenario (12 runs) 树节点并选择 Edit Attributes。

  6. 展开 Execution 树节点。

  7. 展开 Advanced 树节点。

  8. 单击 Application 节点。

    结果: Application 面板在右窗格中打开。

  9. 确认 Network model 设置为 <initials>_cct_network-aloha。

  10. 单击 Outputs 树节点,然后单击 Statistics Collection 树节点。

  11. 将 Probe file 设置为 <NONE>。你不需要创建或指定 Probe 文件。op_stat_scalar_write() 函数可以替代 Probe 文件。

  12. 确认 Vector file 设置为 <initials>_cct_network-aloha。

    结果: 该文件将收集你在 <initials>_cct_rx 模型的 Function Block 中包含的 op_stat_scalar_write() 函数的输出。每次运行都会创建一个文件,并在网络模型名称后添加相应的 -DES-<run #> 后缀。

    标量信息也会写入向量文件。在本教程中,向量文件将只包含标量数据。

  13. 单击 Inputs 树节点,然后单击 Global Attributes 节点,确认 max packet count 为 1000。

  14. 单击 Object Attributes 树节点。

    结果: 在 Value 列中,注意属性 Office Network.*.gen.Packet Interarrival Time 已设置了 12 个值。

  15. 单击 OK 保存更改并关闭 Simulation Sequence 对话框。

  16. 选择 File > Save。

执行仿真

现在可以执行仿真了。由于仿真序列要执行许多单独的仿真,总执行时间可能需要几分钟。

步骤 32:执行仿真

  1. 确保在树视图中选中序列中的所有运行。

  2. 单击 Running Man 工具按钮。

    图 29:执行仿真序列

    执行仿真序列

  3. 在 Confirm Execution 对话框中单击 Yes。由许多运行组成的序列可能需要很长时间执行;该对话框让你可以选择推迟该过程。

    图 30:Confirm Execution 对话框

    Confirm Execution 对话框

    注意: 如果你使用的是多核或多处理器计算机,你可能会看到一个对话框,询问是并发运行还是依次运行仿真。单击 Execute Simulations 以并发运行仿真。

    结果: DES Execution Manager 对话框打开,显示 12 次仿真执行的进度。12 次仿真在执行过程中显示各自的进度。

    图 31:DES Execution Manager 对话框

    DES Execution Manager 对话框

    任何生成 1000 个数据包(max packet count 的值)的仿真运行都会以类似下图所示的消息终止。要查看该消息,请在 DES Execution Manager 对话框中选中一个已完成的运行并单击 View Details。这会为选中的运行打开 Simulation Progress 对话框。

    图 32:终止消息

    终止消息

  4. 仿真完成后,关闭 DES Execution Manager 对话框和 Simulation Sequence Editor。如果遇到问题,请参阅"教程疑难解答"。

分析 Aloha 结果

关键概念——Aloha 信道性能可以根据成功接收的数据包数量(作为提交数据包数量的函数)来衡量,无论这些数据包是原始数据包还是重传数据包。在该网络中,信道吞吐量是衡量网络性能的典型指标。

每次仿真的结果作为两个标量值存储在输出向量文件中,使你能够将网络性能视为输入参数的函数,而不是时间的函数。你可以查看跨越所有仿真的信道吞吐量作为信道流量的函数。

步骤 33:查看标量图

  1. 在 Project Editor 的工具栏按钮中,单击 View Results 工具按钮。

    图 33:View Results 工具栏按钮

    View Results 工具栏按钮

    结果: Results Browser 打开。

  2. 单击 DES Parametric Studies 选项卡。

    图 34:Results Browser 的 Parametric Studies 选项卡

    Results Browser 的 Parametric Studies 选项卡

  3. 展开 Scalar Statistics 树节点。

  4. 右键单击 Channel Throughput S 标量,在弹出菜单中选择 Set as Y-Series。

    结果: Preview 区域显示各次运行的标量值。

    图 35:跨运行查看 Channel Throughput S 数据的预览

    跨运行查看 Channel Throughput S 数据的预览

  5. 右键单击 Channel Traffic G 并选择 Set as X-Series。

    结果: Preview 区域变为显示吞吐量作为流量函数的结果图。

  6. 单击 Show。

    结果: 标量图出现在工作区中。你的图应该与下图类似:

    图 36:Aloha 协议:信道吞吐量作为信道流量的函数

    Aloha 协议:信道吞吐量作为信道流量的函数

理论分析表明,纯 Aloha 系统的信道吞吐量 S 作为信道流量 G 的函数为 S = Ge^(-2G)。该关系给出的最大信道吞吐量为 S_max = 1/(2e) ≈ 0.18。

在低流量水平下,冲突很少发生。在高流量水平下,信道过载,过多的冲突使数据包无法成功接收。仿真结果充分展示了这一行为。特别是,最大吞吐量在 G = 0.5 附近取得,且接近预期值 0.18。

理论结果假设存在基本上无限数量的源,以消除真实网络中出现的缓冲效应。解析模型还假设系统处于理想的稳态条件。该模型的实测性能与解析模型之间的任何差异,都可以归因于各次仿真所选随机数种子的特性(可以通过使用多个种子来修正),以及模型所施加的现实限制(包括有限的仿真时间和有限的节点数量)。

查看完图后,关闭图面板和 Results Browser。

添加延迟(Deference)

关键概念——通过添加载波监听能力,可以提升 Aloha 随机接入协议的性能。载波监听能力被用于经典的 CSMA 协议,该协议要求源节点在承诺发送之前先监听信道并确认信道是空闲的。

你可以增强现有的 <initials>_aloha_tx 进程模型,使进程在发送数据包之前等待信道空闲。

步骤 34:修改状态图

  1. 在 Project Editor 中,选择 File > Recent Files > Process Model 并选择 <initials>_aloha_tx 模型。

  2. 选择 File > Save As… 并将模型重命名为 <initials>_csma_tx。

  3. 修改状态和转移,使模型如下图所示:

    图 37:CSMA 进程模型

    CSMA 进程模型

    • 3.1 创建一个新状态并命名为 wt_free。
    • 3.2 创建一条从 wt_free 到 tx_pkt 的转移,并将条件改为 CH_GOES_FREE。
    • 3.3 创建一条从 wt_free 状态回到自身的转移,并将条件设置为 default。
    • 3.4 创建一条从 idle 状态到 wt_free 的转移,并将条件改为 PKT_ARVL && !FREE。
    • 3.5 添加一条从 idle 状态回到自身的转移,条件为 default。
    • 3.6 将 idle 状态到 tx_pkt 状态的转移条件改为 PKT_ARVL && FREE。
    • 3.7 将 tx_pkt 到 idle 的无条件转移改为条件转移,即将 condition 属性设置为 default。
    • 3.8 创建一条从 tx_pkt 回到自身的转移,并将条件设置为 PKTS_QUEUED && FREE。
    • 3.9 最后,创建一条从 tx_pkt 到 wt_free 的转移,并将条件设置为 PKTS_QUEUED && !FREE。

    注意: 记住,你可以通过左键单击条件标签并将其拖到新位置来移动标签。

编辑 Header Block

你必须更改 Header Block,使进程在发送之前确认信道是空闲的。进程要发送数据包,必须首先使用 Kernel Procedure op_stat_local_read() 读取信道的 busy 统计量,确认信道空闲。如果信道不空闲,进程进入 wt_free 状态,直到收到"信道变空闲"("channel goes free")中断。

在节点级别,当 busy 统计量变为 0.0 时,底层的统计线被触发。启用该线的 falling edge trigger 属性即可激活触发。

步骤 35:修改 Header Block

  1. 在进程模型 Header Block 的末尾添加以下各行。

    /* input statistic indices */
    #define CH_BUSY_STAT			 		0
    
    /* Conditional macros */
    #define FREE (op_stat_local_read (CH_BUSY_STAT) == 0.0)
    #define PKTS_QUEUED (!op_strm_empty (IN_STRM))
    #define CH_GOES_FREE (op_intrpt_type () == OPC_INTRPT_STAT)
    
  2. 选择 File > Commit,然后选择 File > Close 保存 Header Block。

  3. 编译模型,然后关闭 Process Editor。

增强通用发送器节点模型

你可以增强通用发送器节点模型,使总线接收器模块在接收器 busy 统计量从"忙"(1.0)变为"空闲"(0.0)时,向处理器模块送达一个下降沿统计中断。

下面的过程描述如何增强通用发送器节点模型以支持 CSMA。

步骤 36:增强通用发送器节点模型

  1. 选择 File > Recent Files > Node Model 并选择 <initials>_cct_tx。

  2. 选择 File > Save As… 并将模型重命名为 <initials>_cct_csma_tx。

  3. 右键单击 statistic wire,从弹出菜单中选择 Edit Attributes。将 falling edge trigger 属性设置为 enabled。单击 OK。

  4. 打开 tx_proc 处理器模块的 Attributes 对话框,将 process model 属性改为 <initials>_csma_tx。单击 OK 关闭对话框。

    结果: 处理器现在使用一个能够对接收器模块送达的信道忙统计中断作出反应的进程模型。

  5. 保存修改后的模型并关闭 Node Editor。

重新定义网络模型

现在你已经修改了支持 CSMA 的相关模型,需要更改网络模型以使用这些新模型。不必创建一个全新的模型,你可以复制现有场景(包括网络模型)并做相应的更改。

步骤 37:重新定义网络模型

  1. 在 Project Editor 中,选择 Scenarios > Duplicate Scenario… 并将新场景命名为 CSMA。

    网络模型唯一的更改是使用新的 CSMA 发送器节点。

  2. 右键单击其中一个发送器节点并选择 Select Similar Nodes。

    结果: 全部 20 个发送器节点被选中。

  3. 右键单击任一被选中的节点,从菜单中选择 Edit Attributes。

  4. 选中 Apply to selected objects 复选框。

  5. 将 model 属性改为 <initials>_cct_csma_tx。

    结果: 出现一个对话框,警告你正在更改 Standard Model Library 中节点的属性。

  6. 单击 Yes。

  7. 单击 OK 提交更改。

    结果: 节点模型被改为 <initials>_cct_csma_tx。 消息缓冲区中出现 "20 objects changed" 字样。

配置 CSMA 仿真

为 CSMA 模型配置一系列仿真。

步骤 38:配置 CSMA 仿真

  1. 保存项目。
  2. 选择 DES > Configure/Run Discrete Event Simulation。
  3. 将 Seed 改为 11。
  4. 单击 Run 执行仿真运行。运行这 12 次仿真可能需要几分钟。完成后关闭 DES Execution Manager 对话框。

分析 CSMA 结果

查看结果。

步骤 39:查看结果

  1. 在 Project Editor 中,单击 View Results 工具按钮。

  2. 在 Results Browser 中,如有需要,单击 DES Parametric Studies 选项卡。

  3. 展开 Scalar Statistics,右键单击 Channel Throughput S 标量,选择 Set as Y-Series。

  4. 右键单击 Channel Traffic G scalar 并选择 Set as X-Series。

  5. 单击 Show。

    结果: 你的图应该与下图类似:

    图 38:CSMA 协议:信道吞吐量作为信道流量的函数

    CSMA 协议:信道吞吐量作为信道流量的函数

    CSMA 协议实现了约 0.53 的最大信道吞吐量。

在同一张图上查看两组结果

你的目标是比较 Aloha 和 CSMA 协议。最简单的方法是将两条曲线显示在同一张图上。

步骤 40:在同一张图上查看两组结果

  1. 在 Results Browser 中,将 Results for: 弹出菜单改为 Current Project。

    结果: 结果文件树显示 aloha 和 CSMA 两个场景。

  2. 选择 aloha 场景。

    结果: 预览图变为显示两组运行的结果。

  3. 右键单击 Series 表并选择 Add Scenario Name as Parameter。

    结果: 预览图变为显示两条图线,每条对应一个场景的运行输出。

    图 39:将场景名称添加为参数

    将场景名称添加为参数

  4. 单击 Show。

    结果: 两个标量的图应该与下图类似:

    图 40:Aloha 与 CSMA 协议比较

    Aloha 与 CSMA 协议比较

  5. 关闭图、Results Browser 和 Project Editor。

添加冲突检测与退避

关键概念——如果节点具有完全双工能力,它可以同时发送并监视所连接的总线链路。这种能力可以用 Ethernet 协议来建模。

具有完全双工能力的节点可以同时在线上发送和"监听"('listen'),以确定是否存在冲突条件。这种工作模式通常称为带冲突检测的载波监听多路访问(Carrier-Sense Multiple Access with Collision Detection,即 CSMA/CD)。商用协议 Ethernet 就采用这种方式,而且 Riverbed 提供的示例模型对其进行了精确建模。

由于 Ethernet 是一个相当复杂的模型,你将不会自己构建它。相应地,本节将对标准 Ethernet 进程、节点和网络模型进行一次导览。

ethcoax_net 网络模型

ethcoax_net 网络模型由一个多抽头总线网络组成,其中包含八个节点。这些节点使用节点模型 ethcoax_station_adv。

图 41:ethcoax_net 网络模型

ethcoax_net 网络模型

ethcoax_station_adv 节点模型

关键概念——ethcoax_station_adv 节点模型比 Aloha 或 CSMA 节点模型复杂得多。它有四个处理器模块、一个执行大部分信道接入处理的 queue 模块,以及一对总线接收器和发送器模块。

ethcoax_station_adv 节点模型提供了 OSI 数据链路层中称为媒体接入控制(MAC)子层的部分功能。各模块的功能在下面的段落中讨论。

图 42:ethcoax_station_adv 节点模型

ethcoax_station_adv 节点模型

bus_tx 和 bus_rx 模块充当总线链路接口。这些模块设置为以 10 Mbits/second 的数据速率发送和接收,这是 Ethernet 网络使用的标准数据速率。

sink 处理器代表更高层,它只是接收已经过 mac 处理并传入的数据包。

defer 处理器独立监视链路状态,并维护一个延迟标志(deference flag),mac 进程通过统计线读取该标志,以决定是否允许发送。

bursty_gen 模块代表提交数据以供发送的更高层用户。它使用 ON-OFF 模式生成流量。

mac 进程同时处理传入和传出的数据包。传入的数据包从 Ethernet 帧中解封装,并交付给更高层进程。传出的数据包被封装进 Ethernet 帧,当延迟标志变低时,一个帧被发送到发送器。该进程还监视冲突;如果发生冲突,发送会被适当地终止,并重新安排稍后重试。

eth_mac_v2 进程模型

eth_mac_v2 进程模型管理数据包的发送和接收。这些任务已被分解为三个基本功能:

  • 封装并排队传出的数据包
  • 解封装并交付传入的数据包
  • 管理正在进行的发送

图 43:eth_mac_v2 进程模型

eth_mac_v2 进程模型

ethernet_mac_interface 进程模型

ethernet_mac_interface 进程将代表应用数据的数据包转换为 Ethernet 形式,供 mac 处理器使用。

ethernet_mac_interface 进程从流量源获取数据包,为其指定有效的目的地址(如果为流量目的地指定了随机分配),并将它们发送到 mac 处理器。它还接收来自 mac 处理器的数据包,并将其转发给更高层的流量 sink 进程。

图 44:ethernet_mac_interface 进程模型

ethernet_mac_interface 进程模型

eth_defer_v2 进程模型

eth_defer_v2 进程决定延迟标志应该置高还是置低。eth_mac_v2 进程读取该延迟标志,以决定发送是否被允许,还是必须将信道让给其他用户。

图 45:eth_defer_v2 进程模型

eth_defer_v2 进程模型

执行 ethcoax_net 仿真

加载预定义的 Ethernet 模型并运行一次仿真。

步骤 41:执行 ethcoax_net 仿真

  1. 选择 File > Open… 并进入 <install_dir>&lt;release>\models\std\ tutorial_req\modeler\ethcoax_net.project 目录。

  2. 打开 ethcoax_net 项目。

    结果: ethcoax_net 模型在工作区中打开。

  3. 选择 File > Save As… 并将项目保存为 <initials>_ethcoax_net,保存在默认模型目录中。

    图 46:ethcoax_net 模型

    ethcoax_net 模型

  4. 选择 DES > Run Discrete Event Simulation。

  5. 仿真结束后,单击 Results Browser 按钮。

分析 Ethernet 结果

由于默认 Ethernet 模型收集结果的方式与 Aloha 和 CSMA 仿真不同,你需要采用略有不同的方法来查看该仿真的结果。

步骤 42:分析 Ethernet 结果

  1. 选择 Object Statistics > ethcoax_net > bus_0 [0] > utilization。

  2. 将过滤器类型从 As Is 改为 average,然后单击 Show。

  3. 在 Results Browser 中,取消选择 utilization 并选择 bit_thruput。

  4. 单击 Show。

  5. 摆放好两张图使它们都清晰可见,并思考结果。这两张图应该与下图类似。

    图 47:bit_thruput 与 utilization 图

    bit_thruput 与 utilization 图

虽然总体趋势线相同,但两张图的纵轴范围差异巨大。

bit_thruput 统计量衡量接收器在单位时间内成功接收的平均比特数。根据定义,该统计量只统计与无冲突数据包相关的比特,其最大值不会超过 10 Mbits/second,即分配给信道的数据速率。可以看到,仿真 30 秒后吞吐量稳定在 5.1 Mbits/second 附近。要更准确地读取实际吞吐量,你可以将向量图查看为一组数据点。

步骤 43:将向量图查看为一组数据点

  1. 确认 bit_thruput 面板是活动窗口。

  2. 在面板边框内右键单击并选择 Show Statistic Data。

    图 48:选择 "Show Statistic Data"

    选择 "Show Statistic Data"

    结果: 一个窗口打开,以 ASCII 格式显示该向量的纵坐标与横坐标配对序列。

  3. 从 Statistic Information 对话框顶部的下拉菜单中选择 Statistic Data。

  4. 滚动到编辑区底部,读取向量的最终值。

    ASCII 数据应与所示数据类似:

    图 49:仿真结束时的比特吞吐量

    仿真结束时的比特吞吐量

在仿真结束时,接收器的 bit_thruput 统计量确实几乎正好是 5.1 Mbits/second。将该原始比特吞吐量除以信道容量,得到归一化信道吞吐量 0.51(即信道利用率为 51%)。

查看完数据后,关闭 Statistic Information 对话框。

你也可以在 utilization 图上看到这些值:

步骤 44:在利用率图上查看数值

  1. 单击 average (in utilization) 图以激活该窗口。

  2. 将光标移动到向量的最右端并停留。工具提示会显示信道利用率的最终值。

    你应该会看到约 51% 的平均信道利用率。该值是被探测的发送器所使用的 10 Mbits/second 信道的百分比。

    图 50:utilization 图的平均值

    utilization 图的平均值

这表明,即使信道流量高达 51% 这样相对较高的水平,Ethernet 协议也能够承载基本上全部提交的负载。这也展示了 Ethernet 所采用的载波监听、冲突检测和退避策略相对于纯 Aloha 和 CSMA 协议使用的较简单方法的优势。

祝贺你!你已完成所有 Riverbed Modeler 教程课程。此时,你应该已经能够独立构建自己的网络模型、收集统计量、运行仿真并分析结果。

如果你购买了附加模块(例如 eXpress Data Import),请继续学习演示这些功能的教程。返回 Contents 窗格中的教程列表,从可用课程列表中选择所需的教程。

如果你对 Riverbed Modeler 有疑问,请查阅文档(Help > Product Documentation)。你也可以通过选择 Help > Web - Support Center 联系技术支持。

祝建模顺利!

本站文档由 北京智网畅联科技有限公司 整理、翻译并提供 · Documentation compiled and provided by Beijing ZNetLink Technology Co., Ltd.

交流群 · QQ Group:OPNET/智网妙算网络仿真交流群(群号 486383494)

原文档 © 2017 Riverbed Technology · 本站为公益翻译,由 AI 辅助完成,请仔细甄别

Original documentation © 2017 Riverbed Technology. Community translation, AI-assisted. Contact: jiazequn@znetlink.com