Editace stránky DynamickýPřekladPrakticky

Seminář na [[apidesign:MatFyzu|MatFyz]] pro letní semestr 2019, který pokračuje na jaře 2021.

== Dynamický Překlad Prakticky ==

Jaký je nejrychlejší programovací jazyk? Může být [[apidesign:JavaScript|JavaScript]] rychlejší než [[apidesign:C|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 [[apidesign:OracleLabs|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 [[apidesign:OracleLabs|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 [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 ===

Walk-thru [https://github.com/JaroslavTulach/talk2compiler 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 ===

* Explain [https://github.com/JaroslavTulach/talk2compiler/commit/a457bc242427a448b309a6ce028fc697ca52478f assumptions]
** `warmWelcome` with assumptions
* ExplodeLoop [https://github.com/JaroslavTulach/talk2compiler/commit/82713014e621caeae0d2577141e066c0c84874cb example]
** `Chain` 

=== V. Talk 2 Compiler: Nodes & Specializations ===

* [https://github.com/JaroslavTulach/talk2compiler/commit/f316b428d5474a60b6eec760f2d54c67b7d397f1 Interpreter for reading array elements]
** Name the method `executeCompute` to work better with DSL
** Let it work with `int` and `double`
* Rewrite using [https://github.com/JaroslavTulach/talk2compiler/commit/af9d269aafc1c3fb8d82f0a3db6437bedbcf40a6 specializations]

=== VI. Memory Management ===

* Garbage Collector
* VirtualFrame
** Descriptor
* DynamicObject
** Shape

=== VII. Graal Self ===

* Let's look at [https://github.com/JaroslavTulach/SelfGraal real language]
* PE parser
* Interop

=== VIII. JIT vs. AOT překlad ===

* [http://wiki.apidesign.org/wiki/Go Go, Java, go!]
* jargraal vs. libgraal
* Using native-image to [https://github.com/JaroslavTulach/matrixultimate implement `native` methods]

=== IX. Interop mezi jazyky ===

* Messages. "Mounting" trees.
* Exposing [https://github.com/JaroslavTulach/heapdump data structures] to languages

=== 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