Late Data Layout - Initial Presentation

scala-miniboxing.org Late Data Layout Late Data Layout or how to
boil a frog without it noticing LAMP, 11th of February 2014 Vlad Ureche Cristian Talau Martin Odersky

scala-miniboxing.org Late Data Layout Late Data Layout or how to
boil a frog without it noticing LAMP, 11th of February 2014 Vlad Ureche Cristian Talau Martin Odersky Frog clipart credits: www.frog-life-cycle.com

3 scala-miniboxing.org We all like generics We all like generics

a trivial example a trivial example

def identity[T](t: T): T = t a trivial example a trivial example

def identity[T](t: T): T = t • will take any type and a trivial example a trivial example

def identity[T](t: T): T = t • will take any type and • will return that same type a trivial example a trivial example

def identity[T](t: T): T = t a trivial example a trivial example but under erasure: def identity(t: Any): Any = t

def identity[T](t: T): T = t a trivial example a trivial example but under erasure: def identity(t: Any): Any = t Any indicates a by- reference parameter

10 scala-miniboxing.org Specialization Specialization generates too much code generates too
much code

much code def identity[T](t: T): T = t

much code def identity[T](t: T): T = t def identity_V(t: Unit): Unit = t def identity_Z(t: Boolean): Boolean = t def identity_B(t: Byte): Byte = t def identity_C(t: Char): Char = t def identity_S(t: Short): Short = t def identity_I(t: Int): Int = t def identity_J(t: Long): Long = t def identity_F(t: Float): Float = t def identity_D(t: Double): Double = t

much code def identity[T](t: T): T = t def identity_V(t: Unit): Unit = t def identity_Z(t: Boolean): Boolean = t def identity_B(t: Byte): Byte = t def identity_C(t: Char): Char = t def identity_S(t: Short): Short = t def identity_I(t: Int): Int = t def identity_J(t: Long): Long = t def identity_F(t: Float): Float = t def identity_D(t: Double): Double = t Generates 10 times the original code

14 scala-miniboxing.org Miniboxing Miniboxing

15 scala-miniboxing.org Miniboxing Miniboxing reduces the variants reduces the variants

by using something like a tagged union TAG DATA (VALUE)

by using something like a tagged union TAG DATA (VALUE) Stores the original type

by using something like a tagged union TAG DATA (VALUE) Stores the original type Stores the encoded value in a long integer

by using something like a tagged union TAG DATA (VALUE) BOOL 0x0 false =

by using something like a tagged union TAG DATA (VALUE) BOOL 0x0 false = BOOL 0x1 true =

by using something like a tagged union TAG DATA (VALUE) BOOL 0x0 false = BOOL 0x1 true = INT 0x2A 42 =

by using something like a tagged union TAG DATA (VALUE) and using the static type information – tags are attached to code, not to values

25 scala-miniboxing.org Miniboxing Miniboxing let's revisit `def identity` let's revisit
`def identity` def identity[T](t: T): T = t

`def identity` def identity[T](t: T): T = t def identity_J(T_tag: Byte, t: Long): Long

`def identity` def identity[T](t: T): T = t def identity_J(T_tag: Byte, t: Long): Long TAG

`def identity` def identity[T](t: T): T = t def identity_J(T_tag: Byte, t: Long): Long TAG DATA (VALUE)

`def identity` def identity[T](t: T): T = t def identity_J(T_tag: Byte, t: Long): Long TAG DATA (VALUE) T_tag corresponds to the type parameter, instead of the values being passed around.

`def identity` def identity[T](t: T): T = t def identity_J(T_tag: Byte, t: Long): Long TAG DATA (VALUE) T_tag corresponds to the type parameter, instead of the values being passed around. Tag hoisting

31 scala-miniboxing.org WE ARE HERE Transform Boil the frog Advantages
Other uses Conclusion

32 scala-miniboxing.org Transforming Transforming

33 scala-miniboxing.org Transforming Transforming could certainly be easier could certainly
be easier

