Group Members

David J Lange

Research Staff
email: David.Lange@princeton.edu

Education: PhD Phyiscs, University of California, Santa Barbara (1999).

Vassil Vassilev

Research Staff
email: vvasilev@cern.ch

Education: PhD Computer Science, University of Plovdiv “Paisii Hilendarski”, Plovdiv, Bulgaria (2015).

Ioana Ifrim

Research Staff
email: ioana.ifrim@cern.ch

Education: MPhil Advanced Computer Science, University of Cambridge (2018)

Sara Bellei

Google Season of Docs 2022
email: sara.bellei.87@gmail.com

Education: PhD in Physics, Politecnico University of Milan, Italy (2017)

Ongoing project: Improving the Clang-REPL documentation
Clang-REPL is the evolution of Cling, an interactive c++ interpreter based on LLVM and Clang. It first developed as part of the high-energy physics (HEP) data analysis project - ROOT, and subsequently grew as a standalone tool outisde the HEP community. The main goal behind the Clang-REPL project is to move most parts of Cling into LLVM. By doing so, the benefits of using the LLVM community standards for code reviews, release cycles and integration will ensure the software’s sustainability, and will enable it to reach a wider audience. My goal is to establish a protocol for the Clang-REPL’s documentation that will be easy to read from user’s perspective, and easy to update as the codes continue to evolve.

Project Proposal: URL

Project Reports:

Mentors: Vassil Vassilev, David Lange

Surya Somayyajula

IRIS-HEP Fellow
email: somayyajula@wisc.edu

Education: Computer Sciences B.S., University of Wisconsin-Madison

Ongoing project: Improve Cling’s packaging system: Cling Packaging Tool
Cling is an interactive C++ interpreter/compiler that utilizes the REPL (read-evaluate-print-loop) paradigm for fast development and testing as well as immediate feedback and runtime-generated code. One of the many useful tools included in the Cling interpreter is the Cling Packaging Tool (CPT), which is a command line utility that can easily build Cling from source and generate installer bundles for a variety of platforms, including Ubuntu and Debian-based platforms, Windows, distributions based on Red Hat Linux, Mac OS X, and any Unix-like platform. While the CPT is an incredibly useful and flexible tool, there are several improvements that can be made to make the user’s experience with the CPT even more seamless.

Project Proposal: URL

Project Reports:

Mentors: Vassil Vassilev, David Lange

Rohit Singh Rathaur

Google Season of Docs 2022
email: rohitrathore.imh55@gmail.com

Education: Mathematics & Computing, Birla Institute of Technology, Mesra, India

Ongoing project: Improving Interactive Tool Analysis Documentation for the HSF
HEP researchers have developed several unique software technologies in the area of data analysis. Over the last decade we developed an interactive, interpretative C++ interpreter (aka REPL) as part of the ROOT data analysis project. We invested a significant effort to replace CINT, the C++ interpreter used until ROOT5, with a newly implemented REPL based on LLVM Cling. Cling is a core component of ROOT and has been in production since 2014. Cling is also a standalone tool, which has a growing community outside of our field. It is recognized for enabling interactivity, dynamic interoperability and rapid prototyping capabilities for C++ developers. For example, if you are typing C++ in a Jupyter notebook you are using the xeus-cling Jupyter kernel. So we are in the midst of an important project to address one of the major challenges to ensure Clings sustainability and to foster that growing community: moving most parts of Cling into LLVM. Since LLVM version 13 we have a version of Cling called Clang-Repl. As we advance the implementation and generalize its usage here we aim for improving the overall documentation experience in the area of interactive C++.

Project Proposal: URL

Project Reports:

Mentors: Vassil Vassilev, David Lange

Garima Singh

Research Intern at CERN
email: garimasingh0028@gmail.com

Education: B. Tech in Information Technology, Manipal Institute of Technology, Manipal, India

Ongoing project: Add Numerical Differentiation Support in Clad
In mathematics and computer algebra, automatic differentiation (AD) is a set of techniques to numerically evaluate the derivative of a function specified by a computer program. Automatic differentiation is an alternative technique to Symbolic differentiation and Numerical differentiation (the method of finite differences). Clad is based on Clang which provides the necessary facilities for code transformation. The AD library can differentiate non-trivial functions, find a partial derivative for trivial cases, and has good unit test coverage. In several cases, due to different limitations, it is either inefficient or impossible to differentiate a function. For example, clad cannot differentiate declared-but-not-defined functions. In that case, it issues an error. Instead, clad should fall back to its future numerical differentiation facilities.

Project Proposal: URL

Project Reports:

Mentors: Vassil Vassilev, Alexander Penev

Completed project: Floating point error evaluation with Clad
Floating-point estimation errors have been a testament to the finite nature of computing. Moreover, the predominance of Floating-point numbers in real-valued computation does not help that fact. Float computations are highly dependent on precision, and in most cases, very high precision calculation is not only not possible but very inefficient. Here, one has no choice but to resort to lower precision computing, which in turn is quite prone to errors. These errors result in inaccurate and sometimes catastrophic results; hence, it is imperative to estimate these errors accurately. This project aims to use Clad, a source transformation AD tool for C++ implemented as a plugin for the C++ compiler Clang, to develop a generic error estimation framework that is not bound to a particular error approximation model. It will allow users to select their preferable estimation logic and automatically generate functions augmented with code for the specified error estimator.

