Back to overview

ParaBoost: Exploiting multi-variant execution

English title ParaBoost: Exploiting multi-variant execution
Applicant Hauswirth Matthias
Number 157159
Funding scheme Project funding (Div. I-III)
Research institution Istituto del Software (SI) Facoltà di scienze informatiche
Institution of higher education Università della Svizzera italiana - USI
Main discipline Information Technology
Start/End 01.10.2014 - 31.03.2016
Approved amount 152'615.00
Show all

Keywords (4)

back-in-time debugging; multi-variant execution; virtual execution environments; heterogeneous computing

Lay Summary (German)

Die Entwicklung korrekter und effizienter Softwaresysteme ist schwierig, und wird mit den stetig wachsenden Anforderungen an Software zukünftig noch schwieriger. Dieses Projekt studiert auf welche Art Programmiersprachen und Laufzeitumgebungen, welche von Softwareentwicklern zum Bau ihrer Applikationen verwendet werden, helfen können, die Entwicklung zu vereinfachen.
Lay summary

Im ersten Track wird unsere Arbeit neue Einsichten über Programmiersprachen für heterogene Systeme generieren. Viele moderne Computer (z.B., Smartphones) sind heutzutage heterogen, das heisst, dass verschiedene Teilsysteme auf verschiedene Weisen programmiert werden müssen, was zu Problemen und potentiellen Fehlerquellen an den Schnittstellen zwischen den Teilen führen kann. Unsere Einsichten werden über die Programmierung von Grafikprozessoren (GPU) hinausgehen und generelle Einsichten für die Interaktion und Integration verschiedener Programmiermodelle beinhalten.

Im zweiten Track werden neue Einsichten über die effiziente und effektive Fehlersuche in modernen Softwaresystemen angestrebt. Mit steigender Komplexität in modernen Systemen sind Fehler immer schwieriger zu finden. Ein Kernproblem ist die oft grosse zeitliche und räumliche Distanz zwischen einer Fehlerquelle und den Symptomen eines Fehlers. Unsere Arbeit wird Einsichten generieren, wie man diese grosse Distanz effizient und effektiv überbrücken und damit die Fehlerbehebung signifikant erleichtern kann.

Direct link to Lay Summary Last update: 13.11.2014

Responsible applicant and co-applicants



Space-Time Views For Back-In-Time Debugging [Technical Report]
Azadmanesh Mohammad Reza, Hauswirth Matthias (2015), Space-Time Views For Back-In-Time Debugging [Technical Report], Faculty of Informatics, University of Lugano, Lugano, Switzerland.
BLAST: Bytecode-Level Analysis on Sliced Traces
Azadmanesh Mohammad Reza, Hauswirth Matthias, BLAST: Bytecode-Level Analysis on Sliced Traces, in Principles and Practices of Programming on The Java Platform (PPPJ'15), Melbourne, FL, USAACM, New York, NY, USA.
CLOP: A multi-stage compiler to seamlessly embed heterogeneous code
Makarov Dmitri, Hauswirth Matthias, CLOP: A multi-stage compiler to seamlessly embed heterogeneous code, in ACM SIGPLAN International Conference on Generative Programming: Concepts and Experiences (GPCE'15), Pittsburgh, PA, USAACM, New York, NY, USA.
Infection Size as a Measure of Bug Severity
Azadmanesh Mohammad Reza, Hauswirth Matthias, Infection Size as a Measure of Bug Severity, in International Workshop on Dynamic Analysis (WODA'15), Pittsburgh, PA, USAACM, New York, NY, USA.
InfectoMeter: A Tool that Helps to Place Bug Fixes [Tool Demo]
Azadmanesh Mohammad Reza, InfectoMeter: A Tool that Helps to Place Bug Fixes [Tool Demo], in International Conference on Program Comprehension (ICPC'16), Austin, Texas, USAIEEE Press, Piscataway, NJ, USA.
SQL for Deep Dynamic Analysis?
Azadmanesh Mohammad Reza, Hauswirth Matthias, SQL for Deep Dynamic Analysis?, in International Workshop on Dynamic Analysis (WODA'15), Pittsburgh, PA, USAACM, New York, NY, USA.
Vestige: A visualization framework for engineering geometry-related software
Schneider Teseo, Zulian Patrick, Azadmanesh Mohammad Reza, Krause Rolf, Hauswirth Matthias, Vestige: A visualization framework for engineering geometry-related software, in Working Conference on Software Visualization (Vissoft'15), Bremen, GermanyIEEE, Piscataway, NY, USA.

Scientific events

Active participation

Title Type of contribution Title of article or contribution Date Place Persons involved
SPLASH'15 Poster Session Poster SQL for Deep Dynamic Analysis? [Poster related to WODA'15 paper] 28.10.2015 Pittsburgh, PA, United States of America Hauswirth Matthias; Azadmanesh Mohammad Reza;


Title Year
Mohammad Reza Azadmanesh has been granted an internship position with Oracle to work on debugging support in their platform. The experience he gained in this SNF project was instrumental in getting that internship position. 2016

Associated projects

Number Title Start Funding scheme
125259 VIA - Vertical Profiling and Optimization of Modern Interactive Applications 01.04.2009 Project funding (Div. I-III)
135245 ParaBoost: Many-core exploitation through virtual-machine-level multi-variant speculation 01.10.2011 Project funding (Div. I-III)


At the beginning of the ParaBoost project we developed an approach to exploit the growing number of cores in modern processors for speeding up hard-to-parallelize computations. We developed a multi-variant virtual machine to allow the concurrent execution of multiple variants of a sequential computation, reducing the overall execution time to the time of the fastest variant. We aimed at extending the state of the art along several dimensions: allow multiple concurrent multi-variant competitions, each with its own set of competing variants; allow nested competitive computations; monitor the progress of variants to favor more promising variants; and learn and exploit a model of variant behavior to improve performance. Before we could implement our approach, two publications appeared that reported achieving these goals. We thus refocused our project on two related but different tracks.The first track moved to different kinds of applications needing a different type of multi-variant computation: computational kernels running on heterogeneous computing platforms including GPUs. Instead of enabling competitive concurrent variants, this track studies how to enable developers to express computational variants and to easily find the most efficient variant up-front. Based on a study of representative heterogeneous applications, and based on the manual optimization of the computational kernels in those applications, we will design a DSL that separates the specification of the computation from the specification of how to efficiently execute that computation. We will start with kernels representing dynamic programming and stencil computations, and with optimizations including tiling with different tile sizes and shapes, unrolling, and prefetching. We will investigate which GPU kernel optimizations are most effective for the applications we study, and how to enable developers to express the corresponding transformations in our high level DSL.The second track repurposed our VM-based multi-variant computation approach to achieve a different goal: use variants of code not for performance, but for correctness purposes, more specifically, for back-in-time debugging. We are developing an approach that allows running applications at almost full speed, and to use a variant of the application, generated from clones of the running application process, for back-in-time debugging in case the original application fails. In developing this on-failure back-in-time debugging approach, we will investigate how and when to clone the application process; when to kill clones to minimize the slowdown of the application; how to capture the interaction of the application with the environment, so that it can be replayed to steer clones towards the failure, and so it does not significantly slow down the application; how to precisely detect a failure in the original application; how to then rewrite the application in the clone to inject the instrumentation necessary for recording the execution history; how to encode the execution history to allow the efficient navigation backwards along the infection chain; and how to effectively present the execution history to the developer.Our two research tracks provide two different perspectives of multi-variant computation. They extend our work from the first phase of the project, and they exploit parallelism for improving both performance and correctness.