International Business Machines Corporation

Michihiro Horie

Hiroshi Horii

Kazunori Ogata

Mikio Takeuchi

Kiyokuni Kawachiya

Tamiya Onodera

Tatsuhiro Chiba

Takeshi Yoshimura

Embodiments determine that a compiler option is not provided to enable an assertion for a reachable class in a target application, determine that there is no application program interface (API) being used to enable the assertion found in a reachable method in the reachable class, determine that there is no assertion being executed before an initialization of the reachable class, and remove assertion related code from the reachable class.

Removing redundant code

A computer-implemented method is provided for managing Garbage Collection (GC) safepoints. The method includes determining whether a GC safepoint for a target native method can be removed by checking a heap occupancy ratio prior to executing the target native method. The method further includes removing the GC safepoint responsive to the heap occupancy ratio prior to executing the target native method being less than a threshold occupancy amount percentage. The method also includes determining whether the GC safepoint for the target native method can be removed by checking a most recent GC pause time. The method additionally includes removing the GC safepoint responsive to the most recent GC pause time being shorter by a threshold pause time amount percentage than an execution time of the target native method.

Selective injection of GC safepoints for JNI invocations

A computer-implemented method, system, and computer program product are provided. The approach includes popping a first task from a queue of a garbage collection thread. The approach also includes identifying a second task from the popped first task, where the second task is associated with a bit of a bitmap and the bit is located at a location within the bitmap that has not yet been passed by a finger pointer. The approach also includes pushing the second task to the queue of the garbage collection thread.

Concurrent marking garbage collection with finger pointer

Garbage collection methods and systems include determining that a condition for performing concurrent marking has been met, based on object write frequency. It is determined that an opportunity for performing concurrent marking has occurred, based on a stop-the-world event. Performance of concurrent marking is delayed until a future stop-the-world event, to prevent pre-write barriers.

Reducing write barriers in snapshot-based garbage collection

A computer-implemented method is provided for reducing Compare And Swap (CAS) operations in a concurrent marking Garbage Collection (GC) process that operates on objects corresponding to a bit map of multiple blocks. The method includes finding, from among the objects, live objects that belong to a same block in the bit map from among the multiple blocks when traversing object trees of the objects for GC marking. The method further includes loading a latest value of the same block from the bitmap, updating the latest value by setting corresponding marking bits in the bit map, and updating the same block in the bit map with a single CAS operation.

Concurrent marking garbage collection

Embodiments are disclosed for a method. The method includes determining that a thief thread attempted a work steal from a garbage collection (GC) owner queue. Additionally, the method includes determining that a number of tasks in the GC owner queue meets a predetermined threshold. Further, the method includes determining that the GC owner queue comprises a heavy-weight task. The method also includes moving the heavy-weight task to a top position of the GC owner queue.

Reducing load balancing work stealing

A first object at a memory address is identified. A first index location in a bitmap that corresponds to that memory address is calculated. A bit is set at the first index location. A pointer to a child object within the first object is detected. A memory address of that child object is identified using the pointer. A second index location in the bitmap that corresponds to that memory address is calculated. A bit is set at the second index location. A bit is also set at a third index location, which is adjacent to the first index location.

Tri-color bitmap array for garbage collection

Systems and methods for processing hierarchical tasks in a garbage collection mechanism are provided. The method includes determining chunks in a task queue. Each chunk is a group of child tasks created after processing one task. The method includes popping, by an owner thread, tasks from a top side of the task queue pointed at by a chunk in a first in first out (FIFO) pop. The method also includes stealing, by a thief thread, tasks from a chunk in an opposite side of the task queue.

Garbage collection work stealing mechanism

