diff --git a/test/hotspot/jtreg/serviceability/jvmti/vthread/HeapDump/VThreadInHeapDump.java b/test/hotspot/jtreg/serviceability/jvmti/vthread/HeapDump/VThreadInHeapDump.java index ec9362bf53f..89a9a0514bf 100644 --- a/test/hotspot/jtreg/serviceability/jvmti/vthread/HeapDump/VThreadInHeapDump.java +++ b/test/hotspot/jtreg/serviceability/jvmti/vthread/HeapDump/VThreadInHeapDump.java @@ -261,7 +261,7 @@ public class VThreadInHeapDump { private static List findStackRoot(List roots, ThreadObject thread) { List result = new ArrayList<>(); for (Root root: roots) { - if (root.getRefererId() == thread.getId()) { + if (root.getReferrerId() == thread.getId()) { result.add(root); } } @@ -286,7 +286,7 @@ public class VThreadInHeapDump { throw new RuntimeException("No root for " + className + " instance"); } log(" root: " + root.getDescription()); - JavaHeapObject referrer = root.getReferer(); + JavaHeapObject referrer = root.getReferrer(); log(" referrer: " + referrer); } diff --git a/test/lib/jdk/test/lib/hprof/model/JavaHeapObject.java b/test/lib/jdk/test/lib/hprof/model/JavaHeapObject.java index 03eb0b657a3..b50045a7287 100644 --- a/test/lib/jdk/test/lib/hprof/model/JavaHeapObject.java +++ b/test/lib/jdk/test/lib/hprof/model/JavaHeapObject.java @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -53,13 +53,13 @@ public abstract class JavaHeapObject extends JavaThing { // // Who we refer to. This is heavily optimized for space, because it's // well worth trading a bit of speed for less swapping. - // referers and referersLen go through two phases: Building and - // resolved. When building, referers might have duplicates, but can - // be appended to. When resolved, referers has no duplicates or + // referrers and referrersLen go through two phases: Building and + // resolved. When building, referrers might have duplicates, but can + // be appended to. When resolved, referrers has no duplicates or // empty slots. // - private JavaThing[] referers = null; - private int referersLen = 0; // -1 when resolved + private JavaThing[] referrers = null; + private int referrersLen = 0; // -1 when resolved public abstract JavaClass getClazz(); public abstract long getSize(); @@ -77,25 +77,25 @@ public abstract class JavaHeapObject extends JavaThing { } // - // Eliminate duplicates from referers, and size the array exactly. + // Eliminate duplicates from referrers, and size the array exactly. // This sets us up to answer queries. See the comments around the - // referers data member for details. + // referrers data member for details. // - void setupReferers() { - if (referersLen > 1) { - // Copy referers to map, screening out duplicates + void setupReferrers() { + if (referrersLen > 1) { + // Copy referrers to map, screening out duplicates Map map = new HashMap(); - for (int i = 0; i < referersLen; i++) { - if (map.get(referers[i]) == null) { - map.put(referers[i], referers[i]); + for (int i = 0; i < referrersLen; i++) { + if (map.get(referrers[i]) == null) { + map.put(referrers[i], referrers[i]); } } // Now copy into the array - referers = new JavaThing[map.size()]; - map.keySet().toArray(referers); + referrers = new JavaThing[map.size()]; + map.keySet().toArray(referrers); } - referersLen = -1; + referrersLen = -1; } @@ -134,15 +134,15 @@ public abstract class JavaHeapObject extends JavaThing { } void addReferenceFrom(JavaHeapObject other) { - if (referersLen == 0) { - referers = new JavaThing[1]; // It was null - } else if (referersLen == referers.length) { - JavaThing[] copy = new JavaThing[(3 * (referersLen + 1)) / 2]; - System.arraycopy(referers, 0, copy, 0, referersLen); - referers = copy; + if (referrersLen == 0) { + referrers = new JavaThing[1]; // It was null + } else if (referrersLen == referrers.length) { + JavaThing[] copy = new JavaThing[(3 * (referrersLen + 1)) / 2]; + System.arraycopy(referrers, 0, copy, 0, referrersLen); + referrers = copy; } - referers[referersLen++] = other; - // We just append to referers here. Measurements have shown that + referrers[referrersLen++] = other; + // We just append to referrers here. Measurements have shown that // around 10% to 30% are duplicates, so it's better to just append // blindly and screen out all the duplicates at once. } @@ -164,8 +164,8 @@ public abstract class JavaHeapObject extends JavaThing { * * @return an Enumeration of JavaHeapObject instances */ - public Enumeration getReferers() { - if (referersLen != -1) { + public Enumeration getReferrers() { + if (referrersLen != -1) { throw new RuntimeException("not resolved: " + getIdString()); } return new Enumeration() { @@ -173,17 +173,17 @@ public abstract class JavaHeapObject extends JavaThing { private int num = 0; public boolean hasMoreElements() { - return referers != null && num < referers.length; + return referrers != null && num < referrers.length; } public JavaThing nextElement() { - return referers[num++]; + return referrers[num++]; } }; } /** - * Given other, which the caller promises is in referers, determines if + * Given other, which the caller promises is in referrers, determines if * the reference is only a weak reference. */ public boolean refersOnlyWeaklyTo(Snapshot ss, JavaThing other) { diff --git a/test/lib/jdk/test/lib/hprof/model/Root.java b/test/lib/jdk/test/lib/hprof/model/Root.java index f8375ed6c4c..3e87eb22a44 100644 --- a/test/lib/jdk/test/lib/hprof/model/Root.java +++ b/test/lib/jdk/test/lib/hprof/model/Root.java @@ -46,11 +46,11 @@ import jdk.test.lib.hprof.util.Misc; public class Root { private long id; // ID of the JavaThing we refer to - private long refererId; // Thread or Class responsible for this, or 0 - private int index = -1; // Index in Snapshot.roots + private long referrerId; // Thread or Class responsible for this, or 0 + private int index = -1; // Index in Snapshot.roots private int type; private String description; - private JavaHeapObject referer = null; + private JavaHeapObject referrer = null; private StackTrace stackTrace = null; // Values for type. Higher values are more interesting -- see getType(). @@ -68,15 +68,15 @@ public class Root { public final static int JAVA_STATIC = 9; - public Root(long id, long refererId, int type, String description) { - this(id, refererId, type, description, null); + public Root(long id, long referrerId, int type, String description) { + this(id, referrerId, type, description, null); } - public Root(long id, long refererId, int type, String description, + public Root(long id, long referrerId, int type, String description, StackTrace stackTrace) { this.id = id; - this.refererId = refererId; + this.referrerId = referrerId; this.type = type; this.description = description; this.stackTrace = stackTrace; @@ -137,12 +137,12 @@ public class Root { * Get the object that's responsible for this root, if there is one. * This will be null, a Thread object, or a Class object. */ - public JavaHeapObject getReferer() { - return referer; + public JavaHeapObject getReferrer() { + return referrer; } - public long getRefererId() { - return refererId; + public long getReferrerId() { + return referrerId; } /** @@ -161,8 +161,8 @@ public class Root { } void resolve(Snapshot ss) { - if (refererId != 0) { - referer = ss.findThing(refererId); + if (referrerId != 0) { + referrer = ss.findThing(referrerId); } if (stackTrace != null) { stackTrace.resolve(ss); diff --git a/test/lib/jdk/test/lib/hprof/model/Snapshot.java b/test/lib/jdk/test/lib/hprof/model/Snapshot.java index 219f8011794..3ea77b876fd 100644 --- a/test/lib/jdk/test/lib/hprof/model/Snapshot.java +++ b/test/lib/jdk/test/lib/hprof/model/Snapshot.java @@ -300,7 +300,7 @@ public class Snapshot implements AutoCloseable { } int count = 0; for (JavaHeapObject t : heapObjects.values()) { - t.setupReferers(); + t.setupReferrers(); ++count; if (calculateRefs && count % DOT_LIMIT == 0) { System.out.print("."); @@ -461,11 +461,11 @@ public class Snapshot implements AutoCloseable { if (curr.getRoot() != null) { result.addElement(chain); // Even though curr is in the rootset, we want to explore its - // referers, because they might be more interesting. + // referrers, because they might be more interesting. } - Enumeration referers = curr.getReferers(); - while (referers.hasMoreElements()) { - JavaHeapObject t = (JavaHeapObject) referers.nextElement(); + Enumeration referrers = curr.getReferrers(); + while (referrers.hasMoreElements()) { + JavaHeapObject t = (JavaHeapObject)referrers.nextElement(); if (t != null && !visited.containsKey(t)) { if (includeWeak || !t.refersOnlyWeaklyTo(this, curr)) { visited.put(t, t);