// 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. // tjc: I don't know why pub mod pipes { use core::cast::{forget, transmute}; pub enum state { empty, full, blocked, terminated } pub impl state : cmp::Eq { pure fn eq(&self, other: &state) -> bool { ((*self) as uint) == ((*other) as uint) } pure fn ne(&self, other: &state) -> bool { !(*self).eq(other) } } pub type packet = { mut state: state, mut blocked_task: Option, mut payload: Option }; pub fn packet() -> *packet unsafe { let p: *packet = cast::transmute(~{ mut state: empty, mut blocked_task: None::, mut payload: None:: }); p } #[abi = "rust-intrinsic"] 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(move x) } } pub fn swap_state_acq(+dst: &mut state, src: state) -> state { unsafe { transmute(rusti::atomic_xchg_acq(transmute(move dst), src as int)) } } pub fn swap_state_rel(+dst: &mut state, src: state) -> state { unsafe { transmute(rusti::atomic_xchg_rel(transmute(move dst), src as int)) } } pub fn send(-p: send_packet, -payload: T) { let p = p.unwrap(); let p = unsafe { uniquify(p) }; assert (*p).payload.is_none(); (*p).payload = move Some(move 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(move p); } } full => { fail ~"duplicate send" } blocked => { // The receiver will eventually clean this up. unsafe { forget(move p); } } terminated => { // The receiver will never receive this. Rely on drop_glue // to clean everything up. } } } pub fn recv(-p: recv_packet) -> Option { let p = p.unwrap(); let p = unsafe { uniquify(p) }; loop { let old_state = swap_state_acq(&mut (*p).state, blocked); match old_state { empty | blocked => { task::yield(); } full => { let mut payload = None; payload <-> (*p).payload; return Some(option::unwrap(move payload)) } terminated => { assert old_state == terminated; return None; } } } } pub fn sender_terminate(p: *packet) { let p = unsafe { uniquify(p) }; match swap_state_rel(&mut (*p).state, terminated) { empty | blocked => { // The receiver will eventually clean up. unsafe { forget(move p) } } full => { // This is impossible fail ~"you dun goofed" } terminated => { // I have to clean up, use drop_glue } } } pub fn receiver_terminate(p: *packet) { let p = unsafe { uniquify(p) }; match swap_state_rel(&mut (*p).state, terminated) { empty => { // the sender will clean up unsafe { forget(move 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 { mut p: Option<*packet>, } pub impl send_packet : Drop { fn finalize(&self) { if self.p != None { let mut p = None; p <-> self.p; sender_terminate(option::unwrap(move p)) } } } pub impl send_packet { fn unwrap() -> *packet { let mut p = None; p <-> self.p; option::unwrap(move p) } } pub fn send_packet(p: *packet) -> send_packet { send_packet { p: Some(p) } } pub struct recv_packet { mut p: Option<*packet>, } pub impl recv_packet : Drop { fn finalize(&self) { if self.p != None { let mut p = None; p <-> self.p; receiver_terminate(option::unwrap(move p)) } } } pub impl recv_packet { fn unwrap() -> *packet { let mut p = None; p <-> self.p; option::unwrap(move p) } } 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; pub enum ping = ::pipes::send_packet; pub enum 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(ptr::addr_of(x)) } }; let liberated_value = move *addr; cast::forget(move p); move liberated_value } pub fn liberate_pong(-p: pong) -> ::pipes::send_packet unsafe { let addr : *::pipes::send_packet = match &p { &pong(ref x) => { cast::transmute(ptr::addr_of(x)) } }; let liberated_value = move *addr; cast::forget(move p); move 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(move c, ping(move sp)); move rp } pub fn do_pong(-c: pong) -> (ping, ()) { let packet = ::pipes::recv(move c); if packet.is_none() { fail ~"sender closed the connection" } (liberate_pong(option::unwrap(move packet)), ()) } } 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(move c); if packet.is_none() { fail ~"sender closed the connection" } (liberate_ping(option::unwrap(move packet)), ()) } pub fn do_pong(-c: pong) -> ping { let (sp, rp) = ::pipes::entangle(); ::pipes::send(move c, pong(move sp)); move rp } } } fn client(-chan: pingpong::client::ping) { let chan = pingpong::client::do_ping(move chan); log(error, ~"Sent ping"); let (_chan, _data) = pingpong::client::do_pong(move chan); log(error, ~"Received pong"); } fn server(-chan: pingpong::server::ping) { let (chan, _data) = pingpong::server::do_ping(move chan); log(error, ~"Received ping"); let _chan = pingpong::server::do_pong(move chan); log(error, ~"Sent pong"); } fn main() { /* // Commented out because of option::get error let (client_, server_) = pingpong::init(); let client_ = ~mut some(client_); let server_ = ~mut some(server_); task::spawn {|move client_| let mut client__ = none; *client_ <-> client__; client(option::unwrap(client__)); }; task::spawn {|move server_| let mut server_ˊ = none; *server_ <-> server_ˊ; server(option::unwrap(server_ˊ)); }; */ }