DynamickýPřekladPrakticky

Z Denik

Seminář na MatFyz pro letní semestr 2019.

Obsah 1 Dynamický Překlad Prakticky 2 Osnova přednášek 2.1 I. Představujeme nejrychlejší univerzální virtuální stroj 2.2 II. Talk 2 Compiler: Directives 2.3 III. Talk 2 Compiler: Assumptions & Caches 2.4 IV. Talk 2 Compiler: Nodes & Specializations 2.5 V. Graal Self 2.6 VI. JIT vs. AOT překlad 2.7 VII. Interop mezi jazyky 2.8 VIII. Tools & Instruments 2.9 IX. Static Languages with LLVM 2.10 X. Writing bytecode interpreter 2.11 XI. Real Language Problems 2.12 XII. node.js 2.13 XIII. Contributing To Open Source

Dynamický Překlad Prakticky

Jaký je nejrychlejší programovací jazyk? Může být JavaScript rychlejší než Céčko? Existuje jednoduchý způsob, jak si napsat jazyk, který bude opravdu rychlý? Musíme opravdu psát všechny knihovny znovu a znovu? Jak se implementuje debugger? A jak profiler? Kolik to dá práce? To jsou otázky, na které v průběhu semináře budeme hledat a nalezneme odpovědi.

Budeme používat GraalVM, což je nejrychlejší virtuální stroj, který shodou okolností pomáhá vyvíjet tým z pražské pobočky OracleLabs. Díky tomu to bude seminář praktický, přibližující nejnovější trendy ve vývoji virtuálních strojů. Žádná otázka nebude tabu - o GraalVM víme úplně vše!

Cílem bude ukázat si na výhody a zádrhele dynamického překladu. Pochopit, co překladač ve skutečnosti dělá a naučit se dorozumět se s ním - tedy programovat tak, abyste z dynamického překladu v GraalVM získali co nejvíce. Máte-li vlastní programovací jazyk, vezměte si jej s sebou - uděláme jej rychlejší!

A pokud to někoho bude opravdu bavit, tak může pokračovat v létě při studijní stáži v OracleLabs v Jinonicích.

Osnova přednášek

I. Představujeme nejrychlejší univerzální virtuální stroj

• povídání o tom, že již žijeme v mnohojazyčném světě
• představení GraalVM:
  • Eratosthenovo síto: https://github.com/jtulach/sieve
  • Souboj `ruby rb/sieve.rb` vs. truffleruby
  • Stejně všichni píší v JavaScriptu, že?
    • `node js/sieve.js` vs. `graalvm/bin/js`
  • Musíme tedy přepisovat všechny programy do JavaScriptu? Ne, stačí jen část:
    • `graalvm/bin/polyglot --file ruby+js/sieve.rb --file ruby+js/sieve.js`
    • Vysvětlit `Polyglot.export/import`
• A co Java?
  • `mvn -f java/algorithm package exec:java` je stále rychlejší než JavaScript
  • a navíc `JAVA_HOME=/graalvm mvn ...` bývá často ještě rychlejší!
• GraalVM nám dá rychlost, ale také nástroje, které jinde těžko nalezneme
  • Vysvětlení, jak Graal překladač používá grafy
  • Demonstrace Ideal Graph Visualizeru
• Dost o JVM. Představme si Truffle: ušetří nám práci při psaní jazyků
  • Postavte si syntaktický strom. Napište interpreter. A ono to již bude rychlé.
• Kdo by chtěl psát vlastní debugger či profiler?
  • Demonstrace polyglotního ladění na `ruby+js/fromjava` projektu
  • Otevřít v NetBeans 11+, breakpoint na `eval(js)`.
  • Zmáčknout "Stop in GraalVM script" in toolbar - zastaví se v JavaScriptu
  • Dát breakpoint na `natural.next`. Až se tam zastavíme "jít dovnitř". Skočíme do Ruby.
  • Ukázat proměnné v různých jazycích
  • Ukázat zásobník ve skriptovacích jazycích (Java/JavaScript/Ruby jsou vidět najednou)
  • Přepnout na "Java pohled". Skočit do interpretru JavaScriptu či Ruby
• Popsat architekturu GraalVM:
  • JVM, JVMCI, Graal Compiler dává Java, Scala, Ruby
  • plus Truffle API dává Ruby, R, JavaScript, Python
  • když už to máme může GraalVM použít v Node.js či Ruby on Rails místo tradičních VM
  • A pak ještě existuje Sulong ten dává C++, C, Rust, Fortran, atd.
• Představit `native-image` a AOT překlad
  • demonstrace rychlosti startu mezi `graalvm/bin/ruby` a `graalvm/bin/ruby --jvm`
• Nejtěžší problém v dynamických jazycích? `a + b`
  • vysvětlení jak funguje barvení syntaktických stromů
  • deoptimalizace a reoptimalizace

Ukázka: https://www.youtube.com/watch?v=zFxrZTVknmk

II. Talk 2 Compiler: Directives

Walk-thru Talk 2 Compiler demo project:

• Use `CallTarget` & `RootNode` to enter partial evaluation mode
• Use `mvn test -Pigv` to send graphs to IGV
• Install maven modules to IGV to show connection between graph and source
• Follow the README:
  • `warmWelcome`
  • `transferToInterpreter`
  • Rewrite to use profiles
• Show how to write own language

III. Talk 2 Compiler: Assumptions & Caches

• Explain assumptions
  • `warmWelcome` with assumptions
• ExplodeLoop example
  • `Chain`

IV. Talk 2 Compiler: Nodes & Specializations

• Interpreter for reading array elements
  • Name the method `executeCompute` to work better with DSL
  • Let it work with `int` and `double`
• Rewrite using specializations

V. Graal Self

• Let's look at real language
• PE parser
• VirtualFrame
• DynamicObject

VI. JIT vs. AOT překlad

• Go, Java, go!
• jargraal vs. libgraal
• Using native-image to implement `native` methods

VII. Interop mezi jazyky

• Messages. "Mounting" trees.
• Exposing data structures to languages

VIII. Tools & Instruments

• Making your language "toolable"
  • Source section
  • Tags
  • Show how to debug in NetBeans
• Writing an instrument
  • Debugger, profiler, code coverage, language server protocol, NetBeans

IX. Static Languages with LLVM

• Sulong - interpret C, Rust, atd.
• Truffle NFI

X. Writing bytecode interpreter

• Espresso - Java interpreter
• Sulong - bitcode interpreter

XI. Real Language Problems

• implementace FFI jazyku jako Ruby/Python/R
• yield in JavaScriptu
• lazy evaluation in R

XII. node.js

Mixing Java and JavaScript & co.

XIII. Contributing To Open Source

• Overview of the repositories
• Python, JavaScriptem, Ruby, FastR, Espresso
• mx tooling
• Signing OCA

https://github.com/jtulach/bf https://www.youtube.com/watch?v=FJY96_6Y3a4