Connect all Compound Module Gates to Submodule in Omnet++ - omnet++

Question

I am relatively new to Omnet++. Currently I am trying to encapsulate a flooding (simple) module inside a compound module. This is what I came up with:
Node.ned:
module Node
{
gates:
inout g[];
submodules:
floodingModule: FloodingModule;
connections allowunconnected:
g++ <--> floodingModule.g++;
}
FloodingModule.ned
simple FloodingNode
{
parameters:
bool sendInitialMessage = default(false);
gates:
inout g[] #loose;
}
Network.ned
network FloodingNetworkSmall {
submodules:
node0 : Node;
node1 : Node;
node2 : Node;
node3 : Node;
node4 : Node;
node5 : Node;
node6 : Node;
node7 : Node;
node8 : Node;
node9 : Node;
connections:
node0.g++ <--> Link <--> node1.g++;
node0.g++ <--> Link <--> node3.g++;
node0.g++ <--> Link <--> node5.g++;
node1.g++ <--> Link <--> node2.g++;
node1.g++ <--> Link <--> node4.g++;
node1.g++ <--> Link <--> node6.g++;
node1.g++ <--> Link <--> node7.g++;
node1.g++ <--> Link <--> node9.g++;
node2.g++ <--> Link <--> node5.g++;
node2.g++ <--> Link <--> node8.g++;
node3.g++ <--> Link <--> node4.g++;
node3.g++ <--> Link <--> node6.g++;
node4.g++ <--> Link <--> node6.g++;
node4.g++ <--> Link <--> node8.g++;
node6.g++ <--> Link <--> node7.g++;
node7.g++ <--> Link <--> node8.g++;
}
I am calling the flooding in the initialize method of the floodingModule like this:
for (GateIterator i(this); !i.end(); i++) {
cGate *gate = *i;
if (gate->getType() == cGate::OUTPUT) {
SimpleMessage *csmsg = smsg->dup();
send(csmsg, gate);
}
}
The problem I am facing is, that the flooding only happens on the first link that is created. This means, there must be a problem mapping the compound module gates to the submodule gates, or not? Am I doing something wrong here which is obvious? Do you need more code?
Thanks for any advice!

Answer 1

I couldn't even start the simulation with your code unmodified, because there were unconnected gates. (And there are some mildly annoying inconsistencies between file and module names, with the words Node and Module, but that is beside the point.)
To solve this, you need to change the connections segment of your Node module to something similar to what's in the Node module of the routing sample simulation included with OMNeT++:
module Node
{
gates:
inout g[];
submodules:
floodingModule: FloodingNode;
connections:
for i=0..sizeof(g)-1 { // <= this is the important part
g++ <--> floodingModule.g++;
}
}
The point is that for every "outside" connection between Nodes in the network, there has to be a corresponding connection (to continue the path) inside the Node module (at each end), between it and the floodingNode submodule. There is no "automatic merging/diverging" of connection paths at the gate vectors on compound module boundaries.
Yes, this means that if any given node has, say, five other nodes connected to it on the same gate vector, then there has to be five "parallel" connections inside that node, all leading to the gate vector of the submodule - in this case.
And there is no need for the allowunconnected specifier, nor the #loose property anywhere, in this case they do more harm by allowing "invalid" networks, than good. They are mostly useful for wireless simulations anyway.
Also, you should consider only scheduling a simple "timer" self-message (even if it's at T=0) in initialize(), and sending the "real" messages in the handleMessage() method when receiving said timer, this way the visualization of the graphical environments work better, and it is also arguably better design.