Irene Finocchi

Reversible Execution and Visualization of Programs with LEONARDO

In this paper we present LEONARDO, an integrated environment for software visualization that allows the user to edit, compile, execute, and animate general-purpose C programs. LEONARDO relies on a logic-based approach to visualization: a mapping between concrete and abstract data structures can be declared through a logic visualization language and animations are conceived as reflecting formal properties of algorithms. LEONARDO is able to automatically detect visual events during the execution of programs and simplifies the creation of visualizations according to an incremental approach. Moreover, it guarantees the complete reversibility of computations, bounded only by the potentiality of the working machine, and appears simple to be used. The latest version of LEONARDO is currently available over the Internet at the URLhttp: //www.dis.uniroma1.it/~demetres/Leonardo/.

Experimental analysis of simple, distributed vertex coloring algorithms

Abstract We perform an extensive experimental evaluation of very simple, distributed, randomized algorithms for (Δ + 1) and so-called Brooks–Vizing vertex colorings, i.e., colorings using considerably fewer than Δ colors (here Δ denotes the maximum degree of the graph). We consider variants of algorithms known from the literature, boosting them with a distributed independent set computation. Our study clearly determines the relative performance of the algorithms with respect to the number of communication rounds and the number of colors. The results are confirmed by all the experiments and instance families. The empirical evidence shows that some algorithms use very few rounds and are rather effective, thus being amenable to be used in practice.

Input-sensitive profiling

In this article we present a building block technique and a toolkit towards automatic discovery of workload-dependentperformance bottlenecks. From one or more runs of a program, our profiler automatically measures how the performance of individual routines scales as a function of the input size, yielding clues to their growth rate. The output of the profiler is, for each executed routine of the program, a set of tuples that aggregate performance costs by input size. The collected profiles can be used to produceperformance plots and derive trend functions by statistical curve fitting techniques. A key feature of our method is the ability toautomatically measure the size of the input given to a generic code fragment: to this aim, we propose an effective metric for estimating the input size of a routine and show how to compute it efficiently. We discuss several examples, showing that our approach can reveal asymptotic bottlenecks that other profilers may fail to detect and can provide useful characterizations of the workload and behavior of individual routines in the context of mainstream applications, yielding several code optimizations as well as algorithmic improvements. To prove the feasibility of our techniques, we implemented a Valgrind tool called aprof and performed an extensive experimentalevaluation on the SPEC CPU2006 benchmarks. Our experiments show that aprof delivers comparable performance to otherprominent Valgrind tools, and can generate informative plots even from single runs on typical workloads for mostalgorithmically-critical routines.

Resilient search trees

We investigate the problem of computing in a reliable fashion in the presence of faults that may arbitrarily corrupt memory locations. In this framework, we focus on the design of resilient data structures, i.e., data structures that, despite the corruption of some memory values during their lifetime, are nevertheless able to operate correctly (at least) on the set of uncorrupted values. In particular, we present resilient search trees which achieve optimal time and space bounds while tolerating up to <i>O</i>(√log <i>n</i>) memory faults, where <i>n</i> is the current number of items in the search tree. In more detail, our resilient search trees are able to insert, delete and search for a key in <i>O</i>(log <i>n</i> + <i>Δ</i>²) amortized time, where Δ is an upper bound on the total number of faults. The space required is <i>O</i>(<i>n</i> + <i>Δ</i>).

Resilient dictionaries

We address the problem of designing data structures in the presence of faults that may arbitrarily corrupt memory locations. More precisely, we assume that an adaptive adversary can arbitrarily overwrite the content of up to Δ memory locations, that corrupted locations cannot be detected, and that only O(1) memory locations are safe. In this framework, we call a data structure resilient if it is able to operate correctly (at least) on the set of uncorrupted values. We present a resilient dictionary, implementing search, insert, and delete operations. Our dictionary has O(log n + Δ) expected amortized time per operation, and O(n) space complexity, where n denotes the current number of keys in the dictionary. We also describe a deterministic resilient dictionary, with the same amortized cost per operation over a sequence of at least Δ&epsis; operations, where &epsis; > 0 is an arbitrary constant. Finally, we show that any resilient comparison-based dictionary must take Ω(log n + Δ) expected time per search. Our results are achieved by means of simple, new techniques which might be of independent interest for the design of other resilient algorithms.

