2025 EuroLLVM Developers' Meeting

Table of Contents

About

The EuroLLVM Developers’ Meeting is a bi-annual gathering of the entire LLVM Project community. The conference is organized by the LLVM Foundation and many volunteers within the LLVM community. Developers and users of LLVM, Clang, and related subprojects will enjoy attending interesting talks, impromptu discussions, and networking with the many members of our community. Whether you are a new to the LLVM project or a long time member, there is something for each attendee.

To see the agenda and speakers, please visit the Event Site.

What can you can expect at an LLVM Developers’ Meeting?

What types of people attend?

The EuroLLVM Developers’ Meeting strives to be the best conference to meet other LLVM developers and users.

For future announcements or questions: Please visit the LLVM Discourse forums. Most posts are in the Announcements or Community categories and tagged with eurollvm.

Program

Keynotes

A Recipe for Eliminating Entire Classes of Memory Safety Vulnerabilities in C and C++

Devin Coughlin [Slides] [Video]
This talk describes a recipe for developing compiler-backed secure programming models that eliminate entire classes of memory-safety security vulnerabilities in C-based languages. We will explain how we used this recipe to design Clang's -fbounds-safety language extension, Clang's -Wunsafe-buffer-usage programming model and the Clang Static Analyzer's WebKit smart pointer checks. We will also describe the need for new Clang-based static analysis infrastructure to enable faster, lower-developer-cost adoption of these programming models.

Deep Dive into the MLIR to LLVM IR Translation Mechanism

Alex Zinenko [Slides] [Video]
MLIR is now an inherent part of the LLVM compiler infrastructure, but what connects the two representations? In theory, the conceptual similarity of the core representation. In practice, a highly important, yet often overlooked, module translation subsystem. This talk will present the multi-dialect translation mechanism available in MLIR to target LLVM IR, explain how to use it for a custom dialect, and argue why it may not always be the best idea. It will also discuss interoperability between MLIR and LLVM IR functions, including ABI for built-in types and calling conventions.

Technical Talks

berlin: symbol lookup error: libeurollvm.so.2025: undefined symbol: _Z11abiBreakingChange

Domján Dániel [Slides] [Video]
A lightweight talk presenting a Clang Tool that detects binary compatibility breaking changes in C++ libraries. Edit: the title is a valid error message produced by such a change

Integration of LLVM-JIT Compiler with Interpreter and manually prepared machine code snippets

Marc Auberer, Lukas Rapp [Slides] [Video]
In this talk, we will demonstrate how LLVM-based JIT compilation, an interpreter, and manually prepared machine code snippets can be integrated to create a unified SQL query execution engine with low latency and high throughput.

Debugging Regressions: Interactive Differential Debugging

Vipul Cariappa, Martin Vassilev [Slides] [Video]
Software systems have become increasingly complex, making debugging challenging. Interactive Differential Debugging (IDD) automates identification of irrelevant execution paths and provides tools for comparing execution states between two versions, integrating with LLDB to detect functional or performance regressions.

How to bring your Neural Network into Upstream MLIR Dialects

Maximilian Bartel [Slides] [Video]
This talk provides a practical introduction to importing neural networks into MLIR's upstream dialects, covering TensorFlow Lite to TOSA, PyTorch via Torch-MLIR, ONNX to MLIR, and JAX, with concrete examples for beginners.

TK Wave: A Symbolic Python/MLIR DSL and Compiler for High Performance Machine Learning

Ivan Butygin [Slides] [Video]
Wave is a Python DSL and compiler for high performance ML, exposing high-level kernel language and user constraints while using the IREE/MLIR stack. It uses symbolic data types for tensor shapes and memory access patterns to simplify reasoning about kernels.

llvmlite: A python gym for LLVM

Yashwant Singh [Slides] [Video]
This talk explores how llvmlite, a lightweight LLVM Python binding, empowers developers to build LLVM-based compilers in Python, experiment with optimizations, and dynamically execute IR code with LLVM's JIT engine.

