Optimizing Frameworks Performance Using C++ Modules Aware ROOT

TL;DR

This paper explores integrating C++ Modules into the ROOT data analysis framework to enhance runtime performance by reducing header parsing time, presenting experimental results and addressing associated challenges.

Contribution

It introduces experimental support for C++ Modules in ROOT and evaluates their impact on performance, highlighting implementation challenges and benefits.

Findings

C++ Modules reduce header parsing time in ROOT

Performance improvements observed with C++ Modules integration

Challenges include compatibility and implementation complexity

Abstract

ROOT is a data analysis framework broadly used in and outside of High Energy Physics (HEP). Since HEP software frameworks always strive for performance improvements, ROOT was extended with experimental support of runtime C++ Modules. C++ Modules are designed to improve the performance of C++ code parsing. C++ Modules offers a promising way to improve ROOT's runtime performance by saving the C++ header parsing time which happens during ROOT runtime. This paper presents the results and challenges of integrating C++ Modules into ROOT.

Full text

1 Introduction

The core part of HEP data analysis framework ROOT root is the C++ interpreter Cling. Cling is build on the top of the C++ compiler Clang and it allows users to enable interactive ROOT sessions. It also serves as a backend for ROOT’s language bindings such as ROOT Python extension module PyROOT.

In order to offer these features, Cling has to parse source code during runtime. This includes not only the code manually entered by the user from a command line, but also a multitude of the header files coming from libraries and frameworks. The header file parsing can negatively affect ROOT’s performance as it consumes notable amounts of memory and CPU time.

Since the inefficient header parsing in C++ is a well-known issue, it was introduced C++ Modules, delivering a compact, efficient representation of header files. Modules are becoming a promising technology for C++ community and since the adoption of C++ Modules into ROOT was already proposed earlier in paper vassil-paper and we implemented them in ROOT and its interpreter Cling. This allowed us to avoid the expensive parsing of headers and improve ROOT’s runtime performance.

2 Background

Even before C++ Modules adoption, ROOT has been heavily optimized and exploits several mechanisms to improve the performance of the interpreter. In this section we will discuss existing mechanisms in the context of C++ Modules: ROOT precompiled header (PCH), ROOTMAP files (ROOTMAP) and RDICT files.

2.1 Optimizing ROOT using a PCH

ROOT ships with a precompiled header (PCH) available for a subset of ROOT’s components. The PCH the CPU and memory cost for heavily used ROOT libraries. The PCH technology has been well-understood for decades. It is an efficient on-disk representation of the state of the compiler after parsing a set of headers. It can be loaded before starting the next instance to avoid doing redundant work. However, this approach limits compiler to use only a single PCH, as it’s usually too involved to merge multiple compiler states loaded from different PCH files. ROOTâs dictionary generator, rootcling, generates one PCH file at build time, which is loaded on startup and ROOT proceeds to lazily evaluate the code from the file when needed.

The PCH is by design monolithic and not extensible. It introduces problems for third party libraries who want to improve the performance of their code with a PCH. They cannot provide a second PCH file with their code as this is not possible by design. For ROOT developers the PCH brings the problem that changing a single header requires the regeneration of the whole PCH file.

A less restrictive alternative to PCH files is C++ Modules (PCM files). Unlike a PCH, PCM files are designed to be separable, so that multiple PCMs can be attached to the same interpreter or compiler simultaneously. This means that it is possible to split up the content of a single PCH into multiple PCMs as shown in Figure 1. Also, it is possible to rebuild only a subset of all attached PCMs. In ROOT, a single PCM file usually corresponds to a single library.

The implementation of C++ Modules in ROOT is based on Clang’s implementation, which is called as an API from ROOT. Clang uses configuration files called Module Maps for defining the contents of a C++ Module. To stay consistent with Clang, ROOT also uses Module Map files to configure Module contents.

2.2 Optimizing third-party code with ROOTMAP and RDICT

ROOTMAP files are used by ROOT to map unknown symbols and identifiers to libraries. When encountering an unknown symbol or identifier, ROOT uses ROOTMAP files to load the corresponding library. An advantage of this approach is that ROOTMAP files allow ROOT to only parse headers of libraries that are actually used. The expensive header parsing only happens when it is necessary.

RDICT files efficiently store information needed for serialization and deserialization of data types. They allow ROOT to perform IO operations on these data types without loading the respective code from the PCH or parsing the respective library headers.