Abstract: The present disclosure describes techniques for offloading data processing and knowledge synthesis. A set of flags may indicate information about the memory pages in a first memory and may be manageable by at least one central processing unit (CPU). A memory page may be flushed to a second memory if the memory page is associated with a first flag. The first flag may indicate that the memory page is ready to be flushed to the second memory. The second memory may be configured to store a sequence of states of each of the memory pages. Data patterns and relations among the data patterns may be determined by data processing units (DPUs) based on the sequence of states of each of the memory pages. A knowledge base may be built in a third memory based on the data patterns and the relations among the data patterns.

Abstract: One example method includes scanning, at a cloud storage site, metadata associated with an object stored at the cloud storage site, fetching, from the metadata, an object creation time for the object, and determining whether the object is out of a minimum storage duration. When the object is out of the minimum storage duration, it is copy-forwarded and then marked for deletion, and when the object is not out of the minimum storage duration, the object is deselected from a list of objects to be copied forward.

Abstract: A system, method, and machine-readable storage medium for performing garbage collection in a distributed storage system are provided. In some embodiments, an efficiency level of a garbage collection process is monitored. The garbage collection process may include removal of one or more data blocks of a set of data blocks that is referenced by a set of content identifiers. The set of slice services and the set of data blocks may reside in a cluster, and a set of probabilistic filters (e.g., Bloom filters) may indicate whether the set of data blocks is in-use. At least one parameter of a probabilistic filter of the set of probabilistic filters may be adjusted (e.g., increased or reduced) if the efficiency level is below the efficiency threshold. Garbage collection may be performed on the set of data blocks in accordance with the set of probabilistic filters.

Abstract: Techniques for on-the-fly adaptation of remembered set data structures are disclosed. Operations include initiating execution of an application thread and a garbage collection process for a heap memory including a first plurality of logical partitions, wherein each logical partition of the first plurality of logical partitions is associated with a remembered set data structure. While the application thread and the garbage collection process are executing, the system determines a set of characteristics. Based on the set of characteristics meeting threshold criteria for adjusting a first remembered set data structure corresponding to a first logical partition, the system identifies a first remembered set configuration corresponding to the first remembered set data structure, creates a replacement remembered set data structure based on the first remembered set configuration, and associates the replacement remembered set data structure with the first logical partition.

Abstract: Techniques are disclosed for interposing on nondeterministic events during multicore virtual machine (VM) execution to capture information that allows for deterministically recreating the nondeterministic events during execution replay of the VM. A method may include reading, by a virtual processor running within a multicore VM instance, an instruction to execute, and, responsive to a determination that the instruction is a nondeterministic instruction, interposing on the nondeterministic instruction execution so as to allow deterministic execution of the nondeterministic instruction during replay execution of the multicore VM instance. Interposing on the nondeterministic instruction execution may include recording a partial barrier event and/or a full barrier event. The nondeterministic instruction may be a read memory access instruction or a write memory access instruction.

Abstract: During execution of garbage collection, an application receives a first request to overwrite a reference field of an object, the object comprising a first reference and the first request comprising a memory address at which the reference field is stored, and a second reference to be written to the reference field. Responsive to receiving the first request, the system determines a current remembered set phase, and loads the first reference. The application determines that remembered set metadata of the first reference does not match the current remembered set phase. Responsive to that determination, the application adds an entry to a remembered set data structure, modifies the second reference to include the current remembered set phase as the remembered set metadata, and stores the modified second reference to the reference field. In subsequent writes to the reference field, the application refrains from adding to the remembered set data structure.

Abstract: A method, apparatus and computer program product for providing page-protection based memory access barrier traps is presented. A value for a user-mode bit (u-bit) is computed for each extant virtual page in an address space, the u-bit indicative that an object on the virtual page is being moved by a Garbage Collector process. An instruction is executed which causes an access protection fault. The state of the u-bit for the virtual page associated with the access protection fault is consulted when the access protection fault is encountered. Additionally, the access protection fault is translated into a user-trap (utrap) and the utrap is serviced when the u-bit is set.

