<!--
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>
