Andrea Ribichini

Adapting parallel algorithms to the W-Stream model, with applications to graph problems

In this paper we show how parallel algorithms can be turned into efficient streaming algorithms for several classical combinatorial problems in the W-Stream model. In this model, at each pass one input stream is read, one output stream is written, and data items have to be processed using limited space; streams are pipelined in such a way that the output stream produced at pass i is given as input stream at pass i+1. We first introduce a simulation technique that allows turning efficient PRAM algorithms into optimal W-Stream ones, for many classical combinatorial problems, including list ranking and Euler tour of a tree. For other problems, most notably graph problems, however, this technique leads to suboptimal algorithms. To overcome this difficulty we introduce the RelaxedPRAM (RPRAM) computational model, as an intermediate model between PRAM and W-Stream. RPRAM allows every processor to access a non-constant number of memory cells per parallel round, albeit with some restrictions. The RPRAM model, while being more powerful than the PRAM model, can be simulated in W-Stream within the same asymptotic bounds. The extra power provided by RPRAM allows us in many cases to substantially reduce the number of processors, while maintaining the same number of parallel rounds, leading to more efficient W-Stream simulations of parallel algorithms. Our RPRAM technique gives new insights on developing streaming algorithms and yields efficient algorithms for several classical problems in this model including sorting, connectivity, minimum spanning tree, biconnected components, and maximal independent set. In addition to allowing smooth space-passes tradeoffs, our algorithms are also shown, by proving almost-tight communication complexity-based lower bounds in W-Stream, to be optimal up to polylog factors.

On Resilient Graph Spanners

We introduce and investigate a new notion of resilience in graph spanners. Let S be a spanner of a graph G. Roughly speaking, we say that a spanner S is resilient if all its point-to-point distances are resilient to edge failures. Namely, whenever any edge in G fails, then as a consequence of this failure all distances do not degrade in S substantially more than in G (i.e., the relative distance increases in S are very close to those in the underlying graph G). In this paper we show that sparse resilient spanners exist, and that they can be computed efficiently.

Adapting parallel algorithms to the W-stream model, with applications to graph problems

In this paper we show how parallel algorithms can be turned into efficient streaming algorithms for several classical combinatorial problems in the W-Stream model. In this model, at each pass one input stream is read and one output stream is written; streams are pipelined in such a way that the output stream produced at pass i is given as input stream at pass i + 1. Our techniques give new insights on developing streaming algorithms and yield optimal algorithms (up to polylog factors) for several classical problems in this model including sorting, connectivity, minimum spanning tree, biconnected components, and maximal independent set.

COMPUTING GRAPH SPANNERS IN SMALL MEMORY: FAULT-TOLERANCE AND STREAMING

Let G be an undirected graph with m edges and n vertices. A spanner of G is a subgraph which preserves approximate distances between all pairs of vertices. An f-vertex fault-tolerant spanner is a subgraph which preserves approximate distances, under the failure of any set of at most f vertices. The contribution of this paper is twofold: we present algorithms for computing fault-tolerant spanners, and propose streaming algorithms for computing spanners in very small internal memory. In particular, we give algorithms for computing f-vertex fault-tolerant (3,2)- and (2,1)-spanners of G with the following bounds: our (3,2)-spanner contains O(f4/3n4/3) edges and can be computed in time O(f2m), while our(2, 1)-spanner contains O(fn3/2) edges and can be computed in time

Small stretch spanners in the streaming model: new algorithms and experiments

\tilde{O}(fm)

Computing graph spanners in small memory: fault-tolerance and streaming

. Both algorithms improve significantly on previously known bounds. Assume that the graph G is presented as an input stream of edges, which may appear in any arbitrary order, and that we do not know in advance m and n. We show how ...

Computing the Shapley value in allocation problems: approximations and bounds, with an application to the Italian VQR research assessment program

