RTI Connext Modern C++ API  Version 6.1.0
rti::core::policy::RtpsReliableWriterProtocol Class Reference

<<extension>> Configures aspects of an RTPS reliable writer More...

#include <rti/core/policy/CorePolicy.hpp>

Public Member Functions

 RtpsReliableWriterProtocol ()
 Creates an instance with the default settings. More...
 
RtpsReliableWriterProtocollow_watermark (int32_t the_low_watermark)
 When the number of unacknowledged samples in the current send window of a reliable writer meets or falls below this threshold, the dds::core::status::StatusMask::reliable_writer_cache_changed() is considered to have changed. More...
 
int32_t low_watermark () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolhigh_watermark (int32_t the_high_watermark)
 When the number of unacknowledged samples in the current send window of a reliable writer meets or exceeds this threshold, the dds::core::status::StatusMask::reliable_writer_cache_changed() is considered to have changed. More...
 
int32_t high_watermark () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolheartbeat_period (const dds::core::Duration &the_heartbeat_period)
 The period at which to send heartbeats. More...
 
dds::core::Duration heartbeat_period () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolfast_heartbeat_period (const dds::core::Duration &the_fast_heartbeat_period)
 An alternative heartbeat period used when a reliable writer needs to flush its unacknowledged samples more quickly. More...
 
dds::core::Duration fast_heartbeat_period () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocollate_joiner_heartbeat_period (const dds::core::Duration &the_late_joiner_heartbeat_period)
 An alternative heartbeat period used when a reliable reader joins late and needs to be caught up on cached samples of a reliable writer more quickly than the normal heartbeat rate. More...
 
dds::core::Duration late_joiner_heartbeat_period () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolvirtual_heartbeat_period (const dds::core::Duration &the_virtual_heartbeat_period)
 The period at which to send virtual heartbeats. Virtual heartbeats inform the reliable reader about the range of samples currently present, for each virtual GUID, in the reliable writer's queue. More...
 
RtpsReliableWriterProtocolsamples_per_virtual_heartbeat (int32_t the_samples_per_virtual_heartbeat)
 The number of samples that a reliable writer has to publish before sending a virtual heartbeat. More...
 
int32_t samples_per_virtual_heartbeat () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolmax_heartbeat_retries (int32_t the_max_heartbeat_retries)
 The maximum number of periodic heartbeat retries before marking a remote reader as inactive. More...
 
int32_t max_heartbeat_retries () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolinactivate_nonprogressing_readers (bool the_inactivate_nonprogressing_readers)
 Whether to treat remote readers as inactive when their NACKs do not progress. More...
 
bool inactivate_nonprogressing_readers () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolheartbeats_per_max_samples (int32_t the_heartbeats_per_max_samples)
 The number of heartbeats per current send window. More...
 
int32_t heartbeats_per_max_samples () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolmin_nack_response_delay (const dds::core::Duration &the_min_nack_response_delay)
 The minimum delay to respond to a NACK. More...
 
dds::core::Duration min_nack_response_delay () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolmax_nack_response_delay (const dds::core::Duration &the_max_nack_response_delay)
 The maximum delay to respond to a nack. More...
 
dds::core::Duration max_nack_response_delay () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolnack_suppression_duration (const dds::core::Duration &the_nack_suppression_duration)
 The duration for ignoring consecutive NACKs that may trigger redundant repairs. More...
 
dds::core::Duration nack_suppression_duration () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolmax_bytes_per_nack_response (int32_t the_max_bytes_per_nack_response)
 The maximum total message size when resending rejected samples. More...
 
int32_t max_bytes_per_nack_response () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocoldisable_positive_acks_min_sample_keep_duration (const dds::core::Duration &duration)
 The minimum duration a sample is queued for ACK-disabled readers. More...
 
dds::core::Duration disable_positive_acks_min_sample_keep_duration () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocoldisable_positive_acks_max_sample_keep_duration (const dds::core::Duration &duration)
 The maximum duration a sample is queued for ACK-disabled readers. More...
 
