DDS::RtpsReliableReaderProtocol_t Struct Reference

Qos related to reliable reader protocol defined in RTPS. More...

#include <managed_infrastructure.h>

Public Attributes
Duration_t	min_heartbeat_response_delay
	The minimum delay to respond to a heartbeat.
Duration_t	max_heartbeat_response_delay
	The maximum delay to respond to a heartbeat.
Duration_t	heartbeat_suppression_duration
	The duration a reader ignores consecutively received heartbeats.
Duration_t	nack_period
	The period at which to send NACKs.
System::Int32	receive_window_size
	The number of received out-of-order samples a reader can keep at a time.
Duration_t	round_trip_time
	The duration from sending a NACK to receiving a repair of a sample.
Duration_t	app_ack_period
	The period at which application-level acknowledgment messages are sent.
Duration_t	min_app_ack_response_keep_duration
	Minimum duration for which application-level acknowledgment response data is kept.

Detailed Description

Qos related to reliable reader protocol defined in RTPS.

It is used to config reliable reader according to RTPS protocol.

Properties:

RxO = N/A
Changeable = NO

QoS:

DDS::DataReaderProtocolQosPolicy DDS::DiscoveryConfigQosPolicy

Member Data Documentation

Duration_t DDS::RtpsReliableReaderProtocol_t::min_heartbeat_response_delay

The minimum delay to respond to a heartbeat.

When a reliable reader receives a heartbeat from a remote writer and finds out that it needs to send back an ACK/NACK message, the reader can choose to delay a while. This sets the value of the minimum delay.

[default] 0 seconds

[range] [0, 1 year], <= max_heartbeat_response_delay

Duration_t DDS::RtpsReliableReaderProtocol_t::max_heartbeat_response_delay

The maximum delay to respond to a heartbeat.

When a reliable reader receives a heartbeat from a remote writer and finds out that it needs to send back an ACK/NACK message, the reader can choose to delay a while. This sets the value of maximum delay.

[default] The default value depends on the container policy:

For DDS::DiscoveryConfigQosPolicy : 0 seconds
For DDS::DataReaderProtocolQosPolicy : 0.5 seconds

[range] [0, 1 year], >= min_heartbeat_response_delay

Duration_t DDS::RtpsReliableReaderProtocol_t::heartbeat_suppression_duration

The duration a reader ignores consecutively received heartbeats.

When a reliable reader receives consecutive heartbeats within a short duration that will trigger redundant NACKs, the reader may ignore the latter heartbeat(s). This sets the duration during which additionally received heartbeats are suppressed.

[default] 0.0625 seconds

[range] [0, 1 year],

Duration_t DDS::RtpsReliableReaderProtocol_t::nack_period

The period at which to send NACKs.

A reliable reader will send periodic NACKs at this rate when it first matches with a reliable writer. The reader will stop sending NACKs when it has received all available historical data from the writer.

[default] 5 seconds

[range] [1 nanosec, 1 year]

System::Int32 DDS::RtpsReliableReaderProtocol_t::receive_window_size

The number of received out-of-order samples a reader can keep at a time.

A reliable reader stores the out-of-order samples it receives until it can present them to the application in-order. The receive window is the maximum number of out-of-order samples that a reliable reader keeps at a given time. When the receive window is full, subsequently received out-of-order samples are dropped.

[default] 256

[range] [>= 1]

Duration_t DDS::RtpsReliableReaderProtocol_t::round_trip_time

The duration from sending a NACK to receiving a repair of a sample.

This round-trip time is an estimate of the time starting from when the reader sends a NACK for a specific sample to when it receives that sample. For each sample, the reader will not send a subsequent NACK for it until the round-trip time has passed, thus preventing inefficient redundant requests.

[default] 0 seconds

[range] [0 nanosec, 1 year]

Duration_t DDS::RtpsReliableReaderProtocol_t::app_ack_period

The period at which application-level acknowledgment messages are sent.

A DDS::DataReader sends application-level acknowledgment messages to a DDS::DataWriter at this periodic rate, and will continue sending until it receives a message from the DDS::DataWriter that it has received and processed the acknowledgment and an AppAckConfirmation has been received by the DDS::DataReader. Note: application-level acknowledgment messages can also be sent non-periodically, as determined by ::DDS::RtpsReliableReaderProtocol_t::samples_per_app_ack.

[default] 5 seconds

[range] [1 nanosec, 1 year]

Duration_t DDS::RtpsReliableReaderProtocol_t::min_app_ack_response_keep_duration

Minimum duration for which application-level acknowledgment response data is kept.

The user-specified response data of an explicit application-level acknowledgment (called by DDS::DataReader::acknowledge_sample or DDS::DataReader::acknowledge_all) is cached by the DDS::DataReader for the purpose of reliably resending the data with the acknowledgment message. After this duration has passed from the time of the first acknowledgment, the response data is dropped from the cache and will not be resent with future acknowledgments for the corresponding sample(s).

[default] 0 sec

[range] [0 sec, 1 year]