A mechanism is provided for managing memory of a runtime environment executing on a virtual machine. The mechanism includes an elastic cache made of objects within heap memory of the runtime environment. When the runtime environment and virtual machine are not experiencing memory pressure from a hypervisor, the objects of the elastic cache may be used to temporarily store application-level cache data from applications running within the runtime environment. When memory pressure from the hypervisor is exerted, the objects of the elastic cache are re-purposed to inflate a memory balloon within heap memory of the runtime environment.

A method for reclaiming memory resources may include segmenting a plurality of memory resources in an in-memory database into a first resource partition and a second resource partition; generating, for the first resource partition, a first heap containing a first plurality of memory resources sorted based on an age of data occupying the first plurality of memory resources; generating, for the second resource partition, a second heap containing a second plurality of memory resources sorted based on an age of data occupying the second plurality of memory resources; and when a shortage of memory resources is detected, identifying, from the first heap, a first memory resource containing a least recently used data, identifying, from the second heap, a second memory resource containing a least recently used data, and reclaiming the first memory resource and/or the second memory resource. Related systems and articles of manufacture are also disclosed.

A system and related method for managing memory in data processing comprises allocating each of a plurality of application containers a respective portion of a memory communicatively coupled to a plurality of processing units. The method further comprises allocating each of the plurality of application containers a respective group of the plurality of processing units and allocating, to each of the plurality of application containers, nursery and tenured heap spaced in the memory. The method then comprises performing, responsive to a request from an application container, garbage collection from the nursery and tenured heap spaces allocated to the application container.

A system that manages lifetime of an object is provided. The system analyzes references on multiple objects to determine reachability of a native peer and dynamically transitions between native and managed object lifetime management systems based on the analysis. When a native peer is not reachable by a native application reference, the system weakens references to a managed peer avoiding memory leaks and clones the native references to the managed side to avoid premature collection. The system performs an optimized cleanup during object system shutdown wherein the references between managed and native peers are released and SafeHandles are suppressed from finalization. The system employs a pending remove list that stores a reference to a weak reference of a managed peer to eliminate race conditions that occur during finalization.

The disclosed embodiments provide a method, apparatus, and system for selecting, based on feedback from previous garbage collections, a portion of a referenced memory area for garbage collection within a time window. During the execution of a software program, the system selects a given portion of a referenced memory area on which garbage collection can be completed within the given time window and attempts to complete garbage collection on at least the given portion of the referenced memory area before the end of the given time window. Next, the system selects, based on the results of the garbage collection performed during the given time window, a subsequent portion of the referenced memory area on which garbage collection can be completed within the subsequent time window and attempts to complete garbage collection on at least the subsequent portion of the referenced memory area before the end of the subsequent time window.

Efficiently managing encrypted data on a remote backup server, including: receiving an encrypted extent of data; storing the encrypted extent; determining, without decrypting the encrypted extent, whether the encrypted extent is no longer valid; and responsive to determining that the encrypted extent is no longer valid, garbage collecting the encrypted extent.

A method and system are provided for reducing garbage collection overhead. The method includes representing, by a hardware processor, an application program by a Directed Acyclic Graph having a set of nodes. Each of the nodes represents a respective one of a plurality of computation tasks. The method further includes specifying, by the hardware processor from the set of nodes, any of the nodes which store a respective computation result for at least a threshold period of time as cache nodes. The method further includes allocating, by the hardware processor, the respective computation result of each of the cache nodes into a tenure area of a memory.

Methods and systems for garbage collection are described. In some embodiments, Garbage collector threads may maximize local accesses and minimize remote access by copying Young objects and Old objects differently. When copying a Young object, a garbage collector thread may determine the lgroup of the pool that contains the object and copy the object to a pool of the same lgroup. The garbage collector thread may spread Old objects among lgroups by copying Old objects to pools of the same lgroup as the respective garbage collector thread. Additional methods and systems are disclosed.

Techniques for efficient continuation stack storage are disclosed. In some embodiments, when a continuation yields, the continuation stack, or portion thereof, is copied from a thread stack to a data object, referred to herein as a chunk, allocated from memory. The copied stack portion may maintain the same representation in the chunk as on the thread stack to minimize processing overhead of the operation. When the continuation resumes, the continuation stack, or some portion thereof, is copied from the chunk to the thread stack. During execution, the continuation stack that was copied may be modified on the thread stack. When the continuation yields again, the runtime environment may determine, based at least in part on whether the first object in memory is subject to a garbage collection barrier, whether to copy the modified portion of the continuation stack to the existing chunk or to allocate a new chunk.

Fast modern interconnects may be exploited to control when garbage collection is performed on the nodes (e.g., virtual machines, such as JVMs) of a distributed system in which the individual processes communicate with each other and in which the heap memory is not shared. A garbage collection coordination mechanism (a coordinator implemented by a dedicated process on a single node or distributed across the nodes) may obtain or receive state information from each of the nodes and apply one of multiple supported garbage collection coordination policies to reduce the impact of garbage collection pauses, dependent on that information. For example, if the information indicates that a node is about to collect, the coordinator may trigger a collection on all of the other nodes (e.g., synchronizing collection pauses for batch-mode applications where throughput is important) or may steer requests to other nodes (e.g., for interactive applications where request latencies are important).