Turbo Rails in Rust

Ruby is not the fastest language in the world, there is no doubt about it. This doesn't turn out to matter all that much – Ruby and its ecosystem has so much more to offer, making it a worthwhile tradeoff a lot of the times.

However, you might occasionally encounter workloads that are simply not suitable for Ruby. In this talk, we will explore building a native extension with Rust to speed up parts of Rails. (No prior experience with Rust required!) What does Rust has to offer in this scenario over plain-old C? Let's find out!

Transcript

1. ͜Μʹͪ͸ Hello!
2. ࢲ͸೔ຊޠ͕࿩ͤ·ͤΜ I don't speak Japanese
3. 
   αʔόʔΤϥʔͷͨΊ຋༁Ͱ͖·ͤΜͰͨ͠
   αʔόʔΤϥʔͷͨΊ຋༁Ͱ͖·ͤΜͰͨ͠
4. Godfrey Chan @chancancode
6. ొஃऀ Speaker
7. ొஃऀ The Altar Climber? Magic Ruby JS C Rust
8. ͱʹ͔͘ Anyway…
9. "
10. ຊ෺ͷΞϝϦΧྉཧ Authentic American Cuisine 4 Dec 2015 ≥ Portland Airport
11. #
13. 14ºC
14. 14ºC
15. 14ºCanada Χφμ
16. 14ºCanada Χφμ "It's 14 degrees in Canada."
17. 57ºF
18. 57ºF
19. 57ºFreedom ࣗ༝౓
20. 57ºFreedom ࣗ༝౓ "57 degrees of Freedom"
21. gem install canada
22. >> require "canada" => true >> " ".blank_eh? => true >> "hi".blank_eh? => false
23. Also available for mruby ! chancancode/mruby-canada
24. ͱʹ͔͘ Anyway…
26. Ϡϑμ͸Ͳ͜ʁ Where is Yehuda?
27. "The Fold"
28. Lesson* *Always check the fineprint!
29. ͱʹ͔͘ Anyway…
30. Ruby
31. High-level, predictable, dynamic, OOP, metaprogramming…
32. Slow
33. C
34. Low-level, imperative, dangerous…
35. Fast, closer to The Metal™…
36. Native Extensions Best of both worlds*
37. gem install json
38. gem install json JSON::Ext Native Extension JSON::Pure Pure Ruby
39. Native Extensions Best of both worlds*
40. Native Extensions Best of both worlds* * For the end-user
42. "Here’s a general value for Rails development: We will jump through hoops on the implementation to make the user-facing API nicer." David Heinemeier Hansson Creator of Ruby on Rails
43. "Here’s a general value for Rails development: We will jump through hoops on the implementation to make the user-facing API nicer." David Heinemeier Hansson Creator of Ruby on Rails developer experience
44. @SamSaffron
45. String#blank?
46. class String # A string is blank if it's empty or contains whitespaces only: # # ''.blank? # => true # ' '.blank? # => true # "\t\n\r".blank? # => true # ' blah '.blank? # => false # # Unicode whitespace is supported: # # "\u00a0".blank? # => true # # @return [true, false] def blank? /\A[[:space:]]*\z/ === self end end
47. ! SamSaffron/fast_blank
48. Up to 20x faster
49. Me
50. Knows just enough C to be dangerous
51. Knows just enough C to be dangerous ptr
52. Knows just enough C to be dangerous *ptr
53. Knows just enough C to be dangerous ***********ptr
54. Knows just enough C to be dangerous &&&&&&&ptr
55. SIGSEGV
57. Rust?
58. Yehuda Katz @wycats
60. TC39
61. Hack Without Fear!
62. Structs struct Circle { radius: f64 } impl Circle { fn new(r: f64) -> Circle { Circle { radius: r } } fn diameter(&self) -> f64 { self.radius * 2 } }
63. Structs struct Circle { radius: f64 } impl Circle { fn new(r: f64) -> Circle { Circle { radius: r } } fn diameter(&self) -> f64 { self.radius * 2 } } fn main() { let c = Circle::new(10.0); println!("{}", c.diameter()); }
64. Static Dispatch
65. Static Dispatch Allows Function Inlining
66. Function Inlining (Wikipedia) the primary benefit of inline expansion is to allow further optimizations
67. Allocation
68. Heap Allocation typedef struct { double side; } square; int main() { square* s = (square*)malloc(sizeof(square)); s->side = 10.0; printf("%f", diagonal(s)); free(square); }
69. Stack Allocation typedef struct { double side; } square; int main() { square s; s.side = 10.0; printf("%f", diagonal(s)); } "Stack" square diagonal(s) diagonal(s) main() {side: 10.0} 14.142135623
70. Stack Allocation • The stack pointer handles freeing memory (fast) • In Ruby, it is an optimization, never guaranteed
71. But! • The exact size for each function must be known at compile time • It's dangerous to give out pointers to the stack
72. Rust ownership makes stack allocation safe
73. Traits and Generics
74. Traits and Generics This is where it gets interesting!
75. Traits struct Circle { radius: f64 } struct Square { side: f64 }
76. Traits struct Circle { radius: f64 } struct Square { side: f64 } trait Shape { fn area(&self) -> f64; } impl Shape for Circle { fn area(&self) -> f64 { PI * self.radius.powf(2.0) } } impl Shape for Square { fn area(&self) -> f64 { self.side * self.side } }
77. Traits struct Circle { ... } struct Square { ... } trait Shape { ... } impl Shape for Circle { fn area(&self) -> f64 { PI * self.radius.powf(2.0) } } impl Shape for Square { fn area(&self) -> f64 { self.side * self.side } } fn main() { let s = Square::new(10.0); let c = Circle::new(10.0); println!("{}", s.area()); println!("{}", c.area()); }
78. Traits Are Where The Magic Is fn print_area<S: Shape>(shape: &S) { println!("{}", shape.area()); }
79. Still Static Dispatch!
80. It adds up... a lot!
81. Back to fast_blank
82. In C static VALUE rb_string_blank(VALUE str) { rb_encoding *enc; char *s, *e; enc = STR_ENC_GET(str); s = RSTRING_PTR(str); if (!s || RSTRING_LEN(str) == 0) return Qtrue; e = RSTRING_END(str); while (s < e) { int n; unsigned int cc = rb_enc_codepoint_len(...); switch (cc) { case 9: case 0xa: case 0xb: case 0xc: case 0xd: case 0x20: case 0x85: case 0xa0: case 0x1680: case 0x2000: case 0x2001: case 0x2002: case 0x2003: case 0x2004: case 0x2005: case 0x2006: case 0x2007: case 0x2008: case 0x2009: case 0x200a: case 0x2028: case 0x2029: case 0x202f: case 0x205f: case 0x3000: break; default: return Qfalse; } s += n; } return Qtrue; }
83. In Rust pub extern "C" fn fast_blank(buf: Buf) -> bool { buf.as_slice().chars().all(|c| c.is_whitespace()) }
84. =========== Test String Length: 6 =========== Rust 11.043M (± 3.5%) i/s - 54.744M C 10.583M (± 8.5%) i/s - 52.464M Ruby 964.469k (±27.6%) i/s - 4.390M
85. pub extern "C" fn fast_blank(buf: Buf) -> bool { buf.as_slice().chars().all(|c| c.is_whitespace()) }
86. pub extern "C" fn fast_blank(buf: Buf) -> bool { buf.as_slice().chars().all(|c| c.is_whitespace()) } *
88. extern crate libc; use std::{ptr, slice}; use std::marker::PhantomData; #[repr(C)] #[allow(raw_pointer_derive)] #[derive(Copy, Clone)] pub struct Buf<'a> { ptr: *mut u8, len: usize, marker: PhantomData<&'a ()>, } impl<'a> Buf<'a> { pub fn as_slice(self) -> &'a str { unsafe { let s = slice::from_raw_parts(self.ptr as *const u8, self.len); std::str::from_utf8_unchecked(s) } } } #[no_mangle] pub extern "C" fn fast_blank(buf: Buf) -> bool { buf.as_slice().unwrap().chars().all(|c| c.is_whitespace()) } #include <ruby.h> #include <ruby/encoding.h> typedef struct { void* data; size_t len; } fast_blank_buf_t; static inline fast_blank_buf_t STR2BUF(VALUE str) { return (fast_blank_buf_t) { .data = RSTRING_PTR(str), .len = RSTRING_LEN(str), }; } int fast_blank(fast_blank_buf_t); static VALUE rb_string_blank_p(VALUE str) { return fast_blank(STR2BUF(str)) ? Qtrue : Qfalse; } void Init_fast_blank() { rb_define_method(rb_cString, "blank?", rb_string_blank_p, 0); } Rust Code C Code
89. // Rust Code extern crate libc; use std::{ptr, slice}; use std::marker::PhantomData; #[repr(C)] #[allow(raw_pointer_derive)] #[derive(Copy, Clone)] pub struct Buf<'a> { ptr: *mut u8, len: usize, marker: PhantomData<&'a ()>, } impl<'a> Buf<'a> { pub fn as_slice(self) -> &'a str { unsafe { let s = slice::from_raw_parts(self.ptr as *const u8, self.len); std::str::from_utf8_unchecked(s) } } } #[no_mangle] pub extern "C" fn fast_blank(buf: Buf) -> bool { buf.as_slice().unwrap().chars().all(|c| c.is_whitespace()) } // C Code #include <ruby.h> #include <ruby/encoding.h> typedef struct { void* data; size_t len; } fast_blank_buf_t; static inline fast_blank_buf_t STR2BUF(VALUE str) { return (fast_blank_buf_t) { .data = RSTRING_PTR(str), .len = RSTRING_LEN(str), }; } int fast_blank(fast_blank_buf_t); static VALUE rb_string_blank_p(VALUE str) { return fast_blank(STR2BUF(str)) ? Qtrue : Qfalse; } void Init_fast_blank() { rb_define_method(rb_cString, "blank?", rb_string_blank_p, 0); } Rust Extension #include <stdio.h> #include <ruby.h> #include <ruby/encoding.h> #include <ruby/re.h> #define STR_ENC_GET(str) rb_enc_from_index(ENCODING_GET(str)) static VALUE rb_string_blank(VALUE str) { rb_encoding *enc; char *s, *e; enc = STR_ENC_GET(str); s = RSTRING_PTR(str); if (!s || RSTRING_LEN(str) == 0) return Qtrue; e = RSTRING_END(str); while (s < e) { int n; unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc); switch (cc) { case 9: case 0xa: case 0xb: case 0xc: case 0xd: case 0x20: case 0x85: case 0xa0: case 0x1680: case 0x2000: case 0x2001: case 0x2002: case 0x2003: case 0x2004: case 0x2005: case 0x2006: case 0x2007: case 0x2008: case 0x2009: case 0x200a: case 0x2028: case 0x2029: case 0x202f: case 0x205f: case 0x3000: break; default: return Qfalse; } s += n; } return Qtrue; } void Init_fast_blank() { rb_define_method(rb_cString, "blank?", rb_string_blank, 0); } C Extension
90. libcruby
91. extern crate libcruby; use libcruby::consts::*; use libcruby::types::*; extern "C" fn string_is_blank(receiver: String) -> Boolean { if receiver[..].chars().all(|c| c.is_whitespace()) { Qtrue } else { Qfalse } } #[no_mangle] pub extern "C" fn Init_fast_blank() { String.define_method::<String, Boolean>("blank?", string_is_blank); } Rust Extension #include <stdio.h> #include <ruby.h> #include <ruby/encoding.h> #include <ruby/re.h> #define STR_ENC_GET(str) rb_enc_from_index(ENCODING_GET(str)) static VALUE rb_string_blank(VALUE str) { rb_encoding *enc; char *s, *e; enc = STR_ENC_GET(str); s = RSTRING_PTR(str); if (!s || RSTRING_LEN(str) == 0) return Qtrue; e = RSTRING_END(str); while (s < e) { int n; unsigned int cc = rb_enc_codepoint_len(s, e, &n, enc); switch (cc) { case 9: case 0xa: case 0xb: case 0xc: case 0xd: case 0x20: case 0x85: case 0xa0: case 0x1680: case 0x2000: case 0x2001: case 0x2002: case 0x2003: case 0x2004: case 0x2005: case 0x2006: case 0x2007: case 0x2008: case 0x2009: case 0x200a: case 0x2028: case 0x2029: case 0x202f: case 0x205f: case 0x3000: break; default: return Qfalse; } s += n; } return Qtrue; } void Init_fast_blank() { rb_define_method(rb_cString, "blank?", rb_string_blank, 0); } C Extension
92. extern crate libcruby; use libcruby::consts::*; use libcruby::types::*; extern "C" fn string_is_blank(receiver: String) -> Boolean { if receiver[..].chars().all(|c| c.is_whitespace()) { Qtrue } else { Qfalse } } #[no_mangle] pub extern "C" fn Init_fast_blank() { String.define_method::<String, Boolean>("blank?", string_is_blank); }
93. extern use libcruby use libcruby extern if } } } #[no_mangle] pub extern String. } -> Boolean Qtrue Qfalse libcruby::types::Boolean
94. extern use libcruby use libcruby extern if } } } #[no_mangle] pub extern String. } String.define_method::<String, Boolean>("blank?", string_is_blank);
95. String.define_method::<String, Boolean>("blank?", string_is_blank);
96. String. String libcruby::consts::String
97. String. String extern { #[link_name = "rb_Qfalse"] pub static Qfalse: Boolean<'static>; #[link_name = "rb_Qtrue"] pub static Qtrue: Boolean<'static>; // ... #[link_name = "rb_cString"] pub static String: Class<'static>; #[link_name = "rb_mKernel"] pub static Kernel: Module<'static>; } libcruby::consts::String
98. String. String extern } #[link_name = "rb_cString"] pub static String: Class<'static>; libcruby::consts::String
99. String. String extern } rb_cString libcruby::consts::String
100. String. String extern } Class libcruby::consts::String
101. String. String extern } Class libcruby::consts::String libcruby::types::Class
102. String. .define_method extern { fn rb_define_method_id(receiver: VALUE, name: ID, func: *const c_void, argc: c_int); } #[repr(C)] pub struct Class { VALUE: VALUE } #[repr(C)] pub struct Module { VALUE: VALUE } trait Namespace { fn define_method(&self, name: &str, func: ...) { unsafe { rb_define_method_id(self.as_ptr(), intern(name), func); } } } impl Namespace for Module {} impl Namespace for Class {}
103. String. .define_method extern { fn rb_define_method_id } #[repr(C)] pub struct Class VALUE } #[repr(C)] pub struct Module VALUE } trait Namespace fn define_method } } impl Namespace impl Namespace trait Namespace { fn define_method(&self, name: &str, func: ...) { } } impl Namespace for Class {}
104. String. .define_method extern { fn rb_define_method_id } #[repr(C)] pub struct Class VALUE } #[repr(C)] pub struct Module VALUE } trait Namespace fn define_method } } impl Namespace impl Namespace extern { fn rb_define_method_id(receiver: VALUE, name: ID, func: *const c_void, argc: c_int); } rb_define_method_id(self.as_ptr(), intern(name), func);
105. String.define_method::<String, Boolean>("blank?", string_is_blank); rb_define_method_id(rb_cString, rb_intern("blank?"), string_is_blank, 0);
106. let str = String::new("zomg"); let quoted = str.send::<String>("inspect"); let obj_id = str.send::<Fixnum>("__id__");
107. let str = String::new("zomg"); let quoted = str.send::<String>("inspect"); let obj_id = str.send::<Fixnum>("__id__"); VALUE str = rb_str_new_cstr("zomg"); VALUE quoted = rb_func_call(str, rb_intern("inspect")); VALUE obj_id = rb_func_call(str, rb_intern("__id__"));
108. trb files class String def blank? -> bool <<-RUST self[..].chars().all(|c| c.is_whitespace()) RUST end end
109. Usage $ ruby extconf.rb $ make $ ruby -r ./fast_blank -e "p ' '.blank?" true $ ruby -r ./fast_blank -e "p ' nope '.blank?" false
110. trb + libcruby
111. Turbo Rails with Rust?
112. What about Ruby?
113. Channels Forbid Aliasing Functional Forbid Mutation Rust Forbid Both at the Same Time Shared or Mutable, Pick One
114. ͋Γ͕ͱ͏ Thank you!