Abstract: One embodiment provides a method for recovery from failures during garbage collection processing in a system including recording, by a processor, a specific offset within a garbage collection target slot of a log structure associated with a garbage collection transaction. Each transaction record of the garbage collection transaction includes a garbage collection target slot, a victim slot and a beginning offset in the garbage collection target slot.

Abstract: A method, information processing system, and computer readable storage medium, vary a maximum heap memory size for one application of a plurality of applications based on monitoring garbage collection activity levels for the plurality of applications, each application including a heap memory, and unused memory in the heap memory being reclaimed by a garbage collector.

Abstract: Embodiments are directed towards managing memory for an application be executing in a managed runtime environment. Managed peer objects may be generated to correspond to native objects executing in a native runtime environment such that memory may be allocated for managed peer objects. Garbage collection handles may be generated and associated with the managed peer objects. If the managed application executes instructions that interact with the managed peer objects and the native runtime environment each garbage collection handle associated with the managed peer objects may be modified based on a type of an interaction. The garbage collection handlers may be garbage collection roots for a garbage collector that may be included in the managed runtime memory manager. If a garbage collection event occurs, memory for the managed peer objects may be deallocated based in part on its correspondent garbage collection handle.

Abstract: A method comprises creating a first node, determining whether an indicator associated with a head node is present, and designating the first node as a head node, defining and associating a head node identifier with the first node, define a link from the first node to the first node, and create and save an indicator associated with the head node responsive to determining that the indicator associated with a head node is not present.

Abstract: The subject disclosure relates to analyzing memory allocations for one or more computer-implemented processes. In particular, in conjunction with employing tags for tracking memory allocation commands, currently allocated memory can be examined for various characteristics of inefficient memory use. For example, as memory is initially allocated, a predetermined bit pattern can be written to the newly allocated memory. Thus, detection of the predetermined bit pattern can be indicative of wasted memory use. Moreover, additional features can be provided to both analyze data and present views associated with that analysis relating to identification of memory fragmentation, over-allocation, sparse memory use, duplication of allocations, multiple module loads, and so forth.

Abstract: A method to schedule garbage collection operations may be executed in a client/server system using multiple servers. The method includes comparing usage of memory in respective ones of the plurality of servers to one or more memory usage thresholds and dynamically identifying one or more servers in which to perform garbage collection of memory objects during a particular time period. By distributing the durations over which garbage collection is performed on respective servers, the client server system, among other things, reduces the pauses in servicing client requests.

Abstract: A method for managing memory, comprising: maintaining a strong reference count for a first object; establishing a first reference from the first object to a second object; establishing a second reference from the second object to the first object, wherein the second reference is a weak reference that does not increase the strong reference count of the first object; detecting that the strong reference count of the first object has reached zero; in response to detecting that the strong reference count has reached zero, invoking a corresponding action.

Abstract: A garbage collection process performs garbage collection operations in an object-based memory system associated with a processing environment. The garbage collection process receives, at a first garbage collection unit, object references derived from root data from a processor associated with the first garbage collection unit. In addition, the garbage collection process processes, at the first garbage collection unit, the root data received from the processor associated with the first garbage collection unit. The garbage collection process also determines which object references derived from the root data are associated with a second garbage collection unit. Upon determining that an object reference is associated with a second garbage collection unit, the garbage collection process communicates information representative of the object reference to the second garbage collection unit associated with the object reference.

Abstract: At least one region of a heap that includes memory allocations is analyzed, using age and occupancy criteria, across a number of local garbage collection cycles using a processor executing a region-based garbage collector. Based upon the analyzed age and occupancy criteria of the at least one region, at least one stable region in age and occupancy is identified among the at least one region of the heap across the number of local garbage collection cycles. Maintenance of a remembered set (RS) of external references into the at least one stable region is temporarily stopped for each identified stable region during at least one additional local garbage collection cycle.

Abstract: The present invention is directed toward methods and systems for data de-duplication. More particularly, in various embodiments, the present invention provides systems and methods for data de-duplication that may utilize storage reclamation. In various embodiments, data de-duplication may be performed using data storage reclamation by reconciling a list of all active tags against a list of all tags present within the object store itself. Any tags found to be in the object store that have no corresponding active usage may then be deleted. In some embodiments additional steps may be taken to avoid race conditions in deleting tags that are needed by incoming data. In some embodiments the object store may request the lists. In other embodiments, a runtime list, in which each new tag is entered as they are returned from the object store. In another embodiment the object store may maintain this list directly.

Abstract: A system for processing information relating to a vehicle includes one or more electronic control units which can be connected to one another through a vehicle network. The system includes an electronic control device adapted to interface to and exchange data with the network and a nomadic device adapted to exchange data with the electronic device, wherein the electronic control device includes an automatic configuration module adapted to automatically detect parameters of the network so as to retrieve a network database of the vehicle. The network database includes the information required for properly interpreting the data circulating in the network.

Abstract: A method, system and computer program product for caching socket connections while ensuring that there are file descriptors available for the applications. File descriptor references and their referenced objects are stored in a predefined memory region of the heap (“file descriptor heap”). Each time a socket connection is cached, a file descriptor reference may be created to be associated with the socket connection's file descriptor, where the file descriptor reference references the object of the cached socket connection. In order to ensure that there are available file descriptors for the applications, the file descriptor references and their referenced objects are collected by the garbage collector in response to various events (e.g., too many file descriptors are open) thereby freeing the file descriptors that were previously associated with the collected connection objects to be used by the applications.