dds::core::Duration disable_positive_acks_max_sample_keep_duration () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocoldisable_positive_acks_enable_adaptive_sample_keep_duration (bool disable)
 Enables dynamic adjustment of sample keep duration in response to congestion. More...
 
bool disable_positive_acks_enable_adaptive_sample_keep_duration () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocoldisable_positive_acks_decrease_sample_keep_duration_factor (int32_t factor)
 Controls rate of contraction of dynamic sample keep duration. More...
 
int32_t disable_positive_acks_decrease_sample_keep_duration_factor () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocoldisable_positive_acks_increase_sample_keep_duration_factor (int32_t factor)
 Controls rate of growth of dynamic sample keep duration. More...
 
int32_t disable_positive_acks_increase_sample_keep_duration_factor () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolmin_send_window_size (int32_t the_min_send_window_size)
 Minimum size of send window of unacknowledged samples. More...
 
int32_t min_send_window_size () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolmax_send_window_size (int32_t the_max_send_window_size)
 Maximum size of send window of unacknowledged samples. More...
 
int32_t max_send_window_size () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolsend_window_update_period (const dds::core::Duration &the_send_window_update_period)
 Period in which send window may be dynamically changed. More...
 
dds::core::Duration send_window_update_period () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolsend_window_increase_factor (int32_t the_send_window_increase_factor)
 Increases send window size by this percentage when reacting dynamically to network conditions. More...
 
int32_t send_window_increase_factor () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolsend_window_decrease_factor (int32_t the_send_window_decrease_factor)
 Decreases send window size by this percentage when reacting dynamically to network conditions. More...
 
int32_t send_window_decrease_factor () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolenable_multicast_periodic_heartbeat (bool the_enable_multicast_periodic_heartbeat)
 Whether periodic heartbeat messages are sent over multicast. More...
 
bool enable_multicast_periodic_heartbeat () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocolmulticast_resend_threshold (int32_t the_multicast_resend_threshold)
 The minimum number of requesting readers needed to trigger a multicast resend. More...
 
int32_t multicast_resend_threshold () const
 Getter (see setter with the same name) More...
 
RtpsReliableWriterProtocoldisable_repair_piggyback_heartbeat (bool the_disable_repair_piggyback_heartbeat)
 Prevents piggyback heartbeats from being sent with repair samples. More...
 
bool disable_repair_piggyback_heartbeat () const
 Getter (see setter with the same name) More...
 

Detailed Description

<<extension>> Configures aspects of an RTPS reliable writer

It is used to configure a reliable writer according to RTPS protocol.

The reliability protocol settings are applied to batches instead of individual data samples when batching is enabled.

Properties:
RxO = N/A
Changeable = NO
QoS:
rti::core::policy::DataWriterProtocol rti::core::policy::DiscoveryConfig

Constructor & Destructor Documentation

◆ RtpsReliableWriterProtocol()

rti::core::policy::RtpsReliableWriterProtocol::RtpsReliableWriterProtocol ( )
inline

Creates an instance with the default settings.

Member Function Documentation

◆ low_watermark() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::low_watermark ( int32_t  the_low_watermark)

When the number of unacknowledged samples in the current send window of a reliable writer meets or falls below this threshold, the dds::core::status::StatusMask::reliable_writer_cache_changed() is considered to have changed.

This value is measured in units of samples, except with batching configurations where it is measured in units of batches.

The value must be greater than or equal to zero and strictly less than high_watermark.

The high and low watermarks are used for switching between the regular and fast heartbeat rates (rti::core::RtpsReliableWriterProtocol::heartbeat_period and rti::core::RtpsReliableWriterProtocol::fast_heartbeat_period, respectively). When the number of unacknowledged samples in the queue of a reliable dds::pub::DataWriter meets or exceeds high_watermark, the dds::core::status::StatusMask::reliable_writer_cache_changed() is changed, and the DataWriter will start heartbeating at rti::core::RtpsReliableWriterProtocol::fast_heartbeat_period. When the number of samples meets or falls below low_watermark, dds::core::status::StatusMask::reliable_writer_cache_changed() is changed, and the heartbeat rate will return to the "normal" rate (rti::core::RtpsReliableWriterProtocol::heartbeat_period).

