---

yaml
---
r: 81895
b: refs/heads/master
c: 33fef99
h: refs/heads/master
i:
  81893: ba17f0d
  81891: 393bb66
  81887: 58d2b2e
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: d209717ddd260a5b0afd0dd07cddde903281f353
+refs/heads/master: 33fef9934b82df305e6f495839de566b81a5160b
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729

trunk/RELEASES.txt

@@ -1,7 +1,7 @@
-Version 0.8 (October 2013)
+Version 0.8 (September 2013)
 --------------------------
 
-   * ~2100 changes, numerous bugfixes
+   * ~2200 changes, numerous bugfixes
 
    * Language
       * The `for` loop syntax has changed to work with the `Iterator` trait.

trunk/src/libstd/rt/comm.rs

@@ -118,17 +118,6 @@ impl<T> ChanOne<T> {
             rtassert!(!rt::in_sched_context());
         }
 
-        // In order to prevent starvation of other tasks in situations
-        // where a task sends repeatedly without ever receiving, we
-        // occassionally yield instead of doing a send immediately.
-        // Only doing this if we're doing a rescheduling send,
-        // otherwise the caller is expecting not to context switch.
-        if do_resched {
-            // XXX: This TLS hit should be combined with other uses of the scheduler below
-            let sched: ~Scheduler = Local::take();
-            sched.maybe_yield();
-        }
-
         let mut this = self;
         let mut recvr_active = true;
         let packet = this.packet();

trunk/src/libstd/rt/sched.rs

@@ -26,7 +26,7 @@ use rt::local::Local;
 use rt::rtio::{RemoteCallback, PausibleIdleCallback};
 use borrow::{to_uint};
 use cell::Cell;
-use rand::{XorShiftRng, Rng, Rand};
+use rand::{XorShiftRng, Rng};
 use iter::range;
 use vec::{OwnedVector};
 
@@ -78,14 +78,7 @@ pub struct Scheduler {
     /// A fast XorShift rng for scheduler use
     rng: XorShiftRng,
     /// A toggleable idle callback
-    idle_callback: Option<~PausibleIdleCallback>,
-    /// A countdown that starts at a random value and is decremented
-    /// every time a yield check is performed. When it hits 0 a task
-    /// will yield.
-    yield_check_count: uint,
-    /// A flag to tell the scheduler loop it needs to do some stealing
-    /// in order to introduce randomness as part of a yield
-    steal_for_yield: bool
+    idle_callback: Option<~PausibleIdleCallback>
 }
 
 /// An indication of how hard to work on a given operation, the difference
@@ -96,13 +89,6 @@ enum EffortLevel {
     GiveItYourBest
 }
 