34 scala-miniboxing.org Transforming Transforming class C[@miniboxed T] { def foo(t:
T): T = if (...) t else ??? } could certainly be easier could certainly be easier

35 scala-miniboxing.org Transforming Transforming class C[@miniboxed T] { def foo(t:
T): T = if (...) t else ??? } could certainly be easier could certainly be easier How to generate foo_J, the miniboxed version of foo?

36 scala-miniboxing.org Transforming Transforming def foo_J(t: T): T = if
(...) t else ??? could certainly be easier could certainly be easier

(...) t else ??? could certainly be easier could certainly be easier • change T to Long, one variable at a time

(...) t else ??? could certainly be easier could certainly be easier • change T to Long, one variable at a time • patch up the tree

39 scala-miniboxing.org Transforming Transforming def foo_J(t: Long): T = if
(...) t // error: found: Long req'd: T else ??? could certainly be easier could certainly be easier • change T to Long, one variable at a time • patch up the tree

(...) minibox2box(T_Tag, t) else ??? could certainly be easier could certainly be easier • change T to Long, one variable at a time • patch up the tree

42 scala-miniboxing.org Transforming Transforming def foo_J(t: Long): Long = if
(...) minibox2box(T_Tag, t) else ??? // error: found: T req'd: Long could certainly be easier could certainly be easier • change T to Long, one variable at a time • patch up the tree

43 scala-miniboxing.org Transforming Transforming def foo_J(t: Long): Long = box2minibox(T_Tag,
if (...) minibox2box(T_Tag, t) else ???) could certainly be easier could certainly be easier • change T to Long, one variable at a time • patch up the tree

if (...) minibox2box(T_Tag, t) else ???) could certainly be easier could certainly be easier

if (...) minibox2box(T_Tag, t) else ???) could certainly be easier could certainly be easier • performance? – we'd be better off boxing everywhere

46 scala-miniboxing.org Peephole optimization Peephole optimization def foo_J(t: Long): Long
= box2minibox(T_Tag, if (...) minibox2box(T_Tag, t) else ???) to save the day to save the day

= box2minibox(T_Tag, if (...) minibox2box(T_Tag, t) else ???) to save the day to save the day • special case for if – and blocks, and array operations and and and

= if (...) box2minibox(minibox2box(t)) else box2minibox(???) to save the day to save the day

= if (...) box2minibox(minibox2box(t)) else box2minibox(???) to save the day to save the day • special case for nested corecions

= if (...) t else box2minibox(???) to save the day to save the day

= if (...) t else box2minibox(???) to save the day to save the day • contains too many special cases

= if (...) t else box2minibox(???) to save the day to save the day • contains too many special cases • tedious and error-prone to write

54 scala-miniboxing.org Transforming Transforming

55 scala-miniboxing.org Transforming Transforming is like boiling a frog is
like boiling a frog

like boiling a frog • if you put it in hot water – it jumps out right away

like boiling a frog • if you put it in hot water – it jumps out right away error: found: T req'd: Long

like boiling a frog • if you put it in hot water – it jumps out right away – so you need special precautions • patching up the tree + peephole optimization error: found: T req'd: Long

like boiling a frog • if you put it in hot water – it jumps out right away – so you need special precautions • patching up the tree + peephole optimization • if you put it in cold water – it will like it there :) error: found: T req'd: Long

like boiling a frog • if you put it in hot water – it jumps out right away – so you need special precautions • patching up the tree + peephole optimization • if you put it in cold water – it will like it there :) – and then you slowly heat up the water :D error: found: T req'd: Long

like boiling a frog def foo_J(t: T): T = if (...) t else ???

like boiling a frog • you put it in cold water def foo_J(t: T): T = if (...) t else ???

like boiling a frog • you put it in cold water def foo_J(t: @storage T): @storage T = if (...) t else ???

like boiling a frog • you put it in cold water def foo_J(t: @storage T): @storage T = if (...) t else ??? T =:= @storage T

