在 OMNET++ 中连续发送多个数据包

Question

我是 OMNET++ 的新手，需要您的帮助。我正在进行模拟，其中数据包需要从一个模块发送到另一个模块，而无需等待第一个模块发送所有数据包。

 -------------               ------------          -------------   
|   Module A  |     -->     |  Module B  |   -->  |   Module C  |
 -------------               ------------          -------------

现在如果模块 A 通过模块 B 向模块 C 发送 5 个数据包，模块 B 等待所有 5 个数据包接收，并在收到所有 5 个数据包后开始向模块 C 发送。

我想要的是，如果模块B收到一个数据包，它需要直接发送到模块C，而不是等待模块A发送所有数据包。

请查看附件图片以供参考。在这张图片中，您可以看到中间 4 个模块保留所有数据包并在模块 1 发送所有数据包时开始转发。

提前感谢您的帮助。

模块 A 代码

#include <string.h>
#include <omnetpp.h>
#include <iostream>
#include <cstdlib>

using namespace omnetpp;

class QKDProcessor : public cSimpleModule
{
     private:
          int randomGate;
          int counter = 0 ;
     protected:
          virtual void handleMessage(cMessage *msg) override;
};

Define_Module(QKDProcessor);

void QKDProcessor::handleMessage(cMessage *msg)
{
     if(strcmp("QuantumStatesProcessorBob", getName()) == 0)
     {
         delete msg;
         if(counter == 0)
         {
             cMessage *keyCheck = new cMessage("T");
             send(keyCheck,"out",0);
         }
         counter++;
     }
     else
     {
         std::string key = msg->getName();
         delete msg;
         char *stat = new char[key.length()+1];
         strcpy(stat, key.c_str());

         for(int i=0; i<key.length(); i++)
         {
             // Selecting random gates
             double x = rand()/static_cast<double>(RAND_MAX+1);
             randomGate = 0 + static_cast<int>( x * (4 - 0) );

             // Create individual message for each bit.
             std::string j = std::string(1,stat[i]);
             cMessage *quantumState = new cMessage(j.c_str());
             send(quantumState,"out", randomGate);
         }
     }
 }

模块 B 代码

#include <string.h>
#include <omnetpp.h>

 using namespace omnetpp;

 class PolarizationFilter : public cSimpleModule
 {
      protected:
          virtual void handleMessage(cMessage *msg) override;
 };

 Define_Module(PolarizationFilter);

 void PolarizationFilter::handleMessage(cMessage *msg)
 {
     send(msg,"polarizaedLight",0);
 }

模拟日志

