RedDotRubyConf

Hello!

WELCOME!

THANK YOU!

I bought a Google Glass

I love food!

Earth (top)

Radius at Latitude R = radius of earth a =
equatorial radius b = polar radius l = geodetic latitude

Seattle Singapore Latitude 47.6097° N 1.3667° N Radius 6,373 km
6,357 km

Aaron Patterson @tenderlove

Ruby Core Team Rails Core Team

Polymorphism Refactoring Caching Irresponsible Ruby

WARNING!

This talk is extremely technical

Polymorphism

Hide Complexity

Decouple

Driving a Car class Automatic def put_in_drive; end def gas;
end end def drive(car) car.put_in_drive car.gas end car = Automatic.new drive(car)

Manual Car class Manual def press_clutch; end def put_in_gear; end
def release_clutch; end def gas; end end def drive(car) car.press_clutch car.put_in_gear car.release_clutch car.gas end car = Manual.new drive car

Both Cars def drive(car) if car.is_a?(Automatic) car.put_in_drive car.gas else car.press_clutch
car.put_in_gear car.release_clutch car.gas end end

Polymorphic class Automatic def go put_in_drive gas end end class
Manual def go press_clutch put_in_gear release_clutch gas end end

Drive method def drive car car.go end

rm Conditions def drive car if car.is_a? Automatic car.put_in_drive car.gas
else car.press_clutch car.put_in_gear car.release_clutch car.gas end end

Depends on Type def drive car car.go end

Logic is removed from the caller

“Caches” decision logic

def drive car car.go end car = Automatic.new drive car
“Cache”

Refactoring

Code is a graph

if foo && bar do_something else do_something_else end Parse Tree

Parse Tree if statement conditions positive negative

Parse Tree: Structure, but no meaning

if foo && bar do_something else do_something_else end Dependency Tree

Dependency Tree if statement conditions positive negative foo bar

Dependency Tree if statement conditions positive negative foo bar ????

Active Support Callbacks API

Callback Example class Hoge include ActiveSupport::Callbacks define_callbacks :save set_callback :save,
:record set_callback :save, :record1 def record; puts __method__; end def record1; puts __method__; end end f = Hoge.new f.run_callbacks :save

Results $ ruby test.rb record record1 $

Active Record class Person < ActiveRecord::Base validates_presence_of :name validates_length_of :name,
maximum:30 end

Variations class Foo include ActiveSupport::Callbacks define_callbacks :save set_callback :save, :record
set_callback :save, -> { p "lambda1" } set_callback :save, ->(o) { p "lambda2" } set_callback :save, ->(*a) { p "lambda3" } set_callback :save, "puts 'hello'" set_callback :save, SomeClass end call method call lambda eval call “before”

6 tests!

Variations, :if class Foo set_callback :save, :record, if: :foo set_callback
:save, :record, if: -> { p "lambda1" } set_callback :save, :record, if: ->(o) { p "lambda1" } set_callback :save, :record, if: ->(*a) { p "lambda1" } set_callback :save, :record, if: "true" set_callback :save, :record, if: SomeClass end call method call lambda eval call “before”

6 * 6 tests!

Variations, :unless class Foo set_callback :save, :record, unless: :foo set_callback
:save, :record, unless: -> { p "lambda1" } set_callback :save, :record, unless: ->(o) { p "lambda1" } set_callback :save, :record, unless: ->(*a) { p "lambda1" } set_callback :save, :record, unless: "true" set_callback :save, :record, unless: SomeClass end call method lambda eval call “before”

6 * 6 * 2 tests!

Variations, location class Foo set_callback :save, :before, -> { "lambda"
} set_callback :save, :after, -> { "lambda" } set_callback :save, :around, -> { "lambda" } end

6 * 6 * 2 * 3 tests!

Variations, halt class Foo include ActiveSupport::Callbacks define_callbacks :save, terminator: "result
== false" end

6 * 6 * 2 * 3 * tests

Reality: 21 tests

Callback Dependencies

set_callback ﬁrst

set_callback ﬁrst second third etc

set_callback ﬁrst second third etc eval

run_callback ﬁrst second third etc

run_callback ﬁrst second third etc eval

run_callbacks callbacks method callback method callback method conds callback conds
callback

Count Methods class Foo include ActiveSupport::Callbacks define_callbacks :save x =
instance_methods.length 100.times do set_callback :save, -> { "lambda1" } end y = instance_methods.length - x p NEW_METHODS: y end

Run It $ ruby test.rb {:NEW_METHODS=>100} $

Count Methods f = Foo.new x = Foo.instance_methods.length f.run_callbacks :save
y = Foo.instance_methods.length - x p NEW_METHODS: y

Run It $ ruby test.rb {:NEW_METHODS=>1} $