[default] 0

[range] [0, 100 million], < high_watermark

◆ low_watermark() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::low_watermark ( ) const

Getter (see setter with the same name)

◆ high_watermark() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::high_watermark ( int32_t  the_high_watermark)

When the number of unacknowledged samples in the current send window of a reliable writer meets or exceeds this threshold, the dds::core::status::StatusMask::reliable_writer_cache_changed() is considered to have changed.

This value is measured in units of samples, except with batching configurations where it is measured in units of batches.

The value must be strictly greater than low_watermark and less than or equal to a maximum that depends on the container QoS policy:

In dds::domain::qos::DomainParticipantQos::discovery_config:

For rti::core::policy::DiscoveryConfig::publication_writer
high_watermark<= rti::core::AllocationSettings::max_count in rti::core::policy::DomainParticipantResourceLimits::local_writer_allocation

For rti::core::policy::DiscoveryConfig::subscription_writer
high_watermark<= rti::core::AllocationSettings::max_count in rti::core::policy::DomainParticipantResourceLimits::local_reader_allocation

In rti::core::policy::DataWriterProtocol:

For rti::core::policy::DataWriterProtocol::rtps_reliable_writer,

high_watermark<=dds::core::policy::ResourceLimits::max_samples if batching is disabled. Otherwise,
high_watermark<=rti::core::policy::DataWriterResourceLimits::max_batches high_watermark<=rti::core::RtpsReliableWriterProtocol::max_send_window_size

[default] 1

[range] [1, 100 million] or dds::core::LENGTH_UNLIMITED, > low_watermark <= maximum which depends on the container policy

◆ high_watermark() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::high_watermark ( ) const

Getter (see setter with the same name)

◆ heartbeat_period() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::heartbeat_period ( const dds::core::Duration the_heartbeat_period)

The period at which to send heartbeats.

A reliable writer will send periodic heartbeats at this rate.

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

[range] [1 nanosec,1 year], >= rti::core::RtpsReliableWriterProtocol::fast_heartbeat_period, >= rti::core::RtpsReliableWriterProtocol::late_joiner_heartbeat_period

◆ heartbeat_period() [2/2]

dds::core::Duration rti::core::policy::RtpsReliableWriterProtocol::heartbeat_period ( ) const

Getter (see setter with the same name)

◆ fast_heartbeat_period() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::fast_heartbeat_period ( const dds::core::Duration the_fast_heartbeat_period)

An alternative heartbeat period used when a reliable writer needs to flush its unacknowledged samples more quickly.

This heartbeat period will be used when the number of unacknowledged samples in the cache of a reliable writer meets or exceeds the writer's high watermark and has not subsequently dropped to the low watermark. The normal period will be used at all other times.

This period must not be slower (i.e. must be of the same or shorter duration) than the normal heartbeat period.

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

[range] [1 nanosec,1 year], <= rti::core::RtpsReliableWriterProtocol::heartbeat_period

◆ fast_heartbeat_period() [2/2]

dds::core::Duration rti::core::policy::RtpsReliableWriterProtocol::fast_heartbeat_period ( ) const

Getter (see setter with the same name)

◆ late_joiner_heartbeat_period() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::late_joiner_heartbeat_period ( const dds::core::Duration the_late_joiner_heartbeat_period)

An alternative heartbeat period used when a reliable reader joins late and needs to be caught up on cached samples of a reliable writer more quickly than the normal heartbeat rate.

This heartbeat period will be used when a reliable reader joins after a reliable writer with non-volatile durability has begun publishing samples. Once the reliable reader has received all cached samples, it will be serviced at the same rate as other reliable readers.

This period must not be slower (i.e., must be of the same or shorter duration) than the normal heartbeat period.

