DynamickýPřekladPrakticky

Z Denik

(Rozdíly mezi verzemi)
Přejít na: navigace, hledání
m
(→II. How Modern Compilers Work)
Řádka 57: Řádka 57:
=== II. How Modern Compilers Work ===
=== II. How Modern Compilers Work ===
-
Based on [https://chrisseaton.com/truffleruby/jokerconf17/ Chris talk and slides].
+
Based on [https://chrisseaton.com/truffleruby/jokerconf17/ Chris talk and slides]:
 +
 
 +
* What is a JIT compiler?
 +
* Why write a JIT compiler in Java?
 +
* Setting up Graal
 +
* The JVM compiler interface
 +
* The Graal graph
 +
* From bytecode to machine code
 +
** The bytecode parser and graph builder
 +
** Emitting assembly
 +
** Assembly out
 +
* Optimisations
 +
** Canonicalisation
 +
** Global value numbering
 +
** Lock coarsening
 +
* Practicalities
 +
** Register allocation
 +
** Scheduling
 +
* What can you use Graal for?
 +
** A final-tier compiler
 +
** Your own specific optimisations
 +
** Ahead-of-time compilation
 +
** Truffle
 +
* Summary
=== III. Talk 2 Compiler: Directives ===
=== III. Talk 2 Compiler: Directives ===

Verze z 28. 8. 2019, 13:21

Seminář na MatFyz pro letní semestr 2019.

Obsah

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. How Modern Compilers Work

Based on Chris talk and slides:

  • What is a JIT compiler?
  • Why write a JIT compiler in Java?
  • Setting up Graal
  • The JVM compiler interface
  • The Graal graph
  • From bytecode to machine code
    • The bytecode parser and graph builder
    • Emitting assembly
    • Assembly out
  • Optimisations
    • Canonicalisation
    • Global value numbering
    • Lock coarsening
  • Practicalities
    • Register allocation
    • Scheduling
  • What can you use Graal for?
    • A final-tier compiler
    • Your own specific optimisations
    • Ahead-of-time compilation
    • Truffle
  • Summary

III. 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

IV. Talk 2 Compiler: Assumptions & Caches

V. Talk 2 Compiler: Nodes & Specializations

VI. Memory Management

  • Garbage Collector
  • VirtualFrame
    • Descriptor
  • DynamicObject
    • Shape

VII. Graal Self

VIII. JIT vs. AOT překlad

IX. Interop mezi jazyky

X. 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
  • node.js
    • Mixing Java and JavaScript & co.

XI. Static Languages with LLVM

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

XII. Writing bytecode interpreter

  • Espresso - Java interpreter
  • Sulong - bitcode interpreter

XIII. Real Language Problems

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

Appendix A: 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

Citováno z „http://denik.xelfi.cz/o/Dynamick%C3%BDP%C5%99ekladPrakticky“