Пожизненные ошибки с простой структурой ресурсов Allocator
Я пытаюсь сделать простой распределитель, который выделяет и освобождает буферы из фиксированного пула буферов.
struct AllocatedMemory<'a> {
mem: &'a mut [u8],
next: Option<&'a mut AllocatedMemory<'a>>,
}
struct Alloc<'a> {
glob: Option<&'a mut AllocatedMemory<'a>>,
}
impl<'a> Alloc<'a> {
fn alloc_cell(mut self: &mut Alloc<'a>) -> &mut AllocatedMemory<'a> {
let rest: Option<&'a mut AllocatedMemory<'a>>;
match self.glob {
Some(ref mut root_cell) => {
rest = std::mem::replace(&mut root_cell.next, None);
}
None => rest = None,
}
match std::mem::replace(&mut self.glob, rest) {
Some(mut root_cell) => {
return root_cell;
}
None => panic!("OOM"),
}
}
fn free_cell(mut self: &mut Alloc<'a>, mut val: &'a mut AllocatedMemory<'a>) {
match std::mem::replace(&mut self.glob, None) {
Some(mut x) => {
let discard = std::mem::replace(&mut val.next, Some(x));
let rest: Option<&'a mut AllocatedMemory<'a>>;
}
None => {}
}
self.glob = Some(val);
}
}
fn main() {
let mut buffer0: [u8; 1024] = [0; 1024];
let mut buffer1: [u8; 1024] = [0; 1024];
{
let mut cell1: AllocatedMemory = AllocatedMemory {
mem: &mut buffer1[0..1024],
next: None,
};
let mut cell0: AllocatedMemory = AllocatedMemory {
mem: &mut buffer0[0..1024],
next: None,
};
let mut allocator = Alloc { glob: None };
allocator.free_cell(&mut cell1); //populate allocator with a cell
allocator.free_cell(&mut cell0); //populate allocator with another cell (why does this fail?)
let mut x = allocator.alloc_cell();
allocator.free_cell(x);
let mut y = allocator.alloc_cell();
let mut z = allocator.alloc_cell();
allocator.free_cell(y);
allocator.free_cell(z);
}
}
Ошибка
error: `cell0` does not live long enough
allocator.free_cell(&mut cell0); //populate allocator with another cell (why does this fail?)
когда я просто удаляю cell0
и только есть cell1
доступны для моего пула ячеек, то происходят следующие ошибки:
error: allocator does not live long enough
let mut x = allocator.alloc_cell();
^~~~~~~~~
note: reference must be valid for the block suffix following statement 0 at 46:69...
next: None};
let mut cell0 : AllocatedMemory = AllocatedMemory{mem: &mut buffer0[0..1024],
next: None};
let mut allocator = Alloc {glob : None};
allocator.free_cell(&mut cell1); //populate allocator with a cell
//allocator.free_cell(&mut cell0); //populate allocator with another cell (why does this fail?)
note: ...but borrowed value is only valid for the block suffix following statement 2 at 49:48
let mut allocator = Alloc {glob : None};
allocator.free_cell(&mut cell1); //populate allocator with a cell
//allocator.free_cell(&mut cell0); //populate allocator with another cell (why does this fail?)
let mut x = allocator.alloc_cell();
allocator.free_cell(x);
...
error: aborting due to previous error
У кого-нибудь есть рекомендации, как исправить этот код, чтобы он компилировался, и в свободном списке может быть 2+ элемента?
Я хочу заполнить список ссылок на массивы, а затем иметь возможность их извлекать - использовать их какое-то время и помещать значение б / ф обратно в список фриланса.
Мотивация здесь заключается в создании библиотеки, которая использует #![nostd]
директива, поэтому для правильной работы требуется интерфейс распределителя.
2 ответа
Благодаря указателю starblue я решил сделать время жизни распределителя и ячеек одинаковыми, поместив их в структуру и поместив эту структуру в стек. Окончательный результат здесь:
// This code is placed in the public domain
struct AllocatedMemory<'a> {
mem : &'a mut [u8],
next : Option<&'a mut AllocatedMemory <'a> >,
}
struct Alloc<'a> {
glob : Option<&'a mut AllocatedMemory <'a> >,
}
impl<'a> Alloc <'a> {
fn alloc_cell(self : &mut Alloc<'a>) -> &'a mut AllocatedMemory<'a> {
match self.glob {
Some(ref mut glob_next) => {
let rest : Option<&'a mut AllocatedMemory <'a> >;
match glob_next.next {
Some(ref mut root_cell) => {
rest = std::mem::replace(&mut root_cell.next, None);
},
None => rest = None,
}
match std::mem::replace(&mut glob_next.next, rest) {
Some(mut root_cell) =>
{
return root_cell;
},
None => panic!("OOM"),
}
},
None => panic!("Allocator not initialized"),
}
}
fn free_cell(self : &mut Alloc<'a>,
mut val : & 'a mut AllocatedMemory<'a>) {
match self.glob {
Some(ref mut glob_next) => {
match std::mem::replace(&mut glob_next.next ,None) {
Some(mut x) => {
let _discard = std::mem::replace(&mut val.next, Some(x));
},
None => {},
}
glob_next.next = Some(val);
},
None => panic!("Allocator not initialized"),
}
}
}
struct AllocatorGlobalState<'a>{
cell1 : AllocatedMemory<'a>,
cell0 : AllocatedMemory<'a>,
sentinel : AllocatedMemory<'a>,
allocator :Alloc<'a>,
}
fn main() {
let mut buffer0 : [u8; 1024] = [0; 1024];
let mut buffer1 : [u8; 1024] = [0; 1024];
let mut sentinel_buffer : [u8; 1] = [0];
let mut ags : AllocatorGlobalState = AllocatorGlobalState {
cell1 : AllocatedMemory{mem: &mut buffer1[0..1024],
next: None},
cell0 : AllocatedMemory{mem: &mut buffer0[0..1024],
next: None},
sentinel : AllocatedMemory{mem: &mut sentinel_buffer[0..1], next: None},
allocator : Alloc {glob : None},
};
ags.allocator.glob = Some(&mut ags.sentinel);
ags.allocator.free_cell(&mut ags.cell1);
ags.allocator.free_cell(&mut ags.cell0);
{
let mut x = ags.allocator.alloc_cell();
x.mem[0] = 4;
let mut y = ags.allocator.alloc_cell();
y.mem[0] = 4;
ags.allocator.free_cell(y);
let mut z = ags.allocator.alloc_cell();
z.mem[0] = 8;
//y.mem[0] = 5; // <-- this is an error (use after free)
}
}
Мне нужно было добавить структуру Sentinel, чтобы избежать двойного заимствования ags.allocator при многократном распределении.
cell.rs:65:19: 65:32 help: run `rustc --explain E0499` to see a detailed explanation
cell.rs:62:19: 62:32 note: previous borrow of `ags.allocator` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `ags.allocator` until the borrow ends
Хранение часового в Alloc гарантирует, что я никогда не изменю glob
после того, как функция вернется.
Проблема в том, что вы всегда используете одну и ту же жизнь 'a
, Это силы cell0
а также cell1
иметь одинаковое время жизни, что невозможно, потому что нужно определить в первую очередь. Если вы внимательно прочитаете сообщение об ошибке, вы увидите, что оно жалуется на время жизни второго, не включая оператор, определяющий первую ячейку.
Я не знаю, является ли это ошибкой или ошибкой, которая строго реализует время жизни, или это присуще системе типов времени жизни (я еще не видел формального определения).
Я тоже не знаю, как это исправить. Я исправил аналогичную проблему в своем примере кода, введя дополнительные переменные времени жизни, но не смог заставить его работать для вашего кода.