replaced deprecated function calls to Epoll in crate nix, which required quite some changes to the code in epoll.rs, mod.rs and tcp.rs

Author: rstade

build.sh

@@ -129,12 +129,13 @@ case $TASK in
         done
         ;;
     huge_pages)
-        sudo dpdk-hugepages.py -p 2M --setup 8G
-        sudo dpdk-hugepages.py -s
+	./hugepages.sh
+//        sudo dpdk-hugepages.py -p 2M --setup 8G
+//        sudo dpdk-hugepages.py -s
         ;;
     test)
         native
-        huge_pages
+        ./hugepages.sh
         pushd $BASE_DIR/framework
         export LD_LIBRARY_PATH="${NATIVE_LIB_PATH}:${DPDK_LD_PATH}:${TOOLS_BASE}:${LD_LIBRARY_PATH}"
 #        sudo -E env "PATH=$PATH" ${CARGO} test --release

framework/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "e2d2"
-version = "1.0.9"
-authors = ["Aurojit Panda <apanda@cs.berkeley.edu>", "Rainer Stademann"]
+version = "1.0.10"
+authors = ["Aurojit Panda <apanda@cs.berkeley.edu>", "Rainer Stademann <rainer.stademann@silverengine.de>"]
 build = "build.rs"
 
 [lib]
@@ -11,7 +11,7 @@ doctest = false
 libc = ">= 0.2.79"
 time = ">=0.1.0"
 chashmap = ">= 2.2.0"
-log = "0.3"
+log = ">=0.3"
 getopts = "*"
 byteorder = "*"
 fnv = "*"
@@ -21,15 +21,15 @@ lazy_static = "*"
 net2 = "*"
 # NIX restricts us to just unix for now, we can fix this if someone cares at a later point.
 nix = { version = ">=0.27.1", features =["event"] }
-toml = "0.6"
+toml = ">=0.6"
 # Hack for SHM
 uuid= { version = ">=0.7", features=["v4"] }
 tokio-core=">=0.1.8"
 futures=">=0.1.14"
 eui48 = { git= "https://github.com/readysettech/eui48.git", version= ">=1.1", features=["serde"] , default-features= false}
 separator =  ">= 0.3"
-serde_derive = "1.0"
-serde = "1.0"
+serde_derive = ">=1.0"
+serde = ">=1.0"
 ipnet = ">=1.0"
 
 [features]

framework/src/control/linux/epoll.rs

@@ -2,54 +2,56 @@ use super::{Available, HUP, NONE, READ, WRITE};
 
 use nix::sys::epoll::*;
 use std::default::Default;
