CHEP 2013 abstracts

Tuesday 5 Mar 2013, 08:00 → 18:00 Europe/Zurich

CERN

08:00 → 08:20 Geant4 Electromagnetic Physics for LHC Upgrade

Speaker: Prof. Vladimir Ivantchenko (CERN)

Slides EMPhysProg_v2.pdf

08:20 → 08:40 PROOF as a Service on the cloud: a virtual analysis facility based on the CernVM ecosystem

PROOF, the Parallel ROOT Facility, is a ROOT-based framework which enables interactive parallelism for event-based tasks on a cluster of computing nodes. Although PROOF can be used simply from within a ROOT session with no additional requirements, deploying and configuring a PROOF cluster used to be not as straightforward. Recently great efforts have been spent to make the provisioning of generic PROOF analysis facilities with zero configuration, with the added advantages of positively affecting both stability and scalability, making the deployment operations feasible even for the end user. Since a growing amount of large-scale computing resources are nowadays made available by Cloud providers in a virtualized form, we have developed the Virtual PROOF-based Analysis Facility: a cluster appliance combining the solid CernVM ecosystem and PoD (PROOF on Demand), ready to be deployed on the Cloud and leveraging some peculiar Cloud features such as elasticity. We will show how this approach is effective for sysadmins, who will have little or no configuration to do to run it on their Clouds, and for the end users too, who are ultimately in full control of their PROOF cluster and can even easily restart it by themselves in the unfortunate event of a major failure. We will also show how elasticity leads to a more optimal and uniform usage of Cloud resources.

Speaker: Dario Berzano (CERN)

08:40 → 09:00 Speeding up HEP experiments' software with a library of fast and autovectorisable mathematical functions*

During the first four years of data taking at the Large Hadron Collider (LHC), the simulation and reconstruction programs of the experiments proved to be extremely resource consuming. In particular, for complex event simulation and reconstruction applications, the impact of evaluating elementary functions on the runtime is sizeable (up to one fourth of the total), with an obvious effect on the power consumption of the hardware dedicated to their execution. This situation clearly needs improvement, especially considering the even more demanding data taking scenarios after this first LHC long shut down. A possible solution to this issue is the VDT (VectorisD maTh) mathematical library. VDT provides the most common mathematical functions used in HEP in an open source product. The functions' implementations are fast, can be inlined, provide an approximate accuracy and usable in vectorised loops. Their implementation is portable across platforms: x86 and ARM processors, Xeon Phi coprocessors and GPGPUS. In this contribution, we describe the features of the VDT mathematical library, showing significant speedups with respect to the Libm library and comparable accuracies. Moreover, taking as examples simulation and reconstruction workflows ran in production by the experiments, we show the benefits of the usage of VDT in terms of runtime reduction and stability of physics output.

Speaker: Danilo Piparo (CERN)

Slides CHEP2013-VDT.pdf

09:00 → 09:20 Introducing Concurrency in the Gaudi Data Processing Framework

In the past, the increasing demands for HEP processing resources could be fulfilled by distributing the work to more and more physical machines. Limitations in power consumption of both CPUs and entire data centers end this era of easy scaling. To get the most CPU performance per Watt, future hardware will be characterised by less and less memory per processor, thinner, more specialized and more numerous cores per die, and rather heterogeneous resources. To fully exploit the potential of the many cores, HEP data processing frameworks need to allow for parallel execution of reconstruction or simulation algorithms on several events simultaneously represents. We describe our experience in introducing concurrency related capabilities into Gaudi, an experiment-agnostic software framework which is adopted, among the others, by the ATLAS and LHCb experiments at the LHC. After a description of the concurrent framework and the most relevant design choices driving its development, we demonstrate its projected performance emulating data reconstruction workflows of the LHC experiments. As a second step, we describe the behaviour of the framework in a more realistic environment, using a subset of the real LHCb reconstruction workflow, and present our strategy and the used tools to validate the physics outcome of the parallel framework against the results of the present, purely sequential LHCb software. We then summarize the measurement of the code performance of the multithreaded application in terms of memory and CPU usage and I/O load.

Speakers: Benedikt Hegner (CERN), Danilo Piparo (CERN)

09:20 → 09:40 Micro-CernVM: Slashing the Cost of Building and Deploying Virtual Machines

