LABEL REPORT: gc-shenandoah

This report shows bugs with the given label, along with their backporting status.

Report generated: Thu Nov 21 10:48:43 CET 2024

Minimal actionable level to display: NONE

core-libs/java.lang

Fix Versions Bug Synopsis
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256370 Add asserts to Reference.getInactive()

core-libs/java.nio

Fix Versions Bug Synopsis
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
✖ ✖ ✖ ✔ ✖ ✖ ✖ ❉ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8249543 (bf) Force DirectBufferAllocTest to run with -ExplicitGCInvokesConcurrent

core-svc/java.lang.management

Fix Versions Bug Synopsis
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8274522 java/lang/management/ManagementFactory/MXBeanException.java test fails with Shenandoah
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8274523 java/lang/management/MemoryMXBean/MemoryTest.java test should handle Shenandoah

hotspot/compiler

Fix Versions Bug Synopsis
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8252366 Shenandoah: revert/cleanup changes in graphKit.cpp
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8328107 Shenandoah/C2: TestVerifyLoopOptimizations test failure
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✔ ❉ JDK-8342496 C2/Shenandoah: SEGV in compiled code when running jcstress
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8340186 Shenandoah: Missing load_reference_barrier_phantom_narrow match in is_shenandoah_lrb_call
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255400 Shenandoah: C2 failures after JDK-8255000
✖ ✖ ✖ ✔ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220714 C2 Compilation failure when accessing off-heap memory using Unsafe
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8253857 Shenandoah: Bugs in ShenandoahEvacOOMHandler related code
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241070 Shenandoah: remove unused local variables in C2 support
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260637 Shenandoah: assert(_base == Tuple) failure during C2 compilation
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8316959 Improve InlineCacheBuffer pending queue management
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260632 Build failures after JDK-8253353
✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217467 Access barriers are missing in C2 intrinsic for Base64
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217874 Shenandoah: AArch64: Clobbered register in ShenandoahBarrierSetAssembler::cmpxchg_oop()
✖ ✖ ✖ ✔ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223389 Shenandoah optimizations fail with assert(!phase->exceeding_node_budget())
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8235636 gc/shenandoah/compiler/TestUnsafeOffheapSwap.java fails after JDK-8226411
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8252296 Shenandoah: crash in CallNode::extract_projections
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256020 Shenandoah: Don't resurrect objects during evacuation on AS_NO_KEEPALIVE
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8269240 java/foreign/stackwalk/TestAsyncStackWalk.java test failed with concurrent GC
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ JDK-8282025 assert(ctrl != __null) failed: control out is assumed to be unique after JDK-8281732
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8313248 C2: setScopedValueCache intrinsic exposes nullptr pre-values to store barriers
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8313262 C2: Sinking node may cause required cast to be dropped
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8288302 Shenandoah: SIGSEGV in vm maybe related to jit compiling xerces
✔ ✖ ❉ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8191227 Unsafe handle resolution in ConstantOopWriteValue::write_on() / print_on() and LIR_Assembler::jobject2reg()
✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8216482 Shenandoah: typo in ShenandoahBarrierSetC2::clone_barrier_at_expansion() causes failed compilations
✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217042 Shenandoah: write barrier on backedge of strip mined loop causes c2 crash at expansion time
✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217043 Shenandoah: SIGSEGV in Type::meet_helper() at barrier expansion time
✖ ✖ ✖ ✔ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8218468 Load barrier slow path node should be MachTypeNode
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222738 Shenandoah: assert(is_Proj()) failed when running cometd benchmarks
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224496 Shenandoah compilation fails with assert(is_CountedLoopEnd()) failed: invalid node class
✖ ✖ ✖ ✔ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223502 Node estimate for loop unswitching is not correct: assert(delta <= 2 * required) failed: Bad node estimate
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8230470 Shenandoah doesn't need change from JDK-8212610 anymore
✖ ✖ ✖ ✔ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229483 Sinking load out of loop may trigger: assert(found_sfpt) failed: no node in loop that's not input to safepoint
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231499 Shenandoah: compiler/arraycopy/TestDefaultMethodArrayCloneDeoptC2 fails
✔ ✖ ✖ ✔ ✖ ✔ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8236179 C1 register allocation failure with T_ADDRESS
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8236181 C2: Remove useless step_over_gc_barrier() in int->bool conversion
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237007 Shenandoah: assert(_base == Tuple) failure during C2 compilation
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241675 Shenandoah: assert(n->outcnt() > 0) at shenandoahSupport.cpp:2858 with java/util/Collections/FindSubList.java
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255534 Shenandoah: Fix CmpP optimization wrt native-LRB
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255401 Shenandoah: Allow oldval and newval registers to overlap in cmpxchg_oop()
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255936 "parsing found no loops but there are some" assertion failure with Shenandoah
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8258393 Shenandoah: "graph should be schedulable" assert failure
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256215 Shenandoah: re-organize saving/restoring machine state in assembler code
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8259937 guarantee(loc != NULL) failed: missing saved register with native invoker
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8263376 CTW (Shenandoah): assert(mems <= 1) failed: No node right after call if multiple mem projections
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8268641 [foreign] assert(allocates2(pc)) failed: not in CodeBuffer memory with ShenandoahGC
✖ ✖ ✖ ❉ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8272772 Shenandoah: compiler/c2/aarch64/TestVolatilesShenandoah.java fails in 11u
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8329797 Shenandoah: Default case invoked for: "MaxL" (bad AD file)
✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8212611 Small collection of simple changes from shenandoah
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223450 Disable Shenandoah C2 barriers verification for x86_32
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223427 [TESTBUG] Disable JTReg Shenandoah tests when Graal is enabled
✖ ✖ ✖ ✔ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231085 C2/GC: Better GC-interface for expanding clone
✖ ✖ ✖ ✔ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231503 [TESTBUG] compiler/{jvmci,aot} tests should not run with GCs that do not support JVMCI/AOT
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8235729 Shenandoah: Remove useless casting to non-constant
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8238153 CTW: C2 (Shenandoah) compilation fails with "Unknown node in get_load_addr: CreateEx"
✔ ✖ ✖ ✔ ✖ ✔ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237951 CTW: C2 compilation fails with "malformed control flow"
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8238385 CTW: C2 (Shenandoah) compilation fails with "Range check dependent CastII node was not removed"
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240070 Shenandoah: remove obsolete ShenandoahCommonGCStateLoads
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244721 CTW: C2 (Shenandoah) compilation fails with "unexpected infinite loop graph shape"
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8254314 Shenandoah: null checks in c2 should not skip over native load barrier
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8274401 C2: GraphKit::load_array_element bypasses Access API
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ JDK-8299324 inline_native_setCurrentThread lacks GC barrier for Shenandoah
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8315051 jdk/jfr/jvm/TestGetEventWriter.java fails with non-JVMCI GCs
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ❉ ✖ JDK-8325372 Shenandoah: SIGSEGV crash in unnecessary_acquire due to LoadStore split through phi
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8333258 C2: high memory usage in PhaseCFG::insert_anti_dependences()
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8327380 Add tests for Shenandoah barrier expansion optimization

hotspot/gc