-use std::os::unix::io::AsRawFd;
-use std::os::unix::io::RawFd;
+use std::os::fd::AsFd;
 use std::slice;
 
 pub type Token = u64;
 
 pub struct PollHandle {
-    epoll_fd: RawFd,
+    epoll: Epoll,
 }
 
 impl PollHandle {
-    pub fn schedule_read<Fd: AsRawFd>(&self, file: &Fd, token: Token) {
-        self.schedule_read_rawfd(file.as_raw_fd(), token);
-    }
+    // pub fn schedule_read<Fd: AsFd>(&self, file: &Fd, token: Token) {
+    //    self.schedule_read_rawfd(file, token).expect("schedule_read failed");
+    // }
 
-    pub fn schedule_read_rawfd(&self, fd: RawFd, token: Token) {
-        let mut event = EpollEvent::new(
+    pub fn schedule_read<Fd: AsFd>(&self, fd: &Fd, token: Token) {
+        let event = EpollEvent::new(
             EpollFlags::EPOLLIN | EpollFlags::EPOLLET | EpollFlags::EPOLLONESHOT,
             token,
         );
-        epoll_ctl(self.epoll_fd, EpollOp::EpollCtlMod, fd, &mut event).unwrap();
+        // epoll_ctl(self.epoll_fd, EpollOp::EpollCtlMod, fd, &mut event).unwrap();
+        self.epoll.add(fd, event).expect("Epoll::add failed");
     }
 
-    pub fn schedule_write<Fd: AsRawFd>(&self, file: &Fd, token: Token) {
-        self.schedule_write_rawfd(file.as_raw_fd(), token);
-    }
+    //pub fn schedule_write<Fd: AsRawFd>(&self, file: &Fd, token: Token) {
+    //    self.schedule_write_rawfd(file.as_raw_fd(), token);
+    //}
 
-    pub fn schedule_write_rawfd(&self, fd: RawFd, token: Token) {
+    pub fn schedule_write<Fd: AsFd>(&self, file: &Fd, token: Token) {
         let mut event = EpollEvent::new(
             EpollFlags::EPOLLOUT | EpollFlags::EPOLLET | EpollFlags::EPOLLONESHOT,
             token,
         );
-        epoll_ctl(self.epoll_fd, EpollOp::EpollCtlMod, fd, &mut event).unwrap();
+        //epoll_ctl(self.epoll_fd, EpollOp::EpollCtlMod, fd, &mut event).unwrap();
+        self.epoll.modify(file, &mut event).expect("Epoll.modify failed");
     }
 
     /// This assumes file is already set to be non-blocking. This must also be called only the first time round.
-    pub fn new_io_port<Fd: AsRawFd>(&self, file: &Fd, token: Token) {
-        self.new_io_fd(file.as_raw_fd(), token);
+    pub fn new_io_port<Fd: AsFd>(&self, file: &Fd, token: Token) {
+        self.new_io_fd(file, token);
     }
 
-    pub fn new_io_fd(&self, fd: RawFd, token: Token) {
-        let mut event = EpollEvent::new(EpollFlags::EPOLLET | EpollFlags::EPOLLONESHOT, token);
-        epoll_ctl(self.epoll_fd, EpollOp::EpollCtlAdd, fd, &mut event).unwrap();
+    pub fn new_io_fd<Fd: AsFd>(&self, fd: Fd, token: Token) {
+        let event = EpollEvent::new(EpollFlags::EPOLLET | EpollFlags::EPOLLONESHOT, token);
+        //epoll_ctl(self.epoll_fd, EpollOp::EpollCtlAdd, fd, &mut event).unwrap();
+        self.epoll.add(fd, event).expect("Epoll.add failed");
     }
 }
 
 pub struct PollScheduler {
-    epoll_fd: RawFd,
+    poll_handle: PollHandle,
     ready_tokens: Vec<EpollEvent>,
     events: usize,
 }
@@ -61,15 +63,15 @@ impl Default for PollScheduler {
 }
 
 impl PollScheduler {
-    pub fn new_poll_handle(&self) -> PollHandle {
-        PollHandle {
-            epoll_fd: self.epoll_fd,
-        }
+    pub fn poll_handle(&self) -> &PollHandle {
+        &self.poll_handle
     }
 
     pub fn new() -> PollScheduler {
         PollScheduler {
-            epoll_fd: epoll_create().unwrap(),
+            poll_handle: PollHandle {
+                epoll: Epoll::new(EpollCreateFlags::empty()).expect("Epoll::new failed"),
+            }, // epoll_create().unwrap(),
             ready_tokens: Vec::with_capacity(32),
             events: 0,
         }
@@ -97,7 +99,8 @@ impl PollScheduler {
         } else {
             let dest =
                 unsafe { slice::from_raw_parts_mut(self.ready_tokens.as_mut_ptr(), self.ready_tokens.capacity()) };
-            self.events = epoll_wait(self.epoll_fd, dest, 0).unwrap();
+            // self.events = epoll_wait(self.epoll_fd, dest, 0).unwrap();
+            self.events = self.poll_handle.epoll.wait(dest, 0).expect("Epoll::wait failed");
             unsafe { self.ready_tokens.set_len(self.events) };
             self.ready_tokens.pop()
         }

framework/src/control/mod.rs

@@ -1,5 +1,6 @@
 #[cfg(target_os = "linux")]
 pub use self::epoll::*;
+use std::os::fd::AsFd;
 
 #[cfg(target_os = "linux")]
 #[path = "linux/epoll.rs"]
@@ -8,36 +9,30 @@ mod epoll;
 pub mod sctp;
 pub mod tcp;
 
-use std::os::unix::io::RawFd;
-
 pub type Available = u64;
 
 pub const NONE: u64 = 0x0;
 pub const READ: u64 = 0x1;
 pub const WRITE: u64 = 0x2;
 pub const HUP: u64 = 0x4;
 
-pub struct IOScheduler {
-    fd: RawFd,
-    scheduler: PollHandle,
+pub struct IOScheduler<'fd, Fd: AsFd> {
+    fd: Fd,
+    scheduler: &'fd PollHandle,
     token: Token,
 }
 
-impl IOScheduler {
-    pub fn new(scheduler: PollHandle, fd: RawFd, token: Token) -> IOScheduler {
-        scheduler.new_io_fd(fd, token);
-        IOScheduler {
-            fd: fd,
-            scheduler: scheduler,
-            token: token,
-        }
+impl<'fd, Fd: AsFd> IOScheduler<'fd, Fd> {
+    pub fn new(scheduler: &'fd PollHandle, fd: Fd, token: Token) -> IOScheduler<Fd> {
+        scheduler.new_io_fd(fd.as_fd(), token);
+        IOScheduler { fd, scheduler, token }
     }
 
     pub fn schedule_read(&self) {
-        self.scheduler.schedule_read_rawfd(self.fd, self.token);
+        self.scheduler.schedule_read(&self.fd, self.token);
     }
 
     pub fn schedule_write(&self) {
-        self.scheduler.schedule_write_rawfd(self.fd, self.token);
+        self.scheduler.schedule_write(&self.fd, self.token);
     }
 }

framework/src/control/tcp.rs

@@ -1,4 +1,4 @@
-use super::{Available, IOScheduler, PollHandle, PollScheduler, Token, HUP, READ, WRITE};
+use super::{Available, PollScheduler, Token, HUP, READ, WRITE};
 use fnv::FnvHasher;
 /// TCP connection.
 use net2::TcpBuilder;
@@ -8,10 +8,9 @@ use std::collections::HashMap;
 use std::hash::BuildHasherDefault;
 use std::marker::PhantomData;
 use std::net::*;
-use std::os::unix::io::AsRawFd;
 
 pub trait TcpControlAgent {
-    fn new(address: SocketAddr, stream: TcpStream, scheduler: IOScheduler) -> Self;
+    fn new(address: SocketAddr, stream: TcpStream) -> Self;
     fn handle_read_ready(&mut self) -> bool;
     fn handle_write_ready(&mut self) -> bool;
     fn handle_hup(&mut self) -> bool;
@@ -21,7 +20,6 @@ type FnvHash = BuildHasherDefault<FnvHasher>;
 pub struct TcpControlServer<T: TcpControlAgent> {
     listener: TcpListener,
     scheduler: PollScheduler,
-    handle: PollHandle,
     next_token: Token,
     listener_token: Token,
     phantom_t: PhantomData<T>,
@@ -53,13 +51,12 @@ impl<T: TcpControlAgent> TcpControlServer<T> {
         listener.set_nonblocking(true).unwrap();
         let scheduler = PollScheduler::new();
         let listener_token = 0;
-        let handle = scheduler.new_poll_handle();
+        let handle = scheduler.poll_handle();
         handle.new_io_port(&listener, listener_token);
         handle.schedule_read(&listener, listener_token);
         TcpControlServer {
             listener,
             scheduler,
-            handle,
             next_token: listener_token + 1,
             listener_token,
             phantom_t: PhantomData,
@@ -88,15 +85,9 @@ impl<T: TcpControlAgent> TcpControlServer<T> {
                     let token = self.next_token;
                     self.next_token += 1;
                     stream.set_nonblocking(true).unwrap();
-                    let stream_fd = stream.as_raw_fd();
-                    self.connections.insert(
-                        token,
-                        T::new(
-                            addr,
-                            stream,
-                            IOScheduler::new(self.scheduler.new_poll_handle(), stream_fd, token),
-                        ),
-                    );
+                    //let stream_fd = stream.as_fd();
+                    //let scheduler = IOScheduler::new(self.scheduler.poll_handle(), stream_fd.clone(), token);
+                    self.connections.insert(token, T::new(addr, stream));
                     // Add to some sort of hashmap.
                 }
                 Err(_) => {
@@ -106,7 +97,9 @@ impl<T: TcpControlAgent> TcpControlServer<T> {
         } else {
             // TODO: Report something.
         }
-        self.handle.schedule_read(&self.listener, self.listener_token);
+        self.scheduler
+            .poll_handle()
+            .schedule_read(&self.listener, self.listener_token);
     }
 
     fn handle_data(&mut self, token: Token, available: Available) {