1.1.2. Discovery Performance
This section provides the results of testing Simple Discovery in RTI Connext 7.3 in different scenarios, where we modify the number of participants (DomainParticipants) and endpoints (DataWriters and DataReaders).
These numbers should only be used as a first rough approximation, since the results are highly dependent on the hardware, software architecture, QoS in use, data types, and network infrastructure of the system.
1.1.2.1. Time to Complete Discovery (SPDP and SPDP2)
The following test measures the time it takes to complete participant discovery as well as endpoint discovery.
To simplify the configuration of the test environment, we assume the following:
Every application in the system runs a single DomainParticipant.
There is only one endpoint per DomainParticipant. Every DomainParticipant creates either a DataReader or a DataWriter.
There is only one Topic in the system.
50% of the endpoints are DataReaders, 50% are DataWriters.
We perform the tests when the entities use Unicast to discover each other and when they use Multicast.
All applications are equally distributed across all the available machines for the test.
Note
This scenario is likely not the optimal design solution for a real-life architecture. The purpose of the test is to demonstrate how powerful the Connext discovery protocol is even in a flat configuration.
Endpoint Discovery
The following graph displays the time it takes to complete endpoint discovery, per number of participants. There is one endpoint for each participant; across all participants, half the endpoints are DataWriters and half are DataReaders. For each scenario, we graph three values: the maximum, median, and minimum times that the participants took to complete endpoint discovery. (Maximums and minimums are the dashed lines; medians are the solid lines).
The following graphs display the amount of bytes sent and received until the discovery process completes, per number of participants. There is one endpoint for each participant; across all participants, half the endpoints are DataWriters and half are DataReaders. For each scenario, we graph three values: the maximum, median, and minimum bytes reported by the participants until the completion of endpoint discovery (Maximums and minimums are the dashed lines; medians are the solid lines).
As mentioned in the note above, this is a flat configuration: A single LAN with one single endpoint per participant, one participant per application and a single topic across the system. Even though this configuration can be useful for benchmarking purposes, it is not recommended for real-life applications.
In this particular multicast scenario, SPDP2’s network usage is higher than SPDP because repairs for the participant configuration packets are sent over unicast and these packets are sent from each participant to each remote participant, whereas a single SPDP multicast Participant announcement (DATA(P)) can be received via multicast by all participants.
The RECEIVED network load is still higher for SPDP because an SPDP participant may receive many multicast DATA(P)s over multicast and these are larger than the bootstrap messages.
Sent Bytes
Received Bytes
Sent Packets
Received Packets
As mentioned in the note above, this is a flat configuration: A single LAN with one single endpoint per participant, one participant per application and a single topic across the system. Even though this configuration can be useful for benchmarking purposes, it is not recommended for real-life applications.
In this particular multicast scenario, SPDP2’s network usage is higher than SPDP because repairs for the participant configuration packets are sent over unicast and these packets are sent from each participant to each remote participant, whereas a single SPDP multicast Participant announcement (DATA(P)) can be received via multicast by all participants.
Packet Sent
Packet Received
Packet Receive Errors
The following graphs display the amount of memory required by the application after completing the discovery process, per number of participants. There is one endpoint for each participant; across all participants, half the endpoints are DataWriters and half are DataReaders. For each scenario, we graph three values: the maximum, median, and minimum bytes reported by the participants until the completion of endpoint discovery (Maximums and minimums are the dashed lines; medians are the solid lines).
Endpoint Discovery
The following graph displays the time it takes to complete endpoint discovery, per number of participants. There is one endpoint for each participant; across all participants, half the endpoints are DataWriters and half are DataReaders. For each scenario, we graph three values: the maximum, median, and minimum times that the participants took to complete endpoint discovery. (Maximums and minimums are the dashed lines; medians are the solid lines).
As mentioned in the note above, this is a flat configuration: A single LAN with one single endpoint per participant, one participant per application and a single topic across the system. Even though this configuration can be useful for benchmarking purposes, it is not recommended for real-life applications.
However, in this particular unicast scenario it is worth noticing that the new SPDP2 protocol can get to substancially better results for large numbers of participants. This is because the SPDP2 protocol’s bootstrap messages and liveliness messages are smaller than the participant announcement messages sent by SPDP. SPDP2 will only need to send the liveliness messages after the initial bootstrap message while SPDP will need to send the whole participant announcement messages (larger in size), this process has to be done by all the participant to every other discovered participant.
The following graphs display the amount of bytes sent and received until the discovery process completes, per number of participants. There is one endpoint for each participant; across all participants, half the endpoints are DataWriters and half are DataReaders. For each scenario, we graph three values: the maximum, median, and minimum bytes reported by the participants until the completion of endpoint discovery (Maximums and minimums are the dashed lines; medians are the solid lines).
As mentioned in the note above, this is a flat configuration: A single LAN with one single endpoint per participant, one participant per application and a single topic across the system. Even though this configuration can be useful for benchmarking purposes, it is not recommended for real-life applications.
However, in this particular unicast scenario it is worth noticing that the new SPDP2 protocol can get to substancially better results for large numbers of participants. This is because the SPDP2 protocol’s bootstrap messages and liveliness messages are smaller than the participant announcement messages sent by SPDP. SPDP2 will only need to send the liveliness messages after the initial bootstrap message while SPDP will need to send the whole participant announcement messages (larger in size), this process has to be done by all the participant to every other discovered participant.
Sent Bytes
Received Bytes
Sent Packets
Received Packets
As mentioned in the note above, this is a flat configuration: A single LAN with one single endpoint per participant, one participant per application and a single topic across the system. Even though this configuration can be useful for benchmarking purposes, it is not recommended for real-life applications.
However, in this particular unicast scenario it is worth noticing that the new SPDP2 protocol can get to substancially better results for large numbers of participants. This is because the SPDP2 protocol’s bootstrap messages and liveliness messages are smaller than the participant announcement messages sent by SPDP. SPDP2 will only need to send the liveliness messages after the initial bootstrap message while SPDP will need to send the whole participant announcement messages (larger in size), this process has to be done by all the participant to every other discovered participant.
Packet Sent
Packet Received
Packet Receive Errors
The following graphs display the amount of memory required by the application after completing the discovery process, per number of participants. There is one endpoint for each participant; across all participants, half the endpoints are DataWriters and half are DataReaders. For each scenario, we graph three values: the maximum, median, and minimum bytes reported by the participants until the completion of endpoint discovery (Maximums and minimums are the dashed lines; medians are the solid lines).
The parameters for testing this scenario are:
Number of hosts: 12
Participants in the system: <variable we increase>
Topics in the system: 1
Readers per topic: half of the participants
Writers per topic: half of the participants
QoS profiles used: DynamicProfile
Software information
RTI developed a testing framework specifically designed for discovery benchmarking. This framework was used to perform the tests detailed in this section. This framework is capable of distributing and executing the different DDS entities across the different machines available in RTI’s Performance and Discovery Lab. It also gathers information about discovery time as well as network usage and memory usage.
The Middleware version used to perform these tests is:
RTI Connext DDS 7.5.0 Host and Target Libraries for x64 Linux (x64Linux4gcc7.3.0)
Hardware information
Linux Nodes
Dell R340 Servers (13 Units)
Processor: Intel Xeon E-2278G (3.4-5GHz, 8c/16t, 16MB cache, 2 memory channels @2666MHz)
RAM: 4x 16GB 2666MHz DIMM (64GB RAM)
HD: 480GB SATA SSD
NIC 1: Intel 710 dual port 10Gbps SFP
OS: Ubuntu 20.04 -- gcc 9.3.0
Switch
Dell 2048 -- 10Gbps switch (10Gbps and 1Gbps interfaces)
QoS Used
Endpoint Discovery
The following graph displays the time it takes to complete endpoint discovery, per number of participants. There is one endpoint for each participant; across all participants, half the endpoints are DataWriters and half are DataReaders. For each scenario, we graph three values: the maximum, median, and minimum times that the participants took to complete endpoint discovery. (Maximums and minimums are the dashed lines; medians are the solid lines).
The following graphs display the amount of bytes sent and received until the discovery process completes, per number of participants. There is one endpoint for each participant; across all participants, half the endpoints are DataWriters and half are DataReaders. For each scenario, we graph three values: the maximum, median, and minimum bytes reported by the participants until the completion of endpoint discovery (Maximums and minimums are the dashed lines; medians are the solid lines).
As mentioned in the note above, this is a flat configuration: A single LAN with one single endpoint per participant, one participant per application and a single topic across the system. Even though this configuration can be useful for benchmarking purposes, it is not recommended for real-life applications.
In this particular multicast scenario, SPDP2’s network usage is higher than SPDP because repairs for the participant configuration packets are sent over unicast and these packets are sent from each participant to each remote participant, whereas a single SPDP multicast Participant announcement (DATA(P)) can be received via multicast by all participants.
Sent Bytes
Received Bytes
Sent Packets
Received Packets
As mentioned in the note above, this is a flat configuration: A single LAN with one single endpoint per participant, one participant per application and a single topic across the system. Even though this configuration can be useful for benchmarking purposes, it is not recommended for real-life applications.
In this particular multicast scenario, SPDP2’s network usage is higher than SPDP because repairs for the participant configuration packets are sent over unicast and these packets are sent from each participant to each remote participant, whereas a single SPDP multicast Participant announcement (DATA(P)) can be received via multicast by all participants.
Packet Sent
Packet Received
Packet Receive Errors
The following graphs display the amount of memory required by the application after completing the discovery process, per number of participants. There is one endpoint for each participant; across all participants, half the endpoints are DataWriters and half are DataReaders. For each scenario, we graph three values: the maximum, median, and minimum bytes reported by the participants until the completion of endpoint discovery (Maximums and minimums are the dashed lines; medians are the solid lines).
Endpoint Discovery
The following graph displays the time it takes to complete endpoint discovery, per number of participants. There is one endpoint for each participant; across all participants, half the endpoints are DataWriters and half are DataReaders. For each scenario, we graph three values: the maximum, median, and minimum times that the participants took to complete endpoint discovery. (Maximums and minimums are the dashed lines; medians are the solid lines).
As mentioned in the note above, this is a flat configuration: A single LAN with one single endpoint per participant, one participant per application and a single topic across the system. Even though this configuration can be useful for benchmarking purposes, it is not recommended for real-life applications.
However, in this particular unicast scenario it is worth noticing that the new SPDP2 protocol can get to substancially better results for large numbers of participants. This is because the SPDP2 protocol’s bootstrap messages and liveliness messages are smaller than the participant announcement messages sent by SPDP. SPDP2 will only need to send the liveliness messages after the initial bootstrap message while SPDP will need to send the whole participant announcement messages (larger in size), this process has to be done by all the participant to every other discovered participant.
The following graphs display the amount of bytes sent and received until the discovery process completes, per number of participants. There is one endpoint for each participant; across all participants, half the endpoints are DataWriters and half are DataReaders. For each scenario, we graph three values: the maximum, median, and minimum bytes reported by the participants until the completion of endpoint discovery (Maximums and minimums are the dashed lines; medians are the solid lines).
As mentioned in the note above, this is a flat configuration: A single LAN with one single endpoint per participant, one participant per application and a single topic across the system. Even though this configuration can be useful for benchmarking purposes, it is not recommended for real-life applications.
However, in this particular unicast scenario it is worth noticing that the new SPDP2 protocol can get to substancially better results for large numbers of participants. This is because the SPDP2 protocol’s bootstrap messages and liveliness messages are smaller than the participant announcement messages sent by SPDP. SPDP2 will only need to send the liveliness messages after the initial bootstrap message while SPDP will need to send the whole participant announcement messages (larger in size), this process has to be done by all the participant to every other discovered participant.
Sent Bytes
Received Bytes
Sent Packets
Received Packets
As mentioned in the note above, this is a flat configuration: A single LAN with one single endpoint per participant, one participant per application and a single topic across the system. Even though this configuration can be useful for benchmarking purposes, it is not recommended for real-life applications.
However, in this particular unicast scenario it is worth noticing that the new SPDP2 protocol can get to substancially better results for large numbers of participants. This is because the SPDP2 protocol’s bootstrap messages and liveliness messages are smaller than the participant announcement messages sent by SPDP. SPDP2 will only need to send the liveliness messages after the initial bootstrap message while SPDP will need to send the whole participant announcement messages (larger in size), this process has to be done by all the participant to every other discovered participant.
Packet Sent
Packet Received
Packet Receive Errors
The following graphs display the amount of memory required by the application after completing the discovery process, per number of participants. There is one endpoint for each participant; across all participants, half the endpoints are DataWriters and half are DataReaders. For each scenario, we graph three values: the maximum, median, and minimum bytes reported by the participants until the completion of endpoint discovery (Maximums and minimums are the dashed lines; medians are the solid lines).
The parameters for testing this scenario are:
Number of hosts: 12
Participants in the system: <variable we increase>
Topics in the system: 1
Readers per topic: half of the participants
Writers per topic: half of the participants
QoS profiles used: DynamicProfile
Software information
RTI developed a testing framework specifically designed for discovery benchmarking. This framework was used to perform the tests detailed in this section. This framework is capable of distributing and executing the different DDS entities across the different machines available in RTI’s Performance and Discovery Lab. It also gathers information about discovery time as well as network usage and memory usage.
The Middleware version used to perform these tests is:
RTI Connext DDS 7.5.0 Host and Target Libraries for x64 Linux (x64Linux4gcc7.3.0)
Hardware information
Linux Nodes
Dell R340 Servers (13 Units)
Processor: Intel Xeon E-2278G (3.4-5GHz, 8c/16t, 16MB cache, 2 memory channels @2666MHz)
RAM: 4x 16GB 2666MHz DIMM (64GB RAM)
HD: 480GB SATA SSD
NIC 1: Intel 710 dual port 10Gbps SFP
OS: Ubuntu 20.04 -- gcc 9.3.0
Switch
Dell 2048 -- 10Gbps switch (10Gbps and 1Gbps interfaces)
QoS Used
1.1.2.2. Limited Bandwidth Plugin (LBED)
Note
This section is not available in 7.5.0. Refer to the Limited Bandwidth Plugin (LBED) section to see the latest updated numbers for these tests.
1.1.2.3. Participant Partitions
Note
This section is not available in 7.5.0. Refer to the Participant Partitions section to see the latest updated numbers for these tests.
1.1.2.4. Limiting Interfaces
Note
This section is not available in 7.5.0. Refer to the Limiting Interfaces section to see the latest updated numbers for these tests.