1) Using llvm-exegesis to benchmark memory-accessing straightline assembly - Aiden Grossman
2) LLVM-CM: Lightning Talk - Dayann D'almeida
3) In-IR optimizer utility testing - Nate Chandler
4) Optimizing Scudo's Secondary Allocator Cache Strategy - Fernando Salas
5) LLVM Multicall Driver: Statically linked toolchain with dynamically linked size - Alex Brachet
6) Optional, Expected, Error, Oh My! - Paul Robinson
7) Steps to clean and validate order files - Sharjeel Khan
8) Match me if you can - Zijun Zhao
9) Intel Quantum SDK: An Open-Source Quantum Compiler Using the LLVM Framework - Xin-Chuan (Ryan) Wu
10) Improving clangd document open time with preamble caching - Dmitry Polukhin

Using llvm-exegesis to benchmark memory-accessing straightline assembly - Aiden Grossman
In this talk, we showcase how llvm-exegesis can be used to benchmark straight line assembly code that access memory using snippet annotations. In addition, we discuss some of the common shortcomings of how llvm-exegesis performs these benchmarks and ways to deal with them.

LLVM-CM: Lightning Talk - Dayann D'almeida
This lightning talk serves to introduce the llvm-cm tool, a static cost modeling tool capable of ingesting machine basic block profile information for use in ML-based compiler optimization efforts.

In-IR optimizer utility testing - Nate Chandler
Testing utility functions used by optimization passes can be a challenge. On the one hand, we'd like to be able to write tests for them the same way we do for the passes themselves: write an IR test case, run the utility on it, and FileCheck the result. On the other hand, we'd like to be able to test them like any other function: pass arguments to the utility and verify its effects. How can we do both?

Optimizing Scudo's Secondary Allocator Cache Strategy - Fernando Salas
LLVM's memory allocator Scudo has a primary and secondary allocator. The secondary allocator’s cache uses a first-fit algorithm for quickly retrieving memory blocks but leads to a more significant amount of memory fragmentation. To reduce this fragmentation we implemented and tested different cache retrieval algorithms. In this talk we will walk through how we changed the algorithm in order to save memory while improving the efficiency of allocations.

LLVM Multicall Driver: Statically linked toolchain with dynamically linked size - Alex Brachet
The LLVM multicall driver statically links many tools into one binary which dramatically reduces the size of a statically linked toolchain. The talk will discuss how to build a toolchain with the multicall driver enabled. Additionally, the talk will go over the complications of rolling out a multicall enabled toolchain.

Optional, Expected, Error, Oh My! - Paul Robinson
Ever had to return an error to a caller? You have at least SIX ways to do this within LLVM, and they each behave a little bit differently. If you don't want to spend a couple of hours scrolling through header files trying to sort out which one is best for your case, this talk is for you!

Steps to clean and validate order files - Sharjeel Khan
Order files are text files containing symbols representing function names. Linkers (lld) uses order files to layout functions in specific order. These ordered binaries will reduce page faults and improve a program's startup time. Once we get an order file for a library or binary, we need to clean the order file of unwanted and redundant symbols. Following this, we check if it is valid based on certain criteria. In this presentation, we will talk about the steps to clean or validate order files.

Match me if you can - Zijun Zhao
C++ 23 introduced starts_with, and ends_with algorithms in the ranges library. starts_with checks whether a range starts with another range. Similarly, ends_with checks whether a range ends with another range. These are new features which are not limited in string type. They extend to [forward_iterator, bidirectional_iterator and random_access_iterator as well.

I’ll talk about my implementation of starts_with and ends_with in lib++. I’ll also talk about the optimizations implemented in the ends_with algorithm based on the iterator categories.

References: https://en.cppreference.com/w/cpp/algorithm/ranges/starts_with https://en.cppreference.com/w/cpp/algorithm/ranges/ends_with

Patches: [starts_with] https://reviews.llvm.org/D150735 [ends_with still in review] https://reviews.llvm.org/D150831

Intel Quantum SDK: An Open-Source Quantum Compiler Using the LLVM Framework - Xin-Chuan (Ryan) Wu
In this session, we will illustrate how the LLVM compiler infrastructure can be leveraged to create Intel Quantum Compiler, a tool we make open-source along with its compiler front-end and optimization passes. Attendees will delve into the intersection of classical and quantum compilation techniques Our guided exploration will simplify the intricacies of quantum programming and showcase how LLVM's flexible, expandable, and open-source framework can pave the path for quantum advancements. This session is more than just an informative guide – it is an invitation to join us in this quantum computing revolution and help shape the future of technology.

Improving clangd document open time with preamble caching - Dmitry Polukhin
Clangd, an LSP server, constructs an abstract syntax tree for each source file, a process that can often be time-consuming. We are proposing a solution that integrates the use of Clang's implicit modules for preamble caching, alongside cache priming techniques, to significantly improve document open times. Our experiment demonstrates that this approach can boost performance by up to 400 times for certain files, and by 20 times on average, thereby promising a substantial optimization of Clangd's document open time.