Abstract: In the classical meldable heap data type we maintain an item-disjoint collection of heaps under the operations find-min, insert, delete, decrease-key, and meld. In the usual definition decrease-key and delete get the item and the heap containing it as parameters. We consider the modified problem where decrease-key and delete get only the item but not the heap containing it. We show that for this problem one of the operations find-min, decrease-key, or meld must take non-constant time. This is in contrast with the original data type in which data structures supporting all these three operations in constant time are known (both in an amortized and a worst-case setting).To establish our results for meldable heaps we consider a weaker version of the union-find problem that is of independent interest, which we call Boolean union-find. In the Boolean union-find problem the find operation is a binary predicate that gets an item x and a set A and answers positively if and only if k e A. We prove that the lower bounds which hold for union-find in the cell probe model hold for Boolean union-find as well.We also suggest new heap data structures implementing the modified meldable heap data type that are based on redundant binary counters. Our data structures have good worst-case bounds. The best of our data structures matches the worst-case lower bounds which we establish for the problem. The simplest of our data structures is an interesting generalization of binomial queues.

Abstract: The present invention is directed toward data packet transmission scheduling. Scheduling values, such as priority or other scheduling criteria assigned to data packets, are placed in a heap data structure(700). Packets percolate up through the heap by comparing their assigned values in pairs(816). Operations in the heap may be pipelined so as to provide for high-speed sorting(1000). Thus, a few relatively simple operations can be performed repeatedly to quickly percolate packets up trough the heap. Another aspect of the invention provides for fast traversal of the scheduling heap data structure. The hierarchical heap may include a highest level having a single position and each succeeding lower level having twice the number of positions as the preceding level(700). A binary number may represent each position in the heap(806). To traverse the heap, the relative movements necessary to move from one position to another may be determined from the binary number(818).

Abstract: A garbage collector 100 is composed of a generation heap creator 20, an inter-generation object relocator 80, and a generation heap deallocator 40. The generation heap creator 20 creates a generation heap at a start of execution of a method. The inter-generation object relocator 80 relocates, upon detecting a reference from an object in an older generation heap to another object in a younger generation heap, the referenced object in the younger generation heap to the older generation heap. The generation heap deallocator 40 deallocates, at a completion of a method, a generation heap corresponding to the method.

Abstract: Heaps constitute a well-known data structure allowing the implementation of an efficient O(n log n) sorting algorithm as well as the design of fast priority queues. Although heaps have been known for long, their combinatorial properties are still partially worked out: exact summation formulae have been stated, but most of the asymptotic behaviors are still unknown. In this paper, we present a number of general (not restricting to special subsequences) asymptotic results that give insight on the difficulties encountered in the asymptotic study of the number of heaps of a given size and of the cost of heap construction. In particular, we exhibit the influence of arithmetic functions in the apparently chaotic behavior of these quantities and study their extremal and average properties. It is also shown that the distribution function of the cost of heap construction using Floyd’s algorithm and other variants is asymptotically normal.

Abstract: A system and method for secure execution of multiple applications using a single GC heap are provided. A root set is maintained for each of the applications. Each root set includes one or more pointers objects stored in the heap. After a garbage collection operation is performed, the root sets may be used to measure resources consumption by each of the applications. The root sets may be used to measure heap consumption by associating each data structure in the memory with a particular application based on reachability from the application's root set. The root sets may be used to measure CPU time consumption during the GC by dividing the total time consumed by the GC by the total amount of the memory or number of objects used by the application. An object finalizer may be executed in a finalizer thread for each application to help limit GC-related misbehavior to GC of the objects of the misbehaving application itself. In one embodiment, static fields of some classes may be shared among applications. To prevent the compromising of the GC security, static files may be replicated per application.

Abstract: A calendar heap structure and method for sorting N timestamp (TS) values in an ATM fabric scheduler implemented in an access network element. The heap structure is implemented using a radix value (R) for grouping the N TS values into a number of groups. Validity bits associated with the TS values are hierarchically arranged in a tree having logR(N) levels, wherein the bottom layer's N bits correspond to pointers that point to linked lists of flows with respective TS values. Starting from the top level heap, each subsequent level's heaps are successively examined for determining which particular heap obtains a minimum value until a particular validity bit of the bottom level is reached, which validity bit points to the minimum TS.

Abstract: The value of a variable is often given by a field of a heap cell, and frequently the program will pick up the values of several variables from different fields of the same heap cell. By keeping some of these variables out of the stack frame, and accessing them in their original locations on the heap instead, we can reduce the number of loads from and stores to the stack at the cost of introducing a smaller number of loads from the heap. We present an algorithm that finds the optimal set of variables to access via a heap cell instead of a stack slot, and transforms the code of the program accordingly. We have implemented this optimization in the Mercury compiler, and our measurements show that it can reduce program runtimes by up to 12% while at the same time reducing program size. The optimization is straightforward to apply to Mercury and to other languages with immutable data structures; its adaptation to languages with destructive assignment would require the compiler to perform mutability analysis.

Abstract: We present a data structure to implement deques with heap order that supports the operations find minimum, push, pop, inject, eject and concatenate two deques, each in O(1) time.