Showing papers on "Heap (data structure) published in 1991"

The heaps process, libraries, and size-biased permutations

Abstract: The heaps process (also known as a Tsetlin library) provides a model for a self-regulating filing system. Items are requested from time to time according to their popularity and returned to the top of the heap after use. The size-biased permutation of a collection of popularities is a particular random permutation of those popularities, which arises naturally in a number of applications and is of independent interest. For a slightly non-standard formulation of the heaps process we prove that it converges to the size-biased permutation of its initial distribution. This leads to a number of new characterizations of the property of invariance under size-biased permutation, notably what might be described as invariance under ‘partial size-biasing' of any order. Finally we consider in detail the heaps process with Poisson–Dirichlet initial distribution, exhibiting the tractable nature of its equilibrium distribution and explicitly calculating a number of quantities of interest.

Some issues and strategies in heap management and memory hierarchies

Abstract: This position paper 1 will begin by enumerating some of my views about garbage collection, especially for languages like Lisp, Smalltalk, and ML. The first dozen or so points roughly amount to a recipe for my Opportunistic Garbage Collector, which is currently part of the Scheme-48 virtual machine 2. After that, I will proceed into deeper water, describing some work that has either just begun (such as our basic locality experiments) and other ideas I'm interested in working on in the future.

Optimal parallel initialization algorithms for a class of priority queues

Abstract: An adaptive parallel algorithm for inducing a priority queue structure on an n-element array is presented. The algorithm is extended to provide optimal parallel construction algorithms for three other heap-like structures useful in implementing double-ended priority queues, namely min-max heaps, deeps, and min-max-pair heaps. It is shown that an n-element array can be made into a heap, a deap, a min-max heap, or a min-max-pair heap in O(log n+(n/p)) time using no more than n/log n processors, in the exclusive-read-exclusive-write parallel random-access machine model. >

An evaluation of concurrent priority queue algorithms

Abstract: This paper describes the design and experimental evaluation of two novel concurrent priority queue algorithms, a parallel Fibonacci heap and a concurrent priority pool, and compares them with the concurrent binary heap. The parallel Fibonacci heap is based on the sequential Fibonacci heap, which is theoretically the most efficient data structure for sequential priority queues. The concurrent priority pool is based on the concurrent B-tree and the concurrent pool. Both new algorithms scale better and have large throughput than the concurrent binary heap, as shown by the performance results. These performance advantages are achieved by relaxing the semantics of the extract-min operation, allowing it to return items that are close to the minimum but not necessarily minimal. Two applications of concurrent priority queues, the vertex cover problem and the single source shortest path problem, are tested. >

HeapGuard, eliminating garbage collection in real-time Ada systems

Abstract: The authors introduce HeapGuard, a heap management system which eliminates the problem of garbage collection in real-time systems. The sources of garbage and traditional garbage collection are reviewed. The HeapGuard scheme and optional hardware are presented. It is concluded that, in real-time computer systems, heap memory could be managed using HeapGuard to provide predictable timing and eliminate storage errors due to fragmentation. If feasible, a coprocessor could be provided to manage the dynamic memory and increase system throughput. If the application program is known to store only small objects, then a software-only implementation could be effective. If the application program is known to store many large objects in dynamic memory then the coprocessor could provide and manage a set of pointers to these large objects. If the program stores many small and many large objects, then a software-only heap for the small objects and an address pointer based heap for large objects could be provided. >

Controlled percolation method for heap leach mining

Abstract: A system for heap leach mining comprises supply and header pipes for conducting leaching solution alongside a bed or "heap" of crushed metal-laden ore deposited on an impervious pad. A series of spaced tubes are connected to the supply header pipes to extend transversely thereof, over the pad, to receive the leaching solution therefrom. A plurality of emitters are connected in spaced relationship along each of the tubes for emitting the leaching solution at a controlled and substantially uniform rate over the pad and into the ore bed. The tubes and emitters can be positioned either on an upper surface of the ore bed or buried beneath such surface, at a predetermined depth. The system and method of this invention provide numerous advantages over conventional surface spraying systems and methods, including substantial cost savings thereover.

GAML: a parallel implementation of Lazy ML

Abstract: We present a new parallel implementation of lazy ML. Our scheme is a direct extension of the G-machine-based implementation of lazy ML. Parallelism is introduced by fork annotations inserted by the programmer. We discuss the interference of such user annotations with strictness annotations generated by our compiler. The system has been implemented on a Sequent Balance computer. We also address the main practical issues involved, including stack and heap management.

Compile-Time Garbage Collection by Necessity Analysis