The traditional virtual machine building and and deployment process is centered around the virtual machine hard disk image. The packages comprising the VM operating system are carefully selected, hard disk images are built for a variety of different hypervisors, and images have to be distributed and decompressed in order to instantiate a virtual machine. Within the HEP community, the CernVM File System has been established in order to decouple the distribution from the experiment software from the building and distribution of the VM hard disk images. We show how to get rid of such pre-built hard disk image altogether. Due to the high requirements on POSIX compliance imposed by HEP application software, CernVM-FS can also be used to host and boot a Linux operating system. This allows the use of a tiny bootable CD image that comprises only a Linux kernel while the rest of the operating system is provided on demand by CernVM-FS. This approach speeds up the initial boot time and reduces virtual machine image sizes by an order of magnitude. Furthermore, security updates can be distributed instantaneously through CernVM-FS and by leveraging the fact that CernVM-FS is a versioning file system, a historic analysis environment can be easily re-spawned by selecting the corresponding CernVM-FS file system snapshot.

Speaker: Jakob Blomer (CERN)

09:40 → 10:00 Recent developments in the Geant4 hadronic physics framework and models

*** draft *** In this paper we present the recent developments in the Geant4 hadronic framework, as well as some of the existing physics models. Geant4 is the main simulation toolkit used by the LHC experiments and therefore a lot of effort is put into improving the physics models in order for them to have more predictive power. In the same time the software complexity of the underlying framework grows constantly due to new developments and extensions, which requires improvement and optimisation on the programming side. *** To be continued. ***

Speaker: Witold Pokorski (CERN)

10:00 → 10:20 Strategies for preserving the software development history in LCG Savannah

Since more than ten years, the LCG Savannah portal successfully serves the LHC community in their software development cycles. In total more than 8000 users and 400 projects use this portal. Despite its success, the underlying infrastructure, based on the open-source project "Savane" did not keep up with the general evolution of web technologies, and the increasing need for information security. Thus, LCG Savannah is about to be replaced by a new service based on the Jira software. During the many years of running, a huge amount of project specific data was collected in LCG Savannah. We discuss the importance of this historic project data and the knowledge contained therein. Most of the data needs to be preserved for the future and we present our strategy for preserving the LCG Savannah data, the tools supporting the process, and the current status of the project.

Speaker: Benedikt Hegner (CERN)

10:20 → 10:40 Preparing HEP Software for Concurrency

Driven by the increasing processor parallelism, the necessity for really thread-safe experiment software emerged. For high-energy physics this is a real paradigm shift, as concurrent programming was previously only limited to special, well-defined domains like control software or software framework internals. This paradigm shift, however, falls into the middle of the successful LHC program and many million lines of code have already been written without the need for parallel execution in mind. In this presentation we will have a closer look at the offline processing applications of the LHC experiments and their readiness for the many-core era. We will review how previous design choices impact the move to concurrent programming. We present our findings on transforming parts of the LHC experiments' reconstruction software to thread-safe code, and main design patterns that emerged during the process. A plethora of parallel-programming patterns are well known outside the HEP community, but only a few have turned out to be straight forward enough to be suited for non-expert physics programmers. Finally, we propose a potential strategy for the migration of existing HEP experiment software to the many-core era.

Speakers: Benedikt Hegner (CERN), Danilo Piparo (CERN)

10:40 → 11:00 CernVM Online and Cloud Gateway: a uniform interface for CernVM contextualization and deployment

In a virtualized environment, contextualization is the process of configuring a VM instance for the needs of various deployment use cases. Contextualization in CernVM can be done by passing a handwritten context to the “user data” field of cloud APIs, when running CernVM on the cloud, or by using CernVM web interface when running the VM locally. CernVM online is a publicly accessible web interface that unifies these two procedures. A user is able to define, store and share CernVM contexts using CernVM Online and then apply them either in a cloud by using CernVM Cloud Gateway, or on a local VM with the single-step pairing mechanism. CernVM Cloud Gateway is a distributed system that provides a single interface to use multiple and different clouds (by location or type, private or public). Cloud gateway has been so far integrated with OpenNebula, CloudStack and EC2 tools interfaces. A user, with access to a number of clouds, can run CernVM cloud agents that will communicate with these clouds using their interfaces, and then use one single interface to deploy and scale CernVM clusters. CernVM clusters are defined in CernVM Online and consist of a set of CernVM instances that are contextualized and can communicate with each other. In this contribution we present these new components, their status and some common use cases, as well as possible future work. We will also show how the combination of CernVM Online and Cloud Gateway turns out to be an effective way to federate clouds.

Speaker: Georgios Lestaris (University of Athens (GR))

11:00 → 11:20 Geant4 - Towards major release 10

