Asynchronous IO in Rust - Enrico Risa - Codemotion Rome 2017
4 likes1,974 views
The document discusses asynchronous I/O in Rust, highlighting its current status in the standard library and various available crates for handling I/O operations. It emphasizes the advantages of async I/O such as improved throughput, lower memory usage, and scalability, while detailing the architecture and implementations using libraries like Mio and Tokio. The document also showcases examples of creating simple servers and handling futures in Rust, illustrating how to manage asynchronous operations effectively.
![The std::{io,net} way
use std::io::prelude::*;
use std::net::TcpStream;
fn main() {
let mut stream = TcpStream::connect(“127.0.0.1:2424").unwrap();
let _ = stream.read_exact(&mut [0; 128]);
}](https://image.slidesharecdn.com/vgqorihr0skqkucvhoha-signature-391e9508d7f25ab98be331b06a129ab6efbf4e75dcc2a23248bd0c705c628849-poli-170403072918/85/Asynchronous-IO-in-Rust-Enrico-Risa-Codemotion-Rome-2017-5-320.jpg)
![Hyper Service
#[derive(Clone, Copy)]
struct Hello;
impl Service for Hello {
type Request = Request;
type Response = Response;
type Error = hyper::Error;
type Future = FutureResult<Response, hyper::Error>;
fn call(&self, _req: Request) -> Self::Future {
let response = "Hello Rust!";
futures::future::ok(
Response::new()
.with_header(ContentLength(response.len() as u64))
.with_header(ContentType::plaintext())
.with_body(response)
)
}
}](https://image.slidesharecdn.com/vgqorihr0skqkucvhoha-signature-391e9508d7f25ab98be331b06a129ab6efbf4e75dcc2a23248bd0c705c628849-poli-170403072918/85/Asynchronous-IO-in-Rust-Enrico-Risa-Codemotion-Rome-2017-54-320.jpg)
Asynchronous IO in Rust - Enrico Risa - Codemotion Rome 2017
- 1. Asynchronous I/O in Rust Enrico Risa - OrientDB ROME 24-25 MARCH 2017
- 2. About You • Any async I/O ? • … with Rust? • … maybe Node.js
- 3. About Me • Java/Javascript developer at OrientDB @wolf4ood • Nightly Rust developer
- 4. This Talk • Async I/O for network • Current status in standard library • Crates available for doing async I/O
- 5. The std::{io,net} way use std::io::prelude::*; use std::net::TcpStream; fn main() { let mut stream = TcpStream::connect(“127.0.0.1:2424").unwrap(); let _ = stream.read_exact(&mut [0; 128]); }
- 6. Simple Server use std::io::Write; use std::net::TcpListener; use std::thread; fn main() { let listener = TcpListener::bind(“127.0.0.1:9123").unwrap(); println!("listening started, ready to accept”); for stream in listener.incoming() { thread::spawn(|| { let mut stream = stream.unwrap(); stream.write(b"Hello Worldrn").unwrap(); }); } }
- 7. Simple Web Server (Hyper 0.10.x) extern crate hyper; use hyper::server::{Server, Request, Response}; fn main() { let server = Server::http(“127.0.0.1:8080").unwrap(); let _guard = server.handle(|mut req: Request, mut res: Response| { res.send(b"Hello Rust"); }); println!("Listening on http://127.0.0.1:8080"); }
- 8. Based on Hyper • Iron • Rocket • Nickel • Pencil
- 9. Sync Architecture Process / Thread per connection
- 10. Async Architecture Process / Thread handles multiple connections Non Blocking “Event Driven”
- 12. Advantages of async I/O • Throughput • Lower Memory usage • Latency • Scalability
- 13. Async I/O Model • Readiness • Completion
- 14. READINESS read -> EWOULDBLOCK poll for readiness sockets ready read -> data
- 15. COMPLETION read -> OK fired in background do some stuff Poll for completion notifications
- 16. Async I/O with Rust
- 17. MIO
- 18. Metal I/O (mio) • I/O Abstraction over OS • Zero Cost Abstraction • Readiness Model • Event Loop • Handler with tokens https://github.com/carllerche/mio
- 19. Metal I/O (mio) • Very Low level • Manually tracking I/O events • Wire up a state machine Solid foundation of async in Rust
- 20. Abstraction over the metal for handling async computation
- 21. Something like • JS Promise • Java CompletableFuture
- 22. Future • Database Query • HTTP Request • CPU computation • Timeout • Read from a socket • ….
- 23. FUTURES
- 24. Futures • Composability • Error handling / Timeout / Cancellation • Ergonomics • Readiness / No Callback • Zero Cost https://aturon.github.io/blog/2016/08/11/futures/
- 25. How it looks in Rust pub trait Future { type Item; type Error; fn poll(&mut self) -> Poll<Self::Item, Self::Error>; }
- 26. How it looks in Rust pub enum Async<T> { Ready(T), NotReady, } pub type Poll<T, E> = Result<Async<T>, E>;
- 31. Executors • Current thread • Thread Pool • Event Loop
- 32. Combining Example fn get_person(id : i32) -> Box<Future<Item=Person,Error=()>> fn hello_person(person : Person) -> Box<Future<Item=String,Error=()>> get_person(1) .and_then(hello_person) .map(|s|{ let result: Result<String, ()> = Ok(format!("{} from Codemotion",s)); result });
- 33. Combining Example let pool = CpuPool::new_num_cpus(); let combined = get_person(1).and_then(hello_person).map(|s|{ let result: Result<String, ()> = Ok(format!("{} from Codemotion",s)); result }); let future = pool.spawn(combined); println!("{:?}",future.wait().unwrap());
- 34. Streams pub trait Stream { type Item; type Error; fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error>; }
- 35. Stream Example let (mut tx, rx) = mpsc::channel(10); thread::spawn(move ||{ let mut sender = tx; for i in 0..10 { sender = sender.send(i).wait().unwrap(); } }); rx.for_each(|val|{ println!("Got {:?}",val); Ok(()) }).wait();
- 36. Zero Cost • No Allocation in composition • One dynamic dispatch • No Synchronisation https://aturon.github.io/blog/2016/09/07/futures-design
- 38. Is it enough?
- 40. What is? Tokio is a platform for writing fast networking code in Rust.
- 41. Tokio (Core) • Built on top of mio and futures • Lower Level • Tcp Handlers • Timeout • Event Loop https://medium.com/@carllerche/announcing-tokio-df6bb4ddb34#.g9ugbqg71
- 42. Event Loop loop { let event = next_event(); dispatch(event); }
- 43. Tokio Event Loop • Core • Handle • Remote
- 44. Echo Server (Core) let mut core = Core::new().unwrap(); let handle = core.handle(); let address = "127.0.0.1:8080".parse().unwrap(); let acceptor = TcpListener::bind(&address,&handle).unwrap(); let server = acceptor.incoming().for_each(|(socket,address)|{ let (reader, writer) = socket.split(); let future = copy(reader,writer).then(|result|{ println!("{:?}", result); Ok(()) }); handle.spawn(future); Ok(()) }); core.run(server).unwrap();
- 45. Codec • Encoder • Decoder Describe how to encode and decode the frames via buffers
- 46. Codec Declaration pub struct ExampleCodec; impl Encoder for ExampleCodec { type Item = String; type Error = io::Error; fn encode(&mut self, msg: String, buf: &mut BytesMut) -> io::Result<()> {} } impl Decoder for ExampleCodec { type Item = String; type Error = io::Error; fn decode(&mut self, buf: &mut BytesMut) -> io::Result<Option<String>> { } }
- 47. Codec Usage let ( writer , reader) = socket.framed(CodemotionCodec).split();
- 48. Tokio Architecture Mio Futures Tokio Core Tokio Proto Tokio Service
- 49. Tokio Proto • Transport: encoding/deconding frames to the I/O source • Protocol: codec + protocol specification
- 50. Tokio Service • Higher level • Handle Request/Response in async way
- 51. Proto Impl struct ExampleProto; impl<T: Io + 'static> ServerProto<T> for ExampleProto { type Request = String; type Response = String; type Transport = Framed<T, ExampleCodec>; type BindTransport = Result<Self::Transport, io::Error>; fn bind_transport(&self, io: T) -> Self::BindTransport { Ok(io.framed(ExampleCodec)) } }
- 52. Service Impl pub struct ExampleService; impl Service for ExampleService { type Request = String; type Response = String; type Error = io::Error; type Future = BoxFuture<String, io::Error>; fn call(&self, req: String) -> Self::Future { let res = format!("{} from Codemotion",req) future::finished(res).boxed() } }
- 53. Hyper + Tokio = ♥
- 54. Hyper Service #[derive(Clone, Copy)] struct Hello; impl Service for Hello { type Request = Request; type Response = Response; type Error = hyper::Error; type Future = FutureResult<Response, hyper::Error>; fn call(&self, _req: Request) -> Self::Future { let response = "Hello Rust!"; futures::future::ok( Response::new() .with_header(ContentLength(response.len() as u64)) .with_header(ContentType::plaintext()) .with_body(response) ) } }
- 55. Hyper Server fn main() { let addr = “127.0.0.1:8080".parse().unwrap(); let server = Http::new().bind(&addr,|| Ok(Hello)).unwrap(); println!("Listening on port 8080”); server.run().unwrap(); }
- 56. Tokio Based Projects • Tokio Postgres • Tokio Redis • Tokio Memcache • Hyper • Tokio Curl • Telebot • Tokio IRC • ….more
- 57. Rust Rome https://www.meetup.com/it-IT/Rust-Roma
- 58. Thank You • Question ? • https://github.com/carllerche/mio • https://github.com/alexcrichton/futures-rs • https://tokio.rs