lifemaps/qt6-migration-pipeline
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5ee38fcc7a8a3784657fc26da398b8994527e0d6
qt6-migration-pipeline/external/rti_connext_dds-7.7.0/resource/xml/BuiltinProfiles.documentationONLY.xml
T
torstenandCopilot 342ffd3e5c Update submodule to latest BUILD_RTI fixes 
- HandlerMinelayerData: BUILD_RTI Guards für RTI-Abhängigkeiten
- svcTabCommon: Export-Header-Fix via Fallback-Target
- TrainingAreaBase: Stub-Header für BUILD_RTI=OFF
- ddsfts: Include-Pfad und Dependency-Fixes
- BUILD_RTI=OFF Compilation vollständig unterstützt

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Entire-Checkpoint: 01M0JNZA586SACX1PRZ2DJAE5S
2026-08-21 19:30:20 +02:00

4153 lines
180 KiB
XML
Raw Blame History

<!--
RTI Connext DDS Builtin QoS Profiles
This file is provided for reference only and should not be modified. The
QoS Profiles in this file are built into the RTI Connext DDS Core libraries and can be
referred to in the APIs by their library names and QoS Profile names. You can also
use the constants documented under Modules/Infrastructure/Builtin QoS Profiles
in the online html documentation.
If you wish to modify any of the values in this file, the recommendation is to
create a QoS Profile of your own and inherit from this one. The
NDDS_QOS_PROFILES.example.xml file (contained in the same directory as
this file) shows how to inherit from the built-in QoS Profiles.
For Example:
<qos_library name="MyLibrary">
<qos_profile name="MyProfile" base_name="BuiltinQosLib::Generic.StrictReliable">
... Change/add QoS settings here ...
</qos_profile>
</qos_library>
This file contains:
Libraries:
* BuiltinQosLib: A library containing built-in QoS Profiles.
* BuiltinQosLibExp: A library containing experimental QoS Profiles. Experimental
QoS Profiles are new QoS Profiles that have been tested internally but have not gone
through an extensive validation period. Therefore, some of the settings may
change in future releases based on customer and internal feedback. After
validation, experimental QoS Profiles will be moved into the non-experimental
library.
* BuiltinQosSnippetLib: A library containing QoS Snippets that are ready
to use as elements for the QoS Profile composition pattern. For further
information about this pattern visit the following article:
https://community.rti.com/best-practices/qos-profile-inheritance-and-composition-guidance
Profiles:
There are 3 types of QoS Profiles:
* Baseline.X.X.X QoS Profiles represent the QoS defaults for
RTI Connext DDS X.X.X. The defaults for the latest RTI Connext DDS version can be
accessed using the BuiltinQosLib::Baseline QoS Profile.
* Generic.X QoS Profiles are horizontal profiles that allow you to easily configure
different features and communication use cases with RTI Connext DDS. For example,
there is a BuiltinQosLib::Generic.StrictReliable that you can use when your
application has a requirement for no data loss, regardless of the application domain.
* Pattern.X QoS Profiles inherit from Generic.X and are vertical profiles
that allow you to configure various domain-specific communication use cases.
For example, there is a Pattern.Alarm QoS Profile that can be used to manage the
generation and consumption of alarm events.
There are several types of QoS Snippets. These are the current
QoS Snippets available:
* Optimization.X: these QoS Snippets optimize one or more parameters related to
the X QoS Policy or a specific use-case.
* QosPolicy.X.Y: these QoS Snippets set a specific QoS Policy X to the value Y.
* Feature.X: these QoS Snippets set all the needed QoS values to enable/modify
a specific feature.
* Transport.X: these QoS Snippets set a specific transport defined by X. This
transport may have specific scenarios that are also specified in the name.
* Compatibility.X: these QoS Snippets change the specific QoS policies to ensure
compatibility with specific products or versions specified by X.
-->
<dds xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../schema/rti_dds_qos_profiles.xsd" version="7.7.0">
<!-- Library for QoS Snippets. Each of these QoS Snippets configures a simple aspect
of QoS Policy. By applying a combination QoS Snippets, you can define QoS Profiles
or other QoS Snippets that incorporate the features/configurations from the
applied QoS Snippets.
Some of these QoS Snippets provide alternative configurations of the
same QoS Policies. Choose just one QoS Snippet of the alternatives when
defining a new QoS Profile or QoS Snippet.
The "alternative configuration" QoS Snippets all have a common prefix to
indicate they represent alternatives and only one of them should be applied.
For example, the following QoS Snippets represent alternative configurations
of the reliability protocol parameters:
Optimization.ReliabilityProtocol.KeepAll
Optimization.ReliabilityProtocol.KeepLast
Optimization.ReliabilityProtocol.HighRate
Optimization.ReliabilityProtocol.LowLatency
etc.
Only one of the above QoS Snippets should be applied, since they all
configure the same set of parameters.
-->
<qos_library name="BuiltinQosSnippetLib">
<!-- Defines parameters common to a set of "alternative" QoS Snippets that
configure the reliability protocol. These QoS Snippets are named using
the prefix "Optimization.ReliabilityProtocol."
Modified QoS Parameters:
datawriter_qos.protocol.rtps_reliable_writer
datareader_qos.resource_limits
datareader_qos.protocol.rtps_reliable_reader
This QoS Snippet configures the reliability protocol parameters for more aggressive
(faster) heartbeats so that sample loss is detected and repaired faster.
This QoS Snippet also sets the max_heartbeat_retries, which works in combination
with the heartbeat rate to determine when the DataWriter considers a DataReader
non-responsive. This QoS Snippet configures the reliable writer protocol parameters
so that the DataWriter considers the DataReader to be "inactive" after 500
unresponded heartbeats.
-->
<qos_profile name="Optimization.ReliabilityProtocol.Common">
<?rti-qos_snippet?>
<datawriter_qos>
<protocol>
<rtps_reliable_writer>
<!-- All write() calls will block (for at most
max_blocking_time) if there are 40 unacknowledged
samples in the writer queue -->
<max_send_window_size>40</max_send_window_size>
<min_send_window_size>40</min_send_window_size>
<heartbeats_per_max_samples>10</heartbeats_per_max_samples>
<!-- See high_watermark -->
<fast_heartbeat_period>
<sec>0</sec>
<nanosec>20000000</nanosec>
</fast_heartbeat_period>
<late_joiner_heartbeat_period>
<sec>0</sec>
<nanosec>20000000</nanosec>
</late_joiner_heartbeat_period>
<max_nack_response_delay>
<sec>0</sec>
<nanosec>0</nanosec>
</max_nack_response_delay>
<!-- When the number of unacknowledged samples reaches
the high_watermark, the fast_heartbeat_period is
used -->
<high_watermark>25</high_watermark>
<!-- When the number of unacknowledged samples dips
below the low_watermark, the heartbeat_period is
used (200 ms by default) -->
<low_watermark>10</low_watermark>
<!-- The maximum number of heartbeat retries before a
remote DataReader is marked as inactive -->
<max_heartbeat_retries>500</max_heartbeat_retries>
</rtps_reliable_writer>
</protocol>
</datawriter_qos>
<datareader_qos>
<resource_limits>
<max_samples>256</max_samples>
</resource_limits>
<protocol>
<rtps_reliable_reader>
<min_heartbeat_response_delay>
<sec>0</sec>
<nanosec>0</nanosec>
</min_heartbeat_response_delay>
<max_heartbeat_response_delay>
<sec>0</sec>
<nanosec>0</nanosec>
</max_heartbeat_response_delay>
</rtps_reliable_reader>
</protocol>
</datareader_qos>
</qos_profile>
<!-- Optimizes the DataWriter reliable protocol parameters for a reliable DataWriter
with HISTORY set to KEEP_ALL.
Modified QoS Parameters:
datawriter_qos.protocol.rtps_reliable_writer
datareader_qos.resource_limits
datareader_qos.protocol.rtps_reliable_reader
Note that QoS Snippet does not configure the RELIABILITY or HISTORY QoS policies.
It is intended to be used in combination with other QoS Snippets that configure
those policies.
-->
<qos_profile name="Optimization.ReliabilityProtocol.KeepAll">
<?rti-qos_snippet?>
<base_name>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.Common</element>
</base_name>
</qos_profile>
<!-- Optimizes the DataWriter reliable protocol parameters for a reliable DataWriter
with HISTORY set to KEEP_LAST.
Modified QoS Parameters:
datawriter_qos.resource_limits
datawriter_qos.protocol.rtps_reliable_writer
datareader_qos.resource_limits
datareader_qos.protocol.rtps_reliable_reader
Note that this QoS Snippet does not configure the RELIABILITY or HISTORY QoS policies.
It is intended to be used in combination with other QoS Snippets that configure
those policies.
-->
<qos_profile name="Optimization.ReliabilityProtocol.KeepLast">
<?rti-qos_snippet?>
<base_name>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.Common</element>
</base_name>
<datawriter_qos>
<resource_limits>
<max_samples>LENGTH_UNLIMITED</max_samples>
</resource_limits>
<protocol>
<rtps_reliable_writer>
<!-- Do not block because of the send_window -->
<max_send_window_size>LENGTH_UNLIMITED</max_send_window_size>
<min_send_window_size>LENGTH_UNLIMITED</min_send_window_size>
</rtps_reliable_writer>
</protocol>
</datawriter_qos>
<datareader_qos>
<resource_limits>
<max_samples>LENGTH_UNLIMITED</max_samples>
</resource_limits>
</datareader_qos>
</qos_profile>
<!-- Optimizes the DataWriter reliable protocol parameters for a reliable DataWriter
that is writing messages at high rates, especially in situations where throughput
is favored over latency.
Modified QoS Parameters:
datawriter_qos.protocol.rtps_reliable_writer
datareader_qos.resource_limits
datareader_qos.protocol.rtps_reliable_reader
This QoS Snippet sets a fast rate of heartbeats so that errors are detected and
repaired more swiftly.
Note that to get the highest thoughout you may need to apply additional changes to
the final QoS Profile. See the QoS Profile "Generic.StrictReliable.HighThroughput" for
further information.
-->
<qos_profile name="Optimization.ReliabilityProtocol.HighRate">
<?rti-qos_snippet?>
<base_name>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.Common</element>
</base_name>
<datawriter_qos>
<protocol>
<rtps_reliable_writer>
<!-- Speed up the heartbeat rate -->
<heartbeat_period>
<!-- 10 milliseconds: -->
<sec>0</sec>
<nanosec>10000000</nanosec>
</heartbeat_period>
<!-- Speed up the heartbeat rate -->
<fast_heartbeat_period>
<!-- 1 millisecond: -->
<sec>0</sec>
<nanosec>1000000</nanosec>
</fast_heartbeat_period>
<!-- Speed up the heartbeat rate -->
<late_joiner_heartbeat_period>
<!-- 1 millisecond: -->
<sec>0</sec>
<nanosec>1000000</nanosec>
</late_joiner_heartbeat_period>
<!-- The heartbeat rate is faster, so allow more time for readers
to respond before they are deactivated. -->
<max_heartbeat_retries>1000</max_heartbeat_retries>
</rtps_reliable_writer>
</protocol>
</datawriter_qos>
</qos_profile>
<!-- Modifies the Reliable Protocol parameters to accomplish low latency.
Modified QoS Parameters:
datawriter_qos.protocol.rtps_reliable_writer
datareader_qos.resource_limits
datareader_qos.protocol.rtps_reliable_reader
Note that to get the lowest latency you may need to apply additional changes to
the final QoS Profile. See the QoS Profile "Generic.StrictReliable.LowLatency" for
further information.
-->
<qos_profile name="Optimization.ReliabilityProtocol.LowLatency">
<?rti-qos_snippet?>
<base_name>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.Common</element>
</base_name>
<datareader_qos>
<protocol>
<rtps_reliable_reader>
<heartbeat_suppression_duration>
<sec>0</sec>
<nanosec>0</nanosec>
</heartbeat_suppression_duration>
</rtps_reliable_reader>
</protocol>
</datareader_qos>
<datawriter_qos>
<protocol>
<rtps_reliable_writer>
<max_send_window_size>40</max_send_window_size>
<min_send_window_size>40</min_send_window_size>
<!-- Send a piggyback heartbeat per sample -->
<heartbeats_per_max_samples>40</heartbeats_per_max_samples>
</rtps_reliable_writer>
</protocol>
</datawriter_qos>
</qos_profile>
<!-- Modifies the Reliable Protocol parameters and Resource Limits to
work better with Large Data.
Modified QoS Parameters:
datawriter_qos.protocol.rtps_reliable_writer
datareader_qos.resource_limits
datareader_qos.protocol.rtps_reliable_reader
Note that, to send large data, it is recommended to apply additional
changes that configure the data caches, transport buffers, etc.
See, for example, Generic.KeepLastReliable.LargeData,
and derivatives for a fully functional Large Data QoS Profiles.
-->
<qos_profile name="Optimization.ReliabilityProtocol.LargeData">
<?rti-qos_snippet?>
<base_name>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.Common</element>
</base_name>
<datawriter_qos>
<protocol>
<rtps_reliable_writer>
<max_send_window_size>10</max_send_window_size>
<min_send_window_size>10</min_send_window_size>
<heartbeats_per_max_samples>10</heartbeats_per_max_samples>
</rtps_reliable_writer>
</protocol>
</datawriter_qos>
</qos_profile>
<!-- Configures the DataWriter and DataReader caches to use dynamic
memory allocation for Large Data samples.
Modified QoS Parameters:
datawriter_qos.resource_limits
datawriter_qos.property => dds.data_writer.history.memory_manager
datareader_qos.resource_limits
datareader_qos.reader_resource_limits
datareader_qos.property => dds.data_reader.history.memory_manager
This configuration is needed to handle data that contains unbounded
sequences or strings.
This QoS Snippet is also recommended if samples can have very different
sizes and the bigger samples can be very large.
If dynamic memory allocation is not used for the larger samples, then
all samples are allocated to their maximum size which can consume a
lot of resources.
-->
<qos_profile name="Optimization.DataCache.LargeData.DynamicMemAlloc">
<?rti-qos_snippet?>
<datawriter_qos>
<resource_limits>
<!-- Initially, only allocate 1 sample because the samples
are large -->
<initial_samples>1</initial_samples>
</resource_limits>
<property>
<value>
<!-- The min_size property configures the minimum size of the
serialization buffer.
(only supported when using the JAVA API) -->
<element>
<name>dds.data_writer.history.memory_manager.java_stream.min_size</name>
<value>1000000</value>
</element>
<!-- Setting the trim_to_size property to true means that the
serialization buffer will be reallocated with each new sample
in order to fit the sample's serialized size.
(only supported when using the JAVA API) -->
<element>
<name>dds.data_writer.history.memory_manager.java_stream.trim_to_size</name>
<value>true</value>
</element>
</value>
</property>
</datawriter_qos>
<datareader_qos>
<resource_limits>
<initial_samples>1</initial_samples>
<!-- We limit max_samples on the reader so that if the writer is
publishing samples faster than the reader is taking them, then
the reader will start sending NACKs for samples received after
the number of samples in its queue reaches max_samples. This
behavior will put pressure on the writer to throttle back its
publishing speed. -->
<max_samples>20</max_samples>
</resource_limits>
<reader_resource_limits>
<!-- Determines whether the DataReader pre-allocates storage for
storing fragmented samples. This setting can be used to limit
up-front memory allocation costs in applications that deal with
large data -->
<dynamically_allocate_fragmented_samples>true</dynamically_allocate_fragmented_samples>
</reader_resource_limits>
<property>
<value>
<element>
<name>dds.data_reader.history.memory_manager.fast_pool.pool_buffer_max_size</name>
<value>32768</value>
</element>
<element>
<name>dds.data_reader.history.memory_manager.java_stream.min_size</name>
<value>1000000</value>
</element>
<element>
<name>dds.data_reader.history.memory_manager.java_stream.trim_to_size</name>
<value>true</value>
</element>
</value>
</property>
</datareader_qos>
</qos_profile>
<!-- Optimizes the Participant QoS to detect faster discovery changes. This
QoS Snippet increases the speed moderately so that it fits the normal scenarios.
Modified QoS Parameters:
participant_qos.discovery_config.participant_liveliness_lease_duration
participant_qos.discovery_config.participant_liveliness_assert_period
participant_qos.discovery_config.max_liveliness_loss_detection_period
participant_qos.discovery_config.initial_participant_announcements
participant_qos.discovery_config.publication_writer
participant_qos.discovery_config.subscription_writer
-->
<qos_profile name="Optimization.Discovery.Common">
<?rti-qos_snippet?>
<domain_participant_qos>
<!-- Participant discovery time control and reduction -->
<discovery_config>
<participant_liveliness_lease_duration>
<sec>10</sec>
<nanosec>0</nanosec>
</participant_liveliness_lease_duration>
<participant_liveliness_assert_period>
<sec>3</sec>
<nanosec>0</nanosec>
</participant_liveliness_assert_period>
<max_liveliness_loss_detection_period>
<sec>6</sec>
<nanosec>0</nanosec>
</max_liveliness_loss_detection_period>
<initial_participant_announcements>3</initial_participant_announcements>
<!-- Built-in endpoints reliability protocol reduction -->
<publication_writer>
<fast_heartbeat_period>
<sec>1</sec>
<nanosec>0</nanosec>
</fast_heartbeat_period>
<max_bytes_per_nack_response>2000</max_bytes_per_nack_response>
</publication_writer>
<subscription_writer>
<fast_heartbeat_period>
<sec>1</sec>
<nanosec>0</nanosec>
</fast_heartbeat_period>
<max_bytes_per_nack_response>2000</max_bytes_per_nack_response>
</subscription_writer>
</discovery_config>
</domain_participant_qos>
</qos_profile>
<!-- Optimizes the Participant QoS to send less discovery information.
Modified QoS Parameters:
participant_qos.property => dds.participant.inter_participant
participant_qos.property => dds.sys_info
-->
<qos_profile name="Optimization.Discovery.Participant.Compact">
<?rti-qos_snippet?>
<!-- Participant properties-->
<domain_participant_qos>
<property>
<value>
<!-- Disable Preemptive HBs and ACKNACKs-->
<element>
<name>dds.participant.inter_participant_data_reader.protocol.disable_preemptive_nack</name>
<value>1</value>
</element>
<element>
<name>dds.participant.inter_participant_data_writer.protocol.disable_preemptive_heartbeat</name>
<value>1</value>
</element>
<!-- Control Application information-->
<element>
<name>dds.sys_info.creation_timestamp</name>
<value/>
<propagate>false</propagate>
</element>
<element>
<name>dds.sys_info.executable_filepath</name>
<value/>
<propagate>false</propagate>
</element>
<element>
<name>dds.sys_info.execution_timestamp</name>
<value/>
<propagate>false</propagate>
</element>
<element>
<name>dds.sys_info.target</name>
<value/>
<propagate>false</propagate>
</element>
<element>
<name>dds.sys_info.username</name>
<value/>
<propagate>false</propagate>
</element>
<!--
These 2 properties are commented because they are sent by default.
Uncomment the following lines to avoid sending info about the hostname
and process_id.
-->
<!--
<element>
<name>dds.sys_info.hostname</name>
<propagate>false</propagate>
<value/>
</element>
<element>
<name>dds.sys_info.process_id</name>
<propagate>false</propagate>
<value/>
</element>
-->
</value>
</property>
</domain_participant_qos>
</qos_profile>
<!-- QoS Snippet to optimize Endpoint Discovery to be faster. This
is useful when using security, to prevent a noticeable delay.
Modified QoS Parameters:
participant_qos.discovery_config.publication_writer
participant_qos.discovery_config.subscription_writer
-->
<qos_profile name="Optimization.Discovery.Endpoint.Fast">
<?rti-qos_snippet?>
<domain_participant_qos>
<discovery_config>
<!-- These settings prevent a noticeable delay during discovery. -->
<publication_writer>
<fast_heartbeat_period>
<sec>1</sec>
<nanosec>0</nanosec>
</fast_heartbeat_period>
<late_joiner_heartbeat_period>
<sec>1</sec>
<nanosec>0</nanosec>
</late_joiner_heartbeat_period>
<max_heartbeat_retries>30</max_heartbeat_retries>
</publication_writer>
<subscription_writer>
<fast_heartbeat_period>
<sec>1</sec>
<nanosec>0</nanosec>
</fast_heartbeat_period>
<late_joiner_heartbeat_period>
<sec>1</sec>
<nanosec>0</nanosec>
</late_joiner_heartbeat_period>
<max_heartbeat_retries>30</max_heartbeat_retries>
</subscription_writer>
</discovery_config>
</domain_participant_qos>
</qos_profile>
<!-- Modifies the Participant QoS to increase the default buffer
that shmem and udpv4 use. This is useful when using Large Data
Modified QoS Parameters:
participant_qos.transport_builtin
-->
<qos_profile name="Optimization.Transport.LargeBuffers">
<?rti-qos_snippet?>
<domain_participant_qos>
<transport_builtin>
<shmem>
<receive_buffer_size>2097152</receive_buffer_size>
<received_message_count_max>32</received_message_count_max>
</shmem>
<udpv4>
<send_socket_buffer_size>524288</send_socket_buffer_size>
<recv_socket_buffer_size>1048576</recv_socket_buffer_size>
</udpv4>
</transport_builtin>
</domain_participant_qos>
</qos_profile>
<!-- Sets RELIABILITY QoS to RELIABLE and configures a blocking time in
case the DataWriter writes faster than the DataReaders can accommodate.
Modified QoS Parameters:
datawriter_qos.reliability
datareader_qos.reliability
Note that by itself enabling RELIABILITY does not ensure that every sample
written is delivered to the DataReaders. This is because the DataWriter
and/or DataReader can be configured to override samples in its cache
based on the configuration of the HISTORY QoS policy.
To ensure delivery of every sample (at the expense of potentially blocking the
DataWriter), use the QoS Profile BuiltinQosLib::Generic.StrictReliable or
one of the derived QoS Profiles.
-->
<qos_profile name="QosPolicy.Reliability.Reliable">
<?rti-qos_snippet?>
<datawriter_qos>
<reliability>
<kind>RELIABLE_RELIABILITY_QOS</kind>
<max_blocking_time>
<sec>5</sec>
<nanosec>0</nanosec>
</max_blocking_time>
</reliability>
</datawriter_qos>
<datareader_qos>
<reliability>
<kind>RELIABLE_RELIABILITY_QOS</kind>
</reliability>
</datareader_qos>
</qos_profile>
<!-- Sets RELIABILITY QoS to BEST_EFFORT.
Modified QoS Parameters:
datawriter_qos.reliability
datareader_qos.reliability
With best-effort, there are no resources spent to confirm delivery
of samples nor repairs of any samples that may be lost.
Best-effort communication reduces jitter; therefore, the delay between
sending data and receiving it is more deterministic for the samples that are
actually received. Best-effort is good for periodic data where it may be
better to get the next value than to wait for the previous one to be repaired.
-->
<qos_profile name="QosPolicy.Reliability.BestEffort">
<?rti-qos_snippet?>
<datawriter_qos>
<reliability>
<kind>BEST_EFFORT_RELIABILITY_QOS</kind>
</reliability>
</datawriter_qos>
<datareader_qos>
<reliability>
<kind>BEST_EFFORT_RELIABILITY_QOS</kind>
</reliability>
</datareader_qos>
</qos_profile>
<!-- Sets the DataWriter and DataReader HISTORY QoS to KEEP_LAST kind with depth 1.
Modified QoS Parameters:
datawriter_qos.history
datareader_qos.history
-->
<qos_profile name="QosPolicy.History.KeepLast_1">
<?rti-qos_snippet?>
<datawriter_qos>
<history>
<kind>KEEP_LAST_HISTORY_QOS</kind>
<depth>1</depth>
</history>
</datawriter_qos>
<datareader_qos>
<history>
<kind>KEEP_LAST_HISTORY_QOS</kind>
<depth>1</depth>
</history>
</datareader_qos>
</qos_profile>
<!-- Sets the DataWriter and DataReader HISTORY QoS Policy to KEEP_ALL kind.
Modified QoS Parameters:
datawriter_qos.history
datareader_qos.history
-->
<qos_profile name="QosPolicy.History.KeepAll">
<?rti-qos_snippet?>
<datawriter_qos>
<history>
<kind>KEEP_ALL_HISTORY_QOS</kind>
</history>
</datawriter_qos>
<datareader_qos>
<history>
<kind>KEEP_ALL_HISTORY_QOS</kind>
</history>
</datareader_qos>
</qos_profile>
<!-- Sets the DataWriter PUBLISH_MODE QoS Policy to ASYNCHRONOUS kind.
Modified QoS Parameters:
datawriter_qos.publish_mode
Asynchronous Publish mode decouples the application thread that calls the
DataWriter "write" operation from the thread used to send the data on the
network. See https://community.rti.com/glossary/asynchronous-writer
-->
<qos_profile name="QosPolicy.PublishMode.Asynchronous">
<?rti-qos_snippet?>
<datawriter_qos>
<publish_mode>
<kind>ASYNCHRONOUS_PUBLISH_MODE_QOS</kind>
</publish_mode>
</datawriter_qos>
</qos_profile>
<!-- Sets the DataWriter and DataReader DURABILITY QoS Policy to TRANSIENT_LOCAL
kind.
Modified QoS Parameters:
datawriter_qos.durability
datareder_qos.durability
DataWriters will store and send previously published DDS samples for
delivery to newly discovered DataReaders as long as the DataWriter still
exists. For this setting to be effective, you must also set the
RELIABILITY QosPolicy kind to Reliable (not Best Effort). Which particular
DDS samples are kept depends on other QoS settings such as HISTORY QosPolicy
and RESOURCE_LIMITS QosPolicy.
-->
<qos_profile name="QosPolicy.Durability.TransientLocal">
<?rti-qos_snippet?>
<datareader_qos>
<durability>
<kind>TRANSIENT_LOCAL_DURABILITY_QOS</kind>
</durability>
</datareader_qos>
<datawriter_qos>
<durability>
<kind>TRANSIENT_LOCAL_DURABILITY_QOS</kind>
</durability>
</datawriter_qos>
</qos_profile>
<!-- Sets the DataWriter and DataReader DURABILITY QoS Policy to TRANSIENT kind.
Modified QoS Parameters:
datawriter_qos.durability
datareder_qos.durability
RTI Connext DDS will store previously published DDS samples in memory using
Persistence Service, which will send the stored data to newly discovered
DataReaders. Which particular DDS samples are kept and sent by Persistence
Service depends on the HISTORY QosPolicy and RESOURCE_LIMITS QosPolicy of
the Persistence Service DataWriters. These QosPolicies can be configured in
the Persistence Service configuration file or through the DURABILITY SERVICE
QosPolicy of the DataWriters configured with DDS_TRANSIENT_DURABILITY_QOS.
You need a Persistence Service instance running to use this behavior.
-->
<qos_profile name="QosPolicy.Durability.Transient">
<?rti-qos_snippet?>
<datareader_qos>
<durability>
<kind>TRANSIENT_DURABILITY_QOS</kind>
</durability>
</datareader_qos>
<datawriter_qos>
<durability>
<!-- Transient durability requires the use of the
Persistence Service -->
<kind>TRANSIENT_DURABILITY_QOS</kind>
</durability>
<durability_service>
<!-- The DurabilityServiceQosPolicy is used to
configure how the persistence service manages its
memory and local cache. When using Transient durability, the
persistence service maintains an in-memory cache of
stored data. These values, therefore, represent memory
usage. -->
<history_kind>KEEP_LAST_HISTORY_QOS</history_kind>
<history_depth>1</history_depth>
<max_samples>LENGTH_UNLIMITED</max_samples>
<max_instances>LENGTH_UNLIMITED</max_instances>
<max_samples_per_instance>LENGTH_UNLIMITED</max_samples_per_instance>
</durability_service>
</datawriter_qos>
</qos_profile>
<!-- Sets the DataWriter and DataReader DURABILITY QoS Policy to PERSISTENT kind.
Modified QoS Parameters:
datawriter_qos.durability
datareader_qos.durability
RTI Connext DDS will store previously published DDS samples in permanent
storage, like a disk, using Persistence Service, which will send the
stored data to newly discovered DataReaders. Which particular DDS samples
are kept and sent by Persistence Service depends on the HISTORY QosPolicy
and RESOURCE_LIMITS QosPolicy in the Persistence Service DataWriters.
These QosPolicies can be configured in the Persistence Service configuration
file or through the DURABILITY SERVICE QosPolicy of the DataWriters
configured with DDS_PERSISTENT_DURABILITY_QOS.
You need a Persistence Service instance running to use this behavior.
-->
<qos_profile name="QosPolicy.Durability.Persistent">
<?rti-qos_snippet?>
<datareader_qos>
<durability>
<kind>PERSISTENT_DURABILITY_QOS</kind>
</durability>
</datareader_qos>
<datawriter_qos>
<durability>
<kind>PERSISTENT_DURABILITY_QOS</kind>
</durability>
</datawriter_qos>
</qos_profile>
<!-- Sets the DataWriter BATCH QoS Policy to true.
Modified QoS Parameters:
datawriter_qos.batch
This QoS Snippet specifies and configures the mechanism that allows
RTI Connext DDS to collect multiple user data DDS samples to be sent in
a single network packet, to take advantage of the efficiency of sending
larger packets and thus increase effective throughput.
-->
<qos_profile name="QosPolicy.Batching.Enable">
<?rti-qos_snippet?>
<datawriter_qos>
<!-- When sending very many small data samples, the efficiency of
the network can be increased by batching multiple samples together
in a single protocol-level message (usually corresponding to a
single network datagram). Batching can offer very substantial
throughput gains, but often at the expense of latency, although in
some configurations, the latency penalty can be very small or even
zero - even negative. -->
<batch>
<enable>true</enable>
<!-- Batches can be "flushed" to the network based on a maximum size.
This size can be based on the total number of bytes in the
accumulated data samples and/or the number of samples. Whenever
the first of these limits is reached, the batch will be
flushed. -->
<!-- 30 KB -->
<max_data_bytes>30720</max_data_bytes>
<max_samples>LENGTH_UNLIMITED</max_samples>
<!-- Batches can be flushed to the network based on an elapsed
time -->
<max_flush_delay>
<sec>0</sec>
<nanosec>10000000</nanosec>
</max_flush_delay>
</batch>
</datawriter_qos>
</qos_profile>
<!-- Disables sending serialized Typecodes and Typeobjects during endpoint
discovery.
Modified QoS Parameters:
domain_participant_qos.resource_limits
This QoS Snippet sets the allowable serialized size for type codes and
type objects to 0, which effectively disables sending type codes and
type objects as part of endpoint discovery messages for DataReaders and
DataWriters.
Doing this will descrease the size of the samples that are sent during
endpoint discovery (Data(w) and Data(r) messages). However, this will
prevent Connext DDS Professional from performing type matching, so
endpoints will match only based on topic and type names and there will
be no enforcement or checking for correct type extensibility and
evolution.
-->
<qos_profile name="QosPolicy.SerializedTypes.Disable">
<?rti-qos_snippet?>
<domain_participant_qos>
<resource_limits>
<!-- Disable Type Code serialization -->
<type_code_max_serialized_length>0</type_code_max_serialized_length>
<!-- Disable Type Object V1 serialization -->
<type_object_max_serialized_length>LENGTH_AUTO</type_object_max_serialized_length>
</resource_limits>
<discovery_config>
<!-- Disable Type Object V2 serialization -->
<enabled_builtin_channels>SERVICE_REQUEST_CHANNEL</enabled_builtin_channels>
</discovery_config>
</domain_participant_qos>
</qos_profile>
<!-- Disables DataWriter compression support
Modified QoS Parameters:
datawriter_qos.representation
RTI Connext DDS DataWriters do not enable compression by default, so
this QoS snippet does not modify any default behavior.
-->
<qos_profile name="QosPolicy.Compression.Disable">
<?rti-qos_snippet?>
<datawriter_qos>
<representation>
<compression_settings>
<compression_ids>MASK_NONE</compression_ids>
</compression_settings>
</representation>
</datawriter_qos>
</qos_profile>
<!-- The set of QoS Snippets with names starting with "Feature.FlowController."
configure a flow controller and set the DataWriter QoS to use it.
The QoS Snippets differ in the parameters of the flow controller so that
they set the throughput limit to 3 different values.
-->
<!-- The next set of QoS Snippets define three flow controllers that can be
selected for individual DataWriters. The configurations differ only
in the amount of tokens added and allowed per period (128, 32 and 8)
for fast, medium, and slow, respectively. Using 8Kb tokens, a 1M
sample will take 128 tokens. -->
<!-- Configures a FlowController of 838 Mbps (~ 100 MB/sec)
Modified QoS Parameters:
participant_qos.property => dds.flow_controller.token_bucket
datawriter_qos.publish_mode
-->
<qos_profile name="Feature.FlowController.838Mbps">
<?rti-qos_snippet?>
<domain_participant_qos>
<property>
<value>
<element>
<name>dds.flow_controller.token_bucket.fast_flow.token_bucket.max_tokens</name>
<value>128</value>
</element>
<element>
<name>dds.flow_controller.token_bucket.fast_flow.token_bucket.tokens_added_per_period</name>
<value>128</value>
</element>
<element>
<name>dds.flow_controller.token_bucket.fast_flow.token_bucket.bytes_per_token</name>
<value>8192</value>
</element>
<element>
<name>dds.flow_controller.token_bucket.fast_flow.token_bucket.period.sec</name>
<value>0</value>
</element>
<element>
<name>dds.flow_controller.token_bucket.fast_flow.token_bucket.period.nanosec</name>
<value>10000000</value>
</element>
</value>
</property>
</domain_participant_qos>
<datawriter_qos>
<publish_mode>
<flow_controller_name>dds.flow_controller.token_bucket.fast_flow</flow_controller_name>
</publish_mode>
</datawriter_qos>
</qos_profile>
<!-- Configures a FlowController of 209 Mbps (~ 25 MB/sec)
Modified QoS Parameters:
participant_qos.property => dds.flow_controller.token_bucket
datawriter_qos.publish_mode
-->
<qos_profile name="Feature.FlowController.209Mbps">
<?rti-qos_snippet?>
<domain_participant_qos>
<property>
<value>
<!-- medium: 25 MB/sec (209 Mb/sec) flow controller -->
<element>
<name>dds.flow_controller.token_bucket.medium_flow.token_bucket.max_tokens</name>
<value>32</value>
</element>
<element>
<name>dds.flow_controller.token_bucket.medium_flow.token_bucket.tokens_added_per_period</name>
<value>32</value>
</element>
<element>
<name>dds.flow_controller.token_bucket.medium_flow.token_bucket.bytes_per_token</name>
<value>8192</value>
</element>
<element>
<name>dds.flow_controller.token_bucket.medium_flow.token_bucket.period.sec</name>
<value>0</value>
</element>
<element>
<name>dds.flow_controller.token_bucket.medium_flow.token_bucket.period.nanosec</name>
<value>10000000</value>
</element>
</value>
</property>
</domain_participant_qos>
<datawriter_qos>
<publish_mode>
<flow_controller_name>dds.flow_controller.token_bucket.medium_flow</flow_controller_name>
</publish_mode>
</datawriter_qos>
</qos_profile>
<!-- Configures a FlowController of 52 Mbps (~ 6.25 MB/sec)
Modified QoS Parameters:
participant_qos.property => dds.flow_controller.token_bucket
datawriter_qos.publish_mode
-->
<qos_profile name="Feature.FlowController.52Mbps">
<?rti-qos_snippet?>
<domain_participant_qos>
<property>
<value>
<!-- slow: 6.25 MB/sec (50 Mb/sec) flow controller -->
<element>
<name>dds.flow_controller.token_bucket.slow_flow.token_bucket.max_tokens</name>
<value>8</value>
</element>
<element>
<name>dds.flow_controller.token_bucket.slow_flow.token_bucket.tokens_added_per_period</name>
<value>8</value>
</element>
<element>
<name>dds.flow_controller.token_bucket.slow_flow.token_bucket.bytes_per_token</name>
<value>8192</value>
</element>
<element>
<name>dds.flow_controller.token_bucket.slow_flow.token_bucket.period.sec</name>
<value>0</value>
</element>
<element>
<name>dds.flow_controller.token_bucket.slow_flow.token_bucket.period.nanosec</name>
<value>10000000</value>
</element>
</value>
</property>
</domain_participant_qos>
<datawriter_qos>
<publish_mode>
<flow_controller_name>dds.flow_controller.token_bucket.slow_flow</flow_controller_name>
</publish_mode>
</datawriter_qos>
</qos_profile>
<!-- Sets the Participant properties to enable auto_throttle and
turbo_mode to true.
Modified QoS Parameters:
participant_qos.property => dds.domain_participant.auto_throttle
datawriter_qos.property => dds.data_writer.auto_throttle.enable
datawriter_qos.property => dds.data_writer.enable_turbo_mode
The domain_participant.auto_throttle configures the DomainParticipant
to gather internal measurements (during DomainParticipant creation) that
are required for the Auto Throttle feature. This allows DataWriters
belonging to this DomainParticipant to use the Auto Throttle feature.
The turbo_mode adjusts the batch max_data_bytes based on how frequently
the DataWriter writes data.
Data_writer.auto_throttle enables automatic throttling in the DataWriter
so it can automatically adjust the writing rate and the send window size;
this minimizes the need for repairing DDS samples and improves latency.
-->
<qos_profile name="Feature.AutoTuning.Enable">
<?rti-qos_snippet?>
<domain_participant_qos>
<property>
<value>
<element>
<name>dds.domain_participant.auto_throttle.enable</name>
<value>true</value>
</element>
</value>
</property>
</domain_participant_qos>
<datawriter_qos>
<batch>
<enable>false</enable>
</batch>
<property>
<value>
<element>
<name>dds.data_writer.enable_turbo_mode</name>
<value>true</value>
</element>
<element>
<name>dds.data_writer.auto_throttle.enable</name>
<value>true</value>
</element>
</value>
</property>
</datawriter_qos>
</qos_profile>
<!-- QoS Snippet to enable the use of the RTI Monitoring Library.
To enable the use of RTI Monitoring Library apply this QoS Snippet to the
QoS Profile used to create your DomainParticipant. For example:
<qos_profile name="MyProfile">
<base_name>
<element>BuiltinQosLib::Feature.Monitoring.Enable</element>
</base_name>
</qos_profile>
-->
<qos_profile name="Feature.Monitoring.Enable">
<?rti-qos_snippet?>
<domain_participant_qos>
<property>
<value>
<!-- Monitoring can be enabled via XML with dynamic linking. If you
have a C or C++ application that is statically linked, please
refer to the RTI Monitoring chapter of the RTI Core Libraries
User's Manual for instructions on how to enable monitoring.-->
<element>
<name>rti.monitor.library</name>
<value>rtimonitoring</value>
</element>
<element>
<name>rti.monitor.create_function</name>
<value>RTIDefaultMonitor_create</value>
</element>
</value>
</property>
</domain_participant_qos>
</qos_profile>
<!-- QoS Snippet to enable the use of RTI Monitoring Library 2.0 with
a dedicated DomainParticipant publishing telemetry data from your
application in domain ID 2. All metrics are enabled for all resources
in this profile.
To enable the use of RTI Monitoring Library 2.0, apply this QoS Snippet
to the QoS Profile used to create your DomainParticipantFactory.
For example:
<qos_profile name="MyProfile">
<base_name>
<element>BuiltinQosSnippetLib::Feature.Monitoring2.Enable</element>
</base_name>
</qos_profile>
-->
<qos_profile name="Feature.Monitoring2.Enable">
<?rti-qos_snippet?>
<participant_factory_qos>
<monitoring>
<enable>true</enable>
</monitoring>
</participant_factory_qos>
</qos_profile>
<!-- QoS Snippet to enable security using the Builtin Security Plugins.
To enable the use of the Builtin DDS Security Library apply this QoS Snippet to the
QoS Profile used to create your DomainParticipant. For example:
<qos_profile name="MyProfile">
<base_name>
<element>BuiltinQosLib::Feature.Security.Enable</element>
</base_name>
</qos_profile>
-->
<qos_profile name="Feature.Security.Enable">
<?rti-qos_snippet?>
<domain_participant_qos>
<property>
<value>
<element>
<name>com.rti.serv.load_plugin</name>
<value>com.rti.serv.secure</value>
</element>
<!-- Security can be enabled via XML with dynamic linking. If you
have a C or C++ application that is statically linked, please
refer to the Hello_security examples for instructions on how
to enable security.-->
<element>
<name>com.rti.serv.secure.library</name>
<value>nddssecurity</value>
</element>
<element>
<name>com.rti.serv.secure.create_function</name>
<value>RTI_Security_PluginSuite_create</value>
</element>
</value>
</property>
</domain_participant_qos>
</qos_profile>
<!-- QoS Snippet to enable pre-shared key protection using the Lightweight
Security Plugins.
To enable the use of the Builtin DDS Lightweight Security Library apply
this QoS Snippet to the QoS Profile used to create your
DomainParticipant. For example:
<qos_profile name="MyProfile">
<base_name>
<element>BuiltinQosLib::Feature.LightweightSecurity.Enable</element>
</base_name>
</qos_profile>
-->
<qos_profile name="Feature.LightweightSecurity.Enable">
<?rti-qos_snippet?>
<domain_participant_qos>
<property>
<value>
<element>
<name>com.rti.serv.load_plugin</name>
<value>com.rti.serv.secure</value>
</element>
<!-- Lightweight Security can be enabled via XML with dynamic linking.
If you have a C or C++ application that is statically linked, please
refer to the Hello_lightweight_security examples for instructions on how
to enable security.-->
<element>
<name>com.rti.serv.secure.library</name>
<value>nddslightweightsecurity</value>
</element>
<element>
<name>com.rti.serv.secure.create_function</name>
<value>RTI_SecurityLightweight_PluginSuite_create</value>
</element>
</value>
</property>
</domain_participant_qos>
</qos_profile>
<!-- QoS Snippet to enable Topic Query.
To enable the use of the RTI Connext DDS Topic Query feature apply this QoS Snippet to the
QoS Profile used to create your DataWriter. For example:
<qos_profile name="MyProfile">
<base_name>
<element>BuiltinQosLib::Feature.TopicQuery.Enable</element>
</base_name>
</qos_profile>
For more information on Topic Query see the 'Topic Queries' chapter
of the User's Manual.
-->
<qos_profile name="Feature.TopicQuery.Enable">
<?rti-qos_snippet?>
<datawriter_qos>
<topic_query_dispatch>
<enable>true</enable>
<publication_period>
<sec>1</sec>
<nanosec>0</nanosec>
</publication_period>
<samples_per_period>100</samples_per_period>
</topic_query_dispatch>
</datawriter_qos>
</qos_profile>
<!-- QoS Snippets to enable TypeObject V1 propagation.
To enable TypeObject V1 propagation apply this QoS Snippet to
the QoS Profile used to create your DomainParticipant.
For example:
<qos_profile name="MyProfile">
<base_name>
<element>BuiltinQosLib::Feature.TypeSupport.V1.Enable</element>
</base_name>
</qos_profile>
-->
<qos_profile name="Feature.TypeSupport.V1.Enable">
<?rti-qos_snippet?>
<domain_participant_qos>
<resource_limits>
<type_object_max_serialized_length>8192</type_object_max_serialized_length>
</resource_limits>
</domain_participant_qos>
</qos_profile>
<!-- QoS Snippets to disable TypeObject V1 propagation.
To disable TypeObject V1 propagation apply this QoS Snippet to
the QoS Profile used to create your DomainParticipant.
For example:
<qos_profile name="MyProfile">
<base_name>
<element>BuiltinQosLib::Feature.TypeSupport.V1.Disable</element>
</base_name>
</qos_profile>
-->
<qos_profile name="Feature.TypeSupport.V1.Disable">
<?rti-qos_snippet?>
<domain_participant_qos>
<resource_limits>
<type_object_max_serialized_length>LENGTH_AUTO</type_object_max_serialized_length>
</resource_limits>
</domain_participant_qos>
</qos_profile>
<!-- QoS Snippets to enable TypeObject V2 propagation.
To enable TypeObject V2 propagation apply this QoS Snippet to
the QoS Profile used to create your DomainParticipant.
For example:
<qos_profile name="MyProfile">
<base_name>
<element>BuiltinQosLib::Feature.TypeSupport.V2.Enable</element>
</base_name>
</qos_profile>
-->
<qos_profile name="Feature.TypeSupport.V2.Enable">
<?rti-qos_snippet?>
<domain_participant_qos>
<discovery_config>
<enabled_builtin_channels>
SERVICE_REQUEST_CHANNEL | TYPE_LOOKUP_SERVICE_CHANNEL
</enabled_builtin_channels>
</discovery_config>
</domain_participant_qos>
</qos_profile>
<!-- QoS Snippets to disable TypeObject V2 propagation.
To disable TypeObject V2 propagation apply this QoS Snippet to
the QoS Profile used to create your DomainParticipant.
For example:
<qos_profile name="MyProfile">
<base_name>
<element>BuiltinQosLib::Feature.TypeSupport.V2.Disable</element>
</base_name>
</qos_profile>
-->
<qos_profile name="Feature.TypeSupport.V2.Disable">
<?rti-qos_snippet?>
<domain_participant_qos>
<discovery_config>
<enabled_builtin_channels>SERVICE_REQUEST_CHANNEL</enabled_builtin_channels>
</discovery_config>
</domain_participant_qos>
</qos_profile>
<!-- Configures a DDS Entity to use TCP. These four QoS Snippets:
Transport.TCP.LAN.Client
Transport.TCP.WAN.Symmetric.Client
Transport.TCP.WAN.Asymmetric.Client
Transport.TCP.WAN.Asymmetric.Server
These QoS Snippets configure TCP in different ways, for a LAN, for a
symmetric WAN, and also the client and the server of an asymmetric WAN.
Modified QoS Parameters:
participant_qos.property => dds.transport_builtin
participant_qos.property => <TCP_plugin_name>
<TCP_plugin_name> is the value of the property dds.transport.load_plugins
-->
<!-- The following QoS Snippet configures a TCP LAN Client over DDS. It sets
all the mandatory properties; however the final QoS Profile requires
additional configuration..
The values of the initial_peers and the property
dds.transport.TCPv4.tcp1.server_bind_port are incorrect (just sample
strings). Therefore, the following must be modified:
initial_peers: should point to the remote client IP and port.
server_bind_port: is the port this application will be using.
This modification should be done in the QoS Profile that will be used
to create the DDS Entity. These new values will overwrite the current
invalid values.
-->
<qos_profile name="Transport.TCP.LAN.Client">
<?rti-qos_snippet?>
<domain_participant_qos>
<!-- Disable built-in transports -->
<transport_builtin>
<mask>MASK_NONE</mask>
</transport_builtin>
<discovery>
<initial_peers>
<!-- The initial peers have to point to the other clients parameters -->
<element>tcpv4_lan://public_ip_address_remote_client:port_number_remote_client</element>
</initial_peers>
</discovery>
<property>
<value>
<element>
<name>dds.transport.load_plugins</name>
<value>dds.transport.TCPv4.tcp1</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.library</name>
<value>nddstransporttcp</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.create_function</name>
<value>NDDS_Transport_TCPv4_create</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.parent.classid</name>
<value>NDDS_TRANSPORT_CLASSID_TCPV4_LAN</value>
</element>
<!-- Change 'port_number' with the corresponding port where
the application will be listening from.
-->
<element>
<name>dds.transport.TCPv4.tcp1.server_bind_port</name>
<value>my_port_number</value>
</element>
</value>
</property>
</domain_participant_qos>
</qos_profile>
<!-- The following QoS Snippet configures a symmetric WAN TCP Client over DDS. It
sets all the mandatory properties; however the final QoS Profile requires
additional configuration.
The values of the properties dds.transport.TCPv4.tcp1.public_address
and dds.transport.TCPv4.tcp1.server_bind_port are incorrect (just sample
strings). Also the initial_peers information is not correct. Therefore,
the following must be modified:
initial_peers: should point to the remote client IP and port.
public_address: public IP address where this application can
be reached.
server_bind_port: port this application will be using.
This modification should be done in the QoS Profile that will be used to
create the DDS Entity. These new values will overwrite the current
invalid values.
-->
<qos_profile name="Transport.TCP.WAN.Symmetric.Client">
<?rti-qos_snippet?>
<domain_participant_qos>
<transport_builtin>
<mask>MASK_NONE</mask>
</transport_builtin>
<discovery>
<initial_peers>
<!-- The initial peers have to point to the remote client parameters -->
<element>tcpv4_wan://public_ip_address_remote_client:port_number_remote_client</element>
</initial_peers>
</discovery>
<property>
<value>
<element>
<name>dds.transport.load_plugins</name>
<value>dds.transport.TCPv4.tcp1</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.library</name>
<value>nddstransporttcp</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.create_function</name>
<value>NDDS_Transport_TCPv4_create</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.parent.classid</name>
<value>NDDS_TRANSPORT_CLASSID_TCPV4_WAN</value>
</element>
<!-- The following properties (public_address and server_bind_port)
should configure the local machine public IP and port.
-->
<element>
<name>dds.transport.TCPv4.tcp1.public_address</name>
<value>my_public_ip_address:my_port_number</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.server_bind_port</name>
<value>my_port_number</value>
</element>
</value>
</property>
</domain_participant_qos>
</qos_profile>
<!-- The following QoS Snippet configures an asymmetric WAN TCP Server over DDS. It
sets all the mandatory properties; however the final QoS Profile requires
additional configuration.
The values of the properties dds.transport.TCPv4.tcp1.public_address
and dds.transport.TCPv4.tcp1.server_bind_port are incorrect (just sample
strings). Therefore, they must be modified to the corresponding
public_address and port_number. This modification should be done
in the QoS Profile that will be used to create the DDS Entity.
These new values will overwrite the current invalid values.
-->
<qos_profile name="Transport.TCP.WAN.Asymmetric.Server">
<?rti-qos_snippet?>
<!--TCP Server Configuration-->
<domain_participant_qos>
<!-- Disable built-in transports -->
<transport_builtin>
<mask>MASK_NONE</mask>
</transport_builtin>
<property>
<value>
<element>
<name>dds.transport.load_plugins</name>
<value>dds.transport.TCPv4.tcp1</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.library</name>
<value>nddstransporttcp</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.create_function</name>
<value>NDDS_Transport_TCPv4_create</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.parent.classid</name>
<value>NDDS_TRANSPORT_CLASSID_TCPV4_WAN</value>
</element>
<!--
Change 'public_ip_address' and 'port_number' to the
corresponding public IP that will be used.
-->
<element>
<name>dds.transport.TCPv4.tcp1.public_address</name>
<value>my_public_ip_address:my_port_number</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.server_bind_port</name>
<value>my_port_number</value>
</element>
</value>
</property>
</domain_participant_qos>
</qos_profile>
<!-- The following QoS Snippet configures an asymmetric WAN TCP Client over DDS.
It sets all the mandatory properties; however the final QoS Profile requires
additional configuration.
The values of discovery.initial_peers and public_ip have to match the values
set on the Server side (Transport.TCP.WAN.Asymmetric.Server).
This modification should be done in the QoS Profile that will be used to
create the DDS Entity. This new value will overwrite the current invalid value.
-->
<qos_profile name="Transport.TCP.WAN.Asymmetric.Client">
<?rti-qos_snippet?>
<domain_participant_qos>
<transport_builtin>
<mask>MASK_NONE</mask>
</transport_builtin>
<discovery>
<initial_peers>
<!-- The initial peers have to point to the server parameters -->
<element>tcpv4_wan://public_ip_address:port_number</element>
</initial_peers>
</discovery>
<property>
<value>
<element>
<name>dds.transport.load_plugins</name>
<value>dds.transport.TCPv4.tcp1</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.library</name>
<value>nddstransporttcp</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.create_function</name>
<value>NDDS_Transport_TCPv4_create</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.parent.classid</name>
<value>NDDS_TRANSPORT_CLASSID_TCPV4_WAN</value>
</element>
<!--
The following properties (public_address and server_bind_port)
should be set to 0 which indicates that this is the client.
-->
<element>
<name>dds.transport.TCPv4.tcp1.public_address</name>
<value>0.0.0.0</value>
</element>
<element>
<name>dds.transport.TCPv4.tcp1.server_bind_port</name>
<value>0</value>
</element>
</value>
</property>
</domain_participant_qos>
</qos_profile>
<!-- Descreases the UDP message size max to be compatible with Connext
DDS Micro version 2.x releases.
Modified QoS Parameters:
domain_participant_qos.transport_builtin
Connext DDS Micro has a message size max of 8192. If Connext DDS Pro
leaves its message size max to the default then any messages larger
than 8192 bytes would be dropped by Connext DDS Micro.
-->
<qos_profile name="Transport.UDP.Micro2CompatibleMessageSizeMax">
<?rti-qos_snippet?>
<domain_participant_qos>
<transport_builtin>
<udpv4>
<message_size_max>8192</message_size_max>
</udpv4>
</transport_builtin>
</domain_participant_qos>
</qos_profile>
<!-- QoS Snippet that configures RTI Connext and the UDP built-in
transports (UDPv4, UDPv6) to avoid IP fragmentation. The default
UDPv4_WAN message_size_max is already set to 1400 because it is so
common to run into IP fragmentation issues in a WAN environment.
For WAN communications and, in general, for communications in
third-party networks, it is not a good idea to rely on IP
fragmentation. IP fragmentation causes significant issues in UDP,
where there is no integrated support for a path MTU (maximum
transmission unit) discovery protocol as there is in TCP.
This snippet provides a way to avoid IP fragmentation in
Connext applications using the built-in UDP transports. Instead,
Connext will be responsible for fragmentation, which is done at the
RTPS level.
This configuration changes the transport MTU (message_size_max) to be
1400 bytes. Notice that this change will affect other transports such
as SHMEM since Connext chooses the minimum transport MTU across all
enabled transports to determine the maximum size of outgoing RTPS
messages.
-->
<qos_profile name="Transport.UDP.AvoidIPFragmentation">
<?rti-qos_snippet?>
<domain_participant_qos>
<transport_builtin>
<udpv4>
<message_size_max>1400</message_size_max>
</udpv4>
<udpv6>
<message_size_max>1400</message_size_max>
</udpv6>
</transport_builtin>
</domain_participant_qos>
</qos_profile>
<!-- QoS Snippet that enables the RTI Real-Time WAN Transport (UDPv4_WAN).
The snippet disables all the other built-in transports.
-->
<qos_profile name="Transport.UDP.WAN">
<?rti-qos_snippet?>
<domain_participant_qos>
<transport_builtin>
<mask>UDPv4_WAN</mask>
</transport_builtin>
</domain_participant_qos>
</qos_profile>
<!-- QoS Snippet that sets the DataReaders' and DataWriters' LIVELINESS
QoS Policy to MANUAL_BY_TOPIC to be compatible with RTI Connext DDS Micro 2.4.3.
It also disables the built-in shared memory transport.
Modified QoS Parameters:
datareader_qos.liveliness
datawriter_qos.liveliness
participant_qos.transport_builtin
RTI Connext DDS Micro versions 2.4.3 and earlier only supported
MANUAL_BY_TOPIC LivelinessQosPolicy kind. In order to be compatible
with RTI Connext DDS, the DataReader and DataWriter must have their
liveliness kind changed to this value because the default kind in
RTI Connext DDS is AUTOMATIC.
-->
<qos_profile name="Compatibility.ConnextMicro.Version243">
<?rti-qos_snippet?>
<datareader_qos>
<liveliness>
<kind>MANUAL_BY_TOPIC_LIVELINESS_QOS</kind>
</liveliness>
</datareader_qos>
<datawriter_qos>
<liveliness>
<kind>MANUAL_BY_TOPIC_LIVELINESS_QOS</kind>
</liveliness>
</datawriter_qos>
<domain_participant_qos>
<!-- Disable the built-in shared memory transport -->
<transport_builtin>
<mask>UDPv4</mask>
</transport_builtin>
</domain_participant_qos>
</qos_profile>
<!-- This QoS Snippet configures RTI Connext DDS to interoperate with
other DDS vendors.
-->
<qos_profile name="Compatibility.OtherDDSVendor.Enable">
<?rti-qos_snippet?>
<domain_participant_qos>
<discovery_config>
<!-- Don't send the RTI-proprietary domain announcement message -->
<default_domain_announcement_period>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</default_domain_announcement_period>
<!-- Disable TypeObject compression (TypeObjectLb). The compressed
format is RTI-proprietary and not understood by other DDS
vendors. The sentinel value -1 disables compression. -->
<endpoint_type_object_lb_serialization_threshold>-1</endpoint_type_object_lb_serialization_threshold>
<!-- Enable the TypeLookup Service channel for standard TypeObject
V2 (DDS-XTypes 1.3) exchange. -->
<enabled_builtin_channels>
SERVICE_REQUEST_CHANNEL | TYPE_LOOKUP_SERVICE_CHANNEL
</enabled_builtin_channels>
</discovery_config>
<resource_limits>
<!-- Disable TypeObject V1 (DDS-XTypes 1.1) serialization in
favor of the TypeLookup Service (TypeObject V2). -->
<type_object_max_serialized_length>LENGTH_AUTO</type_object_max_serialized_length>
</resource_limits>
</domain_participant_qos>
</qos_profile>
<!-- This QoS Snippet configures RTI Connext DDS 5.2.0 and above to interoperate with
RTI Connext DDS 5.1.0 and below for UDPv6 and SHMEM transports.
-->
<qos_profile name="Compatibility.510Transport.Enable">
<?rti-qos_snippet?>
<domain_participant_qos>
<property>
<value>
<element>
<name>dds.transport.use_510_compatible_locator_kinds</name>
<value>true</value>
<propagate>true</propagate>
</element>
</value>
</property>
</domain_participant_qos>
</qos_profile>
</qos_library>
<!-- QoS Library -->
<qos_library name="BuiltinQosLib">
<!-- The QoS default values for version 5.0.0 -->
<qos_profile name="Baseline.5.0.0" base_name="Baseline.Root"/>
<!-- The QoS default values for version 5.1.0 -->
<qos_profile name="Baseline.5.1.0" base_name="Baseline.5.0.0">
<domain_participant_qos>
<discovery_config>
<default_domain_announcement_period>
<sec>30</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</default_domain_announcement_period>
<ignore_default_domain_announcements>true</ignore_default_domain_announcements>
</discovery_config>
<property>
<value>
<element>
<name>dds.transport.UDPv4.builtin.parent.message_size_max</name>
<value>65507</value>
<propagate>false</propagate>
</element>
<element>
<name>dds.transport.UDPv4.builtin.send_socket_buffer_size</name>
<value>131072</value>
<propagate>false</propagate>
</element>
<element>
<name>dds.transport.UDPv4.builtin.recv_socket_buffer_size</name>
<value>131072</value>
<propagate>false</propagate>
</element>
<!-- public_address is a new property necessary to support
communication over WAN that involves Network Address
Translation (NAT). Its default value is NULL
<element>
<name>dds.transport.UDPv4.builtin.public_address</name>
<value/>
</element> -->
<element>
<name>dds.transport.UDPv6.builtin.parent.message_size_max</name>
<value>65507</value>
<propagate>false</propagate>
</element>
<element>
<name>dds.transport.UDPv6.builtin.send_socket_buffer_size</name>
<value>131072</value>
<propagate>false</propagate>
</element>
<element>
<name>dds.transport.UDPv6.builtin.recv_socket_buffer_size</name>
<value>131072</value>
<propagate>false</propagate>
</element>
<element>
<name>dds.transport.shmem.builtin.parent.message_size_max</name>
<value>65536</value>
<propagate>false</propagate>
</element>
<element>
<name>dds.transport.shmem.builtin.receive_buffer_size</name>
<value>1048576</value>
<propagate>false</propagate>
</element>
<element>
<name>dds.transport.shmem.builtin.received_message_count_max</name>
<value>64</value>
<propagate>false</propagate>
</element>
</value>
</property>
<participant_name>
<name xsi:nil="true"/>
<role_name xsi:nil="true"/>
</participant_name>
<receiver_pool>
<buffer_size>LENGTH_AUTO</buffer_size>
</receiver_pool>
<resource_limits>
<participant_property_string_max_length>2048</participant_property_string_max_length>
<transport_info_list_max_length>12</transport_info_list_max_length>
</resource_limits>
<type_support>
<cdr_padding_kind>AUTO_CDR_PADDING</cdr_padding_kind>
</type_support>
</domain_participant_qos>
<publisher_qos>
<publisher_name>
<name xsi:nil="true"/>
<role_name xsi:nil="true"/>
</publisher_name>
</publisher_qos>
<subscriber_qos>
<subscriber_name>
<name xsi:nil="true"/>
<role_name xsi:nil="true"/>
</subscriber_name>
</subscriber_qos>
<datawriter_qos>
<type_support>
<cdr_padding_kind>AUTO_CDR_PADDING</cdr_padding_kind>
</type_support>
</datawriter_qos>
<datareader_qos>
<type_support>
<cdr_padding_kind>AUTO_CDR_PADDING</cdr_padding_kind>
</type_support>
</datareader_qos>
</qos_profile>
<!-- The QoS default values for version 5.2.0 -->
<qos_profile name="Baseline.5.2.0" base_name="Baseline.5.1.0">
<domain_participant_qos>
<discovery>
<enable_endpoint_discovery>true</enable_endpoint_discovery>
</discovery>
<discovery_config>
<participant_reader_resource_limits>
<dynamically_allocate_fragmented_samples>true</dynamically_allocate_fragmented_samples>
<max_fragments_per_sample>LENGTH_UNLIMITED</max_fragments_per_sample>
</participant_reader_resource_limits>
<publication_reader_resource_limits>
<dynamically_allocate_fragmented_samples>true</dynamically_allocate_fragmented_samples>
<max_fragments_per_sample>LENGTH_UNLIMITED</max_fragments_per_sample>
</publication_reader_resource_limits>
<subscription_reader_resource_limits>
<dynamically_allocate_fragmented_samples>true</dynamically_allocate_fragmented_samples>
<max_fragments_per_sample>LENGTH_UNLIMITED</max_fragments_per_sample>
</subscription_reader_resource_limits>
<publication_writer_data_lifecycle>
<autopurge_unregistered_instances_delay>
<sec>0</sec>
<nanosec>0</nanosec>
</autopurge_unregistered_instances_delay>
<autopurge_disposed_instances_delay>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</autopurge_disposed_instances_delay>
</publication_writer_data_lifecycle>
<subscription_writer_data_lifecycle>
<autopurge_unregistered_instances_delay>
<sec>0</sec>
<nanosec>0</nanosec>
</autopurge_unregistered_instances_delay>
<autopurge_disposed_instances_delay>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</autopurge_disposed_instances_delay>
</subscription_writer_data_lifecycle>
<participant_message_reader_reliability_kind>BEST_EFFORT_RELIABILITY_QOS</participant_message_reader_reliability_kind>
</discovery_config>
<resource_limits>
<ignored_entity_replacement_kind>NO_REPLACEMENT_IGNORED_ENTITY_REPLACEMENT</ignored_entity_replacement_kind>
</resource_limits>
</domain_participant_qos>
<datawriter_qos>
<liveliness>
<assertions_per_lease_duration>3</assertions_per_lease_duration>
</liveliness>
<writer_data_lifecycle>
<autopurge_disposed_instances_delay>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</autopurge_disposed_instances_delay>
</writer_data_lifecycle>
<service>
<kind>NO_SERVICE_QOS</kind>
</service>
<protocol>
<propagate_app_ack_with_no_response>true</propagate_app_ack_with_no_response>
</protocol>
</datawriter_qos>
<datareader_qos>
<reader_data_lifecycle>
<autopurge_disposed_instances_delay>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</autopurge_disposed_instances_delay>
</reader_data_lifecycle>
<reader_resource_limits>
<dynamically_allocate_fragmented_samples>true</dynamically_allocate_fragmented_samples>
<max_fragments_per_sample>LENGTH_UNLIMITED</max_fragments_per_sample>
<keep_minimum_state_for_instances>true</keep_minimum_state_for_instances>
</reader_resource_limits>
<service>
<kind>NO_SERVICE_QOS</kind>
</service>
<protocol>
<propagate_unregister_of_disposed_instances>false</propagate_unregister_of_disposed_instances>
</protocol>
<transport_priority>
<value>0</value>
</transport_priority>
</datareader_qos>
</qos_profile>
<!-- The QoS default values for version 5.3.0 -->
<qos_profile name="Baseline.5.3.0" base_name="Baseline.5.2.0">
<!-- Because of the order in which the participant factory's QoS values
are loaded, they are commented out here. The following are the new
fields and default values added to the logging policy as of 5.3.0.
Note that the default output_file_suffix is that there is no file
suffix on the output files -->
<!-- <participant_factory_qos>
<logging>
<output_file_suffix/>
<max_bytes_per_file>LENGTH_UNLIMITED</max_bytes_per_file>
<max_files>LENGTH_UNLIMITED</max_files>
</logging>
</participant_factory_qos> -->
<domain_participant_qos>
<resource_limits>
<max_gather_destinations>16</max_gather_destinations>
<participant_property_string_max_length>
4096
</participant_property_string_max_length>
<remote_topic_query_allocation>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
<incremental_count>-1</incremental_count>
</remote_topic_query_allocation>
<remote_topic_query_hash_buckets>1</remote_topic_query_hash_buckets>
</resource_limits>
<discovery_config>
<locator_reachability_assert_period>
<sec>20</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</locator_reachability_assert_period>
<locator_reachability_lease_duration>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</locator_reachability_lease_duration>
<locator_reachability_change_detection_period>
<sec>60</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</locator_reachability_change_detection_period>
<service_request_writer_publish_mode>
<kind>SYNCHRONOUS_PUBLISH_MODE_QOS</kind>
<flow_controller_name>DEFAULT_FLOW_CONTROLLER_NAME</flow_controller_name>
<priority>PUBLICATION_PRIORITY_UNDEFINED</priority>
</service_request_writer_publish_mode>
<service_request_writer_data_lifecycle>
<autodispose_unregistered_instances>true</autodispose_unregistered_instances>
<autopurge_unregistered_instances_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</autopurge_unregistered_instances_delay>
<autopurge_disposed_instances_delay>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</autopurge_disposed_instances_delay>
</service_request_writer_data_lifecycle>
<service_request_writer>
<low_watermark>0</low_watermark>
<high_watermark>1</high_watermark>
<min_send_window_size>LENGTH_UNLIMITED</min_send_window_size>
<max_send_window_size>LENGTH_UNLIMITED</max_send_window_size>
<send_window_update_period>
<sec>3</sec>
<nanosec>0</nanosec>
</send_window_update_period>
<send_window_increase_factor>105</send_window_increase_factor>
<send_window_decrease_factor>50</send_window_decrease_factor>
<heartbeat_period>
<sec>3</sec>
<nanosec>0</nanosec>
</heartbeat_period>
<fast_heartbeat_period>
<sec>3</sec>
<nanosec>0</nanosec>
</fast_heartbeat_period>
<late_joiner_heartbeat_period>
<sec>3</sec>
<nanosec>0</nanosec>
</late_joiner_heartbeat_period>
<virtual_heartbeat_period>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</virtual_heartbeat_period>
<samples_per_virtual_heartbeat>LENGTH_UNLIMITED</samples_per_virtual_heartbeat>
<max_heartbeat_retries>10</max_heartbeat_retries>
<inactivate_nonprogressing_readers>false</inactivate_nonprogressing_readers>
<heartbeats_per_max_samples>8</heartbeats_per_max_samples>
<min_nack_response_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</min_nack_response_delay>
<max_nack_response_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</max_nack_response_delay>
<nack_suppression_duration>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</nack_suppression_duration>
<disable_positive_acks_min_sample_keep_duration>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>1000000</nanosec>
</disable_positive_acks_min_sample_keep_duration>
<disable_positive_acks_max_sample_keep_duration>
<sec>1</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</disable_positive_acks_max_sample_keep_duration>
<disable_positive_acks_enable_adaptive_sample_keep_duration>
true
</disable_positive_acks_enable_adaptive_sample_keep_duration>
<disable_positive_acks_decrease_sample_keep_duration_factor>
95
</disable_positive_acks_decrease_sample_keep_duration_factor>
<disable_positive_acks_increase_sample_keep_duration_factor>
150
</disable_positive_acks_increase_sample_keep_duration_factor>
<max_bytes_per_nack_response>131072</max_bytes_per_nack_response>
<enable_multicast_periodic_heartbeat>false</enable_multicast_periodic_heartbeat>
<multicast_resend_threshold>2</multicast_resend_threshold>
<disable_repair_piggyback_heartbeat>false</disable_repair_piggyback_heartbeat>
</service_request_writer>
<service_request_reader>
<min_heartbeat_response_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</min_heartbeat_response_delay>
<max_heartbeat_response_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</max_heartbeat_response_delay>
<heartbeat_suppression_duration>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>62500000</nanosec>
</heartbeat_suppression_duration>
<nack_period>
<sec>5</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</nack_period>
<round_trip_time>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</round_trip_time>
<app_ack_period>
<sec>5</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</app_ack_period>
<min_app_ack_response_keep_duration>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</min_app_ack_response_keep_duration>
<samples_per_app_ack>1</samples_per_app_ack>
<receive_window_size>256</receive_window_size>
</service_request_reader>
</discovery_config>
<wire_protocol>
<compute_crc>false</compute_crc>
<check_crc>false</check_crc>
</wire_protocol>
</domain_participant_qos>
<publisher_qos>
<asynchronous_publisher>
<disable_topic_query_publication>false</disable_topic_query_publication>
<topic_query_publication_thread>
<mask>MASK_DEFAULT</mask>
<priority>THREAD_PRIORITY_DEFAULT</priority>
<stack_size>THREAD_STACK_SIZE_DEFAULT</stack_size>
</topic_query_publication_thread>
</asynchronous_publisher>
</publisher_qos>
<topic_qos>
<destination_order>
<scope>INSTANCE_SCOPE_DESTINATIONORDER_QOS</scope>
</destination_order>
</topic_qos>
<datareader_qos>
<reader_resource_limits>
<initial_topic_queries>1</initial_topic_queries>
<max_topic_queries>LENGTH_UNLIMITED</max_topic_queries>
</reader_resource_limits>
<destination_order>
<scope>INSTANCE_SCOPE_DESTINATIONORDER_QOS</scope>
</destination_order>
</datareader_qos>
<datawriter_qos>
<writer_resource_limits>
<initial_active_topic_queries>1</initial_active_topic_queries>
<max_active_topic_queries>LENGTH_UNLIMITED</max_active_topic_queries>
<max_remote_reader_filters>LENGTH_UNLIMITED</max_remote_reader_filters>
</writer_resource_limits>
<topic_query_dispatch>
<enable>false</enable>
<publication_period>
<sec>1</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</publication_period>
<samples_per_period>LENGTH_UNLIMITED</samples_per_period>
</topic_query_dispatch>
<destination_order>
<scope>INSTANCE_SCOPE_DESTINATIONORDER_QOS</scope>
</destination_order>
</datawriter_qos>
</qos_profile>
<!-- The QoS default values for version 6.0.0 -->
<qos_profile name="Baseline.6.0.0" base_name="Baseline.5.3.0">
<domain_participant_qos>
<!-- Setting rtps_auto_id_kind to RTPS_AUTO_ID_FROM_UUID set the
first two bytes of the GUIDs to the RTPS RTI vendorId -->
<wire_protocol>
<rtps_auto_id_kind>RTPS_AUTO_ID_FROM_UUID</rtps_auto_id_kind>
</wire_protocol>
<resource_limits>
<writer_data_tag_list_max_length>0</writer_data_tag_list_max_length>
<writer_data_tag_string_max_length>0</writer_data_tag_string_max_length>
<reader_data_tag_list_max_length>0</reader_data_tag_list_max_length>
<reader_data_tag_string_max_length>0</reader_data_tag_string_max_length>
<shmem_ref_transfer_mode_max_segments>500</shmem_ref_transfer_mode_max_segments>
<type_code_max_serialized_length>0</type_code_max_serialized_length>
<type_object_max_serialized_length>8192</type_object_max_serialized_length>
<serialized_type_object_dynamic_allocation_threshold>8192</serialized_type_object_dynamic_allocation_threshold>
</resource_limits>
<discovery_config>
<secure_volatile_writer_publish_mode>
<kind>SYNCHRONOUS_PUBLISH_MODE_QOS</kind>
<flow_controller_name>DEFAULT_FLOW_CONTROLLER_NAME</flow_controller_name>
<priority>PUBLICATION_PRIORITY_UNDEFINED</priority>
</secure_volatile_writer_publish_mode>
<endpoint_type_object_lb_serialization_threshold>0</endpoint_type_object_lb_serialization_threshold>
</discovery_config>
</domain_participant_qos>
<datareader_qos>
<type_consistency>
<kind>AUTO_TYPE_COERCION</kind>
<ignore_sequence_bounds>false</ignore_sequence_bounds>
<ignore_string_bounds>false</ignore_string_bounds>
<ignore_member_names>false</ignore_member_names>
<prevent_type_widening>false</prevent_type_widening>
<force_type_validation>false</force_type_validation>
<ignore_enum_literal_names>false</ignore_enum_literal_names>
</type_consistency>
<reader_resource_limits>
<max_app_ack_response_length>1</max_app_ack_response_length>
<shmem_ref_transfer_mode_attached_segment_allocation>
<initial_count>AUTO_COUNT</initial_count>
<max_count>AUTO_COUNT</max_count>
<incremental_count>AUTO_COUNT</incremental_count>
</shmem_ref_transfer_mode_attached_segment_allocation>
</reader_resource_limits>
<data_tags>
<tags/>
</data_tags>
<representation>
<value>
<element>AUTO_DATA_REPRESENTATION</element>
</value>
</representation>
</datareader_qos>
<datawriter_qos>
<writer_resource_limits>
<writer_loaned_sample_allocation>
<initial_count>AUTO_COUNT</initial_count>
<max_count>AUTO_COUNT</max_count>
<incremental_count>AUTO_COUNT</incremental_count>
</writer_loaned_sample_allocation>
<initialize_writer_loaned_sample>false</initialize_writer_loaned_sample>
</writer_resource_limits>
<transfer_mode>
<shmem_ref_settings>
<enable_data_consistency_check>true</enable_data_consistency_check>
</shmem_ref_settings>
</transfer_mode>
<data_tags>
<tags/>
</data_tags>
<representation>
<value>
<element>AUTO_DATA_REPRESENTATION</element>
</value>
</representation>
<protocol>
<initial_virtual_sequence_number>
<value>AUTO_SEQUENCE_NUMBER</value>
</initial_virtual_sequence_number>
</protocol>
</datawriter_qos>
<topic_qos>
<representation>
<value>
<element>AUTO_DATA_REPRESENTATION</element>
</value>
</representation>
</topic_qos>
</qos_profile>
<!-- The QoS default values for version 6.1.0 -->
<qos_profile name="Baseline.6.1.0" base_name="Baseline.6.0.0">
<subscriber_qos>
<presentation>
<drop_incomplete_coherent_set>true</drop_incomplete_coherent_set>
</presentation>
</subscriber_qos>
<datareader_qos>
<type_consistency>
<ignore_sequence_bounds>true</ignore_sequence_bounds>
<ignore_string_bounds>true</ignore_string_bounds>
</type_consistency>
<reader_resource_limits>
<instance_replacement>
<alive_instance_removal>NO_INSTANCE_REMOVAL</alive_instance_removal>
<disposed_instance_removal>EMPTY_INSTANCE_REMOVAL</disposed_instance_removal>
<no_writers_instance_removal>EMPTY_INSTANCE_REMOVAL</no_writers_instance_removal>
</instance_replacement>
</reader_resource_limits>
<representation>
<compression_settings>
<compression_ids>MASK_ALL</compression_ids>
</compression_settings>
</representation>
<reader_data_lifecycle>
<autopurge_nowriter_instances_delay>
<sec>0</sec>
<nanosec>0</nanosec>
</autopurge_nowriter_instances_delay>
</reader_data_lifecycle>
</datareader_qos>
<datawriter_qos>
<durability>
<writer_depth>AUTO_WRITER_DEPTH</writer_depth>
</durability>
<writer_data_lifecycle>
<autodispose_unregistered_instances>false</autodispose_unregistered_instances>
</writer_data_lifecycle>
<representation>
<compression_settings>
<compression_ids>MASK_NONE</compression_ids>
<writer_compression_level>BEST_COMPRESSION</writer_compression_level>
<writer_compression_threshold>8192</writer_compression_threshold>
</compression_settings>
</representation>
<protocol>
<rtps_reliable_writer>
<disable_repair_piggyback_heartbeat>false</disable_repair_piggyback_heartbeat>
</rtps_reliable_writer>
</protocol>
</datawriter_qos>
<topic_qos>
<representation>
<compression_settings>
<compression_ids>MASK_NONE</compression_ids>
<writer_compression_level>BEST_COMPRESSION</writer_compression_level>
<writer_compression_threshold>8192</writer_compression_threshold>
</compression_settings>
</representation>
</topic_qos>
<domain_participant_qos>
<discovery_config>
<dns_tracker_polling_period>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</dns_tracker_polling_period>
<secure_volatile_reader>
<min_heartbeat_response_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</min_heartbeat_response_delay>
<max_heartbeat_response_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</max_heartbeat_response_delay>
<heartbeat_suppression_duration>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>62500000</nanosec>
</heartbeat_suppression_duration>
<nack_period>
<sec>5</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</nack_period>
<round_trip_time>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</round_trip_time>
<app_ack_period>
<sec>5</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</app_ack_period>
<min_app_ack_response_keep_duration>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</min_app_ack_response_keep_duration>
<samples_per_app_ack>1</samples_per_app_ack>
<receive_window_size>256</receive_window_size>
</secure_volatile_reader>
<secure_volatile_writer>
<low_watermark>0</low_watermark>
<high_watermark>1</high_watermark>
<min_send_window_size>LENGTH_UNLIMITED</min_send_window_size>
<max_send_window_size>LENGTH_UNLIMITED</max_send_window_size>
<send_window_update_period>
<sec>1</sec>
<nanosec>0</nanosec>
</send_window_update_period>
<send_window_increase_factor>105</send_window_increase_factor>
<send_window_decrease_factor>50</send_window_decrease_factor>
<heartbeat_period>
<sec>1</sec>
<nanosec>0</nanosec>
</heartbeat_period>
<fast_heartbeat_period>
<sec>0</sec>
<nanosec>250000000</nanosec>
</fast_heartbeat_period>
<late_joiner_heartbeat_period>
<sec>1</sec>
<nanosec>0</nanosec>
</late_joiner_heartbeat_period>
<virtual_heartbeat_period>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</virtual_heartbeat_period>
<samples_per_virtual_heartbeat>LENGTH_UNLIMITED</samples_per_virtual_heartbeat>
<max_heartbeat_retries>LENGTH_UNLIMITED</max_heartbeat_retries>
<inactivate_nonprogressing_readers>false</inactivate_nonprogressing_readers>
<heartbeats_per_max_samples>1</heartbeats_per_max_samples>
<min_nack_response_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</min_nack_response_delay>
<max_nack_response_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</max_nack_response_delay>
<nack_suppression_duration>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</nack_suppression_duration>
<disable_positive_acks_min_sample_keep_duration>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>1000000</nanosec>
</disable_positive_acks_min_sample_keep_duration>
<disable_positive_acks_max_sample_keep_duration>
<sec>1</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</disable_positive_acks_max_sample_keep_duration>
<disable_positive_acks_enable_adaptive_sample_keep_duration>
true
</disable_positive_acks_enable_adaptive_sample_keep_duration>
<disable_positive_acks_decrease_sample_keep_duration_factor>
95
</disable_positive_acks_decrease_sample_keep_duration_factor>
<disable_positive_acks_increase_sample_keep_duration_factor>
150
</disable_positive_acks_increase_sample_keep_duration_factor>
<max_bytes_per_nack_response>9216</max_bytes_per_nack_response>
<enable_multicast_periodic_heartbeat>false</enable_multicast_periodic_heartbeat>
<multicast_resend_threshold>2</multicast_resend_threshold>
<disable_repair_piggyback_heartbeat>false</disable_repair_piggyback_heartbeat>
</secure_volatile_writer>
<publication_writer_data_lifecycle>
<autodispose_unregistered_instances>false</autodispose_unregistered_instances>
</publication_writer_data_lifecycle>
<subscription_writer_data_lifecycle>
<autodispose_unregistered_instances>false</autodispose_unregistered_instances>
</subscription_writer_data_lifecycle>
<service_request_writer_data_lifecycle>
<autodispose_unregistered_instances>false</autodispose_unregistered_instances>
</service_request_writer_data_lifecycle>
<publication_writer>
<disable_repair_piggyback_heartbeat>false</disable_repair_piggyback_heartbeat>
</publication_writer>
<subscription_writer>
<disable_repair_piggyback_heartbeat>false</disable_repair_piggyback_heartbeat>
</subscription_writer>
<participant_message_writer>
<disable_repair_piggyback_heartbeat>false</disable_repair_piggyback_heartbeat>
</participant_message_writer>
<service_request_writer>
<disable_repair_piggyback_heartbeat>false</disable_repair_piggyback_heartbeat>
</service_request_writer>
</discovery_config>
</domain_participant_qos>
</qos_profile>
<!-- The QoS default values for version 7.0.0 -->
<qos_profile name="Baseline.7.0.0" base_name="Baseline.6.1.0">
<domain_participant_qos>
<discovery_config>
<new_remote_participant_announcements>2</new_remote_participant_announcements>
<enabled_builtin_channels>SERVICE_REQUEST_CHANNEL</enabled_builtin_channels>
<min_initial_participant_announcement_period>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>10000000</nanosec>
</min_initial_participant_announcement_period>
<participant_announcement_period>
<sec>DURATION_AUTO_SEC</sec>
<nanosec>DURATION_AUTO_NSEC</nanosec>
</participant_announcement_period>
<participant_configuration_writer>
<low_watermark>0</low_watermark>
<high_watermark>1</high_watermark>
<heartbeat_period>
<sec>3</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</heartbeat_period>
<fast_heartbeat_period>
<sec>3</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</fast_heartbeat_period>
<late_joiner_heartbeat_period>
<sec>3</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</late_joiner_heartbeat_period>
<max_heartbeat_retries>10</max_heartbeat_retries>
<inactivate_nonprogressing_readers>false</inactivate_nonprogressing_readers>
<heartbeats_per_max_samples>8</heartbeats_per_max_samples>
<min_nack_response_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</min_nack_response_delay>
<max_nack_response_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</max_nack_response_delay>
<nack_suppression_duration>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</nack_suppression_duration>
<max_bytes_per_nack_response>131072</max_bytes_per_nack_response>
<disable_positive_acks_min_sample_keep_duration>
<sec>0</sec>
<nanosec>1000000</nanosec>
</disable_positive_acks_min_sample_keep_duration>
<disable_positive_acks_max_sample_keep_duration>
<sec>1</sec>
<nanosec>0</nanosec>
</disable_positive_acks_max_sample_keep_duration>
<disable_positive_acks_enable_adaptive_sample_keep_duration>
true
</disable_positive_acks_enable_adaptive_sample_keep_duration>
<disable_positive_acks_decrease_sample_keep_duration_factor>
95
</disable_positive_acks_decrease_sample_keep_duration_factor>
<disable_positive_acks_increase_sample_keep_duration_factor>
150
</disable_positive_acks_increase_sample_keep_duration_factor>
<min_send_window_size>LENGTH_UNLIMITED</min_send_window_size>
<max_send_window_size>LENGTH_UNLIMITED</max_send_window_size>
<send_window_update_period>
<sec>3</sec>
<nanosec>0</nanosec>
</send_window_update_period>
<send_window_increase_factor>105</send_window_increase_factor>
<send_window_decrease_factor>50</send_window_decrease_factor>
<virtual_heartbeat_period>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</virtual_heartbeat_period>
<samples_per_virtual_heartbeat>LENGTH_UNLIMITED</samples_per_virtual_heartbeat>
<enable_multicast_periodic_heartbeat>false</enable_multicast_periodic_heartbeat>
<multicast_resend_threshold>2</multicast_resend_threshold>
</participant_configuration_writer>
<participant_configuration_writer_data_lifecycle>
<autodispose_unregistered_instances>false</autodispose_unregistered_instances>
<autopurge_unregistered_instances_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</autopurge_unregistered_instances_delay>
<autopurge_disposed_instances_delay>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</autopurge_disposed_instances_delay>
</participant_configuration_writer_data_lifecycle>
<participant_configuration_writer_publish_mode>
<kind>SYNCHRONOUS_PUBLISH_MODE_QOS</kind>
<flow_controller_name>DEFAULT_FLOW_CONTROLLER_NAME</flow_controller_name>
<priority>PUBLICATION_PRIORITY_UNDEFINED</priority>
</participant_configuration_writer_publish_mode>
<participant_configuration_reader>
<min_heartbeat_response_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</min_heartbeat_response_delay>
<max_heartbeat_response_delay>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>DURATION_ZERO_NSEC</nanosec>
</max_heartbeat_response_delay>
<heartbeat_suppression_duration>
<sec>DURATION_ZERO_SEC</sec>
<nanosec>62500000</nanosec>
</heartbeat_suppression_duration>
<nack_period>
<sec>5</sec>
<nanosec>0</nanosec>
</nack_period>
<receive_window_size>256</receive_window_size>
<round_trip_time>
<sec>0</sec>
<nanosec>0</nanosec>
</round_trip_time>
</participant_configuration_reader>
<participant_configuration_reader_resource_limits>
<initial_samples>64</initial_samples>
<max_samples>LENGTH_UNLIMITED</max_samples>
<initial_infos>64</initial_infos>
<max_infos>LENGTH_UNLIMITED</max_infos>
<initial_outstanding_reads>2</initial_outstanding_reads>
<max_outstanding_reads>LENGTH_UNLIMITED</max_outstanding_reads>
<max_samples_per_read>1024</max_samples_per_read>
<disable_fragmentation_support>false</disable_fragmentation_support>
<max_fragmented_samples>1024</max_fragmented_samples>
<initial_fragmented_samples>4</initial_fragmented_samples>
<max_fragmented_samples_per_remote_writer>256</max_fragmented_samples_per_remote_writer>
</participant_configuration_reader_resource_limits>
</discovery_config>
<database>
<shutdown_cleanup_period>
<sec>0</sec>
<nanosec>10000000</nanosec>
</shutdown_cleanup_period>
</database>
</domain_participant_qos>
</qos_profile>
<!-- The QoS default values for version 7.1.0 -->
<qos_profile name="Baseline.7.1.0" base_name="Baseline.7.0.0">
<participant_factory_qos>
<monitoring>
<!-- From 7.1.0 until 7.6.0, the Monitoring Library was disabled
by default. From 7.7.0 onwards, it is enabled by default.
Because of that, the enable value cannot be specified in
the XML, otherwise, users' XML configurations inheriting
from our builtin qos profiles would have the Monitoring
Library disabled by default when they upgrade to 7.7.0.
<enable>false</enable>
-->
<!-- The factory default for application_name is NULL which cannot
be represented in XML. When the <application_name> tag is
not present, RTI Monitoring Library 2.0 will automatically
assign a name that is globally unique in a Connext system.
<application_name/>
-->
<distribution_settings>
<dedicated_participant>
<enable>true</enable>
<domain_id>2</domain_id>
<!-- The factory default is NULL and equivalent to
BuiltinQosLib::::Generic.Monitoring2. However,
NULL cannot be represented in XML.
<participant_qos_profile_name>
BuiltinQosLib::::Generic.Monitoring2
</participant_qos_profile_name>
-->
</dedicated_participant>
<!-- The factory default is NULL and equivalent to
BuiltinQosLib::::Generic.Monitoring2. However,
NULL cannot be represented in XML.
<publisher_qos_profile_name>
BuiltinQosLib::::Generic.Monitoring2
</publisher_qos_profile_name>
-->
<event_settings>
<concurrency_level>5</concurrency_level>
<!-- The factory default is NULL and equivalent to
BuiltinQosLib::::Generic.Monitoring2. However,
NULL cannot be represented in XML.
<datawriter_qos_profile_name>
BuiltinQosLib::::Generic.Monitoring2
</datawriter_qos_profile_name>
-->
<thread>
<mask>MASK_DEFAULT</mask>
<priority>THREAD_PRIORITY_DEFAULT</priority>
<stack_size>THREAD_STACK_SIZE_DEFAULT</stack_size>
</thread>
<publication_period>
<sec>1</sec>
<nanosec>0</nanosec>
</publication_period>
</event_settings>
<periodic_settings>
<!-- The factory default is NULL and equivalent to
BuiltinQosLib::::Generic.Monitoring2. However,
NULL cannot be represented in XML.
<datawriter_qos_profile_name>
BuiltinQosLib::::Generic.Monitoring2
</datawriter_qos_profile_name>
-->
<thread>
<mask>MASK_DEFAULT</mask>
<priority>THREAD_PRIORITY_DEFAULT</priority>
<stack_size>THREAD_STACK_SIZE_DEFAULT</stack_size>
</thread>
<polling_period>
<sec>5</sec>
<nanosec>0</nanosec>
</polling_period>
</periodic_settings>
<logging_settings>
<concurrency_level>5</concurrency_level>
<max_historical_logs>128</max_historical_logs>
<!-- The factory default is NULL and equivalent to
BuiltinQosLib::::Generic.Monitoring2. However,
NULL cannot be represented in XML.
<datawriter_qos_profile_name>
BuiltinQosLib::::Generic.Monitoring2
</datawriter_qos_profile_name>
-->
<thread>
<mask>MASK_DEFAULT</mask>
<priority>THREAD_PRIORITY_DEFAULT</priority>
<stack_size>THREAD_STACK_SIZE_DEFAULT</stack_size>
</thread>
<publication_period>
<sec>1</sec>
<nanosec>0</nanosec>
</publication_period>
</logging_settings>
</distribution_settings>
</monitoring>
</participant_factory_qos>
<datawriter_qos>
<reliability>
<instance_state_consistency_kind>NO_RECOVER_INSTANCE_STATE_CONSISTENCY</instance_state_consistency_kind>
</reliability>
</datawriter_qos>
<datareader_qos>
<reliability>
<instance_state_consistency_kind>NO_RECOVER_INSTANCE_STATE_CONSISTENCY</instance_state_consistency_kind>
</reliability>
</datareader_qos>
</qos_profile>
<!-- The QoS default values for version 7.2.0 -->
<qos_profile name="Baseline.7.2.0" base_name="Baseline.7.1.0">
<participant_factory_qos>
<monitoring>
<telemetry_data>
<!-- An empty sequence, meaning that no metrics
will be collected and distributed for any observable
resource.
-->
<metrics/>
<logs>
<middleware_forwarding_level>WARNING</middleware_forwarding_level>
<security_event_forwarding_level>WARNING</security_event_forwarding_level>
<service_forwarding_level>WARNING</service_forwarding_level>
<user_forwarding_level>WARNING</user_forwarding_level>
</logs>
</telemetry_data>
<distribution_settings>
<dedicated_participant>
<collector_initial_peers/>
</dedicated_participant>
</distribution_settings>
</monitoring>
</participant_factory_qos>
<datawriter_qos>
<durability>
<storage_settings>
<enable>false</enable>
<file_name xsi:nil="true"/>
<trace_file_name xsi:nil="true"/>
<journal_kind>WAL</journal_kind>
<synchronization_kind>NORMAL</synchronization_kind>
<vacuum>true</vacuum>
<restore>true</restore>
<writer_sample_cache_allocation>
<initial_count>32</initial_count>
<max_count>32</max_count>
<incremental_count>AUTO_COUNT</incremental_count>
</writer_sample_cache_allocation>
<writer_instance_cache_allocation>
<initial_count>AUTO_COUNT</initial_count>
<max_count>AUTO_COUNT</max_count>
<incremental_count>-1</incremental_count>
</writer_instance_cache_allocation>
<writer_memory_state>true</writer_memory_state>
</storage_settings>
</durability>
</datawriter_qos>
<datareader_qos>
<durability>
<storage_settings>
<enable>false</enable>
<file_name xsi:nil="true"/>
<trace_file_name xsi:nil="true"/>
<journal_kind>WAL</journal_kind>
<synchronization_kind>NORMAL</synchronization_kind>
<vacuum>true</vacuum>
<restore>true</restore>
<reader_checkpoint_frequency>1</reader_checkpoint_frequency>
</storage_settings>
</durability>
<reader_resource_limits>
<autopurge_remote_not_alive_writer_delay>
<sec>DURATION_AUTO_SEC</sec>
<nanosec>DURATION_AUTO_NSEC</nanosec>
</autopurge_remote_not_alive_writer_delay>
</reader_resource_limits>
</datareader_qos>
</qos_profile>
<!-- The QoS default values for version 7.3.0 -->
<qos_profile name="Baseline.7.3.0" base_name="Baseline.7.2.0">
</qos_profile>
<!-- The QoS default values for version 7.4.0 -->
<qos_profile name="Baseline.7.4.0" base_name="Baseline.7.3.0">
<domain_participant_qos>
<discovery_config>
<secure_volatile_writer>
<max_heartbeat_retries>800</max_heartbeat_retries>
</secure_volatile_writer>
</discovery_config>
<transport_builtin>
<udpv4_wan>
<message_size_max>1400</message_size_max>
</udpv4_wan>
</transport_builtin>
</domain_participant_qos>
</qos_profile>
<!-- The QoS default values for version 7.5.0 -->
<qos_profile name="Baseline.7.5.0" base_name="Baseline.7.4.0">
<domain_participant_qos>
<transport_builtin>
<udpv4>
<send_socket_buffer_size>NDDS_TRANSPORT_UDPV4_SEND_SOCKET_BUFFER_SIZE_DEFAULT</send_socket_buffer_size>
<recv_socket_buffer_size>NDDS_TRANSPORT_UDPV4_RECV_SOCKET_BUFFER_SIZE_DEFAULT</recv_socket_buffer_size>
</udpv4>
<udpv4_wan>
<send_socket_buffer_size>NDDS_TRANSPORT_UDPV4_SEND_SOCKET_BUFFER_SIZE_DEFAULT</send_socket_buffer_size>
<recv_socket_buffer_size>NDDS_TRANSPORT_UDPV4_RECV_SOCKET_BUFFER_SIZE_DEFAULT</recv_socket_buffer_size>
</udpv4_wan>
<udpv6>
<send_socket_buffer_size>NDDS_TRANSPORT_UDPV6_SEND_SOCKET_BUFFER_SIZE_DEFAULT</send_socket_buffer_size>
<recv_socket_buffer_size>NDDS_TRANSPORT_UDPV6_RECV_SOCKET_BUFFER_SIZE_DEFAULT</recv_socket_buffer_size>
</udpv6>
</transport_builtin>
</domain_participant_qos>
</qos_profile>
<!-- The QoS default values for version 7.6.0 -->
<qos_profile name="Baseline.7.6.0" base_name="Baseline.7.5.0">
<domain_participant_qos>
<discovery_config>
<dns_tracker_polling_period>
<sec>20</sec>
<nanosec>0</nanosec>
</dns_tracker_polling_period>
</discovery_config>
</domain_participant_qos>
<datawriter_qos>
<protocol>
<rtps_reliable_writer>
<heartbeat_period>
<sec>0</sec>
<nanosec>200000000</nanosec>
</heartbeat_period>
<fast_heartbeat_period>
<sec>0</sec>
<nanosec>200000000</nanosec>
</fast_heartbeat_period>
<late_joiner_heartbeat_period>
<sec>0</sec>
<nanosec>200000000</nanosec>
</late_joiner_heartbeat_period>
<max_heartbeat_retries>150</max_heartbeat_retries>
</rtps_reliable_writer>
</protocol>
</datawriter_qos>
</qos_profile>
<!-- The QoS default values for version 7.7.0 -->
<qos_profile name="Baseline.7.7.0" base_name="Baseline.7.6.0">
<participant_factory_qos>
<monitoring>
<!-- The factory default is true for applications linking with
Connext shared libraries shared libraries and false for
static libraries. This conditional value cannot be
represented in XML.
<enable>true</enable>
-->
<distribution_settings>
<dedicated_participant>
<domain_id>101</domain_id>
</dedicated_participant>
</distribution_settings>
<telemetry_data>
<metrics>
<element>
<resource_selection>//applications/*</resource_selection>
<enabled_metrics_selection>
<!-- Periodic metrics -->
<element>dds_application_process_memory_usage_*</element>
</enabled_metrics_selection>
</element>
<element>
<resource_selection>//domain_participants/*</resource_selection>
<enabled_metrics_selection>
<!-- Periodic metrics -->
<element>dds_domain_participant_udpv4_usage_in_net_pkts_*</element>
<element>dds_domain_participant_udpv4_usage_in_net_bytes_*</element>
<element>dds_domain_participant_udpv4_usage_out_net_pkts_*</element>
<element>dds_domain_participant_udpv4_usage_out_net_bytes_*</element>
</enabled_metrics_selection>
</element>
<element>
<resource_selection>//topics/*</resource_selection>
<enabled_metrics_selection>
<!-- Event metrics -->
<element>dds_topic_inconsistent_total</element>
</enabled_metrics_selection>
</element>
<element>
<resource_selection>//data_writers/*</resource_selection>
<enabled_metrics_selection>
<!-- Periodic metrics -->
<element>dds_data_writer_reliable_cache_*</element>
<!-- Event metrics -->
<element>dds_data_writer_liveliness_lost_total</element>
<element>dds_data_writer_deadline_missed_total</element>
<element>dds_data_writer_incompatible_qos_total</element>
<element>dds_data_writer_publication_matched_*</element>
<element>dds_data_writer_reliable_reader_activity_*</element>
</enabled_metrics_selection>
</element>
<element>
<resource_selection>//data_readers/*</resource_selection>
<enabled_metrics_selection>
<!-- Periodic metrics -->
<element>dds_data_reader_cache_*</element>
<element>dds_data_reader_protocol_*</element>
<!-- Event metrics -->
<element>dds_data_reader_liveliness_*</element>
<element>dds_data_reader_deadline_missed_total</element>
<element>dds_data_reader_incompatible_qos_total</element>
<element>dds_data_reader_sample_lost_total</element>
<element>dds_data_reader_subscription_matched_*</element>
</enabled_metrics_selection>
</element>
</metrics>
</telemetry_data>
</monitoring>
</participant_factory_qos>
<domain_participant_qos>
<resource_limits>
<type_object_max_serialized_length>LENGTH_AUTO</type_object_max_serialized_length>
<serialized_type_object_dynamic_allocation_threshold>LENGTH_AUTO</serialized_type_object_dynamic_allocation_threshold>
</resource_limits>
<discovery_config>
<enabled_builtin_channels>
SERVICE_REQUEST_CHANNEL | TYPE_LOOKUP_SERVICE_CHANNEL
</enabled_builtin_channels>
<secure_volatile_writer>
<heartbeat_period>
<sec>0</sec>
<nanosec>200000000</nanosec>
</heartbeat_period>
<fast_heartbeat_period>
<sec>0</sec>
<nanosec>200000000</nanosec>
</fast_heartbeat_period>
<late_joiner_heartbeat_period>
<sec>0</sec>
<nanosec>200000000</nanosec>
</late_joiner_heartbeat_period>
<max_heartbeat_retries>1000</max_heartbeat_retries>
<heartbeats_per_max_samples>100000000</heartbeats_per_max_samples>
</secure_volatile_writer>
<request_types_filter xsi:nil="true" />
</discovery_config>
</domain_participant_qos>
<datawriter_qos>
<reliability>
<exact_reliability_kind_match>false</exact_reliability_kind_match>
</reliability>
<writer_resource_limits>
<initial_remote_readers>2</initial_remote_readers>
</writer_resource_limits>
</datawriter_qos>
<datareader_qos>
<reader_resource_limits>
<lazily_allocate_batch_resources>true</lazily_allocate_batch_resources>
</reader_resource_limits>
</datareader_qos>
</qos_profile>
<!-- The most up-to-date QoS default values.
If a QoS Profile inherits from this QoS Profile, it will automatically configure
the default settings to the ones that match the current version of RTI Connext DDS.
You do not need to explicitly inherit from this QoS Profile. Any QoS Profile that
does not specify a base_name automatically gets initialized with the settings
of the "Baseline" QoS Profile.
-->
<qos_profile name="Baseline" base_name="Baseline.7.7.0"/>
<!-- A common Participant base QoS Profile from which all Generic.X and
Pattern.X QoS Profiles will inherit -->
<qos_profile name="Generic.Common" base_name="Baseline" >
<domain_participant_qos>
<resource_limits>
<participant_property_string_max_length>4096</participant_property_string_max_length>
<participant_property_list_max_length>45</participant_property_list_max_length>
</resource_limits>
</domain_participant_qos>
</qos_profile>
<!-- This QoS Profile will always represent the QoS values required for
interoperability between the most recent version of RTI Connext DDS Micro
at the time of release of the most recent version of RTI Connext DDS.
-->
<qos_profile name="Generic.ConnextMicroCompatibility" base_name="Baseline">
<base_name>
<!-- Connext DDS Micro does not support type object, so we disable
sending it.
This setting is not strictly needed for compatibility, but makes
discovery bandwidth usage more efficient since Connext Micro will
not use the type information anyway. -->
<element>BuiltinQosSnippetLib::QosPolicy.SerializedTypes.Disable</element>
<!-- Connext DDS Micro will not interoperate with DataWriters that send
compressed data -->
<element>BuiltinQosSnippetLib::QosPolicy.Compression.Disable</element>
<element>BuiltinQosSnippetLib::Transport.UDP.Micro2CompatibleMessageSizeMax</element>
</base_name>
</qos_profile>
<!-- The most recent version of RTI Connext DDS Micro at the
time of release of RTI Connext DDS 5.3.0 was 2.4.9. There is no
guarantee that this QoS Profile will interoperate with versions of RTI
Connext Micro newer than 2.4.9. -->
<qos_profile name="Generic.ConnextMicroCompatibility.2.4.9" base_name="Baseline">
<base_name>
<element>BuiltinQosSnippetLib::Transport.UDP.Micro2CompatibleMessageSizeMax</element>
</base_name>
</qos_profile>
<!-- QoS Profile that makes an entity compatible with RTI Connext DDS Micro 2.4.3 -->
<qos_profile name="Generic.ConnextMicroCompatibility.2.4.3" base_name="Baseline">
<base_name>
<element>BuiltinQosSnippetLib::Compatibility.ConnextMicro.Version243</element>
<element>BuiltinQosSnippetLib::Transport.UDP.Micro2CompatibleMessageSizeMax</element>
</base_name>
</qos_profile>
<!-- This QoS Profile configures RTI Connext DDS to interoperate with
other DDS vendors
-->
<qos_profile name="Generic.OtherDDSVendorCompatibility" base_name="Baseline">
<base_name>
<element>BuiltinQosSnippetLib::Compatibility.OtherDDSVendor.Enable</element>
</base_name>
</qos_profile>
<!-- This QoS Profile configures RTI Connext DDS 5.2.0 and above to interoperate with
RTI Connext DDS 5.1.0 and below for UDPv6 and SHMEM transports
-->
<qos_profile name="Generic.510TransportCompatibility" base_name="Baseline">
<base_name>
<element>BuiltinQosSnippetLib::Compatibility.510Transport.Enable</element>
</base_name>
</qos_profile>
<!-- Generic Base participant QoS Profile that enables RTI Monitoring Library.
Use of this QoS Profile is deprecated. It is included for backwards compatibility.
Instead of using the (deprecated) "BuiltinQosLib::Generic.Monitoring.Common", apply
the QoS Snippet "BuiltinQosSnippetLib::Feature.Monitoring.Enable" via composition. For example:
<qos_profile name="MyProfile">
<base_name>
<element>BuiltinQosSnippetLib::Feature.Monitoring.Enable</element>
</base_name>
</qos_profile>
Legacy applications may use this QoS Profile via inheritance. To do this,
create a derived QoS Profile that inherits from this one. For example:
<qos_profile name="MyProfile" base_name="BuiltinQosLib::Generic.StrictReliable">
<domain_participant_qos base_name="BuiltinQosLib::Generic.Monitoring.Common">
</qos_profile>
-->
<qos_profile name="Generic.Monitoring.Common" base_name="Generic.Common">
<base_name>
<element>BuiltinQosSnippetLib::Feature.Monitoring.Enable</element>
</base_name>
</qos_profile>
<!--
Generic Base Participant Profile that enables the builtin DDS Security Plugins.
Use of this QoS Profile is deprecated. It is included for backwards compatibility.
Instead of using the (deprecated) "BuiltinQosLib::Generic.Security", apply
the QoS Snippet "BuiltinQosSnippetLib::Feature.Security.Enable" via composition. For example:
<qos_profile name="MyProfile">
<base_name>
<element>BuiltinQosSnippetLib::Feature.Security.Enable</element>
</base_name>
</qos_profile>
Legacy applications may use this QoS Profile via inheritance. To do this,
create a derived QoS Profile that inherits from this one. For example:
<qos_profile name="MyProfile" base_name="BuiltinQosLib::Generic.StrictReliable">
<domain_participant_qos base_name="BuiltinQosLib::Generic.Security">
</qos_profile>
-->
<qos_profile name="Generic.Security" base_name="Generic.Common">
<base_name>
<element>BuiltinQosSnippetLib::Optimization.Discovery.Endpoint.Fast</element>
<element>BuiltinQosSnippetLib::Feature.Security.Enable</element>
</base_name>
</qos_profile>
<!-- Configures communication to be "strict reliable" where every sample is
reliably delivered.
Combines the use of the RELIABLE kind for RELIABILITY QosPolicy with a
KEEP_ALL kind for the HISTORY QosPolicy
This QoS Profile also optimizes the reliability protocol setting for
this configuration.
-->
<qos_profile name="Generic.StrictReliable" base_name="BuiltinQosLib::Generic.Common">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.Reliability.Reliable</element>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepAll</element>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.KeepAll</element>
</base_name>
</qos_profile>
<!-- Like the Generic.StrictReliable QoS Profile, this QoS Profile ensures
in-order delivery of samples. However, new data can overwrite
data that has not been acknowledged yet by the reader, therefore
causing possible sample loss (KeepLast_1 QoS Snippet).
-->
<qos_profile name="Generic.KeepLastReliable" base_name="BuiltinQosLib::Generic.Common">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.Reliability.Reliable</element>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepLast_1</element>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.KeepLast</element>
</base_name>
</qos_profile>
<!-- This QoS Profile enables best-effort communication. No effort or
resources are spent to track whether or not sent samples are
received. Minimal resources are used. Best-effort is the most
deterministic method of sending data since there is no
indeterministic delay that can be introduced by resending data.
Data samples may be lost. This QoS Profile is good for periodic
data.
-->
<qos_profile name="Generic.BestEffort" base_name="BuiltinQosLib::Generic.Common">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.Reliability.BestEffort</element>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepLast_1</element>
</base_name>
<datawriter_qos>
<history>
<depth>100</depth>
</history>
</datawriter_qos>
<datareader_qos>
<history>
<depth>100</depth>
</history>
</datareader_qos>
</qos_profile>
<!-- The Generic.StrictReliable.HighThroughput QoS Profile extends the
Generic.StrictReliable QoS Profile to perform additional, fine-grained
performance tuning specific to applications that send continuously
streaming data. The parameters specified here add to and/or override
the parameters specified in the Generic.StrictReliable QoS Profile.
Important! If you are inheriting from this QoS Profile and are writing
samples smaller than 120 bytes you will fail to see
communication between your DataWriters and DataReaders. This is because
of the batching settings in combination with the DataReader's
max_samples resource limit of 256 that is inherited from the
Generic.StrictReliable QoS Profile. You will need to increase this value.
For a full explanation of the problem please visit
https://community.rti.com/kb/why-does-communication-fail-when-i-use-one-built-qos-profiles
-->
<qos_profile name="Generic.StrictReliable.HighThroughput" base_name="BuiltinQosLib::Generic.StrictReliable">
<base_name>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.HighRate</element>
<element>BuiltinQosSnippetLib::QosPolicy.Batching.Enable</element>
</base_name>
</qos_profile>
<!-- The Generic.LowLatency QoS Profile extends the Generic.StrictReliable
QoS Profile to perform additional, fine-grained performance tuning
specific to applications that send continuously streaming data. The
parameters specified here add to and/or override the parameters
specified in the Generic.StrictReliable QoS Profile.
-->
<qos_profile name="Generic.StrictReliable.LowLatency" base_name="BuiltinQosLib::Generic.StrictReliable">
<base_name>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.LowLatency</element>
</base_name>
</qos_profile>
<!-- A common Participant base QoS Profile that configures 3 different
flow controllers: 838, 209, and 52 Mbps that can each be used to
throttle application data flow at different rates.
-->
<qos_profile name="Generic.Participant.LargeData" base_name="BuiltinQosLib::Generic.Common">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.Reliability.Reliable</element>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepAll</element>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.KeepAll</element>
<element>BuiltinQosSnippetLib::Feature.FlowController.838Mbps</element>
<element>BuiltinQosSnippetLib::Feature.FlowController.209Mbps</element>
<element>BuiltinQosSnippetLib::Feature.FlowController.52Mbps</element>
</base_name>
<!-- Sets the default flowcontroller, so only the Participant QoS has
been modified.
-->
<datawriter_qos>
<publish_mode>
<flow_controller_name>DEFAULT_FLOW_CONTROLLER_NAME</flow_controller_name>
</publish_mode>
</datawriter_qos>
</qos_profile>
<!-- A common base Participant QoS Profile to configure Participants to both
handle large data and use RTI Monitoring Library.
This QoS Profile is deprecated. It is included for backwards compatibility.
It is recommended that instead of inheriting from this QoS Profile, new applications
apply the following QoS Snippets to their application-specific QoS Profiles:
* Enable Monitoring
* BuiltinQosLib::Feature.Monitoring.Enable
* Enable Large Data optimizations
* BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.LargeData
* BuiltinQosSnippetLib::Optimization.DataCache.LargeData.DynamicMemAlloc
-->
<qos_profile name="Generic.Participant.LargeData.Monitoring" base_name="BuiltinQosLib::Generic.Participant.LargeData">
<base_name>
<element>BuiltinQosSnippetLib::Feature.Monitoring.Enable</element>
</base_name>
</qos_profile>
<!-- This QoS Profile extends the Generic.Participant.LargeData QoS Profile
to handle sending large samples reliably. This QoS Profile optimizes
memory usage per sample within RTI Connext DDS.
You can use this QoS Profile directly, which doesn't perform any flow
control, or you can use one of the three QoS Profiles below
(Generic.StrictReliable.LargeData.*Flow), which use this QoS Profile
as a common base QoS Profile, but additionally enable asynchronous
publication. Each of these three QoS Profiles uses one of the three
flow controllers defined in Generic.Participant.LargeData in order to
throttle application data flow.
-->
<qos_profile name="Generic.StrictReliable.LargeData" base_name="BuiltinQosLib::Generic.Participant.LargeData">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.Reliability.Reliable</element>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepAll</element>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.LargeData</element>
<element>BuiltinQosSnippetLib::Optimization.DataCache.LargeData.DynamicMemAlloc</element>
</base_name>
</qos_profile>
<!-- This QoS Profile is similar to the Generic.KeepLastReliable QoS Profile,
but also adds QoS Snippets to handle sending large samples reliably.
You can use this QoS Profile directly, which doesn't perform any flow
control, or you can use one of the three QoS Profiles below
(Generic.KeepLastReliable.LargeData.*Flow), which use this QoS Profile
as a common base QoS Profile, but additionally enable asynchronous
publication. Each of these three QoS Profiles uses one of the three
flow controllers defined in Generic.Participant.LargeData in order to
throttle application data flow.
-->
<qos_profile name="Generic.KeepLastReliable.LargeData" base_name="BuiltinQosLib::Generic.Participant.LargeData">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.Reliability.Reliable</element>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepLast_1</element>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.LargeData</element>
<element>BuiltinQosSnippetLib::Optimization.DataCache.LargeData.DynamicMemAlloc</element>
</base_name>
<datawriter_qos>
<resource_limits>
<max_samples>LENGTH_UNLIMITED</max_samples>
</resource_limits>
</datawriter_qos>
<datareader_qos>
<resource_limits>
<max_samples>LENGTH_UNLIMITED</max_samples>
</resource_limits>
</datareader_qos>
</qos_profile>
<!-- Strictly reliable communication for large data with a 838 Mbps
(~ 100 MB/sec) flow controller.
-->
<qos_profile name="Generic.StrictReliable.LargeData.FastFlow" base_name="Generic.StrictReliable.LargeData">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.PublishMode.Asynchronous</element>
<element>BuiltinQosSnippetLib::Feature.FlowController.838Mbps</element>
</base_name>
</qos_profile>
<!-- Strictly reliable communication for large data with a 209Mbps
(~ 25 MB/sec) flow controller.
-->
<qos_profile name="Generic.StrictReliable.LargeData.MediumFlow" base_name="Generic.StrictReliable.LargeData">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.PublishMode.Asynchronous</element>
<element>BuiltinQosSnippetLib::Feature.FlowController.209Mbps</element>
</base_name>
</qos_profile>
<!-- Strictly reliable communication for large data with a 52 MB/sec
(~ 6.25 MB/sec) flow controller.
-->
<qos_profile name="Generic.StrictReliable.LargeData.SlowFlow" base_name="Generic.StrictReliable.LargeData">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.PublishMode.Asynchronous</element>
<element>BuiltinQosSnippetLib::Feature.FlowController.52Mbps</element>
</base_name>
</qos_profile>
<!-- Keep-last reliable communication for large data with a 838 Mbps
(~ 100 MB/sec) flow controller.
-->
<qos_profile name="Generic.KeepLastReliable.LargeData.FastFlow" base_name="Generic.KeepLastReliable.LargeData">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.PublishMode.Asynchronous</element>
<element>BuiltinQosSnippetLib::Feature.FlowController.838Mbps</element>
</base_name>
</qos_profile>
<!-- Keep-last reliable communication for large data with a 209Mbps
(~ 25 MB/sec) flow controller.
-->
<qos_profile name="Generic.KeepLastReliable.LargeData.MediumFlow" base_name="Generic.KeepLastReliable.LargeData">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.PublishMode.Asynchronous</element>
<element>BuiltinQosSnippetLib::Feature.FlowController.209Mbps</element>
</base_name>
</qos_profile>
<!-- Keep-last reliable communication for large data with a 52 MB/sec
(~ 6.25 MB/sec) flow controller.
-->
<qos_profile name="Generic.KeepLastReliable.LargeData.SlowFlow" base_name="Generic.KeepLastReliable.LargeData">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.PublishMode.Asynchronous</element>
<element>BuiltinQosSnippetLib::Feature.FlowController.52Mbps</element>
</base_name>
</qos_profile>
<!-- This QoS Profile does the same as Generic.KeepLastReliable, but
also persists the samples of a DataWriter as long as the entity exists
in order to deliver them to late-joining DataReaders.
-->
<qos_profile name="Generic.KeepLastReliable.TransientLocal" base_name="BuiltinQosLib::Generic.Common">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.Reliability.Reliable</element>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepLast_1</element>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.KeepLast</element>
<element>BuiltinQosSnippetLib::QosPolicy.Durability.TransientLocal</element>
</base_name>
</qos_profile>
<!-- This QoS Profile does the same as Generic.KeepLastReliable, but
also persists samples using RTI Persistence Service in order to deliver
them to late-joining DataReaders.
-->
<qos_profile name="Generic.KeepLastReliable.Transient" base_name="BuiltinQosLib::Generic.Common">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.Reliability.Reliable</element>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepLast_1</element>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.KeepLast</element>
<element>BuiltinQosSnippetLib::QosPolicy.Durability.Transient</element>
</base_name>
</qos_profile>
<!-- This QoS Profile does the same as Generic.KeepLastReliable, but
also persists samples in permanent storage, such as a disk, using
RTI Persistence Service to deliver them to late-joining DataReaders
-->
<qos_profile name="Generic.KeepLastReliable.Persistent" base_name="BuiltinQosLib::Generic.Common">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.Reliability.Reliable</element>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepLast_1</element>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.KeepLast</element>
<element>BuiltinQosSnippetLib::QosPolicy.Durability.Persistent</element>
</base_name>
</qos_profile>
<!-- This QoS Profile enables the Turbo Mode batching and Auto Throttle
experimental features. Aside from the properties that enable these
features (which are all false by default), all the values are set to their
defaults and are shown here for reference. Turbo Mode batching adjusts
the maximum number of bytes of a batch, based on how frequently samples
are being written. Auto Throttle auto-adjusts the speed at which a
writer will write samples, based on the number of unacknowledged
samples in its queue.
These features are designed to auto-adjust the publishing behavior
within a system to achieve the best possible performance
with regards to throughput and latency.
Important! If you are inheriting from this QoS Profile and are writing
samples smaller than 120 bytes you will fail to see
communication between your DataWriters and DataReaders. This is because
of the batching settings in combination with the DataReader's
max_samples resource limit of 256 that is inherted from the
Generic.StrictReliable QoS Profile. You will need to increase this value.
For a full explanation of the problem please visit
https://community.rti.com/kb/why-does-communication-fail-when-i-use-one-built-qos-profiles
-->
<qos_profile name="Generic.AutoTuning" base_name="BuiltinQosLib::Generic.Common">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.Reliability.Reliable</element>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepAll</element>
<element>BuiltinQosSnippetLib::QosPolicy.Batching.Enable</element>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.HighRate</element>
<element>BuiltinQosSnippetLib::Feature.AutoTuning.Enable</element>
</base_name>
<datawriter_qos>
<protocol>
<rtps_reliable_writer>
<max_send_window_size>100</max_send_window_size>
</rtps_reliable_writer>
</protocol>
</datawriter_qos>
</qos_profile>
<!-- This QoS Profile establishes the QoS needed for reducing the memory
footprint of an RTI Connext DDS application to its minimum. As this
QoS Profile drastically reduces several resource limits, it is expected
that some changes may need to be made when using this QoS Profile in a
real environment to account for system and application requirements. Notice
this QoS Profile does not extend from any other QoS Profile nor QoS Snippet.
-->
<qos_profile name="Generic.MinimalMemoryFootprint">
<domain_participant_qos>
<transport_builtin>
<mask>UDPv4</mask>
</transport_builtin>
<discovery_config>
<publication_reader_resource_limits>
<initial_samples>1</initial_samples>
<max_samples>LENGTH_UNLIMITED</max_samples>
<max_samples_per_read>1</max_samples_per_read>
<dynamically_allocate_fragmented_samples>true</dynamically_allocate_fragmented_samples>
<initial_infos>1</initial_infos>
<initial_outstanding_reads>1</initial_outstanding_reads>
<initial_fragmented_samples>1</initial_fragmented_samples>
</publication_reader_resource_limits>
<subscription_reader_resource_limits>
<initial_samples>1</initial_samples>
<max_samples>LENGTH_UNLIMITED</max_samples>
<max_samples_per_read>1</max_samples_per_read>
<dynamically_allocate_fragmented_samples>true</dynamically_allocate_fragmented_samples>
<initial_infos>1</initial_infos>
<initial_outstanding_reads>1</initial_outstanding_reads>
<initial_fragmented_samples>1</initial_fragmented_samples>
</subscription_reader_resource_limits>
<participant_reader_resource_limits>
<initial_samples>1</initial_samples>
<max_samples>LENGTH_UNLIMITED</max_samples>
<max_samples_per_read>1</max_samples_per_read>
<dynamically_allocate_fragmented_samples>true</dynamically_allocate_fragmented_samples>
<initial_infos>1</initial_infos>
<initial_outstanding_reads>1</initial_outstanding_reads>
<initial_fragmented_samples>1</initial_fragmented_samples>
</participant_reader_resource_limits>
<participant_configuration_reader_resource_limits>
<initial_samples>1</initial_samples>
<max_samples>LENGTH_UNLIMITED</max_samples>
<max_samples_per_read>1</max_samples_per_read>
<dynamically_allocate_fragmented_samples>true</dynamically_allocate_fragmented_samples>
<initial_infos>1</initial_infos>
<initial_outstanding_reads>1</initial_outstanding_reads>
<initial_fragmented_samples>1</initial_fragmented_samples>
</participant_configuration_reader_resource_limits>
<enabled_builtin_channels>MASK_NONE</enabled_builtin_channels>
</discovery_config>
<resource_limits>
<transport_info_list_max_length>0</transport_info_list_max_length>
<local_writer_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</local_writer_allocation>
<local_reader_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</local_reader_allocation>
<local_publisher_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</local_publisher_allocation>
<local_subscriber_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</local_subscriber_allocation>
<local_topic_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</local_topic_allocation>
<remote_writer_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</remote_writer_allocation>
<remote_reader_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</remote_reader_allocation>
<remote_participant_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</remote_participant_allocation>
<matching_writer_reader_pair_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</matching_writer_reader_pair_allocation>
<matching_reader_writer_pair_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</matching_reader_writer_pair_allocation>
<ignored_entity_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</ignored_entity_allocation>
<content_filter_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</content_filter_allocation>
<content_filtered_topic_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</content_filtered_topic_allocation>
<read_condition_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</read_condition_allocation>
<query_condition_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</query_condition_allocation>
<outstanding_asynchronous_sample_allocation>
<incremental_count>1</incremental_count>
<initial_count>1</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</outstanding_asynchronous_sample_allocation>
<flow_controller_allocation>
<incremental_count>1</incremental_count>
<initial_count>4</initial_count>
<max_count>LENGTH_UNLIMITED</max_count>
</flow_controller_allocation>
<local_writer_hash_buckets>1</local_writer_hash_buckets>
<local_reader_hash_buckets>1</local_reader_hash_buckets>
<local_publisher_hash_buckets>1</local_publisher_hash_buckets>
<local_subscriber_hash_buckets>1</local_subscriber_hash_buckets>
<local_topic_hash_buckets>1</local_topic_hash_buckets>
<remote_writer_hash_buckets>1</remote_writer_hash_buckets>
<remote_reader_hash_buckets>1</remote_reader_hash_buckets>
<remote_participant_hash_buckets>1</remote_participant_hash_buckets>
<matching_reader_writer_pair_hash_buckets>1</matching_reader_writer_pair_hash_buckets>
<matching_writer_reader_pair_hash_buckets>1</matching_writer_reader_pair_hash_buckets>
<ignored_entity_hash_buckets>1</ignored_entity_hash_buckets>
<content_filter_hash_buckets>1</content_filter_hash_buckets>
<content_filtered_topic_hash_buckets>1</content_filtered_topic_hash_buckets>
<flow_controller_hash_buckets>1</flow_controller_hash_buckets>
<max_gather_destinations>16</max_gather_destinations>
<participant_user_data_max_length>8</participant_user_data_max_length>
<topic_data_max_length>0</topic_data_max_length>
<publisher_group_data_max_length>0</publisher_group_data_max_length>
<subscriber_group_data_max_length>0</subscriber_group_data_max_length>
<writer_user_data_max_length>16</writer_user_data_max_length>
<reader_user_data_max_length>16</reader_user_data_max_length>
<max_partitions>0</max_partitions>
<max_partition_cumulative_characters>0</max_partition_cumulative_characters>
<type_code_max_serialized_length>0</type_code_max_serialized_length>
<type_object_max_deserialized_length>0</type_object_max_deserialized_length>
<type_object_max_serialized_length>LENGTH_AUTO</type_object_max_serialized_length>
<deserialized_type_object_dynamic_allocation_threshold>0</deserialized_type_object_dynamic_allocation_threshold>
<serialized_type_object_dynamic_allocation_threshold>0</serialized_type_object_dynamic_allocation_threshold>
<contentfilter_property_max_length>1</contentfilter_property_max_length>
<!-- The system participant properties are needed to integrate with
Admin Console. This is why we do reserve some space for them
-->
<participant_property_list_max_length>32</participant_property_list_max_length>
<participant_property_string_max_length>1024</participant_property_string_max_length>
<!-- This needs to be re-calculated. Zero breaks ServiceRequest reader -->
<!--reader_property_list_max_length>0</reader_property_list_max_length-->
<writer_property_list_max_length>0</writer_property_list_max_length>
<!-- This needs to be re-calculated. Zero breaks ServiceRequest reader -->
<!--reader_property_string_max_length>0</reader_property_string_max_length-->
<writer_property_string_max_length>0</writer_property_string_max_length>
<max_endpoint_groups>0</max_endpoint_groups>
<max_endpoint_group_cumulative_characters>0</max_endpoint_group_cumulative_characters>
<channel_seq_max_length>0</channel_seq_max_length>
<channel_filter_expression_max_length>0</channel_filter_expression_max_length>
<writer_data_tag_list_max_length>0</writer_data_tag_list_max_length>
<writer_data_tag_string_max_length>0</writer_data_tag_string_max_length>
<reader_data_tag_list_max_length>0</reader_data_tag_list_max_length>
<reader_data_tag_string_max_length>0</reader_data_tag_string_max_length>
</resource_limits>
<database>
<initial_weak_references>256</initial_weak_references>
<max_weak_references>1000000</max_weak_references>
</database>
</domain_participant_qos>
<datawriter_qos>
<reliability>
<kind>RELIABLE_RELIABILITY_QOS</kind>
</reliability>
<history>
<kind>KEEP_ALL_HISTORY_QOS</kind>
</history>
<resource_limits>
<initial_instances>1</initial_instances>
<initial_samples>1</initial_samples>
<instance_hash_buckets>1</instance_hash_buckets>
</resource_limits>
<writer_resource_limits>
<initial_remote_readers>0</initial_remote_readers>
</writer_resource_limits>
</datawriter_qos>
<datareader_qos>
<reliability>
<kind>RELIABLE_RELIABILITY_QOS</kind>
</reliability>
<history>
<kind>KEEP_ALL_HISTORY_QOS</kind>
</history>
<resource_limits>
<initial_instances>1</initial_instances>
<initial_samples>1</initial_samples>
</resource_limits>
<reader_resource_limits>
<max_samples_per_read>1</max_samples_per_read>
<initial_infos>1</initial_infos>
<initial_outstanding_reads>1</initial_outstanding_reads>
<initial_remote_writers>1</initial_remote_writers>
<initial_remote_writers_per_instance>1</initial_remote_writers_per_instance>
<initial_fragmented_samples>1</initial_fragmented_samples>
<dynamically_allocate_fragmented_samples>1</dynamically_allocate_fragmented_samples>
<initial_remote_virtual_writers>1</initial_remote_virtual_writers>
<initial_remote_virtual_writers_per_instance>1</initial_remote_virtual_writers_per_instance>
<max_query_condition_filters>0</max_query_condition_filters>
<lazily_allocate_batch_resources>true</lazily_allocate_batch_resources>
</reader_resource_limits>
</datareader_qos>
<topic_qos>
<resource_limits>
<initial_samples>1</initial_samples>
<initial_instances>1</initial_instances>
<instance_hash_buckets>1</instance_hash_buckets>
</resource_limits>
</topic_qos>
</qos_profile>
<!-- The default QoS profile that the entities of Monitoring Library 2.0
(or the entities that interact with Monitoring Library 2.0) use.
It uses Topic Filters to select the endpoints QoS based on the
Distribution Topic name.
This profile also minimizes memory usage.
-->
<qos_profile name="Generic.Monitoring2" base_name="Generic.MinimalMemoryFootprint">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepAll</element>
<element>BuiltinQosSnippetLib::QosPolicy.PublishMode.Asynchronous</element>
<element>BuiltinQosSnippetLib::Optimization.DataCache.LargeData.DynamicMemAlloc</element>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.Common</element>
<!-- This disable unnecessary system properties -->
<element>BuiltinQosSnippetLib::Optimization.Discovery.Participant.Compact</element>
</base_name>
<domain_participant_qos>
<transport_builtin>
<mask>UDPv4|SHMEM</mask>
</transport_builtin>
<resource_limits>
<max_partition_cumulative_characters>16</max_partition_cumulative_characters>
<contentfilter_property_max_length>256</contentfilter_property_max_length>
<writer_property_list_max_length>32</writer_property_list_max_length>
<writer_property_string_max_length>1024</writer_property_string_max_length>
<reader_property_list_max_length>32</reader_property_list_max_length>
<reader_property_string_max_length>1024</reader_property_string_max_length>
<participant_property_string_max_length>2048</participant_property_string_max_length>
<transport_info_list_max_length>12</transport_info_list_max_length>
</resource_limits>
<discovery_config>
<participant_liveliness_lease_duration>
<sec>35</sec>
<nanosec>0</nanosec>
</participant_liveliness_lease_duration>
<participant_liveliness_assert_period>
<sec>10</sec>
<nanosec>0</nanosec>
</participant_liveliness_assert_period>
<max_liveliness_loss_detection_period>
<sec>10</sec>
<nanosec>0</nanosec>
</max_liveliness_loss_detection_period>
<initial_participant_announcements>3</initial_participant_announcements>
<service_request_writer>
<heartbeat_period>
<sec>1</sec>
<nanosec>0</nanosec>
</heartbeat_period>
<fast_heartbeat_period>
<sec>1</sec>
<nanosec>0</nanosec>
</fast_heartbeat_period>
<late_joiner_heartbeat_period>
<sec>1</sec>
<nanosec>0</nanosec>
</late_joiner_heartbeat_period>
<max_heartbeat_retries>30</max_heartbeat_retries>
</service_request_writer>
<service_request_writer_data_lifecycle>
<autopurge_disposed_instances_delay>
<sec>0</sec>
<nanosec>0</nanosec>
</autopurge_disposed_instances_delay>
</service_request_writer_data_lifecycle>
<enabled_builtin_channels>SERVICE_REQUEST_CHANNEL</enabled_builtin_channels>
</discovery_config>
<discovery>
<!--
disable the reception multicast for discovery
Collector Service will overwrite this setting in its
own configuration to enable the multicast reception in the
default multicast address.
-->
<multicast_receive_addresses />
</discovery>
<property>
<value>
<!-- Set a domain tag to identify the DomainParticipant used
for observability. o11y is short for observability.
-->
<element>
<name>dds.domain_participant.domain_tag</name>
<value>RTI_o11y</value>
<propagate>false</propagate>
</element>
</value>
</property>
<participant_name>
<name>Observability Domain Participant</name>
</participant_name>
</domain_participant_qos>
<datawriter_qos topic_filter="DCPSEventStatusMonitoring">
<reliability>
<kind>RELIABLE_RELIABILITY_QOS</kind>
<max_blocking_time>
<sec>DURATION_INFINITE_SEC</sec>
<nanosec>DURATION_INFINITE_NSEC</nanosec>
</max_blocking_time>
<exact_reliability_kind_match>true</exact_reliability_kind_match>
</reliability>
<durability>
<kind>VOLATILE_DURABILITY_QOS</kind>
</durability>
<protocol>
<rtps_reliable_writer>
<max_heartbeat_retries>LENGTH_UNLIMITED</max_heartbeat_retries>
</rtps_reliable_writer>
</protocol>
</datawriter_qos>
<datawriter_qos topic_filter="DCPSLoggingStatusMonitoring">
<reliability>
<kind>RELIABLE_RELIABILITY_QOS</kind>
<max_blocking_time>
<sec>0</sec>
<nanosec>250000000</nanosec>
</max_blocking_time>
<exact_reliability_kind_match>true</exact_reliability_kind_match>
</reliability>
<durability>
<kind>VOLATILE_DURABILITY_QOS</kind>
</durability>
<protocol>
<rtps_reliable_writer>
<max_heartbeat_retries>LENGTH_UNLIMITED</max_heartbeat_retries>
</rtps_reliable_writer>
</protocol>
</datawriter_qos>
<datawriter_qos topic_filter="DCPSPeriodicStatusMonitoring">
<reliability>
<kind>BEST_EFFORT_RELIABILITY_QOS</kind>
</reliability>
<durability>
<kind>VOLATILE_DURABILITY_QOS</kind>
</durability>
<protocol>
<rtps_reliable_writer>
<max_heartbeat_retries>LENGTH_UNLIMITED</max_heartbeat_retries>
</rtps_reliable_writer>
</protocol>
</datawriter_qos>
<datareader_qos topic_filter="DCPSEventStatusMonitoring">
<reliability>
<kind>RELIABLE_RELIABILITY_QOS</kind>
</reliability>
<durability>
<kind>VOLATILE_DURABILITY_QOS</kind>
</durability>
<reader_resource_limits>
<max_samples_per_read>1024</max_samples_per_read>
</reader_resource_limits>
</datareader_qos>
<datareader_qos topic_filter="DCPSLoggingStatusMonitoring">
<reliability>
<kind>RELIABLE_RELIABILITY_QOS</kind>
</reliability>
<durability>
<kind>VOLATILE_DURABILITY_QOS</kind>
</durability>
<reader_resource_limits>
<max_samples_per_read>1024</max_samples_per_read>
</reader_resource_limits>
</datareader_qos>
<datareader_qos topic_filter="DCPSPeriodicStatusMonitoring">
<reliability>
<kind>BEST_EFFORT_RELIABILITY_QOS</kind>
</reliability>
<durability>
<kind>VOLATILE_DURABILITY_QOS</kind>
</durability>
<reader_resource_limits>
<max_samples_per_read>1024</max_samples_per_read>
</reader_resource_limits>
</datareader_qos>
</qos_profile>
<!-- This QoS Profile that the entities of Monitoring Library 2.0
use when communicating with a Collector Service over the WAN.
The profile uses the RTI-RealTime WAN Transport.
-->
<qos_profile name="Generic.Monitoring2.WAN" base_name="Generic.Monitoring2">
<base_name>
<element>BuiltinQosSnippetLib::Transport.UDP.WAN</element>
</base_name>
<domain_participant_qos>
<discovery_config>
<initial_participant_announcements>5</initial_participant_announcements>
</discovery_config>
</domain_participant_qos>
</qos_profile>
<!-- The default QoS of the entities created by an RPC client, RPC service,
Requester, or Replier.
-->
<qos_profile name="Pattern.RPC">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepAll</element>
</base_name>
<datawriter_qos>
<reliability>
<kind>RELIABLE_RELIABILITY_QOS</kind>
<max_blocking_time>
<sec>10</sec>
<nanosec>0</nanosec>
</max_blocking_time>
</reliability>
<protocol>
<rtps_reliable_writer>
<max_heartbeat_retries>LENGTH_UNLIMITED</max_heartbeat_retries>
<heartbeats_per_max_samples>2</heartbeats_per_max_samples>
<heartbeat_period>
<sec>0</sec>
<nanosec>100000000</nanosec>
</heartbeat_period>
<fast_heartbeat_period>
<sec>0</sec>
<nanosec>10000000</nanosec>
</fast_heartbeat_period>
<late_joiner_heartbeat_period>
<sec>0</sec>
<nanosec>10000000</nanosec>
</late_joiner_heartbeat_period>
<max_nack_response_delay>
<sec>0</sec>
<nanosec>0</nanosec>
</max_nack_response_delay>
<min_nack_response_delay>
<sec>0</sec>
<nanosec>0</nanosec>
</min_nack_response_delay>
<max_send_window_size>32</max_send_window_size>
<min_send_window_size>32</min_send_window_size>
</rtps_reliable_writer>
</protocol>
</datawriter_qos>
<datareader_qos>
<reliability>
<kind>RELIABLE_RELIABILITY_QOS</kind>
<max_blocking_time>
<sec>10</sec>
<nanosec>0</nanosec>
</max_blocking_time>
</reliability>
<protocol>
<rtps_reliable_reader>
<max_heartbeat_response_delay>
<sec>0</sec>
<nanosec>0</nanosec>
</max_heartbeat_response_delay>
<min_heartbeat_response_delay>
<sec>0</sec>
<nanosec>0</nanosec>
</min_heartbeat_response_delay>
<nack_period>
<sec>0</sec>
<nanosec>500000000</nanosec>
</nack_period>
</rtps_reliable_reader>
</protocol>
</datareader_qos>
</qos_profile>
<!-- This QoS Profile is intended to be used for applications that expect
periodic data such as sensor data. The deadline that is set in
this QoS Profile can be used to detect when DataWriters are not
publishing data with the expected periodicity.
-->
<qos_profile name="Pattern.PeriodicData" base_name="BuiltinQosLib::Generic.BestEffort">
<datawriter_qos>
<deadline>
<period>
<sec>4</sec>
<nanosec>0</nanosec>
</period>
</deadline>
</datawriter_qos>
<datareader_qos>
<deadline>
<period>
<sec>10</sec>
<nanosec>0</nanosec>
</period>
</deadline>
</datareader_qos>
</qos_profile>
<!-- The data sent in streaming applications is commonly periodic and
therefore this QoS Profile simply inherits from Pattern.PeriodicData.
Notice that with this QoS Profile, the application may lose data, which
may be acceptable in use cases such as video conferencing.
-->
<qos_profile name="Pattern.Streaming" base_name="Pattern.PeriodicData"/>
<!-- Sometimes streaming applications require reliable communication
while still tolerating some data loss. In this case, we inherit
from BuiltinQosLib::Generic.Common and add the following
QoS Snippets:
* QosPolicy.Reliability.Reliable
* QosPolicy.History.KeepLast_1
* Optimization.ReliabilityProtocol.KeepLast
This QoS Snippet also increases the HistoryQosPolicy's depth to
reduce the probability of losing samples.
-->
<qos_profile name="Pattern.ReliableStreaming" base_name="BuiltinQosLib::Generic.Common">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.Reliability.Reliable</element>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepLast_1</element>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.KeepLast</element>
</base_name>
<datawriter_qos>
<history>
<depth>100</depth>
</history>
</datawriter_qos>
<datareader_qos>
<history>
<depth>100</depth>
</history>
</datareader_qos>
</qos_profile>
<!-- This QoS Profile can be used by applications in which samples represent
events such as button pushes or alerts. When events are triggered,
the system should almost always do something, meaning that you
don't want the system to lose the event. This means that the system
requires strictly reliable communication. To enable it, use the following
QoS Snippets:
* QosPolicy.Reliability.Reliable
* QosPolicy.History.KeepAll
* Optimization.ReliabilityProtocol.KeepAll
Since events and alerts are critical and non-periodic data, it is
important to detect situations in which communication between a
DataWriter and DataReader is broken. This is why this QoS Profile sets the
LivelinessQosPolicy. If the DataWriter does not assert its
liveliness in a timely manner, the DataReader will report loss
of liveliness to the application.
-->
<qos_profile name="Pattern.Event" base_name="BuiltinQosLib::Generic.Common">
<base_name>
<element>BuiltinQosSnippetLib::QosPolicy.Reliability.Reliable</element>
<element>BuiltinQosSnippetLib::QosPolicy.History.KeepAll</element>
<element>BuiltinQosSnippetLib::Optimization.ReliabilityProtocol.KeepAll</element>
</base_name>
<datawriter_qos>
<liveliness>
<lease_duration>
<sec>4</sec>
<nanosec>0</nanosec>
</lease_duration>
</liveliness>
</datawriter_qos>
<datareader_qos>
<liveliness>
<lease_duration>
<sec>10</sec>
<nanosec>0</nanosec>
</lease_duration>
</liveliness>
</datareader_qos>
</qos_profile>
<!-- An alarm is a type of event; therefore this QoS Profile simply inherits from
Pattern.Event
-->
<qos_profile name="Pattern.AlarmEvent" base_name="Pattern.Event"/>
<!-- This QoS Profile can be used by applications in which samples represent
state variables whose values remain valid as long as they don't
explicitly change. State variables typically do not change
periodically. State variables and their values should also be
available to applications that appear after the value originally
changed because it is unreasonable to have to wait until the next
change of state, which may be indeterminate.
Whether to use this QoS Profile or Pattern.PeriodicData can often
be an application choice. For example, if a DataWriter is
publishing temperature sensor data, it could use the
Pattern.PeriodicData QoS Profile and publish the data at a fixed rate
or it could use the Pattern.Status QoS Profile and only publish the
temperature when it changes more than 1 degree.
-->
<qos_profile name="Pattern.Status" base_name="Generic.KeepLastReliable.TransientLocal"/>
<!-- An alarm status is a type of status; therefore this QoS Profile simply inherits
from Pattern.Status.
-->
<qos_profile name="Pattern.AlarmStatus" base_name="Pattern.Status"/>
<!-- With this QoS Profile, a DataWriter will keep in its queue the last
value that was published for each sample instance. Late-joining
DataReaders will get that value when they join the system. This
QoS Profile inherits from Generic.KeepLastReliable.TransientLocal
because the use case requires delivery to late-joiners.
-->
<qos_profile name="Pattern.LastValueCache" base_name="Generic.KeepLastReliable.TransientLocal"/>
</qos_library>
<!--
QoS Profiles in this library are deprecated. They have been moved to
"BuiltinQosLib". You should use the QoS Profiles from "BuiltinQosLib"
instead of the ones in "BuiltinQosLibExp". The experimental profiles
are still defined here to avoid backward compatibility issues.
-->
<qos_library name="BuiltinQosLibExp">
<qos_profile name="Pattern.PeriodicData" base_name="BuiltinQosLib::Pattern.PeriodicData"/>
<qos_profile name="Pattern.Streaming" base_name="BuiltinQosLib::Pattern.Streaming"/>
<qos_profile name="Pattern.ReliableStreaming" base_name="BuiltinQosLib::Pattern.ReliableStreaming"/>
<qos_profile name="Pattern.Event" base_name="BuiltinQosLib::Pattern.Event"/>
<qos_profile name="Pattern.AlarmEvent" base_name="BuiltinQosLib::Pattern.AlarmEvent"/>
<qos_profile name="Pattern.Status" base_name="BuiltinQosLib::Pattern.Status"/>
<qos_profile name="Pattern.AlarmStatus" base_name="BuiltinQosLib::Pattern.AlarmStatus"/>
<qos_profile name="Pattern.LastValueCache" base_name="BuiltinQosLib::Pattern.LastValueCache"/>
<qos_profile name="Generic.StrictReliable" base_name="BuiltinQosLib::Generic.StrictReliable"/>
<qos_profile name="Generic.KeepLastReliable" base_name="BuiltinQosLib::Generic.KeepLastReliable"/>
<qos_profile name="Generic.BestEffort" base_name="BuiltinQosLib::Generic.BestEffort"/>
<qos_profile name="Generic.StrictReliable.HighThroughput" base_name="BuiltinQosLib::Generic.StrictReliable.HighThroughput"/>
<qos_profile name="Generic.StrictReliable.LowLatency" base_name="BuiltinQosLib::Generic.StrictReliable.LowLatency"/>
<qos_profile name="Generic.Participant.LargeData" base_name="BuiltinQosLib::Generic.Participant.LargeData"/>
<qos_profile name="Generic.Participant.LargeData.Monitoring" base_name="BuiltinQosLib::Generic.Participant.LargeData.Monitoring"/>
<qos_profile name="Generic.StrictReliable.LargeData" base_name="BuiltinQosLib::Generic.StrictReliable.LargeData"/>
<qos_profile name="Generic.KeepLastReliable.LargeData" base_name="BuiltinQosLib::Generic.KeepLastReliable.LargeData"/>
<qos_profile name="Generic.StrictReliable.LargeData.FastFlow" base_name="BuiltinQosLib::Generic.StrictReliable.LargeData.FastFlow"/>
<qos_profile name="Generic.StrictReliable.LargeData.MediumFlow" base_name="BuiltinQosLib::Generic.StrictReliable.LargeData.MediumFlow"/>
<qos_profile name="Generic.StrictReliable.LargeData.SlowFlow" base_name="BuiltinQosLib::Generic.StrictReliable.LargeData.SlowFlow"/>
<qos_profile name="Generic.KeepLastReliable.LargeData.FastFlow" base_name="BuiltinQosLib::Generic.KeepLastReliable.LargeData.FastFlow"/>
<qos_profile name="Generic.KeepLastReliable.LargeData.MediumFlow" base_name="BuiltinQosLib::Generic.KeepLastReliable.LargeData.MediumFlow"/>
<qos_profile name="Generic.KeepLastReliable.LargeData.SlowFlow" base_name="BuiltinQosLib::Generic.KeepLastReliable.LargeData.SlowFlow"/>
<qos_profile name="Generic.KeepLastReliable.TransientLocal" base_name="BuiltinQosLib::Generic.KeepLastReliable.TransientLocal"/>
<qos_profile name="Generic.KeepLastReliable.Transient" base_name="BuiltinQosLib::Generic.KeepLastReliable.Transient"/>
<qos_profile name="Generic.KeepLastReliable.Persistent" base_name="BuiltinQosLib::Generic.KeepLastReliable.Persistent"/>
<qos_profile name="Generic.AutoTuning" base_name="BuiltinQosLib::Generic.AutoTuning"/>
<qos_profile name="Generic.MinimalMemoryFootprint" base_name="BuiltinQosLib::Generic.MinimalMemoryFootprint"/>
</qos_library>
</dds>
Reference in new issue View Git Blame Copy Permalink