A reliable writer will use whichever heartbeat period is faster, the current heartbeat period being used for other reliable readers or the rti::core::RtpsReliableWriterProtocol::late_joiner_heartbeat_period, to service the late joining reader. This means that if the rti::core::RtpsReliableWriterProtocol::fast_heartbeat_period is currently being used and is faster than the late_joiner_heartbeat_period, then the fast_heartbeat_period will continue to be used for the late joiner as well.

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

[range] [1 nanosec,1 year], <= rti::core::RtpsReliableWriterProtocol::heartbeat_period

◆ late_joiner_heartbeat_period() [2/2]

dds::core::Duration rti::core::policy::RtpsReliableWriterProtocol::late_joiner_heartbeat_period ( ) const

Getter (see setter with the same name)

◆ virtual_heartbeat_period()

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::virtual_heartbeat_period ( const dds::core::Duration the_virtual_heartbeat_period)

The period at which to send virtual heartbeats. Virtual heartbeats inform the reliable reader about the range of samples currently present, for each virtual GUID, in the reliable writer's queue.

A reliable writer will send periodic virtual heartbeats at this rate.

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

[range] > 1 nanosec, dds::core::Duration::infinite(), or dds::core::Duration::automatic()

◆ samples_per_virtual_heartbeat() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::samples_per_virtual_heartbeat ( int32_t  the_samples_per_virtual_heartbeat)

The number of samples that a reliable writer has to publish before sending a virtual heartbeat.

[default] dds::core::LENGTH_UNLIMITED

[range] [1,1000000], dds::core::LENGTH_UNLIMITED

◆ samples_per_virtual_heartbeat() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::samples_per_virtual_heartbeat ( ) const

Getter (see setter with the same name)

◆ max_heartbeat_retries() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::max_heartbeat_retries ( int32_t  the_max_heartbeat_retries)

The maximum number of periodic heartbeat retries before marking a remote reader as inactive.

When a remote reader has not acked all the samples the reliable writer has in its queue, and max_heartbeat_retries number of periodic heartbeats has been sent without receiving any ack/nack back, the remote reader will be marked as inactive (not alive) and be ignored until it resumes sending ack/nack.

Note that piggyback heartbeats do NOT count towards this value.

[default] 10

[range] [1, 1 million] or dds::core::LENGTH_UNLIMITED

◆ max_heartbeat_retries() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::max_heartbeat_retries ( ) const

Getter (see setter with the same name)

◆ inactivate_nonprogressing_readers() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::inactivate_nonprogressing_readers ( bool  the_inactivate_nonprogressing_readers)

Whether to treat remote readers as inactive when their NACKs do not progress.

Nominally, a remote reader is marked inactive when a successive number of periodic heartbeats equal or greater than rti::core::RtpsReliableWriterProtocol::max_heartbeat_retries have been sent without receiving any ack/nacks back.

By setting this true, it changes the conditions of inactivating a remote reader: a reader will be considered inactive when it either does not send any ack/nacks or keeps sending non-progressing nacks for rti::core::RtpsReliableWriterProtocol::max_heartbeat_retries number of heartbeat periods, where a non-progressing nack is one whose oldest sample requested has not advanced from the oldest sample requested of the previous nack.

[default] false

◆ inactivate_nonprogressing_readers() [2/2]

bool rti::core::policy::RtpsReliableWriterProtocol::inactivate_nonprogressing_readers ( ) const

Getter (see setter with the same name)

◆ heartbeats_per_max_samples() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::heartbeats_per_max_samples ( int32_t  the_heartbeats_per_max_samples)

The number of heartbeats per current send window.

A piggyback heartbeat is sent every [(current send window size/heartbeats_per_max_samples)] number of samples written

If set to zero, no piggyback heartbeat will be sent.

If current send window size is dds::core::LENGTH_UNLIMITED, 100 million is assumed as the value in the calculation.

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

[range] [0, 100 million]

heartbeats_per_max_samples<= dds::core::policy::ResourceLimits::max_samples if batching is disabled. Otherwise:
heartbeats_per_max_samples<= rti::core::policy::DataWriterResourceLimits::max_batches

heartbeats_per_max_samples<= rti::core::RtpsReliableWriterProtocol::max_send_window_size

