---

yaml
---
r: 142701
b: refs/heads/try2
c: f74250e
h: refs/heads/master
i:
  142699: 7c5c9d4
v: v3

Author: thestinger

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 41dcec2fe16e272016ae77d10a6a5ff3a737f192
+refs/heads/try2: f74250e3a970f81388a73aeb8f3d53304d77c34b
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libextra/test.rs

@@ -36,6 +36,14 @@ use std::u64;
 use std::uint;
 use std::vec;
 
+pub mod rustrt {
+    use std::libc::size_t;
+
+    #[abi = "cdecl"]
+    pub extern {
+        pub unsafe fn rust_sched_threads() -> size_t;
+    }
+}
 
 // The name of a test. By convention this follows the rules for rust
 // paths; i.e. it should be a series of identifiers separated by double
@@ -485,10 +493,11 @@ static SCHED_OVERCOMMIT : uint = 1;
 static SCHED_OVERCOMMIT : uint = 4u;
 
 fn get_concurrency() -> uint {
-    use std::rt;
-    let threads = rt::util::default_sched_threads();
-    if threads == 1 { 1 }
-    else { threads * SCHED_OVERCOMMIT }
+    unsafe {
+        let threads = rustrt::rust_sched_threads() as uint;
+        if threads == 1 { 1 }
+        else { threads * SCHED_OVERCOMMIT }
+    }
 }
 
 #[allow(non_implicitly_copyable_typarams)]

branches/try2/src/libstd/at_vec.rs

@@ -22,6 +22,23 @@ use vec::{ImmutableVector, OwnedVector};
 /// Code for dealing with @-vectors. This is pretty incomplete, and
 /// contains a bunch of duplication from the code for ~-vectors.
 
