No abstract available.

No abstract available.

The paper presents a technique to allow quick evaluation of the relevance of documents to one's interests. It is designed primarily for presenting documents on the World Wide Web, but it can also be used in other situations. The idea is to automatically highlight selected keywords in Web pages as they are shown. Users maintain lists of keywords of interest to them. At any given time, a user can activate any such list and from then on all words in that list will be highlighted automatically, transparently, and efficiently in all documents. Users can change lists at any time and also control several other highlighting parameters (such as the number of selected words). Extensions of this scheme, where documents are automatically changed in other ways based on readers' preferences, are also discussed.

A new text compression scheme is presented in this article. The main purpose of this scheme is to speed up string matching by searching the compressed file directly. The scheme requires no modification of the string-matching algorithm, which is used as a black box; any string-matching procedure can be used. Instead, the pattern is modified; only the outcome of the matching of the modified pattern against the compressed file is decompressed. Since the compressed file is smaller than the original file, the search is faster both in terms of I/O time and precessing time than a search in the original file. For typical text files, we achieve about 30% reduction of space and slightly less of search time. A 30% space saving is not competitive with good text compression schemes, and thus should not be used where space is the predominant concern. The intended applications of this scheme are files that are searched often, such as catalogs, bibliographic files, and address books. Such files are typically not compressed, but with this scheme they can remain compressed indefinitely, saving space while allowing faster search at the same time. A particular application to an information retrieval system that we developed is also discussed.

The web is changing the world of computing.This is no longer a prediction; it's a fact.The need for sophisticated techniques to handle data, be it text, images, numbers, video, sound, molecular sequences, or whatever, will grow more rapidly than ever before.

A new and conceptually simple data structure, called a suffix array, for on-line string searches is introduced in this paper. Constructing and querying suffix arrays is reduced to a sort and search paradigm that employs novel algorithms. The main advantage of suffix arrays over suffix trees is that, in practice, they use three to five times less space. From a complexity standpoint, suffix arrays permit on-line string searches of the type, “Is W a substring of A?” to be answered in time $O(P + \log N)$, where P is the length of W and N is the length of A, which is competitive with (and in some cases slightly better than) suffix trees. The only drawback is that in those instances where the underlying alphabet is finite and small, suffix trees can be constructed in $O(N)$ time in the worst case, versus $O(N\log N)$ time for suffix arrays. However, an augmented algorithm is given that, regardless of the alphabet size, constructs suffix arrays in $O(N)$expected time, albeit with lesser space efficiency. It is believed that suffix arrays will prove to be better in practice than suffix trees for many applications.

The round-robin (RR) protocol, which uses statically assigned arbitration numbers to resolve conflict during an arbitration, is more robust and simpler to implement than previous distributed RR protocols that are based on rotating-aging priorities. The proposed first-come-first-served (FCFS) protocol uses partly static arbitration numbers, and is the first practical proposal for a FCFS arbiter known the authors. The proposed protocols have a better combination of efficiency, cost, and fairness characteristics than existing multiprocessor bus arbitration algorithms. Three implementations of the RR protocol, and two implementations of the FCFS protocol, are discussed. Simulation results are presented that address: (1) the practical potential for unfairness in the simpler implementation of the FCFS protocol: (2) the practical implications of the higher waiting-time variance in the RR protocol; and (3) the allocation of bus bandwidth among agents with unequal request rate in each protocol. The simulation results indicate that there is very little practical difference in the performance of the two protocols.>

Abstract An algorithm for improving storage utilization for nonadaptive routing tables in point‐to‐point networks is presented. It allows storage vs. access time tradeoffs. The algorithm is quite general, and it can be used for other applications to improve storage in tree‐like structures. The algorithm was applied to the UUCP routing tables resulting in a threefold storage improvement.

We consider the problem of selecting the kth largest of n inputs, where initially the inputs are stored in the n leaf processors of the 2n − 1 processor tree machine. A probabilistic algorithm is presented that implements a type of pipelining to solve the problem in a simple data driven fashion, with each processor maintaining just a constant amount of state information. On any problem instance, the algorithm's running time is2n]/[loglog n], for some constant c > 0, with overwhelming probability.

