dope-net 0.39.0

Owned network transports for dope
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

use std::num::NonZero;

use dope_core::io::transfer;
use o3::depot::capacity;

use crate::link::egress::{Credit, Entries, Fit, Resident, metadata};

const CAP_BYTES: u32 = 1 << 20;
const CAP_ENTRIES: u32 = 1 << 12;

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Config {
    kind: Kind,
    shared: Credit,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
enum Kind {
    Split,
    Shared,
}

impl Config {
    pub const DEFAULT: Self = Self {
        kind: Kind::Split,
        shared: Credit::new(Entries::new(CAP_ENTRIES / 2), Resident::new(CAP_BYTES / 2)),
    };

    pub const fn shared(shared: Credit) -> Self {
        Self {
            kind: Kind::Shared,
            shared,
        }
    }

    pub(in crate::link::egress) const fn shared_limit(self) -> [u32; 2] {
        [self.shared.entries().raw(), self.shared.resident().raw()]
    }

    const fn total(self) -> Credit {
        match self.kind {
            Kind::Split => Credit::new(Entries::new(CAP_ENTRIES), Resident::new(CAP_BYTES)),
            Kind::Shared => self.shared,
        }
    }

    pub(in crate::link::egress) const fn reserved(self) -> Credit {
        match self.kind {
            Kind::Split => Self::DEFAULT.shared,
            Kind::Shared => Credit::new(Entries::new(0), Resident::ZERO),
        }
    }

    /// Maximum retained metadata entries owned by one arena.
    pub const fn entries(self) -> Entries {
        self.total().entries()
    }

    /// Maximum resident payload bytes owned by one arena.
    pub const fn bytes(self) -> Resident {
        self.total().resident()
    }

    /// Maximum non-empty fixed-size chunks admitted by both credit axes.
    pub const fn chunks(self, bytes: transfer::NonZero) -> Option<NonZero<u32>> {
        let bytes = bytes.into_nonzero().get();
        let entries = self.entries().raw();
        let resident = self.bytes().raw() / bytes;
        let chunks = if entries < resident {
            entries
        } else {
            resident
        };
        capacity::Count::new(chunks).nonzero()
    }

    pub(in crate::link::egress) fn flights(self, lanes: metadata::LaneCount) -> capacity::Count {
        capacity::Count::new(lanes.position().get().min(self.entries().raw()))
    }

    pub(in crate::link::egress) fn fits_all(self, lanes: metadata::LaneCount, req: Credit) -> Fit {
        let avail = self.shared.capped_add(self.reserved().floor(lanes));
        if req.entries() > avail.entries() {
            Fit::Entries
        } else if req.resident() > avail.resident() {
            Fit::Resident
        } else {
            Fit::Admitted
        }
    }
}

impl Default for Config {
    fn default() -> Self {
        Self::DEFAULT
    }
}

const _: () = assert!(size_of::<Config>() == 3 * size_of::<u32>());