dope-core 0.21.0

Owned native I/O and completion driver for dope
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use crate::driver::{settings, settings::errors};

mod layout;
pub(super) mod plan;

#[derive(Clone, Copy, PartialEq, Eq)]
pub struct Config {
    queues: settings::QueueLayout,
    schedule: settings::Schedule,
    files: settings::FileSlots,
    recv: settings::Receive,
    domains: settings::Domain,
    progress: settings::Progress,
}

impl Default for Config {
    fn default() -> Self {
        const FILES: settings::FileSlots = settings::FileSlots::fixed::<0, 256>();
        Self::new(
            settings::QueueLayout::fixed::<1024, 2048>(),
            settings::Schedule::fixed::<{ u16::MAX as u32 - FILES.capacity().raw() }, 65_536>(),
            FILES,
            settings::Receive::fixed::<128, 4096>(),
            settings::Domain::ZERO,
            settings::Progress::Prompt,
        )
    }
}

impl Config {
    /// Assembles validated fields; driver creation checks their relationships.
    pub const fn new(
        queues: settings::QueueLayout,
        schedule: settings::Schedule,
        files: settings::FileSlots,
        recv: settings::Receive,
        domains: settings::Domain,
        progress: settings::Progress,
    ) -> Self {
        Self {
            queues,
            schedule,
            files,
            recv,
            domains,
            progress,
        }
    }

    #[must_use]
    pub const fn file_slots(&self) -> settings::FileSlots {
        self.files
    }

    #[must_use]
    pub const fn queue_layout(&self) -> settings::QueueLayout {
        self.queues
    }

    #[must_use]
    pub const fn schedule(&self) -> settings::Schedule {
        self.schedule
    }

    #[must_use]
    pub const fn progress(&self) -> settings::Progress {
        self.progress
    }

    #[must_use]
    pub const fn with_files(mut self, files: settings::FileSlots) -> Self {
        self.files = files;
        self
    }

    #[must_use]
    pub const fn receive(&self) -> settings::Receive {
        self.recv
    }

    /// Number of stable resident-accounting domains provisioned for one
    /// generative driver scope.
    #[must_use]
    pub const fn domains(&self) -> settings::Domain {
        self.domains
    }

    #[must_use]
    pub const fn with_domains(mut self, domains: settings::Domain) -> Self {
        self.domains = domains;
        self
    }

    #[must_use]
    pub const fn with_queues(mut self, queues: settings::QueueLayout) -> Self {
        self.queues = queues;
        self
    }

    #[must_use]
    pub const fn set_schedule(mut self, schedule: settings::Schedule) -> Self {
        self.schedule = schedule;
        self
    }

    /// Materializes a statically validated profile baseline.
    #[must_use]
    pub const fn for_profile<P: settings::Profile>() -> Self {
        const {
            let config = Self::new(
                P::QUEUES,
                P::SCHEDULER,
                P::FILES,
                P::RECEIVE,
                P::RESIDENT_DOMAINS,
                P::COMPLETION_PROGRESS,
            );
            assert!(plan::Plan::new(config).is_ok(), "capacity");
            config
        }
    }

    #[must_use]
    pub fn with_receive(mut self, receive: settings::Receive) -> Self {
        self.recv = receive;
        self
    }

    /// Validates cross-field relationships before any driver allocation or I/O.
    pub(crate) fn into_plan(self) -> Result<settings::Plan, errors::Config> {
        settings::Plan::new(self)
    }
}

const _: () = {
    assert!(std::mem::align_of::<Config>() == std::mem::align_of::<u32>());
};