Abstract: Methods and systems for a storage environment are provided. One method includes identifying, by a processor, a plurality of block numbers of a fragmented address space for re-allocation, each block number associated with data stored by a file system in a storage device of a storage system; determining, by the processor, compressed data associated with a block number from among the plurality of block numbers; verifying, by the processor, that an indirect block of a hierarchical structure maintained by the file system references the block number associated with the compressed data; and copying, by the processor, the compressed data to a new block, without decompressing the data.

Abstract: A streaming multiprocessor (SM) included within a parallel processing unit (PPU) is configured to suspend a thread group executing on the SM and to save the operating state of the suspended thread group. A load-store unit (LSU) within the SM re-maps local memory associated with the thread group to a location in global memory. Subsequently, the SM may re-launch the suspended thread group. The LSU may then perform local memory access operations on behalf of the re-launched thread group with the re-mapped local memory that resides in global memory.

Abstract: Methods and systems for provisioning persistent storage are disclosed. For example, a new isolated guest and associated persistent storage volume are requested to be created. The isolated guest is based on an image file in an image repository and is associated with metadata. An orchestrator obtains the image file. The orchestrator reserves the persistent storage volume by updating the system resource allocation database based on the metadata. The persistent storage volume is then created in the persistent storage based on the reservation of the persistent storage volume in the system resource allocation database. The orchestrator activates the constructed isolated guest and the isolated guest accesses the persistent storage volume.

Abstract: A memory heap is allocated to a contiguous range of memory. One end of the heap is designated as a small object area. The other end of the heap is designated as a large object area. When the two object areas grow, the small object area grows inward within the heap toward the large object area, and the large object area grows inward within the heap toward the small object area.

Abstract: A method of managing backup data. The method includes accessing, via a backup manager, index data of an initial snapshot and accessing, via the backup manager, index data of a subsequent snapshot. The method further includes determining, via the backup manager, whether the index data of the subsequent snapshot is different from the index data of the initial snapshot. Responsive to a determination that the index data of the subsequent snapshot is different from the index data of the initial snapshot, creating an updated index data and creating an updated snapshot with the updated index data.

Abstract: An apparatus, system, and method are disclosed for data block usage information synchronization for a non-volatile storage volume. The method includes referencing first data block usage information for data blocks of a non-volatile storage volume managed by a storage manager. The first data block usage information is maintained by the storage manager. The method also includes synchronizing second data block usage information managed by a storage controller with the first data block usage information maintained by the storage manager. The storage manager maintains the first data block usage information separate from second data block usage information managed by the storage controller.

Abstract: Systems and methods are provided for large-scale, incrementing clustering. A plurality of processing nodes each include a processor and a non-transitory computer readable medium. The non-transitory computer readable medium stores a plurality of clusters of feature vectors and machine executable instructions for determining a plurality of values for a distance metric relating each of the plurality of clusters to an input feature vector and selecting a cluster having a best value for the distance metric. An arbitrator is configured to receive the selected cluster and best value for the distance metric from each of the plurality of processing nodes and determine a winning cluster as one of the selected clusters and a new cluster. A multiplexer is configured to receive the winning cluster and provide the winning cluster and a new input feature vector to each of the plurality of processing nodes.

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 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 system and method for performing garbage collection. A system includes a storage medium, a first table including entries which map a virtual address to locations in the storage medium, and a second table with entries which include a reverse mapping of a physical address in a data storage medium to one or more virtual addresses. A storage controller is configured to perform garbage collection. During garbage collection, the controller is configured to identify one or more entries in the second table which correspond to a segment to be garbage collected. In response to determining the first table includes a valid mapping for a virtual address included in an entry of the one of the one or more entries, the controller is configured to copy data from a first location identified in the entry to a second location in the data storage medium, and reclaim the first storage location.

Abstract: A CPU perform the steps of: (a) causing a compression/decompression processor to decompress the compressed data of one of three bands in the data area except for the first block in the band, and storing decompressed bitmap data in the data area; (b) rasterizing each of the intermediate data blocks in the band and synthesizing the rasterized data and the decompressed bitmap data in the band; and (c) causing the compression/decompression processor to compress the synthesized bitmap data and storing the compressed data in the data area. The CPU performs the steps (a) to (c) in different respective tasks in parallel, and performs the steps (a) to (c) along the order of (a), (b), (c) for each of the intermediate code blocks in each of the bands while using the 1st to the 3rd bitmap data area in turn for each of the steps (a) to (c).

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.

