Project Meetings

Connection information: Link to zoom

Agenda:

• Numba 2023 and beyond. PIXIE and RVSDG (Siu Kwan Lam, Stuart Archibald)
  Abstract:

  The Numba project engineers are undertaking research into some new technology in 2023, in this talk two of the larger areas of this research will be presented. One part of this research aims to alter the typical view of the compilation space as neither being JIT nor AOT, but as a user defined continuum of options. A new AOT output format is being developed, PIXIE, which helps to provide higher performance runtime execution and also allows for cross library/whole program optimisation, along with AOT re-specialisation. This talk will present the Numba 2023 target MVP, it will be able to combine AOT compiled C/C++ libraries from Clang based toolchains with JIT compiled Python code to present a continuum of compilation options to users based on their desired compilation and runtime performance characteristics.

  Another part of the research being undertaken is into Regionalise Value State Dependence Graphs (RVSDGs). Its initial use will be to isolate the Numba compiler frontend from the ever changing semantics of Python byte code (Numba uses this as its input source, it’s a CPython implementation detail). It will do this by transforming the CFGs derived from the byte code into a structured form, that of the RVSDG. This talk will note some of the numerous research opportunities anticipated as a result of using this form, particularly with respect to IR design and the expected ease with which new compiler passes can be written.

• Update (Vassil)
• Round Table
• Next meeting (Vassil) 4 May 1700

Connection information: Link to zoom

Agenda:

• Round Table (M Foco (NVIDIA), W Moses (MIT), A Penev (University of Plovdiv), M Vassilev (University of Plovdiv), I Ifrim (Princeton), Garima Singh (Manipal Institute of Tech) ) []

  Meeting Notes

Connection information: Link to zoom

Agenda:

• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 6 Apr 1700

Connection information: Link to zoom

Agenda:

• Updates

  Meeting Notes

• Implement value printing in clang-repl - Roadmap (Jun Zhang) [Jan 25, 2023]

  Slides

• The CaaS Project. Progress & Plans Q3, Q4 (Vassil Vassilev) [Sep 21, 2022]

  Slides

• Shared Memory Based JITLink Memory Manager (Anubhab Ghosh) [Sep 7, 2022]

  Slides

• Current working status of optmizing ROOT modules (Jun Zhang) [Sep 7, 2022]

  Slides

• Clang Template Specialization Resugaring - Roadmap Part 2 (Matheus Izvekov) [Aug 31, 2022]

  Slides

• Add Initial Integration of Clad with Enzyme - Final Presentation (Manish Kausik H) [Aug 31, 2022]

  Slides

• Improving the Cling Packaging Tool - Final Presentation (Surya Somayyajula) [Aug 10, 2022]

  Slides

• Write JITLink support for new format/architecture Current Progress (Sunho Kim) [Aug 10, 2022]

  Slides

• Adding AD Support to RooFit (Garima Singh) [Jul 20, 2022]

  Slides

• The CaaS Project. Progress & Plans Q2, Q3 (Vassil Vassilev) [Jul 13, 2022]

  Slides

• Improving the Clang-REPL documentation (Sara Bellei) [Jun 29, 2022]

  Slides

• Clang-REPL Interactive Analysis - Roadmap (Rohit Singh Rathaur) [Jun 29, 2022]

  Slides

• Python and C++ clang-repl Integration - Progress Update (Ioana Ifrim) [Jun 15, 2022]

  Slides

• Shared Memory Based JITLink Memory Manager - Roadmap (Anubhab Ghosh) [Jun 15, 2022]

  Slides

• Write JITLink support for a new format/architecture - Roadmap (Sunho Kim) [Jun 8, 2022]

  Slides

• Optimize ROOT use of modules for large codebases - Roadmap (Jun Zhang) [Jun 8, 2022]

  Slides

• Add Initial Integration of Clad with Enzyme - Roadmap (Manish Kausik H) [Jun 1, 2022]

  Slides

• Clang Template Specialization Resugaring - Roadmap Part 1 (Matheus Izvekov) [Jun 1, 2022]

  Slides

• Improving performance of C++ modules in Clang-Project - Roadmap (Tapasweni Pathak) [May 25, 2022]

  Slides

• cppyy Progress Update (Baidyanath Kundu) [May 11, 2022]

  Slides

• Utilizing Clad Derivatives in RooFit - Progress Update (Garima Singh) [Apr 27, 2022]

  Slides

• The CaaS Project.Progress & Plans Q1, Q2 (Vassil Vassilev) [Apr 20, 2022]

  Slides

• Differentiation of Eigen and Softsusy libraries by Clad - Project Progress (Parth Arora) [Apr 6, 2022]

  Slides