The Geant4 simulation toolkit has reached maturity in the middle of the previous decade, providing a wide variety of established features coherently aggregated in a software product which has become the standard for detector simulation in HEP and is used in a variety of other application domains. We review the most recent capabilities introduced in the kernel, highlighting those which are being prepared for the next major release 10.0 of Geant4 scheduled for the end of 2013. A significant new feature part of release 10.0 will be the integration of multi-threading processing, aiming at targeting efficient use of modern many-cores system architectures and minimisation of the memory footprint for exploiting event-level parallelism. We discuss its design features and impact on the existing API and user-interface of Geant4. Revisions are made to balance the need for preserving backwards compatibility and to consolidate and improve the interfaces, taking into account requirements from the multi-threaded extensions and from the evolution of the data processing model of the LHC experiments.

Speaker: Dr Gabriele Cosmo (CERN)

11:20 → 11:40 ROOT I/O in JavaScript - Reading ROOT files in a browser

In order to be able to browse (inspect) ROOT files in a platform independent way, a JavaScript version of the ROOT I/O subsystem has been developed, allowing to display the content of ROOT files in most of the web browsers, without having to install ROOT or any other software on the server or on the client. This gives a direct access to ROOT files from new any device in a light way. It is possible to display simple graphical objects like histograms and graphs (TH1, TH2, TH3, TProfile, TGraph, ...). The rendering of 1D/2D histograms and graphs is done with an external JavaScript library (d3.js), and another one (three.js) is used for 2D & 3D histograms. This poster will describe the techniques used to stream and display the content of a ROOT file, with a rendering being now very close to the one done with ROOT.

Speaker: Bertrand Bellenot (CERN)

11:40 → 12:00 Status of ROOT Graphics

ROOT 2D and 3D graphics have seen many new developments since the last CHEP conference. This poster will summarize them, emphasizing the most recent and noticeable ones: ROOT's new default style, new palettes, and its new latex-style text output. It will also give an overview on ongoing and planned projects.

Speaker: Mr Olivier Couet (CERN)

12:00 → 12:20 A new ROOT graphical back-end developed for Mac OS

In my poster I'll present a new ROOT's graphical back-end developed for the Mac OS X operating system as an alternative to the more than 15 year-old X11-based version. It's a complete implementation of ROOT's GUI, 2D and 3D graphics based on Apple's native APIs/frameworks, written in Objective-C++

Speaker: Timur Pocheptsov (Joint Inst. for Nuclear Research (RU))

12:20 → 12:40 C++ Evolves!

High Energy Physics is unthinkable without C++. But C++ is not the language it used to be: today it evolves continuously to respond to new requirements, and to benefit from the streamlined delivery process of new language features to compilers. How should HEP react? After a short, subjective overview of parallel languages and extensions, the main features of C++11 will be presented, including the new concurrency model. A simple migration strategy for HEP will be discussed. A second theme will focus on structs-of-arrays and limits of auto-vectorization. The evolution of C++ including vectorization and concurrency will be presented.

Speaker: Axel Naumann (CERN)

12:40 → 13:00 Vectorization of ROOT Mathematical Libraries

The ROOT Mathematical Libraries are used by the LHC experiments for simulation, reconstruction and analysis of high energy physics data. Improving their performance is crucial to optimize the overall computing resources. We will present the studies performed to optimize the performances of these libraries, such as the vector and matrix libraries using vectorization techniques. We will introduce also Vc, a dedicated library to explicit vectorization and we will show how this library can be combined and integrated with the ROOT matrix and vector classes. We will present as well the performances improvements obtained in the fitting classes of ROOT.

Speaker: Lorenzo Moneta (CERN)

13:00 → 13:20 Using Cling/LLVM and C++11 for parametric function classes in ROOT

The parametric function classes of ROOT (TFormula and TF1) have been improved using the capabilities of Cling/LLVM. We will present how formula expressions can now be compiled on the fly using the just in time capabilities of LLVM/Cing. Furthermore using the new features of C++ 11, one can build complex function expression by re-using the existing mathematical functions. We will show also the possibility of implementing auto-differentiation for having an automatic derivative computation of the functions.

Speaker: Lorenzo Moneta (CERN)

13:20 → 13:40 Automatic Differentiation With Cling in ROOT

Differentiation is ubiquitous in high energy physics, for instance in minimization. Automatic differentiation (AD) avoids limitations that symbolic and numerical differentiation suffer from, by transforming the source code of a function. We will present how automatic differentiation can be used to compute the gradient of a multi-variate function in a minimization/optimization algorithm. It does not suffer from round-off errors as numerical differentiation, the technique which is currently used, and AD it is also faster. We will explain approaches to implement an AD tool. We will show how Cling (our C++11 interpreter) simplifies creation of such automatic differentiation tool and could be used and integrated within ROOT. We will demonstrate a simple proof-of-concept prototype.

Speakers: Lorenzo Moneta (CERN), Vasil Georgiev Vasilev (Plovdiv University Paisii Hilendarski (BG))