# HG changeset patch
# User rkennke
# Date 1579704902 -3600
# Wed Jan 22 15:55:02 2020 +0100
# Node ID 63a288f3f25a5785460fa25756bd7d1e532cd874
# Parent ca116bb90caf334f8a78c6c763321f7c76452540
8227269: Slow class loading when running with JDWP
Reviewed-by: sspitsyn, cjplummer
diff --git a/src/jdk.jdwp.agent/share/native/libjdwp/classTrack.c b/src/jdk.jdwp.agent/share/native/libjdwp/classTrack.c
--- a/src/jdk.jdwp.agent/share/native/libjdwp/classTrack.c
+++ b/src/jdk.jdwp.agent/share/native/libjdwp/classTrack.c
@@ -22,273 +22,204 @@
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
+
/*
* This module tracks classes that have been prepared, so as to
- * be able to compute which have been unloaded. On VM start-up
- * all prepared classes are put in a table. As class prepare
- * events come in they are added to the table. After an unload
- * event or series of them, the VM can be asked for the list
- * of classes; this list is compared against the table keep by
- * this module, any classes no longer present are known to
- * have been unloaded.
- *
- * For efficient access, classes are keep in a hash table.
- * Each slot in the hash table has a linked list of KlassNode.
- *
- * Comparing current set of classes is compared with previous
- * set by transferring all classes in the current set into
- * a new table, any that remain in the old table have been
- * unloaded.
+ * be able to report which have been unloaded. On VM start-up
+ * and whenever new classes are loaded, all prepared classes'
+ * signatures are attached as JVMTI tag to the class object.
+ * Class unloading is tracked by registering
+ * ObjectFree callback on class objects. When this happens, we find
+ * the signature of the unloaded class(es) and report them back
+ * to the event handler to synthesize class-unload-events.
*/
#include "util.h"
#include "bag.h"
#include "classTrack.h"
-/* ClassTrack hash table slot count */
-#define CT_HASH_SLOT_COUNT 263 /* Prime which eauals 4k+3 for some k */
+#define NOT_TAGGED 0
-typedef struct KlassNode {
- jclass klass; /* weak global reference */
- char *signature; /* class signature */
- struct KlassNode *next; /* next node in this slot */
-} KlassNode;
+/*
+ * The JVMTI tracking env to keep track of klass tags for class-unloads
+ */
+static jvmtiEnv* trackingEnv;
+
+/*
+ * A bag containing all the deleted classes' signatures. Must be accessed under
+ * classTrackLock.
+ */
+struct bag* deletedSignatures;
/*
- * Hash table of prepared classes. Each entry is a pointer
- * to a linked list of KlassNode.
+ * Lock to keep integrity of deletedSignatures.
*/
-static KlassNode **table;
+static jrawMonitorID classTrackLock;
/*
- * Return slot in hash table to use for this class.
+ * Invoke the callback when classes are freed, find and record the signature
+ * in deletedSignatures. Those are only used in addPreparedClass() by the
+ * same thread.
*/
-static jint
-hashKlass(jclass klass)
+static void JNICALL
+cbTrackingObjectFree(jvmtiEnv* jvmti_env, jlong tag)
{
- jint hashCode = objectHashCode(klass);
- return abs(hashCode) % CT_HASH_SLOT_COUNT;
+ debugMonitorEnter(classTrackLock);
+ if (deletedSignatures == NULL) {
+ debugMonitorExit(classTrackLock);
+ return;
+ }
+ *(char**)bagAdd(deletedSignatures) = (char*)tag;
+
+ debugMonitorExit(classTrackLock);
}
/*
- * Transfer a node (which represents klass) from the current
- * table to the new table.
- */
-static void
-transferClass(JNIEnv *env, jclass klass, KlassNode **newTable) {
- jint slot = hashKlass(klass);
- KlassNode **head = &table[slot];
- KlassNode **newHead = &newTable[slot];
- KlassNode **nodePtr;
- KlassNode *node;
-
- /* Search the node list of the current table for klass */
- for (nodePtr = head; node = *nodePtr, node != NULL; nodePtr = &(node->next)) {
- if (isSameObject(env, klass, node->klass)) {
- /* Match found transfer node */
-
- /* unlink from old list */
- *nodePtr = node->next;
-
- /* insert in new list */
- node->next = *newHead;
- *newHead = node;
-
- return;
- }
- }
-
- /* we haven't found the class, only unloads should have happenned,
- * so the only reason a class should not have been found is
- * that it is not prepared yet, in which case we don't want it.
- * Asset that the above is true.
- */
-/**** the HotSpot VM doesn't create prepare events for some internal classes ***
- JDI_ASSERT_MSG((classStatus(klass) &
- (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY))==0,
- classSignature(klass));
-***/
-}
-
-/*
- * Delete a hash table of classes.
- * The signatures of classes in the table are returned.
- */
-static struct bag *
-deleteTable(JNIEnv *env, KlassNode *oldTable[])
-{
- struct bag *signatures = bagCreateBag(sizeof(char*), 10);
- jint slot;
-
- if (signatures == NULL) {
- EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"signatures");
- }
-
- for (slot = 0; slot < CT_HASH_SLOT_COUNT; slot++) {
- KlassNode *node = oldTable[slot];
-
- while (node != NULL) {
- KlassNode *next;
- char **sigSpot;
-
- /* Add signature to the signature bag */
- sigSpot = bagAdd(signatures);
- if (sigSpot == NULL) {
- EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"signature bag");
- }
- *sigSpot = node->signature;
-
- /* Free weak ref and the node itself */
- JNI_FUNC_PTR(env,DeleteWeakGlobalRef)(env, node->klass);
- next = node->next;
- jvmtiDeallocate(node);
-
- node = next;
- }
- }
- jvmtiDeallocate(oldTable);
-
- return signatures;
-}
-
-/*
- * Called after class unloads have occurred. Creates a new hash table
- * of currently loaded prepared classes.
- * The signatures of classes which were unloaded (not present in the
- * new table) are returned.
+ * Called after class unloads have occurred.
+ * The signatures of classes which were unloaded are returned.
*/
struct bag *
classTrack_processUnloads(JNIEnv *env)
{
- KlassNode **newTable;
- struct bag *unloadedSignatures;
-
- unloadedSignatures = NULL;
- newTable = jvmtiAllocate(CT_HASH_SLOT_COUNT * sizeof(KlassNode *));
- if (newTable == NULL) {
- EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY, "classTrack table");
- } else {
-
- (void)memset(newTable, 0, CT_HASH_SLOT_COUNT * sizeof(KlassNode *));
-
- WITH_LOCAL_REFS(env, 1) {
-
- jint classCount;
- jclass *classes;
- jvmtiError error;
- int i;
-
- error = allLoadedClasses(&classes, &classCount);
- if ( error != JVMTI_ERROR_NONE ) {
- jvmtiDeallocate(newTable);
- EXIT_ERROR(error,"loaded classes");
- } else {
-
- /* Transfer each current class into the new table */
- for (i=0; i<classCount; i++) {
- jclass klass = classes[i];
- transferClass(env, klass, newTable);
- }
- jvmtiDeallocate(classes);
-
- /* Delete old table, install new one */
- unloadedSignatures = deleteTable(env, table);
- table = newTable;
- }
-
- } END_WITH_LOCAL_REFS(env)
-
+ debugMonitorEnter(classTrackLock);
+ if (deletedSignatures == NULL) {
+ // Class tracking not initialized, nobody's interested.
+ debugMonitorExit(classTrackLock);
+ return NULL;
}
-
- return unloadedSignatures;
+ struct bag* deleted = deletedSignatures;
+ deletedSignatures = bagCreateBag(sizeof(char*), 10);
+ debugMonitorExit(classTrackLock);
+ return deleted;
}
/*
- * Add a class to the prepared class hash table.
- * Assumes no duplicates.
+ * Add a class to the prepared class table.
*/
void
-classTrack_addPreparedClass(JNIEnv *env, jclass klass)
+classTrack_addPreparedClass(JNIEnv *env_unused, jclass klass)
{
- jint slot = hashKlass(klass);
- KlassNode **head = &table[slot];
- KlassNode *node;
jvmtiError error;
+ jvmtiEnv* env = trackingEnv;
- if (gdata->assertOn) {
- /* Check this is not a duplicate */
- for (node = *head; node != NULL; node = node->next) {
- if (isSameObject(env, klass, node->klass)) {
- JDI_ASSERT_FAILED("Attempting to insert duplicate class");
- break;
- }
+ if (gdata && gdata->assertOn) {
+ // Check this is not already tagged.
+ jlong tag;
+ error = JVMTI_FUNC_PTR(trackingEnv, GetTag)(env, klass, &tag);
+ if (error != JVMTI_ERROR_NONE) {
+ EXIT_ERROR(error, "Unable to GetTag with class trackingEnv");
}
+ JDI_ASSERT(tag == NOT_TAGGED);
}
- node = jvmtiAllocate(sizeof(KlassNode));
- if (node == NULL) {
- EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"KlassNode");
- }
- error = classSignature(klass, &(node->signature), NULL);
+ char* signature;
+ error = classSignature(klass, &signature, NULL);
if (error != JVMTI_ERROR_NONE) {
- jvmtiDeallocate(node);
EXIT_ERROR(error,"signature");
}
- if ((node->klass = JNI_FUNC_PTR(env,NewWeakGlobalRef)(env, klass)) == NULL) {
- jvmtiDeallocate(node->signature);
- jvmtiDeallocate(node);
- EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"NewWeakGlobalRef");
+ error = JVMTI_FUNC_PTR(trackingEnv, SetTag)(env, klass, (jlong)signature);
+ if (error != JVMTI_ERROR_NONE) {
+ jvmtiDeallocate(signature);
+ EXIT_ERROR(error,"SetTag");
}
+}
- /* Insert the new node */
- node->next = *head;
- *head = node;
+static jboolean
+setupEvents()
+{
+ jvmtiCapabilities caps;
+ memset(&caps, 0, sizeof(caps));
+ caps.can_generate_object_free_events = 1;
+ jvmtiError error = JVMTI_FUNC_PTR(trackingEnv, AddCapabilities)(trackingEnv, &caps);
+ if (error != JVMTI_ERROR_NONE) {
+ return JNI_FALSE;
+ }
+ jvmtiEventCallbacks cb;
+ memset(&cb, 0, sizeof(cb));
+ cb.ObjectFree = cbTrackingObjectFree;
+ error = JVMTI_FUNC_PTR(trackingEnv, SetEventCallbacks)(trackingEnv, &cb, sizeof(cb));
+ if (error != JVMTI_ERROR_NONE) {
+ return JNI_FALSE;
+ }
+ error = JVMTI_FUNC_PTR(trackingEnv, SetEventNotificationMode)(trackingEnv, JVMTI_ENABLE, JVMTI_EVENT_OBJECT_FREE, NULL);
+ if (error != JVMTI_ERROR_NONE) {
+ return JNI_FALSE;
+ }
+ return JNI_TRUE;
}
/*
- * Called once to build the initial prepared class hash table.
+ * Called once to initialize class-tracking.
*/
void
classTrack_initialize(JNIEnv *env)
{
- WITH_LOCAL_REFS(env, 1) {
-
- jint classCount;
- jclass *classes;
- jvmtiError error;
- jint i;
+ deletedSignatures = NULL;
+ classTrackLock = debugMonitorCreate("Deleted class tag lock");
+ trackingEnv = getSpecialJvmti();
+ if (trackingEnv == NULL) {
+ EXIT_ERROR(AGENT_ERROR_INTERNAL, "Failed to allocate tag-tracking jvmtiEnv");
+ }
- error = allLoadedClasses(&classes, &classCount);
- if ( error == JVMTI_ERROR_NONE ) {
- table = jvmtiAllocate(CT_HASH_SLOT_COUNT * sizeof(KlassNode *));
- if (table != NULL) {
- (void)memset(table, 0, CT_HASH_SLOT_COUNT * sizeof(KlassNode *));
- for (i=0; i<classCount; i++) {
- jclass klass = classes[i];
- jint status;
- jint wanted =
- (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY);
+
+ if (!setupEvents()) {
+ EXIT_ERROR(AGENT_ERROR_INTERNAL, "Unable to setup ObjectFree tracking");
+ }
- /* We only want prepared classes and arrays */
- status = classStatus(klass);
- if ( (status & wanted) != 0 ) {
- classTrack_addPreparedClass(env, klass);
- }
- }
- } else {
- jvmtiDeallocate(classes);
- EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"KlassNode");
+ jint classCount;
+ jclass *classes;
+ jvmtiError error;
+ jint i;
+
+ error = allLoadedClasses(&classes, &classCount);
+ if ( error == JVMTI_ERROR_NONE ) {
+ for (i = 0; i < classCount; i++) {
+ jclass klass = classes[i];
+ jint status;
+ jint wanted = JVMTI_CLASS_STATUS_PREPARED | JVMTI_CLASS_STATUS_ARRAY;
+ status = classStatus(klass);
+ if ((status & wanted) != 0) {
+ classTrack_addPreparedClass(env, klass);
}
- jvmtiDeallocate(classes);
- } else {
- EXIT_ERROR(error,"loaded classes array");
}
-
- } END_WITH_LOCAL_REFS(env)
-
+ jvmtiDeallocate(classes);
+ } else {
+ EXIT_ERROR(error,"loaded classes array");
+ }
}
+/*
+ * Called to activate class-tracking when a listener registers for EI_GC_FINISH.
+ */
+void
+classTrack_activate(JNIEnv *env)
+{
+ debugMonitorEnter(classTrackLock);
+ deletedSignatures = bagCreateBag(sizeof(char*), 1000);
+ debugMonitorExit(classTrackLock);
+}
+
+static jboolean
+cleanDeleted(void *signatureVoid, void *arg)
+{
+ char* sig = *(char**)signatureVoid;
+ jvmtiDeallocate(sig);
+ return JNI_TRUE;
+}
+
+/*
+ * Called when agent detaches.
+ */
void
classTrack_reset(void)
{
+ debugMonitorEnter(classTrackLock);
+
+ if (deletedSignatures != NULL) {
+ bagEnumerateOver(deletedSignatures, cleanDeleted, NULL);
+ bagDestroyBag(deletedSignatures);
+ deletedSignatures = NULL;
+ }
+
+ debugMonitorExit(classTrackLock);
}
diff --git a/src/jdk.jdwp.agent/share/native/libjdwp/classTrack.h b/src/jdk.jdwp.agent/share/native/libjdwp/classTrack.h
--- a/src/jdk.jdwp.agent/share/native/libjdwp/classTrack.h
+++ b/src/jdk.jdwp.agent/share/native/libjdwp/classTrack.h
@@ -46,6 +46,12 @@
classTrack_initialize(JNIEnv *env);
/*
+ * Activates class tracking.
+ */
+void
+classTrack_activate(JNIEnv *env);
+
+/*
* Reset class tracking.
*/
void
diff --git a/src/jdk.jdwp.agent/share/native/libjdwp/eventHandler.c b/src/jdk.jdwp.agent/share/native/libjdwp/eventHandler.c
--- a/src/jdk.jdwp.agent/share/native/libjdwp/eventHandler.c
+++ b/src/jdk.jdwp.agent/share/native/libjdwp/eventHandler.c
@@ -1625,6 +1625,9 @@
node->handlerID = external? ++requestIdCounter : 0;
error = eventFilterRestricted_install(node);
+ if (node->ei == EI_GC_FINISH) {
+ classTrack_activate(getEnv());
+ }
if (error == JVMTI_ERROR_NONE) {
insert(getHandlerChain(node->ei), node);
}
diff --git a/src/jdk.jdwp.agent/share/native/libjdwp/util.c b/src/jdk.jdwp.agent/share/native/libjdwp/util.c
--- a/src/jdk.jdwp.agent/share/native/libjdwp/util.c
+++ b/src/jdk.jdwp.agent/share/native/libjdwp/util.c
@@ -1742,7 +1742,7 @@
}
/* Get the jvmti environment to be used with tags */
-static jvmtiEnv *
+jvmtiEnv *
getSpecialJvmti(void)
{
jvmtiEnv *jvmti;
diff --git a/src/jdk.jdwp.agent/share/native/libjdwp/util.h b/src/jdk.jdwp.agent/share/native/libjdwp/util.h
--- a/src/jdk.jdwp.agent/share/native/libjdwp/util.h
+++ b/src/jdk.jdwp.agent/share/native/libjdwp/util.h
@@ -414,4 +414,6 @@
void saveGlobalRef(JNIEnv *env, jobject obj, jobject *pobj);
void tossGlobalRef(JNIEnv *env, jobject *pobj);
+jvmtiEnv* getSpecialJvmti(void);
+
#endif