• Enhance the incremental compilation error recovery in clang and clang-repl - Project Roadmap and Updates (Purva Chaudhari) [Mar 30, 2022]

  Slides

• Heterogenous AD with Clad - CUDA kernels diff support - Project Roadmap (Ioana Ifrim) [Mar 23, 2022]

  Slides

• Improving the reflection layer in cppyy using Cling - Project Roadmap (Baidyanath Kundu) [Mar 9, 2022]

  Slides

• The CaaS Project. Plans Q1, Q2 (Vassil Vassilev) [Feb 16, 2022]

  Slides

• Utilizing Clad Derivatives in RooFit - Preliminary Project Roadmap (Garima Singh) [Feb 16, 2022]

  Slides

• Add support for differentiating with respect to user-defined types -- Progress Update (Parth Arora) [Jan 5, 2022]

  Slides

Connection information: Link to zoom

Agenda:

• Multiline input and Windows support in clang-repl (Sunho Kim, De Anza College, CA)
  Abstract:

  Efficient multiline input support in clang-repl has been worked on over the last months. We formulated a RFC to extend the clang Lexer to receive incremental in LLVM community and implemented it with received feedbacks considered. Clang Lexer is now capable of lexing buffer growing line by line while handling all complicated preprocessor expressions correctly. Based on this groundwork, an efficient incremental input support was added to clang-repl.

  I will demonstrate these new additions to clang-repl with demoes, talk about how do they work under the good, and talk about the future direction. I will also briefly show demos of enhanced Windows support in clang-repl featuring native static library and SEH exception handling. video: “https://youtu.be/jc5oj8ooG7s”

• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 2 Mar 1700

Connection information: Link to zoom

Agenda:

• Finding the Higgs on RISC-V (Jonas Hahnfeld, CERN)
  Abstract:

  Abstract: RISC-V is a new computer architecture. It currently receives a lot of attention from open source developers because the ISA itself is royalty free and vendors can create hardware without paying licensing fees. As with any new architecture, the software ecosystem has to catch up once actual hardware is available. In this talk, I will present the current status of Just-In-Time-Compilation support for RISC-V in LLVM, how I made clang-repl work on RISC-V to interpret C++ code and eventually bring up the whole of Cling and ROOT to run a first physics analysis on this new architecture.

  Slides Video
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 2 Feb 1700

Connection information: Link to zoom

Agenda:

• JITLink: Native Windows JITing in LLVM (Sunho Kim, De Anza College, CA)
  Abstract:

  JITLink is a new JIT linker in LLVM developed to eliminate limitations in LLVM’s JIT implementation. With JITLink, it is not required to use special compilation flags or workarounds to load code into the JIT, since most of the object file features including small code model and thread local storage are fully implemented. This tutorial will explain how to use JITLink by working on a windows JIT application that just-in-time links to third-party static libraries. The tutorial will also dig into internals of JITLink by working on a JITLink plugin managing SEH exception tables.

  Slides Video
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 8 Dec 1700

Connection information: Link to zoom

Agenda:

• jank: A Clojure dialect on LLVM with gradual typing, a native runtime, and C++ interop (Jeaye Wilkerson, Technical Director at Electronic Arts (EA))
  Abstract:

  Following years of Lisp development, Clojure has entered the scene as a practical Lisp for the JVM. It takes a functional-first approach to designs and has extensive support for purely transforming persistent, immutable data structures. The interactive programming experience Clojure brings to the JVM is unmatched, built on both a JIT and technology such as nREPL. Clojure developers use this interactive programming to build their software from empty source files to working servers, GUI applications, and more without restarting the process.

  In the spirit of Clojure, I would like to present jank, a research programming language which is a Clojure dialect built on native C++, rather than the JVM, using Cling as its JIT compiler. jank aims to be strongly compatible with Clojure while offering the same interactive programming experience. Like Clojure, jank aims to provide seamless interop with its host (meaning C++), allowing for easy consumption of third-party libraries. On top of a native runtime, jank also aims to provide gradual, structural typing, which will not be covered in this presentation.

  Slides Video
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 3 Nov 1700

Connection information: Link to zoom

Agenda:

• Update (Vassil)
• Round Table
• Next meeting (Vassil) 6 Oct 1700

Connection information: Link to zoom

Agenda:

• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 1 Sep 1700

Connection information: Link to zoom

Agenda:

• Update (Ioana) Slides
• Round Table
• Next meeting (Ioana) 4 Aug 1700

Connection information: Link to zoom

Agenda:

