---

yaml
---
r: 32703
b: refs/heads/dist-snap
c: 4f5bff9
h: refs/heads/master
i:
  32701: 4c103a0
  32699: 9b84e63
  32695: 2fc7116
  32687: c60e233
  32671: 08349aa
  32639: 1370474
v: v3

Author: brson

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 591c152dfc07bc43b132f6ec0f24f2d5e8e06620
+refs/heads/dist-snap: 4f5bff993b44c412bb57afe2d6c3709f5371e3d4
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/libcore/core.rc

@@ -222,6 +222,8 @@ mod comm;
 mod task {
     mod local_data;
     mod local_data_priv;
+    mod spawn;
+    mod rt;
 }
 mod future;
 mod pipes;

branches/dist-snap/src/libcore/task.rs

@@ -52,7 +52,7 @@ type LocalDataKey<T: Owned> = &fn(+@T);
 unsafe fn local_data_pop<T: Owned>(
     key: LocalDataKey<T>) -> Option<@T> {
 
-    local_pop(rustrt::rust_get_task(), key)
+    local_pop(rt::rust_get_task(), key)
 }
 /**
  * Retrieve a task-local data value. It will also be kept alive in the
@@ -61,7 +61,7 @@ unsafe fn local_data_pop<T: Owned>(
 unsafe fn local_data_get<T: Owned>(
     key: LocalDataKey<T>) -> Option<@T> {
 
-    local_get(rustrt::rust_get_task(), key)
+    local_get(rt::rust_get_task(), key)
 }
 /**
  * Store a value in task-local data. If this key already has a value,
@@ -70,7 +70,7 @@ unsafe fn local_data_get<T: Owned>(
 unsafe fn local_data_set<T: Owned>(
     key: LocalDataKey<T>, +data: @T) {
 
-    local_set(rustrt::rust_get_task(), key, data)
+    local_set(rt::rust_get_task(), key, data)
 }
 /**
  * Modify a task-local data value. If the function returns 'None', the
@@ -80,7 +80,7 @@ unsafe fn local_data_modify<T: Owned>(
     key: LocalDataKey<T>,
     modify_fn: fn(Option<@T>) -> Option<@T>) {
 
-    local_modify(rustrt::rust_get_task(), key, modify_fn)
+    local_modify(rt::rust_get_task(), key, modify_fn)
 }
 
 #[test]

branches/dist-snap/src/libcore/task/local_data.rs

@@ -1,6 +1,7 @@
 #[doc(hidden)]; // FIXME #3538
 
 use local_data::LocalDataKey;
+use rt::rust_task;
 
 trait LocalData { }
 impl<T: Owned> @T: LocalData { }
@@ -34,13 +35,13 @@ unsafe fn get_task_local_map(task: *rust_task) -> TaskLocalMap {
     // NOTE: The map's box lives in TLS invisibly referenced once. Each time
     // we retrieve it for get/set, we make another reference, which get/set
     // drop when they finish. No "re-storing after modifying" is needed.
-    let map_ptr = rustrt::rust_get_task_local_data(task);
+    let map_ptr = rt::rust_get_task_local_data(task);
     if map_ptr.is_null() {
         let map: TaskLocalMap = @dvec::DVec();
         // Use reinterpret_cast -- transmute would take map away from us also.
-        rustrt::rust_set_task_local_data(
+        rt::rust_set_task_local_data(
             task, cast::reinterpret_cast(&map));
-        rustrt::rust_task_local_data_atexit(task, cleanup_task_local_map);
+        rt::rust_task_local_data_atexit(task, cleanup_task_local_map);
         // Also need to reference it an extra time to keep it for now.
         cast::bump_box_refcount(map);
         map

branches/dist-snap/src/libcore/task/local_data_priv.rs

@@ -0,0 +1,59 @@
+/*!
+
+The task interface to the runtime
+
+*/
+
+#[doc(hidden)]; // FIXME #3538
+
+#[allow(non_camel_case_types)] // runtime type
+type sched_id = int;
+#[allow(non_camel_case_types)] // runtime type
+type task_id = int;
+
+// These are both opaque runtime/compiler types that we don't know the
+// structure of and should only deal with via unsafe pointer
+#[allow(non_camel_case_types)] // runtime type
+type rust_task = libc::c_void;
+#[allow(non_camel_case_types)] // runtime type
+type rust_closure = libc::c_void;
+
+extern {
+    #[rust_stack]
+    fn rust_task_yield(task: *rust_task) -> bool;
+
+    fn rust_get_sched_id() -> sched_id;
+    fn rust_new_sched(num_threads: libc::uintptr_t) -> sched_id;
+    fn rust_sched_threads() -> libc::size_t;
+    fn rust_sched_current_nonlazy_threads() -> libc::size_t;
+    fn rust_num_threads() -> libc::uintptr_t;
+
+    fn get_task_id() -> task_id;
+    #[rust_stack]
+    fn rust_get_task() -> *rust_task;
+
+    fn new_task() -> *rust_task;
+    fn rust_new_task_in_sched(id: sched_id) -> *rust_task;
+
+    fn start_task(task: *rust_task, closure: *rust_closure);
+
+    fn rust_task_is_unwinding(task: *rust_task) -> bool;
+    fn rust_osmain_sched_id() -> sched_id;
+    #[rust_stack]
+    fn rust_task_inhibit_kill(t: *rust_task);
+    #[rust_stack]
+    fn rust_task_allow_kill(t: *rust_task);
+    #[rust_stack]
+    fn rust_task_inhibit_yield(t: *rust_task);
+    #[rust_stack]
+    fn rust_task_allow_yield(t: *rust_task);
+    fn rust_task_kill_other(task: *rust_task);
+    fn rust_task_kill_all(task: *rust_task);
+
+    #[rust_stack]
+    fn rust_get_task_local_data(task: *rust_task) -> *libc::c_void;
+    #[rust_stack]
+    fn rust_set_task_local_data(task: *rust_task, map: *libc::c_void);
+    #[rust_stack]
+    fn rust_task_local_data_atexit(task: *rust_task, cleanup_fn: *u8);
+}