Matching Lower Bound Research Articles

Finding the size and the diameter of a radio network using short labels

The number of nodes of a network, called its size, and the largest distance between nodes of a network, called its diameter, are among the most important network parameters. Knowing the size and/or diameter (or a good upper bound on those parameters) is a prerequisite of many distributed network algorithms, ranging from broadcasting and gossiping, through leader election, to rendezvous and exploration. A radio network is a collection of stations, called nodes, with wireless transmission and receiving capabilities. It is modeled as a simple connected undirected graph whose nodes communicate in synchronous rounds. In each round, a node can either transmit a message to all its neighbors, or stay silent and listen. At the receiving end, a node v hears a message from a neighbor w in a given round, if v listens in this round, and if w is its only neighbor that transmits in this round. If v listens in a round, and two or more neighbors of v transmit in this round, a collision occurs at v. If v transmits in a round, it does not hear anything in this round. Two scenarios are considered in the literature: if listening nodes can distinguish collision from silence (the latter occurs when no neighbor transmits), we say that the network has the collision detection capability, otherwise there is no collision detection.We consider the tasks of size discovery and diameter discovery: finding the size (resp. the diameter) of an unknown radio network with collision detection. All nodes have to output the size (resp. the diameter) of the network, using a deterministic algorithm. Nodes have labels which are (not necessarily distinct) binary strings. The length of a labeling scheme is the largest length of a label.We concentrate on the following problems: Our main result states that the minimum length of a labeling scheme that permits size discovery is Θ(log⁡log⁡Δ). The upper bound is proven by designing a size discovery algorithm using a labeling scheme of length O(log⁡log⁡Δ), for all networks of maximum degree Δ. The matching lower bound is proven by constructing a class of graphs (in fact even of trees) of maximum degree Δ, for which any size discovery algorithm must use a labeling scheme of length at least Ω(log⁡log⁡Δ) on some graph of this class. By contrast, we show that diameter discovery can be done in all radio networks using a labeling scheme of constant length.

FPGA Realization of the Reconfigurable Mesh Counting Algorithm

Pass transistor logic (PTL) is a circuit design technique wherein transistors are used as switches. The reconfigurable mesh (RM) is a model that exploits the power of PTLs signal switching, by enabling flexible bus connections in a grid of processing elements containing switches. RM algorithms have theoretical results proving that [Formula: see text] can speed up computations significantly. However, the RM assumes that the latency of broadcasting a signal through [Formula: see text] switches (bus length) is 1. This is an unrealistic assumption preventing physical realizations of the RM. We propose the restricted-RM (RRM) wherein the bus lengths are restricted to [Formula: see text], [Formula: see text]. We show that counting the number of 1-bits in an input of [Formula: see text] bits can be done in [Formula: see text] steps for [Formula: see text] by an [Formula: see text] RRM. An almost matching lower bound is presented, using a technique which adds to the few existing lower-bound techniques in this area. Finally, the algorithm was directly coded over an FPGA, outperforming an optimal tree of adders. This work presents an alternative way of counting, which is fundamental for summing, beating regular Boolean circuits for large numbers, where summing a vast amount of numbers is the basis of any accelerator in embedded systems such as neural-nets and streaming. a

On the Value of Job Migration in Online Makespan Minimization

Makespan minimization on identical parallel machines is a classical scheduling problem. We consider the online scenario where a sequence of n jobs has to be scheduled non-preemptively on m machines so as to minimize the maximum completion time of any job. The best competitive ratio that can be achieved by deterministic online algorithms is in the range [1.88, 1.9201]. Currently no randomized online algorithm with a smaller competitiveness is known, for general m. In this paper we explore the power of job migration, i.e. an online scheduler is allowed to perform a limited number of job reassignments. Migration is a common technique used in theory and practice to balance load in parallel processing environments. As our main result we settle the performance that can be achieved by deterministic online algorithms. We develop an algorithm that is $$\alpha _m$$źm-competitive, for any $$m\ge 2$$mź2, where $$\alpha _m$$źm is the solution of a certain equation. For $$m=2$$m=2, $$\alpha _2 = 4/3$$ź2=4/3 and $$\lim _{m\rightarrow \infty } \alpha _m = W_{-1}(-1/e^2)/(1+ W_{-1}(-1/e^2)) \approx 1.4659$$limmźźźm=W-1(-1/e2)/(1+W-1(-1/e2))ź1.4659. Here $$W_{-1}$$W-1 is the lower branch of the Lambert W function. For $$m\ge 11$$mź11, the algorithm uses at most 7m migration operations. For smaller m, 8m to 10m operations may be performed. We complement this result by a matching lower bound: No online algorithm that uses o(n) job migrations can achieve a competitive ratio smaller than $$\alpha _m$$źm. We finally trade performance for migrations. We give a family of algorithms that is c-competitive, for any $$5/3\le c \le 2$$5/3≤c≤2. For $$c= 5/3$$c=5/3, the strategy uses at most 4m job migrations. For $$c=1.75$$c=1.75, at most 2.5m migrations are used.

