moirai-executor 0.4.0

Hybrid executor implementation for Moirai concurrency library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

//! Static route topology definition.

use super::{AcceleratorCounts, AsyncLanesPerProcess, ProcessCount, ServerCount, WorkerCount};

/// Static route topology used by [`super::HybridRouter`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RouteTopology {
    worker_threads: WorkerCount,
    processes: ProcessCount,
    async_lanes_per_process: AsyncLanesPerProcess,
    servers: ServerCount,
    accelerators: AcceleratorCounts,
}

impl RouteTopology {
    /// Construct a route topology from validated count newtypes.
    #[inline]
    pub const fn new(
        worker_threads: WorkerCount,
        processes: ProcessCount,
        async_lanes_per_process: AsyncLanesPerProcess,
        servers: ServerCount,
    ) -> Self {
        Self {
            worker_threads,
            processes,
            async_lanes_per_process,
            servers,
            accelerators: AcceleratorCounts::new(0, 0, 0, 0),
        }
    }

    /// Return a copy of this topology with accelerator route targets attached.
    #[inline]
    pub const fn with_accelerators(mut self, accelerators: AcceleratorCounts) -> Self {
        self.accelerators = accelerators;
        self
    }

    /// Return the local worker-thread count.
    #[inline]
    pub const fn worker_threads(self) -> WorkerCount {
        self.worker_threads
    }

    /// Return the process route target count.
    #[inline]
    pub const fn processes(self) -> ProcessCount {
        self.processes
    }

    /// Return the async-lane count per process.
    #[inline]
    pub const fn async_lanes_per_process(self) -> AsyncLanesPerProcess {
        self.async_lanes_per_process
    }

    /// Return the server route target count.
    #[inline]
    pub const fn servers(self) -> ServerCount {
        self.servers
    }

    /// Return accelerator route target counts.
    #[inline]
    pub const fn accelerators(self) -> AcceleratorCounts {
        self.accelerators
    }
}