---

yaml
---
r: 139874
b: refs/heads/try2
c: ab08b4f
h: refs/heads/master
v: v3

Author: brson

[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: 2a864852774e924f1f9bb68da34adca736211545
+refs/heads/try2: ab08b4fbfde7e9cc9e0de07aed17b4d4e06ccc3e
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libcore/pipes.rs

@@ -83,7 +83,6 @@ bounded and unbounded protocols allows for less code duplication.
 */
 
 use cast::{forget, reinterpret_cast, transmute};
-use cell::Cell;
 use either::{Either, Left, Right};
 use kinds::Owned;
 use libc;
@@ -902,51 +901,6 @@ pub fn entangle<T>() -> (SendPacket<T>, RecvPacket<T>) {
     (SendPacket(p), RecvPacket(p))
 }
 
-/** Spawn a task to provide a service.
-
-It takes an initialization function that produces a send and receive
-endpoint. The send endpoint is returned to the caller and the receive
-endpoint is passed to the new task.
-
-*/
-pub fn spawn_service<T:Owned,Tb:Owned>(
-            init: extern fn() -> (SendPacketBuffered<T, Tb>,
-                                  RecvPacketBuffered<T, Tb>),
-            service: ~fn(v: RecvPacketBuffered<T, Tb>))
-        -> SendPacketBuffered<T, Tb> {
-    let (client, server) = init();
-
-    // This is some nasty gymnastics required to safely move the pipe
-    // into a new task.
-    let server = Cell(server);
-    do task::spawn {
-        service(server.take());
-    }
-
-    client
-}
-
-/** Like `spawn_service_recv`, but for protocols that start in the
-receive state.
-
-*/
-pub fn spawn_service_recv<T:Owned,Tb:Owned>(
-        init: extern fn() -> (RecvPacketBuffered<T, Tb>,
-                              SendPacketBuffered<T, Tb>),
-        service: ~fn(v: SendPacketBuffered<T, Tb>))
-        -> RecvPacketBuffered<T, Tb> {
-    let (client, server) = init();
-
-    // This is some nasty gymnastics required to safely move the pipe
-    // into a new task.
-    let server = Cell(server);
-    do task::spawn {
-        service(server.take())
-    }
-
-    client
-}
-
 pub mod rt {
     use option::{None, Option, Some};
 

branches/try2/src/rt/arch/x86_64/morestack.S

@@ -54,7 +54,7 @@ MORESTACK:
 	// Calculate the CFA as on offset from %ebp
 	.cfi_def_cfa_register %rbp
 
-        subq $56, %rsp
+        subq $184, %rsp
 
 	// Save argument registers of the original function
 	movq %rdi,       (%rsp)
@@ -63,6 +63,14 @@ MORESTACK:
 	movq %rcx,     24(%rsp)
 	movq %r8,      32(%rsp)
 	movq %r9,      40(%rsp)
+	movdqa %xmm0,  48(%rsp)
+	movdqa %xmm1,  64(%rsp)
+	movdqa %xmm2,  80(%rsp)
+	movdqa %xmm3,  96(%rsp)
+	movdqa %xmm4, 112(%rsp)
+	movdqa %xmm5, 128(%rsp)
+	movdqa %xmm6, 144(%rsp)
+	movdqa %xmm7, 160(%rsp)
 
 	// Calculate the address of the stack arguments.
 	// We have the base pointer, __morestack's return address,
@@ -93,8 +101,16 @@ MORESTACK:
 	movq    24(%rsp), %rcx
 	movq    32(%rsp), %r8
 	movq    40(%rsp), %r9
-
-	addq $56, %rsp
+	movdqa  48(%rsp), %xmm0
+	movdqa  64(%rsp), %xmm1
+	movdqa  80(%rsp), %xmm2
+	movdqa  96(%rsp), %xmm3
+	movdqa 112(%rsp), %xmm4
+	movdqa 128(%rsp), %xmm5
+	movdqa 144(%rsp), %xmm6
+	movdqa 160(%rsp), %xmm7
+
+	addq $184, %rsp
 
         movq 8(%rbp),%r10       // Grab the return pointer.
         incq %r10               // Skip past the `ret` in our parent frame

branches/try2/src/test/bench/pingpong.rs

@@ -14,7 +14,8 @@
 
 extern mod std;
 
-use core::pipes::{spawn_service, recv};
+use core::cell::Cell;
+use core::pipes::*;
 use std::time::precise_time_s;
 
 proto! pingpong (
@@ -70,6 +71,52 @@ macro_rules! follow (
     )
 )
 
+
+/** Spawn a task to provide a service.
+
+It takes an initialization function that produces a send and receive
+endpoint. The send endpoint is returned to the caller and the receive
+endpoint is passed to the new task.
+
+*/
+pub fn spawn_service<T:Owned,Tb:Owned>(
+            init: extern fn() -> (SendPacketBuffered<T, Tb>,
+                                  RecvPacketBuffered<T, Tb>),
+            service: ~fn(v: RecvPacketBuffered<T, Tb>))
+        -> SendPacketBuffered<T, Tb> {
+    let (client, server) = init();
+
+    // This is some nasty gymnastics required to safely move the pipe
+    // into a new task.
+    let server = Cell(server);
+    do task::spawn {
+        service(server.take());
+    }
+
+    client
+}
+
+/** Like `spawn_service_recv`, but for protocols that start in the
+receive state.
+
+*/
+pub fn spawn_service_recv<T:Owned,Tb:Owned>(
+        init: extern fn() -> (RecvPacketBuffered<T, Tb>,
+                              SendPacketBuffered<T, Tb>),
+        service: ~fn(v: SendPacketBuffered<T, Tb>))
+        -> RecvPacketBuffered<T, Tb> {
+    let (client, server) = init();
+
+    // This is some nasty gymnastics required to safely move the pipe
+    // into a new task.
+    let server = Cell(server);
+    do task::spawn {
+        service(server.take())
+    }
+
+    client
+}
+
 fn switch<T:Owned,Tb:Owned,U>(+endp: core::pipes::RecvPacketBuffered<T, Tb>,
                       f: &fn(+v: Option<T>) -> U) -> U {
     f(core::pipes::try_recv(endp))

branches/try2/src/test/run-pass/pipe-detect-term.rs

@@ -18,7 +18,7 @@ extern mod std;
 use std::timer::sleep;
 use std::uv;
 
-use core::pipes;
+use core::cell::Cell;
 use core::pipes::{try_recv, recv};
 
 proto! oneshot (
@@ -30,12 +30,14 @@ proto! oneshot (
 pub fn main() {
     let iotask = &uv::global_loop::get();
 
-    pipes::spawn_service(oneshot::init, |p| { 
-        match try_recv(p) {
+    let (chan, port) = oneshot::init();
+    let port = Cell(port);
+    do spawn {
+        match try_recv(port.take()) {
           Some(*) => { fail!() }
           None => { }
         }
-    });
+    }
 
     sleep(iotask, 100);
 

branches/try2/src/test/run-pass/pipe-select.rs

@@ -17,8 +17,9 @@ extern mod std;
 use std::timer::sleep;
 use std::uv;
 
+use core::cell::Cell;
 use core::pipes;
-use core::pipes::{recv, select};
+use core::pipes::*;
 
 proto! oneshot (
     waiting:send {
@@ -32,13 +33,30 @@ proto! stream (
     }
 )
 
+pub fn spawn_service<T:Owned,Tb:Owned>(
+            init: extern fn() -> (SendPacketBuffered<T, Tb>,
+                                  RecvPacketBuffered<T, Tb>),
+            service: ~fn(v: RecvPacketBuffered<T, Tb>))
+        -> SendPacketBuffered<T, Tb> {
+    let (client, server) = init();
+
+    // This is some nasty gymnastics required to safely move the pipe
+    // into a new task.
+    let server = Cell(server);
+    do task::spawn {
+        service(server.take());
+    }
+
+    client
+}
+
 pub fn main() {
     use oneshot::client::*;
     use stream::client::*;
 
     let iotask = &uv::global_loop::get();
 
-    let c = pipes::spawn_service(stream::init, |p| { 
+    let c = spawn_service(stream::init, |p| { 
         error!("waiting for pipes");
         let stream::send(x, p) = recv(p);
         error!("got pipes");

branches/try2/src/test/run-pass/pipe-sleep.rs

@@ -13,19 +13,45 @@
 extern mod std;
 use std::timer::sleep;
 use std::uv;
+use core::cell::Cell;
 use core::pipes;
-use core::pipes::recv;
+use core::pipes::*;
 
 proto! oneshot (
     waiting:send {
         signal -> !
     }
 )
 
+
+/** Spawn a task to provide a service.
+
+It takes an initialization function that produces a send and receive
+endpoint. The send endpoint is returned to the caller and the receive
+endpoint is passed to the new task.
+
+*/
+pub fn spawn_service<T:Owned,Tb:Owned>(
+            init: extern fn() -> (SendPacketBuffered<T, Tb>,
+                                  RecvPacketBuffered<T, Tb>),
+            service: ~fn(v: RecvPacketBuffered<T, Tb>))
+        -> SendPacketBuffered<T, Tb> {
+    let (client, server) = init();
+
+    // This is some nasty gymnastics required to safely move the pipe
+    // into a new task.
+    let server = Cell(server);
+    do task::spawn {
+        service(server.take());
+    }
+
+    client
+}
+
 pub fn main() {
     use oneshot::client::*;
 
-    let c = pipes::spawn_service(oneshot::init, |p| { recv(p); });
+    let c = spawn_service(oneshot::init, |p| { recv(p); });
 
     let iotask = &uv::global_loop::get();
     sleep(iotask, 500);