DIB is a general-purpose package that allows a wide range of applications such as recursive backtrack, branch and bound, and alpha-beta search to be implemented on a multicomputer. It is very easy to use. The application program needs to specify only the root of the recursion tree, the computation to be performed at each node, and how to generate children at each node. In addition, the application program may optionally specify how to synthesize values of tree nodes from their children's values and how to disseminate information (such as bounds) either globally or locally in the tree. DIB uses a distributed algorithm, transparent to the application programmer, that divides the problem into subproblems and dynamically allocates them to any number of (potentially nonhomogeneous) machines. This algorithm requires only minimal support from the distributed operating system. DIB can recover from failures of machines even if they are not detected. DIB currently runs on the Crystal multicomputer at the University of Wisconsin-Madison. Many applications have been implemented quite easily, including exhaustive traversal ( N queens, knight's tour, negamax tree evaluation), branch and bound (traveling salesman) and alpha-beta search (the game of NIM). Speedup is excellent for exhaustive traversal and quite good for branch and bound.

This paper considers the amount of cooperation required for independent asynchronous processes to share a simple dynamic data structure. We present a scheme for designing efficient concurrent algorithms to add and remove elements from a shared pool of elements. The efficiency is measured mainly by the number of non-local operations that a process may have to make. Non-local operations may involve writing into a shared variable, locking, or sending a message, hence they introduce interference (or require cooperation). We derive upper and lower bounds on the interference in the worst case. Applications to distributed computation are also discussed.

This work generalizes decision trees in order to study lower bounds on the running times of algorithms that allow probabilistic, nondeterministic, or alternating control. It is shown that decision trees that are allowed internal randomization (at the expense of introducing a small probability of error) run no faster asymptotically than ordinary decision trees for a collection of natural problems. Two geometric techniques from the literature for proving lower bounds on the time required by ordinary decision trees are shown to be special cases of one unified technique that, in fact, applies to nondeterministic decision trees as well. Finally, it is shown that any lower bound on alternating decision tree time also applies to alternating Turing machine time.

Combinatorial techniques for extending lower bound results for decision trees to general types of queries are presented. Problems that are defined by simple inequalities between inputs, called order invariant problems, are considered. A decision tree is called k-bounded if each query depends on at most k variables. No further assumptions on the type of queries are made. It is proved that one can replace the queries of any k -bounded decision tree that solves an order-invariant problem over a large enough input domain with k -bounded queries whose outcome depends only on the relative order of the inputs. As a consequence, all existing lower bounds for comparison-based algorithms are valid for general k -bounded decision trees, where k is a constant. An Ω( n log n ) lower bound for the element uniqueness problem and several other problems for any k -bounded decision tree, such that k = O ( n c ) and c < 1/2 is proved. This lower bound is tight since there exist n 1/2 -bounded decision trees of complexity O ( n ) that solve the element-uniqueness problem. All the lower bounds mentioned above are shown to hold for nondeterministic and probabilistic decision trees as well.

An extension to the token ring protocol which allows a special type of arithmetic, called shift arithmetic, to be performed directly on the node's interfaces is proposed. The new protocol is based on an approach in which the communication channel and the interfaces form an environment in which simple commands can be executed. Each command operates on operands located at the interfaces, and places the result at the interface which initiated the command. The commands utilize the mandatory 1-bit delay of the token ring protocol to implement arithmetic and logical operations on the operands without further delay. The goal of this protocol is to enhance the performance of distributed algorithms on ring networks by performing many simple tasks in the lowest possible level. The authors show that this protocol is especially useful for load sharing in local area networks. Other potential application areas include parallel algorithms, distributed simulation, distributed operating systems, distributed databases and real-time computations.

Combinatorial techniques for extending lower bounds results for decision trees to general types of queries are presented. We consider problems, which we call order invariant, that are defined by simple inequalities between inputs. A decision tree is called k-bounded if each query depends on at most k variables. We make no further assumptions on the type of queries. We prove that we can replace the queries of any k-bounded decision tree that solves an order invariant problem over a large enough input dornain with k-bounded queries whose outcome depends only on the relative order of the inputs. As a consequence, all existing lower bounds for comparison based algorithms are valid for general k-bounded decision trees, where k is a constant. We also prove an /spl Omega/(n log n) lower bound for the element uniqueness problem and several other problems for any k-bounded decision tree, such that k - )(n/sup c/) and c < 1/2. This lower bound is tight since that there exist n/sup 1/2/-bounded decision trees of complexity 0(n) that solve the element uniqueness problem. All the lower bounds mentioned above are shown to hold for nondeterministic and probabilistic decision trees as well.