• Cling for live coding music and musical instruments (Jack Armitage, Intelligent Instruments Lab)
  Abstract:

  The artistic live coding community has been growing steadily since around the year 2000. The Temporary Organisation for the Permanence of Live Art Programming (TOPLAP) has been around since 2004, Algorave (algorithmic rave parties) recently celebrated its tenth birthday, and six editions of the International Conference on Live Coding (ICLC) have been held. A great many live coding systems have been developed during this time, many of them exhibiting exotic and culturally specific features that professional software developers are mostly unaware of. This talk will introduce the artistic live coding context and community, and then describe attempts by this community to appropriate the Cling C++ interpreter for artistic practice. In one such example, Cling has been used as the basis for a C++ based live coding synthesiser [1]. In another example, Cling has been installed on a BeagleBoard to bring live coding to the Bela interactive audio platform [2]. Following these examples, I will offer some reflections on the potential mutual benefits for increased engagement between the Cling community and the artistic live coding community.

  [1] tiny spectral synthesizer with livecoding support
  [2] Using the Cling C++ Interpreter on the Bela Platform

  Slides
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 7 Jul 1700

Connection information: Link to zoom

Agenda:

• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 9 Jun 1700

Connection information: Link to zoom

Agenda:

• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 5 May 1700

Connection information: Link to zoom

Agenda:

• ez-clang: experimental C++ REPL for bare metal (Stefan Gränitz, LLVM Orc JIT developer)
  Abstract:

  In 2021 a new remote-JIT layer “RemoteEPC” landed in LLVM’s OrcJIT library [0]. It separates serialization from transport, streamlines error behavior and integrates well with ExecutorProcessControl. Combined with the clean design and extensibility of ORCv2 and JITLink, it lowers the bar for building exotic out-of-process LLVM bitcode JITs.

  The ez-clang project [1] makes use of all these to build a pure out-of-process REPL specifically designed for very low-resource embedded devices. The executor endpoint on the device is very simple and fits into a few Kilobytes of memory. All heavy lifting happens in the JIT process on the host.

  I want to present my proof-of-concept implementation, which is based on a hacked-up version of cling [2] (bringing in Clang-integration, a command line and the concept of transaction-based incremental compilation). Right now, it supports a small selection of Cortex-M development boards. The smallest is the TeensyLC [3] with an ARMv6-M instruction set, 62kb Flash memory and 8kb RAM.
  [0] https://github.com/llvm/llvm-project/commit/bb27e4564355
  [1] https://echtzeit.dev/ez-clang
  [2] https://github.com/root-project/cling
  [3] https://www.pjrc.com/teensy/teensyLC.html

  Slides Video
• Update (Vassil) Slides
• Round Table
• Next meeting 7 Apr 1700

Connection information: Link to zoom

Agenda:

• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 10 Mar 1700

Connection information: Link to zoom

Agenda:

• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 3 Feb 1700

Connection information: Link to zoom

Agenda:

• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 13 Jan 1700

Connection information: Link to zoom

Agenda:

• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 9 Dec 1700

Connection information: Link to zoom

Agenda:

• Proposal for a C++ Language Interoperability Layer (Vassil Vassilev, Princeton)
  Abstract:

  The C++ programming language is used for many numerically intensive scientific applications. A combination of performance and solid backward compatibility has led to its use for many research software codes over the past 20 years. Despite its power, C++ is often seen as difficult to learn and inconsistent with rapid application development. Exploration and prototyping is slowed down by the long edit-compile-run cycles during development. Exploratory programming is an effective way to gain a deeper understanding of a project’s requirements; reduce the complexity of a problem; and provide an early validation of the system’s design and implementation. This is amongst the strengths of Python and a major design goal of new languages such as Julia, D and Swift.

  Two of the most widely used languages by researchers are C++ and Python. Python has grown steadily as a language of choice for data science and application control. The interactive nature of Python and its many available libraries make it an excellent choice for scripting tasks and code prototyping. However, native computational performance of Python is mediocre. Python includes functionality for replacing the most critical components of a processing kernel with implementations in C. This functionality is insufficient to fully cover many scientific use cases because crossing the language boundary is expensive due to limitations in current tools.

  This talk describes key aspects of language interoperability for C++ using an automated binding approach. The primary initial focus is to support automatic binding to and from Python. Furthermore, the approach is generic enough to fit other languages such as D and Julia.

  Slides
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 4 Nov 1700

Connection information: Link to zoom

Agenda:

• Cppyy (Wim Lavrijsen, LBL)
  Abstract:

  cppyy provides automatic Python bindings to C++ code, at runtime, through Cling, the C++ interpreter. Python is itself a dynamic language executed by an interpreter, thus the interaction with C++ code becomes more natural when intermediated by Cling. Examples include runtime template instantiations, callbacks, cross-language inheritance, automatic downcasting, and exception mapping. Many advanced C++ features such as placement new, multiple virtual inheritance, variadic templates, etc., are also naturally handled.

  cppyy achieves high performance through an all-lazy approach and specialization of common cases through runtime reflection. As such, it has a much lower call overhead than other binders, notably in its implementation for PyPy, a fully compatible Python interpreter sporting a tracing JIT. Furthermore, cppyy makes maintaining a large software stack simpler: except for cppyy’s own python-interpreter binding, it does not have any compiled code that is Python-dependent. I.e., cppyy-based extension modules require no recompilation when switching Python interpreters.

  In this presentation I’ll show the benefits of runtime Python-C++ bindings and give a bird’s eye overview of the implementation underpinning cppyy.

  Slides Video
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 7 October 1700