Project Proposal: URL

Project Reports:

Mentors: Vassil Vassilev, David Lange

Baidyanath Kundu

Research Intern at CERN
email: kundubaidya99@gmail.com

Education: B. Tech in Computer Science and Engg., Manipal Institute of Technology, Manipal, India

Ongoing project: Improving Cling Reflection for Scripting Languages
Cling has basic facilities to make queries about the C++ code that it has seen/collected so far. These lookups assume, however, that the caller knows what it is looking for and the information returned, although exact, usually only makes sense within C++ and is thus often too specific to be used as-is. A scripting language, such as Python, that wants to make use of such lookups by name, is forced to loop over all possible entities (classes, functions, templates, enums, …) to find a match. This is inefficient. Furthermore, many lookups will be multi-stage: a function, but which overload? A template, but which instantiation? A typedef, of what? The current mechanism forces the scripting language to provide a type-based match, even where C++ makes distinctions (e.g. pointer v.s. reference) that do not exist in the scripting language. This, too, makes lookups very inefficient. The returned information, once a match is found, is exact, but because of its specificity, requires the caller to figure out C++ concepts that have no meaning in the scripting language. E.g., there is no reason for Python to consider an implicitly instantiated function template different from an explicitly instantiated one.

Project Proposal: URL

Project Reports:

Mentors: Wim Lavrijsen, Vassil Vassilev

Completed project: Utilize second order derivatives from Clad in ROOT
ROOT is a framework for data processing, born at CERN, at the heart of the research on high-energy physics. ROOT has a clang-based C++ interpreter Cling and integrates with the automatic differentiation plugin Clad to enable flexible automatic differentiation facility. TFormula is a ROOT class which bridges compiled and interpreted code. This project aims to add second order derivative support in TFormula using clad::hessian. The PR that added support for gradients in ROOT is taken as a reference and can be accessed here.

Project Proposal: URL

Project Reports:

Mentors: Vassil Vassilev, Ioana Ifrim

Purva Chaudhari

Research Intern
email: purva.chaudhari02@gmail.com

Education: Computer Science, Vishwakarma Institute of Technology

Ongoing project: Enhance the incremental compilation error recovery in clang and clang-repl
The Clang compiler is part of the LLVM compiler infrastructure and supports various languages such as C, C++, ObjC and ObjC++. Advancements in JIT infstructure and usability of Clang libriries in LLVM has enabled research into processing C++. It has been challenging to include incremental compilation and fitting compile time optimizations into a more dynamic environment. Incremental compilation pipelines process code chunk-by-chunk by building an ever-growing translation unit. Code is then lowered into the LLVM IR and subsequently run by the LLVM JIT. The incremental compilation mode is used by the interactive C++ interpreter, Cling, initially developed to enable interactive high-energy physics analysis in a C++ environment. Clang-repl is a new-tool incroporated in LLVM ecosystem by residesigning parts of Cling in Clang mainline. The project aims at enhancing the error recovery when users type C++ at the prompt of clang-repl.

Project Proposal: URL

Project Reports:

Mentors: Vassil Vassilev, David Lange

Completed project: Reduce boost dependencies in CMSSW
This project has the objective to reduce CMSSW technical debt by finding and replacing boost dependencies that have an equivalent solution in standard C++. Reducing boost dependencies helps us create more lightweight boost clang modules for upcoming c++20. This also reduces the amount of headers that we need to work on to be able to use c++20 clang modules.

Project Proposal: URL

Project Reports: URL

Mentors: Vassil Vassilev, David Lange

Matheus Izvekov

Google Summer of Code Contributor 2022
email: mizvekov@gmail.com

Education: Computer Science

Ongoing project: Preserve type sugar for member access on template specializations
In C++, it’s often useful to write wrappers that abstract or extend some underlying type passed as a template argument. But templates are only instantated taking into account the ‘fundamental’ types of the arguments, discarding ‘type sugar’, such as any aliases, attributes or other cosmetic metadata such as how the name of the type was qualified and such. While this ends up in practice being brittle to rely on, attributes on the type itself or a typedef thereof can have many interesting non-cosmetic effects, like changing data alignment, calling conventions, and other custom / domain specific functionality. We refer to such ‘fundamental’ types as ‘canonical’ types here. Without any further engineering to work around this limitation, member accesses on template specializations will only reflect these canonical types, with the simplest example being the loss of any sugar on the argument when acessing a member alias to the argument itself. For this project, we will improve Clang’s type system so that any type sugar on the arguments of a template specialization are pushed into those member accesses.

Project Proposal: URL

Project Reports:

Mentors: Vassil Vassilev, Richard Smith

This could be you!

See openings for more info
email: vvasilev@cern.ch