eval based when :before <<-RUBY_EVAL if !halted && #{@compiled_options} result
= result = #{@source} halted = (#{chain.config[:terminator]}) if halted halted_callback_hook(#{@raw_filter}) end end #{code} RUBY_EVAL when :after

when :before <<-RUBY_EVAL if !halted && #{@compiled_options} result = result
= #{@source} halted = (#{chain.config[:terminator]}) if halted halted_callback_hook(#{@raw_filter}) end end #{code} RUBY_EVAL when :after class Foo define_callbacks :save, :terminator => 'xxx' set_callback :save, :before, -> { "lambda" } set_callback :save, -> { "lambda1" } end

value = nil halted = false if !halted && true
result = result = _callback_before_1 halted = (xxx) if halted halted_callback_hook("#<Proc:>") end end if !halted && true result = result = _callback_before_2 halted = (xxx) if halted halted_callback_hook("#<Proc:>") end end value = !halted && (!block_given? || yield) value class Foo define_callbacks :save, :terminator => 'xxx' set_callback :save, :before, -> { "lambda" } set_callback :save, -> { "lambda1" } end User Code Eval’d Code

Currently ❤ Hard to understand ❤ Hard to change ❤
Memory Intensive ❤ Fast

What we want ❤ Easy to understand ❤ Easy to
change ❤ Low memory ❤ Fast

❤ Conditionals (:if, :unless) ❤ Callback body code ❤ Termination
code Dependencies

Leaf Nodes

callback

def _compile_filter(filter) case filter when Symbol filter when String "(#{filter})"
when Proc method_name = "_callback_#{@kind}_#{next_id}" @klass.send(:define_method, method_name, &filter) return method_name if filter.arity <= 0 method_name << (filter.arity == 1 ? "(self)" : " self, Proc.new ") else @klass.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1 def #{method_name}(&blk) #{method_name}_object.send(:#{method_to_call}, self, &blk) end RUBY_EVAL method_name end end Conversion Method

compile_filter

compile_filter Object

compile_filter String

compile_filter

String contains ❤ A method name ❤ Some code to
eval ❤ A method that changes depending on the arity of the proc

We need CONSISTENCY

Return a lambda!

if object.is_a?(Symbol) lambda { |target,object| object.send target } end Handle
Symbols

Handle Lambdas if object.is_a?(Proc) object end

Handle Objects if object.is_a?(Object) lambda { |target, object| object.before_filter(target) }
end

Etc...

def make_lambda(filter) case filter when Symbol lambda { |target, _,
&blk| target.send filter, &blk } when String l = eval "lambda { |value| #{filter} }" lambda { |target, value| target.instance_exec(value, &l) } when ::Proc if filter.arity > 1 return lambda { |target, _, &block| raise ArgumentError unless block target.instance_exec(target, block, &filter) } end if filter.arity <= 0 lambda { |target, _| target.instance_exec(&filter) } else lambda { |target, _| target.instance_exec(target, &filter) } end else lambda { |target, _, &blk| filter.public_send method_to_call, target, &blk } end end Conversion Method

Move Up

callback

Conversion Method when :before <<-RUBY_EVAL if !halted && #{@compiled_options} result
= result = #{@source} halted = (#{chain.config[:terminator]}) if halted halted_callback_hook(#{@raw_filter}) end end #{code} RUBY_EVAL when :after

compile_method

compile_method conditions, callback, next callback

compile_method

Return a lambda!

if filter_type == :before lambda { halting = halted.call conds
= conditionals.all? { |c| c.call } if !halting && conds callback_lambda.call end next_callback.call } end “Before” Callback

when :before lambda { |env| target = env.target value =
env.value halted = env.halted if !halted && user_conditions.all? { |c| c.call(target, value) } result = user_callback.call target, value env.halted = halted_lambda.call result if env.halted target.send :halted_callback_hook, @filter end end next_callback.call env } when :after class Foo define_callbacks :save, :terminator => 'xxx' set_callback :save, :before, -> { "lambda" } set_callback :save, -> { "lambda1" } end

if filter_type == :after lambda { next_callback.call halting = halted.call
conds = conditionals.all? { |c| c.call } if !halting && conds callback_lambda.call end } end “After” Callback

lambda Linked List

lambda lambda lambda Linked List

Generate Lambda when :before # The “before” callback lambda when
:after # The “after” callback lambda when :around # The “around” callback lambda else # ... end

Switch lambdas based on type. (polymorphism)

change ❤ Low memory? ❤ Fast?

Benchmark!

require 'active_support/callbacks' class Foo include ActiveSupport::Callbacks define_callbacks :save 100_000.times {
set_callback :save, :before, -> { "lambda" } } end puts "DONE!" GC.start sleep

Memory

change ❤ Low memory ❤ Fast?

