Пожизненные ошибки с простой структурой ресурсов 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 иметь одинаковое время жизни, что невозможно, потому что нужно определить в первую очередь. Если вы внимательно прочитаете сообщение об ошибке, вы увидите, что оно жалуется на время жизни второго, не включая оператор, определяющий первую ячейку.

Я не знаю, является ли это ошибкой или ошибкой, которая строго реализует время жизни, или это присуще системе типов времени жизни (я еще не видел формального определения).

Я тоже не знаю, как это исправить. Я исправил аналогичную проблему в своем примере кода, введя дополнительные переменные времени жизни, но не смог заставить его работать для вашего кода.

Другие вопросы по тегам