Struct ThrottlingState

pub struct ThrottlingState {
    inner: Mutex<ThrottlingStateInner>,
    throttled_count: AtomicUsize,
}

Throttling state for statement logging, shared across multiple frontend tasks (and currently also shared with the old peek sequencing).

Fields

inner: Mutex<ThrottlingStateInner>

Inner state protected by a mutex for rate-limiting, because the two inner fields have to be manipulated together atomically. This mutex is locked once per unsampled query. (There is both sampling and throttling. Sampling happens before throttling.) This should be ok for now: Our QPS will not be more than 10000s for now, and a mutex should be able to do 100000s of lockings per second, even with some contention. If this ever becomes an issue, then we could redesign throttling to be per-session/per-tokio-worker-thread.

throttled_count: AtomicUsize

The number of statements that have been throttled since the last successfully logged statement. This is not needed for the throttling decision itself, so it can be a separate atomic to allow reading/writing without acquiring the inner mutex.

Implementations

impl ThrottlingState

pub fn new(now: &NowFn) -> Self

Create a new throttling state.

pub fn throttling_check( &self, cost: u64, target_data_rate: u64, max_data_credit: Option<u64>, now: &NowFn, ) -> bool

Check if we need to drop a statement due to throttling, and update the number of available tokens appropriately.

Returns false if we must throttle this statement, and true otherwise. Note: throttled_count is NOT modified by this method - callers are responsible for incrementing it on throttle failure and resetting it when appropriate.

pub fn get_throttled_count(&self) -> usize

pub fn increment_throttled_count(&self)

pub fn reset_throttled_count(&self)

Trait Implementations

impl Debug for ThrottlingState

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

Formats the value using the given formatter.