International Business Machines Corporation

Kazunori Ogata

Michihiro Horie

Hiroshi Horii

Kiyokuni Kawachiya

Tamiya Onodera

Hideaki Komatsu

Michiaki Tatsubori

Mikio Takeuchi

Kazuaki Ishizaki

Rei Odaira

Rina Nakazawa

Hiroshi Inoue

Seetharami R Seelam

Trent Gray-Donald

Tatsuhiro Chiba

Toshiaki Yasue

Hiroyuki Momose

Hiroshi Dohji

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

Methods and systems for controlling process priority for one or more work units having one or more processes. The method includes monitoring a combination of a throughput value and a response time value for each work unit, detecting a change in load level for each work unit based on a correlation between the throughput value and the response time value to adjust a priority level associated with the work unit, and reallocating one or more resources to the work unit when the priority level exceeds a predetermined threshold value.

Systems and methods for controlling process priority for efficient resource allocation

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

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

Apparatus, method, and a program for causing a computer to function as an apparatus, for realizing a runtime system for programming language. The apparatus includes a storage unit for storing a first class that is an existing class in the object-oriented programming language, a second class that is a class that includes a member accessible from outside of the first class and is a class which is specialized for specific use; and a processing unit for performing processing using the second class with a predetermined instruction in software that realizes the runtime system, and performing processing using the first class with an instruction to check an identity of the second class in a user program product that is executed by the runtime system.

Apparatus and method for realizing runtime system for programming language

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

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

Tokyo, Japan

Kazunori Ogata