Ukázat zdroj

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

[https://stream.cuni.cz/cs/Detail/0/12041 Záznam úvodní přednášky]. Začínáme historií [[NetBeans]], protože se k přednášce na [[MatFyz]]u určitě hodí. Nemůže chybět zmínka o návrhu [[API]] a mé knížce [http://practical.apidesign.org Practical API Design], aby bylo zřejmé, proč se tomuto kurzu říká ''Practical Dynamic Compilation''! Následuje takové to tradiční povídání o tom, co [[GraalVM]] umí a jak je snadné a jednoduché to nainstalovat (pomocí utilitky '''gu'''), použít a jak strašně rychle pak lze počítat [https://github.com/jtulach/sieve Eratesthénovo síto] v libovolném jazyce. Není to nic převratného, ale pokud jste to ještě někdo neviděl, tak je to vhodná upoutávka k záznamům dalších lekcí.

Je naše [[GraalVM]] implementace '''Ruby''' 10-krát rychlejší než jakákoli jiná? Jak dlouho může trvat vypsat všechna prvočísla? Co je vstupem a co je výstupem [[GraalVM|Graal]] překladače? Jakým nástrojem můžeme zkoumat, co [[GraalVM|Graal]] překladač vlastně uvnitř dělá? Jak napsat vlastní jazyk? Jak vložit implementaci existujícího dynamického jazyka do vlastního Java programu? Dá se to potom také ladit? V [[NetBeans]]? Ve Chrome Dev Tools? Má cenu psát interpretr Céčka?

=== II. Jak fungují moderní překladače? ===

V [https://stream.cuni.cz/cs/Detail/12042/12041 záznamu druhé přednášky] si nejprve dokončíme úvod z minula a povíme si, jak se ''zbavit Javovské virtuální mašiny''! Dynamický překlad je skvělý, ale vyžaduje spoustu metadat. Naštěstí můžeme [[GraalVM]] využít na překlad ''Java kódu'' do '''EXáče'''! To je důležitý střípek v tom jak [[GraalVM]] ekosystém funguje. Ale protože nás primárně bude zajímat překlad dynamických jazyků, tak si hned také představíme základní trik, který z dynamických jazyků dělá něco, z čeho lze vygenerovat efektivní strojový kód. Pořádně to prodiskutujeme a pak...

Od 35-té minuty následuje skutečné povídání o moderních překladačích: Jak vlastně překládat Javu, Céčko a jiné staticky typované jazyky? Pro osvěžení, co to vlastně  překladače jsou a jak fungují, nám výborně poslouží [https://chrisseaton.com/truffleruby/jokerconf17/ přednáška kolegy Chrise Seatona]. Opravdu je lepší psát překladač v C++ než v Javě? Chcete psát překladač a nebo vás baví psát vlastní garbage collector!? Nevynalézejte znovu kolo a raději si vyklonujte [https://github.com/oracle/graal/ graal repozitoř]. Vaše oblíbené IDE (ať [http://netbeans.org NetBeans] nebo [https://marketplace.visualstudio.com/items?itemName=oracle-labs-graalvm.graalvm-pack VSCode] či [https://docs.oracle.com/en/graalvm/enterprise/21/docs/tools/igv/ Ideal Graph Visualizer] a nebo i jiné) ty zdrojáky bez problémů otevře. Pak už můžete přidávat breakpointy do zdrojáků překladače, spouštět si vaše programy a koukat, jak se překládají. Můžete si i změnit sémantiku překladu, vypsat si ladící hlášky či něco podobného. Jak vaše aplikace, tak váš překladač jsou v Javě a ve vašem vývojovém prostředí se chovají úplně stejně. Avšak ne jen laděním je živ překládající inženýr! My milujeme grafy z překladače, které radostně zkoumáme v [https://docs.oracle.com/en/graalvm/enterprise/21/docs/tools/igv/ IGV]. Stahujte, zkoumejte jednotlivé fáze překladu a bezostyšně přeskakujte mezi IR grafy různých fází, vašimi zdrojáky, zdrojáky překladače. Bez [https://docs.oracle.com/en/graalvm/enterprise/21/docs/tools/igv/ IGV] ani ránu!

=== III. Jak překládají moderní překladače? ===

[https://stream.cuni.cz/cs/detail/12199/12041 Třetí díl záznamu] zahajuje pět minut technických problémů, ale pak již následuje vytvoření Maven projektu v [https://docs.oracle.com/en/graalvm/enterprise/21/docs/tools/igv/ IGV] a jeho zkoumání ze všech možných úhlů. Použijte ''-Dgraal.Dump=:1'' a ''-Dgraal.PrintGraph=Network'' a pojďme se podívat na grafy překladu. S gettery, které se inlinují či neinlinují. Prozkoumejme, jak vypadá výpočet průměru. Se smyčkou či bez ní. Jak funguje bytecode parser? Jak se generuje assembler? Jak si můžeme vypsat strojový kód z příkazové řádky? Třída '''Phase''' a její implementace poskytují různé optimalizace: Kanonikalizace uzlů. Znovupoužití hodnot. Eliminace zámků. Jak může debugger spolupracovat s [https://docs.oracle.com/en/graalvm/enterprise/21/docs/tools/igv/ IGV]? Přes '''graph.getDebug().forceDump(...)'''. Tomáš Zezula nám představí GraphBuilderPluginy a dostane domácí úkol...

=== IV. Talk 2 Compiler: Directives ===

[https://stream.cuni.cz/cs/detail/12485/12041 Čtvrtá část záznamu] zkoumá k čemu všemu lze [[GraalVM|Graal překladač]] vlastně použít. Začínáme ukázkou Tomáše Zezuly používající '''GraphBuilderPlugin''' k nahrazení '''SecurityManager''' no-op konstantou (do 12min). Takže místo [https://openjdk.java.net/jeps/411 JEP-411], který se snaží '''SecurityManager''' smazat, bychom jej tam mohli nechat a jen eliminovat jakoukoli zátěž, která je s ním spojená, nepoužívá-li se. Zajímavé, že?

[[TBD]]


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