P. Russo’s scientific contributions

What is this page?


This page lists works of an author who doesn't have a ResearchGate profile or hasn't added the works to their profile yet. It is automatically generated from public (personal) data to further our legitimate goal of comprehensive and accurate scientific recordkeeping. If you are this author and want this page removed, please let us know.

Publications (5)


Figure 1. Error recovery example.
Figure 5. AST transformation of ill-formed C++ code preparing it for partial recompilation at runtime.
Figure 6. A complex example of dynamic expression. Usually the dynamic expressions are used homogeneously in the source code. We must allow mixing static and dynamic expressions. A main issue when mixing is the storage sharing. (For example, use static variables in dynamic expression). It leads to some extra implementation challenges at compilation time. Proper handling of mixed static and dynamic expression needs a way of sharing the relevant context. Cling does it by embedding the necessary information in the string that is passed for recompilation. In the particular type information and storage information of the actual arguments have to be passed in. The storage information is presented as void pointers showing the memory address of the arguments. The type information is needed for casting the void pointers to the expected arguments' type. Just before recompilation happens the "@" placeholders are replaced with the actual arguments' addresses in memory. The construct that contains the dynamic expression is important as well. When the expected return type of the callsite is recognized, the callsite template instantiation happens programmatically. In the snippet in Figure 6, the condition of the "if"-statement expects value of type Boolean. Thus the callsite is instantiated as Boolean. Later on, the recompilation makes sure the real result matches the expectation of the dynamic expression and if not, a diagnosis is issued.
Figure 7. Error recovery example.
Figure 8. ROOT core.

+1

Cling – The New Interactive Interpreter for ROOT 6
  • Conference Paper
  • Full-text available

May 2012

·

2,086 Reads

·

50 Citations

Journal of Physics Conference Series

·

Ph Canal

·

A Naumann

·

P Russo

Cling is an interactive C++ interpreter, built on top of Clang and LLVM compiler infrastructure. Like its predecessor Cint, Cling realizes the read-print-evaluate-loop concept, in order to leverage rapid application development. Implemented as a small extension to LLVM and Clang, the interpreter reuses their strengths such as the praised concise and expressive compiler diagnostics. We show how to match the interpreter concept to the compiler library and generalize common set of requirements for building up an interactive interpreter. We reason the design and implementation decisions as solution to the challenge of implementing interpreter behaviour as an extension of the compiler library. We present the new features, e.g. how C++11 will come to Cling and how Cint-specific extensions are being adopted. We clarify the state of integration in the ROOT framework and the induced change set. We explain how ROOT dictionaries are simplified due to the new interpreter.

Download

ROOT - A C++ Framework for Petabyte Data Storage, Statistical Analysis and Visualization

June 2011

·

1,302 Reads

·

590 Citations

Computer Physics Communications

·

·

·

[...]

·

A new stable version ("production version") v5.28.00 of ROOT [1] has been published [2]. It features several major improvements in many areas, most noteworthy data storage performance as well as statistics and graphics features. Some of these improvements have already been predicted in the original publication Antcheva et al. (2009) [3]. This version will be maintained for at least 6 months; new minor revisions ("patch releases") will be published [4] to solve problems reported with this version.


Figure 1: Streamers in ROOT version 0.90
Figure 2: Hand coded schema evolution 2.2. Automatic Schema Evolution With the increasing number of legacy class layouts to support, manually maintained streamer functions become quickly extremely complex and hence more vulnerable to the introduction of deficiencies. In addition any seemingly minor changes to the class layout, like adding a new member or changing the type of a member from short to int, requires manual attention. In order to alleviate these issues, we introduced a new streaming mechanism that leverages the availability of the class layout dictionary. The new mechanism relies on StreamerInfo objects that describe the name and type of the data member to be stored for one specific class. These StreamerInfo objects are stored along side the data in the ROOT file. Thanks to the addition of these StreamerInfo objects in the file, the ROOT file became selfdescribing and support for forward compatibility and reading without the original shared library became possible. Forward compatibility is the ability to read with an older version of the software a file that was written with a newer version of the software. The self-describing capability also allows other frameworks [7] to be able to read ROOT files since they can interrogate the file to learn how to interpret the file's content. When loading a StreamerInfo description from a file, the framework can lookup the memory offsets of the data members by simply matching the data member names from the StreamerInfo with the data member names lists in the dictionary. This is however only meaningful if the data members have the same name and contain the same logical information. When the names in the streamer information and in dictionary information match but the types of the data members differ between disk and memory and the type is a basic type then the framework will attempt to do the conversion.
Figure 3: Column-wise storage 
Support For Significant Evolutions of the User Data Model In ROOT Files