We present deterministic algorithms for computing small stretch spanners in the streaming model. An (α,β)-spanner of a graph G with n vertices is a subgraph S ⊆ G such that for each pair of vertices the distance in S is at most a times the distance in G plus β. We assume that the graph is given as a stream of edges in arbitrary order, that the number of vertices and the number of edges are not known in advance and that only one pass over the data is allowed. In this model, we show how to compute a (k, k-1)-spanner of an unweighted undirected graph, for k = 2, 3, in O(1) amortized processing time per edge/vertex. The computed (k, k - 1)-spanners have O(n1+1/k) edges and our algorithms use only O(n1+1/k) words of memory space. In case only Θ(n) internal memory is available, our algorithms can be adapted to store some of the data structures in external memory. We complement our theoretical analysis with an experimental study that suggests that our approach can be of practical value.

Reactive Imperative Programming with Dataflow Constraints

Let G be an undirected graph with m edges and n vertices. A spanner of G is a subgraph which preserves approximate distances between all pairs of vertices. An f-vertex fault-tolerant spanner is a subgraph which preserves approximate distances, under the failure of any set of at most f vertices. The contribution of this paper is twofold: we present algorithms for computing fault-tolerant spanners, and propose streaming algorithms for computing spanners in very small internal memory. In particular, we give algorithms for computing f-vertex faulttolerant (3,2)- and (2,1)-spanners of G with the following bounds: our (3,2)-spanner contains O(f4/3n4/3) edges and can be computed in time O (f2m), while our (2,1)-spanner contains O(fn3/2) edges and can be computed in time O (fm). Both algorithms improve significantly on previously known bounds. Assume that the graph G is presented as an input stream of edges, which may appear in any arbitrary order, and that we do not know in advance m and n. We show how to compute efficiently (3,2)- and (2,1)- spanners of G, using only very small internal memory and a slow access external memory device. Our spanners have asymptotically optimal size and the I/O complexity of our algorithms for computing such spanners is optimal up to a polylogarithmic factor. Our f-vertex fault-tolerant (3,2)- and (2,1)-spanners can also be computed efficiently in the same computational model described above.

Reactive imperative programming with dataflow constraints

Abstract In allocation problems with indivisible goods, money compensation is used to distribute worth in a fair way. Coalitional games provide a formal mathematical framework to model such problems, and the Shapley value is a solution concept widely used to realise a fair distribution. To overcome its intractability, we describe how to simplify allocation problems and we propose algorithms for computing lower bounds and upper bounds of the Shapley value that can be combined with approximation algorithms. The proposed techniques have been implemented and tested on a real-world application of allocation problems, namely, the Italian research assessment program known as VQR.

Trading off space for passes in graph streaming problems

Dataflow languages provide natural support for specifying constraints between objects in dynamic applications, where programs need to react efficiently to changes in their environment. In this article, we show that one-way dataflow constraints, largely explored in the context of interactive applications, can be seamlessly integrated in any imperative language and can be used as a general paradigm for writing performance-critical reactive applications that require efficient incremental computations. In our framework, programmers can define ordinary statements of the imperative host language that enforce constraints between objects stored in special memory locations designated as “reactive.” Reactive objects can be of any legal type in the host language, including primitive data types, pointers, arrays, and structures. Statements defining constraints are automatically re-executed every time their input memory locations change, letting a program behave like a spreadsheet where the values of some variables depend on the values of other variables. The constraint-solving mechanism is handled transparently by altering the semantics of elementary operations of the host language for reading and modifying objects. We provide a formal semantics and describe a concrete embodiment of our technique into C/C++, showing how to implement it efficiently in conventional platforms using off-the-shelf compilers. We discuss common coding idioms and relevant applications to reactive scenarios, including incremental computation, observer design pattern, data structure repair, and software visualization. The performance of our implementation is compared to problem-specific change propagation algorithms, as well as to language-centric approaches such as self-adjusting computation and subject/observer communication mechanisms, showing that the proposed approach is efficient in practice.