Can OMNET with INET4.4 be used for large-scale simulations?

Question

everybody!

I want to simulate a large-scale (more than thousand nodes) satellite network,e.g.,starlink_p1 constellation with 1584 satellites.

We model satellite as router, and each router connects to a standhost for generating traffic. We use the up-to-date version of OMNET with INET4.4 in Ubuntu20.04, and the topology file (NED) and config file(ini) are complete as the following.

However, when we run the simulation by the means of Cmdenv, the simulation has been initializing for more than a day. I wonder if there's something wrong with my setting, or if omnet does not support large-scale simulation with 1584 nodes.

I look forward to your reply, thanks.

NED.file：

package inet.examples.inet.MegaCons;

import inet.networklayer.configurator.ipv4.Ipv4NetworkConfigurator;
import inet.node.inet.Router;
import inet.node.inet.StandardHost;

network Starlink_p1_grid_topo
{
    parameters:
        int n = 1584;
    types:
        channel Intra_channel extends ned.DatarateChannel
        {
            delay = 2.2ms;
            datarate = 1Gbps;
            ber = 1e-7;
        }
        channel Ref_channel extends ned.DatarateChannel
        {
            datarate = 1Gbps;
            ber = 1e-7;
        }
    submodules:
        sat[n]: Router {
            gates:
                pppg[4];
                ethg[1];
        }
        H1: StandardHost {
            gates:
                ethg[1];
        }
        H2: StandardHost {
            gates:
                ethg[1];
        }
        configurator: Ipv4NetworkConfigurator {
            @display("p=66,93");
        }
    connections allowunconnected:
        sat[125].ethg++ <--> Ref_channel <--> H1.ethg++;
        sat[853].ethg++ <--> Ref_channel <--> H2.ethg++;
        //------intra-plane ISLs---------------- 
        for orb = 0..23,for orb_sat = 0..65 {
            sat[24*orb + orb_sat].pppg++ <--> Ref_channel <--> sat[24*orb + orb_sat + 1].pppg++ if (24*orb + orb_sat < 66*(orb + 1) - 1);
            sat[24*orb + orb_sat].pppg++ <--> Ref_channel <--> sat[24*orb + orb_sat - 65].pppg++ if (24*orb + orb_sat == 66*(orb + 1) - 1);
        } 
        //------inter-plane ISLs---------------- 
         for orb_sat = 0..65,for orb = 0..23 {
            sat[orb_sat + 24*orb].pppg++ <--> Ref_channel <--> sat[orb_sat + 66*(orb + 1)].pppg++ if (orb < 23);
            sat[orb_sat + 24*orb].pppg++ <--> Ref_channel <--> sat[orb_sat + 66*(orb - 23)].pppg++ if (orb == 23);       
        }  
}

INI file ：

[General]
network = Starlink_p1_grid_topo
sim-time-limit = 30s

**.module-eventlog-recording = false
**.sndNxt.statistic-recording = true
**.sndTime.statistic-recording = true
**.rcvSeq.statistic-recording = true
**.rcvTime.statistic-recording = true
**.packetSent.statistic-recording = true
**.packetReceived.statistic-recording = true
**.endToEndDelay.statistic-recording = true
**.throughput.statistic-recording = true
**.**.statistic-recording = false
**.**.bin-recording = false


[Config test]
**.H*.numApps = 2
**.app[0].typename = "UdpBasicApp"
**.app[0].destPort = 1234
**.app[0].messageLength = 128B
**.app[0].sendInterval = 0.1s
**.app[0].startTime = 10s
**.app[0].stopTime = 20s
**.H2.app[0].destAddresses = "H1"
**.H1.app[0].destAddresses = "H2"
**.app[1].typename = "UdpEchoApp"
**.app[1].localPort = 1234

And Cmdenv config is as following:

Answer 1

First, a few comments on your network:

• if you use the ++ operator on gates, you do NOT have to specify the gate sizes (for ethg and pppg) in your hosts. The simulation kernel will allocate new gates as needed when the ++ operator is used.
• It seems that you want to create a 'torus' topology in your network. Your code is sub-omptimal as it tests some conditions unnecessary in the loop and in some places it has definitely bugs (e.g. orb_sat + 24*orb seems definitely wrong to me. isn't that orb_sat + 66*orb ?).

But after correcting these issues, you will still face heavy initialization times (that are non-linear with the size of the network). The reason is the usage of the Ipv4NetworkConfigurator module. That module is very powerful, but if does NOT scale easily with the number of network, because it has to find the shortest path between ALL subnets in the network and configure optimize ALL routing tables everywhere. This is OK if you have a lot of nodes placed in a few subnets, but here you have 1584 routers with 1584 subnets. That is not something the Ipv4NetworkConfigurator can handle in a reasonable time. You MUST remove the Ipv4NetworkConfigurator module from your network and create your own configurator that set's up the routing tables correctly. I'm not sure how you intend to set up the routing at all. Probably, that's the main point of your study. I suggest to remove the network configurator and as a first step, use HostAutoConfigurator in each roiter by placing this in your INI file:

**.configurator.typename = "HostAutoConfigurator"

This just assigns an IP address to the nodes, but it does NOT set up the routing tables, so you won't be able to route packets until you properly set up all the routing tables. Probably static routing tables are not suitable at all and you would need to implement your own routing algorithm (some kind of geographic routing, where the routing is not done based on destination IP addresses, but rather on the desination's geographic location). I'm not even sure that the whole thing should be simulated at network level. Maybe it should work on link layer level? A bit modified version of your code:

network Starlink_p1_grid_topo
{
    parameters:
        int noOfSats = 66;   // satellites per orbital plane
        int noOfPlanes = 24; // number of orbital planes
    types:
    ...
    submodules:
        sat[noOfSats * noOfPlanes]: Router {
                @display("p=,,m,$noOfSats");
        }
        H1: StandardHost {
        }
        H2: StandardHost {
        }
    connections allowunconnected:
        ...
        
        // connect all sat modules in a torus topology        
        for p = 0..noOfPlanes-1,for s = 0..noOfSats-1 {
            sat[p*noOfSats + s].pppg++ <--> Ref_channel <--> sat[p*noOfSats + ((s+1) % noOfSats)].pppg++; // intra-plane link
            sat[p*noOfSats + s].pppg++ <--> Ref_channel <--> sat[((p+1) % noOfPlanes)*noOfSats + s].pppg++; // inter plane-link
        }
}