◆ heartbeats_per_max_samples() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::heartbeats_per_max_samples ( ) const

Getter (see setter with the same name)

◆ min_nack_response_delay() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::min_nack_response_delay ( const dds::core::Duration the_min_nack_response_delay)

The minimum delay to respond to a NACK.

When a reliable writer receives a NACK from a remote reader, the writer can choose to delay a while before it sends repair samples or a heartbeat. This sets the value of the minimum delay.

[default] 0 seconds

[range] [0,1 day], <= max_nack_response_delay

◆ min_nack_response_delay() [2/2]

dds::core::Duration rti::core::policy::RtpsReliableWriterProtocol::min_nack_response_delay ( ) const

Getter (see setter with the same name)

◆ max_nack_response_delay() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::max_nack_response_delay ( const dds::core::Duration the_max_nack_response_delay)

The maximum delay to respond to a nack.

This set the value of maximum delay between receiving a NACK and sending repair samples or a heartbeat.

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

[range] [0,1 day], >= min_nack_response_delay

◆ max_nack_response_delay() [2/2]

dds::core::Duration rti::core::policy::RtpsReliableWriterProtocol::max_nack_response_delay ( ) const

Getter (see setter with the same name)

◆ nack_suppression_duration() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::nack_suppression_duration ( const dds::core::Duration the_nack_suppression_duration)

The duration for ignoring consecutive NACKs that may trigger redundant repairs.

A reliable writer may receive consecutive NACKs within a short duration from a remote reader that will trigger the sending of redundant repair messages.

This specifies the duration during which consecutive NACKs are ignored to prevent redundant repairs from being sent.

[default] 0 seconds

[range] [0,1 day],

◆ nack_suppression_duration() [2/2]

dds::core::Duration rti::core::policy::RtpsReliableWriterProtocol::nack_suppression_duration ( ) const

Getter (see setter with the same name)

◆ max_bytes_per_nack_response() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::max_bytes_per_nack_response ( int32_t  the_max_bytes_per_nack_response)

The maximum total message size when resending rejected samples.

As part of the reliable communication protocol, data writers send heartbeat (HB) messages to their data readers. Each HB message contains the sequence number of the most recent sample sent by the data writer.

In response, a data reader sends an acknowledgement (ACK) message, indicating what sequence numbers it did not receive, if any. If the data reader is missing some samples, the data writer will send them again.

max_bytes_per_nack_response determines the maximum size of the message sent by the data writer in response to an ACK. This message may contain multiple samples. The data writer will always send at least one message, even if the size of that message exceeds the max_bytes_per_nack_response value.

If max_bytes_per_nack_response is larger than the maximum message size supported by the underlying transport, RTI Connext will send multiple messages. If the total size of all samples that need to be resent is larger than max_bytes_per_nack_response, the remaining samples will be resent the next time an ACK arrives.

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

[range] [0, 1 GB]

◆ max_bytes_per_nack_response() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::max_bytes_per_nack_response ( ) const

Getter (see setter with the same name)

◆ disable_positive_acks_min_sample_keep_duration() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::disable_positive_acks_min_sample_keep_duration ( const dds::core::Duration duration)

The minimum duration a sample is queued for ACK-disabled readers.

When positive ACKs are disabled for a data writer (rti::core::policy::DataWriterProtocol::disable_positive_acks = true) or a data reader (rti::core::policy::DataReaderProtocol::disable_positive_acks = true), a sample is available from the data writer's queue for at least this duration, after which the sample may be considered to be acknowledged.

[default] 1 millisecond

[range] [0,1 year], <= rti::core::RtpsReliableWriterProtocol::disable_positive_acks_max_sample_keep_duration

◆ disable_positive_acks_min_sample_keep_duration() [2/2]

dds::core::Duration rti::core::policy::RtpsReliableWriterProtocol::disable_positive_acks_min_sample_keep_duration ( ) const

Getter (see setter with the same name)

◆ disable_positive_acks_max_sample_keep_duration() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::disable_positive_acks_max_sample_keep_duration ( const dds::core::Duration duration)

