Abstract: One embodiment of the present invention sets forth a technique for dynamically allocating memory using a nested hierarchical heap. A lock-free mechanism is used to access to a hierarchical heap data structure for allocating and deallocating memory from the heap. The heap is organized as a series of levels of fixed-size blocks, where all blocks at given level are the same size. At each lower level of the hierarchy, a collection of N blocks in the lower level equals the size of a single block at the level above. When a thread requests an allocation, one or more blocks at only one level are allocated to the thread. When threads are finished using an allocation, each thread deallocates the respective allocated blocks. When all of the blocks for a level have been deallocated, defragmentation is performed at that level.

Abstract: We consider verification of programs manipulating dynamic linked data structures such as various forms of singly and doubly-linked lists or trees. We consider important properties for this kind of systems like no null-pointer dereferences, absence of garbage, shape properties, etc. We develop a verification method based on a novel use of tree automata to represent heap configurations. A heap is split into several "separated" parts such that each of them can be represented by a tree automaton. The automata can refer to each other allowing the different parts of the heaps to mutually refer to their boundaries. Moreover, we allow for a hierarchical representation of heaps by allowing alphabets of the tree automata to contain other, nested tree automata. Program instructions can be easily encoded as operations on our representation structure. This allows verification of programs based on a symbolic state-space exploration together with refinable abstraction within the so-called abstract regular tree model checking. A motivation for the approach is to combine advantages of automata-based approaches (higher generality and flexibility of the abstraction) with some advantages of separation-logic-based approaches (efficiency). We have implemented our approach and tested it successfully on multiple non-trivial case studies.

Abstract: We introduce the rank-pairing heap, an implementation of heaps that combines the asymptotic efficiency of Fibonacci heaps with much of the simplicity of pairing heaps. Other heap implementations that match the bounds of Fibonacci heaps do so by maintaining a balance condition on the trees representing the heap. In contrast to these structures but like pairing heaps, our trees can evolve to have arbitrary (unbalanced) structure. Also like pairing heaps, our structure requires at most one cut and no other restructuring per key decrease, in the worst case: the only changes that can cascade during a key decrease are changes in node ranks. Although our data structure is simple, its analysis is not.

Abstract: A system and method for use with garbage collected systems and languages, for enabling an allocated heap memory to be updated (e.g., increased or decreased) at runtime, subject to sufficient availability of physical memory. In accordance with an embodiment, a Java Virtual Machine (JVM) is associated with a management console, which allows a systems administrator to monitor current heap utilization at runtime. The heap is visualized as a contiguous chunk of memory with one or more extension points, e.g., by use of a trailing pointer to a null list. If later, at runtime, the heap size needs to be incremented then the trailing pointer can be set to a new chunk of memory with a size of (new value−old value), so that the cumulative new size is made equal to a new value specified on the console. The new chunk of memory can again end with a trailing pointer, to allow for further extension. The features can help ensure that an alert administrator will have the means to prevent an out-of-memory situation when the allocated heap proves insufficient at runtime.

Abstract: Programs written in languages such as Java and C# maintain most of their state on the heap. The size and complexity of these programs pose a challenge in understanding and maintaining them; Heap analysis by summarizing the state of heap graphs assists programmers in these tasks. In this paper we present a novel dynamic heap analysis technique that uses spectra of the heap graphs to summarize them. These summaries capture the shape of recursive data structures as dynamic invariants or likely properties of these structures that must be preserved after any destructive update. Initial experiments show that this approach can generate meaningful summaries for a range of subject structures.

Abstract: We describe an integrated solution to symbol, heap and logic engine memory management in a context where exchanges of arbitrary Prolog terms occur between multiple dynamically created engines, implemented in a new Java-based experimental Prolog system.As our symbols represent not just Prolog atoms, but also handles to Java objects (including arbitrary size integers and decimals), everything is centered around a symbol garbage collection algorithm ensuring that external objects are shared and exchanged between logic engines efficiently.Taking advantage of a tag-on-data heap representation of Prolog terms, our algorithm performs in-place updates of live symbol references directly on heap cells.With appropriate fine tuning of collection policies our algorithm provides an integrated memory management solution for Prolog systems, with amortized cost dominated by normally occurring heap garbage collection costs.

