Special meeting: NVIDIA at CERN

Europe/Zurich
13/2-005 (CERN)

13/2-005

CERN

90
Show room on map
Aaron Jomy (CERN), Jonas Rembser (CERN)
Description

Public get-together organized by compiler-research.org, with NVIDIA and CERN engineers to discuss cutting-edge developments in GPU programming, challenges, and future prospects.

Zoom Meeting ID
68220187050
Host
Aaron Jomy
Passcode
37382853
Useful links
Join via phone
Zoom URL
    • 14:30 15:30
      Tile Programming for GPUs 1h

      Abstract: Parallel programming can be intimidating, but doesn't need to be! There's a new paradigm for parallel programming that's newcomer-friendly, highly productive, and performant: tile-based programming models.

      In this example-driven talk, we'll introduce you to tile-based programming in Python, C++, and Rust. We'll present cuTile, NVIDIA's new tile programming stack and Tile IR, the new compiler stack that it is built with. You'll learn all about new features of CUDA Tile that have recently been announced, including multi-GPU communication, interoperability with traditional CUDA SIMT, and support for more diverse kernels like convolutions and stencils. We'll compare and contrast tile-based models with traditional parallel programming models. You'll see examples from a variety of domains, including HPC stencils, a sparse matrix vector (SPMV) and conjugate gradient (CG) solver, and AI models from TileGym.

      Tile programming has its roots in HPC libraries, such as NWChem’s TCE, BLIS, and ATLAS. In recent years, this paradigm has grown in popularity for GPU programming in languages such as Triton, JAX/Pallas, and Warp.

      In this session, you'll:
      - Learn the best practices for writing tile parallel applications for GPUs.
      - Gain insight into the performance of tile code and how it actually gets executed.
      - Discover how to reason about and debug tile applications.
      - Understand the differences between tile and traditional parallel programming and when each paradigm should be used.
      - See how tile programming makes your software portable in light of recent hardware trends.

      By the end of the session, you'll understand how tile programming enables more intuitive, portable, and efficient development of high-performance, data-parallel applications, for HPC, data science, and machine learning.

      Bryce Adelstein Lelbach is an American software engineer and a prominent contributor to the C++ programming language community. He is currently a Principal Architect at NVIDIA, where he leads programming language standardization initiatives and drives the technical roadmap for the company's high-performance computing libraries.

      Speaker: Bryce Lelbach (NVIDIA)
    • 15:30 15:50
      ROOT and particle physics analysis on the GPU 20m

      Abstract: We will give a short overview on the ROOT data analysis framework and the possibilities to accelerate it with GPUs.

      Speakers: Danilo Piparo (CERN), Jonas Rembser (CERN), Lukas Breitwieser (CERN)
    • 15:50 16:20
      Compiler-as-a-Service and Programming Language Interoperability 30m

      Abstract: This presentation discusses how language interoperability tooling developed by CERN and Compiler Research, based on LLVM and Clang, can be leveraged to generate automatic Python/C++ bindings, bridge various programming languages with C++, and support JIT compilation of hardware accelerator code such as CUDA and Thrust.

      CppInterOp provides compiler-as-a-service capabilities using Clang-REPL, enabling dynamic languages to interoperate with C++. This talk covers its technical design, including runtime template instantiation and code generator. We demonstrate how CppInterOp's API, built on Clang's AST and the LLVM JIT, enables advanced Python–C++ interoperability with GPU support, and interactive C++ environments in Jupyter running on WebAssembly, with xeus-cpp.

      Speakers: Aaron Jomy (CERN), Vassil Vasilev (Princeton University (US))
    • 16:20 16:40
      AdePT: Detailed Monte Carlo Particle Transport on GPUs 20m

      Abstract: Despite being embarrassingly parallel, detailed particle transport remains challenging on GPUs because of the inherent divergence and random memory access. In this talk, a brief overview of AdePT and its hybrid CPU–GPU workflow is presented. The main performance bottlenecks and opportunities for further optimisation are discussed.

      Speaker: Severin Diederichs (CERN)
    • 16:40 17:05
      Discussion 25m