Speed [[email protected] rails (4-0-stable)]$ time bundle exec ruby rawr.rb DONE!
real 0m54.925s user 0m53.928s sys 0m0.498s [[email protected] rails (4-0-stable)]$ git checkout 73aefee [[email protected] rails (73aefee...)]$ time bundle exec ruby rawr.rb DONE! real 0m17.619s user 0m17.385s sys 0m0.176s [[email protected] rails (73aefee...)]$

Speed [[email protected] rails (4-0-stable)]$ time bundle exec ruby rawr.rb DONE!
real 0m54.925s user 0m53.928s sys 0m0.498s [[email protected] rails (4-0-stable)]$ git checkout 73aefee [[email protected] rails (73aefee...)]$ time bundle exec ruby rawr.rb DONE! real 0m17.619s user 0m17.385s sys 0m0.176s [[email protected] rails (73aefee...)]$ 54s 18s

Runtime Speed class User < ActiveRecord::Base validates_presence_of :name end user
= User.new(name: 'Aaron') user.valid? Benchmark.ips do |x| x.report("valid") { user.valid? } end

Runtime Speed [[email protected] rails (4-0-stable)]$ bundle exec ruby test.rb Calculating
------------------------------------- valid 3902 i/100ms ------------------------------------------------- valid 51094.4 (±14.0%) i/s - 253630 in 5.059460s [[email protected] rails (4-0-stable)]$ [[email protected] rails (73aefee...)]$ bundle exec ruby test.rb Calculating ------------------------------------- valid 3726 i/100ms ------------------------------------------------- valid 49397.5 (±12.1%) i/s - 245916 in 5.047747s [[email protected] rails (73aefee...)]$ 51k / s 49k / s

Slower. (T_T)

More Polymorphism!

