ort2 0.1.2

onnxruntime wrapper c/c++ api
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

use std::{
    ffi::{CStr, CString},
    ptr::{null, null_mut},
};

use ort2_sys::{self as ffi, OrtAllocatorType, OrtMemType};

use crate::{api::ok, error::Result};

pub struct MemoryInfo {
    inner: *mut ffi::OrtMemoryInfo,
}

impl MemoryInfo {
    pub fn new(
        name: impl AsRef<str>,
        typ: OrtAllocatorType,
        id: i32,
        mem_typ: OrtMemType,
    ) -> Result<Self> {
        let name = CString::new(name.as_ref())?;
        let mut inner = null_mut();
        ok!(
            CreateMemoryInfo,
            name.as_ptr(),
            typ,
            id,
            mem_typ,
            &mut inner
        )?;
        Ok(MemoryInfo { inner })
    }

    pub fn new_cpu(typ: OrtAllocatorType, mem_typ: OrtMemType) -> Result<Self> {
        let mut inner = null_mut();
        ok!(CreateCpuMemoryInfo, typ, mem_typ, &mut inner)?;
        Ok(Self { inner })
    }

    pub fn inner(&self) -> *mut ffi::OrtMemoryInfo {
        self.inner
    }

    pub fn mem_typ(&self) -> Result<ffi::OrtMemType> {
        let mut typ = OrtMemType::OrtMemTypeDefault;
        ok!(MemoryInfoGetMemType, self.inner, &mut typ)?;
        Ok(typ)
    }

    pub fn name(&self) -> Result<&CStr> {
        let mut name = null();
        ok!(MemoryInfoGetName, self.inner, &mut name)?;
        Ok(unsafe { CStr::from_ptr(name) })
    }

    pub fn typ(&self) -> Result<OrtAllocatorType> {
        let mut typ = OrtAllocatorType::OrtInvalidAllocator;
        ok!(MemoryInfoGetType, self.inner, &mut typ)?;
        Ok(typ)
    }

    pub fn id(&self) -> Result<i32> {
        let mut id = 0i32;
        ok!(MemoryInfoGetId, self.inner, &mut id)?;
        Ok(id)
    }
}

impl Default for MemoryInfo {
    fn default() -> Self {
        Self::new_cpu(
            OrtAllocatorType::OrtArenaAllocator,
            OrtMemType::OrtMemTypeDefault,
        )
        .expect("failed to create memory info")
    }
}