Struct HTB

pub struct HTB<T> {
    pub unit_cost: u64,
    /* private fields */
}

Hierarchical Token Bucket structure

You can advance time for HTB structure using advance and advance_ns and examine/alter internal state using peek/take.

When several buckets are feeding from a single parent earlier one gets a priority

Fields

unit_cost: u64

Normalized unit cost, each nanosecond corresponds to this many units

Implementations

impl<T> HTB<T>

where T: Copy + Eq + PartialEq, usize: From<T>,

pub fn new(tokens: &[BucketCfg<T>]) -> Result<Self, Error>

Create HTB for a given bucket configuration

Buckets should be given in depth first search traversal order:

• root with parent set to None
• higher priority child of the root
• followed by high priority child of the child, if any, etc.
• followed by the next child

Errors

If bucket configuration is invalid - returns an Error type describing a problem

pub fn drain(&mut self)

Drain all the available tokens

pub fn refill(&mut self)

Refill all the available buckets to full capacity

pub fn advance_ns(&mut self, time_diff: u64)

Advance time by number of nanoseconds

Updates internal structure, see also advance

Performance

Update cost is O(N) where N is number of buckets

pub fn advance(&mut self, time_diff: Duration)

Advance time by Duration

Updates internal structure, see also advance_ns

pub fn peek(&self, label: T) -> bool

Check if there’s at least one token available at index T

See also peek_n

pub fn available(&self, label: T) -> u64

Shows how many tokens are available at

pub fn peek_n(&self, label: T, cnt: usize) -> bool

Check if there’s at least cnt tokens available at index T

See also peek

pub fn take(&mut self, label: T) -> bool

Consume a single token from T

See also take_n

pub fn take_n(&mut self, label: T, cnt: usize) -> bool

Consume cnt tokens from T

See also take

Trait Implementations

impl<T: Clone> Clone for HTB<T>

fn clone(&self) -> HTB<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for HTB<T>

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

Formats the value using the given formatter.

impl<T> Index<T> for HTB<T>

where usize: From<T>,

type Output = u64

The returned type after indexing.

fn index(&self, index: T) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: PartialEq> PartialEq for HTB<T>

fn eq(&self, other: &HTB<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> StructuralPartialEq for HTB<T>