Making LoopAccessAnalysis more precise

Ramkumar Ramachandra [Slides] [Video]
Recent and ongoing work to make LoopAccessAnalysis more precise, leading to better vectorization results.

C++ interoperability with memory-safe languages

Gabor Horvath [Slides] [Video]
This talk explores challenges in polyglot projects and discusses how Clang can evolve to better facilitate interoperability between memory-safe and memory-unsafe languages.

Canonicalization in MLIR - Uniqueness and Equivalence

Javed Absar [Slides] [Video]
An overview of canonicalization in MLIR, including its importance, how it works, interesting examples, and concerns from different perspectives.

Solving Compiler Puzzles: Debug Methods in MLIR

Christopher McGirr [Slides] [Video]
A deep dive into debugging MLIR-based compilers, covering IR printing, mlir-opt arguments, reproducers, LLDB integration, and MLIR Reduce.

Function multi-versioning: compiler aided function specialization with runtime dispatch.

Alexandros Lamprineas [Slides] [Video]
Implementation of Function Multi Versioning (FMV) for AArch64, generating multiple function versions and auto-dispatching between them, useful for CPUs with optional instructions.

Bringing NVIDIA Blackwell support to LLVM and MLIR

Guray Ozen, Durgadoss Ramanathan, Pradeep Kumar [Slides] [Video]
Covers integration of NVIDIA Blackwell features into LLVM and MLIR, including intrinsics, APFloat additions, NVGPU/NVVM dialects, and sample kernel tutorials with NVDSL in Python.

Pass Plugins: Past, Present and Future

Stefan Gränitz [Slides] [Video]
Overview of pass plugins in LLVM and MLIR, their history, current state, and proposed changes for domain-specific extensions via plugin interfaces.

Weiwei Chen [Slides] [Video]
Discusses LLVM pipeline parallelization in the Mojo compiler using MCLink, reducing compilation time without modifying generated code.

Devise Loop Distribution with Scalar Expansion for Enhancing Auto-Vectorization in LLVM

Hung-Ming Lai, Jenq-Kuen Lee [Slides] [Video]
Integrates Data Dependence Graph and Scalar Expansion techniques into LLVM's LoopDistribute pass to enhance auto-vectorization, including algorithm and compile-time regression report.

How to trust your peephole rewrites: automatically verifying them for arbitrary width!

Siddharth Bhat [Slides] [Video]
Algorithms for proving peephole optimizations correct in a bitwidth-generic fashion, with implementation and evaluation in Lean proof assistant, and an interface for end-users to verify bitvector rewrites.

Accidental Dataflow Analysis: Extending the RISC-V VL Optimizer

Luke Lau [Slides] [Video]
Overview of RISC-V VL backend improvements, including incremental changes to the VL optimizer leading to dataflow analysis, while guaranteeing properties via underlying mathematical theory.

LLVM IR: Past, Present, and Future

Nikita Popov [Slides] [Video]
Covers LLVM IR design considerations, past changes, and future plans for optimizations and evolving requirements.

Faster Compilation — Improvements in LLVM 20 and Beyond

Alexis Engelke [Slides] [Video]
Describes performance improvements in LLVM backend over last two release cycles, lessons learned, and ideas for further compile-time reductions.

Bridging LLVM and SPIR-V for Heterogeneous Computing

Vyacheslav Levytskyy, Michal Paszkowski [Slides] [Video]
Explores enhancements to SPIR-V backend for robust heterogeneous computing, including translation optimizations, type system solutions, module handling, TableGen register classes, and integration with DPC++ and OpenAI Triton backend.

Instrumentor: Easily Customizable Code Instrumentation

Johannes Doerfert, Kevin Sala [Slides] [Video]
Introduces the Instrumentor, an LLVM pass for simple and customizable code instrumentation using JSON files, reducing maintainability and paving the way for future instrumentation tools.

