---

yaml
---
r: 97190
b: refs/heads/dist-snap
c: 1763f36
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 1b2cebc2c1f4d6e4bad36f4fa682f3d4e70cfb70
+refs/heads/dist-snap: 1763f36c9d47550838793e129f2297ecfc8bebd1
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/etc/vim/syntax/rust.vim

@@ -78,7 +78,7 @@ syn keyword rustTrait Default
 syn keyword rustTrait Hash
 syn keyword rustTrait FromStr
 syn keyword rustTrait FromIterator Extendable
-syn keyword rustTrait Iterator DoubleEndedIterator RandomAccessIterator CloneableIterator
+syn keyword rustTrait Iterator DoubleEndedIterator RandomAccessIterator ClonableIterator
 syn keyword rustTrait OrdIterator MutableDoubleEndedIterator ExactSize
 syn keyword rustTrait Times
 

branches/dist-snap/src/libextra/enum_set.rs

@@ -13,7 +13,7 @@
 //! This module defines a container which uses an efficient bit mask
 //! representation to hold C-like enum variants.
 
-#[deriving(Clone, Eq, IterBytes, ToStr, Encodable, Decodable)]
+#[deriving(Clone, Eq, IterBytes, ToStr)]
 /// A specialized Set implementation to use enum types.
 pub struct EnumSet<E> {
     // We must maintain the invariant that no bits are set

branches/dist-snap/src/libgreen/lib.rs

@@ -214,7 +214,11 @@ impl SchedPool {
             pool.handles.push(sched.make_handle());
             let sched = sched;
             pool.threads.push(do Thread::start {
-                sched.bootstrap();
+                let mut sched = sched;
+                let task = do GreenTask::new(&mut sched.stack_pool, None) {
+                    rtdebug!("boostraping a non-primary scheduler");
+                };
+                sched.bootstrap(task);
             });
         }
 
@@ -266,7 +270,13 @@ impl SchedPool {
         let ret = sched.make_handle();
         self.handles.push(sched.make_handle());
         let sched = sched;
-        self.threads.push(do Thread::start { sched.bootstrap() });
+        self.threads.push(do Thread::start {
+            let mut sched = sched;
+            let task = do GreenTask::new(&mut sched.stack_pool, None) {
+                rtdebug!("boostraping a non-primary scheduler");
+            };
+            sched.bootstrap(task);
+        });
 
         return ret;
     }

branches/dist-snap/src/libgreen/sched.rs

@@ -171,7 +171,7 @@ impl Scheduler {
 
     // Take a main task to run, and a scheduler to run it in. Create a
     // scheduler task and bootstrap into it.
-    pub fn bootstrap(mut ~self) {
+    pub fn bootstrap(mut ~self, task: ~GreenTask) {
 
         // Build an Idle callback.
         let cb = ~SchedRunner as ~Callback;
@@ -187,11 +187,18 @@ impl Scheduler {
         self.idle_callback.get_mut_ref().resume();
 
         // Now, as far as all the scheduler state is concerned, we are inside
-        // the "scheduler" context. The scheduler immediately hands over control
-        // to the event loop, and this will only exit once the event loop no
-        // longer has any references (handles or I/O objects).
-        rtdebug!("starting scheduler {}", self.sched_id());
-        let mut sched_task = self.run(sched_task);
+        // the "scheduler" context. So we can act like the scheduler and resume
+        // the provided task. Let it think that the currently running task is
+        // actually the sched_task so it knows where to squirrel it away.
+        let mut sched_task = self.resume_task_immediately(sched_task, task);
+
+        // Now we are back in the scheduler context, having
+        // successfully run the input task. Start by running the
+        // scheduler. Grab it out of TLS - performing the scheduler
+        // action will have given it away.
+        let sched = sched_task.sched.take_unwrap();
+        rtdebug!("starting scheduler {}", sched.sched_id());
+        let mut sched_task = sched.run(sched_task);
 
         // Close the idle callback.
         let mut sched = sched_task.sched.take_unwrap();
@@ -541,10 +548,7 @@ impl Scheduler {
         // We push the task onto our local queue clone.
         assert!(!task.is_sched());
         self.work_queue.push(task);
-        match self.idle_callback {
-            Some(ref mut idle) => idle.resume(),
-            None => {} // allow enqueuing before the scheduler starts
-        }
+        self.idle_callback.get_mut_ref().resume();
 
         // We've made work available. Notify a
         // sleeping scheduler.
@@ -1172,21 +1176,25 @@ mod test {
                 let mut sh = special_handle;
                 sh.send(Shutdown);
             };
-            normal_sched.enqueue_task(normal_task);
+
 
             let special_task = do GreenTask::new(&mut special_sched.stack_pool,
                                                  None) {
                 run(task1);
                 run(task3);
                 chan.send(());
             };
-            special_sched.enqueue_task(special_task);
+
 
             let normal_sched = normal_sched;
-            let normal_thread = do Thread::start { normal_sched.bootstrap() };
+            let normal_thread = do Thread::start {
+                normal_sched.bootstrap(normal_task);
+            };
 
             let special_sched = special_sched;
-            let special_thread = do Thread::start { special_sched.bootstrap() };
+            let special_thread = do Thread::start {
+                special_sched.bootstrap(special_task);
+            };
 
             normal_thread.join();
             special_thread.join();

branches/dist-snap/src/libnative/io/file.rs

@@ -37,7 +37,7 @@ fn keep_going(data: &[u8], f: |*u8, uint| -> i64) -> i64 {
         let mut ret;
         loop {
             ret = f(data, amt);
-            if cfg!(not(windows)) { break } // windows has no eintr
+            if cfg!(windows) { break } // windows has no eintr
             // if we get an eintr, then try again
             if ret != -1 || os::errno() as int != eintr { break }
         }
@@ -73,7 +73,10 @@ impl FileDesc {
         FileDesc { fd: fd, close_on_drop: close_on_drop }
     }
 
-    fn inner_read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> {
+    // FIXME(#10465) these functions should not be public, but anything in
+    //               native::io wanting to use them is forced to have all the
+    //               rtio traits in scope
+    pub fn inner_read(&mut self, buf: &mut [u8]) -> Result<uint, IoError> {
         #[cfg(windows)] type rlen = libc::c_uint;
         #[cfg(not(windows))] type rlen = libc::size_t;
         let ret = keep_going(buf, |buf, len| {
@@ -899,7 +902,7 @@ pub fn utime(p: &CString, atime: u64, mtime: u64) -> IoResult<()> {
 
 #[cfg(test)]
 mod tests {
-    use super::{CFile, FileDesc};
+    use super::{CFile, FileDesc, CloseFd};
     use std::io;
     use std::libc;
     use std::os;

branches/dist-snap/src/libnative/io/mod.rs

@@ -55,7 +55,7 @@ fn unimpl() -> IoError {
     }
 }
 
-fn last_error() -> IoError {
+fn translate_error(errno: i32, detail: bool) -> IoError {
     #[cfg(windows)]
     fn get_err(errno: i32) -> (io::IoErrorKind, &'static str) {
         match errno {
@@ -79,14 +79,16 @@ fn last_error() -> IoError {
         }
     }
 
-    let (kind, desc) = get_err(os::errno() as i32);
+    let (kind, desc) = get_err(errno);
     IoError {
         kind: kind,
         desc: desc,
-        detail: Some(os::last_os_error())
+        detail: if detail {Some(os::last_os_error())} else {None},
     }
 }
 
+fn last_error() -> IoError { translate_error(os::errno() as i32, true) }
+
 // unix has nonzero values as errors
 fn mkerr_libc(ret: libc::c_int) -> IoResult<()> {
     if ret != 0 {
@@ -106,6 +108,17 @@ fn mkerr_winbool(ret: libc::c_int) -> IoResult<()> {
     }
 }
 
+#[cfg(unix)]
+fn retry(f: || -> libc::c_int) -> IoResult<libc::c_int> {
+    loop {
+        match f() {
+            -1 if os::errno() as int == libc::EINTR as int => {}
+            -1 => return Err(last_error()),
+            n => return Ok(n),
+        }
+    }
+}
+
 /// Implementation of rt::rtio's IoFactory trait to generate handles to the
 /// native I/O functionality.
 pub struct IoFactory;