Abstract: This paper gives a brief overview of an analysis technique for determining at compile-time whether heap cells are still needed at a particular point in the execution of a functional program. This technique involves the analysis of necessity information. The analysis technique is used to determine at compile-time which heap cells can be deallocated, and also which of these deallocated cells can subsequently be reallocated.

Implementation of Prolog as Binary Definite Programs.

Abstract: We describe how Prolog can be implemented with a simplified WAM, by transforming Prolog programs to binary definite programs. This removes all operations from the WAM which are related to environments, as environments are no longer needed for these transformed programs. The obvious catch is that the heap includes the information previously in the environments. We discuss the transformation scheme, including the treatment of disjunctions and cut and the primitives necessary to support the latter. We show how to implement built-in predicates and how to reintroduce optimizations lost in the general transformation. We show best and worst case behavior and a performance analysis for a selected program.

Combining Single-Space and Two-Space Compacting Garbage Collectors

Abstract: The garbage collector presented in this paper makes use of two well known compaction garbage collection algorithms with very different performance characteristics: Cheney’s two-space copying collector and Jonker’s single-space sliding compaction collector. We propose a scheme which allows either collector to be used. The run-time memory requirements of the program being executed are used to determine the most appropriate collector. This enables us to achieve a fast collector for heap requirements less than half of the heap memory but allows the heap utilization to increase beyond this threshold. Using these ideas we develop a particularly attractive extension to Appel’s generational collector.

Distribution of oxidizing bacterial activities and characterization of bioleaching-related microorganisms in a uranium mineral heap.

Abstract: The occurrence and activity of bioleaching-related microorganisms are highest at 0.25 m under the surface of a uranium mineral heap, and decrease at points deeper than 1 m inside the heap. Thiobacillus ferrooxidans, Th. acidophilus, Th. thiooxidans and Leptospirillum ferrooxidans have been found and isolated from different sites inside the heap. Other mesophilic iron- or sulphur-oxidizing bacteria and some moderate thermophile have also been isolated from deep (1 m and 4 m) sites and characterized. Several fungi and some yeasts are present in this bioleaching habitat.

Managing a parallel heap efficiently

Abstract: We design a cost-optimal algorithm for managing a parallel heap on an exclusive-read and exclusive-write (EREW), parallel random access machine (PRAM) model. This is an improvement in space and time over the one recently proposed by Deo and Prasad [4]. Our approach efficiently employs p processors in the range 1 ≤ p ≤ n, where n is the maximum number of items in a parallel heap. It is assumed that a delete-think-insert cycle is repeatedly performed, and each processor requires an arbitrary but the same amount of time (called the think time) for processing an item which in turn generates at most α (a constant) new items. The time required for deleting p items of the highest priority from the parallel heap is O(1), while that for inserting at most αp new items is O(log n). With or without incorporating the think time, the speedup of our algorithm is proved to be linear, i.e. O(p). Using a global, working data structure for each level of the heap, it is shown that the additional memory space required for our parallel heap is much less than that for the existing one [4]. Furthermore, the proposed algorithm retains the strict priority ordering of a sequential heap.

Optimizing the Design

Abstract: This chapter contains sections titled: Heap representation, Constants, lists, and anonymous variables, A note on set instructions, Register allocation, Last call optimization, Chain rules, Environment trimming, Stack variables, Variable classification revisited, Indexing, Cut

Heap-filter merge join: a new algorithm for joining medium-size inputs

Abstract: A novel algorithm for relational equijoin is presented. The algorithm is a modification of merge join, but promises superior performance for medium-size inputs. In many cases it even compares favorably with both merge join and hybrid hash join, which is shown using analytic cost functions. >

Analysing Heap Contents in a Graph Reduction Intermediate Language

Abstract: We present an algorithm to analyse graph reduction intermediate code, which gives a safe approximation to what kind of nodes (i.e. which constructors and/or unevaluated function applications) pointers might point to at different points in the program. The analysed language, called GRIN (Graph Reduction Intermediate Notation) is a procedural language with operations essentially the same as in the G-machine but in the form of three address instructions. The analysis uses a framework developed by Jones and Muchnick for dealing with the interprocedural flow of information.

Fast generation of long sorted runs for sorting a large file