Abstract: One or more embodiments are directed to creating a structure comprising a weak reference to an object, a strong reference to the object, a count of remote references to the object, and an identifier for the object, incrementing the count when a remote reference is created to the object and decrementing the count when a remote reference is removed, setting the strong reference in response to the count being greater than a first threshold in order to avoid a garbage collection of the object, clearing the strong reference in response to the count being less than a second threshold to enable a garbage collection of the object, and removing the structure and related resources based on a recognition of the object's collection through the weak reference.

Abstract: A technique for incrementally unloading classes using a region-based garbage collector is described. One aspect of such a technique includes maintaining a remembered set for a class set. The remembered set indicates whether instances of the class set are contained in one or more regions in memory, and in which regions the instances are contained. Upon performing an incremental garbage collection process for a subset of the regions in memory, the technique examines the remembered set to determine whether the class set includes instances in regions outside of the subset. If the remembered set indicates that the class set includes instances outside of the subset of regions, the technique identifies the class set as “live.” This will preclude unloading the class set from the subset of regions.

Abstract: A technique for incrementally unloading classes using a region-based garbage collector is described. One aspect of such a technique includes maintaining a remembered set for a class set. The remembered set indicates whether instances of the class set are contained in one or more regions in memory, and in which regions the instances are contained. Upon performing an incremental garbage collection process for a subset of the regions in memory, the technique examines the remembered set to determine whether the class set includes instances in regions outside of the subset. If the remembered set indicates that the class set includes instances outside of the subset of regions, the technique identifies the class set as “live.” This will preclude unloading the class set from the subset of regions.

Abstract: A method for managing an object watchpoint during a garbage collection cycle, including identifying an object having a field, where the object is associated with an original object location, where the field is associated with an original field location, and where the object and the field are located in a memory heap of a virtual machine memory, setting, within a debugger, the object watchpoint on the original field location, where the object watchpoint is a memory trap associated with the object, determining, after a relocation of the object by a garbage collector (GC), a new object location associated with the object, determining a new field location of the field based on the new object location, and setting, within the debugger, the object watchpoint on the new field location.

Abstract: A technique for incrementally unloading classes using a region-based garbage collector is described. One aspect of such a technique includes maintaining a remembered set for a class set. The remembered set indicates whether instances of the class set are contained in one or more regions in memory, and in which regions the instances are contained. Upon performing an incremental garbage collection process for a subset of the regions in memory, the technique examines the remembered set to determine whether the class set includes instances in regions outside of the subset. If the remembered set indicates that the class set includes instances outside of the subset of regions, the technique identifies the class set as “live.” This will preclude unloading the class set from the subset of regions.

Abstract: Systems and methods are provided for performing incremental garbage collection for non-volatile memories (“NVMs”), such as flash memory. In some embodiments, an electronic device including the NVM may perform incremental garbage collection to free up and erase a programmed block of the NVM. The programmed block may include valid data and invalid data, and the electronic device may be configured to copy the valid data from the programmed block to an erased block in portions. In between programming each portion of the valid data to the erased block, the electronic device can program host data to the erased block. This way, the electronic device can stagger the garbage collection operations and prevent a user from having to experience one long garbage collection operation.

Abstract: Disclosed are apparatus and methods for reporting garbage collection operations. A virtual machine that is executable on a computing device can receive a request to be informed prior to execution of garbage collection software on the computing device via a prior up-call. The virtual machine can receive a request to be informed upon completion of execution of the garbage collection software on the computing device via a post up-call. Prior to the execution of the garbage collection software, the virtual machine can initiate execution of the prior up-call to indicate the garbage collection software is to be executed. After the garbage collection software has completed execution, the virtual machine can initiate execution of the post up-call to indicate the garbage collection software has completed execution.

Abstract: Techniques to perform garbage collection in an environment where more than one software programming language is in use are described. A technique may include creating a managed proxy object in one language that creates an unmanaged object in memory in a different language. A collection of nodes is generated and maintained, where a node comprises: a reference to the managed proxy object, and a reference to the unmanaged object. A count of the nodes in the collection is maintained. When the count exceeds a threshold, the collection is traversed, and garbage collection is performed on any unmanaged object in a node when the managed proxy object in the same node has been collected. Other embodiments are described and claimed.

Abstract: Prefetching data using a piecemeal list prefetching method. This is achieved by various means, including building a plurality of data pages, sorting the plurality of data pages into sequential data pages and a list of non-sequential pages, prefetching the sequential data pages using a first prefetching technique, and prefetching the non-sequential list of data pages using a second prefetching technique.