The maximum duration a sample is queued for ACK-disabled readers.

When positive ACKs are disabled for a data writer (rti::core::policy::DataWriterProtocol::disable_positive_acks = true) or a data reader (rti::core::policy::DataReaderProtocol::disable_positive_acks = true), a sample is available from the data writer's queue for at most this duration, after which the sample is considered to be acknowledged.

[default] 1 second

[range] [0,1 year], >= rti::core::RtpsReliableWriterProtocol::disable_positive_acks_min_sample_keep_duration

◆ disable_positive_acks_max_sample_keep_duration() [2/2]

dds::core::Duration rti::core::policy::RtpsReliableWriterProtocol::disable_positive_acks_max_sample_keep_duration ( ) const

Getter (see setter with the same name)

◆ disable_positive_acks_enable_adaptive_sample_keep_duration() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::disable_positive_acks_enable_adaptive_sample_keep_duration ( bool  disable)

Enables dynamic adjustment of sample keep duration in response to congestion.

For dynamic networks where a static minimum sample keep duration may not provide sufficient performance or reliability, setting rti::core::RtpsReliableWriterProtocol::disable_positive_acks_enable_adaptive_sample_keep_duration = true, enables the sample keep duration to be dynamically adjusted to adapt to network conditions. The keep duration changes according to the detected level of congestion, which is determined to be proportional to the rate of NACKs received. An adaptive algorithm automatically controls the keep duration to optimize throughput and reliability.

To relieve high congestion, the keep duration is increased to effectively decrease the send rate; this lengthening of the keep duration is controlled by rti::core::RtpsReliableWriterProtocol::disable_positive_acks_increase_sample_keep_duration_factor. Alternatively, when congestion is low, the keep duration is decreased to effectively increase send rate; this shortening of the keep duration is controlled by rti::core::RtpsReliableWriterProtocol::disable_positive_acks_decrease_sample_keep_duration_factor.

The lower and upper bounds of the dynamic sample keep duration are set by rti::core::RtpsReliableWriterProtocol::disable_positive_acks_min_sample_keep_duration and rti::core::RtpsReliableWriterProtocol::disable_positive_acks_max_sample_keep_duration, respectively.

When rti::core::RtpsReliableWriterProtocol::disable_positive_acks_enable_adaptive_sample_keep_duration = false, the sample keep duration is set to rti::core::RtpsReliableWriterProtocol::disable_positive_acks_min_sample_keep_duration .

[default] true

◆ disable_positive_acks_enable_adaptive_sample_keep_duration() [2/2]

bool rti::core::policy::RtpsReliableWriterProtocol::disable_positive_acks_enable_adaptive_sample_keep_duration ( ) const

Getter (see setter with the same name)

◆ disable_positive_acks_decrease_sample_keep_duration_factor() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::disable_positive_acks_decrease_sample_keep_duration_factor ( int32_t  factor)

Controls rate of contraction of dynamic sample keep duration.

Used when rti::core::RtpsReliableWriterProtocol::disable_positive_acks_enable_adaptive_sample_keep_duration = true.

When the adaptive algorithm determines that the keep duration should be decreased, this factor (a percentage) is multiplied with the current keep duration to get the new shorter keep duration. For example, if the current keep duration is 20 milliseconds, using the default factor of 95% would result in a new keep duration of 19 milliseconds.

[default] 95

[range] <= 100

◆ disable_positive_acks_decrease_sample_keep_duration_factor() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::disable_positive_acks_decrease_sample_keep_duration_factor ( ) const

Getter (see setter with the same name)

◆ disable_positive_acks_increase_sample_keep_duration_factor() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::disable_positive_acks_increase_sample_keep_duration_factor ( int32_t  factor)

Controls rate of growth of dynamic sample keep duration.

Used when rti::core::RtpsReliableWriterProtocol::disable_positive_acks_enable_adaptive_sample_keep_duration = true.

When the adaptive algorithm determines that the keep duration should be increased, this factor (a percentage) is multiplied with the current keep duration to get the new longer keep duration. For example, if the current keep duration is 20 milliseconds, using the default factor of 150% would result in a new keep duration of 30 milliseconds.

