[prev in list] [next in list] [prev in thread] [next in thread] 

List:       openjdk-serviceability-dev
Subject:    Integrated: 8212879: Make JVMTI TagMap table concurrent
From:       Coleen Phillimore <coleenp () openjdk ! java ! net>
Date:       2020-11-19 14:33:16
Message-ID: XJbTNVPJgFyO62O_jn1Mo0KOs52qXuqNJX8X2O5Qeew=.60971263-b83c-4962-949e-3e6d8c0e2430 () github ! com
[Download RAW message or body]

On Fri, 30 Oct 2020 20:23:04 GMT, Coleen Phillimore <coleenp@openjdk.org> wrote:

> This change turns the HashTable that JVMTI uses for object tagging into a regular \
> Hotspot hashtable - the one in hashtable.hpp with resizing and rehashing.   Instead \
> of pointing directly to oops so that GC has to walk the table to follow oops and \
> then to rehash the table, this table points to WeakHandle.  GC walks the backing \
> OopStorages concurrently. 
> The hash function for the table is a hash of the lower 32 bits of the address.  A \
> flag is set during GC (gc_notification if in a safepoint, and through a call to \
> JvmtiTagMap::needs_processing()) so that the table is rehashed at the next use. 
> The gc_notification mechanism of weak oop processing is used to notify Jvmti to \
> post ObjectFree events.  In concurrent GCs there can be a window of time between \
> weak oop marking where the oop is unmarked, so dead (the phantom load in peek \
> returns NULL) but the gc_notification hasn't been done yet.  In this window, a heap \
> walk or GetObjectsWithTags call would not find an object before the ObjectFree \
> event is posted.  This is dealt with in two ways: 
> 1. In the Heap walk, there's an unconditional table walk to post events if events \
> are needed to post. 2. For GetObjectWithTags, if a dead oop is found in the table \
> and posting is required, we use the VM thread to post the event. 
> Event posting cannot be done in a JavaThread because the posting needs to be done \
> while holding the table lock, so that the JvmtiEnv state doesn't change before \
> posting is done.  ObjectFree callbacks are limited in what they can do as per the \
> JVMTI Specification.  The allowed callbacks to the VM already have code to allow \
> NonJava threads. 
> To avoid rehashing, I also tried to use object->identity_hash() but this breaks \
> because entries can be added to the table during heapwalk, where the objects use \
> marking.  The starting markWord is saved and restored.  Adding a hashcode during \
> this operation makes restoring the former markWord (locked, inflated, etc) too \
> complicated.  Plus we don't want all these objects to have hashcodes because \
> locking operations after tagging would have to always use inflated locks. 
> Much of this change is to remove serial weak oop processing for the weakProcessor, \
> ZGC and Shenandoah.  The GCs have been stress tested with jvmti code. 
> It has also been tested with tier1-6.
> 
> Thank you to Stefan, Erik and Kim for their help with this change.

This pull request has now been integrated.

Changeset: ba721f5f
Author:    Coleen Phillimore <coleenp@openjdk.org>
URL:       https://git.openjdk.java.net/jdk/commit/ba721f5f
Stats:     1891 lines in 49 files changed: 769 ins; 992 del; 130 mod

8212879: Make JVMTI TagMap table concurrent

Co-authored-by: Kim Barrett <kbarrett@openjdk.org>
Co-authored-by: Coleen Phillimore <coleenp@openjdk.org>
Reviewed-by: stefank, ihse, zgu, eosterlund, sspitsyn, kbarrett

-------------

PR: https://git.openjdk.java.net/jdk/pull/967


[prev in list] [next in list] [prev in thread] [next in thread]