Abstract: Improved backup and storage operations are disclosed for virtual computing environments using a backup proxy server to perform storage operations on one or more virtual machine disks. The proxy server can include a module that intercepts application programming interface (API) calls, for writing backup data to a first location, prior to the data arriving on the proxy disk. During the intercept process, the data can be compressed in memory pages of the proxy server and redirected to an alternative backup disk location. The proxy server can also include a differential engine that identifies changes to the virtual machine disk at the block level since the last full backup. The differential engine can advantageously leverage memory pages of the proxy server to compare differences between signatures of blocks of the last full backup with signatures of new blocks. Subsequently, only blocks with non-matching signatures are processed for backup.

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: One embodiment of the present invention provides a system that uses versioned pointers to facilitate reusing memory without having to reclaim the objects solely through garbage collection. The system operates by first receiving a request to allocate an object. Next, the system obtains the object from a pool of free objects, and sets an allocated/free flag in the object to indicate that the object is allocated. The system also increments a version number in the object, and also encodes the version number into a pointer for the object. The system then returns the pointer, which includes the encoded version number. In this way, subsequent accesses to the object through the pointer can compare the version number encoded in the pointer with the version number in the object to determine whether the object has been reused since the pointer was generated.

Abstract: A method, apparatus and computer program product for providing removal of replicated objects based on garbage collection is presented. Data objects are replicated from a primary source to a backup device. A notification is received from a garbage collection process for at least one data object replicated from the primary source to the backup device, the notification indicating that the data object should be deleted. The data object having the notification is deleted from the backup destination.

Abstract: An apparatus, system, and method are disclosed for managing data with an empty data segment directive at the requesting device. The apparatus, system, and method include a token directive generation module and a token directive transmission module. The token directive generation module generates a storage request with a token directive. The token directive includes a request to store on the storage device a data segment token. The token directive substitutes for a series of repeated, identical characters or a series of repeated, identical character strings to be stored as a data segment. The token directive includes at least a data segment identifier and a data segment length. The data segment token and the token directive are substantially free from data of the data segment. The token directive transmission module transmits the token directive to the storage device.

Abstract: The present invention provides a system and method for flexible space reservations in a file system. An administrator of a storage system selects a fractional reserve percentage, which defines the size of the overwrite reserve that is to be maintained to ensure file writeability.

Abstract: Per thread garbage collection is disclosed. Objects associated only with a thread that created them are tracked. At a garbage collection time for a particular thread, it is determined which objects associated only with that thread remain reachable from a restricted root set associated with the thread. Any thread-only objects that are not determined to be reachable are garbage collected.

Abstract: A method for incrementally unloading classes using a region-based garbage collector is described. In one embodiment, such a method includes maintaining a remembered set for a class set. The remembered set indicates whether instances of the class set are contained in one or more regions in memory, and in which regions the instances are contained. Upon performing an incremental garbage collection process for a subset of the regions in memory, the method examines the remembered set to determine whether the class set includes instances in regions outside of the subset. If the remembered set indicates that the class set includes instances outside of the subset of regions, the method identifies the class set as “live.” This will preclude unloading the class set from the subset of regions. A corresponding computer program product and apparatus are also disclosed herein.

Abstract: A method for incrementally unloading classes using a region-based garbage collector is described. In one embodiment, such a method includes maintaining a remembered set for a class set. The remembered set indicates whether instances of the class set are contained in one or more regions in memory, and in which regions the instances are contained. Upon performing an incremental garbage collection process for a subset of the regions in memory, the method examines the remembered set to determine whether the class set includes instances in regions outside of the subset. If the remembered set indicates that the class set includes instances outside of the subset of regions, the method identifies the class set as “live.” This will preclude unloading the class set from the subset of regions. A corresponding computer program product and apparatus are also disclosed herein.

Abstract: A method for garbage collection in which resources used by data objects in a computer program that are not accessed in the future are reclaimed, the method consists of the following steps of 1. Providing a tracing garbage collector which is both parallelized and incremental; 2. Integrating the collector with the computer program to create the mutator; 3. Instructing the mutator to scan and collect resources used by data objects in a computer program that are not accessed in the future simultaneously on all threads in small amounts; and 4. Interleaving the mutator scanning and collection with unrelated processing by the computer program such that all of the threads in the application are never stopped simultaneously for any portion of the collection cycle.

