Enum glommio::PoolPlacement

pub enum PoolPlacement {
    Unbound(usize),
    Fenced(usize, CpuSet),
    MaxSpread(usize, Option<CpuSet>),
    MaxPack(usize, Option<CpuSet>),
    Custom(Vec<CpuSet>),
}

Specifies a policy by which LocalExecutorPoolBuilder selects CPUs.

PoolPlacement is used to bind LocalExecutors to a set of CPUs via preconfigured policies designed to address a variety of use cases.

Example

Some PoolPlacements allow manually filtering available CPUs via a CpuSet, such as MaxSpread. The following would place shards on four CPUs (a.k.a. hyper-threads) that are on NUMA node 0 and have an even numbered package ID according to their CpuLocation. The selection aims to achieve a high degree of separation between the CPUs in terms of machine topology. Each LocalExecutor would be bound to a single CPU.

Note that if four CPUs are not available, the call to LocalExecutorPoolBuilder::on_all_shards would return an Err when using MaxSpread.

use glommio::{CpuSet, LocalExecutorPoolBuilder, PoolPlacement};

let cpus = CpuSet::online()
    .expect("Err: please file an issue with glommio")
    .filter(|l| l.numa_node == 0)
    .filter(|l| l.package % 2 == 0);

let handles = LocalExecutorPoolBuilder::new(PoolPlacement::MaxSpread(4, Some(cpus)))
    .on_all_shards(|| async move {
        // ... important stuff ...
    })
    .unwrap();

handles.join_all();

Variants

Unbound(usize)

The Unbound variant creates a specific number of LocalExecutors that are not bound to any CPU.

Fenced(usize, CpuSet)

The Fenced variant binds each LocalExecutor to create to the set of CPUs specified by CpuSet. With an unfiltered CPU set returned by CpuSet::online, this is similar to using Unbound with the distinction that bringing additional CPUs online will not allow the executors to run on the newly available CPUs. The Fenced variant allows the number of shards specified in LocalExecutorPoolBuilder::new to be greater than the number of CPUs as long as at least one CPU is included in CpuSet.

Errors

If the provided CpuSet contains no CPUs, a call to LocalExecutorPoolBuilder::on_all_shards will return Result:: Err.

MaxSpread(usize, Option<CpuSet>)

Each LocalExecutor to create is pinned to a particular CpuLocation such that the set of all CPUs selected has a high degree of separation. The selection proceeds from all CPUs that are online in a non-deterministic manner. The Option<CpuSet> parameter may be used to restrict the CpuSet from which CPUs are selected; specifying None is equivalent to using Some(CpuSet::online()?).

Errors

If the number of shards is greater than the number of CPUs available, then a call to LocalExecutorPoolBuilder::on_all_shards will return Result:: Err.

MaxPack(usize, Option<CpuSet>)

Each LocalExecutor to create is pinned to a particular CpuLocation such that the set of all CPUs selected has a low degree of separation. The selection proceeds from all CPUs that are online in a non-deterministic manner. The Option<CpuSet> parameter may be used to restrict the CpuSet from which CPUs are selected; specifying None is equivalent to using Some(CpuSet::online()?).

Errors

If the number of shards is greater than the number of CPUs available, then a call to LocalExecutorPoolBuilder::on_all_shards will return Result:: Err.

Custom(Vec<CpuSet>)

One LocalExecutor is bound to each of the CpuSets specified by Custom. The number of CpuSets in the Vec should match the number of shards requested from the pool builder.

Errors

LocalExecutorPoolBuilder::on_all_shards will return Result::Err if any of the provided CpuSet is empty.

Implementations

impl PoolPlacement

pub fn executor_count(&self) -> usize

Return the number of executor to create according to this placement policy

pub fn generate_cpu_set(self) -> Result<CpuSetGenerator, ()>

Probe the topology of the system and materialize this PoolPlacement into a set of CpuSet

Trait Implementations

impl Clone for PoolPlacement

fn clone(&self) -> PoolPlacement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PoolPlacement

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

Formats the value using the given formatter.

impl From<Placement> for PoolPlacement

fn from(placement: Placement) -> Self

Converts to this type from the input type.

impl Hash for PoolPlacement

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for PoolPlacement

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for PoolPlacement

impl StructuralPartialEq for PoolPlacement