Abstract: On sequential machines, most internal sorting algorithms can sort no more than m items using a memory of size m. However, sorting with a heap can produce sorted sequences, called runs, of length about twice the heap size. A second advantage of sorting with a heap is that data I/O and the heap restructuring can be performed concurrently to reduce the sorting time. The third advantage is that it can even sort an arbitrarily large file in one pass if the file satisfies a certain ordering condition. The authors present an algorithm running on a linear array to obtain the above advantages. Specifically, the algorithm can produce runs of length about 2(m+2)p on a linear array of p PEs each with a heap of size m, and can overlap I/O with internal operations. In addition, it can completely sort an arbitrarily large file in one pass providing no item in the file has (m+2)p larger items before it. The algorithm can be modified to perform (mp+2p)-way merges. The authors have also estimated the optimal heap size in each PE for the minimum sorting time. >

An architectural technique for cache-level garbage collection

Abstract: Cache performance is critical in high-speed computing systems. However, heap-intensive programs such as LISP codes typically have low cache performance because of inherently poor data locality. To improve the cache performance, the system should reuse heap cells while they are in cache, thus reducing the number of cache misses due to heap references. Furthermore, the system can adopt multi-threaded architecture to hide the cache miss overhead by switching to different control threads when a cache miss occurs. In this paper, a novel architectural scheme called cache-level garbage collection based on multi-threading is developed to improve the cache performance for heap-intensive programs. Consequently both the cache hit ratio is improved and the cache miss overhead is masked, thereby minimizing the total cache miss penalty. We present the garbage collection algorithm and its architectural support features, together with initial performance evaluation.

An efficient and scalable parallel algorithm for discrete-event simulation

Abstract: The authors describe a novel parallel algorithm for discrete-event simulation on an exclusive-read exclusive-write parallel random-access machine (EREW PRAM). This algorithm is based on a recently developed parallel data structure, namely the parallel heap, which, when used as a parallel event-queue, allows deletion of O(p) earliest messages and insertion of O(p) new messages each in O(log n) time, using p processors, where n is the number of messages scheduled. The proposed algorithm can simulate up to p independent messages in O(log n) time, thus achieving O(p) speedup. The number of processors, p, can be optimally varied in the range 1 >

Exploiting parallelism in the implementation of AGNA, a persistent programming system

Abstract: A design for AGNA, a persistent object system that utilizes parallelism in a fundamental way to enhance performance, is presented. The underlying thesis is that fine-grained parallelism is essential for achieving scalable performance on parallel multiple instruction/multiple data (MIMD) machines. This, in turn, implies a data-driven model of computation for efficiency. The complete design based on these principles starts with a declarative source language because such languages reveal the most fine-grained parallelism. It is described how transactions are compiled into an abstract, fine-grained parallel machine called P-RISC. The P-RISC virtual heap is implemented in the memory and disk of a parallel machine in such a way that paging is overlapped with useful computation. The current implementation status is described, some preliminary performance results are reported and the approach presented is compared to several recent parallel database system projects. >

Reducing Scheduling Overheads for Concurrent Logic Programs

Abstract: Strictness analysis is crucial for the efficient implementation of the lazy functional languages. A related technique for the concurrent logic languages (CLLs) called schedule analysis is presented which divides at compile-time a CLL program into threads of totally ordered atoms, whose relative ordering is determined at run-time. The technique enables the enqueuing and dequeuing of processes to be reduced, synchronisation tests to be partially removed, introduces the possibility of using unboxed arguments, and permits variables to be migrated from a heap to a stack to affect a form of compile-time garbage collection. The implementation is outlined and some preliminary results are given.

Faster composting appts. with self-circulating air flow - where warm air from reaction rises, cools and falls to base of container via tube, draws in water and flows through heap again

Abstract: Process and appts. for composting biological materials. Heat produced by the reaction rises above the heap, is cooled and falls via a central or side channel to the heap base where it is drawn in again, thus forming a self-circulating air flow. Moisture is picked up during circulation and carried into the heap. Appts. comprises a closed, insulated container with a continuous, perforated central pipe in which a water container with an exposed water surface is suspended. An annular gap remains between the water container and central pipe for air circulation. USE/ADVANTAGE - Used for efficient composting with more rapid material breakdown.

A shared-memory multiprocessor garbage collector and its evaluation for committed-choice logic programs

Abstract: A parallel copying garbage collection algorithm for symbolic languages executing on shared-memory multiprocessors is proposed. The algorithm is an extension of Baker's sequential algorithm with a novel method of heap allocation to prevent fragmentation and facilitate load distribution during garbage collection. An implementation of the algorithm within a concurrent logic programming system, VPIM, has been evaluated and the results, for a wide selection of benchmarks, are analyzed. The authors show (1) how much the algorithm reduces the contention for critical sections during garbage collection, (2) how well the load-balancing strategy works and its expected overheads, and (3) the expected speedup achieved by the algorithm. >