Skip to content

Commit 694b515

Browse files
pranavkalpathishankarChaitanya-Shahare
pranavkalpathishankar
and
Chaitanya-Shahare
authored
2023-05 EuroLLVM dev meeting (#8)
* 2023-05 EuroLLVM dev meeting * changes to order for 2023-05 * Update data/devmtg/2023-05/keynote.yml --------- Co-authored-by: Chaitanya Shahare <[email protected]>
1 parent 018e156 commit 694b515

9 files changed

+909
-0
lines changed

‎content/devmtg/2023-05.md

+112
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,112 @@
1+
---
2+
title: "2023 EuroLLVM Developers' Meeting"
3+
description: ""
4+
date: 2023-05-10T19:45:19+05:30
5+
toc: true
6+
tags: []
7+
draft: false
8+
---
9+
10+
{{< event_data "2023-05" >}}
11+
12+
## About
13+
14+
The Euro LLVM 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.
15+
16+
To see the agenda, speakers, and register, please visit the Event Site here: https://llvm.swoogo.com/2024eurollvm
17+
18+
What can you can expect at an LLVM Developers' Meeting?
19+
20+
- **Technical Talks**
21+
22+
These 20-30 minute talks cover all topics from core infrastructure talks, to project's using LLVM's infrastructure. Attendees will take away technical information that could be pertinent to their project or general interest.
23+
- **Tutorials**
24+
25+
Tutorials are 50-60 minute sessions that dive down deep into a technical topic. Expect in depth examples and explanations.
26+
27+
- **Lightning Talks**
28+
29+
These are fast 5 minute talks that give you a taste of a project or topic. Attendees will hear a wide range of topics and probably leave wanting to learn more.
30+
31+
- **Quick Talks**
32+
33+
Quick 10 minute talks that dive a bit deeper into a topic, but not as deep as a Technical Talk.
34+
35+
- **Student Technical Talks**
36+
37+
Graduate or Undergraduate students present their work using LLVM.
38+
39+
40+
What types of people attend?
41+
42+
- Active developers of projects in the LLVM Umbrella (LLVM core, Clang, LLDB, libc++, compiler_rt, flang, lld, MLIR, etc).
43+
- Anyone interested in using these as part of another project.
44+
- Students and Researchers
45+
- Compiler, programming language, and runtime enthusiasts.
46+
- Those interested in using compiler and toolchain technology in novel and interesting ways.
47+
48+
The LLVM Developers' Meeting strives to be the best conference to meet other LLVM developers and users.
49+
50+
For future announcements or questions: Please visit the LLVM Discourse forums. Most posts are in the Announcements or Community categories and tagged with usllvmdevmtg.
51+
52+
## Program
53+
54+
### Keynote
55+
56+
{{< event_talks
57+
"devmtg/2023-05/keynote"
58+
"keynote"
59+
>}}
60+
61+
### Technical Talks
62+
63+
{{< event_talks
64+
"devmtg/2023-05/technical_talks"
65+
"technical_talks"
66+
>}}
67+
68+
### Tutorials
69+
70+
{{< event_talks
71+
"devmtg/2023-05/tutorials"
72+
"tutorials"
73+
>}}
74+
75+
### Quick Talks
76+
77+
{{< event_talks
78+
"devmtg/2023-05/quick_talks"
79+
"quick_talks"
80+
>}}
81+
82+
### Lightning Talks
83+
84+
{{< event_talks
85+
"devmtg/2023-05/lightning_talks"
86+
"lightning_talks"
87+
>}}
88+
89+
### Student Technical Talks
90+
91+
{{< event_talks
92+
"devmtg/2023-05/student_technical_talks"
93+
"student_technical_talks"
94+
>}}
95+
96+
### Posters
97+
98+
{{< event_posters
99+
"devmtg/2023-05/posters"
100+
"posters"
101+
>}}
102+
103+
## Code of Conduct
104+
105+
The LLVM Foundation is dedicated to providing an inclusive and safe
106+
experience for everyone. We do not tolerate harassment of participants in any
107+
form. By registering for this event, we expect you to have read and agree to
108+
the [LLVM Code of Conduct](http://llvm.org/docs/CodeOfConduct.html).
109+
110+
## Contact
111+
112+
To contact the organizer, email [[email protected]](mailto:[email protected]).

‎data/devmtg/2023-05/keynote.yml

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
keynote:
2+
- title: "Order out of Chaos, The LLVM Release Process"
3+
speaker: Tobias Hieta, Ubisoft
4+
video_url: https://youtu.be/onaNb2U1Od8
5+
slides_url: https://llvm.org/devmtg/2023-05/slides/TechnicalTalks-May10/01-Tobias%20Hieta-LLVM-Release-Process.pdf
6+
description: |
7+
In this Talk, I will explain how the LLVM release process works. How fixes are
8+
created, staged, tested, and reviewed to be included in a release and how community
9+
members can get involved and help improve future releases of LLVM.
10+
11+
- title: "'-fbounds-safety': Enforcing bounds safety for production C code"
12+
speaker: Yeoul Na, Apple
13+
video_url: https://youtu.be/RK9bfrsMdAM
14+
slides_url: https://llvm.org/devmtg/2023-05/slides/TechnicalTalks-May11/01-Na-fbounds-safety.pdf
15+
description: |
16+
In this talk we will describe "-fbounds-safety", a new language extension
17+
implemented in Clang that brings bounds safety to the C language. The language extension
18+
addresses multiple of the practical challenges that have made existing approaches to safer
19+
C dialects difficult to adopt. Our approach facilitates incremental adoption by preserving
20+
source compatibility with standard C and preserving ABI-compatibility with C binaries. It
21+
also minimizes adoption effort by reconciling wide pointers (a.k.a. "fat" pointers) with
22+
ABI-preserving bounds annotations. "-fbounds-safety" has been adopted on millions of lines
23+
of production C code and proven to work in an industrial setting.
24+

‎data/devmtg/2023-05/lightning_talks.yml

+112
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,112 @@
1+
lightning_talks:
2+
3+
- title: "LLVM IR as an Embedded Domain-Specific Language"
4+
speaker: "Nikita Baksalyar"
5+
video_url: ""
6+
slides_url: ""
7+
description: |
8+
This lightning talk will demonstrate an alternative way of using the LLVM API. We
9+
will develop a simple domain-specific language using metaprogramming techniques and see
10+
how it simplifies code and reduces boilerplate.
11+
12+
- title: "Using MLIR for Dalvik Bytecode Analysis"
13+
speaker: "Eduardo Blázquez, University Carlos III of Madrid"
14+
video_url: "https://youtu.be/hfqOivYdD40"
15+
slides_url: "https://llvm.org/devmtg/2023-05/slides/Lightning-Talks/01-Eduardo-EuroLLVM2023.pdf"
16+
description: |
17+
Using intermediate representations allows analysts to write optimizations and code
18+
analysis passes easier than parsing binary or bytecode directly. Kunai is a library
19+
intended for static analysis of dalvik bytecode, in a newer version of the library, the
20+
idea is to use the capabilities and possibilities offered by MLIR, writing a new dialect
21+
centered on Dalvik instructions.
22+
23+
24+
- title: "Spot the Difference with LLVM-FLOW: an open-source interactive visualization tool for comparing IR CFGs"
25+
speaker: "Jinmyoung Lee, KC Machine Learning Lab"
26+
video_url: "https://youtu.be/bCwteA-9mSs"
27+
slides_url: "https://llvm.org/devmtg/2023-05/slides/Lightning-Talks/08-Lee-LLVMFlow.pdf"
28+
description: |
29+
One way to understand and debug IR optimization process is to visualize Control Flow
30+
Graphs (CFGs) before and after optimization and compare them. However, since the CFGs can
31+
be drastically different, comparing these two graphs is a challenging task. LLVM-FLOW
32+
(https://llvmflow.kc-ml2.com/), an open-source interactive CFG visualization web app, is
33+
developed to ease the difficulty by highlighting the same components in two graphs. By
34+
clicking the highlighted node, you can easily find the corresponding node in another
35+
graph. LLVM-FLOW is a useful tool for LLVM experts to understand the IR flow when writing
36+
a custom pass, as well as for LLVM newcomers to study the IR pattern's behavior.
37+
38+
39+
- title: "Leveraging MLIR for Better SYCL Compilation"
40+
speaker: "Victor Lomüller, Codeplay Software"
41+
video_url: "https://youtu.be/UOOPFpojGN8"
42+
slides_url: "https://llvm.org/devmtg/2023-05/slides/Lightning-Talks/02-Lomuller-SYCL-MLIR.pdf"
43+
description: |
44+
SYCL is an open standard programming model for heterogeneous device programming,
45+
based on C++. Similar to optimizing C++ compilers, SYCL compilers would therefore also
46+
profit from a more suitable high-level representation for optimization. This talk presents
47+
first results on our investigation on how MLIR can be leveraged to improve SYCL
48+
compilation flows and optimizations.
49+
50+
- title: "Arm/AArch64 Embedded Development with LLD : What’s New"
51+
speaker: "Amilendra Kodithuwakku, Arm Limited"
52+
video_url: "https://youtu.be/cJCr4XqFmFY"
53+
slides_url: "https://llvm.org/devmtg/2023-05/slides/Lightning-Talks/03-Amilendra-Arm-AArch64-EmbeddedDevelopment-with-LLD.pdf"
54+
description: |
55+
Arm Limited has been continuously adding LLD support for embedded development on
56+
Arm/AArch64 targets. This lightning talk will be a short explanation of recently added
57+
features. 1) Armv8-M Security Extensions, also known as, Cortex-M Security Extensions
58+
(CMSE) 2) AArch64 Big Endian Support
59+
60+
- title: "Using automated tests to tune the -Og pipeline"
61+
speaker: "Stephen Livermore-Tozer, SN Systems (Sony Interactive Entertainment)"
62+
video_url: "https://youtu.be/f1uHy-ukucc"
63+
slides_url: "https://llvm.org/devmtg/2023-05/slides/Lightning-Talks/04-Tozer-UsingAutomatedTestsToTuneOgSlides.pdf"
64+
description: |
65+
In clang, the -Og flag is intended to run optimizations that will not significantly reduce
66+
the quality of the program's debug information. Rather than making informed decisions
67+
about which optimizations will preserve debug info, this flag currently uses the -O1
68+
pipeline, to run a few optimizations and hope that debug info will not be significantly
69+
affected. This is due to the lack of useful data about how well the various optimization
70+
passes in LLVM preserve debug info. In this talk I explain how we at Sony have attempted
71+
to solve this problem using Dexter, a tool for testing debug info quality, in an automated
72+
test pipeline to empirically explore different pipeline designs to find a fast and
73+
debuggable -Og pipeline.
74+
75+
- title: "Buddy-CAAS: Compiler As A Service for MLIR"
76+
speaker: "Hongbin Zhang, Institute of Software Chinese Academy of Sciences"
77+
video_url: "https://youtu.be/f7USv-oAtvI"
78+
slides_url: "https://llvm.org/devmtg/2023-05/slides/Lightning-Talks/05-Zhang-Buddy-CAAS-CompilerAs-AService-forMLIR.pdf"
79+
description: |
80+
This talk will introduce the Buddy-CAAS, Buddy Compiler As A Service for MLIR. In
81+
practice, debugging and configuring an MLIR pass pipeline is always time-consuming, and
82+
there are no good aid tools. In order to improve the efficiency of compiler developers, we
83+
implemented an online platform called Buddy-CAAS (https://buddy.isrc.ac.cn/). Our platform
84+
allows MLIR developers to configure the pass pipeline, view the intermediate products, and
85+
execute on a specific backend through an emulator. We are also integrating more features
86+
on our platform to power the MLIR ecosystem.
87+
88+
- title: "llvm-buildmark - observations, tips, and tricks on reducing LLVM build times"
89+
speaker: "Alex Bradbury, Igalia"
90+
video_url: "https://youtu.be/ka1wehtGQ-4"
91+
slides_url: "https://llvm.org/devmtg/2023-05/slides/Lightning-Talks/06-Bradbury-llvm-buildmark.pdf"
92+
description: |
93+
This talk provides a series of statistics on LLVM build times (both incremental and
94+
in a simulation of common edit-compile-test cycles) using a simple script that aims to
95+
provide a common baseline statistic. We'll look at some figures across real-world
96+
hardware, how LLVM build performance has changed over time, and the impact of various
97+
options (e.g. -DBUILD_SHARED_LIBS=True, -DLLVM_USE_SPLIT_DWARF=True, GCC vs Clang, lld vs
98+
ld.{bfd,gold} and so on).
99+
100+
- title: "Lock Coarsening optimizations for loops in Java"
101+
speaker: "Anna Thomas, Azul Systems"
102+
video_url: "https://youtu.be/IpGqTq8cVKw"
103+
slides_url: "https://llvm.org/devmtg/2023-05/slides/Lightning-Talks/07-Thomas-LockOpts.pdf"
104+
description: |
105+
This talk will focus on lock optimizations done for loops in Java by Falcon, Azul’s LLVM
106+
based JIT compiler. Synchronization is one the basic techniques that guarantee correctness
107+
in parallel execution. This is implemented using monitors in Java. Monitor acquires are
108+
expensive CPU operations, which also block various loop and reordering compiler
109+
optimizations. We will talk about two specific loop optimizations done for lock coarsening
110+
and the benefits it brings. For both these techniques, we introduced loop chunking in LLVM
111+
as a mechanism to coarsen locks over. We will go over the legality and cost model aspects
112+
as well.

‎data/devmtg/2023-05/posters.yml

+70
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,70 @@
1+
posters:
2+
- title: "Automatic Translation of C++ to Rust"
3+
speaker: "Henrique Preto, ULisboa - Instituto Superior Técnico"
4+
poster_url: "https://llvm.org/devmtg/2023-05/slides/Posters/02-Preto-AutomaticTranslationCPlusPlus-Rust.pdf"
5+
description: |
6+
Memory safety bugs account for 70% of the security vulnerabilities found in major
7+
Microsoft and Google projects. C++, while not memory safe, is an efficient language
8+
commonly used to implement critical systems software. However, Rust is a memory-safe
9+
programming language that offers comparable performance to C++. Still, manually rewriting
10+
existing C++ codebases in Rust is not practical. This work presents a source-to-source
11+
compiler built with Clang that translates C++ code to safe Rust, automatically making the
12+
software safer without losing performance and efficiency.
13+
14+
- title: "A sustainable approach to have vector predication in the Loop Vectorizer"
15+
speaker: "Lorenzo Albano, Barcelona Supercomputing Center"
16+
poster_url: "https://llvm.org/devmtg/2023-05/slides/Posters/01-Albano-VectorPredictionPoster.pdf"
17+
description: |
18+
A number of vector ISAs, like the RISC-V Vector Extension, have support for vector length
19+
and predication. Vector Predication provides us intrinscis to express operations that map
20+
well to these ISAs. However, the Loop Vectorizer still does not make use of them. At BSC
21+
we extended the Loop Vectorizer so it can use Vector Predication intrinsics but the amount
22+
of duplication makes us reluctant to upstream it. In this poster we present an alternative
23+
that has less impact to the Loop Vectorizer and a new pass that propagates the vector
24+
length and mask to the vectorised code.
25+
26+
- title: "Performance Analysis of Undefined Behavior Optimizations"
27+
speaker: "Lucian Popescu, Politehnica University of Bucharest"
28+
poster_url: "https://llvm.org/devmtg/2023-05/slides/Posters/05-Popescu-PerformanceImpactOfExploitingUndefinedBehavior.pdf"
29+
description: |
30+
State-of-the-art compilers, such as Clang/LLVM, use undefined behavior (UB) to issue
31+
optimizations. We present the impact of UB optimizations for a diverse set of application
32+
categories to discover what are UBs that are most performance critical.
33+
34+
- title: "Static Analysis for C++ Rust-Like Lifetime Annotations "
35+
speaker: "Susana Monteiro, INESC-ID, IST ULisboa"
36+
poster_url: "https://llvm.org/devmtg/2023-05/slides/Posters/06-Monteiro-StaticAnalysisForCPlusPlus-Rust-Like-LifetimeAnnotations.pdf"
37+
description: |
38+
Memory safety vulnerabilities can be addressed by incrementally migrating from
39+
memory-unsafe languages like C++ to memory-safe languages, namely Rust. However, this
40+
involves some challenges, in particular regarding Rust’s concept of lifetimes, which
41+
does not exist in C++. Recently, Clang introduced Rust-like lifetime annotations to
42+
approach this challenge, but it is essential to ensure their correctness. Our work focuses
43+
on developing a static analyzer to verify the correctness of C++ lifetime annotations,
44+
consequently addressing memory-safety vulnerabilities.
45+
46+
- title: "Leveraging MLIR for Better SYCL Compilation"
47+
speaker: "Victor Lomüller, Codeplay Software"
48+
poster_url: "https://llvm.org/devmtg/2023-05/slides/Posters/04-Lomuller-LeveragingMLIR-forBetterSYCLCompilation.pdf"
49+
description: |
50+
SYCL is an open standard programming model for heterogeneous device programming,
51+
based on C++. Similar to optimizing C++ compilers, SYCL compilers would therefore also
52+
profit from a more suitable high-level representation for optimization. This talk presents
53+
first results on our investigation on how MLIR can be leveraged to improve SYCL
54+
compilation flows and optimizations.
55+
56+
- title: "Forcefully Embedding MLIR into Python"
57+
speaker: "George Mitenkov, ETH Zurich"
58+
poster_url: "https://llvm.org/devmtg/2023-05/slides/Posters/03-Mitenkov-ForcefullyEmbedding%20MLIR-intoPython.pdf"
59+
description: |
60+
While MLIR provides its users with the infrastructure to create new dialects,
61+
lowerings and rewrites to support efficient domain-specific and ML workload compilation,
62+
the front-ends that generate MLIR have not been fully explored. In particular, it is
63+
common to either write SSA-based MLIR code in high-level dialects, or re-implement the
64+
code generation flow from the source language to MLIR. Both approaches are not developer-
65+
friendly because they require maintenance and significant development effort. In this
66+
poster session, we present how MLIR can be embedded into Python, allowing one to generate
67+
non-SSA Pythonic front-ends based on the dialect specifications. Moreover, we discuss how
68+
the front-ends can be statically compiled to SSA-based MLIR or even dynamically executed.
69+
We evaluate our work by presenting examples of front-ends for zero-knowledge proof or
70+
RISC-V compilers.

0 commit comments

Comments
 (0)