mirror of
https://github.com/openjdk/jdk.git
synced 2025-08-28 07:14:30 +02:00
42d3f8d610
Avoid redefinition of hotspot constants and ia64 code vestiges removal Reviewed-by: sspitsyn, dholmes, coleenp
481 lines
16 KiB
Java
481 lines
16 KiB
Java
/*
|
|
* Copyright (c) 2004, 2017, 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
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*
|
|
*/
|
|
|
|
package sun.jvm.hotspot.runtime;
|
|
|
|
import java.util.*;
|
|
import sun.jvm.hotspot.debugger.*;
|
|
import sun.jvm.hotspot.oops.*;
|
|
import sun.jvm.hotspot.types.*;
|
|
import sun.jvm.hotspot.utilities.*;
|
|
|
|
public class PerfDataEntry extends VMObject {
|
|
private static JIntField entryLengthField;
|
|
private static JIntField nameOffsetField;
|
|
private static JIntField vectorLengthField;
|
|
private static JByteField dataTypeField;
|
|
private static JByteField flagsField;
|
|
private static JByteField dataUnitsField;
|
|
private static JByteField dataVariabilityField;
|
|
private static JIntField dataOffsetField;
|
|
|
|
static {
|
|
VM.registerVMInitializedObserver(new Observer() {
|
|
public void update(Observable o, Object data) {
|
|
initialize(VM.getVM().getTypeDataBase());
|
|
}
|
|
});
|
|
}
|
|
|
|
private static synchronized void initialize(TypeDataBase db) {
|
|
Type type = db.lookupType("PerfDataEntry");
|
|
entryLengthField = type.getJIntField("entry_length");
|
|
nameOffsetField = type.getJIntField("name_offset");
|
|
vectorLengthField = type.getJIntField("vector_length");
|
|
dataTypeField = type.getJByteField("data_type");
|
|
flagsField = type.getJByteField("flags");
|
|
dataUnitsField = type.getJByteField("data_units");
|
|
dataVariabilityField = type.getJByteField("data_variability");
|
|
dataOffsetField = type.getJIntField("data_offset");
|
|
}
|
|
|
|
public PerfDataEntry(Address addr) {
|
|
super(addr);
|
|
}
|
|
|
|
// Accessors
|
|
|
|
public int entryLength() {
|
|
return (int) entryLengthField.getValue(addr);
|
|
}
|
|
|
|
public int nameOffset() {
|
|
return (int) nameOffsetField.getValue(addr);
|
|
}
|
|
|
|
public int vectorLength() {
|
|
return (int) vectorLengthField.getValue(addr);
|
|
}
|
|
|
|
// returns one of the constants in BasicType class
|
|
public int dataType() {
|
|
char ch = (char) (byte) dataTypeField.getValue(addr);
|
|
return BasicType.charToType(ch);
|
|
}
|
|
|
|
public byte flags() {
|
|
return (byte) flagsField.getValue(addr);
|
|
}
|
|
|
|
public boolean supported() {
|
|
return (flags() & 0x1) != 0;
|
|
}
|
|
|
|
private static class PerfDataUnits {
|
|
public static int U_None;
|
|
public static int U_Bytes;
|
|
public static int U_Ticks;
|
|
public static int U_Events;
|
|
public static int U_String;
|
|
public static int U_Hertz;
|
|
|
|
static {
|
|
VM.registerVMInitializedObserver(new Observer() {
|
|
public void update(Observable o, Object data) {
|
|
initialize(VM.getVM().getTypeDataBase());
|
|
}
|
|
});
|
|
}
|
|
private static synchronized void initialize(TypeDataBase db) {
|
|
U_None = db.lookupIntConstant("PerfData::U_None");
|
|
U_Bytes = db.lookupIntConstant("PerfData::U_Bytes");
|
|
U_Ticks = db.lookupIntConstant("PerfData::U_Ticks");
|
|
U_Events = db.lookupIntConstant("PerfData::U_Events");
|
|
U_String = db.lookupIntConstant("PerfData::U_String");
|
|
U_Hertz = db.lookupIntConstant("PerfData::U_Hertz");
|
|
}
|
|
}
|
|
|
|
// returns one of the constants in PerfDataUnits
|
|
public int dataUnits() {
|
|
return (int) dataUnitsField.getValue(addr);
|
|
}
|
|
|
|
// returns one of the constants in PerfDataVariability
|
|
public int dataVariability() {
|
|
return (int) dataVariabilityField.getValue(addr);
|
|
}
|
|
|
|
public int dataOffset() {
|
|
return (int) dataOffsetField.getValue(addr);
|
|
}
|
|
|
|
public String name() {
|
|
int off = nameOffset();
|
|
return CStringUtilities.getString(addr.addOffsetTo(off));
|
|
}
|
|
|
|
public boolean booleanValue() {
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(vectorLength() == 0 &&
|
|
dataType() == BasicType.tBoolean, "not a boolean");
|
|
}
|
|
return addr.getJBooleanAt(dataOffset());
|
|
}
|
|
|
|
public char charValue() {
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(vectorLength() == 0 &&
|
|
dataType() == BasicType.tChar, "not a char");
|
|
}
|
|
return addr.getJCharAt(dataOffset());
|
|
}
|
|
|
|
public byte byteValue() {
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(vectorLength() == 0 &&
|
|
dataType() == BasicType.tByte, "not a byte");
|
|
}
|
|
return addr.getJByteAt(dataOffset());
|
|
|
|
}
|
|
|
|
public short shortValue() {
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(vectorLength() == 0 &&
|
|
dataType() == BasicType.tShort, "not a short");
|
|
}
|
|
return addr.getJShortAt(dataOffset());
|
|
}
|
|
|
|
public int intValue() {
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(vectorLength() == 0 &&
|
|
dataType() == BasicType.tInt, "not an int");
|
|
}
|
|
return addr.getJIntAt(dataOffset());
|
|
}
|
|
|
|
public long longValue() {
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(vectorLength() == 0 &&
|
|
dataType() == BasicType.tLong, "not a long");
|
|
}
|
|
return addr.getJLongAt(dataOffset());
|
|
}
|
|
|
|
public float floatValue() {
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(vectorLength() == 0 &&
|
|
dataType() == BasicType.tFloat, "not a float");
|
|
}
|
|
return addr.getJFloatAt(dataOffset());
|
|
}
|
|
|
|
public double doubleValue() {
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(vectorLength() == 0 &&
|
|
dataType() == BasicType.tDouble, "not a double");
|
|
}
|
|
return addr.getJDoubleAt(dataOffset());
|
|
}
|
|
|
|
public boolean[] booleanArrayValue() {
|
|
int len = vectorLength();
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(len > 0 &&
|
|
dataType() == BasicType.tBoolean, "not a boolean vector");
|
|
}
|
|
boolean[] res = new boolean[len];
|
|
final int off = dataOffset();
|
|
final long size = getHeap().getBooleanSize();
|
|
for (int i = 0; i < len; i++) {
|
|
res[i] = addr.getJBooleanAt(off + i * size);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public char[] charArrayValue() {
|
|
int len = vectorLength();
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(len > 0 &&
|
|
dataType() == BasicType.tChar, "not a char vector");
|
|
}
|
|
char[] res = new char[len];
|
|
final int off = dataOffset();
|
|
final long size = getHeap().getCharSize();
|
|
for (int i = 0; i < len; i++) {
|
|
res[i] = addr.getJCharAt(off + i * size);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public byte[] byteArrayValue() {
|
|
int len = vectorLength();
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(len > 0 &&
|
|
dataType() == BasicType.tByte, "not a byte vector");
|
|
}
|
|
byte[] res = new byte[len];
|
|
final int off = dataOffset();
|
|
final long size = getHeap().getByteSize();
|
|
for (int i = 0; i < len; i++) {
|
|
res[i] = addr.getJByteAt(off + i * size);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public short[] shortArrayValue() {
|
|
int len = vectorLength();
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(len > 0 &&
|
|
dataType() == BasicType.tShort, "not a short vector");
|
|
}
|
|
short[] res = new short[len];
|
|
final int off = dataOffset();
|
|
final long size = getHeap().getShortSize();
|
|
for (int i = 0; i < len; i++) {
|
|
res[i] = addr.getJShortAt(off + i * size);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public int[] intArrayValue() {
|
|
int len = vectorLength();
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(len > 0 &&
|
|
dataType() == BasicType.tInt, "not an int vector");
|
|
}
|
|
int[] res = new int[len];
|
|
final int off = dataOffset();
|
|
final long size = getHeap().getIntSize();
|
|
for (int i = 0; i < len; i++) {
|
|
res[i] = addr.getJIntAt(off + i * size);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public long[] longArrayValue() {
|
|
int len = vectorLength();
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(len > 0 &&
|
|
dataType() == BasicType.tLong, "not a long vector");
|
|
}
|
|
long[] res = new long[len];
|
|
final int off = dataOffset();
|
|
final long size = getHeap().getLongSize();
|
|
for (int i = 0; i < len; i++) {
|
|
res[i] = addr.getJLongAt(off + i * size);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public float[] floatArrayValue() {
|
|
int len = vectorLength();
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(len > 0 &&
|
|
dataType() == BasicType.tFloat, "not a float vector");
|
|
}
|
|
float[] res = new float[len];
|
|
final int off = dataOffset();
|
|
final long size = getHeap().getFloatSize();
|
|
for (int i = 0; i < len; i++) {
|
|
res[i] = addr.getJFloatAt(off + i * size);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
public double[] doubleArrayValue() {
|
|
int len = vectorLength();
|
|
if (Assert.ASSERTS_ENABLED) {
|
|
Assert.that(len > 0 &&
|
|
dataType() == BasicType.tDouble, "not a double vector");
|
|
}
|
|
double[] res = new double[len];
|
|
final int off = dataOffset();
|
|
final long size = getHeap().getDoubleSize();
|
|
for (int i = 0; i < len; i++) {
|
|
res[i] = addr.getJDoubleAt(off + i * size);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
// value as String
|
|
public String valueAsString() {
|
|
int dataType = dataType();
|
|
int len = vectorLength();
|
|
String str = null;
|
|
if (len == 0) { // scalar
|
|
switch (dataType) {
|
|
case BasicType.tBoolean:
|
|
str = Boolean.toString(booleanValue());
|
|
break;
|
|
case BasicType.tChar:
|
|
str = "'" + Character.toString(charValue()) + "'";
|
|
break;
|
|
case BasicType.tByte:
|
|
str = Byte.toString(byteValue());
|
|
break;
|
|
case BasicType.tShort:
|
|
str = Short.toString(shortValue());
|
|
break;
|
|
case BasicType.tInt:
|
|
str = Integer.toString(intValue());
|
|
break;
|
|
case BasicType.tLong:
|
|
str = Long.toString(longValue());
|
|
break;
|
|
case BasicType.tFloat:
|
|
str = Float.toString(floatValue());
|
|
break;
|
|
case BasicType.tDouble:
|
|
str = Double.toString(doubleValue());
|
|
break;
|
|
default:
|
|
str = "<unknown scalar value>";
|
|
break;
|
|
}
|
|
} else { // vector
|
|
switch (dataType) {
|
|
case BasicType.tBoolean: {
|
|
boolean[] res = booleanArrayValue();
|
|
StringBuffer buf = new StringBuffer();
|
|
buf.append('[');
|
|
for (int i = 0; i < res.length; i++) {
|
|
buf.append(Boolean.toString(res[i]));
|
|
buf.append(", ");
|
|
}
|
|
buf.append(']');
|
|
str = buf.toString();
|
|
break;
|
|
}
|
|
|
|
case BasicType.tChar: {
|
|
// char[] is returned as a String
|
|
str = new String(charArrayValue());
|
|
break;
|
|
}
|
|
|
|
case BasicType.tByte: {
|
|
// byte[] is returned as a String
|
|
try {
|
|
str = new String(byteArrayValue(), "US-ASCII");
|
|
} catch (java.io.UnsupportedEncodingException e) {
|
|
str = "can't decode string : " + e.getMessage();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case BasicType.tShort: {
|
|
short[] res = shortArrayValue();
|
|
StringBuffer buf = new StringBuffer();
|
|
buf.append('[');
|
|
for (int i = 0; i < res.length; i++) {
|
|
buf.append(Short.toString(res[i]));
|
|
buf.append(", ");
|
|
}
|
|
buf.append(']');
|
|
str = buf.toString();
|
|
break;
|
|
}
|
|
|
|
case BasicType.tInt: {
|
|
int[] res = intArrayValue();
|
|
StringBuffer buf = new StringBuffer();
|
|
buf.append('[');
|
|
for (int i = 0; i < res.length; i++) {
|
|
buf.append(Integer.toString(res[i]));
|
|
buf.append(", ");
|
|
}
|
|
buf.append(']');
|
|
str = buf.toString();
|
|
break;
|
|
}
|
|
|
|
case BasicType.tLong: {
|
|
long[] res = longArrayValue();
|
|
StringBuffer buf = new StringBuffer();
|
|
buf.append('[');
|
|
for (int i = 0; i < res.length; i++) {
|
|
buf.append(Long.toString(res[i]));
|
|
buf.append(", ");
|
|
}
|
|
buf.append(']');
|
|
str = buf.toString();
|
|
break;
|
|
}
|
|
|
|
case BasicType.tFloat: {
|
|
float[] res = floatArrayValue();
|
|
StringBuffer buf = new StringBuffer();
|
|
buf.append('[');
|
|
for (int i = 0; i < res.length; i++) {
|
|
buf.append(Float.toString(res[i]));
|
|
buf.append(", ");
|
|
}
|
|
buf.append(']');
|
|
str = buf.toString();
|
|
break;
|
|
}
|
|
|
|
case BasicType.tDouble: {
|
|
double[] res = doubleArrayValue();
|
|
StringBuffer buf = new StringBuffer();
|
|
buf.append('[');
|
|
for (int i = 0; i < res.length; i++) {
|
|
buf.append(Double.toString(res[i]));
|
|
buf.append(", ");
|
|
}
|
|
buf.append(']');
|
|
str = buf.toString();
|
|
break;
|
|
}
|
|
|
|
default:
|
|
str = "<unknown vector value>";
|
|
break;
|
|
}
|
|
}
|
|
|
|
// add units
|
|
int dataUnitsValue = dataUnits();
|
|
|
|
if (dataUnitsValue == PerfDataUnits.U_Bytes) {
|
|
str += " byte(s)";
|
|
} else if (dataUnitsValue == PerfDataUnits.U_Ticks) {
|
|
str += " tick(s)";
|
|
} else if (dataUnitsValue == PerfDataUnits.U_Events) {
|
|
str += " event(s)";
|
|
} else if (dataUnitsValue == PerfDataUnits.U_Hertz) {
|
|
str += " Hz";
|
|
}
|
|
|
|
return str;
|
|
}
|
|
|
|
// -- Internals only below this point
|
|
private ObjectHeap getHeap() {
|
|
return VM.getVM().getObjectHeap();
|
|
}
|
|
}
|