[default] 150

[range] >= 100

◆ disable_positive_acks_increase_sample_keep_duration_factor() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::disable_positive_acks_increase_sample_keep_duration_factor ( ) const

Getter (see setter with the same name)

◆ min_send_window_size() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::min_send_window_size ( int32_t  the_min_send_window_size)

Minimum size of send window of unacknowledged samples.

A dds::pub::DataWriter has a limit on the number of unacknowledged samples in-flight at a time. This send window can be configured to have a minimum size (this field) and a maximum size (max_send_window_size). The send window can dynamically change, between the min and max sizes, to throttle the effective send rate in response to changing network congestion, as measured by negative acknowledgements received.

[default] dds::core::LENGTH_UNLIMITED

[range] > 0, <= max_send_window_size, or dds::core::LENGTH_UNLIMITED

See also
rti::core::RtpsReliableWriterProtocol::max_send_window_size
rti::core::RtpsReliableWriterProtocol::low_watermark
rti::core::RtpsReliableWriterProtocol::high_watermark
rti::core::status::ReliableWriterCacheChangedStatus::full_reliable_writer_cache

◆ min_send_window_size() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::min_send_window_size ( ) const

Getter (see setter with the same name)

◆ max_send_window_size() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::max_send_window_size ( int32_t  the_max_send_window_size)

Maximum size of send window of unacknowledged samples.

A dds::pub::DataWriter has a limit on the number of unacknowledged samples in-flight at a time. This send window can be configured to have a minimum size (min_send_window_size) and a maximum size (this field). The send window can dynamically change, between the min and max sizes, to throttle the effective send rate in response to changing network congestion, as measured by negative acknowledgements received.

When both min_send_window_size and max_send_window_size are dds::core::LENGTH_UNLIMITED, then either dds::core::policy::ResourceLimits::max_samples (for non-batching) or rti::core::policy::DataWriterResourceLimits::max_batches (for batching) serves as the effective max_send_window_size. When dds::core::policy::ResourceLimits::max_samples (for non-batching) or rti::core::policy::DataWriterResourceLimits::max_batches (for batching) is less than max_send_window_size, then it serves as the effective max_send_window_size. If it is also less than min_send_window_size, then effectively both min and max send window sizes are equal to max_samples or max_batches.

In addition, the low and high watermarks are scaled down linearly to stay within the current send window size, and the full reliable queue status is set when the send window is full.

[default] dds::core::LENGTH_UNLIMITED

[range] > 0, >= min_send_window_size, or dds::core::LENGTH_UNLIMITED

See also
rti::core::RtpsReliableWriterProtocol::min_send_window_size
rti::core::RtpsReliableWriterProtocol::low_watermark
rti::core::RtpsReliableWriterProtocol::high_watermark
rti::core::status::ReliableWriterCacheChangedStatus::full_reliable_writer_cache

◆ max_send_window_size() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::max_send_window_size ( ) const

Getter (see setter with the same name)

◆ send_window_update_period() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::send_window_update_period ( const dds::core::Duration the_send_window_update_period)

Period in which send window may be dynamically changed.

The dds::pub::DataWriter's send window will dynamically change, between the min and max send window sizes, to throttle the effective send rate in response to changing network congestion, as measured by negative acknowledgements received.

The change in send window size happens at this update period, whereupon the send window is either increased or decreased in size according to the increase or decrease factors, respectively.

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

[range] > [0,1 year]

See also
rti::core::RtpsReliableWriterProtocol::send_window_increase_factor, rti::core::RtpsReliableWriterProtocol::send_window_decrease_factor

◆ send_window_update_period() [2/2]

dds::core::Duration rti::core::policy::RtpsReliableWriterProtocol::send_window_update_period ( ) const

Getter (see setter with the same name)

◆ send_window_increase_factor() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::send_window_increase_factor ( int32_t  the_send_window_increase_factor)

Increases send window size by this percentage when reacting dynamically to network conditions.

