Merge pull request #31 from Mark-Simulacrum/update-allocators

Update to use the new allocator APIs.
pull/32/head
Alex Crichton 7 years ago committed by GitHub
commit eee5ffb127

@ -26,14 +26,11 @@ this is totally fine.
For instance, a custom implementation of `Box` might write `Drop` like this:
```rust
#![feature(alloc, heap_api, unique)]
#![feature(unique, allocator_api)]
extern crate alloc;
use std::ptr::{drop_in_place, Unique};
use std::heap::{Heap, Alloc, Layout};
use std::mem;
use alloc::heap;
use std::ptr::{drop_in_place, Unique};
struct Box<T>{ ptr: Unique<T> }
@ -41,9 +38,7 @@ impl<T> Drop for Box<T> {
fn drop(&mut self) {
unsafe {
drop_in_place(self.ptr.as_ptr());
heap::deallocate(self.ptr.as_ptr() as *mut u8,
mem::size_of::<T>(),
mem::align_of::<T>());
Heap.dealloc(self.ptr.as_ptr() as *mut u8, Layout::new::<T>())
}
}
}
@ -57,24 +52,19 @@ use-after-free the `ptr` because when drop exits, it becomes inaccessible.
However this wouldn't work:
```rust
#![feature(alloc, heap_api, unique)]
extern crate alloc;
#![feature(allocator_api, unique)]
use std::heap::{Heap, Alloc, Layout};
use std::ptr::{drop_in_place, Unique};
use std::mem;
use alloc::heap;
struct Box<T>{ ptr: Unique<T> }
impl<T> Drop for Box<T> {
fn drop(&mut self) {
unsafe {
drop_in_place(self.ptr.as_ptr());
heap::deallocate(self.ptr.as_ptr() as *mut u8,
mem::size_of::<T>(),
mem::align_of::<T>());
Heap.dealloc(self.ptr.as_ptr() as *mut u8, Layout::new::<T>());
}
}
}
@ -86,9 +76,7 @@ impl<T> Drop for SuperBox<T> {
unsafe {
// Hyper-optimized: deallocate the box's contents for it
// without `drop`ing the contents
heap::deallocate(self.my_box.ptr.as_ptr() as *mut u8,
mem::size_of::<T>(),
mem::align_of::<T>());
Heap.dealloc(self.my_box.ptr.as_ptr() as *mut u8, Layout::new::<T>());
}
}
}
@ -135,24 +123,19 @@ The classic safe solution to overriding recursive drop and allowing moving out
of Self during `drop` is to use an Option:
```rust
#![feature(alloc, heap_api, unique)]
extern crate alloc;
#![feature(allocator_api, unique)]
use std::heap::{Alloc, Heap, Layout};
use std::ptr::{drop_in_place, Unique};
use std::mem;
use alloc::heap;
struct Box<T>{ ptr: Unique<T> }
impl<T> Drop for Box<T> {
fn drop(&mut self) {
unsafe {
drop_in_place(self.ptr.as_ptr());
heap::deallocate(self.ptr.as_ptr() as *mut u8,
mem::size_of::<T>(),
mem::align_of::<T>());
Heap.dealloc(self.ptr.as_ptr() as *mut u8, Layout::new::<T>());
}
}
}
@ -166,9 +149,7 @@ impl<T> Drop for SuperBox<T> {
// without `drop`ing the contents. Need to set the `box`
// field as `None` to prevent Rust from trying to Drop it.
let my_box = self.my_box.take().unwrap();
heap::deallocate(my_box.ptr.as_ptr() as *mut u8,
mem::size_of::<T>(),
mem::align_of::<T>());
Heap.dealloc(my_box.ptr.as_ptr() as *mut u8, Layout::new::<T>());
mem::forget(my_box);
}
}

@ -2,16 +2,13 @@
```rust
#![feature(unique)]
#![feature(alloc, heap_api)]
extern crate alloc;
#![feature(allocator_api)]
use std::ptr::{Unique, self};
use std::mem;
use std::ops::{Deref, DerefMut};
use std::marker::PhantomData;
use alloc::heap;
use std::heap::{Alloc, Layout, Heap};
struct RawVec<T> {
ptr: Unique<T>,
@ -35,22 +32,22 @@ impl<T> RawVec<T> {
// 0, getting to here necessarily means the Vec is overfull.
assert!(elem_size != 0, "capacity overflow");
let align = mem::align_of::<T>();
let (new_cap, ptr) = if self.cap == 0 {
let ptr = heap::allocate(elem_size, align);
let ptr = Heap.alloc(Layout::array::<T>(1).unwrap());
(1, ptr)
} else {
let new_cap = 2 * self.cap;
let ptr = heap::reallocate(self.ptr.as_ptr() as *mut _,
self.cap * elem_size,
new_cap * elem_size,
align);
let ptr = Heap.realloc(self.ptr.as_ptr() as *mut _,
Layout::array::<T>(self.cap).unwrap(),
Layout::array::<T>(new_cap).unwrap());
(new_cap, ptr)
};
// If allocate or reallocate fail, we'll get `null` back
if ptr.is_null() { oom() }
// If allocate or reallocate fail, oom
let ptr = match ptr {
Ok(ptr) => ptr,
Err(err) => Heap.oom(err),
};
self.ptr = Unique::new(ptr as *mut _);
self.cap = new_cap;
@ -62,20 +59,14 @@ impl<T> Drop for RawVec<T> {
fn drop(&mut self) {
let elem_size = mem::size_of::<T>();
if self.cap != 0 && elem_size != 0 {
let align = mem::align_of::<T>();
let num_bytes = elem_size * self.cap;
unsafe {
heap::deallocate(self.ptr.as_ptr() as *mut _, num_bytes, align);
Heap.dealloc(self.ptr.as_ptr() as *mut _,
Layout::array::<T>(self.cap).unwrap());
}
}
}
}
pub struct Vec<T> {
buf: RawVec<T>,
len: usize,

Loading…
Cancel
Save