Ein Blog

Posts mit Tag "compiler"

Sagte ich, jemand hat TypeScript nach Rust portiert? Cloudflare will da auch mit machen.

Der Unterschied: Sie arbeiten mit VoidZero zusammen und bauen es in OXC ein. Das wird dann auf lange Sicht wohl Teil von VitePlus. Sie betonen aber, dass sie TS nicht forken wollen. Das wird dann wohl einfach eine sehr harte Variante eines “Hard Forks” sein. Warum machen sie es noch? Rust lĂ€uft besser in WASM, weil da kein GC hinter hĂ€ngt. Wahrscheinlich haben sie dann auch besseres FFI, wenn die restliche Toolchain auch bereits in Rust gebaut ist.

Sie machen es aber nicht komplett selbst. Sie nehmen den Code von Theo als basis:

First, we are working with Theo Browne to merge tsc-rs and tsrs into a single package that supports all of TypeScript’s features including Language Server Protocol (LSP) and content mappers.

Daniel Rosenwasser (aus dem TS-Team) hat da auch schon drauf geantwortet:

The tsrs project has been extremely interesting to see come together. We’ve been working with the maintainers to better understand how tsrs is fast and what sorts of optimizations it uses are safe. We even did our own Rust vibe port and what we currently suspect is that a lot of the speed does not just come down to language choice, and some of what is going to make TS 7.1 faster and leaner (see the charts in the blog post) actually comes from optimizations discovered in tsrs.

We think the wasm and oxlint integration makes a lot of sense for Cloudflare’s needs, so this investment makes sense. At the same time, we’ll be working hard and collaborating to make the official TypeScript toolset faster and even more efficient.

Eine EinfĂŒhrung in Parser Combinators.

Der nÀchste TypeScript-Compiler-Rewrite in Rust: tsz

Was er zusĂ€tzlich noch hat: Einen Sound-Mode. Damit ĂŒberprĂŒft der noch ein bisschen mehr. Z. B. wird Array-Index-Access von einem number[], dann number | undefined zurĂŒckgeben, statt wie ĂŒblich number, da ggf. nicht garantiert ist, dass der Index existiert.

Google hat eine IR fĂŒr JavaScript gebaut: JSIR.

Ziel ist es, JS -> JSIR -> JS zu ermöglichen, sodass mehrere Toolchains sich die IR teilen können, Àhnlich wie es ESTree macht.

Vielleicht wĂ€re das was fĂŒr React Compiler. Die haben ihre eigene IR mit SSA gebaut, die von und nach ESTree compiled. Die JSIR wird dafĂŒr sicher nicht 100% ausreichen, aber die Integration in OXC könnte damit weniger Overhead haben.

Matt Godbolt macht einen Adentskalender ĂŒber Compileroptimierungen.

Hier ist die ganze Playlist ĂŒber alle Tage.

WebAssembly Troubles part 1: WebAssembly Is Not a Stack Machine. Der ganze Blog enthÀlt noch mehr Posts in die Richtung.

Microsoft portiert den TypeScript-Compiler in eine native Sprache. Das ist echt eine Mammutaufgabe. Sie benutzen Go.

Hier ist das Repo. Titel ist “TypeScript 7”. Da wir aktuell bei Version 5 sind, ist damit wohl klar, was sie fĂŒr einen Zeitplan fĂŒr die Fertigstellung haben.

Beim Parsen von OperatorprĂ€zedenzen gibt’s ja verschiedene AnsĂ€tze. Der erste und “einfache” Ansatz ist, die PrĂ€zedenzen in der Grammatik abzubilden. Die Implementierung mit einem rekursiven Abstieg ist dann trivial. Problematisch ist allerdings, dass der Syntaxbaum dann fĂŒr einfache Sachen ziemlich tief wird. FĂŒr z. B. ein einfaches a = 5 hĂ€tte man auf der rechten Seite dann einen kompletten Unterbaum mit Nodes fĂŒr jeden möglichen Operator, die dann aber quasi leer sind. Das ist sehr ineffizient. Der nĂ€chste Schritt wĂ€re ein Parser mit Dokus auf OperatorprĂ€zedenz. Dort weist man jedem Operator eine PrĂ€zedenz in Form einer Zahl zu und löst es spĂ€ter ein einen vergleichsweise flachen Baum auf. Den OperatorprĂ€zedenzparser kann man in den normalen rekursiven Abstieg integrieren und dann fĂŒr binĂ€re AUsdrĂŒcke verwenden. TypeScript macht das z. B. auch so.

Hier ist ein anderer Ansatz, PrÀzedenzen zu parsen: Better operator precedence

Die Web-Version von Crafting Interpreters.

Parsing and all that:

Hello again! I’m picking up my series on Automata, with this post that goes into what I had always meant to get to: parsers. We’ll check out the old-school linear time parsing algorithms, which only need to go over the input once, without backtracking or caching. We’ll check out LL and LR, parse tables, recursive descent and recursive ascent. Welcome to the world of deterministic parsing


cppinsights: See your source code with the eyes of a compiler.

Beispiel aus dem Readme:

class Base {};
class Derived : public Base {};
int main() {
  Derived d;
  Derived d2 = d;
  d2 = d;
  Base& b = d;
}

