<!-- 
RTI Data Distribution Service QoS Profiles
-->
<dds xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     xsi:noNamespaceSchemaLocation="../schema/rti_dds_qos_profiles.xsd" version="4.5f">
    <!-- Qos Library -->
    <qos_library name="UserQosProfilesLibrary">
        <qos_profile name="MonitorDefault">
            <participant_qos>
                <participant_name>
                    <name>RTI Monitoring Demo</name>
                </participant_name> 
                
                <!-- increase total property string max length -->
                <resource_limits>
                    <participant_property_string_max_length>
                        2048
                    </participant_property_string_max_length>
                    <!-- 935926.  
                 the following changes were required to get around a crash 
                 that for some reason began occuring in R2013a.  Same Sfuns 
                 ran fine in R2012b. 
                 5/24/2013 debugging sessionn with Ferndando at RTI confirmed that this is a RTI bug.
                 64 bit address is being cast to 32 bit.  Causes crash when address > 32 bits. 
            -->
                    <type_object_max_deserialized_length>
                        0
                    </type_object_max_deserialized_length>
                    <deserialized_type_object_dynamic_allocation_threshold>
                        0
                    </deserialized_type_object_dynamic_allocation_threshold>
            
                    <type_object_max_serialized_length>
                        0
                    </type_object_max_serialized_length>
                    <serialized_type_object_dynamic_allocation_threshold>
                        0
                    </serialized_type_object_dynamic_allocation_threshold>
                   
                    
                </resource_limits>
              
                <property>
                    <value>
                        
                        <!-- ================= -->
                        <!-- enable monitoring -->
                        <!-- ================= -->

                        <!-- must match the library type for the DDS
                                 application -->
                        <!-- 
                            <value>rtimonitoring</value>
                            <value>rtimonitoringd</value>
                         -->
                
                        <!-- causing crash on win7 64 builds.  RTI needs to fix this once they fix the other crash that occurs with this disabled.
                        
                        <element>
                            <name>rti.monitor.library</name>
                            <value>rtimonitoring</value>
                            <propagate>false</propagate>
                        </element>

                        <element>
                            <name>rti.monitor.create_function</name>
                            <value>RTIDefaultMonitor_create</value>
                            <propagate>false</propagate>
                        </element>
			    -->

                        <!-- ========================= -->
                        <!-- monitoring configurations -->
                        <!-- ========================= -->

                        <!-- how often to sample and publish monitoirng
                             topics in seconds, default 5 -->
                        <!--
                        <element>
                            <name>rti.monitor.config.publish_period</name>
                            <value>5</value>
			    <propagate>false</propagate>
                        </element>
			-->

                        <!-- monitoring topics that are sent out,
			     default * (no filter) -->
                        <!--
                        <element>
                            <name>rti.monitor.config.topics</name>
                            <value>*</value>
			    <propagate>false</propagate>
                        </element>
			-->

                        <!-- user topic filter, default * (no filter) -->
                        <!--
                        <element>
                            <name>rti.monitor.config.usertopics</name>
                            <value>*</value>
			    <propagate>false</propagate>
                        </element>
			-->

                        <!-- Uncomment this if you want statistics to be
			     published by a new separate particpant,
			     with the specified domain ID. Default:
			     not specified (use user participant for
			     publishing monitoring data) -->
                        <!--
                        <element>
                            <name>rti.monitor.config.new_participant_domain_id</name>
                            <value>10</value>
			    <propagate>false</propagate>
                        </element>
			-->

                        <!-- Uncomment this if you want to use specific
			     QoS profile for entities created by
			     monitoring. Default: not specified
			     (use internal QoS values) -->
                        <!--
                        <element>
                            <name>rti.monitor.config.qos_library</name>
                            <value>RTIMonitoringQosLibrary</value>
			    <propagate>false</propagate>
                        </element>
                        <element>
                            <name>rti.monitor.config.qos_profile</name>
                            <value>RTIMonitoringPublishingQosProfile</value>
			    <propagate>false</propagate>
                        </element>
			-->

                        <!-- Uncomment this if you want to control the
			     property of the thread that sample and publish
			     monitoring data -->
                        <!-- default -2 for windows, -999999 for linux -->
                        <!--
                        <element>
                            <name>rti.monitor.config.publish_thread_priority</name>
                            <value>-2</value>
			    <propagate>false</propagate>
                        </element>
			-->
                        <!-- default 0 for windows, -1 for linux -->
                        <!--
                        <element>
                            <name>rti.monitor.config.publish_thread_stacksize</name>
                            <value>0</value>
			    <propagate>false</propagate>
                        </element>
			-->
                        <!-- default FLOATING_POINT | STDIO -->
                        <!--
                        <element>
                            <name>rti.monitor.config.publish_thread_options</name>
                            <value></value>
			    <propagate>false</propagate>
                        </element>
			-->

                        <!-- do we want to montior memory and CPU usage,
			     default true -->
                        <!--
                        <element>
                            <name>rti.monitor.config.get_process_statistics</name>
                            <value>true</value>
			    <propagate>false</propagate>
                        </element>
			-->

                        <!-- Do we want to skip monitoring internal entitities
			     and not include them in entity counts,
			     default true -->
                        <!--
                        <element>
                            <name>rti.monitor.config.skip_monitor_entities</name>
                            <value>true</value>
			    <propagate>false</propagate>
                        </element>
			-->

                        <!-- do you want monitoring library to reset
			     status change count after access, default false -->
                        <!--
                        <element>
                            <name>rti.monitor.config.reset_status_change_counts</name>
                            <value>false</value>
			    <propagate>false</propagate>
                        </element>
			-->

                        <!-- monitoring library verbosity for internal
			     debugging purpose, default 1 -->
                        <!--
                        <element>
                            <name>rti.monitor.config.verbosity</name>
                            <value>1</value>
			    <propagate>false</propagate>
                        </element>
			-->

                        <!-- maximum size of the preallocated buffer.
			     If sample serialized size is 
			     larger than this value (unless the value is -1),
			     dynamic memory allocation will be used.
			     Default -1 (preallocated buffer is set
			     according to max size serialized of the data
			     type, no dynamic memory allocation) -->
                        <!--
                        <element>
                            <name>rti.monitor.config.writer_pool_buffer_max_size</name>
                            <value>-1</value>
			    <propagate>false</propagate>
                        </element>
			-->

                    </value>
                </property>
                
                <!-- monitoring types can have large data -->
                <receiver_pool>
                    <buffer_size>65530</buffer_size>
                </receiver_pool>
            </participant_qos>
        </qos_profile>
        <!-- 
        <qos_profile name="DefaultProfile" is_default_qos="true">