Fix Versions Bug Synopsis
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8311843 GenShen: assertion failed "Old generation affiliated regions must be less than capacity"
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231366 Shenandoah: Shenandoah String Dedup thread is not properly initialized
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8297796 GenShen: instrument the remembered set scan
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8298597 HdrSeq: support for a merge() method
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8311883 [Genshen] Adaptive tenuring threshold
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8313574 GenShen: Completing a global mark should also complete an old mark
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8315247 GenShen: Condition calls to post-write barrier code generation by a flag
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8315872 GenShen: ShenandoahGenerationalHeap as a subclass of ShenandoahHeap
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8323901 GenShen: separate generational marking code
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8324325 [Genshen] Normalize wrt AgeTable changes from JDK-8314329
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8325886 GenShen: separate generational evacuation code
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8335930 GenShen: Reserve regions within each generation's freeset until available is sufficient
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8274546 Shenandoah: Remove unused ShenandoahUpdateRootsTask copy
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ JDK-8300644 Remove gc/shenandoah/jni/TestStringCriticalWithDedup.java
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✔ ❉ ✖ ✖ ✖ JDK-8307378 Allow collectors to provide specific values for GC notifications' actions
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8325671 Shenandoah: Introduce a ShenandoahGenerationType and templatize certain marking closures with it
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8334315 Shenandoah: reduce GC logging noise
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8293650 Shenandoah: Support archived heap objects
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8336915 Shenandoah: Remove unused ShenandoahVerifier::verify_after_evacuation
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8340490 Shenandoah: Optimize ShenandoahPacer
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8342588 Shenandoah: Pull shared closures together in one header
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8252114 Windows-AArch64: Enable and test ZGC and ShenandoahGC
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8282809 Shenandoah Generational: JBB 2015 crash on PPC64 product build
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8282810 Shenandoah Generational: Improve load balancing of remembered set scanning
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8282840 Shenandoah Generational: Relax enforcement of evacuation budgets
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8282844 Shenandoah Generational: Investigate assertion failure during verification before mark
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8282997 Shenandoah Generational: Mutator threads may fail to evacuate
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8298647 GenShen require heap size 2MB granularity
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8306024 GenShen: Disable failing Shenandoah tests and assertions while corrections are made
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8306333 GenShen: Investigate gc/shenandoah/TestDynamicSoftMaxHeapSize.java#generational
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8306334 Handle preemption of old cycle between filling and bootstrap phases
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8306335 GenShen: Investigate gc/shenandoah/oom/TestThreadFailure.java
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8306336 GenShen: Investigate gc/shenandoah/oom/TestClassLoaderLeak.java
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8306337 GenShen: Investigate gc/shenandoah/mxbeans/TestChurnNotifications.java#generational
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8306339 GenShen: Investigate gc/stress/gcold/TestGCOldWithShenandoah.java#generational
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8309317 [Shenandoah] TestRetainObjects#no-tlab and TestSieveObjects#no-tlab time out on some machines
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8309319 [GenShen] Assertion "used cannot exceed regions" with TestAllocObjects & TestDynamicSoftMaxHeapSize
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8309320 [GenShen] Assertion "size must be multiple of card table size"" with TestElasticTLAB
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8309321 [GenShen] Assertion "Cannot budget more than is available"" with TestGCOldWithShenandoah
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8309322 [GenShen] TestAllocOutOfMemory#large failed
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8309392 [GenShen] Review and correct copyright headers that may have been incorrectly updated
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8309639 GenShen: Regression in LRU cache benchmark
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8309693 Synchronize openjdk/shenandoah:master with changes made for PR
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8309874 NMethod barriers may remain armed when regions are promoted in place
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8310062 [Shenandoah] Incomplete SATB buffers may not be processed during degenerated young collection
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8310574 GenShen: Should not update-references for in-place-promotions
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8310680 GenShen: In-place region promotions may fail
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8311599 GenShen: Missing card mark barrier when processing references
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8311602 GenShen: Decouple generational mode heuristics
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8312321 GenShen: Remembered set scan may encounter garbage objects
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8312322 GenShen: Cancelled GCs may become stuck in self-cancellation loop
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8312422 GenShen: In-place region promotion state may carry over when evacuation fails
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8312610 GenShen: Old generation available is unintentionally restricted by mutator's available memory
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8315875 GenShen: Remove heap mode check from ShenandoahInitLogger
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8316755 GenShen: Serviceability needs to know about ShenandoahGenerationalHeap
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8317534 GenShen: Remove unused code
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8318570 GenShen: Only start old cycles if a young cycle is ready to run
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8318619 GenShen: Add configurable threshold for young triggers to expedite old evacuations
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8319671 GenShen: Old marking may encounter invalid pointers in SATB buffers
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8319867 GenShen: Make old regions parsable at end of concurrent cycles
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8319931 GenShen: Increase no progress threshold for TestThreadFailure
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8320119 GenShen: Correct misspellings of parsable
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8320913 GenShen: Bootstrap 21u backports repo
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8321605 GenShen: Old generation reference process is never reset
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8321816 GenShen: Provide a minimum amount of time for an old collection to run
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8321937 GenShen: Sync up 21u based repo
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8321939 [GenShen] ShenandoahOldEvacRatioPercent=100 fails with divide-by-zero
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8322219 GenShen: GHA for shenandoah repo should run all shenandoah jtreg tests
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8322875 [GenShen] Unused/obsolete method parameter consumed_by_advance_promotion
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8323023 GenShen: Region logging test fails intermittently
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8324067 GenShen: Isolate regulator thread to generational mode
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8324173 GenShen: Fix error that could cause young gcs to fail when old marking is running
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8328220 GenShen: Move generational mode operational parameters out of ShenandoahHeap
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8328626 GenShen: Combine old generation surplus/deficit fields into a single balance field
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8329342 GenShen: Synchronize shenandoah-jdk21u:master with shenandoah:master
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8329699 GenShen: Move promotion logic out of shHeap and shHeapRegion
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8330414 GenShen: Class unloading requires old regions be made parseable
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8331609 GenShen: Refactor generational mode allocations
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8332081 GenShen: Disentangle generational mode update references
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8332094 GenShen: Reuse existing code to verify usage before rebuilding free set
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8332095 GenShen: Move more generational mode members out of shHeap
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8332254 GenShen: Remove obsolete comments and revert unnecessary formatting changes
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8332330 Shenandoah: Change jcheck configuration for fix version to match project repo
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8332331 Shenandoah: Change jcheck configuration for fix version to match project repo
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8332548 GenShen: Factor generational mode out of gc helpers
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8332824 GenShen: Temporarily revert recent changes to GC helpers
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8332913 GenShen: Restore shared update refs iterator
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8333109 GenShen: Factor generational mode out of gc helpers (redo)
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8333457 GenShen: Move remembered set into new generational code
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8333750 GenShen: Only instantiate young/old generations in generational mode
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8333825 GenShen: Revert/Remove ShenandoahMaxEvacLABRatio
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8333930 GenShen: Check for cancellation of old mark after final mark
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8334491 GenShen: Revert changes to Shenandoah defaults
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8334681 GenShen: Do not use gtest skip test feature
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8335289 GenShen: Whitebox breakpoint GC requests may cause assertions
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8335347 GenShen: Revert change that has adaptive heuristic ignore abbreviated cycles
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8335932 GenShen: Fix old heuristic unit test
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8336106 Genshen: Fix use of missing API in Shenandoah Old Heuristic test
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8337242 GenShen: Remove unnecessary copyright changes
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338336 GenShen: Cleanup stale TODOs
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338341 GenShen: Cleanup headers, unreachable code and unintentional changes
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338420 GenShen: Forward declare card table for Shenandoah barrier set
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338473 GenShen: Cleanup access levels, whitespace, typos and unused code
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338477 GenShen: Cleanup generational heap
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338479 GenShen: Detemplatize ShenandoahScanRemembered
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338528 GenShen: Cleanup shenandoahHeapRegion
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338695 GenShen: Clean up jtreg tests
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338717 GenShen: Fix up some assertions
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338763 GenShen: Global GC should not swap remembered sets for the verifier
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338779 GenShen: Prefer log_develop_debug in performance critical code
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338780 GenShen: Fix up some comments
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8338881 GenShen: Use explicit third temp register for post barrier
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8339094 Shenandoah: Fix up test output from ShenandoahNumberSeqTest
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8339127 GenShen: Restore completed mark context assertion during class unloading
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8339197 GenShen: Adding Generation and Evacuation Information JFR Logging
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8339346 GenShen: Remove even more stale TODOs
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8339643 Port JEP 404 to RISC-V
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8339695 GenShen: Concurrent reset performance has regressed
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8339870 Remove yet more stale TODOs
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8340395 GenShen: Remove unnecessary check on card barrier flag
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8341042 GenShen: Reset mark bitmaps for unaffiliated regions when preparing for a cycle
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8341099 GenShen: assert(HAS_FWD == _heap->has_forwarded_objects()) failed: Forwarded object status is sane
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8341485 GenShen: Make evac tracker a non-product feature and confine it to generational mode
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8341992 GenShen: Fix formatting, remove unreachable code, unused imports and unnecessary comments
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8342001 GenShen: Factor cases for allocation type into separate methods
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8342214 GenShen: Reduce code duplication in shFreeSet with iterator abstraction
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8342239 GenShen: Revert changes in adaptive heuristic to avoid overflow on 32 bit
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8342255 GenShen: Remove unnecessary enum initial values
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8342278 GenShen: Move non-generational mode test out of generational test configuration
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8342560 GenShen: Fix confusing method name
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8342564 GenShen: Only reference young/old generation names in generational mode
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8342734 GenShen: Test failure gc/shenandoah/TestReferenceRefersToShenandoah.java#generational
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8342861 GenShen: Old generation in unexpected state when abandoning mixed gc candidates
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8342919 GenShen: Fix whitespace
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8342924 GenShen: Problem list gc/shenandoah/TestReferenceRefersToShenandoah.java
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8342927 GenShen: Guarantee slices of time for coalesce and filling
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8343227 GenShen: Fold resource mark into management of preselected regions
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8343649 Shenandoah: ShenandoahEvacInfo event does not follow JFR guidelines
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8344151 GenShen: Improve comments, clean up unnecessary changes
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8344152 GenShen: Initialize RegionData in product builds
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8344260 GenShen: Excess unaffiliated regions reserved for old will not be transferred to young
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8344263 GenShen: Reduce extraneous log messages at INFO level
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8344264 GenShen: Improve comments and method names
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8344320 GenShen: Possible null pointer usage in shGenerationalHeap
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8344321 GenShen: Fix various sonar scan warnings
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8344339 GenShen: Avoid using namespaces
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8344592 GenShen: Remove unnecessary comments and changes
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8344638 GenShen: Verifier should not touch claim token
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8344640 GenShen: Reuse existing card mark barrier function when dropping references
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8344670 GenShen: Use concurrent worker session for concurrent mark phase
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8277212 GC accidentally cleans valid megamorphic vtable inline caches
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8335126 Shenandoah: Improve OOM handling
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8275226 Shenandoah: Relax memory constraint for worker claiming tasks/ranges
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8277654 Shenandoah: Don't produce new memory state in C2 LRB runtime call
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ JDK-8309953 Strengthen and optimize oopDesc age methods
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ JDK-8310110 Shenandoah: Trace page sizes
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ JDK-8311978 Shenandoah: Create abstraction over heap metrics for heuristics
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ JDK-8310388 Shenandoah: Auxiliary bitmap is not madvised for THP
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ JDK-8316632 Shenandoah: Raise OOME when gc threshold is exceeded
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ JDK-8320969 Shenandoah: Enforce stable number of GC workers
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8322954 Shenandoah: Convert evac-update closures asserts to rich asserts
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8322815 Eliminate -Wparentheses warnings in shenandoah code
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8323627 Shenandoah: Refactor init logger
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8323629 Shenandoah: Fix missing include and declaration
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8324334 Shenandoah: Improve end of process report
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8324553 Shenandoah: Move periodic tasks closer to their collaborators
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8324981 Shenandoah: Move commit and soft max heap changed methods into heap
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8325516 Shenandoah: Move heap change tracking into ShenandoahHeap
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8325517 Shenandoah: Reduce unnecessary includes from shenandoahControlThread.cpp
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8325574 Shenandoah: Simplify and enhance reporting of requested GCs
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8332255 Shenandoah: Remove duplicate definition of init mark closure
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8332082 Shenandoah: Use consistent tests to determine when pre-write barrier is active
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8333105 Shenandoah: Results of concurrent mark may be lost for degenerated cycle
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8333926 Shenandoah: Lower default immediate garbage threshold
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ JDK-8334147 Shenandoah: Avoid taking lock for disabled free set logging
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8335356 Shenandoah: Improve concurrent cleanup locking
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8337213 Shenandoah: Add verification for class mirrors
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8338202 Shenandoah: Improve handshake closure labels
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8336742 Shenandoah: Add more verbose logging/stats for mark termination attempts
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ JDK-8336914 Shenandoah: Missing verification steps after JDK-8255765
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8338444 Shenandoah: Remove ShenandoahHumongousThreshold tunable
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8337981 ShenandoahHeap::is_in should check for alive regions
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8338662 Shenandoah: Remove excessive ShenandoahVerifier::verify_during_evacuation
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8340181 Shenandoah: Cleanup ShenandoahRuntime stubs
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8342081 Shenandoah: Remove extra ShenandoahMarkUpdateRefsSuperClosure
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8342079 Shenandoah: Remove extra ShenandoahInitMarkRootsClosure
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8342119 Shenandoah: Remove extra ShenandoahUpdateRefsClosure
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8314329 AgeTable: add is_clear() & allocation spec, and relax assert to allow use of 0-index slot
✖ ✖ ✖ ✔ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8235324 Dying objects are published from users of CollectedHeap::object_iterate
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8235669 G1: Stack walking API can expose AS_NO_KEEPALIVE oops
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242216 ObjectSampler::weak_oops_do() should not trigger barrier
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247736 Shenandoah: assert(_nm->is_alive()) failed: only alive nmethods here
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8248725 Shenandoah: Claim verifier thread roots for parallel processing
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8249230 Shenandoah: assertion failure with -XX:-ResizeTLAB
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ❉ ✖ ✔ ✖ ✖ ✖ JDK-8280885 Shenandoah: Some tests failed with "EA: missing allocation reference path"
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245240 Shenandoah: support nesting evacuation OOM scope
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256036 Shenandoah: MethodHandles adapters section overflows after JDK-8255762
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256039 Shenandoah: runtime/stringtable/StringTableCleaningTest.java fails
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8273559 Shenandoah: Shenandoah should support multi-threaded heap dump
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8316929 Shenandoah: Shenandoah degenerated GC and full GC need to cleanup old OopMapCache entries
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✔ ❉ JDK-8333088 ubsan: shenandoahAdaptiveHeuristics.cpp:245:44: runtime error: division by zero
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8235598 Shenandoah: Update copyrights
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241067 Shenandoah: improve ShenandoahNMethod::has_cset_oops arguments
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242370 Enable JFR TestGCPhaseConcurrent test for Shenandoah
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243478 Shenandoah: avoid implicit worker_id = 0
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244243 Shenandoah: Cleanup Shenandoah phase timing tracking and JFR event supporting
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245083 [REDO] Shenandoah: Remove null-handling in LRB expansion
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245720 Shenandoah: improve configuration logging
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245827 Shenandoah: Cleanup Shenandoah code root iterators and root scanner
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245955 Shenandoah: Remove LRB/is_redundant optimization
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8246342 Shenandoah: remove unused ShenandoahIsMarkedNextClosure
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8246612 Shenandoah: add timing tracking to ShenandoahStringDedupRoots
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247845 Shenandoah: refactor TLAB/GCLAB retirement code
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8248634 Shenandoah: incorrect include in shenandoahInitLogger.cpp
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8248799 Shenandoah: Claim threads token in constructor of ShenandoahRootVerifier
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8249877 Shenandoah: Report number of dead weak oops during STW weak roots
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8249884 Shenandoah: Call report_num_dead() from ShParallelWeakRootsCleaningTask destructor
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8251527 CTW: C2 (Shenandoah) compilation fails with SEGV due to unhandled catchproj == NULL
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8252695 Shenandoah: clean up Graal enabled/disabled filter in tests
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8253361 Shenandoah: runtime barrier does not honor ShenandoahSelfFixing flag
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255036 Shenandoah: Reset GC state for root verifier
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255614 Shenandoah: Consolidate/streamline runtime LRBs
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256278 Shenandoah: Avoid num of dead callback from weak processor in Shenandoah root verifier
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255984 Shenandoah: "adaptive" heuristic is prone to missing load spikes
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8258244 Shenandoah: Not expecting forwarded object in roots during mark after JDK-8240868
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8258490 Shenandoah: Full GC does not need to remark threads and drain SATB buffers
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260048 Shenandoah: ShenandoahMarkingContext asserts are unnecessary
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260212 Shenandoah: resolve-only UpdateRefsMode is not used
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260106 Shenandoah: refactor reference updating closures and related code
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260408 Shenandoah: adjust inline hints after JDK-8255019
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260309 Shenandoah: Clean up ShenandoahBarrierSet
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261493 Shenandoah: reconsider bitmap access memory ordering
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261500 Shenandoah: reconsider region live data memory ordering
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261503 Shenandoah: reconsider verifier memory ordering
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261504 Shenandoah: reconsider ShenandoahJavaThreadsIterator::claim memory ordering
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261501 Shenandoah: reconsider heap statistics memory ordering
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261842 Shenandoah: cleanup ShenandoahHeapRegionSet
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261838 Shenandoah: reconsider heap region iterators memory ordering
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8263041 Shenandoah: Cleanup C1 keep alive barrier check
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8264727 Shenandoah: Remove extraneous whitespace from phase timings report
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8266083 Shenandoah: Consolidate dedup/no dedup oop closures
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8266185 Shenandoah: Fix incorrect comment/assertion messages
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8266845 Shenandoah: Simplify SBS::load_reference_barrier implementation
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8267257 Shenandoah: Always deduplicate strings when it is enabled during full gc
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8267875 Shenandoah: Duplicated code in ShenandoahBarrierSetC2::ideal_node()
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261495 Shenandoah: reconsider update references memory ordering
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8270094 Shenandoah: Provide human-readable labels for test configurations
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8270171 Shenandoah: Cleanup TestStringDedup and TestStringDedupStress tests
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8270110 Shenandoah: Add test for JDK-8269661
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8266519 Cleanup resolve() leftovers from BarrierSet et al
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8273378 Shenandoah: Remove the remaining uses of os::is_MP
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ❉ ✖ ✔ ✖ ✖ ✖ JDK-8278826 Print error if Shenandoah flags are empty (instead of crashing)
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✔ ❉ ✔ ✖ ✖ ✖ JDK-8297309 Memory leak in ShenandoahFullGC
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ❉ ✖ ✖ ✖ JDK-8300053 Shenandoah: Handle more GCCauses in ShenandoahControlThread::request_gc
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8314935 Shenandoah: Unable to throw OOME on back-to-back Full GCs
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8317535 Shenandoah: Remove unused code
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8320877 Shenandoah: Remove ShenandoahUnloadClassesFrequency support
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8320888 Shenandoah: Enable ShenandoahVerifyOptoBarriers in debug builds
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8320907 Shenandoah: Remove ShenandoahSelfFixing flag
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8321120 Shenandoah: Remove ShenandoahElasticTLAB flag
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8321122 Shenandoah: Remove ShenandoahLoopOptsAfterExpansion flag
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8321410 Shenandoah: Remove ShenandoahSuspendibleWorkers flag
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8325807 Shenandoah: Refactor full gc in preparation for generational mode changes
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8332256 Shenandoah: Do not visit heap threads during shutdown
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8332257 Shenandoah: Move evacuation methods to implementation file
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ❉ ✖ JDK-8331572 Allow using OopMapCache outside of STW GC phases
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✔ ❉ JDK-8333728 ubsan: shenandoahFreeSet.cpp:1347:24: runtime error: division by zero
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8336944 Shenandoah: Should only relativize stack chunks for successful evacuations
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✔ ❉ JDK-8336640 Shenandoah: Parallel worker use in parallel_heap_region_iterate
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8336685 Shenandoah: Remove experimental incremental update mode
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8335865 Shenandoah: Improve THP pretouch after JDK-8315923
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8258251 Move PtrQueue behaviors to PtrQueueSet subclasses
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217419 Shenandoah fails to build after JDK-8212826 (Make PtrQueue free list lock-free)
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217522 Missing barriers in some java_lang_String assertion code after JDK-8217442
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223570 Shenandoah needs to acquire lock before CLDG::clear_claimed_marks
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223583 Build failure after JDK-8223567 (Rename ShenandoahBrooksPointer to ShenandoahForwarding)
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223767 Shenandoah fails to build on Solaris x86_64
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224875 Shenandoah: ParallelCleaning code unloading should take lock to protect shared code roots array
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229176 Shenandoah should acquire CodeCache_lock without safepoint check
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229709 x86_32 build and test failures after JDK-8228369 (Shenandoah: Refactor LRB C1 stubs)
✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231405 [Shenandoah] guarantee(d != NULL) failed: Null dominator info
✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231583 Shenandoah: Fix register clash in SBSA::resolve_forwarding_pointer() borrowing
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232674 Fix build and rename ShenandoahBarrierSet::oop_load_from_native_barrier
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232712 Shenandoah: SIGBUS in load_reference_barrier_native
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237776 Shenandoah: Wrong result with Lucene test
✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217717 ZGC: Broken oop map in C1 load barrier stub
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220671 Initialization race for non-JavaThread PtrQueues
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221102 Allow GC threads to participate in threads claiming protocol
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222333 fastdebug build broken after JDK-8221393 (phase_mapping[] doesn't match enum Phase in WeakProcessorPhases)
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222838 Shenandoah: SEGV on accessing cset bitmap for NULL ptr
✖ ✖ ✖ ✔ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222926 Shenandoah build fails with --with-jvm-features=-compiler1
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223651 Build fails with --with-jvm-features=-jfr and --disable-precompiled-headers
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224573 Fix windows build after JDK-8221507
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224522 Shenandoah should apply barriers on deoptimization
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224836 Backout: JDK-8224626: Shenandoah: Elide barriers on uncommon traps
✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224881 Shenandoah: trashing "Collection Set, Pinned" region during Degenerated GC
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8228420 compile error in shenandoahSupport.cpp with clang 9
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8230024 Shenandoah: remove unnecessary ShenandoahTimingConverter
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8230046 Build failure after JDK-8230003
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8230215 MacOS debug build is broken after JDK-8230003
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231395 Backout JDK-8231249
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232176 Shenandoah: new assert in ShenandoahEvacuationTask is too strong
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232778 Shenandoah: SBSA::arraycopy_prologue checks wrong register
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233232 AArch64: Shenandoah: jni_fast_GetLongField is broken
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233796 Shenandoah is broken after 8233708
✖ ✖ ✖ ✔ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8234508 VM_HeapWalkOperation::iterate_over_object reads non-strong fields with an on-strong load barrier
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8236815 Shenandoah: Fix weak roots in final Traversal GC phase
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8236902 Shenandoah: Missing string dedup roots in all root scanner
✖ ✖ ✖ ✔ ✖ ✖ ❉ ✔ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237369 Shenandoah: failed vmTestbase/nsk/jvmti/AttachOnDemand/attach021/TestDescription.java test
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237821 Shenandoah: build broken after JDK-8237637 (Remove dubious type conversions from oop)
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237874 Shenandoah: Backout JDK-8234399
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237837 Shenandoah: assert(mem == __null) failed: only one safepoint
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8238851 Shenandoah: C1: Resolve into registers of correct type
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237780 Shenandoah: More reliable nmethod verification
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237632 Shenandoah: accept NULL fwdptr to cooperate with JVMTI and JFR
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8236981 Shenandoah: Remove ShenandoahTraversalUpdateRefsClosure
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8239926 Shenandoah: Shenandoah needs to mark nmethod's metadata
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241081 Shenandoah: Do not modify update-watermark concurrently
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244663 Shenandoah: C2 assertion fails in Matcher::collect_null_checks
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245773 Shenandoah: Windows assertion failure after JDK-8245464
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245942 Shenandoah: x86_32 builds fail after JDK-8245594
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247310 Shenandoah: pacer should not affect interrupt status
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247474 Shenandoah: Windows build warning after JDK-8247310
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247560 Shenandoah: heap iteration holds root locks all the time
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247593 Shenandoah: should not block pacing reporters
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247670 Shenandoah: deadlock during class unloading OOME
✖ ✖ ✖ ✔ ✖ ✖ ✖ ❉ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8250588 Shenandoah: LRB needs to save/restore fp registers for runtime call
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8251192 Shenandoah: Shenandoah build failed after JDK-8235573
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8251451 Shenandoah: Remark ObjectSynchronizer roots with I-U
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8254319 Shenandoah: Interpreter native-LRB needs to activate during HAS_FORWARDED
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255852 Shenandoah: Fix incorrect copyright header in new files added by 8254315
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255886 Shenandoah: Resolve cset address truncation and register clash in interpreter LRB
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256051 nmethod_entry_barrier stub miscalculates xmm spill size on x86_32
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256011 Shenandoah: Don't resurrect finalizably reachable objects
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256426 Shenandoah: Remove superfluous assert is ShBS::load_reference_barrier()
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256688 Shenandoah: Lock rank inversion after JDK-8212879
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256912 Zero builds fail after JDK-8255984
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256517 (ref) Reference.clear during reference processing may lose notification
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8257701 Shenandoah: objArrayKlass metadata is not marked with chunked arrays
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8257793 Shenandoah: SATB barrier should only filter out already strongly marked oops
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8257817 Shenandoah: Don't race with conc-weak-in-progress flag in weak-LRB
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8258714 Shenandoah: Process references before evacuation during degen
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8259252 Shenandoah: Shenandoah build failed on AArch64 after JDK-8258459
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8265984 Concurrent GC: Some tests fail "assert(is_frame_safe(f)) failed: Frame must be safe"
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8269661 JNI_GetStringCritical does not lock char array
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8269897 Shenandoah: Resolve UNKNOWN access strength, where possible
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8273832 gc/shenandoah/TestJcmdHeapDump.java does not have a @requires vm.gc.shenandoah
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8274925 Shenandoah: shenandoah/TestAllocHumongousFragment.java test failed on lock rank check
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✔ ✖ ✖ ✖ JDK-8278627 Shenandoah: TestHeapDump test failed
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ❉ ✖ JDK-8329088 Stack chunk thawing races with concurrent GC stack iteration
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✔ ❉ JDK-8334482 Shenandoah: Deadlock when safepoint is pending during nmethods iteration
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217778 StringTable cleanup miscalculates amount of dead objects
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8219524 Shenandoah misreports "committed" size in MemoryMXBean
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220161 Shenandoah does not need to initialize PLABs for safepoint workers
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220153 Shenandoah does not work with TransparentHugePages properly
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220162 Shenandoah should not commit HugeTLBFS memory
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220344 Build failures when using --with-jvm-features=-g1gc,-jfr
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221435 Shenandoah should not mark through weak roots
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222086 CodeCache::UnloadingScope needs to preserve and restore previous IsUnloadingBehavior
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222125 Shenandoah: Crash when running with ShenandoahParallelSafepointThreads=1
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222186 Shenandoah should not uncommit below minimum heap size
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222786 Shenandoah get_barrier_strength should accept all shapes of (Weak)CAS reference barriers
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223446 Shenandoah breaks alignment with some HumongousThreshold values
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223448 Shenandoah disabled barriers blocks omit LRB
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223980 Shenandoah: Refactor and fix ObjArrayChunkedTask verification
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224179 Shenandoah: CTW test failures with traversal GC
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224584 Shenandoah: Eliminate forwarding pointer word
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225014 Separate ShenandoahRootScanner method for object_iterate
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225048 Shenandoah x86_32 support
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225111 Make Shenandoah tests work with 32-bit VMs
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225229 Shenandoah: trim down default number of GC threads
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8228490 Shenandoah: Shenandoah concurrent root evacuation may race against OopStorage::release()
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229350 Shenandoah does not need barriers before CreateEx
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229865 Use explicit #include debug.hpp for STATIC_ASSERT in gc/shenandoah/shenandoahUtils.cpp
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8230483 Shenandoah: consistently disable concurrent roots for Traversal mode
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8230350 Shenandoah: Assertion failed when GC is cancelled by a worker thread
✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231197 Shenandoah: JVMTI heap walking cleanup crashes with NULL forwardee
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231198 Shenandoah: heap walking should visit all roots most of the time
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231244 Shenandoah: all-roots heap walking misses some weak roots
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231293 Shenandoah: Traversal should not revive dead weak roots
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231410 Shenandoah: clone barrier should use base pointer
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231999 Shenandoah: Traversal failed compiler/jsr292/CallSiteDepContextTest.java
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232575 Shenandoah: asynchronous object/region pinning
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232730 Shenandoah: Traversal should not CAS the roots
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232802 Shenandoah: transition between "cset" and "pinned_cset" does not require cancelled gc
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233165 Shenandoah:SBSA::gen_load_reference_barrier_stub() should use pointer register for address on aarch64
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233500 Shenandoah: Shenandoah load barrier should save registers before calling keep alive barrier on x86
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8235586 Shenandoah: Traversal GC still uses old CLD::oops_do API
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8234974 Shenandoah: Do concurrent roots even when no evacuation is necessary
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8235842 Shenandoah: Implement native LRB for narrow oop
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8236106 [TESTBUG] Shenandoah: Make TestThreadFailure more resilient
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8236681 Shenandoah: Disable concurrent class unloading flag if no class unloading for the GC cycle
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8236732 Shenandoah: Stricter placement for oom-evac scopes
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237038 Shenandoah: Reduce thread pool size in TestEvilSyncBug.java test
✖ ✖ ✖ ✔ ✖ ✖ ❉ ✔ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237392 Shenandoah: Remove unreliable assertion
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237963 Shenandoah: Heap iteration should use concurrent version of string dedup roots
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241765 Shenandoah: AARCH64 need to save/restore call clobbered registers before calling keepalive barrier
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242107 Shenandoah: Fix aarch64 build after JDK-8242082
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243200 Shenandoah: Allow concurrent nmethod iteration
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243323 Shenandoah: Recycle immediate garbage before concurrent class unloading
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241793 Shenandoah: Enable concurrent class unloading for aarch64
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244551 Shenandoah: Fix racy update of update_watermark
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244821 Shenandoah: disarmed_value is initialized at wrong place
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245288 Shenandoah: move up ShenandoahEvacOOM scope for code root processing during concurrent class unloading
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8246162 Shenandoah: full GC does not mark code roots when class unloading is off
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245961 Shenandoah: move some root marking to concurrent phase
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8246593 Shenandoah: string dedup roots should be processed during concurrent weak roots phase
✖ ✖ ✖ ✖ ✖ ✖ ✔ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247358 Shenandoah: reconsider free budget slice for marking
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8248041 Shenandoah: pre-Full GC root updates may miss some roots
✖ ✖ ✖ ✔ ✖ ✖ ✖ ❉ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247824 CTW: C2 (Shenandoah) compilation fails with SEGV in SBC2Support::pin_and_expand
✖ ✖ ✖ ✔ ✖ ✖ ✖ ❉ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8249560 Shenandoah: Fix racy GC request handling
✖ ✖ ✖ ❉ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8250784 Shenandoah: A Low-Pause-Time Garbage Collector
✖ ✖ ✖ ❉ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8250827 Shenandoah: needs to reset/finish StringTable's dead count before/after parallel walk
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8251910 Shenandoah: Handshake threads between weak-roots and reset phases
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8252853 AArch64: gc/shenandoah/TestVerifyJCStress.java fails intermittently with C1
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255006 Add NULL-check to StringDedupTable lookup
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255527 Shenandoah: Let ShenadoahGCStateResetter disable barriers
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255847 Shenandoah: Shenandoah should not mark through weak roots
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255991 Shenandoah: Apply 'weak' LRB on cmpxchg and xchg
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256040 Shenandoah: Allow NULL referent in ShenandoahReferenceProcessor::should_discover()
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256415 Shenandoah: Should evacuate/update codecache concurrently when class unloading is off
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256658 Shenandoah: Deadlock between nmethod_entry_barrier and concurrent code root evacuator
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8257641 Shenandoah: Query is_at_shenandoah_safepoint() from control thread should return false
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8259962 Shenandoah: task queue statistics is inconsistent after JDK-8255019
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261448 Preserve GC stack watermark across safepoints in StackWalk
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8263427 Shenandoah: Trigger weak-LRB even when heap is stable
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8264052 Shenandoah: Backout 8263832
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8264279 Shenandoah: Missing handshake after JDK-8263427
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8265012 Shenandoah: Backout JDK-8264718
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8265239 Shenandoah: Shenandoah heap region count could be off by 1
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8265759 Shenandoah: Avoid race for referent in assert
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8266453 Shenandoah: Disable write protections before patching nmethod in nmethod_barrier on MacOSX/AArch64
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8266522 Shenandoah: Shenandoah LRB calls wrong runtime barrier on aarch64
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8266802 Shenandoah: Round up region size to page size unconditionally
✖ ✖ ✖ ❉ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8267561 Shenandoah: Reference processing not properly setup for outside of cycle degenerated GC
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8268127 Shenandoah: Heap size may be too small for region to align to large page size
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8276201 Shenandoah: Race results degenerated GC to enter wrong entry point
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8276205 Shenandoah: CodeCache_lock should always be held for initializing code cache iteration
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ JDK-8279540 Shenandoah: Should only clear CLD::_claim_strong mark for strong CLD iterations
✖ ✖ ✖ ❉ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8290198 Shenandoah: a few Shenandoah tests failure after JDK-8214799 11u backport
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✔ ✖ ✖ ✖ JDK-8290250 Shenandoah: disable Loom for iu mode
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8288129 Shenandoah: Skynet test crashed with iu + aggressive
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✔ ❉ ✖ ✖ ✖ JDK-8305403 Shenandoah evacuation workers may deadlock
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ JDK-8306734 Shenandoah: Missing barriers on deoptimization path
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8299614 Shenandoah: STW mark should keep nmethod/oops referenced from stack chunk alive
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✔ ❉ ✖ JDK-8323086 Shenandoah: Heap could be corrupted by oom during evacuation
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✔ ❉ ✖ JDK-8325587 Shenandoah: ShenandoahLock should allow blocking in VM
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✔ ❉ ✖ JDK-8316328 Test jdk/jfr/event/oldobject/TestSanityDefault.java times out for some heap sizes
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8339651 ShenandoahPacer::setup_for_mark, ShenandoahPacer::setup_for_updaterefs and ShenandoahPacer::setup_for_evac runtime error: division by zero
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8250841 Shenandoah: need to reset/finish dead counters for StringTable/ResolvedMethodTable during STW root processing
✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8204969 Asserts in objArrayKlass.cpp need to use _raw variants of obj_addr_at()
✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8210879 ClassLoaderStatsClosure does raw oop comparison
✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8213352 Separate BufferNode allocation from PtrQueueSet
✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8214278 Cleanup process_completed_threshold and related state
✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8215220 Simplify Shenandoah task termination in aborted paths
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8214201 Make PtrQueueSet completed buffer list private
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8215549 Shenandoah deduplication cleans up table/queue twice
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8216973 Shenandoah: Kick up cleanup phases in the right places
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217213 shenandoahTaskQueue.hpp includes .inline.hpp file
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217319 Cleanup Shenandoah includes
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217400 Optimized build is broken by Shenandoah changes
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8212826 Make PtrQueue free list lock-free
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217343 Shenandoah control thread should be able to run at critical priority
✖ ✖ ✖ ✔ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217342 Build failed with excluding JFR
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217016 Shenandoah: Streamline generation of CAS barriers
✔ ✖ ✖ ✔ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217785 Padding ParallelTaskTerminator::_offered_termination variable
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217578 Shenandoah cleanup unused timings after concurrent string table change
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8203232 Shenandoah: Resolve oops in SATB filter
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8219857 Shenandoah GC may initialize thread's gclab twice
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8219976 GarbageCollectionNotificationInfo always says "No GC" when running Shenandoah
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8219613 Use NonJavaThread PtrQueues
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220228 Improve Shenandoah pacing histogram message
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220350 Refactor ShenandoahHeap::initialize
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220444 Shenandoah should use parallel version of WeakProcessor in root processor for weak roots
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220546 Shenandoah Reports timing details for weak root processing
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220712 [TESTBUG] gc/shenandoah/compiler/TestMaybeNullUnsafeAccess should run with Shenandoah enabled
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220780 ShenandoahBS::AccessBarrier::oop_store_in_heap ignores AS_NO_KEEPALIVE
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220812 gc/shenandoah/options/TestLoopMiningArguments.java fails if default GC is serial/parallel/cms
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221278 Shenandoah should not enqueue string dedup candidates during root scan
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221629 Shenandoah: Cleanup class unloading logic
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221688 Quarantine Shenandoah string dedup tests
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221735 Shenandoah fails ctw/modules/jdk_management_agent.java with Traversal
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221750 Shenandoah: Enable ThreadLocalHandshake by default
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221751 Shenandoah: Improve SATB enqueueing
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221875 Unquarantine Shenandoah string dedup tests
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220664 Simplify ShenandoahUpdateHeapRefsClosure
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221766 Load-reference barriers for Shenandoah
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221848 Shenandoah: ArrayCopy post-barrier improvements
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222129 Shenandoah: Missing CompareAndSwapP/N case in get_barrier_strength()
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222130 Shenandoah should verify roots after pre-evacuation
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222185 Shenandoah should report "committed" as capacity
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222227 Shenandoah: Fix Traversal GC weak roots handling in final-traversal pause
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222259 Shenandoah: Pre-evacuate string-dedup roots in Traversal GC
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222188 Shenandoah: Adjust Shenandoah work gang types
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222403 Shenandoah: Remove ShenandoahAlwaysTrueClosure, use AlwaysTrueClosure instead
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222419 Shenandoah: Remove unused _par_state_string in ShenandoahRootProcessor
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222425 Shenandoah: Move commonly used closures to separate files
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222490 Shenandoah: Remove unused _par_state_string in ShenandoahRootEvacuator
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222843 Print Shenandoah cset map addresses in hs_err
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223184 Shenandoah: Missing roots in SRP::process_all_roots_slow
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222992 Shenandoah: Pre-evacuate all roots
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223258 Shenandoah: SRP::process_all_roots_slow processes JvmtiExport weak oops twice
✖ ✖ ✖ ✔ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223244 Fix usage of ARRAYCOPY_DISJOINT decorator
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223447 Stabilize gc/shenandoah/TestStringDedupStress test
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223449 Unprotected UseCompressedOops block in gc/shenandoah/shenandoahBarrierSetC1_x86.cpp
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223567 Rename ShenandoahBrooksPointer to ShenandoahForwarding
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223759 Shenandoah should allow arbitrarily low initial heap size
✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223762 Shenandoah: overflows in calculations involving heap capacity
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223215 Shenandoah: Support verifying subset of roots
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224043 Shenandoah: Remove clear_claimed_marks() from start of concurrent_traversal()
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223774 Shenandoah: Refactor ShenandoahRootProcessor and family
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8223951 Shenandoah: Only need to update thread roots during final update refs
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221507 Implement JFR events for Shenandoah
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224210 Shenandoah: Refactor ShenandoahRootScanner to support scanning CSet codecache roots
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224167 Refactor PtrQueue completed buffer processing
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224495 Shenandoah: Do not rescan code roots in final mark pause if it is not degenerated GC
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224579 ResourceMark not declared in shenandoahRootProcessor.inline.hpp with --disable-precompiled-headers
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224508 Shenandoah: Need to update thread roots in final mark for piggyback ref update cycle
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224525 Shenandoah: Eliminate shenandoah verifier's side-effects
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224626 Shenandoah: Elide barriers on uncommon traps
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224667 Shenandoah: Post-LRB cleanup
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224115 Shenandoah: Eliminate RWLock that protects recorded nmethod data array
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224679 Shenandoah: Make ShenandoahParallelCodeCacheIterator noncopyable
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224751 Shenandoah: Shenandoah Verifier should select proper roots according to current GC cycle
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224932 Shenandoah: Rename ShenandoahHeapLock, make it general purpose lock
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225017 [TESTBUG] gc/shenandoah/oom/TestThreadFailure.java takes too long
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224978 Shenandoah: Allows root verifier to verify some roots outside safepoints with proper locks
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225046 Shenandoah metrics logs refactoring
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225171 Remove leftovers in shenandoahBarrierSetC1.cpp
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225341 Shenandoah: CM::update_thread_roots() needs to handle derived pointers
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225342 Shenandoah: use COMPILER2_OR_JVMCI macro consistently
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225357 Rewire ShenandoahHeap::maybe_update_with_forwarded for contending fixups
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225441 Cleanup ShenandoahHeap::atomic_compare_exchange_oop
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225514 Shenandoah: ShenandoahCodeRoots should inherit from AllStatic
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225572 Shenandoah: Move JNIHandles root out of serial roots
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225550 Shenandoah: Prevent SH::object_iterate() call's side-effects
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225743 Remove ShenandoahBarrierSetC2::escape_is_barrier_node and related GC interface
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225573 Shenandoah: Enhance ShenandoahVerifier to ensure roots to-space invariant
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225582 Shenandoah: Enable concurrent evacuation of JNIHandles
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225590 Shenandoah: Refactor ShenandoahClassLoaderDataRoots API
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8226413 Shenandoah: Separate root scanner for SH::object_iterate()
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8226310 Shenandoah: Concurrent evacuation of CLDG
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8226311 Shenandoah: Concurrent evacuation of OopStorage backed weak roots
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8226586 Shenandoah: No need to pre-evacuate roots for degenerated GC
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225255 Make SATB qset lock-free
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8226957 Shenandoah: Remove obsoleted "ShenandoahStoreCheck" option
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8227101 Shenandoah: Use ShenandoahSharedFlag for claimed flag in ShenandoahSerialRoot
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8227199 Shenandoah: Remove superfluous calls to can_do_traversal_gc()
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8226757 Shenandoah: Make traversal and passive modes explicit
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8226822 GC interface for C1 runtime calls
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8227039 Shenandoah: Aggressive heuristics for Traversal mode
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8227327 Shenandoah: Faster and more parallel tests
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8226695 Shenandoah: Wire C1 and C2 IN_NATIVE barrier
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8227637 Adjust Shenandoah C2 verifier to recognize IN_NATIVE barriers
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225483 Shenandoah: Enhance native access barrier
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8227676 Shenandoah: More consistent naming of LRB runtime entry points
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8227677 Shenandoah: C2: Make in-native LRB special case of normal LRB
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8227635 Shenandoah: SHBSA::load_at() needs to deal IN_NATIVE load
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8227755 Need more than 2 distinct CodeCache unloading cycles
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8228364 Shenandoah: Remove unused code from ShenandoahBarrierSetC1
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8227866 Shenandoah: Split weak root processing and class unloading in parallel cleaning task
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8228532 Shenandoah: Implement SBSA::try_resolve_jobject_in_native()
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8228775 Shenandoah: Remove useless null-input-verification in Shenandoah/C2 verifier
✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229002 Shenandoah: Missing node types in ShenandoahLoadReferenceBarrier::needs_barrier_impl()
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229206 Shenandoah: ShenandoahWeakRoot::oops_do() uses wrong timing phase
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229213 Shenandoah: Allow VM global oop storage to be processed concurrently
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8228369 Shenandoah: Refactor LRB C1 stubs
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229416 Shenandoah: Demote or remove ShenandoahOptimize*Final optimizations
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229419 Shenandoah: Cleanup LRB strength selector code
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229470 Shenandoah: Fix C1 getAndSetObject() failure
✖ ✖ ✖ ✔ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229474 Shenandoah: Cleanup CM::update_roots()
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229707 [TESTBUG] Some Shenandoah tests assume Server VM by default
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229921 Shenandoah: Make Traversal mode non-experimental
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229977 Shenandoah: save/restore FPU state aroud LRB runtime call
✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8230425 Shenandoah forces +UseNUMAInterleaving even after explicitly disabled
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8230730 UseCompressedOops test crash with assertion failure
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8221361 Eliminate two-phase initialization for PtrQueueSet classes
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231086 Shenandoah: Stronger invariant for object-arraycopy
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231087 Shenandoah: Self-fixing load reference barriers for C1/C2
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231250 Shenandoah: Traversal GC should keep alive weak load from heap
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231447 Shenandoah: Compilation-time regression after JDK-8231086
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231667 Shenandoah: Full GC should take empty regions into slices for compaction
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231932 Shenandoah: conc/par GC threads ergonomics overrides user settings
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231946 Remove obsolete and unused ShenandoahVerifyObjectEquals flag
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231947 Shenandoah: cleanup ShenandoahHumongousMoves flag treatment
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232102 Shenandoah: print everything in proper units
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232205 Shenandoah: missing "Update References" -> "Update Roots" tracing
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232534 Shenandoah: guard against reentrant ShenandoahHeapLock locking
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232573 Shenandoah: cleanup and add more logging for in-pause phases
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231324 Shenandoah: avoid duplicated weak root works during final traversal
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232008 Shenandoah: C1 load barrier does not match interpreter version
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232009 Shenandoah: C2 load barrier does not match interpreter version
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232010 Shenandoah: implement self-fixing native barrier
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232702 Shenandoah: gc/shenandoah/TestVerifyJCStress.java uses non-existent -XX:+VerifyObjectEquals
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232729 Shenandoah: assert ShenandoahHeap::cas_oop addresses are aligned
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232747 Shenandoah: Concurrent GC should deactivate SATB before processing weak roots
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232791 Shenandoah: passive mode should disable pacing
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232908 Shenandoah: compact heuristics has incorrect trigger "Free is lower than allocated recently"
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8222766 Shenandoah: streamline post-LRB CAS barrier (x86)
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233021 Shenandoah: SBSC2::is_shenandoah_lrb_call should match all LRB shapes
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232992 Shenandoah: Implement self-fixing interpreter LRB
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233303 Shenandoah: verifier assert erroneously uses byte_size_in_exact_unit
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233387 Shenandoah: passive mode should disable pacing ergonomically
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233520 Shenandoah: do not sleep when thread is attaching
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233574 Shenandoah: build is broken without jfr
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233401 Shenandoah: Refactor/cleanup Shenandoah load barrier code
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233337 Shenandoah: Cleanup AArch64 SBSA::load_reference_barrier_not_null()
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233339 Shenandoah: Centralize load barrier decisions into ShenandoahBarrierSet
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8233850 Shenandoah: Shenandoah thread count ergonomics should be container aware
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8234232 [TESTBUG] gc/shenandoah/jvmti/TestHeapDump.java fails with -Xcomp
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8234768 Shenandoah: Streamline enqueueing runtime barriers
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8228720 Shenandoah: Implementation of concurrent class unloading
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8235260 Shenandoah: Don't allow recycle-assist until concurrent roots are done
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8235337 Shenandoah: Fix evac OOM scoping for concurrent class unloading
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8235355 Shenandoah: Resolve deadlock between OOM handler and nmethod lock
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8235685 Shenandoah: Enable leak profiler
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8235776 Shenandoah: Shenandoah root updater not always uses right code blob closure
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231670 Remove TaskExecutor abstraction used in preserved marks processing
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8228818 Shenandoah: Processing weak roots in concurrent phase when possible
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8236851 Shenandoah: More details in Traversal GC event messages
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237017 Shenandoah: Remove racy assertion
✖ ✖ ✖ ✔ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237182 Update copyright header for shenandoah and epsilon files
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237223 Shenandoah: important flags should not be ergonomic for concurrent class unloading
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237543 Shenandoah: More asserts around code roots
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237570 Shenandoah: cleanup uses of allocation/free threshold in static heuristics
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8237586 Shenandoah: provide option to disable periodic GC
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8234399 Shenandoah: Cleanup native load barrier
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8236880 Shenandoah: Move string dedup cleanup into concurrent phase
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8238162 Shenandoah: Remove ShenandoahTaskTerminator wrapper
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8238574 Shenandoah: Assertion failure due to missing null check
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8239081 Shenandoah: Consolidate C1 LRB and native barriers
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8239868 Shenandoah: ditch C2 node limit adjustments
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8239904 Shenandoah: accumulated penalties should not be over 100% of capacity
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240069 Shenandoah: turn more flags diagnostic
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240076 Shenandoah: pacer should cover reset and preclean phases
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8239354 Shenandoah: minor enhancements to traversal GC
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240215 Shenandoah: remove ShenandoahAllocationTrace
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240216 Shenandoah: remove ShenandoahTerminationTrace
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240217 Shenandoah: remove ShenandoahEvacAssist
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240511 Shenandoah: parallel safepoint workers count should be ParallelGCThreads
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240534 Shenandoah: ditch debug safepoint timeout adjustment
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240315 Shenandoah: Rename ShLBN::get_barrier_strength()
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240671 Shenandoah: refactor ShenandoahPhaseTimings
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220503 Move definition of ShenandoahTerminatorTerminator::should_exit_termination() to .cpp file
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8230853 Shenandoah: replace leftover assert(is_in(...)) with rich asserts
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240749 Shenandoah: refactor ShenandoahUtils
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240750 Shenandoah: remove leftover files and mentions of ShenandoahAllocTracker
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225216 gc/logging/TestMetaSpaceLog.java doesn't work for Shenandoah
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240868 Shenandoah: remove CM-with-UR piggybacking cycles
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240872 Shenandoah: Avoid updating new regions from start of evacuation
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240873 Shenandoah: Short-cut arraycopy barriers
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240915 Shenandoah: Remove unused fields in init mark tasks
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240917 Shenandoah: Avoid scanning thread code roots twice in all root scanner
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240948 Shenandoah: cleanup not-forwarded-objects paths after JDK-8240868
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231668 Remove ForceDynamicNumberOfGCThreads
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241093 Shenandoah: editorial changes in flag descriptions
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241068 Shenandoah: improve ShenandoahTraversalGC constructor arguments
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241139 Shenandoah: distribute mark-compact work exactly to minimize fragmentation
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241351 Shenandoah: fragmentation metrics overhaul
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241435 Shenandoah: avoid disabling pacing with "aggressive"
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241520 Shenandoah: simplify region sequence numbers handling
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241534 Shenandoah: region status should include update watermark
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241545 Shenandoah: purge root work overwrites counters after JDK-8228818
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241583 Shenandoah: turn heap lock asserts into macros
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241668 Shenandoah: make ShenandoahHeapRegion not derive from ContiguousSpace
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241673 Shenandoah: refactor anti-false-sharing padding
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241692 Shenandoah: remove ShenandoahHeapRegion::_reserved
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241700 Shenandoah: Fold ShenandoahKeepAliveBarrier flag into ShenandoahSATBBarrier
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241740 Shenandoah: remove ShenandoahHeapRegion::_heap
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241743 Shenandoah: refactor and inline ShenandoahHeap::heap()
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241748 Shenandoah: inline MarkingContext TAMS methods
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241838 Shenandoah: no need to trash cset during final mark
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241841 Shenandoah: ditch one of allocation type counters in ShenandoahHeapRegion
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241842 Shenandoah: inline ShenandoahHeapRegion::region_number
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241844 Shenandoah: rename ShenandoahHeapRegion::region_number
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241845 Shenandoah: align ShenandoahHeapRegions to cache lines
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241160 Concurrent class unloading reports GCTraceTime events as JFR pause sub-phase events
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241926 Shenandoah: only print heap changes for operations that directly affect it
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241983 Shenandoah: simplify FreeSet logging
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241985 Shenandoah: simplify collectable garbage logging
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242040 Shenandoah: print allocation failure type
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242041 Shenandoah: adaptive heuristics should account evac reserve in free target
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242042 Shenandoah: tune down ShenandoahGarbageThreshold
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242075 Shenandoah: rename ShenandoahHeapRegionSize flag
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242082 Shenandoah: Purge Traversal mode
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242083 Shenandoah: split "Prepare Evacuation" tracking into cset/freeset counters
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242089 Shenandoah: per-worker stats should be summed up, not averaged
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242101 Shenandoah: coalesce and parallelise heap region walks during the pauses
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242114 Shenandoah: remove ShenandoahHeapRegion::reset_alloc_metadata_to_shared
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242054 Shenandoah: New incremental-update mode
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242130 Shenandoah: Simplify arraycopy-barrier dispatching
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242211 Shenandoah: remove ShenandoahHeuristics::RegionData::_seqnum_last_alloc
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242212 Shenandoah: initialize ShenandoahHeuristics::_region_data eagerly
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242213 Shenandoah: remove ShenandoahHeuristics::_bytes_in_cset
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242217 Shenandoah: Enable GC mode to be diagnostic/experimental and have a name
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242227 Shenandoah: transit regions to cset state when adding to collection set
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242228 Shenandoah: remove unused ShenandoahCollectionSet methods
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242229 Shenandoah: inline ShenandoahHeapRegion liveness-related methods
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242267 Shenandoah: regions space needs to be aligned by os::vm_allocation_granularity()
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242271 Shenandoah: add test to verify GC mode unlock
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242273 Shenandoah: accept either SATB or IU barriers, but not both
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242301 Shenandoah: Inline LRB runtime call
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242316 Shenandoah: Turn NULL-check into assert in SATB slow-path entry
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241984 Shenandoah: enhance GCTimer and JFR support
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242353 Shenandoah: micro-optimize region liveness handling
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242365 Shenandoah: use uint16_t instead of jushort for liveness cache
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242375 Shenandoah: Remove ShenandoahHeuristic::record_gc_start/end methods
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242400 Shenandoah: Restore logging to pre-jdk8241984 format
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241142 Shenandoah: should not use parallel reference processing with single GC thread
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242602 Shenandoah: allow earlier recycle of trashed regions during concurrent root processing
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242625 Shenandoah: restore heap logging for Degenerated/Full cycles
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242638 Shenandoah: restore heap logging for uncommit
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242641 Shenandoah: clear live data and update TAMS optimistically
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8242643 Shenandoah: split concurrent weak and strong root processing
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243008 Shenandoah: TestVolatilesShenandoah test failed on aarch64
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243238 Shenandoah: explicit GC request should wait for a complete GC cycle
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243307 Shenandoah: remove ShCollectionSet::live_data
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243291 Shenandoah: no need to retire TLABs at Init Update Refs
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243301 Shenandoah: ditch ShenandoahAllowMixedAllocs
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243395 Shenandoah: demote guarantee in ShenandoahPhaseTimings::record_workers_end
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8239786 Shenandoah: print per-cycle statistics
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243460 Shenandoah: purge init_update_refs_prepare counter
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243463 Shenandoah: ditch total_pause counters
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243464 Shenandoah: print statistic counters in time order
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243465 Shenandoah: ditch unused pause_other, conc_other counters
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243487 Shenandoah: make _num_phases illegal phase type
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243494 Shenandoah: set counters once per cycle
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243578 Shenandoah: Cleanup ShenandoahStringDedup::parallel_oops_do()
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243848 Shenandoah: Windows build fails after JDK-8239786
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243573 Shenandoah: rename GCParPhases and related code
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8243495 Shenandoah: print root statistics for concurrent weak/strong root phases
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244180 Shenandoah: carry Phase to ShWorkerTimingsTracker explicitly
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244226 Shenandoah: per-cycle statistics contain worker data from previous cycles
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244200 Shenandoah: build breakages after JDK-8241743
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244326 Shenandoah: global statistics should not accept bogus samples
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244328 Shenandoah: move ShenandoahThreadLocalData::_disarmed_value initialization
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244420 Shenandoah: Ensure _disarmed_value offset < 128
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244509 Shenandoah: refactor ShenandoahBarrierC2Support::test_* methods
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244510 Shenandoah: invert SHC2Support::is_in_cset condition
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244667 Shenandoah: SBC2Support::test_gc_state takes loop for wrong control
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244730 Shenandoah: gc/shenandoah/options/TestHeuristicsUnlock.java should only verify the heuristics
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244732 Shenandoah: move heuristics code to gc/shenandoah/heuristics
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244737 Shenandoah: move mode code to gc/shenandoah/mode
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244739 Shenandoah: break superclass dependency on ShenandoahNormalMode
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244740 Shenandoah: rename ShenandoahNormalMode to ShenandoahSATBMode
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244759 Shenandoah: print verbose class unloading counters
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244807 Shenandoah: ditch filter in ShenandoahUnload::unload
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241062 Shenandoah: rich asserts trigger "empty statement" inspection
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244953 Shenandoah: gc/shenandoah/TestStringInternCleanup fails with broken string table root
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245124 Shenandoah: optimize code root evacuation/update during concurrent class unloading
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245461 Shenandoah: refine mode name()-s
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245463 Shenandoah: refine ShenandoahPhaseTimings constructor arguments
✖ ✖ ✖ ✔ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8244729 Shenandoah: remove resolve paths from SBSA::generate_shenandoah_lrb
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245464 Shenandoah: allocate collection set bitmap at lower addresses
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245465 Shenandoah: test_in_cset can use more efficient encoding
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245726 Shenandoah: lift/cleanup ShenandoahHeuristics names and properties
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245754 Shenandoah: ditch ShenandoahAlwaysPreTouch
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245755 Shenandoah: missing logging for CWR Roots
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245757 Shenandoah: AlwaysPreTouch should not disable heap resizing or uncommits
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245812 Shenandoah: compute root phase parallelism
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245814 Shenandoah: reconsider format specifiers for stats
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245823 Shenandoah: inline/optimize ShenandoahEvacOOMScope
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245825 Shenandoah: Remove diagnostic flag ShenandoahConcurrentScanCodeRoots
✖ ✖ ✖ ✔ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245880 Shenandoah: check class unloading flag early in concurrent code root scan
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8246097 Shenandoah: limit parallelism in CLDG root handling
✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8246100 Shenandoah: walk roots in more efficient order
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8246433 Shenandoah: walk roots in more efficient order in ShenandoahRootUpdater
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8246458 Shenandoah: TestAllocObjects.java test fail with -XX:+ShenandoahVerify
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8246591 Shenandoah: move string dedup roots scanning to concurrent phase
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247367 Shenandoah: pacer should wait on lock instead of exponential backoff
✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247575 serviceability/dcmd/gc/HeapDumpCompressedTest unlocks experimental options for Shenandoah and Z
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247751 Shenandoah: options tests should run with smaller heaps
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247754 Shenandoah: mxbeans tests can be shorter
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247757 Shenandoah: split heavy tests by heuristics to improve parallelism
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8247860 Shenandoah: add update watermark line in rich assert failure message
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8248227 Shenandoah: Refactor Shenandoah::heap() to match other GCs
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8248632 Shenandoah: build fails without both JVMTI and JFR
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8232782 Shenandoah: streamline post-LRB CAS barrier (aarch64)
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8248652 Shenandoah: SATB buffer handling may assume no forwarded objects
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8249137 Remove CollectedHeap::obj_size
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8249649 Shenandoah: provide per-cycle pacing stats
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8249801 Shenandoah: Clear soft-refs on requested GC cycle
✖ ✖ ✖ ✔ ✖ ✖ ✖ ❉ ✔ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8249787 Make TestGCLocker more resilient with concurrent GCs
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8249953 Shenandoah: gc/shenandoah/mxbeans tests should account for corner cases
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241007 Shenandoah: remove ShenandoahCriticalControlThreadPriority support
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241574 Shenandoah: remove ShenandoahAssertToSpaceClosure
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8251359 Shenandoah: filter null oops before calling enqueue/SATB barrier
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8241065 Shenandoah: remove leftover code after JDK-8231086
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8245721 Refactor the TaskTerminator
✖ ✖ ✖ ❉ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8251487 Shenandoah: missing detail timing tracking for final mark cleaning phase
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8252648 Shenandoah: name gang tasks consistently
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8252660 Shenandoah: support manageable SoftMaxHeapSize option
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8240751 Shenandoah: fold ShenandoahTracer definition
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8253222 Shenandoah: unused AlwaysTrueClosure after JDK-8246591
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8253224 Shenandoah: ShenandoahStrDedupQueue destructor calls virtual num_queues()
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8253226 Shenandoah: remove unimplemented ShenandoahStrDedupQueue::verify
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8253244 Shenandoah: cleanup includes in Shenandoah root processor files
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8253434 Shenandoah: Cleanup ShenandoahRootScanner
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8253493 Shenandoah: Remove ShenandoahSerialRoot definition
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8252857 AArch64: Shenandoah C1 CAS is not sequentially consistent
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8254075 Shenandoah: Remove ShenandoahCodeRootsStyle diagnostic flag and related test
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8254103 Shenandoah: Move updating thread roots to concurrent phase
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8254560 Shenandoah: Concurrent Strong Roots logging is incorrect
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8254320 Shenandoah: C2 native LRB should activate for non-cset objects
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8254573 Shenandoah: Streamline/inline native-LRB entry point
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255070 Shenandoah: Use single thread for concurrent CLD liveness test
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255457 Shenandoah: cleanup ShenandoahMarkTask
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255691 Shenandoah: Invoke native-LRB only on non-strong refs
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255760 Shenandoah: match constants style in ShenandoahMarkTask fallback
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8254315 Shenandoah: Concurrent weak reference processing
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255762 Shenandoah: Consolidate/streamline interpreter LRBs
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255955 Shenandoah: Only STW GC should process concurrent roots at pauses
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256015 Shenandoah: Add missing Shenandoah implementation in WB_isObjectInOldGen
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256046 Shenandoah: Mix-in NULL_PTR in non-strong ShLRBNode's type
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256664 Shenandoah: Cleanup after JDK-8212879
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256806 Shenandoah: optimize shenandoah/jni/TestPinnedGarbage.java test
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8257230 assert(InitialHeapSize >= MinHeapSize) failed: Ergonomics decided on incompatible initial and minimum heap sizes
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8258252 Move PtrQueue enqueue to PtrQueueSet subclasses
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8258255 Move PtrQueue active flag to SATBMarkQueue
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8251944 Add Shenandoah test config to compiler/gcbarriers/UnsafeIntrinsicsTest.java
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8258254 Move PtrQueue flush to PtrQueueSet subclasses
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8259377 Shenandoah: Enhance weak reference processing time tracking
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8259580 Shenandoah: uninitialized label in VerifyThreadGCState
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255019 Shenandoah: Split STW and concurrent mark into separate classes
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8259849 Shenandoah: Rename store-val to IU-barrier
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8259488 Shenandoah: Missing timing tracking for STW CLD root processing
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260005 Shenandoah: Remove unused AlwaysTrueClosure in ShenandoahConcurrentRootScanner::roots_do()
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255765 Shenandoah: Isolate concurrent, degenerated and full GC
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8259954 gc/shenandoah/mxbeans tests fail with -Xcomp
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8258742 Move PtrQueue reset to PtrQueueSet subclasses
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8256298 Shenandoah: Enable concurrent stack processing
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260421 Shenandoah: Fix conc_mark_roots timing name and indentations
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260497 Shenandoah: Improve SATB flushing
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260584 Shenandoah: simplify "Concurrent Thread Roots" logging
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260586 Shenandoah: simplify "Concurrent Weak References" logging
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8255837 Shenandoah: Remove ShenandoahConcurrentRoots class
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8259404 Shenandoah: Fix time tracking in parallel_cleaning
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260591 Shenandoah: improve parallelism for concurrent thread root scans
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260004 Shenandoah: Rename ShenandoahMarkCompact to ShenandoahFullGC
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260998 Shenandoah: Restore reference processing statistics reporting
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8260736 Shenandoah: Cleanup includes in ShenandoahGC and families
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261251 Shenandoah: Use object size for full GC humongous compaction
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261496 Shenandoah: reconsider pacing updates memory ordering
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261413 Shenandoah: Disable class-unloading in I-U mode
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261473 Shenandoah: Add breakpoint support
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261984 Shenandoah: Remove unused ShenandoahPushWorkerQueuesScope class
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8261973 Shenandoah: Cleanup/simplify root verifier
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8262876 Shenandoah: Fix comments regarding VM_ShenandoahOperation inheritances
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8262885 Shenandoah: FullGC prologue does not need to save/restore heap has_forwarded_object flag
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8262122 [TESTBUG] Shenandoah-specific variant of TestReferenceRefersTo
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8263030 Remove Shenandoah leftovers from ReferenceProcessor
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8263433 Shenandoah: Don't expect forwarded objects in set_concurrent_mark_in_progress()
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8262398 Shenandoah: Disable nmethod barrier and stack watermark when running with passive mode
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8263832 Shenandoah: Fixing parallel thread iteration in final mark task
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8263861 Shenandoah: Remove unused member in ShenandoahGCStateResetter
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8264374 Shenandoah: Remove leftover parallel reference processing argument
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8264718 Shenandoah: enable string deduplication during root scanning
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8265995 Shenandoah: Move ShenandoahInitMarkRootsClosure close to its use
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8266018 Shenandoah: fix an incorrect assert
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8266440 Shenandoah: TestReferenceShortcutCycle.java test failed on AArch64
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8266813 Shenandoah: Use shorter instruction sequence for checking if marking in progress
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231672 Simplify the reference processing parallelization framework
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8268699 Shenandoah: Add test for JDK-8268127
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8269478 Shenandoah: gc/shenandoah/mxbeans tests should be more resilient
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8270096 Shenandoah: Optimize gc/shenandoah/TestRefprocSanity.java for interpreter mode
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8269924 Shenandoah: Introduce weak/strong marking asserts
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8272327 Shenandoah: Avoid enqueuing duplicate string candidates
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8267188 gc/stringdedup/TestStringDeduplicationInterned.java fails with Shenandoah
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8271834 TestStringDeduplicationAgeThreshold intermittent failures on Shenandoah
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8273614 Shenandoah: intermittent timeout with ConcurrentGCBreakpoint tests
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8275051 Shenandoah: Correct ordering of requested gc cause and gc request flag
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8276801 gc/stress/CriticalNativeStress.java fails intermittently with Shenandoah
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8276927 [ppc64] Port shenandoahgc to linux on ppc64le
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ JDK-8278767 Shenandoah: Remove unused ShenandoahRootScanner
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ JDK-8278551 Shenandoah: Adopt WorkerThread::worker_id() to replace Shenandoah specific implementation
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ JDK-8279168 Shenandoah: Remove unused always_true in ShenandoahRootAdjuster::roots_do()
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ JDK-8283186 Explicitly pass a third temp register to MacroAssembler::store_heap_oop
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ JDK-8286681 ShenandoahControlThread::request_gc misses the case of GCCause::_codecache_GC_threshold
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ JDK-8286814 Shenandoah: RedefineRunningMethods.java test failed with Loom
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ JDK-8286829 Shenandoah: fix Shenandoah Loom support
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✔ ✖ ✖ ✖ JDK-8287734 Shenandoah: Consolidate marking closures
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8287227 Shenandoah: A couple of virtual thread tests failed with iu mode even without Loom enabled.
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8287818 Shenandoah: adapt nmethod arming from Loom
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8290269 gc/shenandoah/TestVerifyJCStress.java fails due to invalid tag: required after JDK-8290023
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8287805 Shenandoah: consolidate evacuate-update-root closures
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8290374 Shenandoah: Remove inaccurate comment on SBS::load_reference_barrier()
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8291289 gc/TestPLABAdaptToMinTLABSize fails after JDK-8289137
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8292868 Explicitly pass a third temp register to MacroAssembler::store_heap_oop for aarch64
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8293492 ShenandoahControlThread missing from hs-err log and thread dump
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8293351 Add second tmp register to aarch64 BarrierSetAssembler::load_at
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8293252 Shenandoah: ThreadMXBean synchronizer tests crash with aggressive heuristics
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8293782 Shenandoah: some tests failed on lock rank check
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8294775 Shenandoah: reduce contention on _threads_in_evac
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8297285 Shenandoah pacing causes assertion failure during VM initialization
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ❉ ✖ ✖ ✖ JDK-8298138 Shenandoah: HdrSeq asserts "sub-bucket index (512) overflow for value ( 1.00)"
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ JDK-8299879 CollectedHeap hierarchy should use override
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ JDK-8301225 Replace NULL with nullptr in share/gc/shenandoah/
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ JDK-8305716 Enhancements for printing age tables
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ JDK-8306321 Add an accessor for the top of a PLAB
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ❉ ✖ ✖ ✖ JDK-8307395 Add missing STS to Shenandoah
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ❉ ✖ ✖ ✖ JDK-8309297 Adjust ShenandoahHeap print_heap_regions_on
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8309956 Shenandoah: Strengthen the mark word check in string dedup
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8311656 Shenandoah: Unused ShenandoahSATBAndRemarkThreadsClosure::_claim_token
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ JDK-8314276 Improve PtrQueue API around size/capacity
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8317350 Move code cache purging out of CodeCache::UnloadingScope
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ JDK-8319439 Move BufferNode from PtrQueue files to new files
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✔ ❉ ✖ JDK-8321815 Shenandoah: gc state should be synchronized to java threads only once per safepoint
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✔ ❉ ✖ JDK-8322418 Problem list gc/TestAllocHumongousFragment.java subtests for 8298781
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✔ ❉ ✖ JDK-8322503 Shenandoah: Clarify gc state usage
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✔ ❉ ✖ JDK-8323021 Shenandoah: Encountered reference count always attributed to first worker thread
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✔ ❉ ✖ JDK-8323428 Shenandoah: Unused memory in regions compacted during a full GC should be mangled
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✔ ❉ ✖ JDK-8328075 Shenandoah: Avoid forwarding when objects don't move in full-GC
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ❉ ✖ JDK-8331405 Shenandoah: Optimize ShenandoahLock with TTAS
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ JDK-8332841 GenShen: Pull shared members from control thread into common base class
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✔ ❉ JDK-8333716 Shenandoah: Check for disarmed method before taking the nmethod lock
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✔ ❉ JDK-8331411 Shenandoah: Reconsider spinning duration in ShenandoahLock
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✔ ❉ JDK-8334769 Shenandoah: Move CodeCache_lock close to its use in ShenandoahConcurrentNMethodIterator
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8337241 Shenandoah: Normalize include guards
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8338688 Shenandoah: Avoid calling java_lang_Class accessors in asserts/verifier
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8340400 Shenandoah: Whitebox breakpoint GC requests may cause assertions
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8340183 Shenandoah: Incorrect match for clone barrier in is_gc_barrier_node
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8340408 Shenandoah: Remove redundant task stats printing code in ShenandoahTaskQueue
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8341242 Shenandoah: LRB node is not matched as GC barrier after JDK-8340183
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ JDK-8332697 ubsan: shenandoahSimpleBitMap.inline.hpp:68:23: runtime error: signed integer overflow: -9223372036854775808 - 1 cannot be represented in type 'long int'
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ JDK-8341554 Shenandoah: Missing heap lock when updating usage for soft ref policy
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ JDK-8341668 Shenandoah: assert(tail_bits < (idx_t)BitsPerWord) failed: precondition
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8342041 Test gc/shenandoah/oom/TestClassLoaderLeak.java slow on Windows after JDK-8340490
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8228665 Shenandoah: Implementation of Concurrent nmethod evacuation
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8336344 Shenandoah: Shenandoah should also rendezvous GC threads
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8343226 Shenandoah: Move tenuring threshold constraint functions into shared constraints
✖ ✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8229835 Shenandoah should recommend -Xlog:safepoint+stats
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✔ ❉ JDK-8335904 Fix invalid comment in ShenandoahLock

hotspot/jfr

Fix Versions Bug Synopsis
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ JDK-8279016 JFR Leak Profiler is broken with Shenandoah
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8274560 JFR: Add test for OldObjectSample event when using Shenandoah
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8224529 [TESTBUG] JFR TestShenandoahHeapRegion* tests fail on build w/o Shenandoah
✖ ✖ ✖ ❉ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8251354 Shenandoah: Fix JFR test failures
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8274563 jfr/event/oldobject/TestClassLoaderLeak.java fails when GC cycles are not happening
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ❉ ✔ ✖ ✖ ✖ JDK-8293828 JFR: jfr/event/oldobject/TestClassLoaderLeak.java still fails when GC cycles are not happening

hotspot/other

Fix Versions Bug Synopsis
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8310075 Revert accidental change to jcheck configuration for shenandoah project

hotspot/runtime

Fix Versions Bug Synopsis
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8252096 Shenandoah: adjust SerialPageShiftCount for x86_32 and JFR
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8272654 Mark word accesses should not use Access API
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8252592 Non-PCH build is broken after JDK-8251560
✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8253778 ShenandoahSafepoint::is_at_shenandoah_safepoint should not access VMThread state from other threads
✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8217854 [TESTBUG] runtime/CompressedOops/UseCompressedOops.java fails with Shenandoah
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8218041 Assorted wrong/missing includes
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220496 Race in java_lang_String::length() when deduplicating
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8263375 Support stack watermarks in Zero VM

hotspot/svc

Fix Versions Bug Synopsis
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8314501 Shenandoah: sun/tools/jhsdb/heapconfig/JMapHeapConfigTest.java fails
✖ ✖ ✖ ✔ ✖ ✖ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8231931 [TESTBUG] serviceability/sa/TestUniverse.java looks for wrong string with Shenandoah

hotspot/svc-agent

Fix Versions Bug Synopsis
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8218734 SA: Incorrect and raw loads of OopHandles
✖ ✖ ✖ ✖ ✖ ✔ ❉ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8225801 Shenandoah: Adjust SA to reflect recent forwarding pointer changes
✖ ✖ ✖ ✔ ✔ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8218733 SA: CollectedHeap provides broken implementation for used() and capacity()
✖ ✖ ✖ ✖ ✖ ❉ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8220602 Shenandoah-SA: Enable best-effort implementation of heap walk

hotspot/test

Fix Versions Bug Synopsis
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ❉ ✖ ✖ JDK-8311986 Disable runtime/os/TestTracePageSizes.java for ShenandoahGC

infrastructure/build

Fix Versions Bug Synopsis
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
✔ ✖ ✖ ✔ ✖ ✖ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8321123 [Shenandoah/JDK21] Fix repo permissions
✖ ✖ ✖ ✖ ❉ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ ✔ ✖ ✖ ✖ JDK-8215356 Disable x86_32 Shenandoah build to avoid hotspot/tier1 failures