ruda-runtime 0.1.15

Ruda portable host runtime.
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

pub(crate) mod memory_pool;

mod base;

/// Export utilities to keep track of CPU buffers when performing async data copies.
pub mod drop_queue;

pub use base::*;

/// Dynamic memory management strategy.
mod memory_manage;
pub use memory_manage::*;
mod adaptive;

use alloc::vec::Vec;

/// The type of memory pool to use.
#[derive(Debug, Clone)]
pub enum PoolType {
    /// Use a memory where every allocation is a separate page.
    ExclusivePages {
        /// The minimum number of bytes to allocate in this pool.
        max_alloc_size: u64,
    },
    /// Use a memory where each allocation is a slice of a bigger allocation.
    SlicedPages {
        /// The page size to allocate.
        page_size: u64,
        /// The maximum size of a slice to allocate in the pool.
        max_slice_size: u64,
    },
}

/// Options to create a memory pool.
#[derive(Debug, Clone)]
pub struct MemoryPoolOptions {
    /// What kind of pool to use.
    pub pool_type: PoolType,
    /// Period after which allocations are deemed unused and deallocated.
    ///
    /// This period is measured in the number of allocations in the parent allocator. If a page
    /// in the pool was unused for the entire period, it will be deallocated. This period is
    /// approximmate, as checks are only done occasionally.
    pub dealloc_period: Option<u64>,
}

/// High level configuration of memory management.
#[derive(Clone, Debug)]
pub enum MemoryConfiguration {
    /// Opt-in workload-sized pages with relocation of unpinned live allocations.
    /// Resolved resources and native graphs keep their addresses fixed.
    #[cfg(not(exclusive_memory_only))]
    Adaptive,
    /// The default preset, which uses pools that allocate sub slices.
    #[cfg(not(exclusive_memory_only))]
    SubSlices,
    /// Default preset for using exclusive pages.
    /// This can be necessary for backends don't support sub-slices.
    ExclusivePages,
    /// Custom settings.
    Custom {
        /// Options for each pool to construct. When allocating, the first
        /// possible pool will be picked for an allocation.
        pool_options: Vec<MemoryPoolOptions>,
    },
}

#[allow(clippy::derivable_impls)]
impl Default for MemoryConfiguration {
    fn default() -> Self {
        #[cfg(exclusive_memory_only)]
        {
            MemoryConfiguration::ExclusivePages
        }
        #[cfg(not(exclusive_memory_only))]
        {
            MemoryConfiguration::SubSlices
        }
    }
}

impl MemoryConfiguration {
    /// Whether workload-sized relocatable pages are explicitly enabled.
    pub fn is_adaptive(&self) -> bool {
        #[cfg(not(exclusive_memory_only))]
        { matches!(self, Self::Adaptive) }
        #[cfg(exclusive_memory_only)]
        { false }
    }

    /// Whether this preset uses sliced pages rather than a whole device heap.
    /// Custom pools retain their explicitly supplied page sizes.
    pub fn uses_subslices(&self) -> bool {
        #[cfg(not(exclusive_memory_only))]
        { matches!(self, Self::SubSlices | Self::Adaptive) }
        #[cfg(exclusive_memory_only)]
        { false }
    }
}