488 research outputs found
Fully Dynamic All-pairs Shortest Paths with Worst-case Update-time revisited
We revisit the classic problem of dynamically maintaining shortest paths between all pairs of nodes of a directed weighted graph. The allowed updates are insertions and deletions of nodes and their incident edges. We give worst-case guarantees on the time needed to process a single update (in contrast to related results, the update time is not amortized over a sequence of updates). Our main result is a simple randomized algorithm that for any parameter has a worst-case update time of and answers distance queries correctly with probability , against an adaptive online adversary if the graph contains no negative cycle. The best deterministic algorithm is by Thorup [STOC 2005] with a worst-case update time of and assumes non-negative weights. This is the first improvement for this problem for more than a decade. Conceptually, our algorithm shows that randomization along with a more direct approach can provide better bounds
Vertex Fault Tolerant Additive Spanners
A {\em fault-tolerant} structure for a network is required to continue
functioning following the failure of some of the network's edges or vertices.
In this paper, we address the problem of designing a {\em fault-tolerant}
additive spanner, namely, a subgraph of the network such that
subsequent to the failure of a single vertex, the surviving part of still
contains an \emph{additive} spanner for (the surviving part of) , satisfying
for every
. Recently, the problem of constructing fault-tolerant additive
spanners resilient to the failure of up to \emph{edges} has been considered
by Braunschvig et. al. The problem of handling \emph{vertex} failures was left
open therein. In this paper we develop new techniques for constructing additive
FT-spanners overcoming the failure of a single vertex in the graph. Our first
result is an FT-spanner with additive stretch and
edges. Our second result is an FT-spanner with additive stretch and
edges. The construction algorithm consists of two main
components: (a) constructing an FT-clustering graph and (b) applying a modified
path-buying procedure suitably adopted to failure prone settings. Finally, we
also describe two constructions for {\em fault-tolerant multi-source additive
spanners}, aiming to guarantee a bounded additive stretch following a vertex
failure, for every pair of vertices in for a given subset of
sources . The additive stretch bounds of our constructions are 4
and 8 (using a different number of edges)
Sparse Fault-Tolerant BFS Trees
This paper addresses the problem of designing a sparse {\em fault-tolerant}
BFS tree, or {\em FT-BFS tree} for short, namely, a sparse subgraph of the
given network such that subsequent to the failure of a single edge or
vertex, the surviving part of still contains a BFS spanning tree for
(the surviving part of) . Our main results are as follows. We present an
algorithm that for every -vertex graph and source node constructs a
(single edge failure) FT-BFS tree rooted at with O(n \cdot
\min\{\Depth(s), \sqrt{n}\}) edges, where \Depth(s) is the depth of the BFS
tree rooted at . This result is complemented by a matching lower bound,
showing that there exist -vertex graphs with a source node for which any
edge (or vertex) FT-BFS tree rooted at has edges. We then
consider {\em fault-tolerant multi-source BFS trees}, or {\em FT-MBFS trees}
for short, aiming to provide (following a failure) a BFS tree rooted at each
source for some subset of sources . Again, tight bounds
are provided, showing that there exists a poly-time algorithm that for every
-vertex graph and source set of size constructs a
(single failure) FT-MBFS tree from each source , with
edges, and on the other hand there exist
-vertex graphs with source sets of cardinality , on
which any FT-MBFS tree from has edges.
Finally, we propose an approximation algorithm for constructing
FT-BFS and FT-MBFS structures. The latter is complemented by a hardness result
stating that there exists no approximation algorithm for these
problems under standard complexity assumptions
Path-Fault-Tolerant Approximate Shortest-Path Trees
Let be an -nodes non-negatively real-weighted undirected graph.
In this paper we show how to enrich a {\em single-source shortest-path tree}
(SPT) of with a \emph{sparse} set of \emph{auxiliary} edges selected from
, in order to create a structure which tolerates effectively a \emph{path
failure} in the SPT. This consists of a simultaneous fault of a set of at
most adjacent edges along a shortest path emanating from the source, and it
is recognized as one of the most frequent disruption in an SPT. We show that,
for any integer parameter , it is possible to provide a very sparse
(i.e., of size ) auxiliary structure that carefully
approximates (i.e., within a stretch factor of ) the true
shortest paths from the source during the lifetime of the failure. Moreover, we
show that our construction can be further refined to get a stretch factor of
and a size of for the special case , and that it can be
converted into a very efficient \emph{approximate-distance sensitivity oracle},
that allows to quickly (even in optimal time, if ) reconstruct the
shortest paths (w.r.t. our structure) from the source after a path failure,
thus permitting to perform promptly the needed rerouting operations. Our
structure compares favorably with previous known solutions, as we discuss in
the paper, and moreover it is also very effective in practice, as we assess
through a large set of experiments.Comment: 21 pages, 3 figures, SIROCCO 201
Fault-Tolerant Hotelling Games
The -player Hotelling game calls for each player to choose a point on the
line segment, so as to maximize the size of his Voronoi cell. This paper
studies fault-tolerant versions of the Hotelling game. Two fault models are
studied: line faults and player faults. The first model assumes that the
environment is prone to failure: with some probability, a disconnection occurs
at a random point on the line, splitting it into two separate segments and
modifying each player's Voronoi cell accordingly. A complete characterization
of the Nash equilibria of this variant is provided for every . Additionally,
a one to one correspondence is shown between equilibria of this variant and of
the Hotelling game with no faults. The second fault model assumes the players
are prone to failure: each player is removed from the game with i.i.d.
probability, changing the payoffs of the remaining players accordingly. It is
shown that for this variant of the game has no Nash equilibria
Matroid and Knapsack Center Problems
In the classic -center problem, we are given a metric graph, and the
objective is to open nodes as centers such that the maximum distance from
any vertex to its closest center is minimized. In this paper, we consider two
important generalizations of -center, the matroid center problem and the
knapsack center problem. Both problems are motivated by recent content
distribution network applications. Our contributions can be summarized as
follows:
1. We consider the matroid center problem in which the centers are required
to form an independent set of a given matroid. We show this problem is NP-hard
even on a line. We present a 3-approximation algorithm for the problem on
general metrics. We also consider the outlier version of the problem where a
given number of vertices can be excluded as the outliers from the solution. We
present a 7-approximation for the outlier version.
2. We consider the (multi-)knapsack center problem in which the centers are
required to satisfy one (or more) knapsack constraint(s). It is known that the
knapsack center problem with a single knapsack constraint admits a
3-approximation. However, when there are at least two knapsack constraints, we
show this problem is not approximable at all. To complement the hardness
result, we present a polynomial time algorithm that gives a 3-approximate
solution such that one knapsack constraint is satisfied and the others may be
violated by at most a factor of . We also obtain a 3-approximation
for the outlier version that may violate the knapsack constraint by
.Comment: A preliminary version of this paper is accepted to IPCO 201
Mapping the Sensitive Volume of an Ion-Counting Nanodosimeter
We present two methods of independently mapping the dimensions of the
sensitive volume in an ion-counting nanodosimeter. The first method is based on
a calculational approach simulating the extraction of ions from the sensitive
volume, and the second method on probing the sensitive volume with 250 MeV
protons. Sensitive-volume maps obtained with both methods are compared and
systematic errors inherent in both methods are quantified.Comment: 27 pages, 8 figures. Submitted to JINST, Jan. 16 200
THGEM operation in Ne and Ne/CH4
The operation of Thick Gaseous Electron Multipliers (THGEM) in Ne and Ne/CH4
mixtures, features high multiplication factors at relatively low operation
potentials, in both single- and double-THGEM configurations. We present some
systematic data measured with UV-photons and soft x-rays, in various Ne
mixtures. It includes gain dependence on hole diameter and gas purity,
photoelectron extraction efficiency from CsI photocathodes into the gas,
long-term gain stability and pulse rise-time. Position resolution of a 100x100
mm^2 X-rays imaging detector is presented. Possible applications are discussed.Comment: Submitted to JINST, 25 pages, 33 figure
Accelerated test execution using GPUs
As product life-cycles become shorter and the scale and complexity of systems increase, accelerating the execution of large test suites gains importance. Existing research has primarily focussed on techniques that reduce the size of the test suite. By contrast, we propose a technique that accelerates test execution, allowing test suites to run in a fraction of the original time, by parallel execution with a Graphics Processing Unit (GPU).
Program testing, which is in essence execution of the same program with multiple sets of test data, naturally exhibits the kind of data parallelism that can be exploited with GPUs. Our approach simultaneously executes the program with one test case per GPU thread. GPUs have severe limitations, and we discuss these in the context of our approach and define the scope of our applications. We observe speed-ups up to a factor of 27 compared to single-core execution on conventional CPUs with embedded systems benchmark programs
- âŠ