15 research outputs found
On reducing the complexity of matrix clocks
Matrix clocks are a generalization of the notion of vector clocks that allows
the local representation of causal precedence to reach into an asynchronous
distributed computation's past with depth , where is an integer.
Maintaining matrix clocks correctly in a system of nodes requires that
everymessage be accompanied by numbers, which reflects an exponential
dependency of the complexity of matrix clocks upon the desired depth . We
introduce a novel type of matrix clock, one that requires only numbers to
be attached to each message while maintaining what for many applications may be
the most significant portion of the information that the original matrix clock
carries. In order to illustrate the new clock's applicability, we demonstrate
its use in the monitoring of certain resource-sharing computations
Optimal Collision/Conflict-free Distance-2 Coloring in Synchronous Broadcast/Receive Tree Networks
This article is on message-passing systems where communication is (a)
synchronous and (b) based on the "broadcast/receive" pair of communication
operations. "Synchronous" means that time is discrete and appears as a sequence
of time slots (or rounds) such that each message is received in the very same
round in which it is sent. "Broadcast/receive" means that during a round a
process can either broadcast a message to its neighbors or receive a message
from one of them. In such a communication model, no two neighbors of the same
process, nor a process and any of its neighbors, must be allowed to broadcast
during the same time slot (thereby preventing message collisions in the first
case, and message conflicts in the second case). From a graph theory point of
view, the allocation of slots to processes is know as the distance-2 coloring
problem: a color must be associated with each process (defining the time slots
in which it will be allowed to broadcast) in such a way that any two processes
at distance at most 2 obtain different colors, while the total number of colors
is "as small as possible". The paper presents a parallel message-passing
distance-2 coloring algorithm suited to trees, whose roots are dynamically
defined. This algorithm, which is itself collision-free and conflict-free, uses
colors where is the maximal degree of the graph (hence
the algorithm is color-optimal). It does not require all processes to have
different initial identities, and its time complexity is , where d
is the depth of the tree. As far as we know, this is the first distributed
distance-2 coloring algorithm designed for the broadcast/receive round-based
communication model, which owns all the previous properties.Comment: 19 pages including one appendix. One Figur
Theory of systems of asynchronous parallel processors
Issued as Progress report and Final report, Project no. G-36-63
On the Probe Complexity of Local Computation Algorithms
In the Local Computation Algorithms (LCA) model, the algorithm is asked to compute a part of the output by reading as little as possible from the input. For example, an LCA for coloring a graph is given a vertex name (as a "query"), and it should output the color assigned to that vertex after inquiring about some part of the graph topology using "probes"; all outputs must be consistent with the same coloring. LCAs are useful when the input is huge, and the output as a whole is not needed simultaneously. Most previous work on LCAs was limited to bounded-degree graphs, which seems inevitable because probes are of the form "what vertex is at the other end of edge i of vertex v?". In this work we study LCAs for unbounded-degree graphs. In particular, such LCAs are expected to probe the graph a number of times that is significantly smaller than the maximum, average, or even minimum degree. We show that there are problems that have very efficient LCAs on any graph - specifically, we show that there is an LCA for the weak coloring problem (where a coloring is legal if every vertex has a neighbor with a different color) that uses log^* n+O(1) probes to reply to any query. As another way of dealing with large degrees, we propose a more powerful type of probe which we call a strong probe: given a vertex name, it returns a list of its neighbors. Lower bounds for strong probes are stronger than ones in the edge probe model (which we call weak probes). Our main result in this model is that roughly Omega(sqrt{n}) strong probes are required to compute a maximal matching.
Our findings include interesting separations between closely related problems. For weak probes, we show that while weak 3-coloring can be done with probe complexity log^* n+O(1), weak 2-coloring has probe complexity Omega(log n/log log n). For strong probes, our negative result for maximal matching is complemented by an LCA for (1-epsilon)-approximate maximum matching on regular graphs that uses O(1) strong probes, for any constant epsilon>0
Self-stabilizing protocol for anonymous oriented bi-directional rings under unfair distributed schedulers with a leader
We propose a self-stabilizing protocol for anonymous oriented bi-directional rings of any size under unfair distributed schedulers with a leader. The protocol is a randomized self-stabilizing, meaning that starting from an arbitrary configuration it converges (with probability 1) in finite time to a legitimate configuration (i.e. global system state) without the need for explicit exception handler of backward recovery. A fault may throw the system into an illegitimate configuration, but the system will autonomously resume a legitimate configuration, by regarding the current illegitimate configuration as an initial configuration, if the fault is transient. A self-stabilizing system thus tolerates any kind and any finite number of transient faults. The protocol can be used to implement an unfair distributed mutual exclusion in any ring topology network; Keywords: self-stabilizing protocol, anonymous oriented bi-directional ring, unfair distributed schedulers. Ring topology network, non-uniform and anonymous network, self-stabilization, fault tolerance, legitimate configuration
Analytical Results on the Performance of Shared Resource Allocation Systems
Resource allocation is a prevalent problem in a wide range of domains of computer science. Analytical tools that evaluate the performance of resource allocation systems allow us to compare with experimental ones, and utilize the design of such systems.We consider shared-object systems that require their threads to fulfill the system jobs by first acquiring sequentially the objects needed for the jobs and then holding on to them until the job completion. Such systems are in the core of a variety of shared-resource allocation and synchronization systems. We provide methods for estimating the performance of such systems in terms of expected task throughput and delay for completion. To the best of our knowledge, this is a new perspective that can provide better analytical tools for the problem, in order to estimate performance measures similar to ones that can be acquired through experimentation on working systems and simulations.We also study the problem of maximizing the energy utilization in the Smart Grid, where the energy supply becomes available in an online fashion (due to unpredictable energy sources) and the energy demand can have some flexibility (energy dispatch problem). Utilizing a proposed modeling of the energy dispatch problem as an online scheduling problem, we model supply-following demand in terms of the Adwords problem, in order to provide algorithmic solutions of measurable quality. In systems where demands are small compared to the individual supply, we prove a (1-1/e)-competitive ratio. For cases where this does not hold, we extend the Adwords problem to utilize dynamic budgets, and present an algorithm with a 1/2-competitive ratio
Shared-object System Equilibria: Delay and Throughput Analysis
We consider shared-object systems that require their threads to fulfill the
system jobs by first acquiring sequentially the objects needed for the jobs and
then holding on to them until the job completion. Such systems are in the core
of a variety of shared-resource allocation and synchronization systems. This
work opens a new perspective to study the expected job delay and throughput
analytically, given the possible set of jobs that may join the system
dynamically.
We identify the system dependencies that cause contention among the threads
as they try to acquire the job objects. We use these observations to define the
shared-object system equilibria. We note that the system is in equilibrium
whenever the rate in which jobs arrive at the system matches the job completion
rate. These equilibria consider not only the job delay but also the job
throughput, as well as the time in which each thread blocks other threads in
order to complete its job. We then further study in detail the thread work
cycles and, by using a graph representation of the problem, we are able to
propose procedures for finding and estimating equilibria, i.e., discovering the
job delay and throughput, as well as the blocking time.
To the best of our knowledge, this is a new perspective, that can provide
better analytical tools for the problem, in order to estimate performance
measures similar to ones that can be acquired through experimentation on
working systems and simulations, e.g., as job delay and throughput in
(distributed) shared-object systems