We answer the following question: Can a deque (double-- ended queue) be implemented in a purely functional language such that each push or pop operation on either end of a queue is accomplished in O(1) time in the worst case? The answer is yes, thus solving a problem posted by Gajewska and Tarjan [14] and by Ponder, McGeer, and Ng [25], and refining results of Sarnak [26] and Hoogerwoord [18]. We term such a deque real--time, since its constant worstcase behavior might be useful in real time programs (assuming real--time garbage collection [3], etc.) Furthermore, we show that no restriction of the functional language is necessary, and that push and pop operations on previous versions of a deque can also be achieved in constant time. We present a purely functional implementation of real-- time deques and its complexity analysis. We then show that the implementation has some interesting implications, and can be used to give a real--time simulation of a multihead Turing machine in a purel...

Multisets (also called bags) are an interesting data structure for parallelly implemented functional programming languages, since they do not force an unneeded restriction of the data flow and allow to exploit as much parallelism as possible. Most operations on multisets can be understood as special cases of the so-called Gamma scheme [?]. In the present paper, we investigate efficient implementations of several instances of this Gamma scheme on MIMD-machines. 1 Introduction The ubiquitous data structure in functional (and logic) programming language is the list. For a parallel implementation of such a language, however, lists have the drawback that they force a sequential access to their elements. Hence, it is only interesting to use lists, if the computation related to every element is large compared to the length of the list. Several researchers have investigated other applicative data structures which are more adequate for parallel implementations, among them modifications of cla...

The design and implementation of efficient aggregate data structures has been an important issue in functional programming. It is not clear how to select a good representation for an aggregate when access patterns to the aggregate are highly variant, or even unpredictable. Previous approaches rely on compile--time analyses or programmer annotations. These methods can be unreliable because they try to predict program behaviors before they are executed. We propose a probabilistic approach, which is based on Markov processes, for automatic selection of data representations. The selection is modeled as a random process moving in a graph with weighted edges. The proposed approach employs coin tossing at run--time to aid choosing suitable data representations. The transition probability function used by the coin tossing is constructed in a simple and common way from a measured cost function. We show that, under this setting, random selection of data representations can be quite effective. Th...

Amortization has been underutilized in the design of persistent data structures, largely because traditional accounting schemes break down in a persistent setting. Such schemes depend on saving "credits" for future use, but a persistent data structure may have multiple "futures", each competing for the same credits. We describe how lazy evaluation can often remedy this problem, yielding persistent data structures with good amortized efficiency. In fact, such data structures can be implemented purely functionally in any functional language supporting lazy evaluation. As an example of this technique, we present a purely functional (and therefore persistent) implementation of lists that simultaneously support catenation and all other usual list primitives in constant amortized time. This data structure is much simpler than the only existing data structure with comparable bounds, the recently discovered catenable lists of Kaplan and Tarjan, which support all operations in constant worst-ca...

Over the last seven years, we have developed static-analysis methods to recover a good approximation to the variables and dynamically allocated memory objects of a stripped executable, and to track the flow of values through them. It is relatively easy to track the effects of an instruction operand that refers to a global address (i.e., an access to a global variable) or that uses a stack-frame offset (i.e., an access to a local scalar variable via the frame pointer or stack pointer). In our work, our algorithms are able to provide useful information for close to 100% of such “direct ” uses and defs. It is much harder for a static-analysis algorithm to track the effects of an instruction operand that uses a non-stack-frame register. These “indirect” uses and defs correspond to accesses to an array or a dynamically allocated memory object. In one study, our approach recovered useful information for only 29 % of indirect uses and 33 % of indirect defs. However, using the technique described in this paper, the algorithm recovered useful information for 81 % of indirect uses and 90 % of indirect defs.

. Despite a lot of recent interest in purely functional data structures, for example [Ada93, Oka95, BO96, Oka96, OB97, Erw97], few have been benchmarked. Of these, even fewer have their performance qualified by how they are used. But how a data structure is used can significantly affect performance. This paper makes three original contributions. (1) We present an algorithm for generating a benchmark according to a given use of data structure. (2) We compare use of an automated tool based on this algorithm, with the traditional technique of hand-picked benchmarks, by benchmarking six implementations of random-access list using both methods. (3) We use the results of this benchmarking to present a decision tree for the choice of random-access list implementation, according to how the list will be used. 1 Motivation Recent years have seen renewed interest in purely functional data structures: sets [Ada93], random-access lists [Oka95], priority queues [BO96], arrays [OB97], gr...

This paper concerns the problem of how to exploit parallelism during the phases of compilation involving syntaxdirected analysis and translation. In particular, we address the problem of how to exploit parallelism during the evaluation of the attributes of a derivation tree of a non-circular attribute grammar. What distinguishes the ideas presented in this paper from earlier work on parallel attribute evaluation is the use of a data-parallel model: We define a new variant of attribute grammars, called scan grammars, that incorporates a data-parallel attribution construct. 1. Introduction Because symbolic (non-numeric) computations often involve irregular structures, the task of devising parallel algorithms for such problems is generally very difficult and attempts are often unsuccessful. This paper addresses a certain class of symbolic computational problems and shows that for these problems speedups on the order of 64-fold with 100 processors and 100-fold with 250 processors may wel...

. We review a general, space and time efficient technique for delivering a sequence of values computable by a recurrence relation, in the order opposing the data-dependencies of the recurrence. The technique provides a series of time/space tradeoffs we characterize by parameter K ? 0. Namely, N values can be delivered against the grain in O(KN) time and O(KN 1=K ) space. This basic idea is not new, but here we present it in a framework exposing its essential nature and we give a concise yet easily understood explanation of it in terms of counting in a radix-N 1=K number system. We then show how to apply this paradigm to a couple of problems in sequence comparison, a domain where it has here to fore not been used. We show that in the limiting case of K = log 2 N , the method coincides with the well-known divideand -conquer algorithm of Hirschberg. Thus, our observation provides a continuum of time/space tradeoffs for all comparison problems that have appealed to the Hirschberg para...

Multisets (also called bags) are an interesting data structure for parallely implemented functional programming languages, since they do not force an unneeded restriction of the data flow and allow to exploit as much parallelism as possible. Most operations on multisets can be understood as special cases of the so-called Gamma scheme [BL90]. In the present paper, we investigate efficient implementations of several instances of this Gamma scheme on MIMD-machines with shared memory. 1 Introduction The ubiquitous data structure in functional (and logic) programming language is the list. For a parallel implementation of such a language, however, lists have the drawback that they force a sequential access to their elements. Hence, it is only interesting to use lists, if the computation related to every element is large compared to the length of the list. Several researchers have investigated other applicative data structures which are more adequate for parallel implementations, among them ...

Finding matches, both exact and approximate, between a sequence of symbols A and a pattern P has long been an active area of research in algorithm design. Some of the more well-known byproducts from that research are the diff program and grep family of programs. These problems form a sub-domain of a larger areas of problems called discrete pattern matching which has been developed recently to characterise the wide range of pattern matching problems. This dissertation presents new algorithms for discrete pattern matching over sequences and develops a new sub-domain of problems called discrete pattern matching over interval sets. The problems and algorithms presented here are characterised by pattern matching over interval sets. The problems and al