The dds::pub::DataWriter's send window will dynamically change, between the min and max send window sizes, to throttle the effective send rate in response to changing network congestion, as measured by negative acknowledgements received.

After an update period during which no negative acknowledgements were received, the send window will be increased by this factor. The factor is treated as a percentage, where a factor of 150 would increase the send window by 150%. The increased send window size will not exceed the max_send_window_size.

[default] 105

[range] > 100

See also
rti::core::RtpsReliableWriterProtocol::send_window_update_period, rti::core::RtpsReliableWriterProtocol::send_window_decrease_factor

◆ send_window_increase_factor() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::send_window_increase_factor ( ) const

Getter (see setter with the same name)

◆ send_window_decrease_factor() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::send_window_decrease_factor ( int32_t  the_send_window_decrease_factor)

Decreases send window size by this percentage when reacting dynamically to network conditions.

The dds::pub::DataWriter's send window will dynamically change, between the min and max send window sizes, to throttle the effective send rate in response to changing network congestion, as measured by negative acknowledgements received.

When increased network congestion causes a negative acknowledgement to be received by a writer, the send window will be decreased by this factor to throttle the effective send rate. The factor is treated as a percentage, where a factor of 80 would decrease the send window to 80% of its previous size. The decreased send window size will not be less than the min_send_window_size.

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

[range] [0, 100]

See also
rti::core::RtpsReliableWriterProtocol::send_window_update_period, rti::core::RtpsReliableWriterProtocol::send_window_increase_factor

◆ send_window_decrease_factor() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::send_window_decrease_factor ( ) const

Getter (see setter with the same name)

◆ enable_multicast_periodic_heartbeat() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::enable_multicast_periodic_heartbeat ( bool  the_enable_multicast_periodic_heartbeat)

Whether periodic heartbeat messages are sent over multicast.

When enabled, if a reader has a multicast destination, then the writer will send its periodic HEARTBEAT messages to that destination. Otherwise, if not enabled or the reader does not have a multicast destination, the writer will send its periodic HEARTBEATs over unicast.

[default] false

◆ enable_multicast_periodic_heartbeat() [2/2]

bool rti::core::policy::RtpsReliableWriterProtocol::enable_multicast_periodic_heartbeat ( ) const

Getter (see setter with the same name)

◆ multicast_resend_threshold() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::multicast_resend_threshold ( int32_t  the_multicast_resend_threshold)

The minimum number of requesting readers needed to trigger a multicast resend.

Given readers with multicast destinations, when a reader NACKs for samples to be resent, the writer can either resend them over unicast or multicast. In order for the writer to resend over multicast, this threshold is the minimum number of readers of the same multicast group that the writer must receive NACKs from within a single response-delay. This allows the writer to coalesce near-simultaneous unicast resends into a multicast resend. Note that a threshold of 1 means that all resends will be sent over multicast, if available.

[default] 2

[range] [>= 1]

◆ multicast_resend_threshold() [2/2]

int32_t rti::core::policy::RtpsReliableWriterProtocol::multicast_resend_threshold ( ) const

Getter (see setter with the same name)

◆ disable_repair_piggyback_heartbeat() [1/2]

RtpsReliableWriterProtocol& rti::core::policy::RtpsReliableWriterProtocol::disable_repair_piggyback_heartbeat ( bool  the_disable_repair_piggyback_heartbeat)

Prevents piggyback heartbeats from being sent with repair samples.

When samples are repaired, the dds::pub::DataWriter resends rti::core::RtpsReliableWriterProtocol::max_bytes_per_nack_response bytes and a piggyback heartbeat with each message. You can configure the dds::pub::DataWriter to not send the piggyback heartbeat and instead rely on the rti::core::RtpsReliableWriterProtocol::late_joiner_heartbeat_period to control the throughput used to repair samples. This field is mutable only for rti::core::policy::DataWriterProtocol::rtps_reliable_writer. [default] false

◆ disable_repair_piggyback_heartbeat() [2/2]

bool rti::core::policy::RtpsReliableWriterProtocol::disable_repair_piggyback_heartbeat ( ) const

Getter (see setter with the same name)