Showing papers on "Communication complexity published in 1992"

The probabilistic communication complexity of set intersection

Abstract: It is shown that, for inputs of length n, the probabilistic (bounded error) communication complexity of set intersection is $\Theta ( n )$. Since set intersection can be recognized nondeterministic...

Communication complexity of secure computation (extended abstract)

Abstract: A secret-ballot vote for a single proposition is an example of a secure distributed computation. The goal is for m participants to jointly compute the output of some n-ary function (in this case, the sum of the votes), while protecting their individual inputs against some form of misbehavior.In this paper, we initiate the investigation of the communication complexity of unconditionally secure multi-party computation, and its relation with various fault-tolerance models. We present upper and lower bounds on communication, as well as tradeoffs among resources.First, we consider the “direct sum problem” for communications complexity of perfectly secure protocols: Can the communication complexity of securely computing a single function f : Fn → F at k sets of inputs be smaller if all are computed simultaneously than if each is computed individually? We show that the answer depends on the failure model. A factor of O(n/log n) can be gained in the privacy model (where processors are curious but correct); specifically, when f is n-ary addition (mod 2), we show a lower bound of O(n2 log n) for computing f O(n) times simultaneously. No gain is possible in a slightly stronger fault model (fail-stop mode); specifically, when f is n-ary addition over GF(q), we show an exact bound of T(kn2 log q) for computing f at k sets of inputs simultaneously (for any k ≥ 1).However, if one is willing to pay an additive cost in fault tolerance (from t to t-k+1), then a variety of known non-cryptographic protocols (including “provably unparallelizable” protocols from above!) can be systematically compiled to compute one function at k sets of inputs with no increase in communication complexity. Our compilation technique is based on a new compression idea of polynomial-based multi-secret sharing.Lastly, we show how to compile private protocols into error-detecting protocols at a big savings of a factor of O(n3) (up to a log factor) over the best known error-correcting protocols. This is a new notion of fault-tolerant protocols, and is especially useful when malicious behavior is infrequent, since error-detection implies error-correction in this case.

Communication on noisy channels: a coding theorem for computation

Abstract: Communication is critical to distributed computing, parallel computing, or any situation in which automata interact-hence its significance as a resource in computation. In view of the likelihood of errors occurring in a lengthy interaction, it is desirable to incorporate this possibility in the model of communication. The author relates the noisy channel and the standard (noise less channel) complexities of a communication problem by establishing a 'two-way' or interactive analogue of Shanon's coding theorem: every noiseless channel protocol can be simulated by a private-coin noisy channel protocol whose time bound is proportional to the original (noiseless) time bound and inversely proportional to the capacity of the channel, while the protocol errs with vanishing probability. The method involves simulating the original protocol while implementing a hierarchical system of progress checks which ensure that errors of any magnitude in the simulation are, with high probability, rapidly eliminated. >

Fractional covers and communication complexity

Abstract: It is possible to view communication complexity as the solution of an integer programming problem. The authors relax this integer programming problem to a linear programming problem, and try to deduce from it information regarding the original communication complexity question. This approach works well for nondeterministic communication complexity. In this case the authors get a special case of Lovasz's fractional cover measure and use it to completely characterize the amortized nondeterministic communication complexity. In the case of deterministic complexity the situation is more complicated. The authors discuss two attempts, and obtain some results using each of them. >

Compile-time estimation of communication costs on multicomputers

Abstract: An important problem facing numerous research projects on parallelizing compilers for distributed memory machines is that of automatically determining a suitable data partitioning scheme for a program. Any strategy for automatic data partitioning needs a mechanism for estimating the performance of a program under a given partitioning scheme, the most crucial part of which involves determining the communication costs incurred by the program. The authors describe a methodology for statically estimating the communication times as certain functions of the array sizes and the numbers of processors over which various arrays used are distributed. This work also lays down a framework for effective synthesis of communication on multicomputers from sequential program references. >