Advances in Function Merging and Symbolication

Alex Borcan, Kyungwoo Lee [Slides] [Video]
Covers global function merging and identical code folding (ICF) improvements for code size reduction, safe_thunks mode, and enhancements in symbolication with new DWARF attributes and extended GSYM format.

Tutorials

Adopting -fbounds-safety in practice

Henrik Olsson, Patryk Stefanski [Slides] [Video]
-fbounds-safety is a C extension in Clang for enforcing bounds safety in C, developed and deployed internally at Apple. The implementation is currently in the process of being upstreamed to mainline LLVM, and a preview is now available to try out in a fork of LLVM. While previously outline in a talk at EuroLLVM 2023, this time we will cover the practical details of -fbounds-safety adoption.

How to reduce an llvm bug

Matthew Arsenault [Slides] [Video]
In this talk, I will provide a walkthrough of how to reduce common types of bugs (primarily crashes) in the middle end and backend. This will serve as an introduction to and documentation of how to use llvm-reduce. I will discuss common roadblocks and bugs you may need to workaround (some of which should probably be fixed). I will also argue that it is long overdue to delete bugpoint and discuss how to add new reduction passes if there is time.

An Introduction to Tensor Tiling in MLIR

Kunwar Grover, Mahesh Ravishankar [Video]
This talk will introduce the audience to TileAndFuse, an algorithm in upstream MLIR which allows tiling tensor operations and fusing these tiled tensor operations. The talk will cover how the algorithm works, how users can use it in their compiler and different tiling and distribution pipelines that can be built using it.

Lightning Talks

What is LLDB-DAP?

Jonas Devlieghere [Slides] [Video]
lldb-dap is a utility that allows LLDB to work with editors and IDEs that support the Debug Adapter Protocol (DAP), such as Visual Studio Code. It builds on LLDB's stable API and uses a standardized protocol to act as a bridge between LLDB and other developer tools. It is part of the Xcode developer tools and the open source Swift toolchain. It is also the name of the official VS Code extension, which is available in the Marketplace. We'll talk about the Debugger Adapter Protocol, how we support it in LLDB and where the line is between the IDE-agnostic tool and the VSCode extension.

sd-visualiser: Interactive graph visualisation for SSA-based IRs

Alex Rice [Slides] [Video]
We present sd-visualiser, an interactive graph visualisation program. It is specialised for drawing constructions common in LLVM and MLIR, such as regions, blocks, nodes with multiple ordered inputs and outputs, and SSA-values with multiple uses. We will demo the tool, and show off some of its interactive features.

Beyond Pattern-based Optimization: What Can LLM Reshape Auto-vectorization?

Long Cheng [Slides] [Video]
Our talk, Beyond Pattern-based Optimization: What Can LLM Reshape Auto-vectorization?, presents a novel LLM-driven framework integrated into LLVM-based compilers. By combining the semantic reasoning capbility of LLM Deepseek V3 with the precision of traditional LLVM-based compilers, we tackle complex vectorization scenarios which is generally hard to be done for naive LLVM-based compilers. We'll share results from TSVC-2 HPC and Skia benchmarks, demonstrating significant performance improvements (1.42× to 1.91×) on SVE/Neon for Arm CPUs. Learn how this approach reshapes auto-vectorization and discover future directions for LLM-native compiler optimization.

Why add an IR Reader to the llvm-debuginfo-analyzer tool?

Carlos Alberto Enciso [Slides] [Video]
The llvm-debuginfo-analyzer is a tool developed by Sony, as part of the open-source LLVM project. We have added support for the LLVM IR format. This talk will cover the benefits to allow compare IRs at different stages and determine any specific changes.

To be OR NOT to be

Piotr Fusik [Slides] [Video]
RISC-V has inverted bitwise operations such as or not. I will present a few scenarios where they are useful and how I implemented them in LLVM.

Accidentally quadratic in compiler-rt/asan

