Upcoming Events

Classic compilers that argue about and optimize low-level program
representations are not sufficient to tackle many modern computationally
expensive applications such as image processing, machine learning, or
simulation software. Optimizations should happen at a much higher-level
that actually understand the primitive operations of the specific
application domain. In addition, we would like to generate
high-performance code for various highly parallel devices like multicore
CPUs with SIMD instructions or GPUs.

Compilers for domain-specific languages (DSLs) such as Halide or XLA
exactly fulfill these requirements. However, DSL compilers reinvent the
wheel over and over again as standard optimizations, code generators,
and general infrastructure & boilerplate code must be reimplemented for
each application domain.

This talk presents Thorin, an extensible, higher-order intermediate
representation. At its core, Thorin is a pure type system and, hence, a
form of a typed lambda calculus. Users can add new operations - called
axioms - simply by declaring them. These axioms may be opaque functions,
type operators, or any other entity with a possibly polymorphic and/or
dependent type. This way users can extend Thorin with new operations at
any low or high level and bundle them in a so-called dialect. A plugin
architecture allows to define new optimizations that interact with
axioms and other optimizations defined in other dialects in the most
optimal way without suffering from the infamous phase-ordering problem.