Abstract: A system and method for efficient garbage collection. A general-purpose central processing unit (CPU) partitions an allocated heap according to a generational garbage collection technique. The generations are partitioned into fixed size cards. The CPU marks indications of qualified dirty cards during application execution since the last garbage collection. When the CPU detects a next garbage collection start condition is satisfied, the CPU sends a notification to a special processing unit (SPU) corresponding to a determination of one or more card root addresses, each card root address corresponding to one of said marked indications. The SPU has a single instruction multiple data (SIMD) parallel architecture and may be a graphics processing unit (GPU). The SPU may utilize the parallel architecture of its SIMD core to simultaneously compute multiple card root addresses. Following, the SPU sends these addresses to the CPU to be used in a garbage collection algorithm.

Abstract: A method, system and computer program product for reducing garbage collection pause time. According to example embodiments, a garbage collection cycle is initiated on a set of objects that have been dynamically allocated in a memory. An identification is made of new persistent objects and reachable non-persistent objects while ignoring old persistent objects that have been identified as persistent in previous garbage collection cycles. The new persistent objects are associated as members of a set of persistent objects that includes the old persistent objects. The persistence information for the set of persistent objects is preserved for use during subsequent garbage collection cycles. All reachable non-persistent objects and all persistent objects in the set of persistent objects are marked for memory reclamation phase processing.

Abstract: A consistent snapshot of a large main memory knowledge base is saved to persistent storage without blocking the application for the duration of serializing and writing the knowledge base. Taking the snapshot comprises bringing the knowledge base to a consistent state (in a multithreaded application), using virtual memory facilities to obtain a copy-on-write copy of the knowledge base in memory, and using a separate thread or process to serialize the copy-on-write copy to persistent storage.

Abstract: The present invention provides techniques that allow concurrent collection of cyclic garbage on reference counting systems. In general, candidate objects are found that may be part of cyclic garbage. Each candidate object has a reference count. Two tests are performed to determine if concurrent operations have affected the reference counts of the candidate objects. If concurrent operations have not affected the reference counts, the candidate objects are collected as garbage. Additionally, during garbage collection, the decrements to reference counts are delayed so that increments occur before decrements and so that decrements are held a predetermined time before being applied. This prevents decrementing a reference and collecting a cycle as garbage right before a reference is added to an object in the cycle.

Abstract: A method and apparatus for interfacing a drive with a tree-structured cluster as a library for a data grid storage system is described. In one embodiment, the tree-structured cluster of cache nodes is provided for storing data. The cluster is mounted as a drive or file system based on data stored in the cache nodes transparent to anyone using the drive or file system. A file system interface interfaces with the tree-structure cluster of cache nodes to presents data stored in the cache nodes.

Abstract: The number of CPU cycles required to reclaim object memory space in a memory management process is reduced by using a two phase approach. A data structure exists for each object that is to be loaded into object memory space. One part of the data structure is the object definition. The other part is a MM (Memory Management) immunity annotation or value that controls the frequency with which the object must actually be examined to determine if it is suitable for reclamation. On each iteration of the memory management process, the object's MM immunity value is tested to determine whether it is greater than a predetermined threshold. If greater than the threshold, the value is decremented, but the object is not actually examined for its suitability for removal. If the value equals the threshold, the object itself is examined.

Abstract: The present invention provides techniques that allow concurrent collection of cyclic garbage on reference counting systems. In general, candidate objects are found that may be part of cyclic garbage. Each candidate object has a reference count. Two tests are performed to determine if concurrent operations have affected the reference counts of the candidate objects. If concurrent operations have not affected the reference counts, the candidate objects are collected as garbage. Additionally, during garbage collection, the decrements to reference counts are delayed so that increments occur before decrements and so that decrements are held a predetermined time before being applied. This prevents decrementing a reference and collecting a cycle as garbage right before a reference is added to an object in the cycle.

Abstract: A method for performing garbage collection involves obtaining a first reference bitmap including a block address and a set of mark bits, obtaining a first reference, identifying a mark bit of the set of mark bits based on the first reference, comparing an address associated with the mark bit with the first reference to generate a comparison, selecting an existing word from a global bit map based on the block address and the comparison, calculating a new word based on the set of mark bits and the existing word, replacing the existing word in the global bit map with the new word, and reclaiming a block of memory for reuse based on the global bit map after replacing the existing word.

Abstract: A garbage collection algorithm that achieves hierarchical copy order with parallel garbage collection threads. More specifically, the present invention provides a garbage collection method and system for copying objects from a from-space to a to-space. The method comprises the steps of (a) having multiple threads that simultaneously perform work for garbage collection (GC), (b) examining the placement of objects on blocks, and (c) changing the placement of objects on blocks based on step (b). Preferably, the method includes the additional step of calculating a placement of object(s) based on step (b), and using the result of the calculation for step (c). For example, the calculation may be used to increase the frequency of intra-block pointers and/or to increase the frequency of siblings on the same block.

Abstract: Architecture that automatically breaks the circular reference between objects without any different logic by introducing a helper object called a child object container. The child object is contained within the container object and both share a reference counter. The parent object holds a strong reference to the container object. When adding a reference to the child object both the shared reference counter and the parent reference counter increase. When releasing a reference to the child object both the shared reference counter and the parent reference counter decrease. This approach provides a systematic way of solving the circular reference problem that does not rely on any weak-reference feature provided by the programming language.

Abstract: One embodiment of the present invention provides a memory-management system that supports both address-referenced objects and identifier-referenced objects, wherein an address-referenced object is accessed through a reference containing an address of the object, and wherein an identifier-referenced object is accessed through a reference containing an object identifier (OID) for the object. During operation, the system receives a request to access an object. Next, the system determines if the object is an address-referenced object or an identifier-referenced object. If the object is an address-referenced object, the system accesses the object using the associated address for the object. If the object is an identifier-referenced object, the system accesses the object by using the associated OID for the object to look up the address for the object, and then using the address to access the object.