Update dependencies (mio 0.6, slab 0.3)

Cargo.toml

@@ -11,18 +11,18 @@ license = "MIT/Apache-2.0"
 name = "coio"
 
 [dev-dependencies]
-clap = "2.1"
+clap = "2.16"
 env_logger = "0.3"
-num_cpus = "0.2"
+num_cpus = "1.1"
 
 [dependencies]
 context = "1.0"
 deque = "0.3"
 libc = "0.2"
-linked-hash-map = "0.0.9"
-mio = "0.5"
+linked-hash-map = "0.3.0"
+mio = "0.6"
 rand = "0.3"
-slab = { git = "https://github.com/carllerche/slab.git", rev = "44f9f41a1680e69db7d370d1912898fb0f90b1f8" }
+slab = "0.3.0"
 time = "0.1"
 
 [dependencies.log]

src/net/mod.rs

@@ -30,7 +30,7 @@ use std::time::Duration;
 #[cfg(unix)]
 use std::os::unix::io::{AsRawFd, RawFd};
 
-use mio::{Evented, EventSet, Token};
+use mio::{Evented, Ready, Token};
 
 use scheduler::{ReadyStates, ReadyType, Scheduler};
 use sync::spinlock::Spinlock;
@@ -59,7 +59,7 @@ pub struct GenericEvented<E: Evented + Debug> {
 
 impl<E: Evented + Debug> GenericEvented<E> {
     #[doc(hidden)]
-    pub fn new(inner: E, interest: EventSet) -> io::Result<GenericEvented<E>> {
+    pub fn new(inner: E, interest: Ready) -> io::Result<GenericEvented<E>> {
         let scheduler = try!(Scheduler::instance_or_err());
         let (token, ready_states) = try!(scheduler.register(&inner, interest));
 

src/net/tcp.rs

@@ -17,18 +17,17 @@ use std::net::{SocketAddr, ToSocketAddrs};
 #[cfg(unix)]
 use std::os::unix::io::{FromRawFd, RawFd};
 
-use mio::EventSet;
+use mio::Ready;
 use mio::tcp::{TcpListener as MioTcpListener, TcpStream as MioTcpStream};
 
-use scheduler::ReadyType;
-use super::{each_addr, make_timeout, GenericEvented, SyncGuard};
+use super::{each_addr, GenericEvented};
 
 macro_rules! create_tcp_listener {
-    ($inner:expr) => (TcpListener::new($inner, EventSet::readable()));
+    ($inner:expr) => (TcpListener::new($inner, Ready::readable()));
 }
 
 macro_rules! create_tcp_stream {
-    ($inner:expr) => (TcpStream::new($inner, EventSet::readable() | EventSet::writable()));
+    ($inner:expr) => (TcpStream::new($inner, Ready::readable() | Ready::writable()));
 }
 
 pub type TcpListener = GenericEvented<MioTcpListener>;
@@ -42,33 +41,14 @@ impl TcpListener {
     }
 
     pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {
-        let mut sync_guard = SyncGuard::new();
-
-        loop {
-            match self.get_inner().accept() {
-                Ok(None) => {
-                    trace!("TcpListener({:?}): accept() => WouldBlock", self.token);
-                }
-                Ok(Some((stream, addr))) => {
-                    trace!("TcpListener({:?}): accept() => Ok(..)", self.token);
-                    return create_tcp_stream!(stream).map(|stream| (stream, addr));
-                }
-                Err(err) => {
-                    trace!("TcpListener({:?}): accept() => Err(..)", self.token);
-                    return Err(err);
-                }
+        match self.get_inner().accept() {
+            Ok((stream, addr)) => {
+                trace!("TcpListener({:?}): accept() => Ok(..)", self.token);
+                return create_tcp_stream!(stream).map(|stream| (stream, addr));
             }
-
-            trace!("TcpListener({:?}): wait(Readable)", self.token);
-            sync_guard.disarm();
-
-            match *self.read_timeout.lock() {
-                None => self.ready_states.wait(ReadyType::Readable),
-                Some(t) => {
-                    if self.ready_states.wait_timeout(ReadyType::Readable, t) {
-                        return Err(make_timeout());
-                    }
-                }
+            Err(err) => {
+                trace!("TcpListener({:?}): accept() => Err(..)", self.token);
+                return Err(err);
             }
         }
     }

src/net/udp.rs

@@ -14,19 +14,21 @@ use std::net::{SocketAddr, ToSocketAddrs};
 #[cfg(unix)]
 use std::os::unix::io::{FromRawFd, RawFd};
 
-use mio::EventSet;
+use mio::Ready;
 use mio::udp::UdpSocket as MioUdpSocket;
 
 use scheduler::ReadyType;
 use super::{each_addr, make_timeout, GenericEvented, SyncGuard};
 
 macro_rules! create_udp_socket {
-    ($inner:expr) => (UdpSocket::new($inner, EventSet::readable() | EventSet::writable()));
+    ($inner:expr) => (UdpSocket::new($inner, Ready::readable() | Ready::writable()));
 }
 
 pub type UdpSocket = GenericEvented<MioUdpSocket>;
 
 impl UdpSocket {
+
+    /*
     /// Returns a new, unbound, non-blocking, IPv4 UDP socket
     pub fn v4() -> io::Result<UdpSocket> {
         let inner = try!(MioUdpSocket::v4());
@@ -38,17 +40,12 @@ impl UdpSocket {
         let inner = try!(MioUdpSocket::v6());
         create_udp_socket!(inner)
     }
+    */
 
     pub fn bind<A: ToSocketAddrs>(addr: A) -> io::Result<UdpSocket> {
         each_addr(addr, |addr| {
-            let sock = try!(match *addr {
-                SocketAddr::V4(..) => Self::v4(),
-                SocketAddr::V6(..) => Self::v6(),
-            });
-
-            try!(sock.bind(addr));
-
-            Ok(sock)
+            let inner = try!(MioUdpSocket::bind(addr));
+            create_udp_socket!(inner)
         })
     }
 

src/net/unix.rs

@@ -12,30 +12,29 @@ use std::io;
 use std::os::unix::io::{FromRawFd, RawFd};
 use std::path::Path;
 
-use mio::EventSet;
-use mio::unix::PipeReader as MioPipeReader;
-use mio::unix::PipeWriter as MioPipeWriter;
-use mio::unix::UnixListener as MioUnixListener;
-use mio::unix::UnixSocket as MioUnixSocket;
-use mio::unix::UnixStream as MioUnixStream;
+use mio::Ready;
+use mio::deprecated::unix::PipeReader as MioPipeReader;
+use mio::deprecated::unix::PipeWriter as MioPipeWriter;
+use mio::deprecated::unix::UnixListener as MioUnixListener;
+use mio::deprecated::unix::UnixSocket as MioUnixSocket;
+use mio::deprecated::unix::UnixStream as MioUnixStream;
 
-use scheduler::ReadyType;
-use super::{make_timeout, GenericEvented, SyncGuard};
+use super::GenericEvented;
 
 macro_rules! create_unix_listener {
-    ($inner:expr) => (UnixListener::new($inner, EventSet::readable()));
+    ($inner:expr) => (UnixListener::new($inner, Ready::readable()));
 }
 
 macro_rules! create_unix_stream {
-    ($inner:expr) => (UnixStream::new($inner, EventSet::readable() | EventSet::writable()));
+    ($inner:expr) => (UnixStream::new($inner, Ready::readable() | Ready::writable()));
 }
 
 macro_rules! create_pipe_reader {
-    ($inner:expr) => (PipeReader::new($inner, EventSet::readable()));
+    ($inner:expr) => (PipeReader::new($inner, Ready::readable()));
 }
 
 macro_rules! create_pipe_writer {
-    ($inner:expr) => (PipeWriter::new($inner, EventSet::writable()));
+    ($inner:expr) => (PipeWriter::new($inner, Ready::writable()));
 }
 
 #[derive(Debug)]
@@ -87,33 +86,14 @@ impl UnixListener {
     }
 
     pub fn accept(&self) -> io::Result<UnixStream> {
-        let mut sync_guard = SyncGuard::new();
-
-        loop {
-            match self.get_inner().accept() {
-                Ok(None) => {
-                    trace!("UnixListener({:?}): accept() => WouldBlock", self.token);
-                }
-                Ok(Some(stream)) => {
-                    trace!("UnixListener({:?}): accept() => Ok(..)", self.token);
-                    return create_unix_stream!(stream);
-                }
-                Err(err) => {
-                    trace!("UnixListener({:?}): accept() => Err(..)", self.token);
-                    return Err(err);
-                }
+        match self.get_inner().accept() {
+            Ok(stream) => {
+                trace!("UnixListener({:?}): accept() => Ok(..)", self.token);
+                return create_unix_stream!(stream);
             }
-
-            trace!("UnixListener({:?}): wait(Readable)", self.token);
-            sync_guard.disarm();
-
-            match *self.read_timeout.lock() {
-                None => self.ready_states.wait(ReadyType::Readable),
-                Some(t) => {
-                    if self.ready_states.wait_timeout(ReadyType::Readable, t) {
-                        return Err(make_timeout());
-                    }
-                }
+            Err(err) => {
+                trace!("UnixListener({:?}): accept() => Err(..)", self.token);
+                return Err(err);
             }
         }
     }
@@ -153,7 +133,7 @@ impl FromRawFd for UnixStream {
 }
 
 pub fn pipe() -> io::Result<(PipeReader, PipeWriter)> {
-    let (reader, writer) = try!(::mio::unix::pipe());
+    let (reader, writer) = try!(::mio::deprecated::unix::pipe());
     let reader = try!(create_pipe_reader!(reader));
     let writer = try!(create_pipe_writer!(writer));
     Ok((reader, writer))

src/runtime/timer.rs

@@ -47,7 +47,7 @@ impl<T> Timer<T> {
     pub fn new(tick_ms: u64, slots: usize, capacity: usize) -> Timer<T> {
         let mut timer = Timer {
             tick_ms: tick_ms,
-            entries: Slab::new(capacity.next_power_of_two()),
+            entries: Slab::with_capacity(capacity.next_power_of_two()),
             wheel: Vec::new(),
             start: 0,
             tick: 0,
@@ -63,12 +63,12 @@ impl<T> Timer<T> {
     #[allow(dead_code)]
     #[inline]
     pub fn count(&self) -> usize {
-        self.entries.count()
+        self.entries.len()
     }
 
     // Number of ms remaining until the next tick
     pub fn next_tick_in_ms(&self) -> Option<u64> {
-        if self.entries.count() == 0 {
+        if self.entries.len() == 0 {
             return None;
         }
 
@@ -137,9 +137,9 @@ impl<T> Timer<T> {
         let slot = (tick & self.mask) as usize;
         let curr = self.wheel[slot];
 
-        if !self.entries.has_remaining() {
-            let grow_by = self.entries.count() >> 1;
-            self.entries.grow(grow_by);
+        if !self.entries.has_available() {
+            let grow_by = self.entries.len() >> 1;
+            self.entries.reserve_exact(grow_by);
         }
 
         // Insert the new entry
@@ -255,6 +255,7 @@ impl<T> Timer<T> {
 
 // Doubly linked list of timer entries. Allows for efficient insertion /
 // removal of timeouts.
+#[derive(Debug)]
 struct Entry<T> {
     token: T,
     links: EntryLinks,
@@ -273,7 +274,7 @@ impl<T> Entry<T> {
     }
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Debug)]
 struct EntryLinks {
     tick: u64,
     prev: Token,