---

yaml
---
r: 23366
b: refs/heads/master
c: 5f32e18
h: refs/heads/master
v: v3

Author: msullivan

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 98d0aae9a1a427e299f281917ad3f387dbd675f2
+refs/heads/master: 5f32e180118b8163821e3276d4234f4d7e2f1eeb
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cd6f24f9d14ac90d167386a56e7a6ac1f0318195
 refs/heads/try: ffbe0e0e00374358b789b0037bcb3a577cd218be

trunk/src/libcore/sys.rs

@@ -65,11 +65,13 @@ pure fn size_of<T>() -> uint {
  * This is the alignment used for struct fields. It may be smaller
  * than the preferred alignment.
  */
+#[inline(always)]
 pure fn min_align_of<T>() -> uint {
     unchecked { rusti::min_align_of::<T>() }
 }
 
 /// Returns the preferred alignment of a type
+#[inline(always)]
 pure fn pref_align_of<T>() -> uint {
     unchecked { rusti::pref_align_of::<T>() }
 }

trunk/src/libstd/arena.rs

@@ -1,17 +1,63 @@
 // Dynamic arenas.
 
+// Arenas are used to quickly allocate objects that share a
+// lifetime. The arena uses ~[u8] vectors as a backing store to
+// allocate objects from. For each allocated object, the arena stores
+// a pointer to the type descriptor followed by the
+// object. (Potentially with alignment padding after each of them.)
+// When the arena is destroyed, it iterates through all of its chunks,
+// and uses the tydesc information to trace through the objects,
+// calling the destructors on them.
+// One subtle point that needs to be addressed is how to handle
+// failures while running the user provided initializer function. It
+// is important to not run the destructor on uninitalized objects, but
+// how to detect them is somewhat subtle. Since alloc() can be invoked
+// recursively, it is not sufficient to simply exclude the most recent
+// object. To solve this without requiring extra space, we use the low
+// order bit of the tydesc pointer to encode whether the object it
+// describes has been fully initialized.
+
+// A good extension of this scheme would be to segregate data with and
+// without destructors in order to avoid the overhead in the
+// plain-old-data case.
+
 export arena, arena_with_size;
 
 import list;
 import list::{list, cons, nil};
 import unsafe::reinterpret_cast;
+import sys::TypeDesc;
+import libc::size_t;
 
-type chunk = {data: ~[u8], mut fill: uint};
+#[abi = "rust-intrinsic"]
+extern mod rusti {
+    fn move_val_init<T>(&dst: T, -src: T);
+}
+extern mod rustrt {
+    #[rust_stack]
+    fn rust_call_tydesc_glue(root: *u8, tydesc: *TypeDesc, field: size_t);
+}
+// This probably belongs somewhere else. Needs to be kept in sync with
+// changes to glue...
+const tydesc_drop_glue_index: size_t = 3 as size_t;
 
-type arena_ = {mut chunks: @list<@chunk>};
+// The way arena uses arrays is really deeply awful. The arrays are
+// allocated, and have capacities reserved, but the fill for the array
+// will always stay at 0.
+type chunk = {data: ~[u8], mut fill: uint};
 
-enum arena {
-    arena_(arena_)
+struct arena {
+    // The head is seperated out from the list as a unbenchmarked
+    // microoptimization, to avoid needing to case on the list to
+    // access the head.
+    priv mut head: @chunk;
+    priv mut chunks: @list<@chunk>;
+    drop {
+        unsafe {
+            destroy_chunk(self.head);
+            for list::each(self.chunks) |chunk| { destroy_chunk(chunk); }
+        }
+    }
 }
 
 fn chunk(size: uint) -> @chunk {
@@ -21,58 +67,152 @@ fn chunk(size: uint) -> @chunk {
 }
 
 fn arena_with_size(initial_size: uint) -> arena {
-    return arena_({mut chunks: @cons(chunk(initial_size), @nil)});
+    return arena {mut head: chunk(initial_size),
+                  mut chunks: @nil};
 }
 
 fn arena() -> arena {
     arena_with_size(32u)
 }
 
-#[abi = "rust-intrinsic"]
-extern mod rusti {
-    fn move_val_init<T>(&dst: T, -src: T);
+#[inline(always)]
+fn round_up_to(base: uint, align: uint) -> uint {
+    (base + (align - 1)) & !(align - 1)
+}
+
+// Walk down a chunk, running the destructors for any objects stored
+// in it.
+unsafe fn destroy_chunk(chunk: @chunk) {
+    let mut idx = 0;
+    let buf = vec::unsafe::to_ptr(chunk.data);
+    let fill = chunk.fill;
+
+    while idx < fill {
+        let tydesc_data: *uint = reinterpret_cast(ptr::offset(buf, idx));
+        let (tydesc, is_done) = un_bitpack_tydesc_ptr(*tydesc_data);
+        let size = (*tydesc).size, align = (*tydesc).align;
+
+        let after_tydesc = idx + sys::size_of::<*TypeDesc>();
+
+        let start = round_up_to(after_tydesc, align);
+
+        //debug!("freeing object: idx = %u, size = %u, align = %u, done = %b",
+        //       start, size, align, is_done);
+        if is_done {
+            rustrt::rust_call_tydesc_glue(
+                ptr::offset(buf, start), tydesc, tydesc_drop_glue_index);
+        }
+
+        // Find where the next tydesc lives
+        idx = round_up_to(start + size, sys::pref_align_of::<*TypeDesc>());
+    }
 }
 
+// We encode whether the object a tydesc describes has been
+// initialized in the arena in the low bit of the tydesc pointer. This
+// is necessary in order to properly do cleanup if a failure occurs
+// during an initializer.
+#[inline(always)]
+unsafe fn bitpack_tydesc_ptr(p: *TypeDesc, is_done: bool) -> uint {
+    let p_bits: uint = reinterpret_cast(p);
+    p_bits | (is_done as uint)
+}
+#[inline(always)]
+unsafe fn un_bitpack_tydesc_ptr(p: uint) -> (*TypeDesc, bool) {
+    (reinterpret_cast(p & !1), p & 1 == 1)
+}
+
+
 impl &arena {
-    fn alloc_grow(n_bytes: uint, align: uint) -> *() {
+    fn alloc_grow(n_bytes: uint, align: uint) -> (*u8, *u8) {
         // Allocate a new chunk.
-        let mut head = list::head(self.chunks);
-        let chunk_size = vec::capacity(head.data);
+        let chunk_size = vec::capacity(self.head.data);
         let new_min_chunk_size = uint::max(n_bytes, chunk_size);
-        head = chunk(uint::next_power_of_two(new_min_chunk_size + 1u));
-        self.chunks = @cons(head, self.chunks);
+        self.chunks = @cons(self.head, self.chunks);
+        self.head = chunk(uint::next_power_of_two(new_min_chunk_size + 1u));
 
         return self.alloc_inner(n_bytes, align);
     }
 
     #[inline(always)]
-    fn alloc_inner(n_bytes: uint, align: uint) -> *() {
-        let alignm1 = align - 1u;
-        let mut head = list::head(self.chunks);
+    fn alloc_inner(n_bytes: uint, align: uint) -> (*u8, *u8) {
+        let head = self.head;
 
-        let mut start = head.fill;
-        start = (start + alignm1) & !alignm1;
+        let after_tydesc = head.fill + sys::size_of::<*TypeDesc>();
+
+        let start = round_up_to(after_tydesc, align);
         let end = start + n_bytes;
         if end > vec::capacity(head.data) {
             return self.alloc_grow(n_bytes, align);
         }
 
+        //debug!("idx = %u, size = %u, align = %u, fill = %u",
+        //       start, n_bytes, align, head.fill);
+
         unsafe {
-            let p = ptr::offset(vec::unsafe::to_ptr(head.data), start);
-            head.fill = end;
-            return unsafe::reinterpret_cast(p);
+            let buf = vec::unsafe::to_ptr(head.data);
+            let tydesc_p = ptr::offset(buf, head.fill);
+            let p = ptr::offset(buf, start);
+            head.fill = round_up_to(end, sys::pref_align_of::<*TypeDesc>());
+
+            return (tydesc_p, p);
         }
     }
 
     #[inline(always)]
     fn alloc<T>(op: fn() -> T) -> &self/T {
         unsafe {
             let tydesc = sys::get_type_desc::<T>();
-            let ptr = self.alloc_inner((*tydesc).size, (*tydesc).align);
+            let (ty_ptr, ptr) =
+                self.alloc_inner((*tydesc).size, (*tydesc).align);
+            let ty_ptr: *mut uint = reinterpret_cast(ty_ptr);
             let ptr: *mut T = reinterpret_cast(ptr);
+            // Write in our tydesc along with a bit indicating that it
+            // has *not* been initialized yet.
+            *ty_ptr = reinterpret_cast(tydesc);
+            // Actually initialize it
             rusti::move_val_init(*ptr, op());
+            // Now that we are done, update the tydesc to indicate that
+            // the object is there.
+            *ty_ptr = bitpack_tydesc_ptr(tydesc, true);
+
             return reinterpret_cast(ptr);
         }
     }
 }
 
+#[test]
+fn test_arena_destructors() {
+    let arena = arena::arena();
+    for uint::range(0, 10) |i| {
+        // Arena allocate something with drop glue to make sure it
+        // doesn't leak.
+        do arena.alloc { @i };
+        // Allocate something with funny size and alignment, to keep
+        // things interesting.
+        do arena.alloc { [0u8, 1u8, 2u8]/3 };
+    }
+}
+
+#[test]
+#[should_fail]
+fn test_arena_destructors_fail() {
+    let arena = arena::arena();
+    // Put some stuff in the arena.
+    for uint::range(0, 10) |i| {
+        // Arena allocate something with drop glue to make sure it
+        // doesn't leak.
+        do arena.alloc { @i };
+        // Allocate something with funny size and alignment, to keep
+        // things interesting.
+        do arena.alloc { [0u8, 1u8, 2u8]/3 };
+    }
+    // Now, fail while allocating
+    do arena.alloc::<@int> {
+        // First, recursively allocate something else; that needs to
+        // get freed too.
+        do arena.alloc { @20 };
+        // Now fail.
+        fail;
+    };
+}

trunk/src/rt/rust_builtin.cpp

@@ -949,6 +949,15 @@ rust_task_deref(rust_task *task) {
     task->deref();
 }
 
+// Must call on rust stack.
+extern "C" CDECL void
+rust_call_tydesc_glue(void *root, size_t *tydesc, size_t glue_index) {
+    void (*glue_fn)(void *, void *, void *, void *) =
+        (void (*)(void *, void *, void *, void *))tydesc[glue_index];
+    if (glue_fn)
+        glue_fn(0, 0, 0, root);
+}
+
 //
 // Local Variables:
 // mode: C++

trunk/src/rt/rustrt.def.in

@@ -195,3 +195,4 @@ rust_set_task_local_data
 rust_task_local_data_atexit
 rust_task_ref
 rust_task_deref
+rust_call_tydesc_glue