April 2010

·

86 Reads

·

6 Citations

Journal of Physics Conference Series

One of the main strengths of ROOT input and output (I/O) is its inherent support for schema evolution. Two distinct modes are supported, one manual via a hand coded streamer function and one fully automatic via the ROOT StreamerInfo. One draw back of the streamer functions is that they are not usable by TTree objects in split mode. Until now, the user could not customize the automatic schema evolution mechanism and the only mechanism to go beyond the default rules was to revert to using the streamer function. In ROOT 5.22/00, we introduced a new mechanism which allows user provided extensions of the automatic schema evolution that can be used in object-wise, member-wise and split modes. This paper will describe the many possibilities ranging from the simple assignment of transient members to the complex reorganization of the user's object model.


Developments in ROOT I/O and trees

January 2009

·

1 Read

For the last several months the main focus of development in the ROOT I/O package has been code consolidation and performance improvements. Access to remote files is affected both by bandwidth and latency. We introduced a pre-fetch mechanism to minimize the number of transactions between client and server and hence reducing the effect of latency. We will review the implementation and how well it works in different conditions (gain of an order of magnitude for remote file access). We will also review new utilities, including a faster implementation of TTree cloning (gain of an order of magnitude), a generic mechanism for object references, and a new entry list mechanism tuned both for small and large number of selections. In addition to reducing the coupling with the core module and becoming its owns library (libRIO) (as part of the general restructuration of the ROOT libraries), the I/O package has been enhanced in the area of XML and SQL support, thread safety, schema evolution, TTreeFormula, and many other areas. We will also discuss various ways, ROOT will be able to benefit from multi-core architecture to improve I/O performances.


Developments in ROOT I/O and trees

July 2008

·

113 Reads

·

1 Citation

Journal of Physics Conference Series

For the last several months the main focus of development in the ROOT I/O package has been code consolidation and performance improvements. We introduced a new pre-fetch mechanism to minimize the number of transactions between client and server, hence reducing the effect of latency on the time it takes to read a file both locally and over wide are network. We will review the implementation and how well it works in different conditions (gain of an order of magnitude for remote file access). We will also briefly describe new utilities, including a faster implementation of TTree cloning (gain of an order of magnitude), a generic mechanism for object references, and a new entry list mechanism tuned both for small and large number of selections. In addition to reducing the coupling with the core module and becoming its owns library (libRIO) (as part of the general restructuring of the ROOT libraries), the I/O package has been enhanced in the area of XML and SQL support, thread safety, schema evolution, tree queries, and many other areas.

Citations (3)


... During our initial computational experiments, we discovered a bottleneck in the current BioDynaMo version. Most of the execution time was spent starting the BioDy-naMo simulation engine, more precisely, initializing the C++ interpreter cling (Vasilev et al. 2012). Initialization became the dominant factor since the simulation of a single neuron is very fast compared to the extensive simulations with billions of agents that BioDynaMo supports. ...

Reference:

Calibration of stochastic, agent-based neuron growth models with approximate Bayesian computation
Cling – The New Interactive Interpreter for ROOT 6

Journal of Physics Conference Series

... After all jobs have finished processing of their respective ROG files, merging the resulting outputs from storage elements is done in the second step by a second manger which produce a global dose file of about 36 MB. This latter is explored with ROOT in the last step to produce different dose profiles [11]- [13]. ...

Support For Significant Evolutions of the User Data Model In ROOT Files

Journal of Physics Conference Series

... The different axion helioscope components required to calculate the apparatus response have been implemented inside the REST-for-Physics framework [42] as metadata descriptors, consisting of C++ data members that define the behavior of a particular class, and that can be integrated inside the REST-for-Physics framework I/O scheme, based on ROOT [43]. The new classes have been contributed to a dedicated REST-for-Physics library for axion physics-axionlib [44]-which can be optionally compiled as a module into the REST-for-Physics framework. ...

ROOT - A C++ Framework for Petabyte Data Storage, Statistical Analysis and Visualization

Computer Physics Communications