Artem Pianykh [Slides] [Video]
You build your binary with ASan, you run it...and nothing happens for 10 seconds. Without ASan the binary starts instantly. This talk will discuss how a bad asymptotic in the ODR checker's runtime code turned into a practical performance bottleneck, the fix to this problem, and the importance of tight upper bounds.

Dialects as a Dialect: Bringing native C++ registration to IRDL

Ivan Ho [Slides] [Video]
IRDL allows to define dialects in MLIR in a declarative and easy to analyse fashion. While this feature set was useful on its own, IRDL-defined dialects were not tightly integrated into MLIR: it was notably impossible to realistically use C++ patterns on them, or use dialect conversion with them. We present how we created a new MLIR tool capable of generating C++ definitions for dialects, just like ODS with TableGen. With our tool, IRDL-defined dialects are now tightly integrated into MLIR and indistinguishable from ODS dialects from a user's perspective. We also present how we wish to improve the code template rendering tooling in LLVM.

Autocheck: Clang-Based Checker for Automotive: Status and Issues

Djordje Todorovic [Slides] [Video]
Autocheck is a clang-based source code analysis tool designed to enforce compliance with the automotive standards, ensuring that critical automotive software adheres to strict safety and quality guidelines. In this talk, I will present the current status of Autocheck, discussing its implementation using the clang API, the challenges we have encountered—particularly around open-sourcing due to licensing and approval hurdles—and our roadmap for supporting both the current and new versions of the automotive standards, usage of AI, and more.

LLDB Statusline

Jonas Devlieghere [Slides] [Video]
Motivated by a better place to show progress events and a way to display the current state of the debugger, I extended command-line LLDB with a statusline. This dedicated area at the bottom of the screen shows things like the current target, the stop reason, and progress updates. The statusline can be customized using LLDB's format strings. I'll talk a little bit about the motivation, the implementation, and how to configure it.

Defining and verifying MLIR operations with constraints

Alex Rice [Slides] [Video]
This talk describes work in progress on a new constraint-based system for defining MLIR operations, which can be used to declaritely specify complex verification procedures, as well as providing inference of operation fields used when defining custom syntax of MLIR operations.

Quick Talks

Leveraging nsw in Flang's LLVM IR Generation for Vectorization

Yusuke Minato [Slides] [Video]
Flang is the Fortran frontend in the LLVM project. Its quality and performance have been improving, so that its driver has been renamed from flang-new to flang since LLVM 20. With respect to optimizations, loop vectorization plays an important role because it can reduce the number of operations in a loop by half or more. This talk focuses on Flang's capability of vectorization in the backend and our work on nsw to improve the capability. As a result of our work, loop vectorization for Fortran has been enhanced by introducing several options related to integer overflow into Flang.

Instruction Cache Prefetching

Oriel Avraham [Slides] [Video]
This talk explores the addition of a lightweight, non-blocking instruction cache prefetching mechanism tailored for simple hardware architectures without built-in I$ optimization components. We will discuss how the LLVM framework can be used to identify strategical points for prefetch insertion through static analysis.

#embed in clang: one directive to embed them all

Lukas Sommer [Slides] [Video]
The C23 standard defines the #embed directive – a fast, simple, tooling-friendly, cross-platform standardized way to include binary data into an application. For 40+ years of C and C++ implementations every compiler, every linker, every platform had its own little bespoke way of putting data into your executable. Since 2024 with C23 we now have #embed in clang: just one directive to (rule) embed them all. This talk will present the language feature design, feature status in clang, clang implementation details, and challenges faced during the implementation.

LLVM_ENABLE_RUNTIMES=flang-rt

Michael Kruse [Slides] [Video]
Flang's runtime library was changed from being compiled as part of Flang itself, to using LLVM's mechanism for runtime libraries. On this occasion this talk is about the motivation behind this change, design choices, the implications for users, experiences of the conversion, the purpose of runtime libraries, comparison to Clang's runtime libraries, and the differences between LLVM_ENABLE_PROJECTS and LLVM_ENABLE_RUNTIMES.

