ic-memory 0.44.0

Durable stable-memory allocation governance for Internet Computer canisters
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

#[path = "support/host.rs"]
mod host;
use host::RUNTIME;

const AUTHORITY: &str = "wasm_runtime_integration_size_probe";
const KEY: &str = "wasm_runtime_integration_size_probe.rows.v1";

#[unsafe(no_mangle)]
pub extern "C" fn ic_memory_wasm_runtime_integration_size_probe_bootstrap() -> u64 {
    let Ok(declarations) = probe_declarations() else {
        return 0;
    };
    RUNTIME.with(|slot| {
        let Ok(mut slot) = slot.try_borrow_mut() else {
            return 0;
        };
        if slot.is_none() {
            let Ok(config) = ic_memory::MemoryManagerConfig::new(16) else {
                return 0;
            };
            let Ok(runtime) = host::Runtime::new_with_config(
                ic_memory::ic_stable_structures::DefaultMemoryImpl::default(),
                config,
            ) else {
                return 0;
            };
            *slot = Some(runtime);
        }
        let Some(runtime) = slot.as_mut() else {
            return 0;
        };
        runtime
            .bootstrap(&declarations, &pool(), &ic_memory::GenericAllocationPolicy)
            .map_or(0, ic_memory::CommittedAllocations::generation)
    })
}

#[unsafe(no_mangle)]
pub extern "C" fn ic_memory_wasm_runtime_integration_size_probe_grow(pages: u64) -> u32 {
    RUNTIME
        .with(|slot| {
            slot.try_borrow()
                .ok()?
                .as_ref()?
                .open_memory(KEY)
                .ok()?
                .grow(pages)
                .ok()
                .and_then(|previous| u32::try_from(previous).ok())
        })
        .unwrap_or(u32::MAX)
}

#[unsafe(no_mangle)]
pub extern "C" fn ic_memory_wasm_runtime_integration_size_probe_adopt() -> u32 {
    RUNTIME
        .with(|slot| {
            let slot = slot.try_borrow().ok()?;
            let runtime = slot.as_ref()?;
            runtime
                .verify_authority(&probe_declarations().ok()?, AUTHORITY)
                .ok()?;
            runtime.memory_id(KEY).ok().map(u32::from)
        })
        .unwrap_or(u32::MAX)
}

#[unsafe(no_mangle)]
pub extern "C" fn ic_memory_wasm_runtime_integration_size_probe_summary() -> u32 {
    RUNTIME
        .with(|slot| {
            let slot = slot.try_borrow().ok()?;
            let summary = slot.as_ref()?.memory_allocation_summary().ok()?;
            let mut bytes = Vec::new();
            ciborium::into_writer(&summary, &mut bytes).ok()?;
            u32::try_from(bytes.len()).ok()
        })
        .unwrap_or(u32::MAX)
}

fn pool() -> ic_memory::MemoryAllocationPool {
    ic_memory::MemoryAllocationPool::new(
        vec![
            ic_memory::MemoryAuthority::new(
                "wasm_runtime_integration_size_probe",
                "wasm_runtime_integration_size_probe.",
            )
            .unwrap(),
        ],
        vec![],
    )
    .unwrap()
}

fn probe_declarations()
-> Result<ic_memory::SealedDeclarationSnapshot, ic_memory::MemoryDeclarationError> {
    let request = ic_memory::MemoryRequest::new(
        AUTHORITY,
        "wasm_runtime_integration_size_probe.rows.v1",
        ic_memory::SchemaMetadata::default(),
    )?;
    ic_memory::SealedDeclarationSnapshot::new(vec![request])
}