1. Fast Pivot Function for Presburger Library through Vectorization and Integer Arithmetic in FPU -Qi Zhou
2. Using the Clang data-flow framework for null-pointer analysis -Viktor Cseh
3. Cost Modelling for Register Allocation and Beyond -Aiden Grossman
4. Image Processing Ops as first class citizens in MLIR: write once, vectorise everywhere! -Prathamesh Tagore, Hongbin Zhang

Fast Pivot Function for Presburger Library through Vectorization and Integer Arithmetic in FPU -Qi Zhou

This talk presents a fast implementation of the core function pivot for the Presburger library in MLIR by performing vectorized integer arithmetics in FPU. The hot loop of the pivot function performs overflow-checked multiplication and addition on each element of an input matrix of low dimension and mostly small-value items. MLIR’s upstream uses element-wise transprecision computing, where the data type of each element starts with int64_t and will be switched to LargeInteger in case of overflow. Compilers cannot automatically vectorize this approach, and int64_t has a much larger bit width than what is typically needed for most items in the matrix. Additionally, extra arithmetics are required to perform overflow checking for integers, resulting in significant overhead. These issues can be addressed by taking advantage of SIMD and reducing the bit width for every element. This report also introduces the int24_t data type, a  24-bit integer data type created from the sign bit, plus the 23-bit mantissa of a 32-bit floating point. int24_t overflow can be captured as floating point imprecision by a status register, making overflow awareness almost free. On a  representative 30-row by 19-column input matrix, the runtime is reduced from 550 ns to 26 ns, achieving 20 times  speedup.

Using the Clang data-flow framework for null-pointer analysis -Viktor Cseh

In late 2021 a new data-flow analysis framework was introduced into the Clang analysis tooling, enabling reasoning about program states the symbolic execution engine of the Clang Static Analyzer had difficulty deducing. In this talk, we summarize our experience with the data-flow framework through the lens of implementing a Clang-Tidy checker using null-pointer analysis. We discuss various approaches we tested to encode pointer values within the framework, their performance and limitations, and best practices and common pitfalls we encountered while implementing checkers using the framework.

Cost Modelling for Register Allocation and Beyond -Aiden Grossman

Accurate and fast cost modeling is essential for training ML models to replace certain key heuristics within LLVM when looking for performance gains. For eviction in the LLVM greedy register allocator, we use a linear model with some domain specific features which has successfully trained highly performant ML replacements, but leaves a lot to be desired in terms of absolute accuracy. In this talk we present results on the application of more generic basic block specific cost models to this problem as well as future directions and current work to push accurate cost modeling beyond basic blocks for the application of training ML models.

Image Processing Ops as first class citizens in MLIR: write once, vectorise everywhere!
-Prathamesh Tagore

We present an MLIR dialect for Image Processing named Digital Image Processing (DIP). DIP dialect solves the problem of dependence on external tools and libraries for image pre-processing in deep learning models at the MLIR IR level. This dialect is capable of processing an image input at the IR level in the form of memrefs. We utilise MLIR’s vector dialect abstraction to generate fast vectorisable code using a single lowering pipeline for different architectures. Additionally, we also present these operations in the form of a C++ library for their higher level use. As of now, the DIP dialect supports 1D as well as 2D convolutions, resizing, rotation, FFT, IFFT and morphological transformations for images