Los valores iniciales de las variables estáticas pueden no corresponder con lo especificado en el código fuente.

Estoy trabajando en un proyecto de sistemas integrados. Así que tengo que implementar un método de asignación para asignar un nuevo segmento de memoria y un método de desasignación para devolver una asignación anterior al asignador para reutilizarla.

El siguiente párrafo está tomado del libro “Rust for Rustaceans”:

En plataformas que realmente no ejecutan ningún código antes de saltar al símbolo de inicio definido, como la mayoría de los dispositivos integrados, los valores iniciales de las variables estáticas pueden no coincidir incluso con lo especificado en el código fuente. En tales casos, su función de inicialización deberá inicializar explícitamente los diferentes segmentos de memoria estática con los valores de datos iniciales especificados en su programa binario.

Tengo exactamente el mismo problema que se describe en el párrafo anterior. En tiempo de ejecución, Rust asigna una cantidad de memoria heap muy grande. ¿Alguien tiene una solución para este problema?

Este código funciona en Linux pero no en mi dispositivo. Debido a que Rust solicita memoria mucho mayor que la capacidad de mi dispositivo.

pub struct Heap {
    pub vector: Vec<u8>,
}

pub static mut MY_HEAP: Option<heap> = None;

fn main() {
    unsafe {
        MY_HEAP = Some(Heap {
            vector: vec![1, 2, 3],
        })
    };
    unsafe {
        match &mut MY_HEAP {
            Some(h) => {
                println!("{:?}", h.vector);
            }
            None => (),
        }
    }
}

Puedes ver la implementación del asignador a continuación:

“`rust
#![feature(allocator_api)]
#![feature(alloc_error_handler)]
#![no_std]
#![crate_name = "ql_alloc"]
#![crate_type = "rlib"]

use ql_sys as ql;
use core::alloc::{GlobalAlloc, Layout};

pub struct QLAllocator;

unsafe impl GlobalAlloc for QLAllocator {
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
let a = ql::Ql_MEM_Alloc(layout.size() as u32) as *mut u8;
a
}
unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
ql::Ql_MEM_Free(ptr as *mut _ as *mut cty::c_void);
}
}

#[alloc_error_handler]
fn on_oom(layout: Layout) -> ! {
loop {}
}
“`