LLDB support for Propeller optimized code

Pavel Labath [Slides] [Video]
Propeller optimization boosts binary performance by up to 20%, but creates challenges for LLDB due to non-continuous functions. This talk unveils how LLDB was adapted to handle these complexities and explains how to avoid common pitfalls when writing new LLDB code.

1:N Dialect Conversion in MLIR

Matthias Springer [Slides] [Video]
The dialect conversion framework, one of the core pattern drivers in MLIR, has recently been extended with 1:N support: replacing one SSA value with multiple other SSA values. This talk illustrates how to use the new infrastructure and migrate existing passes that are currently relying on workarounds.

Enhancing Tile & Fuse Transformation in MLIR with a Planning Interface

Aviad Cohen [Slides] [Video]
The MLIR project provides a Tile & Fuse transformation to enhance memory locality by breaking down computations into smaller tiles and merging tiled loops. While the transformation utilities exist, determining optimal tiling and fusion decisions is challenging due to the lack of readily available iteration domain mapping information. This talk proposes a new interface to expose this critical mapping independent of the transformation process, enabling more informed and flexible tiling and fusion strategies. By providing a common solution, this interface aims to benefit both in-tree and out-of-tree dialects, addressing challenges faced by downstream projects and improving the broader MLIR ecosystem.

LTO/BOLT Optimised Clang/LLD AArch64 toolchain

Elvina Yakubova [Slides] [Video]
In this talk, we present our work on building a faster AArch64 Clang compiler by using an advanced LTO-PGO-BOLT build. We'll show that using the default settings leads to regressions in some applications due to its training on C++ codebases. To address this issue, efforts are made to diversify the training phase and merge profiles from applications with different codebases to develop a LTO-PGO-BOLT-optimized compiler that achieves higher performance across a wider range of applications.

MLIR Tensor Compiler Charter Update

Rolf Morel [Slides] [Video]
This will be an update on the current efforts to consolidate the MLIR charter via the recently formed design group. In the two months before EuroLLVM, we'll collect rationale, design and implementation documents, review contents and propose changes and reach a state where we'll be in a position to start making more assertive suggestions based on the community's feedback on current progress. This effort will continue upstream, in the open, but we recognize that the volume and intensity of discussions can be daunting, so we plan to present a summary of the current state and potential futures, which will lead into a round table for discussions, and follow-up forum threads to finally reach back the rest of the community.

Accurate Runtime Performance Estimation for Predictably Training ML Guided Register Eviction Policies

Aiden Grossman [Slides] [Video]
Within this talk, we describe how we trained a machine-learned register allocation heuristic using a new trace-based runtime estimation methodology. We outline how our new performance estimation system works, our overall training process, and our results, where we were able to achieve performance gains of around 1% on some server binaries.

The New Premerge System

Aiden Grossman [Slides] [Video]
Here we talk through the redesigned premerge system. We show a demo of the system in action from the contributor perspective, talk through the public analytics to understand system performance and reliability, explain the SLO and on-call process, provide a technical overview of the system, and answer any questions the audience might have.

Measuring the health of the LLVM community

Jeremy Bennett [Slides] [Video]
In this short talk, I look at how data mining of git activity and mailing lists can give insight to the health for a community project. The talk offers no prescriptions, its purpose is to share techniques that may be useful to the community.

Lessons learned from leveling up RISC-V LLVM testing

Alex Bradbury [Slides] [Video]
Testing is essential to ensuring the quality of LLVM's releases and maintaining its development velocity. LLVM has built an extensive collection of CI and testing infrastructure over the years, but it can be challenging to stand up builders that provide a reasonable cycle time for scenarios such as testing a backend of target configuration where high performance hardware isn't (yet) readily available. This talk describes work done to improve the situation for RISC-V, including extending support for qemu and cross-compilation scenarios, improvements to documentation and the ability to test buildbot configurations locally, balancing available compute resource vs configuration coverage vs test cycle time, and the path to providing feedback beyond functional testing (e.g. code size, performance).