-->
        <qos_profile name="DefaultProfile">
            <datareader_qos>
                <durability>
                    <kind>VOLATILE_DURABILITY_QOS</kind>
                    <direct_communication>true</direct_communication>
                </durability>
                <deadline>
                    <period>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </period>
                </deadline>
                <latency_budget>
                    <duration>
                        <sec>DURATION_ZERO_SEC</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </duration>
                </latency_budget>
                <liveliness>
                    <kind>AUTOMATIC_LIVELINESS_QOS</kind>
                    <lease_duration>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </lease_duration>
                </liveliness>
                <reliability>
                    <kind>BEST_EFFORT_RELIABILITY_QOS</kind>
                    <max_blocking_time>
                        <sec>DURATION_ZERO_SEC</sec>
                        <nanosec>100000000</nanosec>
                    </max_blocking_time>
                </reliability>
                <destination_order>
                    <kind>BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS</kind>
                    <source_timestamp_tolerance>
                        <sec>30</sec>
                        <nanosec>0</nanosec>
                    </source_timestamp_tolerance>
                </destination_order>
                <history>
                    <kind>KEEP_LAST_HISTORY_QOS</kind>
                    <depth>10</depth>
                    <refilter>NONE_REFILTER_QOS</refilter>
                </history>
                <resource_limits>
                    <max_samples>LENGTH_UNLIMITED</max_samples>
                    <max_instances>LENGTH_UNLIMITED</max_instances>
                    <max_samples_per_instance>LENGTH_UNLIMITED</max_samples_per_instance>
                    <initial_samples>32</initial_samples>
                    <initial_instances>32</initial_instances>
                </resource_limits>
                <user_data/>
                <ownership>
                    <kind>SHARED_OWNERSHIP_QOS</kind>
                </ownership>
                <time_based_filter>
                    <minimum_separation>
                        <sec>DURATION_ZERO_SEC</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </minimum_separation>
                </time_based_filter>
                <reader_data_lifecycle>
                    <autopurge_nowriter_samples_delay>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </autopurge_nowriter_samples_delay>
                    <autopurge_disposed_samples_delay>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </autopurge_disposed_samples_delay>
                </reader_data_lifecycle>
                <reader_resource_limits>
                    <max_remote_writers>LENGTH_UNLIMITED</max_remote_writers>
                    <max_remote_writers_per_instance>LENGTH_UNLIMITED</max_remote_writers_per_instance>
                    <max_samples_per_remote_writer>LENGTH_UNLIMITED</max_samples_per_remote_writer>
                    <max_infos>LENGTH_UNLIMITED</max_infos>
                    <initial_remote_writers>2</initial_remote_writers>
                    <initial_remote_writers_per_instance>2</initial_remote_writers_per_instance>
                    <initial_infos>32</initial_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>
                    <max_fragments_per_sample>512</max_fragments_per_sample>
                    <dynamically_allocate_fragmented_samples>false</dynamically_allocate_fragmented_samples>
                    <max_total_instances>AUTO_MAX_TOTAL_INSTANCES</max_total_instances>
                </reader_resource_limits>
                <protocol>
                    <virtual_guid>
                        <value>GUID_AUTO</value>
                    </virtual_guid>
                    <rtps_object_id>RTPS_AUTO_ID</rtps_object_id>
                    <expects_inline_qos>false</expects_inline_qos>
                    <disable_positive_acks>false</disable_positive_acks>
                    <propagate_dispose_of_unregistered_instances>false</propagate_dispose_of_unregistered_instances>
                    <rtps_reliable_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>500000000</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>
                    </rtps_reliable_reader>
                </protocol>
                <transport_selection>
                    <enabled_transports/>
                </transport_selection>
                <unicast>
                    <value/>
                </unicast>
                <multicast>
                    <value/>
                </multicast>
                <property>
                    <value/>
                </property>
            </datareader_qos>
            <datawriter_qos>
                <durability>
                    <kind>VOLATILE_DURABILITY_QOS</kind>
                    <direct_communication>true</direct_communication>
                </durability>
                <durability_service>
                    <service_cleanup_delay>
                        <sec>DURATION_ZERO_SEC</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </service_cleanup_delay>
                    <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>
                <deadline>
                    <period>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </period>
                </deadline>
                <latency_budget>
                    <duration>
                        <sec>DURATION_ZERO_SEC</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </duration>
                </latency_budget>
                <liveliness>
                    <kind>AUTOMATIC_LIVELINESS_QOS</kind>
                    <lease_duration>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </lease_duration>
                </liveliness>
                <reliability>
                    <kind>RELIABLE_RELIABILITY_QOS</kind>
                    <max_blocking_time>
                        <sec>DURATION_ZERO_SEC</sec>
                        <nanosec>100000000</nanosec>
                    </max_blocking_time>
                </reliability>
                <destination_order>
                    <kind>BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS</kind>
                    <source_timestamp_tolerance>
                        <sec>0</sec>
                        <nanosec>100000000</nanosec>
                    </source_timestamp_tolerance>
                </destination_order>
                <history>
                    <kind>KEEP_LAST_HISTORY_QOS</kind>
                    <depth>1</depth>
                    <refilter>NONE_REFILTER_QOS</refilter>
                </history>
                <resource_limits>
                    <max_samples>LENGTH_UNLIMITED</max_samples>
                    <max_instances>LENGTH_UNLIMITED</max_instances>
                    <max_samples_per_instance>LENGTH_UNLIMITED</max_samples_per_instance>
                    <initial_samples>32</initial_samples>
                    <initial_instances>32</initial_instances>
                    <instance_hash_buckets>1</instance_hash_buckets>
                </resource_limits>
                <transport_priority>
                    <value>0</value>
                </transport_priority>
                <lifespan>
                    <duration>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </duration>
                </lifespan>
                <user_data/>
                <ownership>
                    <kind>SHARED_OWNERSHIP_QOS</kind>
                </ownership>
                <ownership_strength>
                    <value>0</value>
                </ownership_strength>
                <writer_data_lifecycle>
                    <autodispose_unregistered_instances>true</autodispose_unregistered_instances>
                    <autopurge_unregistered_instances_delay>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </autopurge_unregistered_instances_delay>
                </writer_data_lifecycle>
                <writer_resource_limits>
                    <initial_concurrent_blocking_threads>1</initial_concurrent_blocking_threads>
                    <max_concurrent_blocking_threads>LENGTH_UNLIMITED</max_concurrent_blocking_threads>
                    <max_remote_reader_filters>32</max_remote_reader_filters>
                    <initial_batches>8</initial_batches>
                    <max_batches>LENGTH_UNLIMITED</max_batches>
                    <autoregister_instances>false</autoregister_instances>
                    <replace_empty_instances>false</replace_empty_instances>
                    <instance_replacement>UNREGISTERED_INSTANCE_REPLACEMENT</instance_replacement>
                </writer_resource_limits>
                <protocol>
                    <virtual_guid>
                        <value>GUID_AUTO</value>
                    </virtual_guid>
                    <rtps_object_id>RTPS_AUTO_ID</rtps_object_id>
                    <push_on_write>true</push_on_write>
                    <disable_positive_acks>false</disable_positive_acks>
                    <disable_inline_keyhash>false</disable_inline_keyhash>
                    <serialize_key_with_dispose>false</serialize_key_with_dispose>
                    <rtps_reliable_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>200000000</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>70</send_window_decrease_factor>
                    </rtps_reliable_writer>
                </protocol>
                <transport_selection>
                    <enabled_transports/>
                </transport_selection>
                <unicast>
                    <value/>
                </unicast>                
                <publish_mode>
                    <kind>SYNCHRONOUS_PUBLISH_MODE_QOS</kind>
                    <flow_controller_name>DEFAULT_FLOW_CONTROLLER_NAME</flow_controller_name>
                </publish_mode>
                <property>
                    <value/>
                </property>
                <batch>
                    <enable>false</enable>
                    <max_data_bytes>1024</max_data_bytes>
                    <max_meta_data_bytes>LENGTH_UNLIMITED</max_meta_data_bytes>
                    <max_samples>LENGTH_UNLIMITED</max_samples>
                    <max_flush_delay>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </max_flush_delay>
                    <source_timestamp_resolution>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </source_timestamp_resolution>
                    <thread_safe_write>true</thread_safe_write>
                </batch>
                <multi_channel>
                    <channels>
                    </channels>
                    <filter_name>STRINGMATCHFILTER_NAME</filter_name>
                </multi_channel>
            </datawriter_qos>
            <participant_qos>
                <user_data/>
                <entity_factory>
                    <autoenable_created_entities>true</autoenable_created_entities>
                </entity_factory>
                <wire_protocol>
                    <participant_id>-1</participant_id>
                    <rtps_auto_id_kind>RTPS_AUTO_ID_FROM_IP</rtps_auto_id_kind>
                    <rtps_host_id>RTPS_AUTO_ID</rtps_host_id>
                    <rtps_app_id>RTPS_AUTO_ID</rtps_app_id>
                    <rtps_instance_id>RTPS_AUTO_ID</rtps_instance_id>
                    <rtps_well_known_ports>
                        <port_base>7400</port_base>
                        <domain_id_gain>250</domain_id_gain>
                        <participant_id_gain>2</participant_id_gain>
                        <builtin_multicast_port_offset>0</builtin_multicast_port_offset>
                        <builtin_unicast_port_offset>10</builtin_unicast_port_offset>
                        <user_multicast_port_offset>1</user_multicast_port_offset>
                        <user_unicast_port_offset>11</user_unicast_port_offset>
                    </rtps_well_known_ports>
                    <rtps_reserved_port_mask>MASK_DEFAULT</rtps_reserved_port_mask>
                </wire_protocol>
                <transport_builtin>
                    <mask>MASK_DEFAULT</mask>
                </transport_builtin>
                <default_unicast>
                    <value/>
                </default_unicast>
                <discovery>
                    <enabled_transports/>
                    <!-- The default value of this properties depends on the value of NDDS_DISCOVERY_PEERS
                    <initial_peers/>
                    <multicast_receive_addresses/> 
                    -->
                    <metatraffic_transport_priority>0</metatraffic_transport_priority>
                    <accept_unknown_peers>true</accept_unknown_peers>
                </discovery>
                <resource_limits>
                    <!-- 935926.  
                         the following changes were required to get around a crash 
                         that for some reason began occuring in 2013a.  Same Sfuns 
                         ran fine in 12b. 
                    -->
                    <type_object_max_serialized_length>
                        0
                    </type_object_max_serialized_length>
                    <type_object_max_deserialized_length>
                        0
                    </type_object_max_deserialized_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>
                    <local_writer_allocation>
                        <initial_count>16</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </local_writer_allocation>
                    <local_reader_allocation>
                        <initial_count>16</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </local_reader_allocation>
                    <local_publisher_allocation>
                        <initial_count>4</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </local_publisher_allocation>
                    <local_subscriber_allocation>
                        <initial_count>4</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </local_subscriber_allocation>
                    <local_topic_allocation>
                        <initial_count>16</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </local_topic_allocation>
                    <remote_writer_allocation>
                        <initial_count>64</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </remote_writer_allocation>
                    <remote_reader_allocation>
                        <initial_count>64</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </remote_reader_allocation>
                    <remote_participant_allocation>
                        <initial_count>16</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </remote_participant_allocation>
                    <matching_writer_reader_pair_allocation>
                        <initial_count>32</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </matching_writer_reader_pair_allocation>
                    <matching_reader_writer_pair_allocation>
                        <initial_count>32</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </matching_reader_writer_pair_allocation>
                    <ignored_entity_allocation>
                        <initial_count>8</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </ignored_entity_allocation>
                    <content_filtered_topic_allocation>
                        <initial_count>4</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </content_filtered_topic_allocation>
                    <content_filter_allocation>
                        <initial_count>4</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </content_filter_allocation>
                    <read_condition_allocation>
                        <initial_count>4</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </read_condition_allocation>
                    <query_condition_allocation>
                        <initial_count>4</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </query_condition_allocation>
                    <outstanding_asynchronous_sample_allocation>
                        <initial_count>64</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </outstanding_asynchronous_sample_allocation>
                    <flow_controller_allocation>
                        <initial_count>4</initial_count>
                        <max_count>LENGTH_UNLIMITED</max_count>
                        <incremental_count>-1</incremental_count>
                    </flow_controller_allocation>
                    <local_writer_hash_buckets>4</local_writer_hash_buckets>
                    <local_reader_hash_buckets>4</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>4</local_topic_hash_buckets>
                    <remote_writer_hash_buckets>16</remote_writer_hash_buckets>
                    <remote_reader_hash_buckets>16</remote_reader_hash_buckets>
                    <remote_participant_hash_buckets>4</remote_participant_hash_buckets>
                    <matching_writer_reader_pair_hash_buckets>32</matching_writer_reader_pair_hash_buckets>
                    <matching_reader_writer_pair_hash_buckets>32</matching_reader_writer_pair_hash_buckets>
                    <ignored_entity_hash_buckets>1</ignored_entity_hash_buckets>
                    <content_filtered_topic_hash_buckets>1</content_filtered_topic_hash_buckets>
                    <content_filter_hash_buckets>1</content_filter_hash_buckets>
                    <flow_controller_hash_buckets>1</flow_controller_hash_buckets>
                    <max_gather_destinations>8</max_gather_destinations>
                    <participant_user_data_max_length>256</participant_user_data_max_length>
                    <topic_data_max_length>256</topic_data_max_length>
                    <publisher_group_data_max_length>256</publisher_group_data_max_length>
                    <subscriber_group_data_max_length>256</subscriber_group_data_max_length>
                    <writer_user_data_max_length>256</writer_user_data_max_length>
                    <reader_user_data_max_length>256</reader_user_data_max_length>
                    <max_partitions>64</max_partitions>
                    <max_partition_cumulative_characters>256</max_partition_cumulative_characters>
                    <type_code_max_serialized_length>2048</type_code_max_serialized_length>
                    <contentfilter_property_max_length>256</contentfilter_property_max_length>
                    <participant_property_list_max_length>32</participant_property_list_max_length>
                    <participant_property_string_max_length>1024</participant_property_string_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>
                    <channel_seq_max_length>32</channel_seq_max_length>
                    <channel_filter_expression_max_length>256</channel_filter_expression_max_length>
                </resource_limits>
                <event>
                    <thread>
                        <mask>STDIO | FLOATING_POINT</mask>
                        <priority>THREAD_PRIORITY_BELOW_NORMAL</priority>
                        <stack_size>THREAD_STACK_SIZE_DEFAULT</stack_size>
                    </thread>
                    <initial_count>256</initial_count>
                    <max_count>LENGTH_UNLIMITED</max_count>
                </event>
                <receiver_pool>
                    <thread>
                        <mask>STDIO | FLOATING_POINT</mask>
                        <priority>THREAD_PRIORITY_ABOVE_NORMAL</priority>
                        <stack_size>THREAD_STACK_SIZE_DEFAULT</stack_size>
                    </thread>
                    <buffer_size>9216</buffer_size>
                    <buffer_alignment>16</buffer_alignment>
                </receiver_pool>
                <database>
                    <thread>
                        <mask>STDIO</mask>
                        <priority>THREAD_PRIORITY_LOW</priority>
                        <stack_size>THREAD_STACK_SIZE_DEFAULT</stack_size>
                    </thread>
                    <shutdown_timeout>
                        <sec>15</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </shutdown_timeout>
                    <cleanup_period>
                        <sec>61</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </cleanup_period>
                    <shutdown_cleanup_period>
                        <sec>1</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </shutdown_cleanup_period>
                    <initial_records>1024</initial_records>
                    <max_skiplist_level>7</max_skiplist_level>
                    <max_weak_references>LENGTH_UNLIMITED</max_weak_references>
                    <initial_weak_references>2049</initial_weak_references>
                </database>
                <discovery_config>
                    <participant_liveliness_lease_duration>
                        <sec>100</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </participant_liveliness_lease_duration>
                    <participant_liveliness_assert_period>
                        <sec>30</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </participant_liveliness_assert_period>
                    <remote_participant_purge_kind>LIVELINESS_BASED_REMOTE_PARTICIPANT_PURGE</remote_participant_purge_kind>
                    <max_liveliness_loss_detection_period>
                        <sec>60</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </max_liveliness_loss_detection_period>
                    <initial_participant_announcements>5</initial_participant_announcements>
                    <min_initial_participant_announcement_period>
                        <sec>1</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </min_initial_participant_announcement_period>
                    <max_initial_participant_announcement_period>
                        <sec>1</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </max_initial_participant_announcement_period>
                    <participant_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>
                    </participant_reader_resource_limits>
                    <publication_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>
                    </publication_reader>
                    <publication_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>
                    </publication_reader_resource_limits>
                    <subscription_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>
                    </subscription_reader>
                    <subscription_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>
                    </subscription_reader_resource_limits>
                    <publication_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>
                    </publication_writer>
                    <publication_writer_data_lifecycle>
                        <autodispose_unregistered_instances>true</autodispose_unregistered_instances>
                        <autopurge_unregistered_instances_delay>
                            <sec>DURATION_INFINITE_SEC</sec>
                            <nanosec>DURATION_INFINITE_NSEC</nanosec>
                        </autopurge_unregistered_instances_delay>
                    </publication_writer_data_lifecycle>
                    <subscription_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>
                    </subscription_writer>
                    <subscription_writer_data_lifecycle>
                        <autodispose_unregistered_instances>true</autodispose_unregistered_instances>
                        <autopurge_unregistered_instances_delay>
                            <sec>DURATION_INFINITE_SEC</sec>
                            <nanosec>DURATION_INFINITE_NSEC</nanosec>
                        </autopurge_unregistered_instances_delay>
                    </subscription_writer_data_lifecycle>
                    <builtin_discovery_plugins>SDP</builtin_discovery_plugins>
                </discovery_config>
                <property>
                    <value>
                        <!-- ================= -->
                        <!-- 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>
                <participant_name>
                    <name>Simulink</name>
                </participant_name>                
            </participant_qos>
            <subscriber_qos>
                <presentation>
                    <access_scope>INSTANCE_PRESENTATION_QOS</access_scope>
                    <coherent_access>false</coherent_access>
                    <ordered_access>false</ordered_access>
                </presentation>
                <partition>
                    <name/>
                </partition>
                <group_data/>
                <entity_factory>
                    <autoenable_created_entities>true</autoenable_created_entities>
                </entity_factory>
                <exclusive_area>
                    <use_shared_exclusive_area>false</use_shared_exclusive_area>
                </exclusive_area>
            </subscriber_qos>
            <publisher_qos>
                <presentation>
                    <access_scope>INSTANCE_PRESENTATION_QOS</access_scope>
                    <coherent_access>false</coherent_access>
                    <ordered_access>false</ordered_access>
                </presentation>
                <partition>
                    <name/>
                </partition>
                <group_data/>
                <entity_factory>
                    <autoenable_created_entities>true</autoenable_created_entities>
                </entity_factory>
                <asynchronous_publisher>
                    <disable_asynchronous_write>false</disable_asynchronous_write>
                    <thread>
                        <mask>MASK_DEFAULT</mask>
                        <priority>THREAD_PRIORITY_DEFAULT</priority>
                        <stack_size>THREAD_STACK_SIZE_DEFAULT</stack_size>
                    </thread>
                    <disable_asynchronous_batch>false</disable_asynchronous_batch>
                    <asynchronous_batch_thread>
                        <mask>MASK_DEFAULT</mask>
                        <priority>THREAD_PRIORITY_DEFAULT</priority>
                        <stack_size>THREAD_STACK_SIZE_DEFAULT</stack_size>
                    </asynchronous_batch_thread>
                </asynchronous_publisher>
                <exclusive_area>
                    <use_shared_exclusive_area>false</use_shared_exclusive_area>
                </exclusive_area>
            </publisher_qos>
            <topic_qos>
                <topic_data>
                    <value/>
                </topic_data>
                <durability>
                    <kind>VOLATILE_DURABILITY_QOS</kind>
                    <direct_communication>true</direct_communication>
                </durability>
                <durability_service>
                    <service_cleanup_delay>
                        <sec>DURATION_ZERO_SEC</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </service_cleanup_delay>
                    <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>
                <deadline>
                    <period>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </period>
                </deadline>
                <latency_budget>
                    <duration>
                        <sec>DURATION_ZERO_SEC</sec>
                        <nanosec>DURATION_ZERO_NSEC</nanosec>
                    </duration>
                </latency_budget>
                <liveliness>
                    <kind>AUTOMATIC_LIVELINESS_QOS</kind>
                    <lease_duration>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </lease_duration>
                </liveliness>
                <reliability>
                    <kind>BEST_EFFORT_RELIABILITY_QOS</kind>
                    <max_blocking_time>
                        <sec>DURATION_ZERO_SEC</sec>
                        <nanosec>100000000</nanosec>
                    </max_blocking_time>
                </reliability>
                <destination_order>
                    <kind>BY_RECEPTION_TIMESTAMP_DESTINATIONORDER_QOS</kind>
                    <source_timestamp_tolerance>
                        <sec>30</sec>
                        <nanosec>0</nanosec>
                    </source_timestamp_tolerance>
                </destination_order>
                <history>
                    <kind>KEEP_LAST_HISTORY_QOS</kind>
                    <depth>1</depth>
                    <refilter>NONE_REFILTER_QOS</refilter>
                </history>
                <resource_limits>
                    <max_samples>LENGTH_UNLIMITED</max_samples>
                    <max_instances>LENGTH_UNLIMITED</max_instances>
                    <max_samples_per_instance>LENGTH_UNLIMITED</max_samples_per_instance>
                    <initial_samples>32</initial_samples>
                    <initial_instances>32</initial_instances>
                </resource_limits>
                <transport_priority>
                    <value>0</value>
                </transport_priority>
                <lifespan>
                    <duration>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </duration>
                </lifespan>
                <ownership>
                    <kind>SHARED_OWNERSHIP_QOS</kind>
                </ownership>
            </topic_qos>
        </qos_profile>
        <!--
        The HighThroughput profile is an extension of the Reliable profile.
        RTI Connext provides APIs for loading multiple QoS
        profile files at once, and referring from one to the other, but for
        the sake of simplicity, we duplicate the Reliable profile here. For
        more information about how it works, see the file reliable.xml.
        -->
        <qos_profile name="Reliable">
            <participant_qos>
                <resource_limits>
                    <!-- 935926.  
                             the following changes were required to get around a crash 
                             that for some reason began occuring in 2013a.  Same Sfuns 
                             ran fine in 12b. 
                        -->
                    <type_object_max_serialized_length>
                        0
                    </type_object_max_serialized_length>
                    <type_object_max_deserialized_length>
                        0
                    </type_object_max_deserialized_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>
                </resource_limits>
            </participant_qos>
            
            <datareader_qos>
                <reliability>
                    <kind>RELIABLE_RELIABILITY_QOS</kind>
                </reliability>
                <history>
                    <kind>KEEP_ALL_HISTORY_QOS</kind>
                </history>
                <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>
            
            <datawriter_qos>      
                <reliability>
                    <kind>RELIABLE_RELIABILITY_QOS</kind>
                    <max_blocking_time>
                        <sec>5</sec>
                        <nanosec>0</nanosec>
                    </max_blocking_time>
                </reliability>
                <history>
                    <kind>KEEP_ALL_HISTORY_QOS</kind>
                </history>
                <resource_limits>
                    <max_samples>32</max_samples>
                </resource_limits>
                <protocol>
                    <rtps_reliable_writer>
                        <low_watermark>5</low_watermark>
                        <high_watermark>15</high_watermark>
                        <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_heartbeat_retries>500</max_heartbeat_retries>
                        <min_nack_response_delay>
                            <sec>0</sec>
                            <nanosec>0</nanosec>
                        </min_nack_response_delay>
                        <max_nack_response_delay>
                            <sec>0</sec>
                            <nanosec>0</nanosec>
                        </max_nack_response_delay>
                        <min_send_window_size>32</min_send_window_size>
                        <max_send_window_size>32</max_send_window_size>
                    </rtps_reliable_writer>
                </protocol>
            </datawriter_qos>
        </qos_profile>
        
        <!--
        The HighThroughput profile extends the Reliable profile to perform
        additional, finer-grainer performance tuning specific to applications
        that send continuously streaming data. The parameters specified here
        add to and/or override the parameters specified in the Reliable
        profile.
        -->
        <qos_profile name="HighThroughput"
                     base_name="Reliable"
                     is_default_qos="true">
            <participant_qos>
                <resource_limits>
                    <!-- 935926.  
                             the following changes were required to get around a crash 
                             that for some reason began occuring in 2013a.  Same Sfuns 
                             ran fine in 12b. 
                        -->
                    <type_object_max_serialized_length>
                        0
                    </type_object_max_serialized_length>
                    <type_object_max_deserialized_length>
                        0
                    </type_object_max_deserialized_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>
                </resource_limits>
            </participant_qos>
            <datawriter_qos>
                <writer_resource_limits>
                    <!--
                    The number of batches (not samples) for which the
                    DataWriter will allocate space.

                    The initial_batches parameter is also set here, indicating
                    to the writer that it should pre-allocate all of the space
                    up front. Pre-allocation will remove memory allocattion
                    from the critical path of the application, improving
                    performance and determinism.

                    Finite resources are not required for strict reliability.
                    However, by limiting how far "ahead" of its readers a
                    writer is able to get, you can make the system more
                    robust and performant in the face of slow readers and/or
                    dropped packets while at the same time constraining your
                    memory growth.
                    -->
                    <max_batches>32</max_batches>
                    <initial_batches>32</initial_batches>
                </writer_resource_limits>
                
                <!--
                We're limiting resources based on the number of batches. We
                could limit resources on a per-sample basis too if we wanted
                to; we'd probably to set the value based on how many samples
                we expect to be in each batch. Rather than come up with a
                heuristic, however, it's more straightforward to override
                this value to leave the value unlimited. (If you were to set
                both, the first limit to be hit would take effect.)
                -->
                <resource_limits>
                    <max_samples>LENGTH_UNLIMITED</max_samples>
                </resource_limits>
                
                <protocol>
                    <rtps_reliable_writer>
                        <!--
                        Speed up the heartbeat rate. See reliable.xml for
                        more information about this parameter.
                        -->            
                        <heartbeat_period>
                            <!-- 10 milliseconds: -->
                            <sec>0</sec>
                            <nanosec>10000000</nanosec>
                        </heartbeat_period>
                        <!--
                        Speed up the heartbeat rate. See reliable.xml for
                        more information about this parameter.
                        -->
                        <fast_heartbeat_period>
                            <!-- 1 millisecond: -->
                            <sec>0</sec>
                            <nanosec>1000000</nanosec>
                        </fast_heartbeat_period>
                        <!--
                        Speed up the heartbeat rate. See reliable.xml for
                        more information about this parameter.
                        -->
                        <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. See
                        reliable.xml for more information about this parameter.
                        -->
                        <max_heartbeat_retries>1000</max_heartbeat_retries>
                        
                        <!--
                        Set the maximum number of unacknowedged samples 
                        (batches) in the DataWriter's queue equal to the max 
                        number of batches.  
                        -->
                        <min_send_window_size>32</min_send_window_size>
                        <max_send_window_size>32</max_send_window_size>
                        
                    </rtps_reliable_writer>
                </protocol>
                
                <!--
                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.
                    -->
                    <max_data_bytes>30720</max_data_bytes><!-- 30 KB -->
                    <max_samples>LENGTH_UNLIMITED</max_samples>
                    
                    <!--
                    Batches can be flushed to the network based on an elapsed
                    time.
                    -->
                    <max_flush_delay>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </max_flush_delay>
                    
                    <!--
                    The middleware will associate a source timestamp with a
                    batch when it is started. The duration below indicates
                    the amount of time that may pass before the middleware
                    will insert an additional timestamp into the middle of an
                    existing batch.
        
                    Shortening this duration can give readers increased
                    timestamp resolution if they require that. However,
                    lengthening this duration decreases the amount of
                    meta-data on the network, potentially improving
                    throughput, especially if the data samples are very small.
                    If this delay is set to an infinite time period,
                    timestamps will be inserted only once per batch, and
                    furthermore the middleware will not need to check the
                    time with each sample in the batch, reducing the amount
                    of computation on the send path and potentially improving
                    both latency and throughput performance.
                    -->
                    <source_timestamp_resolution>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </source_timestamp_resolution>
                </batch>        
            </datawriter_qos>
            
            <participant_qos>
                <!--
                The participant name, if it is set, will be displayed in the
                RTI Analyzer tool, making it easier for you to tell one
                application from another when you're debugging.
                -->
                <participant_name>
                    <name>RTI Example (High Throughput)</name>
                </participant_name>
                
                <receiver_pool>
                    <!--
                    The maximum size of a datagram that can be deserialized,
                    independent of the network transport. By default, this
                    value is 9 KB, since that is a common default maximum
                    size for UDP datagrams on some platforms. However, on
                    platforms that support larger datagrams - up to 64 KB -
                    it's a good idea to increase this limit for demanding
                    applications to avoid socket read errors.
                    -->
                    <buffer_size>65536</buffer_size><!-- 64 KB -->
                </receiver_pool>
                
                <property>
                    <value>
                        <!--
                        Configure UDPv4 transport:
                        -->
                        <element>
                            <!--
                            On platforms that support it, increase the maximum
                            size of a UDP datagram to the maximum supported by
                            the protocol: 64 KB. That will allow you to send
                            the large packets that can result when you batch
                            samples.
                            -->
                            <name>dds.transport.UDPv4.builtin.parent.message_size_max</name>
                            <value>65536</value><!-- 64 KB -->
                        </element>
                        <element>
                            <!--
                            If possible, increase the UDP send socket buffer
                            size. This will allow you to send multiple large
                            packets without UDP send errors.

                            On some platforms (e.g. Linux), this value is
                            limited by a system-wide policy. Setting it to
                            a larger value will fail silently; the value will
                            be set to the maximum allowed by that policy.
                            -->
                            <name>dds.transport.UDPv4.builtin.send_socket_buffer_size</name>
                            <value>524288</value><!-- 512 KB -->
                        </element>
                        <element>
                            <!--
                            If possible, increase the UDP receive socket
                            buffer size. This will allow you to receive
                            multiple large packets without UDP receive errors.

                            On some platforms (e.g. Linux), this value is
                            limited by a system-wide policy. Setting it to
                            a larger value will fail silently; the value will
                            be set to the maximum allowed by that policy.
                            -->
                            <name>dds.transport.UDPv4.builtin.recv_socket_buffer_size</name>
                            <value>2097152</value><!-- 2 MB -->
                        </element>
                        
                        <!--
                        Configure shared memory transport:
                        -->
                        <element>
                            <!--
                            Set the shared memory maximum message size to the
                            same value that was set for UDP.
                            -->
                            <name>dds.transport.shmem.builtin.parent.message_size_max</name>
                            <value>65536</value><!-- 64 KB -->
                        </element>
                        <element>
                            <!--
                            Set the size of the shared memory transport's
                            receive buffer to some large value.
                            -->
                            <name>dds.transport.shmem.builtin.receive_buffer_size</name>
                            <value>2097152</value><!-- 2 MB -->
                        </element>
                        <element>
                            <!--
                            Set the maximum number of messages that the shared
                            memory transport can cache while waiting for them
                            to be read and deserialized.
                            -->
                            <name>dds.transport.shmem.builtin.received_message_count_max</name>
                            <value>2048</value>
                        </element>
                        
                        <!--
                        Increase the size of the string built-in size. This
                        configuration is only necessary for applications that
                        use the built-in types (such as Hello_builtin).
                        -->
                        <element>
                            <name>dds.builtin_type.string.max_size</name>
                            <value>2048</value>
                        </element>
                    </value>
                </property> 
            </participant_qos>
        </qos_profile>
    </qos_library>
    <qos_library name="dim_nu_obs_value_Library">

        <!-- QoS profile used to configure reliable communication between the DataWriter 
             and DataReader created in the example code.

             A QoS profile groups a set of related QoS.
        -->
        <qos_profile name="dim_nu_obs_value_Profile" is_default_qos="true">
            <!-- QoS used to configure the data writer created in the example code -->                
            <datawriter_qos>
                <reliability>
                    <kind>RELIABLE_RELIABILITY_QOS</kind>
                    <max_blocking_time>
                        <sec>60</sec>
                    </max_blocking_time>
                </reliability>                

                <history>
                    <kind>KEEP_ALL_HISTORY_QOS</kind>
                </history>

                <protocol>
                    <rtps_reliable_writer>
                        <min_send_window_size>50</min_send_window_size>
                        <max_send_window_size>50</max_send_window_size>
                    </rtps_reliable_writer>
                </protocol>
		
            </datawriter_qos>

            <!-- QoS used to configure the data reader created in the example code -->                
            <datareader_qos>

                <reliability>
                    <kind>RELIABLE_RELIABILITY_QOS</kind>
                </reliability>
    
                <history>
                    <kind>KEEP_ALL_HISTORY_QOS</kind>
                </history>
			
            </datareader_qos>

            <participant_qos>
                <!--
                The participant name, if it is set, will be displayed in the
                RTI Analyzer tool, making it easier for you to tell one
                application from another when you're debugging.
                -->
                <participant_name>
                    <name>RTI "Hello, World" Example</name>
                </participant_name>
                <!-- increase total property string max length -->
                <resource_limits>
                    <participant_property_string_max_length>
                        2048
                    </participant_property_string_max_length>
                    <!-- 935926.  
                 the following changes were required to get around a crash 
                 that for some reason began occuring in R2013a.  Same Sfuns 
                 ran fine in R2012b. 
                 5/24/2013 debugging sessionn with Ferndando at RTI confirmed that this is a RTI bug.
                 64 bit address is being cast to 32 bit.  Causes crash when address > 32 bits. 
            -->
                    <type_object_max_deserialized_length>
                        0
                    </type_object_max_deserialized_length>
                    <deserialized_type_object_dynamic_allocation_threshold>
                        0
                    </deserialized_type_object_dynamic_allocation_threshold>
            
                    <type_object_max_serialized_length>
                        0
                    </type_object_max_serialized_length>
                    <serialized_type_object_dynamic_allocation_threshold>
                        0
                    </serialized_type_object_dynamic_allocation_threshold>
                   
                    
                </resource_limits>

            </participant_qos>
        </qos_profile>
        
    </qos_library>
    <qos_library name="MathWorksQoSLibrary">
        <qos_profile name="MicroDDS">
            <participant_qos>
                <participant_name>
                    <name>Interact with RTI Micro DDS participant</name>
                </participant_name> 
                
                <!-- increase total property string max length -->
                <resource_limits>
                    <participant_property_string_max_length>
                        2048
                    </participant_property_string_max_length>
                    <!-- 935926.  
                 the following changes were required to get around a crash 
                 that for some reason began occuring in R2013a.  Same Sfuns 
                 ran fine in R2012b. 
                 5/24/2013 debugging sessionn with Ferndando at RTI confirmed that this is a RTI bug.
                 64 bit address is being cast to 32 bit.  Causes crash when address > 32 bits. 
            -->
                    <type_object_max_deserialized_length>
                        0
                    </type_object_max_deserialized_length>
                    <deserialized_type_object_dynamic_allocation_threshold>
                        0
                    </deserialized_type_object_dynamic_allocation_threshold>
            
                    <type_object_max_serialized_length>
                        0
                    </type_object_max_serialized_length>
                    <serialized_type_object_dynamic_allocation_threshold>
                        0
                    </serialized_type_object_dynamic_allocation_threshold>
                </resource_limits>                              
            </participant_qos>
            <datareader_qos>
                <liveliness>
                    <kind>MANUAL_BY_TOPIC_LIVELINESS_QOS</kind>
                    <lease_duration>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </lease_duration>
                </liveliness>
            </datareader_qos>              
            <datawriter_qos>
                <liveliness>
                    <kind>MANUAL_BY_TOPIC_LIVELINESS_QOS</kind>
                    <lease_duration>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </lease_duration>
                </liveliness>
            </datawriter_qos>              
            <topic_qos>
                <liveliness>
                    <kind>MANUAL_BY_TOPIC_LIVELINESS_QOS</kind>
                    <lease_duration>
                        <sec>DURATION_INFINITE_SEC</sec>
                        <nanosec>DURATION_INFINITE_NSEC</nanosec>
                    </lease_duration>
                </liveliness>
            </topic_qos>              
        </qos_profile>

    </qos_library>
    <!-- End of Qos Library -->
</dds>
