vec: implement exchange vector reserve in Rust

Author: thestinger

src/libstd/vec.rs

@@ -22,12 +22,14 @@ use iterator::{FromIterator, Iterator, IteratorUtil};
 use iter::FromIter;
 use kinds::Copy;
 use libc;
+use libc::c_void;
 use num::Zero;
 use ops::Add;
 use option::{None, Option, Some};
 use ptr::to_unsafe_ptr;
 use ptr;
 use ptr::RawPtr;
+use rt::global_heap::realloc_raw;
 use sys;
 use sys::size_of;
 use uint;
@@ -52,12 +54,6 @@ pub mod rustrt {
 
     #[abi = "cdecl"]
     pub extern {
-        // These names are terrible. reserve_shared applies
-        // to ~[] and reserve_shared_actual applies to @[].
-        #[fast_ffi]
-        unsafe fn vec_reserve_shared(t: *TyDesc,
-                                     v: **raw::VecRepr,
-                                     n: libc::size_t);
         #[fast_ffi]
         unsafe fn vec_reserve_shared_actual(t: *TyDesc,
                                             v: **raw::VecRepr,
@@ -1523,13 +1519,16 @@ impl<T> OwnedVector<T> for ~[T] {
         use managed;
         if self.capacity() < n {
             unsafe {
-                let ptr: **raw::VecRepr = cast::transmute(self);
+                let ptr: *mut *mut raw::VecRepr = cast::transmute(self);
                 let td = get_tydesc::<T>();
                 if ((**ptr).box_header.ref_count ==
                     managed::raw::RC_MANAGED_UNIQUE) {
-                    rustrt::vec_reserve_shared_actual(td, ptr, n as libc::size_t);
+                    rustrt::vec_reserve_shared_actual(td, ptr as **raw::VecRepr, n as libc::size_t);
                 } else {
-                    rustrt::vec_reserve_shared(td, ptr, n as libc::size_t);
+                    let alloc = n * sys::nonzero_size_of::<T>();
+                    *ptr = realloc_raw(*ptr as *mut c_void, alloc + size_of::<raw::VecRepr>())
+                           as *mut raw::VecRepr;
+                    (**ptr).unboxed.alloc = alloc;
                 }
             }
         }
@@ -1551,12 +1550,15 @@ impl<T> OwnedVector<T> for ~[T] {
         // Only make the (slow) call into the runtime if we have to
         if self.capacity() < n {
             unsafe {
-                let ptr: **raw::VecRepr = cast::transmute(self);
+                let ptr: *mut *mut raw::VecRepr = cast::transmute(self);
                 let td = get_tydesc::<T>();
                 if contains_managed::<T>() {
-                    rustrt::vec_reserve_shared_actual(td, ptr, n as libc::size_t);
+                    rustrt::vec_reserve_shared_actual(td, ptr as **raw::VecRepr, n as libc::size_t);
                 } else {
-                    rustrt::vec_reserve_shared(td, ptr, n as libc::size_t);
+                    let alloc = n * sys::nonzero_size_of::<T>();
+                    *ptr = realloc_raw(*ptr as *mut c_void, alloc + size_of::<raw::VecRepr>())
+                           as *mut raw::VecRepr;
+                    (**ptr).unboxed.alloc = alloc;
                 }
             }
         }

src/rt/rust_builtin.cpp

@@ -75,13 +75,6 @@ vec_reserve_shared_actual(type_desc* ty, rust_vec_box** vp,
     reserve_vec_exact_shared(task, vp, n_elts * ty->size);
 }
 
-// This is completely misnamed.
-extern "C" CDECL void
-vec_reserve_shared(type_desc* ty, rust_vec_box** vp,
-                   size_t n_elts) {
-    reserve_vec_exact(vp, n_elts * ty->size);
-}
-
 extern "C" CDECL size_t
 rand_seed_size() {
     return rng_seed_size();

src/rt/rustrt.def.in

@@ -55,7 +55,6 @@ rust_get_c_stack
 rust_log_str
 start_task
 vec_reserve_shared_actual
-vec_reserve_shared
 task_clear_event_reject
 task_wait_event
 task_signal_event