Abstract: In accordance with exemplary embodiments, a scalable and parallel garbage collection system for incremental backups with data de-duplication may be implemented with a memory and a processor. The memory may store a changed list at a current time, a before-image list including previous versions of the first overwrite at a current time for each of a plurality of overwritten physical blocks in said storage system, a garbage collection related change list and a recycle list. With these lists configured in the memory, the processor limits the garbage collection to incremental changes and distributes garbage collection tasks to a plurality of participating nodes. For garbage collection, each physical block may associate with an expiration time and a reference count. When the reference count drops to zero, the physical blocks are recycled based on the expiration time.

Abstract: Tracking resource use includes determining when the resource is allocated, determining when the resource is first used, determining when the resource is last used, and determining when the resource is deallocated. The resource may be a software object. Deallocating the resource may be performed automatically by a run time system when there are no remaining references to the object in run time code or variables. Deallocating the resource may include at least one of: setting a flag for the resource and adding an identifier for the resource to a list of resources to be deallocated. Time measurements may correspond to a count of garbage collection cycles. Tracking resource use may also include determining additional resource usage metrics.

Abstract: One embodiment of the present invention provides a system that uses versioned pointers to facilitate reusing memory without having to reclaim the objects solely through garbage collection. The system operates by first receiving a request to allocate an object. Next, the system obtains the object from a pool of free objects, and sets an allocated/free flag within the object to indicate that the object is allocated. The system also increments a version number within the object, and also encodes the version number into a pointer for the object. The system then returns the pointer, which includes the encoded version number. In this way, subsequent accesses to the object through the pointer can compare the version number encoded in the pointer with the version number within the object to determine whether the object has been reused since the pointer was generated.

Abstract: Described is a technology by which a real-time data relocating mechanism is provided for multiprocessing environments, including supporting lock-free programs that run in parallel. The relocating mechanism moves an object by using a status field related to the data field, possibly in an interim (wide) object space, which is then copied to a to-space object. The status information for each data field of the original object contains information indicating where a current version of the data for each field is present, that is, in the original, wide or to-space object. In one example, a handshake mechanism of a garbage collector establishes preparation and copy phases between the mechanism and other threads that determine where memory accesses occur. Also described is support for program thread compare-and-swap (CAS) operations and/or multi-word atomic operations.

Abstract: Per thread garbage collection is disclosed. Objects associated only with a thread that created them are tracked. At a garbage collection time for a particular thread, it is determined which objects associated only with that thread remain reachable from a restricted root set associated with the thread. Any thread-only objects that are not determined to be reachable are garbage collected.

Abstract: A system and associated method for optimizing a write barrier in garbage collection. The method marks a bit in a bitmap corresponding to a slot when the slot content is modified to refer to a new object. The method also logs the address of the slot when the object referred by the slot is updated. The method pops the address of the slot to clean from the log and clears the bit corresponding to the slot in the bitmap and when the object referred to by the slot is not already marked, marking said object and pushing its address to the mark stack. When the slot is located within an active object range, the method puts the address of the slot in a deferred log for a later processing.

Abstract: A system for thread local garbage collection in a virtual machine environment, comprising: a virtual machine for executing a software application; a memory space for use by the virtual machine in storing software objects and pointers as part of the software application, divided into a global heap and several thread local heaps; a heap maintaining logic that keeps the global heap and the thread local heaps in a state suitable for efficient garbage collecting; and a garbage collector that can collect the thread local heaps in parallel with only the stop-the-world pauses for the global heap.

Abstract: We explore techniques for designing nonblocking algorithms that do not require advance knowledge of the number of processes that participate, whose time complexity and space consumption both adapt to various measures, rather than being based on predefined worst-case scenarios, and that cannot be prevented from future memory reclamation by process failures. These techniques can be implemented using widely available hardware synchronization primitives. We present our techniques in the context of solutions to the well-known Collect problem. We also explain how our techniques can be exploited to achieve other results with similar properties; these include long-lived renaming and dynamic memory management for nonblocking data structures.

Abstract: Per thread garbage collection is disclosed. Objects associated only with a thread that created them are tracked. At a garbage collection time for a particular thread, it is determined which objects associated only with that thread remain reachable from a restricted root set associated with the thread. Any thread-only objects that are not determined to be reachable are garbage collected.

Abstract: A method and system for garbage collection are provided. A memory allocation request is received for an object. An object identifier is generated for the object. A first memory location is allocated to the object. A translation table is generated storing a map of the object identifier and the first memory location. A data structure is generated for the object. A mark flag is set based on the number of references of the object. Data stored in the first memory location is moved to a second memory location based upon the value of the mark flag. The data is deleted from the first memory location based upon a value of the mark flag.