Connection information: Link to zoom

Agenda:

• A brief history of Cxx.jl (Keno Fischer, JuliaComputing)
  Abstract:

  Cxx.jl is one of the oldest Julia packages and provides extremely tight integration between Julia and C++. With advanced features including a C++, REPL environment, the ability to perform cross-language template instantiation as well as cross-language object implementation, it is a powerful tool for developers seeking to integrate the two languages. However, despite these capabilities, the package never fully became mainstream due to a number of technical limitations. In this talk, I will explore the design and featureset of Cxx.jl, and what limitations in Clang and Julia prevented its full adoption in the Julia world.

  Slides Video
• Calling ROOT from Julia in practice (Oliver Schulz, Max-Planck-Institut für Physik)
  Abstract:

  Julia can directly call C++ via the Cxx.jl package. This enables is to use basically all of ROOT’s capabilities directly from Julia, including reading/writing TFiles and user ROOT’s GUI features. I’ll present some past experiences and practical examples of Julia/ROOT interaction.

  Slides
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 2 September 1700

Connection information: Link to zoom

Agenda:

• ORC 2021 -- Recent developments and future work in LLVM's JIT APIs (Lang Hames, Apple)
  Abstract:

  LLVM’s On Request Compilation (ORC) APIs provide a foundation for building in-memory and just-in-time compilers by re-using existing static compilers. This re-use is enabled by appending a new linking step to the standard compiler pipeline to patch the compiler output into the executing process. The ORC APIs support concurrent compilation, lazy compilation, and linking of code across process boundaries and even across architectures. The ORC APIs are already used in several open source projects including PostgreSQL, Cling, Julia, and the Swift interpreter; and they remain under active development with new features added frequently. This talk will provide an overview of the ORC APIs and recent developments, as well as demos and pointers to example code.

  Slides
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 5 August 1700

Connection information: Link to zoom

Agenda:

• Cymbl: To -jInfinity & Beyond (William Moses, MIT)
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 1 July 1700

Connection information: Link to zoom

Agenda:

• GPU Acceleration of Automatic Differentiation in C++ with Clad (Ioana Ifrim, Princeton) Slides Video
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 3 June 1700

Connection information: Link to zoom

Agenda:

• Deep dive into the Xeus-based Cling kernel for Jupyter (Sylvain Corlay, QuantStack)
  Abstract:

  Sylvain Corlay from QuantStack talks about C++ in Jupyter Notebooks using the Xeus-Cling. Xeus-Cling is a Cling-based notebook kernel which delivers interactive C++. Sylvain makes a deep dive in topic outlining some of the specific challenges and requirements.

  Slides Video
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 6 May 1700

Connection information: Link to zoom

Agenda:

• Cling’s CUDA Backend: Interactive GPU development with CUDA C++ (Simeon Ehrig, HZDR)
  Abstract:

  Simeon Ehrig from Helmholtz-Zentrum Dresden-Rossendorf (HZDR) shared his work with us recently. In his talk he gives insights about interactive CUDA using the C++ interpreter Cling. He shows several exciting examples in the area of dynamic execution without loss of state where we can “checkpoint” the execution state, add specific data analysis and reuse the previous computations.

  Slides Video
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 25 Mar 1700

Connection information: Link to zoom

Agenda:

• Calling C++ libraries from a D-written DSL: A cling/cppyy-based approach (Alexandru Militaru)
  Abstract:

  Alexandru Militaru shared his work with us recently. In his talk he gives insights about C++/D interoperability on the fly using the interactive C++ interpreter Cling and cppyy.

  Slides Video
• Calling C++ libraries from a D-written DSL: A cling/cppyy-based approach. Demo (Alexandru Militaru)
• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 04 Mar 1700

Connection information: Link to zoom

Agenda:

• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 04 Feb 1700

Connection information: Link to zoom

Agenda:

• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) 14 January 1700

Connection information: Link to zoom

Agenda:

• Update (Vassil) Slides
• Round Table
• Next meeting (Vassil) [Doodle pool for week of November 30](https://doodle.com/poll/bkkahvx9d5rrbka2)

Connection information: Link to zoom

Agenda:

• Project introduction (Vassil) Slides
• Round Table