Sorting and searching in the presence of memory faults (without redundancy)

We investigate the design of algorithms resilient to memory faults, i. e., algorithms that, despite the corruption of some memory values during their execution, are able to produce a correct output on the set of uncorrupted values. In this framework, we consider two fundamental problems: sorting and searching. In particular, we prove that any O(nlog n) comparison-based sorting algorithm can tolerate at most O((nlog n)1/2) memory faults. Furthermore, we present one comparison-based sorting algorithm with optimal space and running time that is resilient to O((nlog n)1/3) faults. We also prove polylogarithmic lower and upper bounds on fault-tolerant searching.

Sorting and Searching in Faulty Memories

Abstract In this paper we investigate the design and analysis of algorithms resilient to memory faults. We focus on algorithms that, despite the corruption of some memory values during their execution, are nevertheless able to produce a correct output at least on the set of uncorrupted values. In this framework, we consider two fundamental problems: sorting and searching. In particular, we prove that any O(nlog n) comparison-based sorting algorithm can tolerate the corruption of at most O((nlog n)1/2) keys. Furthermore, we present one comparison-based sorting algorithm with optimal space and running time that is resilient to O((nlog n)1/3) memory faults. We also prove polylogarithmic lower and upper bounds on resilient searching.

Specifying Algorithm Visualizations: Interesting Events or State Mapping?

Perhaps the most popular approach to animating algorithms consists of identifying interesting events in the implementation code, corresponding to relevant actions in the underlying algorithm, and turning them into graphical events by inserting calls to suitable visualization routines. Another natural approach conceives algorithm animation as a graphical interpretation of the state of the computation of a program, letting graphical objects in a visualization depend on a programs variables. In this paper we provide the first direct comparison of these two approaches, identifying scenarios where one might be preferable to the other. The discussion is based on examples realized with the systems Polka and Leonardo.

The price of resiliency: a case study on sorting with memory faults

We address the problem of sorting in the presence of faults that may arbitrarily corrupt memory locations, and investigate the impact of memory faults both on the correctness and on the running times of mergesort-based algorithms. To achieve this goal, we develop a software testbed that simulates different fault injection strategies, and we perform a thorough experimental study using a combination of several fault parameters. Our experiments give evidence that simpleminded approaches to this problem are largely impractical, while the design of more sophisticated resilient algorithms seems really worth the effort. Another contribution of our computational study is a carefully engineered implementation of a resilient sorting algorithm, which appears robust to different memory fault patterns.

Breaking cycles for minimizing crossings

We consider the one-sided crossing minimization problem (CP):given a bipartite graph G and a permutationx0 of the vertices on a layer, find a perumuationx1 of the vertices on the other layer whichminimizes the number of edge crossings in any straightline drawingof G where vertices are placed on two parallel lines andsorted according to x0 and x1.Solving CP represents a fundamental step in the construction ofaesthetically pleasing layouts of heirarchies and directed graphs,but unfortunately this problem has been proved to beNP-complete. In this paper we address the strong relation between CP and theproblem of computing minimum feedback arc sets in directed graphsand we devise a enw approximation algorithm for CP, called PM, thatexploits this dependency. We experimantally and visually comparethe performance of PM with the performance of well-known algorithmsand of recent attractive strategies. Experiments are carried out ondifferent families of randomly generated graphs, on pathologicalinstances, and on real test sets. Performance indicators includeboth number of edge crossings and running time, as well asstructural measures of the problem instances. We found CP to be avery interesting and rich problem from a combinatorial point ofview. Our results clearly separate the behavior of the algorithms,proving the effectiveness of PM on most test sets and showingtradeoffs between quality of the solutions and running time.However, if the visual complexity of the drawings is considered, wefound no clear winner. This confirms the importance of optimizingalso other aesthetic criteria such as symmetry, edge length, andangular resolution.