** Initializing network
Initializing module QKDNetwork, stage 0
QKDNetwork.AliceProcessor: Initializing module QKDNetwork.AliceProcessor, stage 0
QKDNetwork.BobProcessor: Initializing module QKDNetwork.BobProcessor, stage 0
QKDNetwork.AlicePublicChannel: Initializing module QKDNetwork.AlicePublicChannel, stage 0
QKDNetwork.BobPublicChannel: Initializing module QKDNetwork.BobPublicChannel, stage 0
QKDNetwork.FilterA: Initializing module QKDNetwork.FilterA, stage 0
QKDNetwork.FilterB: Initializing module QKDNetwork.FilterB, stage 0
QKDNetwork.FilterC: Initializing module QKDNetwork.FilterC, stage 0
QKDNetwork.FilterD: Initializing module QKDNetwork.FilterD, stage 0
QKDNetwork.Alice_Quantum_Channel: Initializing module QKDNetwork.Alice_Quantum_Channel, stage 0
QKDNetwork.Bob_Quantum_Channel: Initializing module QKDNetwork.Bob_Quantum_Channel, stage 0
QKDNetwork.DiagonalFilter: Initializing module QKDNetwork.DiagonalFilter, stage 0
QKDNetwork.HorizontalFilter: Initializing module QKDNetwork.HorizontalFilter, stage 0
QKDNetwork.QuantumStatesProcessorBob: Initializing module QKDNetwork.QuantumStatesProcessorBob, stage 0
QKDNetwork.QuantumStatesProcessorAlice: Initializing module QKDNetwork.QuantumStatesProcessorAlice, stage 0
** Event #1  t=0  QKDNetwork.QuantumStatesProcessorAlice (QKDProcessor, id=15)  on 01000001 (omnetpp::cMessage, id=0)
** Event #2  t=0  QKDNetwork.FilterC (PolarizationFilter, id=8)  on 0 (omnetpp::cMessage, id=2)
** Event #3  t=0  QKDNetwork.FilterB (PolarizationFilter, id=7)  on 1 (omnetpp::cMessage, id=4)
** Event #4  t=0  QKDNetwork.FilterB (PolarizationFilter, id=7)  on 0 (omnetpp::cMessage, id=6)
** Event #5  t=0  QKDNetwork.FilterD (PolarizationFilter, id=9)  on 0 (omnetpp::cMessage, id=8)
** Event #6  t=0  QKDNetwork.FilterD (PolarizationFilter, id=9)  on 0 (omnetpp::cMessage, id=10)
** Event #7  t=0  QKDNetwork.FilterC (PolarizationFilter, id=8)  on 0 (omnetpp::cMessage, id=12)
** Event #8  t=0  QKDNetwork.FilterA (PolarizationFilter, id=6)  on 0 (omnetpp::cMessage, id=14)
** Event #9  t=0  QKDNetwork.FilterD (PolarizationFilter, id=9)  on 1 (omnetpp::cMessage, id=16)
** Event #10  t=0  QKDNetwork.Alice_Quantum_Channel (QKDChannel, id=10)  on 0 (omnetpp::cMessage, id=2)

Answer 1

正如 Jerzy 所建议的，您的模拟运行正常。假设您没有在模块之间的通道上设置延迟，您所看到的是所有这些消息交换是同时发生的 (t=0)，而不是按照实际动画所暗示的顺序发生。在模拟时间内，这些消息同时发生。观看右上角的模拟时间显示。在这些消息交换期间它没有进展，而是保持在 0，因此您假设模块 B 在收到消息后不立即发送是错误的。虽然这些消息交换是在同一模拟时间发生的，但模拟器会在动画期间将它们序列化为更好（或更差）。或者换一种说法，这里有两条不同的时间线：模拟时间和动画时间。两者并不相同，有时可能会令人困惑。

现在，如果您想看到更符合模拟时间的动画，您应该转到动画选项对话框并启用广播动画。该模式收集发生在同一个 event 中的所有事件（消息发送）并并行地为它们设置动画。您会看到模块 A 发送的所有消息并行动画，然后模块 B 将发送到 C。请注意，这仍然不是现实（模拟时间）的反映，因为它仅对发生在同一事件（不是在同一模拟时间发生的事件）。即实际上所有模块 A 和 B 都会同时发送消息，并且视频上的所有消息交换都应该立即动画化。但是，该动画也会误导消息发送的图形实现，其中一个点沿着连接线行进，因为在这种情况下，您将丢失因果信息（即，您不会看到来自模块 B 的消息实际上是由从模块 A 传入的消息，因此这种模式也会产生误导）。这就是为什么 OMNeT++ 退回到仅对来自同一事件的消息进行动画处理。

第三种动画方式是去掉移动的点，只闪烁显示发生消息交换的连接线。但是，这也会丢失信息，您会看到屏幕上的所有连接同时闪烁，并且因果关系将再次丢失。

实际上，信息永远不会在物理实体之间以无限的速度传播，因此在它们之间的通道上总是有某种延迟是合理的。对动画有很大帮助。最后一个建议是，您应该使用最新版本的 OMNeT++ 和 Qtenv，因为它已经大大改进了动画功能。