A computer-implemented method is provided for compilation rescheduling from among four compilation levels comprising level 1, level 2, level 3, and level 4 on a parallel distributed computing framework running processes for a plurality of jobs of a virtual machine. The method bypasses a program analysis overhead that includes measuring a compiled method execution time by identifying completed compilation levels of a Just In Time compilation. The method finds a repetition of a same process in the processes for the plurality of jobs of the virtual machine from profiles by comparing main class names, virtual machine parameters, and Jar file types therein. The method applies a compilation scheduling for the same process a next time the same process runs based on a result of the checking the transition, by (i) compiling at the level 1 at least some methods for the same process responsive to the virtual machine finishing without compiling the at least some methods for the same process at the level 4 after compiling the at least some of the methods at a level in between the level 1 and the level 4, and (ii) compiling at the level 4 at least a subset of the methods earlier than an original scheduled time responsive to at least the subset of the methods compiled at the level 4 being infrequently invoked below a threshold amount.

Rescheduling JIT compilation based on jobs of parallel distributed computing framework

A computer-implemented method, system, and computer program product are provided to reduce stealing in a processor. The method includes allocating a private space for a first thread in a memory. The method also includes generating a plurality of child tasks by the first thread responsive to processing a first task. The method additionally includes storing a portion of the plurality of child tasks in the private space removing the ability of other threads from popping the portion of the plurality of child tasks, with a remainder of the plurality of child tasks being stored in a public space. The method further includes popping the portion of the plurality of child tasks from the private space by the first thread.

Steal one-process many work-stealing

Methods and systems for performing memory garbage collection include determining a size of N double-ended queues ('deques') associated with N respective garbage collection threads, where N is three or greater. A task is popped from a deque out of the N deques having a largest size. Garbage collection is performed on the popped task.

Scalable garbage collection

Methods and systems for performing garbage collection include issuing a memory fence that indicates that a number of tasks in a garbage collection deque, belonging to a first garbage collection thread, has decreased by more than one. A length of the garbage collection deque, after the memory fence is issued, is determined to be greater than zero. Multiple tasks are popped from the garbage collection deque responsive to the determination that the length of the garbage collection deque is greater than zero. Garbage collection is performed on the popped tasks.

Garbage collection work stealing with multiple-task popping

A method is provided for sharing a global memory by a plurality of threads in a memory management system. The method includes allocating, by a controller of the system, thread-local memory areas in the global memory to a given thread and other threads, from among the plurality of threads. The method further includes gathering, by the controller, fragments of the thread-local memory areas previously allocated to the other threads, responsive to the fragments being scanned. The method also includes allocating, by the controller to the given thread, a requested memory size of the fragments of the thread-local memory areas previously allocated to the other threads, responsive to the fragments not being collectively smaller than the requested memory size. The method additionally includes allocating, by the controller to the given thread, a new memory area from the global memory, responsive to the fragments being collectively smaller than the requested memory size.

Sharing consumed off-heap for parallel data loading

Computer-implemented methods, program storage devices, and systems are provided for object copying in a computer performing parallel copying garbage collection on deques using work stealing. A method includes acquiring, for original objects in a source deque space, a destination deque space to copy the original objects to, and copying, from the source deque space to the destination deque space, any original objects in the source deque space having a reference to other ones of the original objects, or having a pre-known structure for estimating copy overhead. The method also includes registering, together with an address to copy to, any original objects in the source deque space lacking the reference to the other ones of the original objects, or lacking the pre-known structure for estimating copy overhead. The method additionally includes setting, in the source space, forwarding pointers to copied ones of the original objects in the destination deque place. The method may further include copying registered objects based on a copy cost or overhead and a spin count, waiting in a spin loop, and trying to steal a task after the spin loop. An upper limit may be imposed on the number of original objects that can be registered to prevent a load balance loss. The parallel copying garbage collection may be performed on a heap of the computer.

Spin-less work-stealing for parallel copying garbage collection

A computer-implemented method and a computer processing system are provided for increasing memory density in a memory using heap contraction. The method includes dividing the heap into a plurality of work regions including a last region and other regions such the last region is larger in size than the other regions. The method further includes calculating a size of the heap contraction. The method also includes forming a pair of the last region and one of the other regions that has a largest free portion. The method additionally includes executing intra-table compaction and inter-table compaction on the heap. The method further includes contracting the last region by subtracting a prescribed space from the last region.

Growing community of inventors

Saitama, Japan

Michihiro Horie