Percolation with Small Clusters on Random Graphs

Consider the problem of determining the maximal induced subgraph in a random d-regular graph such that its components remain bounded as the size of the graph becomes arbitrarily large. We show, for asymptotically large d, that any such induced subgraph has size density at most $$2(\log d)/d$$ with high probability. A matching lower bound is known for independent sets. We also prove the analogous result for sparse Erdős–Rényi graphs.

Geometric Approach for Optimal Routing on a Mesh with Buses

The architecture of “mesh of buses” is an important model in parallel computing. Its main advantage is that the additional broadcast capability can be used to overcome the main disadvantage of the mesh, namely its relatively large diameter. We show that the addition of buses indeed accelerates routing times. Furthermore, unlike in the “store and forward” model, the routing time becomes proportional to the network load, resulting in decreasing in routing time for a smaller number of packets. We consider 1–1 routing ofmpackets in ad-dimensional mesh withndprocessors andd·nd−1buses (one per row and column). The two standard models of accessing the buses are considered and compared: CREW, in which only one processor may transmit at any given time on a given bus, and the CRCW model, in which several processors may attempt to transmit at the same time (getting a noise signal as a result). We design a routing algorithm that routesmpackets in the CREW model inO(m1/d+n1/(d+1)) steps. This result holds form⩽n2d/3ford⩾3 and unconditionally ford=2. A matching lower bound is also proved. In the CRCW case we show an algorithm ofO(m1/dlogn) and a lower bound ofΩ(m1/d). It is shown that the difference between the models is essentially due to the improved capability of estimating threshold functions in the CRCW case.

Better computing on the anonymous ring

We consider a bidirectional ring of n processors, where processors are anonymous, i.e., are indistinguishable. In this model it is known that “most” functions (in particular XOR and orientation) have worst case message complexity Θ( n 2) for asynchronous computations, and Θ( n log n) for synchronous computations. The average case behavior is different; an algorithm that computes XOR asynchronously with O(n n messages on the average is known. In this paper we give tight bounds on the average complexity of various problems. We show the following: • •An asynchronous deterministic algorithm that computes any computable function with O( n log n) messages, on the average (improving the O(n n algorithm). A matching lower bound is proven for functions such as XOR and orientation. • •An asynchronous probabilistic algorithm that computes any computable function with O( n log n) expected messages on any input, using one random bit per processor. A matching lower bound is proven. • •A Monte-Carlo asynchronous algorithm that computes any computable function with O( n) expected messages on any input, using one random bit per processor, with fixed error probability ε > 0. • •A synchronous algorithm that computes any computable function optimally in O( n) messages, on the average. • •A synchronous probabilistic algorithm that computes any computable function optimally in O( n) expected messages on any input, using one random bit per processor • •Lower bounds on the complexity of Monte-Carlo algorithms that always terminate.

Transaction commit in a realistic timing model

Animportant problem in the construction of fault-tolerant distributed database systems is the design of nonblocking transaction commit protocols. This problem has been extensively studied for synchronous systems (i.e., systems where no messages ever arrive late). In this paper, the synchrony assumption is relaxed. A new partially synchronous timing model is described. Developed for this model is a new nonblocking randomized transaction commit protocol, which incorporates an agreement protocol of Ben-Or. The new protocol works as long as fewer than half the processors fail. A matching lower bound is proved, showing that the number of processor faults tolerated is optimal. If half or more of the processors fail, the protocol degrades gracefully: it blocks, but no processor produces a wrong answer. A notion of asynchronous round is defined, and the protocol is shown to terminate in a small constant expected number of asynchronous rounds. In contrast it is shown that no protocol in this model can guarantee that a processor terminates in a bounded expected number of its own steps, even if processors are synchronous.

Simple constant-time consensus protocols in realistic failure models

Using simple protocols, it is shown how to achieve consensus in constant expected time, within a variety of fail-stop and omission failure models. Significantly, the strongest models considered are completely asynchronous. All of the results are based on distributively flipping a coin, which is usable by a significant majority of the processors. Finally, a nearly matching lower bound is also given for randomized protocols for consensus.