Turbo Rails with Rust

"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

View Slide

developer experience

View Slide

@SamSaffron

View Slide

String#blank?

View Slide

class String
def blank?
/\A[[:space:]]*\z/ === self
end
end

View Slide

! SamSaffron/fast_blank

View Slide

UP TO 20X FASTER*

View Slide

&
ME

View Slide

&
ME
knows just enough C to be dangerous

&
ME
ptr

&
ME
*ptr

&
ME
**********ptr

&
ME
&&&&&&&&&&&&&&&&&&&&ptr

'
SEGV

FEATHERWEIGHT
AGENT

RUST

Rust is a systems programming language that runs
blazingly fast, prevents segfaults, and guarantees
thread safety.

View Slide

HACK WITHOUT FEAR

View Slide

This is Rust.
Rust has a compiler.
Rust's compiler ﬁnds errors at compile-
time.
Rust's compiler guarantees the compiled
program cannot crash at runtime.
Be like Rust.

View Slide

without garbage collection
MEMORY SAFETY

View Slide

without data races
CONCURRENCY

View Slide

ZERO-COST ABSTRACTIONS

View Slide

BACK TO FAST_BLANK

View Slide

FAST_BLANK IN C

View Slide

static VALUE rb_str_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:
/* found */
break;
default:
return Qfalse;
}
s += n;
}
return Qtrue;
}

View Slide

rb_encoding *enc;
char *s, *e;
while (s < e) {
int n;
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:
/* found */
break;
default:
return Qfalse;
}
s += n;
}
return Qtrue;
}
}

View Slide

rb_encoding *enc;
char *s, *e;
while (s < e) {
int n;
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:
/* found */
break;
default:
return Qfalse;
}
s += n;
}
return Qtrue;
}
// …boilerplate…
}

View Slide

rb_encoding *enc;
char *s, *e;
while (s < e) {
int n;
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:
/* found */
break;
default:
return Qfalse;
}
s += n;
}
return Qtrue;
}
}

View Slide

rb_encoding *enc;
char *s, *e;
while (s < e) {
int n;
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:
/* found */
break;
default:
return Qfalse;
}
s += n;
}
return Qtrue;
}
while(s < RSTRING_END(str)) {
s++;
}
}

View Slide

rb_encoding *enc;
char *s, *e;
while (s < e) {
int n;
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:
/* found */
break;
default:
return Qfalse;
}
s += n;
}
return Qtrue;
}
s++;
}
}

View Slide

rb_encoding *enc;
char *s, *e;
while (s < e) {
int n;
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:
/* found */
break;
default:
return Qfalse;
}
s += n;
}
return Qtrue;
}
switch (s) {
}
s++;
}
}

View Slide

rb_encoding *enc;
char *s, *e;
while (s < e) {
int n;
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:
/* found */
break;
default:
return Qfalse;
}
s += n;
}
return Qtrue;
}
switch (cc) {
case 9: case 0xa: … case 0x205f: case 0x3000:
// whitespace
break;
}
s++;
}
}

View Slide

rb_encoding *enc;
char *s, *e;
while (s < e) {
int n;
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:
/* found */
break;
default:
return Qfalse;
}
s += n;
}
return Qtrue;
}
switch (cc) {
// whitespace
break;
default:
return Qfalse;
}
s++;
}
}

View Slide

rb_encoding *enc;
char *s, *e;
while (s < e) {
int n;
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:
/* found */
break;
default:
return Qfalse;
}
s += n;
}
return Qtrue;
}
switch (cc) {
// whitespace
break;
default:
return Qfalse;
}
s++;
}
return Qtrue;
}

View Slide

FAST_BLANK IN RUST

View Slide

pub extern "C" fn fast_blank(buf: Buf) -> bool {
buf.as_slice().chars().all(|c| c.is_whitespace())
}

}

}

}

}

}

}

}

=========== 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

View Slide

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

View Slide

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

View Slide

}

View Slide

}
*

View Slide

RUST C
// 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]
buf.as_slice().unwrap().chars().all(|c| c.is_whitespace())
}
// C Code
#include
#include
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);
}
#include
#include
#include
#include
#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;
while (s < e) {
int n;
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;
}
{
rb_define_method(rb_cString, "blank?", rb_string_blank, 0);
}

View Slide

RUST C
// 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]
buf.as_slice().unwrap().chars().all(|c| c.is_whitespace())
}
// C Code
#include
#include
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;
}
{
rb_define_method(rb_cString, "blank?", rb_string_blank_p, 0);
}
#include
#include
#include
#include
#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;
while (s < e) {
int n;
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;
}
{
rb_define_method(rb_cString, "blank?", rb_string_blank, 0);
}

View Slide

HELIX

View Slide

#[macro_use]
extern crate libcruby;
declare_types! {
reopen class RubyString {
def is_blank(self) -> bool {
self.chars().all(|c| c.is_whitespace())
}
}
}

View Slide

#[macro_use]
declare_types! {
}
}
}

View Slide

#[macro_use]
declare_types! {
}
}
}

View Slide

#[macro_use]
declare_types! {
}
}
}

View Slide

#[macro_use]
declare_types! {
}
}
}

View Slide

TURBO RAILS IN RUST?

View Slide

WHAT ABOUT MY APP?

View Slide

MEAL-MATCHING ALGORITHM

View Slide

meal_tags = [3, 6, 18, 34, 50]
preference_tags = [6, 18, 42]
meal_tags.fully_contain?(preference_tags)

View Slide

meal_tags = [3, 6, 18, 34, 50]

View Slide

meal_tags = [3, 6, 18, 34, 50]

View Slide

meal_tags = [3, 6, 18, 34, 50]

View Slide

SET CONTAINMENT

View Slide

KNOWN TRICKTM

View Slide

class Array
def fully_contain?(other)
self & other == other
end
end

class Array
end
end

class Array
end
end

class Array
end
end

SORTED

UNIQUE

(

WE CAN DO BETTER!

class Array
def fully_contain?(needle)
return true if needle.empty?
return false if self.empty?
needle_length = needle.length
return false if needle_length > self.length
needle_position = 0
needle_item = needle[needle_position]
self.each do |item|
if item == needle_item
needle_position += 1
if needle_position >= needle_length
return true
else
end
end
end
false
end
end

View Slide

class Array
needle_position = 0
self.each do |item|
return true
else
end
end
end
false
end
end

View Slide

class Array
needle_position = 0
self.each do |item|
return true
else
end
end
end
false
end
end

View Slide

class Array
needle_position = 0
self.each do |item|
return true
else
end
end
end
false
end
end

View Slide

class Array
needle_position = 0
self.each do |item|
return true
else
end
end
end
false
end
end

View Slide

UP TO 7X FASTER

View Slide

RUST?

View Slide

#[macro_use]
declare_types! {
reopen class Array {
def fully_contain(self, needle: &[usize]) -> bool {
if needle.is_empty() { return true }
let haystack = self.as_ref();
if haystack.is_empty() { return false }
let mut needle = needle.iter();
let mut needle_item = needle.next().unwrap();
for item in haystack {
if item == needle_item {
match needle.next() {
None => return true,
Some(next_item) => needle_item = next_item
}
}
}
false
}
}
}

Turbo Rails with Rust

Turbo Rails with Rust

Godfrey Chan

More Decks by Godfrey Chan

Other Decks in Programming

Featured

Transcript