lvgl-rs/lvgl/src/mem.rs

167 lines
3.8 KiB
Rust
Raw Normal View History

2020-06-16 21:19:26 +00:00
use core::mem;
use core::ops::{Deref, DerefMut};
2020-06-16 21:19:26 +00:00
use core::ptr::NonNull;
/// Places a sized `T` into LVGL memory.
///
/// This is useful for cases when we need to allocate memory on Rust side
/// and handover the management of that memory to LVGL. May also be used in cases we
/// want to use dynamic memory in the Rust side.
pub(crate) struct Box<T>(NonNull<T>);
2020-06-16 21:19:26 +00:00
2020-06-17 06:38:35 +00:00
impl<T> Box<T> {
/// Allocate memory using LVGL memory API and place `T` in the LVGL tracked memory.
2021-05-25 23:03:07 +00:00
pub fn new(value: T) -> Box<T> {
let size = mem::size_of::<T>();
2020-06-16 21:19:26 +00:00
let inner = unsafe {
let ptr = lvgl_sys::lv_mem_alloc(size as lvgl_sys::size_t) as *mut T;
2020-06-18 21:56:09 +00:00
// LVGL should align the memory address for us!
assert_eq!(
ptr as usize % mem::align_of::<T>(),
0,
"Memory address not aligned!"
);
NonNull::new(ptr)
.map(|p| {
p.as_ptr().write(value);
p
})
2021-05-25 23:03:07 +00:00
.unwrap_or_else(|| {
panic!("Could not allocate memory {} bytes", size);
})
2020-06-16 21:19:26 +00:00
};
2021-05-25 23:03:07 +00:00
Box(inner)
2020-06-16 21:19:26 +00:00
}
pub fn into_raw(self) -> *mut T {
let b = mem::ManuallyDrop::new(self);
2020-06-16 21:19:26 +00:00
b.0.as_ptr()
}
}
2020-06-17 06:38:35 +00:00
impl<T> Drop for Box<T> {
2020-06-16 21:19:26 +00:00
fn drop(&mut self) {
unsafe {
lvgl_sys::lv_mem_free(self.0.as_ptr() as *const cty::c_void);
}
}
}
impl<T> DerefMut for Box<T> {
fn deref_mut(&mut self) -> &mut Self::Target {
self.as_mut()
}
}
impl<T> Deref for Box<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
unsafe { self.0.as_ref() }
}
}
2020-06-17 06:38:35 +00:00
impl<T> AsMut<T> for Box<T> {
2020-06-16 21:19:26 +00:00
fn as_mut(&mut self) -> &mut T {
unsafe { self.0.as_mut() }
}
}
#[cfg(test)]
mod test {
use super::*;
use std::sync::Once;
use std::vec::Vec;
static INIT_LVGL: Once = Once::new();
fn init() {
INIT_LVGL.call_once(|| {
unsafe {
lvgl_sys::lv_init();
};
});
}
2020-06-16 21:19:26 +00:00
#[test]
fn place_value_in_lv_mem() {
init();
2021-05-25 23:03:07 +00:00
let v = Box::new(5);
2020-06-16 21:19:26 +00:00
drop(v);
2021-05-25 23:03:07 +00:00
let v = Box::new(10);
2020-06-16 21:19:26 +00:00
drop(v);
}
#[test]
fn place_complex_value_in_lv_mem() {
init();
2020-06-16 21:19:26 +00:00
#[repr(C)]
#[derive(Debug)]
2020-06-16 21:19:26 +00:00
struct Point {
x: u64,
y: i8,
t: i32,
2020-06-16 21:19:26 +00:00
disp: i32,
}
let initial_mem_info = mem_info();
let mut keep = Vec::new();
for i in 0..100 {
let p = Point {
x: i,
y: 42,
t: 0,
disp: -100,
};
println!("{:?}", p);
2021-05-25 23:03:07 +00:00
let mut b = Box::new(p);
println!("memory address is {:p}", b.as_mut());
2020-06-16 21:19:26 +00:00
let point = b.as_mut();
if point.x != i {
println!("{:?}", point);
}
assert_eq!(point.x, i);
let info = mem_info();
println!("mem info: {:?}", &info);
keep.push(b);
}
drop(keep);
unsafe {
lvgl_sys::lv_mem_defrag();
}
let final_info = mem_info();
println!("mem info: {:?}", &final_info);
// If this fails, we are leaking memory! BOOM! \o/
assert_eq!(initial_mem_info.free_size, final_info.free_size)
}
fn mem_info() -> lvgl_sys::lv_mem_monitor_t {
let mut info = lvgl_sys::lv_mem_monitor_t {
total_size: 0,
free_cnt: 0,
free_size: 0,
free_biggest_size: 0,
used_cnt: 0,
max_used: 0,
used_pct: 0,
2021-05-25 23:03:07 +00:00
frag_pct: 0,
};
unsafe {
lvgl_sys::lv_mem_monitor(&mut info as *mut _);
}
info
}
2020-06-16 21:19:26 +00:00
}