lambda { |env| if user_conditions.all? { |c| c.call(target, value) }
# ... result = user_callback.call target, value # ... end next_callback.call env }

irb(main):001:0> [].all? => true irb(main):002:0> No conditions

if user_conditions.empty? lambda { |env| # ... result = user_callback.call
target, value # ... next_callback.call env } else lambda { |env| if user_conditions.all? { |c| c.call(target, value) } # ... result = user_callback.call target, value # ... end next_callback.call env } end

Runtime Speed [[email protected] rails (4-0-stable)]$ bundle exec ruby test.rb Calculating
------------------------------------- valid 3902 i/100ms ------------------------------------------------- valid 51094.4 (±14.0%) i/s - 253630 in 5.059460s [[email protected] rails (4-0-stable)]$ [[email protected] rails (master)]$ bundle exec ruby test.rb Calculating ------------------------------------- valid 3953 i/100ms ------------------------------------------------- valid 52240.9 (±10.8%) i/s - 260898 in 5.051079s [[email protected] rails (master)]$ 51k / s 52k / s

change ❤ Low memory ❤ Fast

Caching

Active Record

Architecture

Person.where(...).where(...)

AR::Relation AR::Relation AR::Base Person.where(...).where(...) Person .where(...) .where(...)

AR::Relation AR::Relation AR::Base Person.where(...).where(...).to_a

AR::Relation AR::Relation AR::Base Person.where(...).where(...).to_a Arel::Manager SQL AST WHERE ...

AR::Relation AR::Relation AR::Base Person.where(...).where(...).to_a Arel::Manager SQL AST WHERE ... ...

AR::Relation AR::Relation AR::Base Person.where(...).where(...).to_a Arel::Manager SQL AST WHERE ... ...
FROM people SELECT *

AST to SQL SELECT * FROM people WHERE ... AND
...

AST to SQL SQL AST WHERE ... ... FROM people
SELECT * SELECT * FROM people WHERE ... AND ...

3 Transformations 1. Code to AR::Relation 2. AR::Relation to SQL
AST 3. SQL AST to SQL statement

Bind Params R ails >= 3.2

SELECT * FROM people WHERE id = ?

Database Query Database Rails Application

Database Query Database Rails Application SQL Binds

Database Query Database Rails Application Records

Database Work ❤ Parse SQL ❤ Plan Query ❤ Execute
Query ❤ Return Results

Query Plan is cached

Parsed SQL is cached

Better Caching

Student Work

Find Records Person.where(:id => 10).first Person.where(:id => 15).first Person.where(:id =>
3).first

Post.where(:id => params[:id]).first Generated Query Bind Parameters SELECT * FROM
people WHERE id = ? [id, 10] SELECT * FROM people WHERE id = ? [id, 15] SELECT * FROM people WHERE id = ? [id, 3]

Only bind parameters change

class MyController def index person = Person.where(:id => params[:id]).first end
end

class MyController def index person = Person.where(:id => params[:id]).first end
end Only dynamic value

1. Generate AR::Relation chain 2. Generate SQL AST 3. Generate
SQL String 4. Query the database On Every Request

Cache Invariants

relation = Post.where(:id => 10) loop do relation.set_binds([rand(100)]) relation.to_a end
R ails >= 4.1

Benchmarks

class NoCache def initialize(&blk) @block = blk end def call(*args)
@block.call(*args).to_a end end nocache = NoCache.new do |name, age| User.where(:name => name).where(:age => age) end No Cache

class Cache def initialize(&blk) @block = blk @relation = nil
end def call *args @relation ||= @block.call(*args) @relation.set_binds args @relation.to_a end end nocache = Cache.new do |name, age| User.where(:name => name).where(:age => age) end Cache

end def call *args @relation ||= @block.call(*args) @relation.set_binds args @relation.to_a end end nocache = Cache.new do |name, age| User.where(:name => name).where(:age => age) end Cache Cache Relation

end def call *args @relation ||= @block.call(*args) @relation.set_binds args @relation.to_a end end nocache = Cache.new do |name, age| User.where(:name => name).where(:age => age) end Cache Reset Binds

Benchmark cache = Cache.new do |name, age| User.where(:name => name).where(:age
=> age) end nocache = NoCache.new do |name, age| User.where(:name => name).where(:age => age) end name = names.first Benchmark.ips do |x| x.report("cache") { cache.call(name, 32) } x.report("nocache") { nocache.call(name, 32) } end

Result $ bundle exec ruby qcache.rb Calculating ------------------------------------- cache 456
i/100ms nocache 278 i/100ms ------------------------------------------------- cache 4754.9 (±8.0%) i/s - 23712 in 5.018513s nocache 2820.4 (±5.9%) i/s - 14178 in 5.046598s

0 1250 2500 3750 5000 Queries per second Cached Not
Cached

1.68 times faster!

1. Generate AR::Relation chain 2. Generate SQL AST 3. Generate
SQL String 4. Query the database On Every Request Cached! Cached!

Invalidation

Record Cache x = Post.where(:name => ‘xxx’) x.to_a x.to_a x.to_a

Invalidation def set_binds(list) @loaded = nil @records = [] list.zip(values[:bind]).each
do |val, bv| bv[1] = val end end

Record Cache x = Post.where(:name => ‘xxx’) x.to_a x.set_binds(...) #
cache is invalidated x.to_a x.to_a

We can go even faster!

Refactoring is the gateway to speed

Use polymorphism

Cache Invariants

Irresponsible Ruby

Ruby Values ❤ Immediate ❤ Regular

Immediate Values ❤ nil ❤ true ❤ false ❤ Fixnum
(2 ** (0.size * 8 - 2) - 1)

10.object_id >> 1 # => 10 14.object_id >> 1 #
=> 14 Fixnum Trick

Regular Values

>> o = Object.new => #<Object:0x007fab5b38bbd0> >> o.object_id.to_s(16) => "3fd5ad9c5de8"
>> (o.object_id << 1).to_s(16) => "7fab5b38bbd0" >>

ﬁddle with memory

Get a pointer require ‘fiddle’ pointer = Fiddle::Pointer.new(offset) pointer[0] #
=> get the char * val pointer[0] = x # => set the val

Fiddle with Ruby require ‘fiddle’ o = Object.new offset =
o.object_id << 1 pointer = Fiddle::Pointer.new(offset)

RObject Layout struct RObject { struct RBasic basic; union {
struct { long numiv; VALUE *ivptr; struct st_table *iv_index_tbl; } heap; VALUE ary[ROBJECT_EMBED_LEN_MAX]; } as; };

RBasic struct RBasic { VALUE flags; const VALUE klass; }

What is VALUE? typedef uintptr_t VALUE; >> require 'fiddle' =>
false >> Fiddle::SIZEOF_UINTPTR_T => 8

Read Flags >> require 'fiddle' >> o = Object.new >>
offset = o.object_id << 1 >> pointer = Fiddle::Pointer.new(offset) >> 8.times.map { |i| pointer[i] } => [33, 0, 0, 0, 0, 0, 0, 0] >>

Read klass >> 8.times.map { |i| pointer[i+8] } => [-64,
55, -114, -40, -88, 127, 0, 0] >>

Get klass >> 8.times.map { |i| pointer[i+8] } => [-64,
55, -114, -40, -88, 127, 0, 0] >> addr = _.pack('C8').unpack('Q') => [140363164432320] >> Fiddle::Pointer.new(addr.first).to_value => Object >>

Lets set the class!

Set klass o = Object.new offset = o.object_id << 1
pointer = Fiddle::Pointer.new(offset) klass_offset = String.object_id << 1 [klass_offset].pack('Q').unpack('C8').each_with_index { |n,i| pointer[i + 8] = n } o.class # => String

Have Fun at RedDotRubyConf!

RedDotRubyConf

RedDotRubyConf

More Decks by Aaron Patterson

Other Decks in Technology

Featured

Transcript