Skip to content

Latest commit

 

History

History
116 lines (69 loc) · 5.17 KB

README.md

File metadata and controls

116 lines (69 loc) · 5.17 KB
Raw

RustNethuns: a rewrite in Rust of the Nethuns unified API for fast and portable network programming

RustNethuns is a rewrite in Rust of Nethuns, a fast C-based network I/O library. The aim of this work has been to evaluate the high performance and strong safety claims made by the Rust programming language, specifically in the domain of low-level network programming.

This project serves as the central element of Riccardo Sagramoni's MSc thesis in Computer Engineering.

Related resources

  • Final thesis document (GitHub)
  • Performance evaluation of the RustNethuns library (GitHub)
  • Safety analysis of the RustNethuns’s socket model with the Miri interpreter (GitHub)

What is Nethuns?

Nethuns is a software library (originally written in C) that provides a unified API to access and manage low-level network operations over different underlying network I/O frameworks, and consequently operating systems. The design of Nethuns originates from the practical requirement of developing portable network applications with extremely high data rate target. Instead of re-writing the applications to match the underlying network I/O engines available over the different operating systems, Nethuns offers a unified abstraction layer that allows programmers to implement their applications regardless of the underlying technology. Therefore, network applications that use the Nethuns library only need to be re-compiled to run on top of a different engine (chosen in the set of the ones available for the OS), with no need for code adaptation.

Nethuns would like to fill the lack of a unified network abstraction in the software domain, which is instead present in the hardware domain thanks to P4. Nethuns should play a similar role to that entrusted to the pcap library in the past. In addition, it adds support for recent technologies such as AF_XDP and concurrency. Of course, all of this is provided to network programmers while minimizing the overhead, in order not to impact the performance of native underlying network I/O frameworks. The API exposed by Nethuns recalls the interface of UNIX sockets to make immediate and simple its adoption to experienced network programmers.

Currently, the Rust-based Nethuns library fully supports only the netmap framework for fast packet I/O over Linux.

Why a Rust-based Nethuns library?

The Rust programming language is able to maintains analogous performance of the C programming language, while ensuring a significant higher level of memory and thread safety, mostly at compilation time. These features makes Rust a suitable candidate for replacing C and C++ (which are unsafe and error-prone to use) in the domain of network programming.

RustNethuns basic API

  • Open a new socket using the options in opt
let socket: BindableNethunsSocket = BindableNethunsSocket::open(options).unwrap();
  • Bind the socket to a specific queue/any queue of dev
let socket: NethunsSocket = socket.bind(dev, queue).unwrap();
  • Get the next unprocessed received packet
let packet: RecvPacket = socket.recv().unwrap()
  • Release a buffer previously obtained from NethunsSocket::recv()
drop(packet); // <-- optional (it will automatically called when `packet` goes out of scope)
  • Queue up a packet for transmission
socket.send(packet).unwrap();
  • Send all queued up packets
socket.flush().unwrap();
  • Unbind the device and destroy the socket
drop(socket); // <-- optional (it will automatically called when `socket` goes out of scope)

Dependencies

The RustNethuns library relies on the following dependencies:

  • rustc compiler.
  • libclang library with Clang 5.0 or greater, needed to automatically generate the bindings to the underlying C-based I/O frameworks.
  • netmap library, needed to enable netmap support.

Cargo features

  • netmap: enables the netmap framework for network I/O.
  • NETHUNS_USE_BUILTIN_PCAP_READER: use a built-in reader for PCAP files in place of the standard one for NethunsSocketPcap. The built-in reader gives both reading and writing capabilities to the programmer, whereas the standard one allows only reading.

Using the library to implement a brand new application

The current version of the library is not ready to be published on crates.io, so you need to specify RustNethuns as a git dependency.

Credits

Author

  • Riccardo Sagramoni

Supervisors

  • Prof. Giuseppe Lettieri
  • Prof. Gregorio Procissi

Others

The Lartia group for the original C-based Nethuns library.