Abstract: A storage system for storage of data written from a computer, and when a write request of data to a first logical volume is received, the data on request is stored into the first logical volume. When a first-generation snapshot creation request is received, the data stored in the first logical volume at the time of receiving the first-generation snapshot creation request is written into a pool region as data corresponding to a first-generation snapshot, and when a second-generation snapshot creation request is received, any portion of the data updated after the first-generation snapshot creation request is received but before the second-generation snapshot creation request is issued is read from the first logical volume for writing into the pool region. Such a storage system favorably implements snapshot backup with no dependency with a positive volume in terms of performance and failure, and with high capacity efficiency.

Abstract: Automatic memory management with a generational copy collector garbage collection algorithm running on parallel threads to perform simultaneous and independent copying and scanning. An object is scanned. It is determined whether an object referenced within the slot of the object being scanned may be copied to the same generation as the scanned object. A mark may be made to indicate that the referenced object may be copied to a different generation than the scanned object. The mark defers the copying of the referenced object.

Abstract: The invention provides a flash storage device. In one embodiment, the flash storage device comprises a flash memory and a controller. The flash memory comprises a plurality of storage units for data storage, wherein the total capacity of each of the storage units is equal to a storage unit capacity. When the flash storage device receives a read capacity command from a host, the controller determines the size of a logical block to be a specific multiple of the storage unit capacity, and sends information about the logical block size to the host in response to the read capacity command, wherein the specific multiple is a natural number. After the host receives the information from the flash storage device, the host retrieves the logical block size from the information, and sends only write data with an amount equal to a multiple of the logical block size to the flash storage device.

Abstract: The present disclosure describes garbage collection that provides prompt reclamation of large objects. A heap space is divided into Young regions, Old regions, and Humongous regions. A remembered set is created and maintained, during the execution of one or more programs, for each region that specifies where there are references from outside the region to inside the region. A garbage collection list is generated specifying regions to perform garbage collection on. All Young regions and at least one Humongous region are included in the garbage collection list. If it is determined to include Old regions, the Old regions are selected and included in the garbage collection list. Then, a garbage collection is performed on the regions specified in the garbage collection list. During the garbage collection, the indication for each region is utilized to determine reachable objects in the region, ensuring that reachable objects are not deallocated.

Abstract: Systems and methods for memory management in a computing environment are provided. The method comprises uniquely identifying a first object associated with a first task for an application executed in a computing environment, wherein a first area of memory is allocated to the first object; determining a first execution scope for the first task according to a first execution context associated with the first task, wherein the first context defines a first life expectancy for the first task within the execution environment hierarchy; determining a change in execution scope of the first task, in response to monitoring the first execution context; and deallocating the first area of memory, in response to determining that the first task is no longer executed within the first execution scope.

Abstract: Techniques for memory management or analysis with conservative garbage collectors is provided. The native stack is analyzed during runtime to identify within frames references to objects in the heap space. An amount of memory is calculated that represents the memory implicated by the reference. A log can be generated that conveys the frame, location of the reference in the frame and amount of memory implicated by the reference.

Abstract: A method and system for garbage collecting managed and unmanaged memory that is no longer referenced. The time between allocations is compared with a threshold to determine if the garbage collector needs to collect unused memory. Unmanaged memory referenced by objects in the unused managed memory may be freed during the collection.

Abstract: A system and method for asynchronously graying and blackening objects in the marking phase of parallel garbage collection. The system and method use a matrix to control a series of linked list of work to be grayed and blackened. The threads of the garbage collector are each assigned entries within the matrix upon which they may either gray an entry in the linked list or blacken and entry on the linked list. Further restrictions upon the use of the matrix allow non-garbage collection thread to asynchronously or synchronously add objects to be processed by the garbage collector.

Abstract: Mechanisms for memory management in a scoped memory system are provided. The scoped memory system includes a scoped memory area for the allocation of objects therein for access by one or more software threads in execution. The scoped memory area has an associated thread count for indicating that the scoped memory area is discardable. The mechanisms identify a set of root references for objects allocated in the scoped memory area and recursively traverses and marks objects that are referenced from the set of root references and that are allocated in the scoped memory area. The mechanisms further identify objects in the scoped memory area that are not so marked and discards the identified objects.