---

yaml
---
r: 180179
b: refs/heads/tmp
c: 43a2004
h: refs/heads/master
i:
  180177: b5eac4f
  180175: 6ee7dc1
v: v3

Author: alexcrichton

[refs]

@@ -34,4 +34,4 @@ refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
 refs/heads/beta: 44a287e6eb22ec3c2a687fc156813577464017f7
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
-refs/heads/tmp: d4985accb7ab03d1d08945a77b535bfeaf03186c
+refs/heads/tmp: 43a200441674a4f58a55b181cff08d60fa25014c

branches/tmp/src/libarena/lib.rs

@@ -42,6 +42,7 @@ use std::cell::{Cell, RefCell};
 use std::cmp;
 use std::intrinsics::{TyDesc, get_tydesc};
 use std::intrinsics;
+use std::marker;
 use std::mem;
 use std::num::{Int, UnsignedInt};
 use std::ptr;
@@ -88,27 +89,29 @@ impl Chunk {
 /// than objects without destructors. This reduces overhead when initializing
 /// plain-old-data (`Copy` types) and means we don't need to waste time running
 /// their destructors.
-pub struct Arena {
+pub struct Arena<'longer_than_self> {
     // The head is separated out from the list as a unbenchmarked
     // microoptimization, to avoid needing to case on the list to access the
     // head.
     head: RefCell<Chunk>,
     copy_head: RefCell<Chunk>,
     chunks: RefCell<Vec<Chunk>>,
+    _invariant: marker::InvariantLifetime<'longer_than_self>,
 }
 
-impl Arena {
+impl<'a> Arena<'a> {
     /// Allocates a new Arena with 32 bytes preallocated.
-    pub fn new() -> Arena {
+    pub fn new() -> Arena<'a> {
         Arena::new_with_size(32)
     }
 
     /// Allocates a new Arena with `initial_size` bytes preallocated.
-    pub fn new_with_size(initial_size: usize) -> Arena {
+    pub fn new_with_size(initial_size: usize) -> Arena<'a> {
         Arena {
             head: RefCell::new(chunk(initial_size, false)),
             copy_head: RefCell::new(chunk(initial_size, true)),
             chunks: RefCell::new(Vec::new()),
+            _invariant: marker::InvariantLifetime,
         }
     }
 }
@@ -122,7 +125,7 @@ fn chunk(size: usize, is_copy: bool) -> Chunk {
 }
 
 #[unsafe_destructor]
-impl Drop for Arena {
+impl<'longer_than_self> Drop for Arena<'longer_than_self> {
     fn drop(&mut self) {
         unsafe {
             destroy_chunk(&*self.head.borrow());
@@ -180,7 +183,7 @@ fn un_bitpack_tydesc_ptr(p: usize) -> (*const TyDesc, bool) {
     ((p & !1) as *const TyDesc, p & 1 == 1)
 }
 
-impl Arena {
+impl<'longer_than_self> Arena<'longer_than_self> {
     fn chunk_size(&self) -> usize {
         self.copy_head.borrow().capacity()
     }
@@ -293,7 +296,7 @@ impl Arena {
     /// Allocates a new item in the arena, using `op` to initialize the value,
     /// and returns a reference to it.
     #[inline]
-    pub fn alloc<T, F>(&self, op: F) -> &mut T where F: FnOnce() -> T {
+    pub fn alloc<T:'longer_than_self, F>(&self, op: F) -> &mut T where F: FnOnce() -> T {
         unsafe {
             if intrinsics::needs_drop::<T>() {
                 self.alloc_noncopy(op)
@@ -317,20 +320,6 @@ fn test_arena_destructors() {
     }
 }
 
-#[test]
-fn test_arena_alloc_nested() {
-    struct Inner { value: usize }
-    struct Outer<'a> { inner: &'a Inner }
-
-    let arena = Arena::new();
-
-    let result = arena.alloc(|| Outer {
-        inner: arena.alloc(|| Inner { value: 10 })
-    });
-
-    assert_eq!(result.inner.value, 10);
-}
-
 #[test]
 #[should_fail]
 fn test_arena_destructors_fail() {
@@ -365,6 +354,10 @@ pub struct TypedArena<T> {
 
     /// A pointer to the first arena segment.
     first: RefCell<*mut TypedArenaChunk<T>>,
+
+    /// Marker indicating that dropping the arena causes its owned
+    /// instances of `T` to be dropped.
+    _own: marker::PhantomData<T>,
 }
 
 struct TypedArenaChunk<T> {
@@ -460,6 +453,7 @@ impl<T> TypedArena<T> {
                 ptr: Cell::new((*chunk).start() as *const T),
                 end: Cell::new((*chunk).end() as *const T),
                 first: RefCell::new(chunk),
+                _own: marker::PhantomData,
             }
         }
     }
@@ -523,6 +517,41 @@ mod tests {
         z: i32,
     }
 
+    #[test]
+    fn test_arena_alloc_nested() {
+        struct Inner { value: u8 }
+        struct Outer<'a> { inner: &'a Inner }
+        enum EI<'e> { I(Inner), O(Outer<'e>) }
+
+        struct Wrap<'a>(TypedArena<EI<'a>>);
+
+        impl<'a> Wrap<'a> {
+            fn alloc_inner<F:Fn() -> Inner>(&self, f: F) -> &Inner {
+                let r: &EI = self.0.alloc(EI::I(f()));
+                if let &EI::I(ref i) = r {
+                    i
+                } else {
+                    panic!("mismatch");
+                }
+            }
+            fn alloc_outer<F:Fn() -> Outer<'a>>(&self, f: F) -> &Outer {
+                let r: &EI = self.0.alloc(EI::O(f()));
+                if let &EI::O(ref o) = r {
+                    o
+                } else {
+                    panic!("mismatch");
+                }
+            }
+        }
+
+        let arena = Wrap(TypedArena::new());
+
+        let result = arena.alloc_outer(|| Outer {
+            inner: arena.alloc_inner(|| Inner { value: 10 }) });
+
+        assert_eq!(result.inner.value, 10);
+    }
+
     #[test]
     pub fn test_copy() {
         let arena = TypedArena::new();

branches/tmp/src/libcollections/bench.rs

@@ -8,103 +8,113 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use prelude::*;
-use std::rand;
-use std::rand::Rng;
-use test::{Bencher, black_box};
-
-pub fn insert_rand_n<M, I, R>(n: usize,
-                              map: &mut M,
-                              b: &mut Bencher,
-                              mut insert: I,
-                              mut remove: R) where
-    I: FnMut(&mut M, usize),
-    R: FnMut(&mut M, usize),
-{
-    // setup
-    let mut rng = rand::weak_rng();
-
-    for _ in 0..n {
-        insert(map, rng.gen::<usize>() % n);
-    }
-
-    // measure
-    b.iter(|| {
-        let k = rng.gen::<usize>() % n;
-        insert(map, k);
-        remove(map, k);
-    });
-    black_box(map);
+macro_rules! map_insert_rand_bench {
+    ($name: ident, $n: expr, $map: ident) => (
+        #[bench]
+        pub fn $name(b: &mut ::test::Bencher) {
+            use std::rand;
+            use std::rand::Rng;
+            use test::black_box;
+
+            let n: usize = $n;
+            let mut map = $map::new();
+            // setup
+            let mut rng = rand::weak_rng();
+
+            for _ in 0..n {
+                let i = rng.gen() % n;
+                map.insert(i, i);
+            }
+
+            // measure
+            b.iter(|| {
+                let k = rng.gen() % n;
+                map.insert(k, k);
+                map.remove(&k);
+            });
+            black_box(map);
+        }
+    )
 }
 
-pub fn insert_seq_n<M, I, R>(n: usize,
-                             map: &mut M,
-                             b: &mut Bencher,
-                             mut insert: I,
-                             mut remove: R) where
-    I: FnMut(&mut M, usize),
-    R: FnMut(&mut M, usize),
-{
-    // setup
-    for i in 0..n {
-        insert(map, i * 2);
-    }
-
-    // measure
-    let mut i = 1;
-    b.iter(|| {
-        insert(map, i);
-        remove(map, i);
-        i = (i + 2) % n;
-    });
-    black_box(map);
+macro_rules! map_insert_seq_bench {
+    ($name: ident, $n: expr, $map: ident) => (
+        #[bench]
+        pub fn $name(b: &mut ::test::Bencher) {
+            use test::black_box;
+
+            let mut map = $map::new();
+            let n: usize = $n;
+            // setup
+            for i in 0..n {
+                map.insert(i * 2, i * 2);
+            }
+
+            // measure
+            let mut i = 1;
+            b.iter(|| {
+                map.insert(i, i);
+                map.remove(&i);
+                i = (i + 2) % n;
+            });
+            black_box(map);
+        }
+    )
 }
 
-pub fn find_rand_n<M, T, I, F>(n: usize,
-                               map: &mut M,
-                               b: &mut Bencher,
-                               mut insert: I,
-                               mut find: F) where
-    I: FnMut(&mut M, usize),
-    F: FnMut(&M, usize) -> T,
-{
-    // setup
-    let mut rng = rand::weak_rng();
-    let mut keys: Vec<_> = (0..n).map(|_| rng.gen::<usize>() % n).collect();
-
-    for k in &keys {
-        insert(map, *k);
-    }
-
-    rng.shuffle(&mut keys);
-
-    // measure
-    let mut i = 0;
-    b.iter(|| {
-        let t = find(map, keys[i]);
-        i = (i + 1) % n;
-        black_box(t);
-    })
+macro_rules! map_find_rand_bench {
+    ($name: ident, $n: expr, $map: ident) => (
+        #[bench]
+        pub fn $name(b: &mut ::test::Bencher) {
+            use std::rand;
+            use std::rand::Rng;
+            use test::black_box;
+
+            let mut map = $map::new();
+            let n: usize = $n;
+
+            // setup
+            let mut rng = rand::weak_rng();
+            let mut keys: Vec<_> = (0..n).map(|_| rng.gen() % n).collect();
+
+            for &k in &keys {
+                map.insert(k, k);
+            }
+
+            rng.shuffle(&mut keys);
+
+            // measure
+            let mut i = 0;
+            b.iter(|| {
+                let t = map.get(&keys[i]);
+                i = (i + 1) % n;
+                black_box(t);
+            })
+        }
+    )
 }
 
-pub fn find_seq_n<M, T, I, F>(n: usize,
-                              map: &mut M,
-                              b: &mut Bencher,
-                              mut insert: I,
-                              mut find: F) where
-    I: FnMut(&mut M, usize),
-    F: FnMut(&M, usize) -> T,
-{
-    // setup
-    for i in 0..n {
-        insert(map, i);
-    }
-
-    // measure
-    let mut i = 0;
-    b.iter(|| {
-        let x = find(map, i);
-        i = (i + 1) % n;
-        black_box(x);
-    })
+macro_rules! map_find_seq_bench {
+    ($name: ident, $n: expr, $map: ident) => (
+        #[bench]
+        pub fn $name(b: &mut ::test::Bencher) {
+            use test::black_box;
+
+            let mut map = $map::new();
+            let n: usize = $n;
+
+            // setup
+            for i in 0..n {
+                map.insert(i, i);
+            }
+
+            // measure
+            let mut i = 0;
+            b.iter(|| {
+                let x = map.get(&i);
+                i = (i + 1) % n;
+                black_box(x);
+            })
+        }
+    )
 }