/*
* Copyright (c) 2000, 2016, 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.oops;
import java.io.*;
import java.util.*;
import sun.jvm.hotspot.debugger.*;
import sun.jvm.hotspot.runtime.*;
import sun.jvm.hotspot.types.*;
import sun.jvm.hotspot.utilities.*;
// A MethodData provides interpreter profiling information
public class MethodData extends Metadata implements MethodDataInterface<Klass,Method> {
static int TypeProfileWidth = 2;
static int BciProfileWidth = 2;
static int MethodProfileWidth = 0;
static int CompileThreshold;
static int Reason_many; // indicates presence of several reasons
static int Reason_none; // indicates absence of a relevant deopt.
static int Reason_LIMIT;
static int Reason_RECORDED_LIMIT; // some are not recorded per bc
private static String[] trapReasonName;
static String trapReasonName(int reason) {
if (reason == Reason_many) return "many";
if (reason < Reason_LIMIT)
return trapReasonName[reason];
return "reason" + reason;
}
static int trapStateReason(int trapState) {
// This assert provides the link between the width of DataLayout.trapBits
// and the encoding of "recorded" reasons. It ensures there are enough
// bits to store all needed reasons in the per-BCI MDO profile.
// assert(dsReasonMask >= reasonRecordedLimit, "enough bits");
int recompileBit = (trapState & dsRecompileBit);
trapState -= recompileBit;
if (trapState == dsReasonMask) {
return Reason_many;
} else {
// assert((int)reasonNone == 0, "state=0 => Reason_none");
return trapState;
}
}
static final int dsReasonMask = DataLayout.trapMask >> 1;
static final int dsRecompileBit = DataLayout.trapMask - dsReasonMask;
static boolean trapStateIsRecompiled(int trapState) {
return (trapState & dsRecompileBit) != 0;
}
static boolean reasonIsRecordedPerBytecode(int reason) {
return reason > Reason_none && reason < Reason_RECORDED_LIMIT;
}
static int trapStateAddReason(int trapState, int reason) {
// assert(reasonIsRecordedPerBytecode((DeoptReason)reason) || reason == reasonMany, "valid reason");
int recompileBit = (trapState & dsRecompileBit);
trapState -= recompileBit;
if (trapState == dsReasonMask) {
return trapState + recompileBit; // already at state lattice bottom
} else if (trapState == reason) {
return trapState + recompileBit; // the condition is already true
} else if (trapState == 0) {
return reason + recompileBit; // no condition has yet been true
} else {
return dsReasonMask + recompileBit; // fall to state lattice bottom
}
}
static int trapStateSetRecompiled(int trapState, boolean z) {
if (z) return trapState | dsRecompileBit;
else return trapState & ~dsRecompileBit;
}
static String formatTrapState(int trapState) {
int reason = trapStateReason(trapState);
boolean recompFlag = trapStateIsRecompiled(trapState);
// Re-encode the state from its decoded components.
int decodedState = 0;
if (reasonIsRecordedPerBytecode(reason) || reason == Reason_many)
decodedState = trapStateAddReason(decodedState, reason);
if (recompFlag)
decodedState = trapStateSetRecompiled(decodedState, recompFlag);
// If the state re-encodes properly, format it symbolically.
// Because this routine is used for debugging and diagnostics,
// be robust even if the state is a strange value.
if (decodedState != trapState) {
// Random buggy state that doesn't decode??
return "#" + trapState;
} else {
return trapReasonName(reason) + (recompFlag ? " recompiled" : "");
}
}
static {
VM.registerVMInitializedObserver(new Observer() {
public void update(Observable o, Object data) {
initialize(VM.getVM().getTypeDataBase());
}
});
}
private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
Type type = db.lookupType("MethodData");
baseOffset = type.getSize();
size = new CIntField(type.getCIntegerField("_size"), 0);
method = new MetadataField(type.getAddressField("_method"), 0);
VM.Flag[] flags = VM.getVM().getCommandLineFlags();
for (int f = 0; f < flags.length; f++) {
VM.Flag flag = flags[f];
if (flag.getName().equals("TypeProfileWidth")) {
TypeProfileWidth = (int)flag.getIntx();
} else if (flag.getName().equals("BciProfileWidth")) {
BciProfileWidth = (int)flag.getIntx();
} else if (flag.getName().equals("MethodProfileWidth")) {
MethodProfileWidth = (int)flag.getIntx();
} else if (flag.getName().equals("CompileThreshold")) {
CompileThreshold = (int)flag.getIntx();
}
}
cellSize = (int)VM.getVM().getAddressSize();
dataSize = new CIntField(type.getCIntegerField("_data_size"), 0);
data = type.getAddressField("_data[0]");
parametersTypeDataDi = new CIntField(type.getCIntegerField("_parameters_type_data_di"), 0);
sizeofMethodDataOopDesc = (int)type.getSize();
Reason_many = db.lookupIntConstant("Deoptimization::Reason_many").intValue();
Reason_none = db.lookupIntConstant("Deoptimization::Reason_none").intValue();
Reason_LIMIT = db.lookupIntConstant("Deoptimization::Reason_LIMIT").intValue();
Reason_RECORDED_LIMIT = db.lookupIntConstant("Deoptimization::Reason_RECORDED_LIMIT").intValue();
trapReasonName = new String[Reason_LIMIT];
// Find Deopt reasons
Iterator i = db.getIntConstants();
String prefix = "Deoptimization::Reason_";
while (i.hasNext()) {
String name = (String)i.next();
if (name.startsWith(prefix)) {
// Strip prefix
if (!name.endsWith("Reason_many") &&
!name.endsWith("Reason_LIMIT") &&
!name.endsWith("Reason_RECORDED_LIMIT")) {
String trimmed = name.substring(prefix.length());
int value = db.lookupIntConstant(name).intValue();
if (trapReasonName[value] != null) {
throw new InternalError("duplicate reasons: " + trapReasonName[value] + " " + trimmed);
}
trapReasonName[value] = trimmed;
}
}
}
for (int index = 0; index < trapReasonName.length; index++) {
if (trapReasonName[index] == null) {
throw new InternalError("missing reason for " + index);
}
}
}
public MethodData(Address addr) {
super(addr);
}
public Klass getKlassAtAddress(Address addr) {
return (Klass)Metadata.instantiateWrapperFor(addr);
}
public Method getMethodAtAddress(Address addr) {
return (Method)Metadata.instantiateWrapperFor(addr);
}
public void printKlassValueOn(Klass klass, PrintStream st) {
klass.printValueOn(st);
}
public void printMethodValueOn(Method method, PrintStream st) {
method.printValueOn(st);
}
public boolean isMethodData() { return true; }
private static long baseOffset;
private static CIntField size;
private static MetadataField method;
private static CIntField dataSize;
private static AddressField data;
private static CIntField parametersTypeDataDi;
public static int sizeofMethodDataOopDesc;
public static int cellSize;
public Method getMethod() {
return (Method) method.getValue(this);
}
public void printValueOn(PrintStream tty) {
Method m = getMethod();
tty.print("MethodData for " + m.getName().asString() + m.getSignature().asString());
}
public void iterateFields(MetadataVisitor visitor) {
super.iterateFields(visitor);
visitor.doMetadata(method, true);
visitor.doCInt(size, true);
}
int dataSize() {
if (dataSize == null) {
return 0;
} else {
return (int)dataSize.getValue(getAddress());
}
}
int sizeInBytes() {
if (size == null) {
return 0;
} else {
return (int)size.getValue(getAddress());
}
}
int size() {
return (int)alignSize(VM.getVM().alignUp(sizeInBytes(), VM.getVM().getBytesPerWord())/VM.getVM().getBytesPerWord());
}
ParametersTypeData<Klass,Method> parametersTypeData() {
int di = (int)parametersTypeDataDi.getValue(getAddress());
if (di == -1 || di == -2) {
return null;
}
DataLayout dataLayout = new DataLayout(this, di + (int)data.getOffset());
return new ParametersTypeData<Klass,Method>(this, dataLayout);
}
boolean outOfBounds(int dataIndex) {
return dataIndex >= dataSize();
}
ProfileData dataAt(int dataIndex) {
if (outOfBounds(dataIndex)) {
return null;
}
DataLayout dataLayout = new DataLayout(this, dataIndex + (int)data.getOffset());
switch (dataLayout.tag()) {
case DataLayout.noTag:
default:
throw new InternalError(dataIndex + " " + dataSize() + " " + dataLayout.tag());
case DataLayout.bitDataTag:
return new BitData(dataLayout);
case DataLayout.counterDataTag:
return new CounterData(dataLayout);
case DataLayout.jumpDataTag:
return new JumpData(dataLayout);
case DataLayout.receiverTypeDataTag:
return new ReceiverTypeData<Klass,Method>(this, dataLayout);
case DataLayout.virtualCallDataTag:
return new VirtualCallData<Klass,Method>(this, dataLayout);
case DataLayout.retDataTag:
return new RetData(dataLayout);
case DataLayout.branchDataTag:
return new BranchData(dataLayout);
case DataLayout.multiBranchDataTag:
return new MultiBranchData(dataLayout);
case DataLayout.callTypeDataTag:
return new CallTypeData<Klass,Method>(this, dataLayout);
case DataLayout.virtualCallTypeDataTag:
return new VirtualCallTypeData<Klass,Method>(this, dataLayout);
case DataLayout.parametersTypeDataTag:
return new ParametersTypeData<Klass,Method>(this, dataLayout);
}
}
int dpToDi(int dp) {
// this in an offset from the base of the MDO, so convert to offset into _data
return dp - (int)data.getOffset();
}
int firstDi() { return 0; }
public ProfileData firstData() { return dataAt(firstDi()); }
public ProfileData nextData(ProfileData current) {
int currentIndex = dpToDi(current.dp());
int nextIndex = currentIndex + current.sizeInBytes();
return dataAt(nextIndex);
}
boolean isValid(ProfileData current) { return current != null; }
DataLayout limitDataPosition() {
return new DataLayout(this, dataSize() + (int)data.getOffset());
}
DataLayout extraDataBase() {
return limitDataPosition();
}
DataLayout extraDataLimit() {
return new DataLayout(this, sizeInBytes());
}
static public int extraNbCells(DataLayout dataLayout) {
int nbCells = 0;
switch(dataLayout.tag()) {
case DataLayout.bitDataTag:
case DataLayout.noTag:
nbCells = BitData.staticCellCount();
break;
case DataLayout.speculativeTrapDataTag:
nbCells = SpeculativeTrapData.staticCellCount();
break;
default:
throw new InternalError("unexpected tag " + dataLayout.tag());
}
return nbCells;
}
DataLayout nextExtra(DataLayout dataLayout) {
return new DataLayout(this, dataLayout.dp() + DataLayout.computeSizeInBytes(extraNbCells(dataLayout)));
}
public void printDataOn(PrintStream st) {
if (parametersTypeData() != null) {
parametersTypeData().printDataOn(st);
}
ProfileData data = firstData();
for ( ; isValid(data); data = nextData(data)) {
st.print(dpToDi(data.dp()));
st.print(" ");
// st->fillTo(6);
data.printDataOn(st);
}
st.println("--- Extra data:");
DataLayout dp = extraDataBase();
DataLayout end = extraDataLimit();
for (;; dp = nextExtra(dp)) {
switch(dp.tag()) {
case DataLayout.noTag:
continue;
case DataLayout.bitDataTag:
data = new BitData(dp);
break;
case DataLayout.speculativeTrapDataTag:
data = new SpeculativeTrapData<Klass,Method>(this, dp);
break;
case DataLayout.argInfoDataTag:
data = new ArgInfoData(dp);
dp = end; // ArgInfoData is at the end of extra data section.
break;
default:
throw new InternalError("unexpected tag " + dp.tag());
}
st.print(dpToDi(data.dp()));
st.print(" ");
data.printDataOn(st);
if (dp == end) return;
}
}
private byte[] fetchDataAt(Address base, long offset, long size) {
byte[] result = new byte[(int)size];
for (int i = 0; i < size; i++) {
result[i] = base.getJByteAt(offset + i);
}
return result;
}
public byte[] orig() {
// fetch the orig MethodData data between header and dataSize
return fetchDataAt(getAddress(), 0, sizeofMethodDataOopDesc);
}
public long[] data() {
// Read the data as an array of intptr_t elements
Address base = getAddress();
long offset = data.getOffset();
int elements = dataSize() / cellSize;
long[] result = new long[elements];
for (int i = 0; i < elements; i++) {
Address value = base.getAddressAt(offset + i * MethodData.cellSize);
if (value != null) {
result[i] = value.minus(null);
}
}
return result;
}
// Get a measure of how much mileage the method has on it.
int mileageOf(Method method) {
long mileage = 0;
int iic = method.interpreterInvocationCount();
if (mileage < iic) mileage = iic;
long ic = method.getInvocationCount();
long bc = method.getBackedgeCount();
long icval = ic >> 3;
if ((ic & 4) != 0) icval += CompileThreshold;
if (mileage < icval) mileage = icval;
long bcval = bc >> 3;
if ((bc & 4) != 0) bcval += CompileThreshold;
if (mileage < bcval) mileage = bcval;
return (int)mileage;
}
public int currentMileage() {
return 20000;
}
int dumpReplayDataTypeHelper(PrintStream out, int round, int count, int index, ProfileData pdata, Klass k) {
if (k != null) {
if (round == 0) count++;
else out.print(" " +
(dpToDi(pdata.dp() +
pdata.cellOffset(index)) / cellSize) + " " +
k.getName().asString());
}
return count;
}
int dumpReplayDataReceiverTypeHelper(PrintStream out, int round, int count, ReceiverTypeData<Klass,Method> vdata) {
for (int i = 0; i < vdata.rowLimit(); i++) {
Klass k = vdata.receiver(i);
count = dumpReplayDataTypeHelper(out, round, count, vdata.receiverCellIndex(i), vdata, k);
}
return count;
}
int dumpReplayDataCallTypeHelper(PrintStream out, int round, int count, CallTypeDataInterface<Klass> callTypeData) {
if (callTypeData.hasArguments()) {
for (int i = 0; i < callTypeData.numberOfArguments(); i++) {
count = dumpReplayDataTypeHelper(out, round, count, callTypeData.argumentTypeIndex(i), (ProfileData)callTypeData, callTypeData.argumentType(i));
}
}
if (callTypeData.hasReturn()) {
count = dumpReplayDataTypeHelper(out, round, count, callTypeData.returnTypeIndex(), (ProfileData)callTypeData, callTypeData.returnType());
}
return count;
}
int dumpReplayDataExtraDataHelper(PrintStream out, int round, int count) {
DataLayout dp = extraDataBase();
DataLayout end = extraDataLimit();
for (;dp != end; dp = nextExtra(dp)) {
switch(dp.tag()) {
case DataLayout.noTag:
case DataLayout.argInfoDataTag:
return count;
case DataLayout.bitDataTag:
break;
case DataLayout.speculativeTrapDataTag: {
SpeculativeTrapData<Klass,Method> data = new SpeculativeTrapData<Klass,Method>(this, dp);
Method m = data.method();
if (m != null) {
if (round == 0) {
count++;
} else {
out.print(" " + (dpToDi(data.dp() + data.cellOffset(SpeculativeTrapData.methodIndex())) / cellSize) + " " + m.nameAsAscii());
}
}
break;
}
default:
throw new InternalError("bad tag " + dp.tag());
}
}
return count;
}
public void dumpReplayData(PrintStream out) {
Method method = getMethod();
out.print("ciMethodData " + method.nameAsAscii()
+ " " + "2" + " " +
currentMileage());
byte[] orig = orig();
out.print(" orig " + orig.length);
for (int i = 0; i < orig.length; i++) {
out.print(" " + (orig[i] & 0xff));
}
long[] data = data();
out.print(" data " + data.length);
for (int i = 0; i < data.length; i++) {
out.print(" 0x" + Long.toHexString(data[i]));
}
int count = 0;
ParametersTypeData<Klass,Method> parameters = parametersTypeData();
for (int round = 0; round < 2; round++) {
if (round == 1) out.print(" oops " + count);
ProfileData pdata = firstData();
for ( ; isValid(pdata); pdata = nextData(pdata)) {
if (pdata instanceof ReceiverTypeData) {
count = dumpReplayDataReceiverTypeHelper(out, round, count, (ReceiverTypeData<Klass,Method>)pdata);
}
if (pdata instanceof CallTypeDataInterface) {
count = dumpReplayDataCallTypeHelper(out, round, count, (CallTypeDataInterface<Klass>)pdata);
}
}
if (parameters != null) {
for (int i = 0; i < parameters.numberOfParameters(); i++) {
count = dumpReplayDataTypeHelper(out, round, count, ParametersTypeData.typeIndex(i), parameters, parameters.type(i));
}
}
}
count = 0;
for (int round = 0; round < 2; round++) {
if (round == 1) out.print(" methods " + count);
count = dumpReplayDataExtraDataHelper(out, round, count);
}
out.println();
}
}