The rise of Firefox Quantum & Rust

Learn about core concepts behind Rust & Firefox Quantum

Transcript

1. The Rise of FireFox Quantum
2. About Me. 2 I am Vigneshwer AI Researcher Author of Rust CookBook moz://a Techspeaker
4. Objective 4 Entering the Quantum Era - How Firefox got fast again & where it’s going to get faster Rust Core Concepts - Ownership & Borrowing - Concurrency Paradigms - About Community, Tooling & Library ecosystem -
5. History: How did it all begin?
6. Browsers Compete for Performance & Need Safety at it’s core
9. 9 Systems programming for all Systems programming for all
10. 1 What Rust has to offer Strong safety guarantees… No segfaults, no data-races, expressive type system. …without compromising on performance. No garbage collector, no runtime. Goal: Confident, productive systems programming
13. Project Quantum
14. 14 Gradual adoption works.
17. Quantum Compositor
18. Quantum Dom
19. Quantum CSS (aka Stylo)
20. Quantum Render (aka Web Render)
21. Where are we with Rust?
22. 2016 -17 Rust is the Most Loved Language by Developers
23. Friends of Rust Organizations running Rust in production. (https://www.rust-lang.org/en-US/friends.html)
24. 24 Photo credit: Amelia Wells https://www.flickr.com/photos/speculummundi/6424242877/ Memory safety
25. 25 Zero-cost abstractions Memory safety & data-race freedom + = Confident, productive systems programming
26. What is Control? void example() { vector<string> vector; … auto& elem = vector[0]; … } string [0] … elem vector data length capacity [0] [n] […] … ‘H’ … ‘e’ Stack and inline layout. Lightweight references Deterministic destruction Stack Heap C++
27. void example() { vector<string> vector; … auto& elem = vector[0]; vector.push_back(some_string); cout << elem; } vector data length capacity [0] … [0] [1] elem Aliasing: more than one pointer to same memory. Dangling pointer: pointer to freed memory. Mutating the vector freed old contents. C++ Memory safety
28. ~ Ownership and Borrowing ~ Type Ownership Alias? Mutate? T Owned ✓
29. Ownership n. The act, state, or right of possessing something. 29
30. data length capacity fn main() { let mut book = Vec::new(); book.push(…); book.push(…); publish(book); publish(book); } fn publish(book: Vec<String>) { … } Ownership Take ownership of the vector 30 Error: use of moved value: `book` String book data length capacity [0] [1] data length capacity ~~~~~~~~~~~ Give ownership.
31. 31 “Manual” memory management in Rust: Values owned by creator. Values moved via assignment. When final owner returns, value is freed. Feels invisible. ]
32. Borrow v. To receive something with the promise of returning it. 32
33. ~ Ownership and Borrowing ~ Type Ownership T Alias? Mutate? Owned ✓ &T Shared reference ✓
34. fn main() { let mut book = Vec::new(); book.push(…); book.push(…); let p = &book; publish(p); publish(p); } fn publish(book: &Vec<String>) { … } Shared borrow Change type to a reference to a vector 34 String book data length capacity [0] [1] Borrow the vector, creating a reference p book
35. cannot mutate while shared 35 Shared data: immutable let mut book = Vec::new(); book.push(…); { let r = &book; book.push(…); r.push(…); } book.push(…); book mutable here ~~~~~~~~~~~ book borrowed here ~~~~~~~~~ * Actually: mutation only under controlled circumstances * now book is mutable again r goes out of scope; borrow ends
36. ~ Ownership and Borrowing ~ Type Ownership T &T Alias? Mutate? Owned Shared reference ✓ ✓ &mut T Mutable reference ✓
37. fn main() { let mut book = Vec::new(); book.push(…); book.push(…); edit(&mut book); edit(&mut book); } fn edit(book: &mut Vec<String>) { book.push(…); } Mutable borrow Mutable reference to a vector 37 String book data length capacity [0] [1] book [2] Mutable borrow [3]
38. cannot access while borrowed but &mut ref can mutate 38 Mutable references: no other access let mut book = Vec::new(); book.push(…); { let r = &mut book; book.len(); r.push(…); } book.push(…); book mutable here ~~~~~~~~~ book borrowed here borrow ended; accessible again r goes out of scope; borrow ends
39. 39 Parallelism Photo credit: Dave Gingrich https://www.flickr.com/photos/ndanger/2744507570/
40. Library-based concurrency 40 Originally: Rust had message passing built into the language. Now: library-based, multi-paradigm. Libraries leverage ownership and traits to avoid data races.
41. Data races Sharing Mutation No ordering Data race Sound familiar? 41
42. fn qsort(vec: &mut [i32]) { if vec.len() <= 1 { return; } let pivot = vec[random(vec.len())]; let mid = vec.partition(vec, pivot); let (less, greater) = vec.split_at_mut(mid); rayon::join(|| qsort(less), || qsort(greater)); } [0] [1] [2] [3] […] [n] vec: &mut [i32] less: &mut [i32] greater: &mut [i32] `&mut` can safely go between threads — because it is unaliased! fn split_at_mut<‘a>(v: &’a mut [T], …) -> (&’a mut [T], &’a mut [T])
43. 43 Parallel iterators trait ParallelIterator { type Item; … } vec1.par_iter() .zip(vec2) .map(|(i, j)| i * j) .sum() join( || /* seq iter */, || /* seq iter */)
44. 0 fn sync_inc(counter: &Mutex<i32>) { let mut data: Guard<i32> = counter.lock(); *data += 1; } counter data https://commons.wikimedia.org/wiki/File:No-DRM_lock.svg 1
45. ~ Concurrency paradigms ~ Paradigm Fork-join Ownership? Borrowing? ✓ Message Passing Locking ✓ ✓ ✓ Lock-free Futures … ✓ ✓ ✓ ✓
46. 46 Community Photo credit: David McSpadden https://www.flickr.com/photos/familyclan/15535822737/
47. 47 From http://jvns.ca/blog/2016/09/11/rustconf-keynote/ Open and welcoming
48. 48 Almost 40 working groups spread across 7 Rust “teams”
49. 49 RFC Process
51. Rust Trailheads Follow us on Twitter: @rustlang @ThisWeekInRust Join Rust IRC Channels: #rust #rust-community #rust-machine-learning #tensorflow-rust Join Rust Websites: rust-lang.org rustbyexample.com rustaceans.org reddit.com/r/rust/ 51
52. Thanks! 52 Twitter @dvigneshwer Instagram @dvigneshwer Email dvigneshwer@gmail.com Website dvigneshwer.github.io/