Small Changes, Big Impact: GitHub Workflows for the LLVM Project

David Spickett [Slides] [Video]
LLVM contributors benefit from GitHub workflows every day, but did you know that if you want to write one of your own, all you need is a GitHub account? Find out how to get started, iterate and test, then finally submit your workflow to LLVM where 100s of developers can benefit from it.

Student Technical Talks

Clang Static Analyzer: Supporting Multithreaded Code

Isaac Nudelman [Slides] [Video]
Writing multithreaded code is notoriously difficult. Compounding this, static analysis is not particularly effective, as most analyzers (including Clang) are limited to evaluating a single thread of symbolic execution. This talk will describe changes to the Clang Static Analyzer to support analysis across threads, the challenges with the implementation, and the resulting improvement in analysis quality for multithreaded codebases. In particular, we will show multiple bugs that can now be detected using static analysis.

Integrating XRay into the HPC Tool Ecosystem

Sebastian Kreutzer [Slides] [Video]
XRay, Clang's dynamic function tracing system, offers runtime-adaptable instrumentation with minimal overhead. However, its adoption in HPC has been limited due to missing support for shared libraries (DSOs) and insufficient integration with parallel programming models like MPI and OpenMP. This talk presents our efforts to bridge these gaps, including our recently upstreamed extension for DSO instrumentation and the integration of XRay into established performance tools such as Score-P, TALP, and Extrae. Additionally, we present ideas for future work to enhance XRay's filtering mechanisms and instrumentation flexibility.

Automatic LLVM compiler backend generation with OpenVADL

Kevin Per [Slides] [Video]
The Vienna Architecture Description Language (VADL) is a processor description language for rapid design space exploration. OpenVADL is the open source implementation of VADL. One of the generated artifacts is an LLVM compiler backend. This talk provides an overview of how an automatic compiler backend generator was implemented and discusses the problems and limitations it faces. More details are described in an article available at https://arxiv.org/pdf/2402.09087

Pattern Matching, Transform and Code Replacement using LLVM's Polly library

Benedikt Huber [Slides] [Video]
Multidimensional Match, Transform and Replace (MMTR), is an extension to LLVM's Polly library, capable of matching, transforming and replacing nested loops using the polyhedral model. According to a user defined, target specific pattern, MMTR identifies nested loops that are semantically equivalent to an optimized target implementation. On a successful match, it transforms the nested loop in such a way that it can be replaced by a call to this optimized target implementation.

How to Write a Scalable Compiler for an Error-Prone Quantum Computer

Kim Worrall [Video]
Quantum computers have a problem - they are susceptible to errors which can destroy the entire computation. Error correction will make quantum computers feasible, but the architecture and software needed is multi-level, distributed, data intensive, time critical, and crucially not yet integrated into a compilation pipeline. This talk presents our effort to bring together the disparate parts of the quantum ecosystem into an error-correction aware, MLIR compatible framework. In particular, we emphasise how lessons from the MLIR and LLVM community are crucial to the frameworks development, and invite the audience to get involved with quantum computing.

Optimizing FDTD Solvers for Electromagnetics Using MLIR Across Multiple Hardware Platforms

Yifei He [Slides] [Video]
The Finite-Difference Time-Domain (FDTD) method is essential for computational electromagnetics but is computationally intensive. This talk explores how MLIR optimizations—loop tiling, fusion, and vectorization— significantly accelerate FDTD simulations. We showcase MLIR's potential for efficient, portable FDTD solvers across Intel, AMD, ARM CPUs, and GPUs.

Posters

LLVM Support for Sub-FP8 Quantization with RISC-V Extensions for Machine Learning Models

