--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/agent/src/share/classes/sun/jvm/hotspot/runtime/PerfDataEntry.java	Sat Dec 01 00:00:00 2007 +0000
@@ -0,0 +1,480 @@
+/*
+ * Copyright 2004 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.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;
+    }
+
+    // NOTE: Keep this in sync with PerfData::Units enum in VM code
+    public interface PerfDataUnits {
+        public static final int U_None   = 1;
+        public static final int U_Bytes  = 2;
+        public static final int U_Ticks  = 3;
+        public static final int U_Events = 4;
+        public static final int U_String = 5;
+        public static final int U_Hertz  = 6;
+    }
+
+    // returns one of the constants in PerfDataUnits
+    public int dataUnits() {
+        return (int) dataUnitsField.getValue(addr);
+    }
+
+    // NOTE: Keep this in sync with PerfData::Variability enum in VM code
+    public interface PerfDataVariability {
+        public static final int V_Constant  = 1;
+        public static final int V_Monotonic = 2;
+        public static final int V_Variable  = 3;
+    }
+
+    // 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
+        switch (dataUnits()) {
+        case PerfDataUnits.U_None:
+            break;
+        case PerfDataUnits.U_Bytes:
+            str += " byte(s)";
+            break;
+        case PerfDataUnits.U_Ticks:
+            str += " tick(s)";
+            break;
+        case PerfDataUnits.U_Events:
+            str += " event(s)";
+            break;
+        case PerfDataUnits.U_String:
+            break;
+        case PerfDataUnits.U_Hertz:
+            str += " Hz";
+            break;
+        }
+
+        return str;
+    }
+
+    // -- Internals only below this point
+    private ObjectHeap getHeap() {
+        return VM.getVM().getObjectHeap();
+    }
+}