A method includes receiving data objects, determining a predicted lifespan of each data object, and instantiating multiple shard files. Each shard file has an associated predicted lifespan range. The method also includes writing each data object into a corresponding shard file having the associated predicted lifespan range that includes the predicted lifespan of the respective data object and storing the shard files in a distributed system. The method also includes determining whether any stored shard files satisfy a compaction criteria based on a number of deleted data objects in each corresponding stored shard file. For each stored shard file satisfying the compaction criteria, the method also includes compacting the stored shard file by rewriting the remaining data objects of the stored shard file into a new shard file.

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.

Controlling garbage collection operations. The method includes setting up garbage collection to collect objects that are no longer in use in a managed code environment. The method further includes receiving managed code input specifying a desired quantum within which it is desired that garbage collection not be performed. The method further includes performing a computing operation to determine the desired quantum can likely be met. The method further includes running memory operations within the quantum without running the initialized garbage collection.

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.

In some examples, a plurality of nodes may each host a respective logical database (LDB) that includes database data that references external resources stored in a storage system. Further, each node may maintain, for each external resource referenced by the respective LDB on that node, a reference count of a number of references in the respective LDB to each external resource and a timestamp associated with the reference count. In response to addition of a reference to a particular external resource in a particular LDB, a node that hosts the particular LDB may be programmed to increment the reference count and update the timestamp for the particular external resource. Similarly, in response to removal of the reference to the particular external resource in the particular LDB, the node hosting the particular LDB is programmed to decrement the reference count and update the timestamp for the particular external resource.

Methods for enabling automatic reference counting are disclosed. A source code is searched for a particular pattern via a compiler associated with a computer system, wherein the source code is written in an existing language and wherein the particular pattern is for a reference associating an object with a portion of memory. The particular pattern is recognized at the computer system. The particular pattern is replaced with an automatic reference counting implementation at the computer system. The source code is executed with the automatic reference counting implementation.

A process for reducing amount of transmission of data to/from an external storage is performed in a computer. The process includes: storing a plurality of data sets by deduplicating a plurality in the external storage, wherein two or more data sets selected in order generated are collected in an object; determining necessity/unnecessity of defragmentation in units of object group in which two or more objects are collected in order generated; when determining to execute defragmentation, executing first defragmentation processing of acquiring all of the objects included in the object group as first objects from the external storage, combining valid data set having a number of references of 1 or more included in the first objects based on the order generated and the number of references to regenerate one or more second object, and storing the second object in place of the first objects in the external storage.

Described are methods, systems and computer readable media for performance logging of complex query operations.

Technologies for reducing duplication of stored data include storing, by a controller of an apparatus, a first data sub-block of a plurality of data sub-blocks of a data block in a memory at a first physical address. The technologies additionally include storing, by the controller, a pointer in a pointer table. The pointer points to the first physical address. The technologies also include determining, by the controller, whether a second data sub-block of the plurality of data sub-blocks is a duplicate of the first data sub-block, and storing, by the controller in response to a determination that the second data sub-block is a duplicate of the first data sub-block, a second pointer in the pointer table. The second pointer points to the first physical address.

Technical solutions are described to implement a scalable write ahead log using a distributed file system. A general aspect includes a method for providing consistency among metadata replicas and content in an enterprise content management cluster. The method includes recording a transaction log entry in response to receiving a content modification request, the transaction log entry including a version identifier set to a first version value. The method also includes updating the transaction log entry to a second version value in response to successfully modifying content and one of a plurality of metadata replicas containing metadata corresponding to the request. The method also includes updating the transaction log entry to a third version value in response to successfully modifying each of the metadata replicas. The present document further describes examples of other aspects such as methods, computer products.