Upgrade to Pro — share decks privately, control downloads, hide ads and more …

Data-centric Metaprogramming @ VMM 2015

456d1d6154efe50e950b65f966f63a50?s=47 Vlad Ureche
September 11, 2015

Data-centric Metaprogramming @ VMM 2015

The data-centric metaprogramming presentation at the VMM '15 (Virtual Machine Meetup), Zurich, Switzerland. Website: http://vmmeetup.github.io/2015/

Project website: http://scala-ildl.org

456d1d6154efe50e950b65f966f63a50?s=128

Vlad Ureche

September 11, 2015
Tweet

Transcript

  1. scala-ildl.org 11th of September 2015 Virtual Machines Meetup Zürich, Switzerland

    Data-centric Metaprogramming
  2. scala-ildl.org STOP Please ask if things are not clear!

  3. scala-ildl.org Vlad URECHE PhD student in the Scala Team @

    EPFL Working on program transformations focusing on data representation. Miniboxing guy. Scala compiler geek. @ @VladUreche @VladUreche vlad.ureche@epfl.ch
  4. scala-ildl.org Data-centric Metaprogramming

  5. scala-ildl.org Data-centric Metaprogramming Joint work with • Martin Odersky •

    Aggelos Biboudis • Yannis Smaragdakis
  6. scala-ildl.org infoscience.epfl.ch/record/207050

  7. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work

  8. scala-ildl.org Data-centric Metaprogramming

  9. scala-ildl.org Data-centric Metaprogramming ... in Object-Oriented Languages

  10. scala-ildl.org Object Composition Object Composition class Vector[T] { … }

  11. scala-ildl.org Object Composition Object Composition class Vector[T] { … }

    The Vector collection in the Scala library
  12. scala-ildl.org Object Composition Object Composition class Employee(...) ID NAME SALARY

    class Vector[T] { … } The Vector collection in the Scala library
  13. scala-ildl.org Object Composition Object Composition class Employee(...) ID NAME SALARY

    Auto-generated, corresponds to a table row class Vector[T] { … } The Vector collection in the Scala library
  14. scala-ildl.org Object Composition Object Composition class Vector[T] { … }

    class Employee(...) ID NAME SALARY
  15. scala-ildl.org Object Composition Object Composition class Vector[T] { … }

    class Employee(...) ID NAME SALARY
  16. scala-ildl.org Object Composition Object Composition class Employee(...) ID NAME SALARY

    Vector[Employee] ID NAME SALARY ID NAME SALARY class Vector[T] { … }
  17. scala-ildl.org Object Composition Object Composition class Employee(...) ID NAME SALARY

    Vector[Employee] ID NAME SALARY ID NAME SALARY class Vector[T] { … } Traversal requires dereferencing a pointer for each employee.
  18. scala-ildl.org A Better Representation A Better Representation Vector[Employee] ID NAME

    SALARY ID NAME SALARY
  19. scala-ildl.org A Better Representation A Better Representation NAME ... NAME

    EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY
  20. scala-ildl.org A Better Representation A Better Representation NAME ... NAME

    EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY iteration is 5x faster
  21. scala-ildl.org A Better Representation A Better Representation NAME ... NAME

    EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY iteration is 5x faster C++ would produce a better representation here, but there are still cases where the C++ representation could be improved over.
  22. scala-ildl.org A Better Representation A Better Representation • In isolation

    Vector[T] and Employee are optimal
  23. scala-ildl.org A Better Representation A Better Representation • In isolation

    Vector[T] and Employee are optimal • Together, Vector[Employee] can be optimized
  24. scala-ildl.org A Better Representation A Better Representation • In isolation

    Vector[T] and Employee are optimal • Together, Vector[Employee] can be optimized Challenge: No means of communicating this to the compiler
  25. scala-ildl.org A Better Representation A Better Representation • In isolation

    Vector[T] and Employee are optimal • Together, Vector[Employee] can be optimized Challenge: No means of communicating this to the compiler You may disagree. We'll have a related work section later.
  26. scala-ildl.org

  27. scala-ildl.org • Transforming the code by hand – Makes maintenance

    difficult – Changes are not contained
  28. scala-ildl.org • Transforming the code by hand – Makes maintenance

    difficult – Changes are not contained Can we automate this?
  29. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work

  30. scala-ildl.org Transformation Transformation Definition Application

  31. scala-ildl.org Transformation Transformation Definition Application • can't be automated •

    based on experience • based on speculation • one-time effort
  32. scala-ildl.org Transformation Transformation Definition Application • can't be automated •

    based on experience • based on speculation • one-time effort programmer
  33. scala-ildl.org Transformation Transformation Definition Application • can't be automated •

    based on experience • based on speculation • one-time effort • repetitive and simple • affects code readability • is verbose • is error-prone programmer
  34. scala-ildl.org Transformation Transformation programmer Definition Application • can't be automated

    • based on experience • based on speculation • one-time effort • repetitive and simple • affects code readability • is verbose • is error-prone compiler (automated)
  35. scala-ildl.org Transformation Transformation programmer Definition Application • can't be automated

    • based on experience • based on speculation • one-time effort • repetitive and simple • affects code readability • is verbose • is error-prone compiler (automated)
  36. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    ... }
  37. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    ... } An object that describes a Transformation.
  38. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    ... } An object that describes a Transformation. A marker trait for transformations.
  39. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    ... }
  40. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    ... } What does the compiler need to know?
  41. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    ... } What does the compiler need to know? The target of the transformation and its representation.
  42. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    type Target = Vector[Employee] type Result = EmployeeVector ... }
  43. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    type Target = Vector[Employee] type Result = EmployeeVector ... } The transformation is type-driven we indicate → the type of the target and of the representation.
  44. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    type Target = Vector[Employee] type Result = EmployeeVector ... } The transformation is type-driven we indicate → the type of the target and of the representation. The improved representation is defined in the host language.
  45. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    type Target = Vector[Employee] type Result = EmployeeVector ... }
  46. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    type Target = Vector[Employee] type Result = EmployeeVector ... } How to transform Vector[Employee] into an EmployeeVector?
  47. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    type Target = Vector[Employee] type Result = EmployeeVector def toResult(t: Target): Result = ... def toTarget(t: Result): Target = ... ... }
  48. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    type Target = Vector[Employee] type Result = EmployeeVector def toResult(t: Target): Result = ... def toTarget(t: Result): Target = ... ... } Conversions to/from Vector[Employee] that consume/produce a EmployeeVector?
  49. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    type Target = Vector[Employee] type Result = EmployeeVector def toResult(t: Target): Result = ... def toTarget(t: Result): Target = ... ... }
  50. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    type Target = Vector[Employee] type Result = EmployeeVector def toResult(t: Target): Result = ... def toTarget(t: Result): Target = ... ... } So far so good, but how to execute Vector[Employee] operations on EmployeeVector?
  51. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming object VectorOfEmployeeOpt extends Transformation {

    type Target = Vector[Employee] type Result = EmployeeVector def toResult(t: Target): Result = ... def toTarget(t: Result): Target = ... def bypass_length: Int = ... def bypass_apply(i: Int): Employee = ... def bypass_update(i: Int, v: Employee) = ... def bypass_toString: String = ... ... }
  52. scala-ildl.org Data-centric Metaprogramming Data-centric Metaprogramming programmer Definition Application • can't

    be automated • based on experience • based on speculation • one-time effort • repetitive and simple • affects code readability • is verbose • is error-prone compiler (automated)
  53. scala-ildl.org Transformation Transformation programmer Definition Application • can't be automated

    • based on experience • based on speculation • one-time effort • repetitive and simple • affects code readability • is verbose • is error-prone compiler (automated)
  54. scala-ildl.org Transformation Transformation programmer Definition Application • can't be automated

    • based on experience • based on speculation • one-time effort • repetitive and simple • affects code readability • is verbose • is error-prone compiler (automated) In the paper
  55. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work

  56. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best

    Represenation? Composition
  57. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best

    Represenation? Composition
  58. scala-ildl.org Open World Assumption Open World Assumption class Vector[T] {

    … } class Employee(...) ID NAME SALARY
  59. scala-ildl.org Open World Assumption Open World Assumption class Vector[T] {

    … } class Employee(...) ID NAME SALARY
  60. scala-ildl.org Open World Assumption Open World Assumption class Employee(...) ID

    NAME SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY class Vector[T] { … }
  61. scala-ildl.org Open World Assumption Open World Assumption class Employee(...) ID

    NAME SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY class Vector[T] { … } NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY
  62. scala-ildl.org Open World Assumption Open World Assumption class Employee(...) ID

    NAME SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY class Vector[T] { … } NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY class NewEmployee(...) extends Employee(...) ID NAME SALARY DEPT
  63. scala-ildl.org Open World Assumption Open World Assumption class Employee(...) ID

    NAME SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY class Vector[T] { … } NAME ... NAME EmployeeVector ID ID ... ... SALARY SALARY class NewEmployee(...) extends Employee(...) ID NAME SALARY DEPT Oooops...
  64. scala-ildl.org Open World Assumption Open World Assumption • Globally anything

    can happen
  65. scala-ildl.org Open World Assumption Open World Assumption • Globally anything

    can happen • Locally the programmer has full control: – Knows the values that will be used – Can reject non-conforming values
  66. scala-ildl.org Open World Assumption Open World Assumption • Globally anything

    can happen • Locally the programmer has full control: – Knows the values that will be used – Can reject non-conforming values How to use this information?
  67. scala-ildl.org Open World Assumption Open World Assumption • Globally anything

    can happen • Locally the programmer has full control: – Knows the values that will be used – Can reject non-conforming values How to use this information? Scopes
  68. scala-ildl.org Scopes Scopes def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] =

    for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary )
  69. scala-ildl.org Scopes Scopes def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] =

    for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) Method operating on Scala collections (familiar to programmers)
  70. scala-ildl.org Scopes Scopes def indexSalary(employees: Vector[Employee], by: Float): Vector[Employee] =

    for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary )
  71. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeOpt) { def indexSalary(employees: Vector[Employee], by: Float):

    Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) }
  72. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeOpt) { def indexSalary(employees: Vector[Employee], by: Float):

    Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) } Now the method operates on the EmployeeVector representation.
  73. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeOpt) { def indexSalary(employees: Vector[Employee], by: Float):

    Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) } Now the method operates on the EmployeeVector representation. Programmers can freely choose which parts of their code to transform.
  74. scala-ildl.org Scopes Scopes • Can wrap statements, methods even entire

    classes – Inlined immediately after the parser – Definitions are visible outside the "scope"
  75. scala-ildl.org Scopes Scopes • Can wrap statements, methods even entire

    classes – Inlined immediately after the parser – Definitions are visible outside the "scope" • Locally closed world – Incoming/outgoing values go through conversions – Programmer can reject unexpected values
  76. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best

    Represenation? Composition
  77. scala-ildl.org Best Representation Best Representation Vector[Employee] ID NAME SALARY ID

    NAME SALARY
  78. scala-ildl.org Best ...? Best ...? NAME ... NAME EmployeeVector ID

    ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY
  79. scala-ildl.org Best ...? Best ...? NAME ... NAME EmployeeVector ID

    ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY CompactVector <compressed binary blob>
  80. scala-ildl.org Best ...? Best ...? NAME ... NAME EmployeeVector ID

    ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY EmployeeJSON { id: 123, name: “John Doe” salary: 100 } CompactVector <compressed binary blob>
  81. scala-ildl.org Best ...? Best ...? NAME ... NAME EmployeeVector ID

    ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY EmployeeJSON { id: 123, name: “John Doe” salary: 100 } CompactVector <compressed binary blob> Scopes!
  82. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeOpt) { def indexSalary(employees: Vector[Employee], by: Float):

    Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) }
  83. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeOpt) { def indexSalary(employees: Vector[Employee], by: Float):

    Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) } Method operating on column-based storage
  84. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeBinary) { def indexSalary(employees: Vector[Employee], by: Float):

    Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) } Method operating on binary data
  85. scala-ildl.org Scopes Scopes transform(VectorOfEmployeeJSON) { def indexSalary(employees: Vector[Employee], by: Float):

    Vector[Employee] = for (employee ← employees) yield employee.copy( salary = (1 + by) * employee.salary ) } Method operating on JSON data
  86. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best

    Represenation? Composition
  87. scala-ildl.org Scope Composition Scope Composition • Code can be –

    Left untransformed (using the original repr.) – Transformed using different representations
  88. scala-ildl.org Scope Composition Scope Composition calling • Original code •

    Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
  89. scala-ildl.org Scope Composition Scope Composition calling • Original code •

    Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
  90. scala-ildl.org Scope Composition Scope Composition calling • Original code •

    Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations Coercions
  91. scala-ildl.org Scope Composition Scope Composition calling • Original code •

    Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations Coercions
  92. scala-ildl.org Scope Composition Scope Composition calling • Original code •

    Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
  93. scala-ildl.org Scope Composition Scope Composition calling • Original code •

    Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
  94. scala-ildl.org Scope Composition Scope Composition calling • Original code •

    Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations No coercions
  95. scala-ildl.org Scope Composition Scope Composition calling • Original code •

    Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations No coercions Even across separate compilation
  96. scala-ildl.org Scope Composition Scope Composition calling • Original code •

    Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
  97. scala-ildl.org Scope Composition Scope Composition calling • Original code •

    Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
  98. scala-ildl.org Scope Composition Scope Composition calling • Original code •

    Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations Two coercions Repr1 Target Repr2 → →
  99. scala-ildl.org Scope Composition Scope Composition calling • Original code •

    Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
  100. scala-ildl.org Scope Composition Scope Composition calling overriding • Original code

    • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations
  101. scala-ildl.org Scope Composition Scope Composition calling overriding • Original code

    • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations The transformation has to preserve the object model.
  102. scala-ildl.org Scope Composition Scope Composition calling overriding • Original code

    • Transformed code • Original code • Transformed code • Same transformation • Different transformation • Code can be – Left untransformed (using the original repr.) – Transformed using different representations The transformation has to preserve the object model. Handled automatically by the ildl transformation!
  103. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best

    Represenation? Composition
  104. scala-ildl.org Array of Stuct Array of Stuct (Column-oriented) (Column-oriented) NAME

    ... NAME EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY
  105. scala-ildl.org Array of Stuct Array of Stuct (Column-oriented) (Column-oriented) NAME

    ... NAME EmployeeVector ID ID ... ... SALARY SALARY Vector[Employee] ID NAME SALARY ID NAME SALARY 5x faster
  106. scala-ildl.org Specialization Specialization and stack allocation and stack allocation 3

    5 (3,5) Tuples in Scala are generic so they need to use pointers and objects
  107. scala-ildl.org Specialization Specialization and stack allocation and stack allocation 3

    5 3 5 (3,5) (3,5) Tuples in Scala are generic so they need to use pointers and objects + stack allocation
  108. scala-ildl.org + stack allocation Specialization Specialization and stack allocation and

    stack allocation 14x faster reduced memory footprint 3 5 3 5 (3,5) (3,5) Tuples in Scala are generic so they need to use pointers and objects
  109. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum

  110. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4)

  111. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8)

  112. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8)

    18
  113. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8)

    18
  114. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8)

    18 transform(ListDeforestation) { List(1,2,3).map(_ + 1).map(_ * 2).sum }
  115. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8)

    18 transform(ListDeforestation) { List(1,2,3).map(_ + 1).map(_ * 2).sum } accumulate function
  116. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8)

    18 transform(ListDeforestation) { List(1,2,3).map(_ + 1).map(_ * 2).sum } accumulate function accumulate function
  117. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8)

    18 transform(ListDeforestation) { List(1,2,3).map(_ + 1).map(_ * 2).sum } accumulate function accumulate function compute: 18
  118. scala-ildl.org Deforestation Deforestation List(1,2,3).map(_ + 1).map(_ * 2).sum List(2,3,4) List(4,6,8)

    18 transform(ListDeforestation) { List(1,2,3).map(_ + 1).map(_ * 2).sum } accumulate function accumulate function compute: 18 6x faster
  119. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best

    Represenation? Composition
  120. scala-ildl.org Multi-Stage Programming Multi-Stage Programming • Multi-Stage Programming – “Abstraction

    without regret” - Tiark Rompf – DSLs small enough to be staged → • 10000x speed improvements
  121. scala-ildl.org Multi-Stage Programming Multi-Stage Programming • Multi-Stage Programming – “Abstraction

    without regret” - Tiark Rompf – DSLs small enough to be staged → • 10000x speed improvements – Scala many features not supported by LMS: → • Separate compilation/modularization • Dynamic dispatch • Aliasing • Reflection
  122. scala-ildl.org Multi-Stage Programming Multi-Stage Programming • Multi-Stage Programming – “Abstraction

    without regret” - Tiark Rompf – DSLs small enough to be staged → • 10000x speed improvements – Scala many features not supported by LMS: → • Separate compilation/modularization • Dynamic dispatch • Aliasing • Reflection If we add support, we lose the ability to optimize code :(
  123. scala-ildl.org Low-level Optimizers Low-level Optimizers • JIT optimizers with virtual

    machine support – Access to the low-level code – Can assume a (local) closed world – Can speculate based on profiles – On the critical path – limited analysis
  124. scala-ildl.org Low-level Optimizers Low-level Optimizers • JIT optimizers with virtual

    machine support – Access to the low-level code – Can assume a (local) closed world – Can speculate based on profiles – On the critical path – limited analysis – Biggest opportunities are high-level - O(n2) O(n) → • Incoming code is low-level • Rarely possible to recover opportunities
  125. scala-ildl.org Low-level Optimizers Low-level Optimizers • JIT optimizers with virtual

    machine support – Access to the low-level code – Can assume a (local) closed world – Can speculate based on profiles – On the critical path – limited analysis – Biggest opportunities are high-level - O(n2) O(n) → • Incoming code is low-level • Rarely possible to recover opportunities Typical solution: Metaprogramming
  126. scala-ildl.org Metaprogramming Metaprogramming • Not your grandpa's C preprocessor def

    optimize(tree: AST): AST = { ... }
  127. scala-ildl.org Metaprogramming Metaprogramming • Not your grandpa's C preprocessor •

    Full-fledged program transformers – :) Lots of power def optimize(tree: AST): AST = { ... }
  128. scala-ildl.org Metaprogramming Metaprogramming • Not your grandpa's C preprocessor •

    Full-fledged program transformers – :) Lots of power – :( Lots of responsibility def optimize(tree: AST): AST = { ... }
  129. scala-ildl.org Metaprogramming Metaprogramming • Not your grandpa's C preprocessor •

    Full-fledged program transformers – :) Lots of power – :( Lots of responsibility • Compiler invariants • Object-oriented model • Modularity def optimize(tree: AST): AST = { ... }
  130. scala-ildl.org Metaprogramming Metaprogramming • Not your grandpa's C preprocessor •

    Full-fledged program transformers – :) Lots of power – :( Lots of responsibility • Compiler invariants • Object-oriented model • Modularity def optimize(tree: AST): AST = { ... } Can we make metaprogramming “high-level”?
  131. scala-ildl.org Motivation Transformation Applications Challenges Conclusion Related Work Open-world Best

    Represenation? Composition
  132. scala-ildl.org Conclusion Conclusion • Object-oriented composition inefcient representation → •

    Solution: data-centric metaprogramming – Splitting the responsibility: • Defining the Transformation programmer → • Applying the Transformation compiler → – Scopes • Adapt the data representation to the operation • Allow speculating properties of the scope • We've just begun to scratch the surface – Many interesting research questions lie ahead
  133. scala-ildl.org Conclusion Conclusion • Object-oriented composition inefcient representation → •

    Solution: data-centric metaprogramming – Splitting the responsibility: • Defining the Transformation programmer → • Applying the Transformation compiler → – Scopes • Adapt the data representation to the operation • Allow speculating properties of the scope • We've just begun to scratch the surface – Many interesting research questions lie ahead
  134. scala-ildl.org Conclusion Conclusion • Object-oriented composition inefcient representation → •

    Solution: data-centric metaprogramming – Splitting the responsibility: • Defining the Transformation programmer → • Applying the Transformation compiler → – Scopes • Adapt the data representation to the operation • Allow speculating properties of the scope • We've just begun to scratch the surface – Many interesting research questions lie ahead
  135. scala-ildl.org Conclusion Conclusion • Object-oriented composition inefcient representation → •

    Solution: data-centric metaprogramming – Splitting the responsibility: • Defining the Transformation programmer → • Applying the Transformation compiler → – Scopes • Adapt the data representation to the operation • Allow speculating properties of the scope • We've just begun to scratch the surface – Many interesting research questions lie ahead
  136. scala-ildl.org infoscience.epfl.ch/record/207050

  137. scala-ildl.org github.com/miniboxing/ildl-plugin

  138. scala-ildl.org github.com/miniboxing/ildl-plugin

  139. scala-ildl.org github.com/miniboxing/ildl-plugin Examples of data-centric metaprogramming applications

  140. scala-ildl.org

  141. scala-ildl.org Thank you!