Abstract: Handling garbage collection and exceptions in hardware assisted transactions. Embodiments are practiced in a computing environment including a hardware assisted transaction system. Embodiments includes acts for writing to a card table outside of a transaction; handling garbage collection compaction occurring when a hardware transaction is active by using a common global variable and instructing one or more agents to write to the common global variable any time an operation is performed which may change an object's virtual address; acts for managing a thread-local allocation context; acts for handling exceptions while in a hardware assisted transaction.

Abstract: Rectifying discrepancies between a table, from which a segment of data has been removed, and an index for the table may be deferred. Each entry in the index is sequentially analyzed to remove entries therefrom referring to any removed segment referenced in the starting location list. During this process, if a segment newly removed from the table is detected, then analysis of the index entries continues and an indicator is set that another segment has been removed. Analysis of the entries continues in a looping fashion until each entry has been assessed to determine if it makes a reference to any of the removed segments. If a query is received before rectification is complete then the query is amended by establishing search boundaries based so that the query does not produce any entries in the index referring to removed segments.

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: A system and method is provided for efficiently pinning references to the managed heap. The system and method allow for references to managed objects to be declared as pinned during a call to unmanaged code. The references are then reported as pinned to a garbage collector in response to invocation of a garbage collection service. The reference can be declared as pinned by a programmer within the source code or automatically invoked at run-time based on an unsafe condition. The garbage collection service will not move or relocate objects that are referenced by the active pinned local variables. If a garbage collection does not occur, the fact that the local variables are declared pinned is ignored.

Abstract: Solutions to a value recycling problem facilitate implementations of computer programs that may execute as multithreaded computations in multiprocessor computers, as well as implementations of related shared data structures. Some exploitations allow non-blocking, shared data structures to be implemented using standard dynamic allocation mechanisms (such as malloc and free). Some exploitations allow non-blocking, indeed even lock-free or wait-free, implementations of dynamic storage allocation for shared data structures. In some exploitations, our techniques provide a way to manage dynamically allocated memory in a non-blocking manner without depending on garbage collection. While exploitations of solutions to the value recycling problem that we propose include management of dynamic storage allocation wherein values managed and recycled tend to include values that encode pointers, they are not limited thereto.

Abstract: A system and method are provided for object age detection in garbage collection heaps. In one embodiment, ages of objects in a garbage collection heap at a first virtual machine at a server are determined by detecting a number of garbage collections each object has survived. An age is associated to each object according to the determined ages. The objects are grouped in age ranges, wherein the age ranges correspond to the determined ages. The age ranges are communicated to a second virtual machine at a client.

Abstract: A solution for handling objects in a nursery heap that includes a garbage collector monitoring engine, a size adjustor program, and/or a promotion program. The garbage collector monitoring engine can monitor occurrences of global garbage collection events performed by a global garbage collector program as well as occurrences of nursery garbage collection events performed by a nursery garbage collector. The size adjustor program can dynamically adjust a size of a nursery heap based upon programmatically deterministic events detected by the garbage collector monitoring engine. The promotion program can dynamically adjust conditions of promotion for nursery objects, wherein when additional space is needed in the nursery heap to reduce nursery garbage collection induced latency, the promotion program changes promotion criteria to ensure objects are promoted more frequently from the nursery heap.

Abstract: A system and method is provided for efficiently pinning references to the managed heap. The system and method allow for references to managed objects to be declared as pinned during a call to unmanaged code. The references are then reported as pinned to a garbage collector in response to invocation of a garbage collection service. The reference can be declared as pinned by a programmer within the source code or automatically invoked at run-time based on an unsafe condition. The garbage collection service will not move or relocate objects that are referenced by the active pinned local variables. If a garbage collection does not occur, the fact that the local variables are declared pinned is ignored.

Abstract: A near out-of-memory condition in a memory space is detected by creating softly reachable objects which are garbage collected when the memory space is becoming full. The softly reachable objects are objects that can be cleared at the discretion of the garbage collector when heap memory is running low. An agent process of an application can create soft reference objects which reference the softly reachable objects, and periodically poll the soft reference objects to determine if the softly reachable objects have been cleared. If they have been cleared, the agent reports to the application so that a graceful shutdown of the application can be initiated. A report can also be sent to a user interface or other output device. Additional information regarding the memory space can be gained by using softly reachable objects of different sizes and/or ages. Further, a wait period for the polling can be set adaptively.