Struct SurbBalancerConfig 

pub struct SurbBalancerConfig {
    pub target_surb_buffer_size: u64,
    pub max_surbs_per_sec: u64,
    pub surb_decay: Option<(Duration, f64)>,
    pub sustain_on_return_path_loss: bool,
}

Configuration for the SurbBalancer.

Fields

target_surb_buffer_size: u64

The desired number of SURBs to be always kept as a buffer locally or at the Session counterparty.

The SurbBalancer will try to maintain approximately this number of SURBs locally or remotely (at the counterparty) at all times.

The local buffer is maintained by regulating (SurbFlowController) the egress from the Session. The remote buffer (at session counterparty) is maintained by regulating the flow of non-organic SURBs via keep-alive messages.

It does not make sense to set this value higher than the max_surb_buffer_size configuration at the counterparty.

Default is 7000 SURBs.

max_surbs_per_sec: u64

Maximum outflow of SURBs.

• In the context of the local SURB buffer (Entry), this is the maximum egress Session traffic (= SURB consumption).
• In the context of the remote SURB buffer (Exit), this is the maximum egress of keep-alive messages to the counterparty (= artificial SURB production).

The default is 5000 (which is 2500 packets/second currently)

surb_decay: Option<(Duration, f64)>

Sets what percentage of the target buffer size should be discarded at each window.

The SurbBalancer will discard the given percentage of target_surb_buffer_size at each window with the given Duration.

The default is (60, 0.05) (5% of the target buffer size is discarded every 60 seconds).

sustain_on_return_path_loss: bool

Keeps producing SURBs while the return path is known to be failing, instead of reading the resulting silence as a full counterparty buffer.

The remote buffer is estimated as produced − consumed, and consumption is only observed when a reply reaches us. A return path that drops every reply therefore looks exactly like a counterparty that is well stocked, so production is throttled at the very moment the counterparty is in fact draining towards empty and needs more.

Distinguishing that from a peer which simply has nothing to say is impossible from here – both show no consumption – so this only takes effect once an outside observer marks the return path degraded, and it expires on its own if no further evidence arrives.

Off by default: sustaining production spends bandwidth on a path that may be genuinely idle, which is only worth it for sessions that value recovery latency over that bandwidth.

Implementations

impl SurbBalancerConfig

pub fn as_controller_bounds(&self) -> BalancerControllerBounds

Convenience function to convert the SurbBalancerConfig into BalancerControllerBounds.

Trait Implementations

impl Clone for SurbBalancerConfig

fn clone(&self) -> SurbBalancerConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for SurbBalancerConfig

impl Debug for SurbBalancerConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for SurbBalancerConfig

fn default() -> SurbBalancerConfig

Return SurbBalancerConfig { target_surb_buffer_size: 7_000, max_surbs_per_sec: 5_000, surb_decay: Some((Duration :: from_secs(60), 0.05)), sustain_on_return_path_loss: false }

impl PartialEq for SurbBalancerConfig

fn eq(&self, other: &SurbBalancerConfig) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for SurbBalancerConfig