The slide mechanism with applications in dynamic networks

Abstract: This paper presents a simple and efficient building block, called slide, for constructing communication protocols in dynamic networks whose topology frequently changes. We employ slide to derive (1) an end-to-end communication protocol with optimal amortized message complexity, and (2) a general method to efficiently and systematically combine dynamic and static algorithms. (Dynamic algorithms are designed for dynamic networks, and static algorithms work in networks with stable topology.)The new end-to-end communication protocol has amortized message communication complexity O(n) (assuming that the sender is allowed to gather enough data items before transmitting them to the receiver), where n is the total number of nodes in the network (the previous best bound was (O(m), where m is the total number of links in the network). This protocol also has bit communication complexity O(nD), where D is the data item size in bits (assuming data items are large enough; i.e., for D = Ω(nm log n)). In addition we give, as a byproduct, an end-to-end communication protocol using O(n2m) messages per data item, which is considerably simpler than other protocols known to us (the best known end-to-end protocol has message complexity O(nm)[AG91]). The protocols above combine in an interesting way several ideas: the information dispersal algorithm of Rabin [Rab89], the majority insight of [AFWZ88, AAF+], and the slide protocol.The second application of slide develops a systematic mechanism to combine a dynamic algorithm with a static algorithm for the same problem, such that the combined algorithm automatically adjusts its communication complexity to the network conditions. That is the combined algorithm solves the problem in a dynamic network, and if the network stabilizes for a long enough period of time then the algorithm's communication complexity matches that of the static algorithm. This approach has been first introduced in [AM88] in the context of topology update algorithms.

Efficient communication primitives on hypercubes

Abstract: We give practical algorithms, complexity analysis and implementation for one-to-all broadcasting, all-to-all personalized communication and matrix transpose (with two-dimensional partitioning of the matrix) on hypercubes. We assume the following communication characteristics: circuit-switched, e-cube routing and one-port communication model. For one-to-all broadcasting, we give an algorithm that combines the well-known recursive doubling algorithm[1] and the algorithm based on edgedisjoint spanning trees[2]. The measured times of the combined algorithm are always superior to those of the edge-disjoint spanning tree algorithm and outperform the recursive doubling algorithm. For all-to-all personalized communication we propose a hybrid algorithm that combines the well-known recursive doubling algorithm[3,4] and the recently proposed direct-route algorithm[5,6] Our hybrid algorithm balances between data transfer time and start-up time of these two algorithms, and its communication complexity is estimated to be better than the two previous algorithms for a range of machine parameters. For matrix transpose with two-dimensional partitioning of the matrix, we relate a two-phase algorithm to the previous result in Reference 7. The algorithm is predicted to be better than the recursive transpose algorithm[8] by n nearest-neighbor communications[4]. It takes advantage of circuit-switched routing and is congestion-free within each phase. We also suggest a way of storing the matrix such that the transpose operation can be realized in one phase without congestion.

Information routing and reliability issues in distributed sensor networks

Abstract: Communication issues and problems in information routing in distributed sensor networks (DSNs) are considered. Two important communication constraints, viz., the delay constraint and the reliability constraint, are identified, and their impact on information routing is discussed. It is shown that the maximum end-to-end delay in a network depends on the diameter of the network, and efficient distributed algorithms are presented to determine the diameter of asynchronous networks. A distributed algorithm that determines the diameter of an asynchronous tree network when an arbitrary node in the network initiates the algorithm is introduced. An efficient algorithm for determining the diameter when multiple nodes initiate the algorithm is presented. An algorithm to determine the diameter of arbitrary networks is presented, and its message complexity is shown. Effects of link/node failures on network delay are studied, and important network structure design criterion are discussed. The distributed, dynamic routing algorithms are reviewed, and their adaptation to DSN environments is discussed. >

The distributed k-server problem-a competitive distributed translator for k-server algorithms

Abstract: The authors consider the k-server problem in a distributed setting. Given a network of n processors, and k identical mobile servers, requests for service appear at the processors and a server must reach the request point. Besides modeling problems in computer networks where k identical mobile resources are shared by the processors of the network, this models a realistic situation where the transfer of information is costly and there is no central control that governs the behavior of servers that move around to satisfy requests for service. The problem is that of devising algorithms that minimize not only the travel of the server but also the communication cost incurred for the transmission of control messages. The main contribution is a general translator to transform any deterministic global-control competitive k-server algorithm into a distributed competitive one. As consequences they get poly(k)-competitive distributed algorithms for the line, trees and the ring. >

The Lempel-Ziv algorithm and message complexity

Abstract: Data compression has been suggested as a nonparametric way of discriminating between message sources. Compressions obtained from a Lempel-Ziv algorithm for relatively short messages, such as those encountered in practice, are examined. The intuitive notion of message complexity has less connection with compression than one might expect from known asymptotic results about infinite messages. Nevertheless, discrimination by compression remains an interesting possibility. >

Sparser: A Paradigm for Running Distributed Algorithms

Abstract: This paper introduces a transformer for improving the communication complexity of several classes of distributed algorithms. The transformer takes a distributed algorithm whose message complexity is O(f·m) and produces a new distributed algorithm for the same problem with O(f·n log n + m log n) message complexity, where n and m are the total number of nodes and links in the network, and f is an arbitrary function of n and m.

An (N-1)-resilient algorithm for distributed termination detection

Abstract: The authors propose a fault-tolerant algorithm for termination detection that can tolerate any number of stop failures. This algorithm improves on existing ones in many aspects, including worst-case message complexity, average-case message complexity and storage overhead. Most important, it runs as efficiently as the best non-fault-tolerant algorithm available if no process fails during the computation, and incurs only a reasonable amount of cost for each process failure that actually occurs. The main idea of the algorithm is a barrier set at a particular process. It is possible that other termination detection algorithms can be made fault-tolerant using similar techniques. >

Efficiently computing communication complexity for multilevel logic synthesis

Abstract: A new method for computing the communication complexity of a given partitioning whose running time is O(pq), where p is the number of implicants (cubes) in the minimum covering of the function and q is the number of different overlapping of those cubes, is presented. Two heuristics for finding a good partition which give encouraging results are presented. Together, these two techniques allow a much larger class of functions to be synthesized. Two heuristic partitioning methods have been tested for certain circuits from the MCNC benchmark set. Using either heuristic, 11 out of 14 examples actually achieve the optimal solutions. A prototype program designed using the above techniques was developed and tested for circuits from the MCNC benchmark set. The experiment shows that the new symbolic manipulation technique is several orders of magnitude faster than an old version. >

Determinism vs. nondeterminism in multiparty communication complexity

Abstract: A given Boolean function has its input distributed among many parties. The aim is to determine which parties to talk to and what information to exchange in order to evaluate the function while minimizing the total communication. This paper shows that it is possible to evaluate the Boolean function deterministically with only a polynomial increase in communication and number of parties accessed with respect to the information lower bound given by the nondeterministic communication complexity of the function.

A more efficient message-optimal algorithm for distributed termination detection

Abstract: Termination detection is a fundamental problem in distributed computing. Many algorithms have been proposed, but only the S. Chandrasekaran and S. Venkatesan (CV) algorithm (1990) is known to be optimal in worst-case message complexity. This optimal algorithm, however, has several undesirable properties. First, it always requires M'+2* mod E mod +n-1 control messages, whether it is worst case or best case, where M' is the number of basic messages issued by the underlying computation after the algorithm starts, mod E mod is the number of channels in the system, and n is the number of processes. Second, its worst-case detection delay is O(M'). In a message-intensive computation, that might not be tolerable. Third, the maximum amount of space needed by each process is O(M'), a quantity not known at compile time, making it necessary to use the more expensive dynamic memory allocation. Last, it works only for FIFO channels. This paper remedies these drawbacks, while keeping its strength. The authors propose an algorithm that requires M'+2(n-1) control messages in the worst case, but much fewer on the average, and in the best case, it uses only 2(n-1) control messages, no matter how large M' is. >

Universal architecture for matrix transposition

Abstract: A new real-time architecture for matrix transposition is presented. This architecture exploits the inherent parallelism and pipelining of the transposition operation resulting in an efficient mapping of the operation (algorithm) onto the structure. More importantly, this architecture is a universal implementation of executing matrix transposition because it allows data to flow in and out of the structure in either serial or parallel fashion. This architecture has potentially wide applications in real-time data processing, particularly in the areas of signal processing, FFT computations, multidimensional image processing, robotic-vision, database manipulation etc. A basic cell is defined which represents a matrix element and is capable of handling data K bits in width. For a N*N matrix, N/sup 2/ basic cells are connected in a pipelined fashion along the N rows (N columns) of the matrix with the interconnection between adjacent rows (columns) organised in a serpentine fashion. The architecture has a very small execution time and low communication complexity. The simplicity and regular nature of the structure combined with the local interconnection of the elements makes VLSI implementation of the architecture possible.

Separating Counting Communication Complexity Classes

Abstract: We develope new lower bound arguments on communication complexity and establish a number of separation results for Counting Communication Classes. In particular, it will be shown that for Communieation Complexity MOD p -P and MOD q -P are uncomparable via inclusion for all pairs of distinct primes p, q. Further we prove that the same is true for PP and MOD p -P for any prime number p. Our results are due to mathematical characterization of modular and probabilistic communication complexity by the minimum rank of matrices belonging to certain equivalence classes. We use arguments from algebra and analytic geometry.

Dynamic control and prototyping of parallel algorithms for intermediate- and high-level vision

Abstract: Developing parallel algorithms for intermediate and high levels of computer vision systems is addressed. Because the algorithms are complex and the nature and size of the input and output data sets vary for each application, the authors have directly developed parallel algorithms for dynamic control of both processing and communication complexity during execution. They have also examined the merits of functional prototyping and transforming programs into imperative execution code for final implementation. To evaluate and give direction to their work, they have implemented algorithms for plane detection and object recognition on a flexible transputer network. >

Communication Complexity and Lower Bounds for Sequential Computation

Abstract: Information-theoretic approaches for lower bound problems are discussed and two applications of Communication Complexity are presented.

Performance of distributed sparse Cholesky factorization with pre-scheduling

Abstract: The authors propose a Cholesky factorization scheme based on a static task and communication schedule generated by symbolic preprocessing of the intercolumn dependencies. This information is used to reduce the overheads of maintaining data structures and the communication costs incurred in message passing during the numerical factorization step. The authors introduce three primitives which encapsulate these optimizations and alleviate the user's programming effort. Performance results obtained on the iPSC/860 show that an implementation using these primitives results in 30% to 40% savings over one that does not use any static communication structure information. >

Performance analysis of two address space allocation schemes for an optically interconnected distributed shared memory system

Abstract: An Optically Interconnected Distributed Shared Memory (OIDSM) system is introduced and analyzed. Distributed shared memory systems place a heavy traffic requirement on the interconnection network. Complex memory allocation schemes have been introduced to reduce the network load. The photonic network of the system introduced in this paper alleviates the traffic load concern, and enables the development of a fixed memory allocation scheme with a significant reduction in complexity. The photonic network employs wavelength division multiple access (WDMA), creating multiple channels on a single optical fiber. This paper analyzes the performance of two memory allocation schemes through mean value analysis of a closed queueing network. The performance model is validated through simulation. >

The Bit Probe Complexity Measure Revisited

Abstract: The bit probe complexity of a static data structure problem within a given size bound was defined by Elias and Flower. It is the number of bits one needs to probe in the data structure for worst case data and query with an optimal encoding of the data within the space bound. We make some furtber investigations into the properties of the bit probe complexity measure. We determine the complexity of the full problem, which is the problem where every possible query is allowed, within an additive constant. We show a trade off-between structure size and the number of bit probes for all problems. We show that the complexity of almost every problem, even with small query sets, equals that of the full problem. We show how communication complexity can be used to give small, but occasionally tight lower bounds for natural functions. We define the class of access feasible static structure problems and conjecture that not every polynomial time computable problem is access feasible. We show a link to dynamic problems by showing that if polynomial time computable functions without feasible static structures exist, then there are problems in P which can not be reevaluated efficiently on-line.

A real-time algorithm for fair interprocess synchronization

Abstract: The implementation of nondeterministic pairwise synchronous communication among a set of asynchronous processes is modeled as a binary interaction problem. An algorithm for this problem, which satisfies a strong fairness property that guarantees freedom from process starvation, is described. The message and time complexities are independent of the total number of processes in the system. The ways in which the algorithm may be extended to cope with fail-stop process failures are discussed. >

Distributed sparse matrix factorization: QR and Cholesky decompositions

Abstract: The problem of decomposing a sparse matrix into factors on a distributed memory machine is considered. The factorization involves a symbolic phase in which a sparsity preserving ordering is computed. The symbolic phase is followed by a numeric phase, which has a higher sequential computational complexity. Algorithms are developed to exploit medium- and large-grain parallelism for the numeric computation of factors. The two problems considered are the orthogonal factorization of an overdetermined sparse matrix of full column rank, and the Cholesky decomposition of a sparse symmetric positive definite system. The parallelization of these two factorization schemes requires the efficient solution of the attendant data distribution and task allocation problem. The latter is formulated on an appropriate task graph which is a tree structure for medium- and large-grain parallelism. In the context of distributed orthogonal factorization, a distributed submatrix merge scheme is developed based on a task graph called the merge tree. A task involves merging dense submatrices obtained as a result of predecessor tasks. The large-grain, 'proportional heuristic' assigns subtrees composed of smaller and earlier tasks to a processor for local processing without any communication. Larger and later tasks are assigned to groups of processors for effective load balance at the expense of communication overheads. Experiments were performed on the iPSC/2 for a model grid problem and for systems of linear equations arising from graded L-shaped regions. Analysis for the model problem indicates that the parallel arithmetic complexity is optimal and that the communication complexity is of lower order. A related problem is that of task and data assignment for distributed column-oriented Cholesky factorization. Two column-oriented schemes are considered for distributed computation of the Cholesky factor. The assignment problem is closely related to the classical one-task-to-one-processor, multiprocessor scheduling problem. An extension of list scheduling is developed to incorporate message passing latencies. Worst case performance bounds are derived analytically. A variant of the proportional heuristic is also developed, which has low time and space complexities. Implementations of the numeric factorization phase on the Intel iPSC/2 exhibit good speed-ups.

Communication complexity of secure distributed computation in the presence of noise

Abstract: A simple model of distributed computation that requires information exchange over a noisy channel is considered. A communication protocol is utilized that requires alternate bit exchanges between two processors. First, the case of a single public channel is considered and the number of bits that need to be exchanged between the processors to permit delta -accuracy in their goal is compared. For this computation, an error-detection-and-retransmission mechanism of error control and an error-correction-and-retransmission mixture that are consistent with the logical protocol that governs this exchange are considered. Second, the case of the availability of an additional secret channel is considered and interest in determining the minimum number of bits that need to be exchanged over a secret channel in order to maintain in -uncertainty about the computation for an eavesdropper on the public channel is shown. Various subcases under this case are considered and an upper bound on the number of secret bits when no error-control scheme is used is obtained. >