like boiling a frog • you can easily do rewiring – foo(t) foo_J(t) → , no coercions needed def foo_J(t: @storage T): @storage T = if (...) t else ???

like boiling a frog def foo_J(t: @storage T): @storage T = if (...) t else ???

like boiling a frog • then you heat up the water def foo_J(t: @storage T): @storage T = if (...) t else ???

like boiling a frog • then you heat up the water def foo_J(t: @storage T): @storage T = if (...) t else ??? T =/= @storage T

like boiling a frog • then you heat up the water def foo_J(t: @storage T): @storage T = if (...) t else ??? T =/= @storage T retypecheck expected type: @storage T

like boiling a frog • then you heat up the water def foo_J(t: @storage T): @storage T = if (...) t else ??? T =/= @storage T retypecheck expected type: @storage T OK

like boiling a frog • then you heat up the water def foo_J(t: @storage T): @storage T = if (...) t else ??? T =/= @storage T retypecheck expected type: @storage T NO

like boiling a frog • then you heat up the water def foo_J(t: @storage T): @storage T = if (...) t else box2minibox(???) T =/= @storage T retypecheck expected type: @storage T

like boiling a frog • then you heat up the water def foo_J(t: @storage T): @storage T = if (...) t else box2minibox(???) T =/= @storage T retypecheck expected type: @storage T OK

like boiling a frog • then you boil the frog def foo_J(t: @storage T): @storage T = if (...) t else box2minibox(???)

like boiling a frog • then you boil the frog def foo_J(t: @storage T): @storage T = if (...) t else box2minibox(???) @storage T Long →

like boiling a frog • then you boil the frog def foo_J(t: Long): Long = if (...) t else box2minibox(T_Tag, ???) @storage T Long →

like boiling a frog • the three steps are:

like boiling a frog • the three steps are: T =:= @storage T

like boiling a frog • the three steps are: T =/= @storage T T =:= @storage T

like boiling a frog • the three steps are: @storage T Long → T =/= @storage T T =:= @storage T

84 scala-miniboxing.org Boiling the frog Boiling the frog

85 scala-miniboxing.org Boiling the frog Boiling the frog T T
Long

86 scala-miniboxing.org Boiling the frog Boiling the frog is Late
Data Layout is Late Data Layout T T Long

Data Layout is Late Data Layout

Data Layout is Late Data Layout • choice made by injecting annotations • easy to rewrite the tree • coercions inserted late and on-demand

Data Layout is Late Data Layout • choice made by injecting annotations • easy to rewrite the tree • coercions inserted late and on-demand def bar: Unit = { this.foo(...) ... }

Data Layout is Late Data Layout • choice made by injecting annotations • easy to rewrite the tree • coercions inserted late and on-demand def bar: Unit = { this.foo(...) ... } this.foo_J(...)

Data Layout is Late Data Layout • choice made by injecting annotations • easy to rewrite the tree • coercions inserted late and on-demand def bar: Unit = { this.foo(...) ... } this.foo_J(...) No coercion necessary @storage T <: WildcardType

93 scala-miniboxing.org Late Data Layout Late Data Layout is general
is general scala.Int int java.lang.Integer Autoboxing

is general Complex Complex (s.Float, s.Float) Autoboxing Value Classes

is general (s.Int, s.Int) s.Long (s.Int, s.Int) Autoboxing Value Classes Encoding

is general T T Long Autoboxing Value Classes Encoding Miniboxing

97 scala-miniboxing.org Transform Boil the frog Advantages Other uses Conclusion
WE ARE HERE

98 scala-miniboxing.org Conclusion Conclusion Late Data Layout Late Data Layout
Autoboxing Value Classes Encoding Miniboxing • type-driven transformation – heavy-lifting in the type system • generalization – of existing transformations – not tied to erasure • formalization – thinking about it now

Late Data Layout - Initial Presentation

Late Data Layout - Initial Presentation

Transcript

More Decks by Vlad Ureche

Other Decks in Technology

Featured