Showing papers on "Binary heap published in 1998"

Incremental heap expansion in a real-time garbage collector

Abstract: A system that performs real-time garbage collection by dynamically expanding and contracting the heap is provided. This system performs real-time garbage collection in that the system guarantees garbage collection will not take more time than expected. The system dynamically expands and contracts the heap to correspond to the actual memory space used by live objects. This dynamic resizing of the heap has the advantages of expanding when the amount of objects increases and contracting to free memory space for use by other procedures when the amount of objects decreases. Keeping the heap as small as possible frees resources for other processes and increases the locality of reference for the application. This dynamic resizing also ensures that the new memory space will not run out of memory before all of the live objects from the old memory space are copied, even if all of the live objects in the old memory space survive.

Optimizing dynamic memory management in a multithreaded application executing on a multiprocessor

Abstract: The Billing Gateway (BGw) is a large multithreaded object oriented C++ application running on Sun Solaris. Due to frequent allocation and deallocation of dynamic memory, the initial implementation of this system suffered from poor performance when executed on a multiprocessor. We compare two approaches for improving the performance of BGw. First we replace the standard Solaris heap with a parallel heap. In the second approach we optimize the application code by removing a number of heap allocations/deallocations. In order to do this, we introduce memory pools for commonly used object types and replace some heap variables with stack variables. The parallel heap approach resulted in a dramatic speedup improvement. The optimization of the application code did also result in a dramatic speedup improvement. For this approach the performance using a single processor computer was also increased by a factor of eight. The optimizations took approximately one week to implement.

Method and apparatus for supporting efficient programming in dynamic pointer-safe languages

Abstract: One embodiment of the present invention facilitates low-level systems programming in dynamic, “pointer-safe” programming languages, which disallow arbitrary references through pointers. It does so by avoiding the creation of object instances in the traditional fashion. Rather, a large heap is defined to store dynamically allocated data objects, and explicit memory management operations are implemented in order to allocate and deallocate memory from the heap. Traditional object pointers are replaced by indices to the heap. The described technique allows the bypassing of traditional object allocation, thus making object allocation static from the viewpoint of the pointer-safe programming language—with the exception of the large array that is allocated to serve as the heap. Since the new memory system is implemented on top of an existing automatic memory system, varying degrees of automatic and manual memory management are possible.

Car-Pooling as a Data Structuring Device: The Soft Heap

Abstract: A simple variant of a priority queue, called a soft heap, is introduced. The data structure supports the usual operations: insert, delete, meld, and findmin. In order to beat the standard informationtheoretic bounds, the soft heap allows errors: occasionally, the keys of certain items are artificially raised. Given any 0 < Ɛ < 1=2 and any mixed sequence of n operations, the soft heap ensures that at most ∈n keys are raised at any time. The amortized complexity of each operation is constant, except for insert, which takes O(log 1/Ɛ) time. The soft heap is optimal. Also, being purely pointer-based, no arrays are used and no numeric assumptions are made on the keys. The novelty of the data structure is that items are moved together in groups, in a data-structuring equivalent of "car pooling." The main application of the data structure is a faster deterministic algorithm for minimum spanning trees.

Lock bypassing: an efficient algorithm for concurrently accessing priority heaps

Abstract: The heap representation of priority queues is one of the most widely used data structures in the design of parallel algorithms. Efficiently exploiting the parallelism of a priority heap has significant influence on the efficiency of a wide range of applications and parallel algorithms. In this paper, we propose an aggressive priority heap operating algorithm, called the lock bypassing algorithm (LB) on shared memory systems. This algorithm minimizes interference of concurrent enqueue and dequeue operations on priority heaps while keeping the strict priority property: a dequeue always returns the minimum of a heap. The unique idea that distinguishes the LB algorithm from previous concurrent algorithms on priority heaps is the use of locking-on-demand and lock-bypassing techniques to minimize locking granularity and to maximize parallelism. The LB algorithm allows an enqueue operation to bypass the locks along its insertion path until it reaches a possible place where it can perform the insertion. Meanwhile a dequeue operation also makes its locking range and locking period as small as possible by carefully tuning its execution procedure. The LB algorithm is shown to be correct in terms of deadlock freedom and heap consistency. The performance of the LB algorithm was evaluated analytically and experimentally in comparison with previous algorithms. Analytical results show that the LB algorithm reduces by half the number of locks waited for in the worst case by previous algorithms. The experimental results show that the LB algorithm outperforms previously designed algorithms by up to a factor of 2 in hold time.

Comparator Networks for Binary Heap Construction

Abstract: Comparator networks for constructing binary heaps of size n are presented which have size O(n log log n) and depth O(log n). A lower bound of n log log n — O(n) for the size of any heap construction network is also proven, implying that the networks presented are within a constant factor of optimal. We give a tight relation between the leading constants in the size of selection networks and in the size of heap construction networks.

Method and apparatus for generational garbage collection in a shared heap memory by means of multiple processor units

Abstract: of EP0881576Apparatus, methods, systems and computer program products are disclosed describing generational garbage collection on a card-marked heap memory (209) shared by multiple processing units (205, 207). When one of the processing units detects (405) that the free space available for node creation is below a threshold, that processing unit pauses (408) its heap mutation processes and signals the other processing units to also pause mutation. After the other processing units pause (411) heap mutation, the processing units then proceed to execute generational garbage collection procedures (413) on the shared heap. The generational garbage collection procedures for each processing unit are driven by pointers stored in each processing unit's register, stack and static variables along with pointers within a specified partition of the shared card-marked heap. The processing units resume (419) mutation of the heap once they all complete (415, 417) their garbage collection processes.

Algorithm Theory - SWAT'98: 6th Scandinavian Workshop on Algorithm Theory, Stockholm, Sweden, July 8-10, 1998, Proceedings

Abstract: Recent developments in maximum flow algorithms.- An ? - Approximation algorithm for weighted shortest paths on polyhedral surfaces.- Facility location with dynamic distance functions.- An approximation scheme for bin packing with conflicts.- Approximations for the general block distribution of a matrix.- An optimal algorithm for computing visible nearest foreign neighbors among colored line segments.- Moving an angle around a region.- Models and motion planning.- Constrained square-center problems.- Worst-case efficient external-memory priority queues.- Simple confluently persistent catenable lists.- Improved upper bounds for time-space tradeoffs for selection with limited storage.- Probabilistic data structures for priority queues.- Extractors for weak random sources and their applications.- Comparator networks for binary heap construction.- Two-variable linear programming in parallel.- Optimal deterministic protocols for mobile robots on a grid.- Concurrent multicast in weighted networks.- Some recent strong inapproximability results.- Minimal elimination of planar graphs.- Memory requirements for table computations in partial k-tree algorithms.- Formal language constrained path problems.- Local search algorithms for SAT: Worst-case analysis.- Speed is more powerful than clairvoyance.- Randomized online multi-threaded paging.- Determinant: Old algorithms, new insights.- Solving fundamental problems on sparse-meshes.- Output-sensitive cell enumeration in hyperplane arrangements.- Fast and efficient computation of additively weighted Voronoi cells for applications in molecular biology.- On the number of regular vertices of the union of Jordan regions.- Distribution-sensitive algorithms.