- RTI Connext Micro C API Version 4.3.0 Copyright © Thu May 28 2026
|
RTI Connext Micro C API Version 4.3.0
|
<<cert>> Resource limits that apply only to DDS_DataReader instances. More...
#include <dds_c_infrastructure.h>
Data Fields | |
| DDS_Long | max_remote_writers |
| The maximum number of remote writers for which the reader will maintain state and communication. | |
| DDS_Long | max_remote_writers_per_instance |
| The maximum number of remote writers for a unique instance for which the reader will maintain state and communication. | |
| DDS_Long | max_samples_per_remote_writer |
| The maximum number of untaken samples from a given remote DDS_DataWriter that a DDS_DataReader may store. | |
| DDS_Long | max_outstanding_reads |
| The maximum number of outstanding read or take calls, or one of their variants, on the same DDS_DataReader for which the memory has not been returned by calling FooDataReader_return_loan. | |
| DDS_DataReaderResourceLimitsInstanceReplacementKind | instance_replacement |
| The instance replacement policy when the DDS_ResourceLimitsQosPolicy::max_instances limit has been reached and a new instance is detected. | |
| DDS_Long | max_routes_per_writer |
| The maximum number of routes the reader will send to per matched writer. | |
| DDS_Long | max_fragmented_samples |
| The maximum number of samples for which the built-in topic DDS_DataReader may store fragments at a given point in time. | |
| DDS_Long | max_fragmented_samples_per_remote_writer |
| The maximum number of samples per remote writer for which a DDS_DataReader may store fragments. | |
| DDS_Long | shmem_ref_transfer_mode_attached_segment_allocation |
| Number of shared memory segments a Zero Copy transfer over shared memory DDS_DataReader can attach to at any given time. | |
<<cert>> Resource limits that apply only to DDS_DataReader instances.
This QoS policy is an extension to the DDS standard.
| DDS_Long DDS_DataReaderResourceLimitsQosPolicy::max_remote_writers |
The maximum number of remote writers for which the reader will maintain state and communication.
The DDS_DataReaderResourceLimitsQosPolicy::max_remote_writers resource-limit limits the maximum number of remote DDS_DataWriter entities that the DDS_DataReader can receive data from regardless of which instance it is.
Resources controlled by this limit can only be reused when a remote DDS_DataWriter is either deleted or loses liveliness. [default] 1
[range] [1, 1000000], >= max_remote_writers_per_instance
| DDS_Long DDS_DataReaderResourceLimitsQosPolicy::max_remote_writers_per_instance |
The maximum number of remote writers for a unique instance for which the reader will maintain state and communication.
The DDS_DataReaderResourceLimitsQosPolicy::max_remote_writers_per_instance limits the maximum number of remote DDS_DataWriter entities a DDS_DataReader maintains state for per instance. If this resource-limit is lower than the actual number of remote DDS_DataWriter entities updating an instance, only state for up to DDS_DataReaderResourceLimitsQosPolicy::max_remote_writers_per_instance is maintained. It is not guaranteed to be the last DDS_DataReaderResourceLimitsQosPolicy::max_remote_writers_per_instance though. However, the last remote DDS_DataWriter to update an instance is always saved. When an instance is no longer updated by a DDS_DataWriter known to the DDS_DataReader, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE state is signaled on the DDS_DataReader. Thus, if this resource-limit is lower than the actual number of remote DDS_DataWriter entities updating an instance, DDS_NOT_ALIVE_NO_WRITERS_INSTANCE_STATE may be signaled even though there may be one or more DDS_DataWriter entities still updating an instance. In this case the instance will go back to the DDS_ALIVE_INSTANCE_STATE.
[default] 1
[range] [1, 2147483647], <= max_remote_writers
| DDS_Long DDS_DataReaderResourceLimitsQosPolicy::max_samples_per_remote_writer |
The maximum number of untaken samples from a given remote DDS_DataWriter that a DDS_DataReader may store.
This resource-limit limits the maximum number of samples that can be cached for each remote DDS_DataWriter that the DDS_DataReader is receiving data from. This resource-limit is useful in preventing one DDS_DataWriter from starving another DDS_DataWriter. NOTE: The samples cached from a DDS_DataWriter are allocated from the same sample pool controlled by DDS_ResourceLimitsQosPolicy::max_samples.
[default] 1
[range] [1, 100000000], <= DDS_ResourceLimitsQosPolicy::max_samples
| DDS_Long DDS_DataReaderResourceLimitsQosPolicy::max_outstanding_reads |
The maximum number of outstanding read or take calls, or one of their variants, on the same DDS_DataReader for which the memory has not been returned by calling FooDataReader_return_loan.
The DDS_DataReaderResourceLimitsQosPolicy::max_outstanding_reads resource-limit limits the maximum number of simultaneous loans an application can make at any given time using the FooDataReader_read() and FooDataReader_take() APIs.
Typically a value of 1 is sufficient. It is only necessary to increase this value if an application thread will access the same cache before another thread has returned the loan.
[default] 1
[range] [1, 2147483647]
| DDS_DataReaderResourceLimitsInstanceReplacementKind DDS_DataReaderResourceLimitsQosPolicy::instance_replacement |
The instance replacement policy when the DDS_ResourceLimitsQosPolicy::max_instances limit has been reached and a new instance is detected.
[default] DDS_NO_INSTANCE_REPLACEMENT_QOS
| DDS_Long DDS_DataReaderResourceLimitsQosPolicy::max_routes_per_writer |
The maximum number of routes the reader will send to per matched writer.
Each DDS_DataReader maintains information about the state of its peer DDS_DataWriter, those it has matched with. Part of this state is which locators, or destination addresses, it should use to send data to a particular DDS_DataWriter. The DDS_DataReaderResourceLimitsQosPolicy::max_routes_per_writer resource-limit limits the maximum number of routes that can be saved per DDS_DataWriter.
This resource-limit is shared across all matched DDS_DataWriter entities per DDS_DataReader. Thus, if DDS_DataReaderResourceLimitsQosPolicy::max_remote_writers is 2 and DDS_DataReaderResourceLimitsQosPolicy::max_routes_per_writer is 4, a total of 8 routes can be saved for both DDS_DataWriter entities. One DDS_DataWriter entity may have 6 routes and the other 2.
[default] 4
[range] [1, 2000]
| DDS_Long DDS_DataReaderResourceLimitsQosPolicy::max_fragmented_samples |
The maximum number of samples for which the built-in topic DDS_DataReader may store fragments at a given point in time.
At any given time, a built-in topic DDS_DataReader may store fragments for up to max_fragmented_samples samples while waiting for the remaining fragments. These samples need not have consecutive sequence numbers and may have been sent by different built-in topic DDS_DataWriter instances.
Once all fragments of a sample have been received, the sample is treated as a regular sample and becomes subject to standard QoS settings such as DDS_ResourceLimitsQosPolicy::max_samples.
The middleware will drop fragments if the max_fragmented_samples limit has been reached. For best-effort communication, the middleware will accept a fragment for a new sample, but drop the oldest fragmented sample from the same remote writer. For reliable communication, the middleware will not drop fragments for any new samples until all fragments have been received.
| DDS_Long DDS_DataReaderResourceLimitsQosPolicy::max_fragmented_samples_per_remote_writer |
The maximum number of samples per remote writer for which a DDS_DataReader may store fragments.
Logical limit so a single remote writer cannot consume all available resources.
[default] 256
[range] [1, 1 million], <= max_fragmented_samples
| DDS_Long DDS_DataReaderResourceLimitsQosPolicy::shmem_ref_transfer_mode_attached_segment_allocation |
Number of shared memory segments a Zero Copy transfer over shared memory DDS_DataReader can attach to at any given time.
The max_count does not limit the total number of shared memory segments used by the DDS_DataReader. When this limit is hit, the DDS_DataReader will try to detach from a segment that doesn't contain any loaned samples and attach to a new segment. If samples are loaned from all attached segments, then the DDS_DataReader will fail to attach to the new segment. This scenario will result in the sample being rejected.
[default] DDS_DataReaderResourceLimitsQosPolicy::max_remote_writers [range] [0, 1000000]