diff --git a/src/libcore/task/spawn.rs b/src/libcore/task/spawn.rs
index 267250b3642..63959edb427 100644
--- a/src/libcore/task/spawn.rs
+++ b/src/libcore/task/spawn.rs
@@ -72,6 +72,7 @@
#[doc(hidden)]; // FIXME #3538
+use cast::transmute;
use cast;
use cell::Cell;
use container::Map;
@@ -117,10 +118,10 @@ pub fn taskset_each(tasks: &TaskSet, blk: &fn(v: *rust_task) -> bool) {
struct TaskGroupData {
// All tasks which might kill this group. When this is empty, the group
// can be "GC"ed (i.e., its link in the ancestor list can be removed).
- mut members: TaskSet,
+ members: TaskSet,
// All tasks unidirectionally supervised by (directly or transitively)
// tasks in this group.
- mut descendants: TaskSet,
+ descendants: TaskSet,
}
type TaskGroupArc = unstable::Exclusive<Option<TaskGroupData>>;
@@ -145,11 +146,11 @@ struct AncestorNode {
// Hence we assert that this counter monotonically decreases as we
// approach the tail of the list.
// FIXME(#3068): Make the generation counter togglable with #[cfg(debug)].
- generation: uint,
- // Should really be an immutable non-option. This way appeases borrowck.
- mut parent_group: Option<TaskGroupArc>,
+ generation: uint,
+ // Should really be a non-option. This way appeases borrowck.
+ parent_group: Option<TaskGroupArc>,
// Recursive rest of the list.
- mut ancestors: AncestorList,
+ ancestors: AncestorList,
}
struct AncestorList(Option<unstable::Exclusive<AncestorNode>>);
@@ -301,22 +302,26 @@ fn each_ancestor(list: &mut AncestorList,
// One of these per task.
struct TCB {
- me: *rust_task,
+ me: *rust_task,
// List of tasks with whose fates this one's is intertwined.
- tasks: TaskGroupArc, // 'none' means the group has failed.
+ tasks: TaskGroupArc, // 'none' means the group has failed.
// Lists of tasks who will kill us if they fail, but whom we won't kill.
- mut ancestors: AncestorList,
- is_main: bool,
- notifier: Option<AutoNotify>,
+ ancestors: AncestorList,
+ is_main: bool,
+ notifier: Option<AutoNotify>,
}
impl Drop for TCB {
// Runs on task exit.
fn finalize(&self) {
unsafe {
+ let this: &mut TCB = transmute(self);
+
// If we are failing, the whole taskgroup needs to die.
if rt::rust_task_is_unwinding(self.me) {
- for self.notifier.each |x| { x.failed = true; }
+ for this.notifier.each_mut |x| {
+ x.failed = true;
+ }
// Take everybody down with us.
do access_group(&self.tasks) |tg| {
kill_taskgroup(tg, self.me, self.is_main);
@@ -331,16 +336,21 @@ impl Drop for TCB {
// with our own taskgroup, so long as both happen before we die.
// We remove ourself from every ancestor we can, so no cleanup; no
// break.
- for each_ancestor(&mut self.ancestors, None) |ancestor_group| {
+ for each_ancestor(&mut this.ancestors, None) |ancestor_group| {
leave_taskgroup(ancestor_group, self.me, false);
};
}
}
}
-fn TCB(me: *rust_task, tasks: TaskGroupArc, ancestors: AncestorList,
- is_main: bool, notifier: Option<AutoNotify>) -> TCB {
- for notifier.each |x| { x.failed = false; }
+fn TCB(me: *rust_task,
+ tasks: TaskGroupArc,
+ ancestors: AncestorList,
+ is_main: bool,
+ mut notifier: Option<AutoNotify>) -> TCB {
+ for notifier.each_mut |x| {
+ x.failed = false;
+ }
TCB {
me: me,
@@ -353,7 +363,7 @@ fn TCB(me: *rust_task, tasks: TaskGroupArc, ancestors: AncestorList,
struct AutoNotify {
notify_chan: Chan<TaskResult>,
- mut failed: bool,
+ failed: bool,
}
impl Drop for AutoNotify {
@@ -375,9 +385,12 @@ fn enlist_in_taskgroup(state: TaskGroupInner, me: *rust_task,
let newstate = util::replace(&mut *state, None);
// If 'None', the group was failing. Can't enlist.
if newstate.is_some() {
- let group = newstate.unwrap();
- taskset_insert(if is_member { &mut group.members }
- else { &mut group.descendants }, me);
+ let mut group = newstate.unwrap();
+ taskset_insert(if is_member {
+ &mut group.members
+ } else {
+ &mut group.descendants
+ }, me);
*state = Some(group);
true
} else {
@@ -391,9 +404,12 @@ fn leave_taskgroup(state: TaskGroupInner, me: *rust_task,
let newstate = util::replace(&mut *state, None);
// If 'None', already failing and we've already gotten a kill signal.
if newstate.is_some() {
- let group = newstate.unwrap();
- taskset_remove(if is_member { &mut group.members }
- else { &mut group.descendants }, me);
+ let mut group = newstate.unwrap();
+ taskset_remove(if is_member {
+ &mut group.members
+ } else {
+ &mut group.descendants
+ }, me);
*state = Some(group);
}
}
@@ -451,23 +467,30 @@ fn gen_child_taskgroup(linked: bool, supervised: bool)
/*##################################################################*
* Step 1. Get spawner's taskgroup info.
*##################################################################*/
- let spawner_group = match local_get(OldHandle(spawner), taskgroup_key!()) {
- None => {
- // Main task, doing first spawn ever. Lazily initialise here.
- let mut members = new_taskset();
- taskset_insert(&mut members, spawner);
- let tasks = unstable::exclusive(Some(TaskGroupData {
- members: members,
- descendants: new_taskset(),
- }));
- // Main task/group has no ancestors, no notifier, etc.
- let group =
- @TCB(spawner, tasks, AncestorList(None), true, None);
- local_set(OldHandle(spawner), taskgroup_key!(), group);
- group
- }
- Some(group) => group
- };
+ let mut spawner_group: @@mut TCB =
+ match local_get(OldHandle(spawner), taskgroup_key!()) {
+ None => {
+ // Main task, doing first spawn ever. Lazily initialise
+ // here.
+ let mut members = new_taskset();
+ taskset_insert(&mut members, spawner);
+ let tasks = unstable::exclusive(Some(TaskGroupData {
+ members: members,
+ descendants: new_taskset(),
+ }));
+ // Main task/group has no ancestors, no notifier, etc.
+ let group = @@mut TCB(spawner,
+ tasks,
+ AncestorList(None),
+ true,
+ None);
+ local_set(OldHandle(spawner), taskgroup_key!(), group);
+ group
+ }
+ Some(group) => group
+ };
+ let spawner_group: &mut TCB = *spawner_group;
+
/*##################################################################*
* Step 2. Process spawn options for child.
*##################################################################*/
@@ -624,8 +647,11 @@ fn spawn_raw_oldsched(opts: TaskOpts, f: ~fn()) {
};
if enlist_many(child, &child_arc, &mut ancestors) {
- let group = @TCB(child, child_arc, ancestors,
- is_main, notifier);
+ let group = @@mut TCB(child,
+ child_arc,
+ ancestors,
+ is_main,
+ notifier);
unsafe {
local_set(OldHandle(child), taskgroup_key!(), group);
}
diff --git a/src/libcore/unstable.rs b/src/libcore/unstable.rs
index 0b96e649178..7f42507bfd5 100644
--- a/src/libcore/unstable.rs
+++ b/src/libcore/unstable.rs
@@ -235,17 +235,30 @@ pub impl LittleLock {
}
}
-struct ExData<T> { lock: LittleLock, failed: bool, data: T, }
+struct ExData<T> {
+ lock: LittleLock,
+ failed: bool,
+ data: T,
+}
+
/**
* An arc over mutable data that is protected by a lock. For library use only.
*/
-pub struct Exclusive<T> { x: SharedMutableState<ExData<T>> }
+pub struct Exclusive<T> {
+ x: SharedMutableState<ExData<T>>
+}
pub fn exclusive<T:Owned>(user_data: T) -> Exclusive<T> {
let data = ExData {
- lock: LittleLock(), failed: false, data: user_data
+ lock: LittleLock(),
+ failed: false,
+ data: user_data
};
- Exclusive { x: unsafe { shared_mutable_state(data) } }
+ Exclusive {
+ x: unsafe {
+ shared_mutable_state(data)
+ }
+ }
}
impl<T:Owned> Clone for Exclusive<T> {