// xfail-fast // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. use core::util; // tjc: I don't know why pub mod pipes { use core::util; use core::cast::{forget, transmute}; pub struct Stuff { state: state, blocked_task: Option, payload: Option } #[deriving(Eq)] pub enum state { empty, full, blocked, terminated } pub struct packet { state: state, blocked_task: Option, payload: Option } pub fn packet() -> *packet { unsafe { let p: *packet = cast::transmute(~Stuff{ state: empty, blocked_task: None::, payload: None:: }); p } } mod rusti { pub fn atomic_xchg(_dst: &mut int, _src: int) -> int { fail!(); } pub fn atomic_xchg_acq(_dst: &mut int, _src: int) -> int { fail!(); } pub fn atomic_xchg_rel(_dst: &mut int, _src: int) -> int { fail!(); } } // We should consider moving this to ::core::unsafe, although I // suspect graydon would want us to use void pointers instead. pub unsafe fn uniquify(x: *T) -> ~T { unsafe { cast::transmute(x) } } pub fn swap_state_acq(dst: &mut state, src: state) -> state { unsafe { transmute(rusti::atomic_xchg_acq(transmute(dst), src as int)) } } pub fn swap_state_rel(dst: &mut state, src: state) -> state { unsafe { transmute(rusti::atomic_xchg_rel(transmute(dst), src as int)) } } pub fn send(mut p: send_packet, payload: T) { let mut p = p.unwrap(); let mut p = unsafe { uniquify(p) }; assert!((*p).payload.is_none()); (*p).payload = Some(payload); let old_state = swap_state_rel(&mut (*p).state, full); match old_state { empty => { // Yay, fastpath. // The receiver will eventually clean this up. unsafe { forget(p); } } full => { fail!(~"duplicate send") } blocked => { // The receiver will eventually clean this up. unsafe { forget(p); } } terminated => { // The receiver will never receive this. Rely on drop_glue // to clean everything up. } } } pub fn recv(mut p: recv_packet) -> Option { let mut p = p.unwrap(); let mut p = unsafe { uniquify(p) }; loop { let old_state = swap_state_acq(&mut (*p).state, blocked); match old_state { empty | blocked => { task::yield(); } full => { let payload = util::replace(&mut p.payload, None); return Some(payload.unwrap()) } terminated => { assert!(old_state == terminated); return None; } } } } pub fn sender_terminate(mut p: *packet) { let mut p = unsafe { uniquify(p) }; match swap_state_rel(&mut (*p).state, terminated) { empty | blocked => { // The receiver will eventually clean up. unsafe { forget(p) } } full => { // This is impossible fail!(~"you dun goofed") } terminated => { // I have to clean up, use drop_glue } } } pub fn receiver_terminate(mut p: *packet) { let mut p = unsafe { uniquify(p) }; match swap_state_rel(&mut (*p).state, terminated) { empty => { // the sender will clean up unsafe { forget(p) } } blocked => { // this shouldn't happen. fail!(~"terminating a blocked packet") } terminated | full => { // I have to clean up, use drop_glue } } } pub struct send_packet { p: Option<*packet>, } #[unsafe_destructor] impl Drop for send_packet { fn finalize(&self) { unsafe { if self.p != None { let self_p: &mut Option<*packet> = cast::transmute(&self.p); let p = util::replace(self_p, None); sender_terminate(p.unwrap()) } } } } pub impl send_packet { fn unwrap(&mut self) -> *packet { util::replace(&mut self.p, None).unwrap() } } pub fn send_packet(p: *packet) -> send_packet { send_packet { p: Some(p) } } pub struct recv_packet { p: Option<*packet>, } #[unsafe_destructor] impl Drop for recv_packet { fn finalize(&self) { unsafe { if self.p != None { let self_p: &mut Option<*packet> = cast::transmute(&self.p); let p = util::replace(self_p, None); receiver_terminate(p.unwrap()) } } } } pub impl recv_packet { fn unwrap(&mut self) -> *packet { util::replace(&mut self.p, None).unwrap() } } pub fn recv_packet(p: *packet) -> recv_packet { recv_packet { p: Some(p) } } pub fn entangle() -> (send_packet, recv_packet) { let p = packet(); (send_packet(p), recv_packet(p)) } } pub mod pingpong { use core::cast; use core::ptr; use core::util; pub struct ping(::pipes::send_packet); pub struct pong(::pipes::send_packet); pub fn liberate_ping(p: ping) -> ::pipes::send_packet { unsafe { let addr : *::pipes::send_packet = match &p { &ping(ref x) => { cast::transmute(x) } }; let liberated_value = *addr; cast::forget(p); liberated_value } } pub fn liberate_pong(p: pong) -> ::pipes::send_packet { unsafe { let addr : *::pipes::send_packet = match &p { &pong(ref x) => { cast::transmute(x) } }; let liberated_value = *addr; cast::forget(p); liberated_value } } pub fn init() -> (client::ping, server::ping) { ::pipes::entangle() } pub mod client { use core::option; use pingpong; pub type ping = ::pipes::send_packet; pub type pong = ::pipes::recv_packet; pub fn do_ping(c: ping) -> pong { let (sp, rp) = ::pipes::entangle(); ::pipes::send(c, pingpong::ping(sp)); rp } pub fn do_pong(c: pong) -> (ping, ()) { let packet = ::pipes::recv(c); if packet.is_none() { fail!(~"sender closed the connection") } (pingpong::liberate_pong(packet.unwrap()), ()) } } pub mod server { use pingpong; pub type ping = ::pipes::recv_packet; pub type pong = ::pipes::send_packet; pub fn do_ping(c: ping) -> (pong, ()) { let packet = ::pipes::recv(c); if packet.is_none() { fail!(~"sender closed the connection") } (pingpong::liberate_ping(packet.unwrap()), ()) } pub fn do_pong(c: pong) -> ping { let (sp, rp) = ::pipes::entangle(); ::pipes::send(c, pingpong::pong(sp)); rp } } } fn client(chan: pingpong::client::ping) { let chan = pingpong::client::do_ping(chan); error!(~"Sent ping"); let (_chan, _data) = pingpong::client::do_pong(chan); error!(~"Received pong"); } fn server(chan: pingpong::server::ping) { let (chan, _data) = pingpong::server::do_ping(chan); error!(~"Received ping"); let _chan = pingpong::server::do_pong(chan); error!(~"Sent pong"); } pub fn main() { /* // Commented out because of option::get error let (client_, server_) = pingpong::init(); let client_ = Cell(client_); let server_ = Cell(server_); task::spawn {|client_| let client__ = client_.take(); client(client__); }; task::spawn {|server_| let server__ = server_.take(); server(server_ˊ); }; */ }