+pub mod rustrt {
+    use libc;
+    use vec;
+    #[cfg(stage0)]
+    use intrinsic::{TyDesc};
+    #[cfg(not(stage0))]
+    use unstable::intrinsics::{TyDesc};
+
+    #[abi = "cdecl"]
+    #[link_name = "rustrt"]
+    pub extern {
+        pub unsafe fn vec_reserve_shared_actual(t: *TyDesc,
+                                                v: **vec::raw::VecRepr,
+                                                n: libc::size_t);
+    }
+}
+
 /// Returns the number of elements the vector can hold without reallocating
 #[inline]
 pub fn capacity<T>(v: @[T]) -> uint {
@@ -175,17 +192,18 @@ pub mod traits {
 pub mod traits {}
 
 pub mod raw {
-    use at_vec::capacity;
-    use cast;
+    use at_vec::{capacity, rustrt};
     use cast::{transmute, transmute_copy};
     use libc;
     use ptr;
     use sys;
     use uint;
-    use unstable::intrinsics;
-    use unstable::intrinsics::{move_val_init, TyDesc};
+    use unstable::intrinsics::{move_val_init};
     use vec;
-    use vec::UnboxedVecRepr;
+    #[cfg(stage0)]
+    use intrinsic::{get_tydesc};
+    #[cfg(not(stage0))]
+    use unstable::intrinsics::{get_tydesc};
 
     pub type VecRepr = vec::raw::VecRepr;
     pub type SliceRepr = vec::raw::SliceRepr;
@@ -246,49 +264,9 @@ pub mod raw {
     pub unsafe fn reserve<T>(v: &mut @[T], n: uint) {
         // Only make the (slow) call into the runtime if we have to
         if capacity(*v) < n {
-            let ptr: *mut *mut VecRepr = transmute(v);
-            let ty = intrinsics::get_tydesc::<T>();
-            // XXX transmute shouldn't be necessary
-            let ty = cast::transmute(ty);
-            return reserve_raw(ty, ptr, n);
-        }
-    }
-
-    // Implementation detail. Shouldn't be public
-    #[allow(missing_doc)]
-    pub fn reserve_raw(ty: *TyDesc, ptr: *mut *mut VecRepr, n: uint) {
-
-        unsafe {
-            let size_in_bytes = n * (*ty).size;
-            if size_in_bytes > (**ptr).unboxed.alloc {
-                let total_size = size_in_bytes + sys::size_of::<UnboxedVecRepr>();
-                // XXX: UnboxedVecRepr has an extra u8 at the end
-                let total_size = total_size - sys::size_of::<u8>();
-                (*ptr) = local_realloc(*ptr as *(), total_size) as *mut VecRepr;
-                (**ptr).unboxed.alloc = size_in_bytes;
-            }
-        }
-
-        fn local_realloc(ptr: *(), size: uint) -> *() {
-            use rt;
-            use rt::OldTaskContext;
-            use rt::local::Local;
-            use rt::task::Task;
-
-            if rt::context() == OldTaskContext {
-                unsafe {
-                    return rust_local_realloc(ptr, size as libc::size_t);
-                }
-
-                extern {
-                    #[fast_ffi]
-                    fn rust_local_realloc(ptr: *(), size: libc::size_t) -> *();
-                }
-            } else {
-                do Local::borrow::<Task, *()> |task| {
-                    task.heap.realloc(ptr as *libc::c_void, size) as *()
-                }
-            }
+            let ptr: **VecRepr = transmute(v);
+            rustrt::vec_reserve_shared_actual(get_tydesc::<T>(),
+                                              ptr, n as libc::size_t);
         }
     }
 

branches/try2/src/libstd/cleanup.rs

@@ -10,13 +10,105 @@
 
 #[doc(hidden)];
 
-use libc::c_void;
+use libc::{c_char, intptr_t, uintptr_t};
 use ptr::{mut_null};
 use repr::BoxRepr;
 use cast::transmute;
 use unstable::intrinsics::TyDesc;
+#[cfg(not(test))] use unstable::lang::clear_task_borrow_list;
 
-type DropGlue<'self> = &'self fn(**TyDesc, *c_void);
+/**
+ * Runtime structures
+ *
+ * NB: These must match the representation in the C++ runtime.
+ */
+
+type TaskID = uintptr_t;
+
+struct StackSegment { priv opaque: () }
+struct Scheduler { priv opaque: () }
+struct SchedulerLoop { priv opaque: () }
+struct Kernel { priv opaque: () }
+struct Env { priv opaque: () }
+struct AllocHeader { priv opaque: () }
+struct MemoryRegion { priv opaque: () }
+
+#[cfg(target_arch="x86")]
+struct Registers {
+    data: [u32, ..16]
+}
+
+#[cfg(target_arch="arm")]
+#[cfg(target_arch="mips")]
+struct Registers {
+    data: [u32, ..32]
+}
+
+#[cfg(target_arch="x86")]
+#[cfg(target_arch="arm")]
+#[cfg(target_arch="mips")]
+struct Context {
+    regs: Registers,
+    next: *Context,
+    pad: [u32, ..3]
+}
+
+#[cfg(target_arch="x86_64")]
+struct Registers {
+    data: [u64, ..22]
+}
+
+#[cfg(target_arch="x86_64")]
+struct Context {
+    regs: Registers,
+    next: *Context,
+    pad: uintptr_t
+}
+
+struct BoxedRegion {
+    env: *Env,
+    backing_region: *MemoryRegion,
+    live_allocs: *BoxRepr
+}
+
+#[cfg(target_arch="x86")]
+#[cfg(target_arch="arm")]
+#[cfg(target_arch="mips")]
+struct Task {
+    // Public fields
+    refcount: intptr_t,                 // 0
+    id: TaskID,                         // 4
+    pad: [u32, ..2],                    // 8
+    ctx: Context,                       // 16
+    stack_segment: *StackSegment,       // 96
+    runtime_sp: uintptr_t,              // 100
+    scheduler: *Scheduler,              // 104
+    scheduler_loop: *SchedulerLoop,     // 108
+
+    // Fields known only to the runtime
+    kernel: *Kernel,                    // 112
+    name: *c_char,                      // 116
+    list_index: i32,                    // 120
+    boxed_region: BoxedRegion           // 128
+}
+
+#[cfg(target_arch="x86_64")]
+struct Task {
+    // Public fields
+    refcount: intptr_t,
+    id: TaskID,
+    ctx: Context,
+    stack_segment: *StackSegment,
+    runtime_sp: uintptr_t,
+    scheduler: *Scheduler,
+    scheduler_loop: *SchedulerLoop,
+
+    // Fields known only to the runtime
+    kernel: *Kernel,
+    name: *c_char,
+    list_index: i32,
+    boxed_region: BoxedRegion
+}
 
 /*
  * Box annihilation
@@ -35,9 +127,9 @@ unsafe fn each_live_alloc(read_next_before: bool,
     //! Walks the internal list of allocations
 
     use managed;
-    use rt::local_heap;
 
-    let box = local_heap::live_allocs();
+    let task: *Task = transmute(rustrt::rust_get_task());
+    let box = (*task).boxed_region.live_allocs;
     let mut box: *mut BoxRepr = transmute(copy box);
     while box != mut_null() {
         let next_before = transmute(copy (*box).header.next);
@@ -59,13 +151,7 @@ unsafe fn each_live_alloc(read_next_before: bool,
 
 #[cfg(unix)]
 fn debug_mem() -> bool {
-    use rt;
-    use rt::OldTaskContext;
-    // XXX: Need to port the environment struct to newsched
-    match rt::context() {
-        OldTaskContext => ::rt::env::get().debug_mem,
-        _ => false
-    }
+    ::rt::env::get().debug_mem
 }
 
 #[cfg(windows)]
@@ -87,12 +173,13 @@ unsafe fn call_drop_glue(tydesc: *TyDesc, data: *i8) {
 }
 
 /// Destroys all managed memory (i.e. @ boxes) held by the current task.
+#[cfg(not(test))]
+#[lang="annihilate"]
 pub unsafe fn annihilate() {
-    use rt::local_heap::local_free;
+    use unstable::lang::local_free;
     use io::WriterUtil;
     use io;
     use libc;
-    use rt::borrowck;
     use sys;
     use managed;
 
@@ -104,7 +191,7 @@ pub unsafe fn annihilate() {
 
     // Quick hack: we need to free this list upon task exit, and this
     // is a convenient place to do it.
-    borrowck::clear_task_borrow_list();
+    clear_task_borrow_list();
 
     // Pass 1: Make all boxes immortal.
     //
@@ -126,7 +213,7 @@ pub unsafe fn annihilate() {
     // callback, as the original value may have been freed.
     for each_live_alloc(false) |box, uniq| {
         if !uniq {
-            let tydesc: *TyDesc = transmute(copy (*box).header.type_desc);
+            let tydesc = (*box).header.type_desc;
             let data = transmute(&(*box).data);
             call_drop_glue(tydesc, data);
         }

branches/try2/src/libstd/comm.rs

@@ -220,58 +220,48 @@ impl<T: Send> Peekable<T> for PortSet<T> {
 
 /// A channel that can be shared between many senders.
 pub struct SharedChan<T> {
-    inner: Either<Exclusive<pipesy::Chan<T>>, rtcomm::SharedChan<T>>
+    ch: Exclusive<pipesy::Chan<T>>
 }
 
 impl<T: Send> SharedChan<T> {
     /// Converts a `chan` into a `shared_chan`.
     pub fn new(c: Chan<T>) -> SharedChan<T> {
         let Chan { inner } = c;
         let c = match inner {
-            Left(c) => Left(exclusive(c)),
-            Right(c) => Right(rtcomm::SharedChan::new(c))
+            Left(c) => c,
+            Right(_) => fail!("SharedChan not implemented")
         };
-        SharedChan { inner: c }
+        SharedChan { ch: exclusive(c) }
     }
 }
 
 impl<T: Send> GenericChan<T> for SharedChan<T> {
     fn send(&self, x: T) {
-        match self.inner {
-            Left(ref chan) => {
-                unsafe {
-                    let mut xx = Some(x);
-                    do chan.with_imm |chan| {
-                        let x = replace(&mut xx, None);
-                        chan.send(x.unwrap())
-                    }
-                }
+        unsafe {
+            let mut xx = Some(x);
+            do self.ch.with_imm |chan| {
+                let x = replace(&mut xx, None);
+                chan.send(x.unwrap())
             }
-            Right(ref chan) => chan.send(x)
         }
     }
 }
 
 impl<T: Send> GenericSmartChan<T> for SharedChan<T> {
     fn try_send(&self, x: T) -> bool {
-        match self.inner {
-            Left(ref chan) => {
-                unsafe {
-                    let mut xx = Some(x);
-                    do chan.with_imm |chan| {
-                        let x = replace(&mut xx, None);
-                        chan.try_send(x.unwrap())
-                    }
-                }
+        unsafe {
+            let mut xx = Some(x);
+            do self.ch.with_imm |chan| {
+                let x = replace(&mut xx, None);
+                chan.try_send(x.unwrap())
             }
-            Right(ref chan) => chan.try_send(x)
         }
     }
 }
 
 impl<T: Send> ::clone::Clone for SharedChan<T> {
     fn clone(&self) -> SharedChan<T> {
-        SharedChan { inner: self.inner.clone() }
+        SharedChan { ch: self.ch.clone() }
     }
 }