-static MAX_YIELD_CHECKS: uint = 200;
-
-fn reset_yield_check(rng: &mut XorShiftRng) -> uint {
-    let r: uint = Rand::rand(rng);
-    r % MAX_YIELD_CHECKS + 1
-}
-
 impl Scheduler {
 
     // * Initialization Functions
@@ -127,7 +113,7 @@ impl Scheduler {
                        friend: Option<SchedHandle>)
         -> Scheduler {
 
-        let mut sched = Scheduler {
+        Scheduler {
             sleeper_list: sleeper_list,
             message_queue: MessageQueue::new(),
             sleepy: false,
@@ -141,14 +127,8 @@ impl Scheduler {
             run_anything: run_anything,
             friend_handle: friend,
             rng: XorShiftRng::new(),
-            idle_callback: None,
-            yield_check_count: 0,
-            steal_for_yield: false
-        };
-
-        sched.yield_check_count = reset_yield_check(&mut sched.rng);
-
-        return sched;
+            idle_callback: None
+        }
     }
 
     // XXX: This may eventually need to be refactored so that
@@ -327,7 +307,8 @@ impl Scheduler {
             }
             Some(TaskFromFriend(task)) => {
                 rtdebug!("got a task from a friend. lovely!");
-                this.process_task(task, Scheduler::resume_task_immediately_cl);
+                this.process_task(task,
+                                  Scheduler::resume_task_immediately_cl).map_move(Local::put);
                 return None;
             }
             Some(Wake) => {
@@ -371,8 +352,8 @@ impl Scheduler {
         match this.find_work() {
             Some(task) => {
                 rtdebug!("found some work! processing the task");
-                this.process_task(task, Scheduler::resume_task_immediately_cl);
-                return None;
+                return this.process_task(task,
+                                         Scheduler::resume_task_immediately_cl);
             }
             None => {
                 rtdebug!("no work was found, returning the scheduler struct");
@@ -392,35 +373,14 @@ impl Scheduler {
     // there, trying to steal from the remote work queues.
     fn find_work(&mut self) -> Option<~Task> {
         rtdebug!("scheduler looking for work");
-        if !self.steal_for_yield {
-            match self.work_queue.pop() {
-                Some(task) => {
-                    rtdebug!("found a task locally");
-                    return Some(task)
-                }
-                None => {
-                    rtdebug!("scheduler trying to steal");
-                    return self.try_steals();
-                }
+        match self.work_queue.pop() {
+            Some(task) => {
+                rtdebug!("found a task locally");
+                return Some(task)
             }
-        } else {
-            // During execution of the last task, it performed a 'yield',
-            // so we're doing some work stealing in order to introduce some
-            // scheduling randomness. Otherwise we would just end up popping
-            // that same task again. This is pretty lame and is to work around
-            // the problem that work stealing is not designed for 'non-strict'
-            // (non-fork-join) task parallelism.
-            self.steal_for_yield = false;
-            match self.try_steals() {
-                Some(task) => {
-                    rtdebug!("stole a task after yielding");
-                    return Some(task);
-                }
-                None => {
-                    rtdebug!("did not steal a task after yielding");
-                    // Back to business
-                    return self.find_work();
-                }
+            None => {
+                rtdebug!("scheduler trying to steal");
+                return self.try_steals();
             }
         }
     }
@@ -449,7 +409,7 @@ impl Scheduler {
     // place.
 
     fn process_task(~self, task: ~Task,
-                    schedule_fn: SchedulingFn) {
+                    schedule_fn: SchedulingFn) -> Option<~Scheduler> {
         let mut this = self;
         let mut task = task;
 
@@ -462,23 +422,23 @@ impl Scheduler {
                     rtdebug!("sending task home");
                     task.give_home(Sched(home_handle));
                     Scheduler::send_task_home(task);
-                    Local::put(this);
+                    return Some(this);
                 } else {
                     rtdebug!("running task here");
                     task.give_home(Sched(home_handle));
-                    schedule_fn(this, task);
+                    return schedule_fn(this, task);
                 }
             }
             AnySched if this.run_anything => {
                 rtdebug!("running anysched task here");
                 task.give_home(AnySched);
-                schedule_fn(this, task);
+                return schedule_fn(this, task);
             }
             AnySched => {
                 rtdebug!("sending task to friend");
                 task.give_home(AnySched);
                 this.send_to_friend(task);
-                Local::put(this);
+                return Some(this);
             }
         }
     }
@@ -647,14 +607,15 @@ impl Scheduler {
 
     // * Context Swapping Helpers - Here be ugliness!
 
-    pub fn resume_task_immediately(~self, task: ~Task) {
+    pub fn resume_task_immediately(~self, task: ~Task) -> Option<~Scheduler> {
         do self.change_task_context(task) |sched, stask| {
             sched.sched_task = Some(stask);
         }
+        return None;
     }
 
     fn resume_task_immediately_cl(sched: ~Scheduler,
-                                  task: ~Task) {
+                                  task: ~Task) -> Option<~Scheduler> {
         sched.resume_task_immediately(task)
     }
 
@@ -701,10 +662,11 @@ impl Scheduler {
         }
     }
 
-    fn switch_task(sched: ~Scheduler, task: ~Task) {
+    fn switch_task(sched: ~Scheduler, task: ~Task) -> Option<~Scheduler> {
         do sched.switch_running_tasks_and_then(task) |sched, last_task| {
             sched.enqueue_blocked_task(last_task);
         };
+        return None;
     }
 
     // * Task Context Helpers
@@ -724,7 +686,7 @@ impl Scheduler {
 
     pub fn run_task(task: ~Task) {
         let sched: ~Scheduler = Local::take();
-        sched.process_task(task, Scheduler::switch_task);
+        sched.process_task(task, Scheduler::switch_task).map_move(Local::put);
     }
 
     pub fn run_task_later(next_task: ~Task) {
@@ -734,33 +696,6 @@ impl Scheduler {
         };
     }
 
-    /// Yield control to the scheduler, executing another task. This is guaranteed
-    /// to introduce some amount of randomness to the scheduler. Currently the
-    /// randomness is a result of performing a round of work stealing (which
-    /// may end up stealing from the current scheduler).
-    pub fn yield_now(~self) {
-        let mut this = self;
-        this.yield_check_count = reset_yield_check(&mut this.rng);
-        // Tell the scheduler to start stealing on the next iteration
-        this.steal_for_yield = true;
-        do this.deschedule_running_task_and_then |sched, task| {
-            sched.enqueue_blocked_task(task);
-        }
-    }
-
-    pub fn maybe_yield(~self) {
-        // The number of times to do the yield check before yielding, chosen arbitrarily.
-        let mut this = self;
-        rtassert!(this.yield_check_count > 0);
-        this.yield_check_count -= 1;
-        if this.yield_check_count == 0 {
-            this.yield_now();
-        } else {
-            Local::put(this);
-        }
-    }
-
-
     // * Utility Functions
 
     pub fn sched_id(&self) -> uint { to_uint(self) }
@@ -783,7 +718,7 @@ impl Scheduler {
 
 // Supporting types
 
-type SchedulingFn = ~fn(~Scheduler, ~Task);
+type SchedulingFn = ~fn(~Scheduler, ~Task) -> Option<~Scheduler>;
 
 pub enum SchedMessage {
     Wake,
@@ -1296,40 +1231,4 @@ mod test {
             }
         }
     }
-
-    #[test]
-    fn dont_starve_2() {
-        use rt::comm::oneshot;
-
-        do stress_factor().times {
-            do run_in_newsched_task {
-                let (port, chan) = oneshot();
-                let (_port2, chan2) = stream();
-
-                // This task should not be able to starve the other task.
-                // The sends should eventually yield.
-                do spawntask {
-                    while !port.peek() {
-                        chan2.send(());
-                    }
-                }
-
-                chan.send(());
-            }
-        }
-    }
-
-    // Regression test for a logic bug that would cause single-threaded schedulers
-    // to sleep forever after yielding and stealing another task.
-    #[test]
-    fn single_threaded_yield() {
-        use task::{spawn, spawn_sched, SingleThreaded, deschedule};
-        use num::Times;
-
-        do spawn_sched(SingleThreaded) {
-            do 5.times { deschedule(); }
-        }
-        do spawn { }
-        do spawn { }
-    }
 }