This paper considers the amount of cooperation required for independent asynchronous processes to share a simple dynamic data structure. We present a scheme for designing efficient concurrent algorithms to add and remove elements from a shared pool of elements. The efficiency is measured mainly by the number of non-local operations that a process may have to make. Non-local operations may involve writing into a shared variable, locking, or sending a message, hence they introduce interference (or require cooperation). We derive upper and lower bounds on the interference in the worst case. Applications to distributed computation are also discussed.

A generalization of Dobkin and Lipton’s element uniqueness problem is introduced. For any fixed undirected graph G on vertex set $\{ v _1 , v_2 , \cdots , v_n \} $, the problem is to determine, given n real numbers $x_1 ,x_2 , \cdots ,x_n $, whether $x_i \ne x_j $ for every edge $\{ \upsilon _i ,\upsilon _j \} $ in G. This problem is shown to have upper and lower bounds of $\Theta (n\log n)$ linear comparisons if G is any dense graph. The proof of the lower bound involves showing that any dense graph must contain a subgraph with many Hamiltonian paths, and demonstrating the relevance of these Hamiltonian paths to a geometric argument. In addition, we exhibit relatively sparse graphs for which the same lower bound holds, and relatively dense graphs for which a linear upper bound holds.

A design of a data structure and efficient algorithms for concurrent manipulations of a dynamic search structure by independent user processes is presented in this paper. The algorithms include updating data, inserting new elements, and deleting elements. The algorithms support a high level of concurrency. Each of the operations listed above requires only constant amount of locking. In order to make the system even more efficient for the user processes, maintenance processes are introduced. The maintenance processes operate independently in the background to reorganize the data structure and “clean up” after the (more urgent) user processes. A proof of correctness of the algorithms is given and some experimental results and extensions are examined.

The problem of providing efficient concurrent access for independent processes to a dynamic search structure is the topic of this paper. We develop concurrent algorithms for search, update, insert, and delete in a simple variation of binary search trees, called external trees. The algorithm for deletion, which is usually the most difficult operation, is relatively easy in this data structure. The advantages of the data structure and the algorithms are that they are simple, flexible, and efficient, so that they can be used as a part in the design of more complicated concurrent algorithms where maintaining a dynamic search structure is necessary. In order to increase the efficiency of the algorithms we introduce maintenance processes that independently reorganize the data structure and relieve the user processes of nonurgent operations. We also discuss questions of transactions in a dynamic environment and replicated copies of the data structure.

This work generalizes decision trees in order to model algorithms which allow probabilistic, nondeterministic, or alternating control. Two geometric techniques for proving lower bounds on the time required by ordinary decision trees (Dobkin and Lipton's “region-counting” technique as applied to the knapsack and element uniqueness problems [1], and Reingold's technique as applied to set equality [4]) are shown to be special cases of one unified technique, which in fact applies to nondeterministic decision trees as well. This technique is applied to yield tight upper and lower bounds on the nondeterministic time for solving element uniqueness, set disjointness, set membership, set equality, ε-closeness [2], and knapsack problems, as well as many of these problems complements.

A generalization of Dobkin and Lipton's element uniqueness problem is introduced: for any fixed undirected graph G on vertex set {v1, v2, ..., vn}, the problem is to determine, given n real numbers x1, x2, ..., xn, whether xi ≠ xj for every edge {vi, vj} in G. This problem is shown to have upper and lower bounds of Θ(nlogn) linear comparisons if G is any dense graph. The proof of the lower bound involves showing that any dense graph must contain a subgraph with many Hamiltonian paths, and demonstrating the relevance of these Hamiltonian paths to a geometric argument. In addition, we exhibit relatively sparse graphs for which the same lower bound holds, and relatively dense graphs for which a linear upper bound holds.

The model of Preparata et al. [1] is used for system diagnosis. The problem of characterizing systems which are sequentially diagnosable is considered. A new concept (detection set), which gives a new insight to the structure of these systems, is defined in this paper and utilized to prove two theorems which expand the class of known sequentially diagnosable systems. An algorithm for finding a faulty unit is discussed, and a conjecture is stated which, if true, characterizes those systems. Finally, detection sets are also used in the context of Friedman's model of t/s diagnosability, to extend the repair strategies proposed by Karunanithi and Friedman [6] for single loop systems to systems whose diagnostic graph is strongly connected.