Abstract: Recently, Grid Computing Systems have provided wide integrated use of resources. Grid computing systems provide the ability to share, select and aggregate distributed resources as computers, storage systems or other devices in an integrated way. Grid computing systems have solved many problems in science, engineering and commerce fields. In this paper we introduce a self-recognition algorithm for grid network and introduced this algorithm to have exclusive management control on the autonomic grid networks. This algorithm is base on binomial heap to allocate and recognition any node in the grid. We try to using this algorithm in advisor labor law software application as case study and shown in this application how to use this method for any advisor application on the network. By this implementation model shown this method can get better answer to any question as a best labor law advisor.

Abstract: Identifying dependences present in the body of sequential program is used by parallelizing compilers to automatically extract parallelism from the program. Dependence detection mechanisms for programs with scalar and static variables is well explored and have become a standard part of parallelizing and vectorizing compilers. However, detecting dependences in the presence of dynamic (heap) recursive data structures is highly complex because of the unbound and dynamic nature of the structure. The problem becomes more critical due to the presence of pointer-induced aliasing . This thesis addresses the aforementioned problem and gives a novel approach for dependence analysis of sequential programs in presence of heap data structure. The novelty of our technique lies in the two-phase mechanism, where the first phase identifies dependences for whole procedure. It computes abstract heap access paths for each heap accessing statement in the procedure. The access paths approximate the locations accessed by the statement. For each pair of statements these access paths are checked for interference. The second phase refines the dependence analysis in the context of loops. The main aspect of the second phase is the way we convert the precise access paths, for each statement, into equations that can be solved using traditional tests, e.g. GCD test, and Lamport test. The technique discovers loop dependences, i.e. the dependence among two different iterations of the same loop. Further, we extend the intra-procedural analysis to inter-procedural one. This thesis is dedicated to my parents and my beloved friend.

Abstract: We propose a simple linear-time on-line algorithm for constructing a position heap for a string [EMOW11]. Our definition of position heap differs slightly from the one proposed in [EMOW11] in that it considers the suffixes ordered in the descending order of length. Our construction is based on classic suffix pointers and resembles the Ukkonen's algorithm for suffix trees [Ukk95]. Using suffix pointers, the position heap can be extended into the augmented position heap that allows for a linear-time string matching algorithm [EMOW11].

Abstract: Traveltime calculation has been applied in many project extensively such as earthquake simulation, prestack migration, tomographic imaging, velocity analysis. finite-difference solution of the eikonal equation along expanding wavefronts had two prominent characteristics:one was wavefront points update very frequent, Usually insert some new wavefronts points after extacting one minimum point every time;the other was that the new calculated wavefronts’s traveltime was usually large.Therefore,the paper introduced binomial heap sorts method, optimizated the method of inserting new wavefronts and removing the minimum point in wavefronts, ensured the search efficiency, and had good time complexity.

Abstract: In this paper, we will introduce a new method to achieve the fair distribution of data among distributed memories in a distributed system. Some processes consume larger amount of heap spaces [1] in its local memory than the others. So, those processes may use the virtual memory and may cause the thrashing problem [2].At the same time, the rest of heap memories in that distributed system remain almost empty without best utilization for heap memories of the whole distributed system. So, a UDP-Based process communication system is defined [3] to make use of remote heap memories. This is done by allocating dynamic data spaces for other processes in other machines. In fact, the increasing use of high-bandwidth and low-latency networks provides the possibility to use the distributed memory as an alternative to disk.

Abstract: Dynamic memory allocation is widely used in modern programs.General-purpose heap allocators often focus more on reducing their run-time overhead and memory space utilization,but less on exploiting the characteristics of their allocated heap objects.This paper presents a lightweight dynamic optimization technique,named Dynamic Pool Allocation(DPA),which generates Storage Shape Graph at run-time,and exploits the affinity of the allocated heap objects.It uses heuristics to aggregate affinitive heap objects into dedicated memory regions,called memory pools.The authors have implemented DPA and measured its performance on several SPEC CPU 2000 and 2006 benchmarks that use extensive heap objects.Evaluations show that it could achieve an average speed up of 13.1% and 11.8% on two x86 commodity machines respectively using GCC——O3,and up to 82.2% for some benchmarks.The authors also examined the impact of cache size to the effectiveness of pool allocation.