Wird zu:

class Base
{
  public:
  // inline constexpr Base() noexcept = default;
  // inline constexpr Base(const Base &) noexcept = default;
  // inline constexpr Base & operator=(const Base &) noexcept = default;
};
class Derived : public Base
{
  public:
  // inline constexpr Derived() noexcept = default;
  // inline constexpr Derived(const Derived &) noexcept = default;
  // inline constexpr Derived & operator=(const Derived &) noexcept = default;
};
int main()
{
  Derived d;
  Derived d2 = Derived(d);
  d2.operator=(d);
  Base & b = static_cast<Base&>(d);
  return 0;
}

Apple sucht Compiler-Leute, die den Interop von Swift und C++ verbessern.

Swift ist IMHO eine wirklich unterschĂ€tzte Sprache. Die haben keine Angst vor breaking Changes und trotzdem schaffen sie es, kein Python 3 zu erzeugen. Der Code ist ĂŒblicherweise sehr lesbar und seit einiger Zeit haben sie sogar ein Ownership-Modell, das zwar etwas verboser ist, aber IMHO deutlich verstĂ€ndlicher als das von Rust ist. Vielleicht wĂ€ren sie populĂ€rer geworden, wenn Linux- und Windows-Support nicht so lange gedauert hĂ€tte, wer weiß ÂŻ\_(ツ)_/ÂŻ

Ein schöner Talk von Matt Godbolt: What Has My Compiler Done for Me Lately? Unbolting the Compiler’s Lid.

FĂŒr die, die ihn nicht kennen: Das ist der, der den Compiler Explorer gebaut hat: https://gcc.godbolt.org

Damit kann man sich anschauen, was fĂŒr Assembler-Code verschiedene Compiler aus Code erzeugen. Mittlerweile auch fĂŒr andere Sprachen als C und C++.

Der Talk ist sehr schön und zeigt, was fĂŒr Optimierungen der Compiler mittlerweile alle fĂ€hrt. Ein Beispiel ist die Integer-Mulitplikation mit 2, also z. B. x * 2. Spoiler: Es ist nicht x << 1. Aber auch ein paar grĂ¶ĂŸere Beispiele sind durchaus beeindruckend.

Takeaway sollte sein: Optimiert nicht selbst, lasst das den Compiler machen. Ich wĂŒrde noch ergĂ€nzen: WĂ€hlt geeignete Datenstrukturen.

The Hardest Program I’ve Ever Written.

Geht um einen Formatter fĂŒr Source Code.

Habt Ihr UB in einem C++-Programm? Oder Implementation-Defined Behavior (IB)? Vielleicht kennt Ihr den Spruch, dass der Compiler absolut alles machen kann, wenn er UB oder IB findet. GCC startet ggf. ein Spiel.

Eine interessante Blogpost-Serie: Implementing Co, a Small Interpreted Language With Coroutines #2: The Interpreter (Part I ist der Parser).

Einen Type-Checker schreiben: Reconstructing TypeScript, part 1

MS hat hier zusammengetragen, was es fĂŒr Performanceverbesserungen in .NET 6 gibt.

Insgesamt echt beeindruckend, alleine schon das Volumen des Posts. Habe jetzt nicht alles einzeln gelesen, nur grob ĂŒberflogen. Eine Sache ist mir aber aufgefallen:

Most of the Math methods can now participate in constant folding, so if their inputs end up as constants for whatever reason, the results can become constants as well [
] dotnet/runtime#42831 from @nathan-moore ensured that the Length of an array created from a constant could be propagated as a constant. [
] [
] dotnet/runtime#55745, which enables the JIT to fold TimeSpan.FromSeconds(constant) (and other such From methods) into a single instruction.

Nice! Offenbar ist die Compilerinfrastruktur bei .NET jetzt so gut, dass solche Verbesserungen von random GitHub-Leuten eingereicht werden können.

Ich habe vor einiger Zeit mal den Vorschlag gemacht, CTFE in C# zu machen. Das ist jetzt definitiv obsolet. Nahezu jedes Beispiel aus dem Proposal wird jetzt vom Constant-Folding optimiert (was ich auch fĂŒr den besseren Ansatz halte).

Die verbleibenden Use-Cases könnten von generischen Const-Parametern abgefertigt werden. In meinem Proposal werden auch const structs angedeutet (also structs, die zur Compile-Time schon einen Wert haben und sich nicht mehr Ă€ndern). Da gibt es auch ein separates Proposal zu. Der Vorteil davon wĂ€re, dass man z. B. DateTimes als “richtige” Konstante haben kann (nicht nur als Shared-Readonly) und es eigentlich keinen Grund gibt, das nicht zu tun, weil das intern auch nur ein Int64 und sonst immutable ist.

Falls Ihr ein neues C/C++-Projekt anlegt und Euch fragt, welche Compiler-Flags Ihr so gesetzt haben solltet. Hier schreibt RedHat was darĂŒber. Ihr solltet natĂŒrlich schauen, dass die Flags zu Eurem Vorhaben passen. FĂŒr Embedded-Software gibt’s hier auch einen Eintrag.

Wer noch andere kennt oder Verbesserungen hat, her damit!