Enum cuprate_database_service::ReaderThreads

pub enum ReaderThreads {
    OnePerThread,
    One,
    Number(usize),
    Percent(f32),
}

Amount of database reader threads to spawn.

This controls how many reader threads the DatabaseReadService thread-pool will spawn to receive and send requests/responses.

Invariant

The main function used to extract an actual usable thread count out of this is ReaderThreads::as_threads.

This will always return at least 1, up until the amount of threads on the machine.

Variants

OnePerThread

Spawn 1 reader thread per available thread on the machine.

For example, a 32-thread system will spawn 32 reader threads using this setting.

One

Only spawn 1 reader thread.

Number(usize)

Spawn a specified amount of reader threads.

Note that no matter how large this value, it will be ultimately capped at the amount of system threads.

0

ReaderThreads::Number(0) represents “use maximum value”, as such, it is equal to ReaderThreads::OnePerThread.

let reader_threads = ReaderThreads::from(0_usize);
assert!(matches!(reader_threads, ReaderThreads::OnePerThread));

Percent(f32)

Spawn a specified % of reader threads.

This must be a value in-between 0.0..1.0 where 1.0 represents ReaderThreads::OnePerThread.

Example

For example, using a 16-core, 32-thread Ryzen 5950x CPU:

Input	Total thread used
ReaderThreads::Percent(0.0)	32 (maximum value)
ReaderThreads::Percent(0.5)	16
ReaderThreads::Percent(0.75)	24
ReaderThreads::Percent(1.0)	32
ReaderThreads::Percent(2.0)	32 (saturating)
ReaderThreads::Percent(f32::NAN)	32 (non-normal default)

0.0

ReaderThreads::Percent(0.0) represents “use maximum value”, as such, it is equal to ReaderThreads::OnePerThread.

Not quite 0.0

If the thread count multiplied by the percentage ends up being non-zero, but not 1 thread, the minimum value 1 will be returned.

assert_eq!(ReaderThreads::Percent(0.000000001).as_threads().get(), 1);

Implementations

impl ReaderThreads

pub fn as_threads(&self) -> NonZeroUsize

This converts ReaderThreads into a safe, usable number representing how many threads to spawn.

This function will always return a number in-between 1..=total_thread_count.

It uses cuprate_helper::thread::threads() internally to determine the total thread count.

Example

use cuprate_database_service::ReaderThreads as R;

let total_threads: std::num::NonZeroUsize =
    cuprate_helper::thread::threads();

assert_eq!(R::OnePerThread.as_threads(), total_threads);

assert_eq!(R::One.as_threads().get(), 1);

assert_eq!(R::Number(0).as_threads(), total_threads);
assert_eq!(R::Number(1).as_threads().get(), 1);
assert_eq!(R::Number(usize::MAX).as_threads(), total_threads);

assert_eq!(R::Percent(0.01).as_threads().get(), 1);
assert_eq!(R::Percent(0.0).as_threads(), total_threads);
assert_eq!(R::Percent(1.0).as_threads(), total_threads);
assert_eq!(R::Percent(f32::NAN).as_threads(), total_threads);
assert_eq!(R::Percent(f32::INFINITY).as_threads(), total_threads);
assert_eq!(R::Percent(f32::NEG_INFINITY).as_threads(), total_threads);

// Percentage only works on more than 1 thread.
if total_threads.get() > 1 {
    assert_eq!(
        R::Percent(0.5).as_threads().get(),
        (total_threads.get() as f32 / 2.0) as usize,
    );
}

Trait Implementations

impl Clone for ReaderThreads

fn clone(&self) -> ReaderThreads

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ReaderThreads

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

Formats the value using the given formatter.

impl Default for ReaderThreads

fn default() -> ReaderThreads

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ReaderThreads

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Into<usize>> From<T> for ReaderThreads

fn from(value: T) -> Self

Create a ReaderThreads::Number.

If value is 0, this will return ReaderThreads::OnePerThread.

impl PartialEq for ReaderThreads

fn eq(&self, other: &ReaderThreads) -> 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 PartialOrd for ReaderThreads

fn partial_cmp(&self, other: &ReaderThreads) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for ReaderThreads

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for ReaderThreads

impl StructuralPartialEq for ReaderThreads

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes

Size for each variant:

• OnePerThread: 0 bytes
• One: 0 bytes
• Number: 12 bytes
• Percent: 4 bytes