Kathryn Chapman, Fu-Jian Shen [Slides]
Deep learning computations require substantial computational power, storage, and data transfer bandwidth. To enhance efficiency, model quantization has become essential, driving the evolution of data formats from 32-bit and 16-bit to 8-bit, 6-bit, and 4-bit in both integer and floating-point representations. Previously, at the RISC-V Summit, North America, 2024, we proposed the Sub-FP8 extension for RISC-V, a novel approach to low-precision floating-point computation. In this work, we further provide Sub-FP8 support in the LLVM backend, along with C/C++ intrinsics to facilitate its integration into machine learning workloads. In addition, a reference design of Sub-FP8 is in the on-going work to integrate with CVA6 and FPnew core from open hardware. In our reference design, we also look at the issues to integrate Sub-FP8 with risc-v vector and matrix extensions, respectively. Experiments and simulations with Toolkits such as Spike and Gem5 will be also presented.

Towards Multi-Level Arithmetic Optimizations

Louis Ledoux, Florent de Dinechin, Luc Forget [Slides]
Numerical code is usually conceived using real numbers. However, programming languages only provide constructs operating at the lower abstraction level of machine encoding arithmetic. This work introduces an MLIR dialect for representing computations on real numbers at a high abstraction level. This enables more opportunities of arithmetic optimizations than those supported by current compilers. Such optimisations are particularly relevant when compiling a high-level mathematical description to application-specific hardware, for instance in signal processing and AI acceleration.

CuSan: a data race detector for CUDA based on ThreadSanitizer

Alexander Hück [Slides]
CuSan is a tool for detecting data races between (asynchronous) CUDA calls and the host. To achieve this, we analyze and instrument CUDA API usage in the target code during compilation with Clang/LLVM to track CUDA-specific concurrency, memory accesses and synchronization semantics. Our runtime then exposes this information to ThreadSanitizer for final data race analysis.

SonicMachine: Scalable Architecture Description using MLIR

Daniyal Khan [Slides]
SonicMachine is a novel MLIR dialect designed to efficiently represent complex, large-scale machine learning architectures, addressing the challenges of modeling hierarchical structures and data movement in modern accelerators. By leveraging MLIR's shape system, SonicMachine enables explicit representation of interconnections and performance attributes through operations like slice, concat, and broadcast, along with builder functions and templates for scalable descriptions. This work demonstrates how compiler infrastructure can facilitate expressive, hierarchical hardware modeling, providing a foundation for analysis, optimization, and efficient system design.

Coroutines, reinforcement learning environments, typechecking, MLIR: tying them together

Massimo Fiorovanti [Slides]
While machine learning tools become simpler by the day, developing robust environments for those tools to operate in remains an open challenge. Rulebook is an MLIR and coroutine-based DSL aimed at building environments and simplifying their interoperability. This talk describes the issues found at the boundaries between machine learning agents and machine learning environments from a programming language perspective, how Rulebook solves them, what challenges prevent other languages from adopting the same constructs, how the language leverages LLVM and MLIR to achieve its purpose, and various tips and tricks learned from implementing co-routines on top of MLIR.

Code-generation of highly efficient finite element operations using the MLIR compiler infrastructure

Edward Erasmie-Jones [Slides]
In this poster, we present NektarIR, a work-in-progress high-level intermediate representation of high-order finite element operations, built using the MLIR compiler infrastructure. Our goal is to address the software fragmentation that arises in developing highly efficient finite element kernels for heterogeneous hardware by enabling the generation of hardware-specific JIT-compiled kernels through both MLIR and LLVM. We demonstrate the initial stages in the development of our MLIR dialect and the performance of JIT-compiled finite kernels, tested as a back-end for the Nektar++ spectral/hp element framework.

Code of Conduct

The LLVM Foundation is dedicated to providing an inclusive and safe experience for everyone. We do not tolerate harassment of participants in any form. By registering for this event, we expect you to have read and agreed to the LLVM Code of Conduct.

Contact

To contact the organizer, email events@llvm.org.