feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/sun/jvmstat/perfdata/monitor/v1_0/BasicType.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2004, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.jvmstat.perfdata.monitor.v1_0;
+
+/**
+ * A typesafe enumeration for describing Java basic types.
+ *
+ * <p> The enumeration values for this typesafe enumeration must be
+ * kept in synchronization with the BasicType enum in the
+ * globalsDefinitions.hpp file in the HotSpot source base.</p>
+ *
+ * @author Brian Doherty
+ * @since 1.5
+ */
+public class BasicType {
+
+    private final String name;
+    private final int value;
+
+    public static final BasicType BOOLEAN = new BasicType("boolean",  4);
+    public static final BasicType CHAR    = new BasicType("char",     5);
+    public static final BasicType FLOAT   = new BasicType("float",    6);
+    public static final BasicType DOUBLE  = new BasicType("double",   7);
+    public static final BasicType BYTE    = new BasicType("byte",     8);
+    public static final BasicType SHORT   = new BasicType("short",    9);
+    public static final BasicType INT     = new BasicType("int",     10);
+    public static final BasicType LONG    = new BasicType("long",    11);
+    public static final BasicType OBJECT  = new BasicType("object",  12);
+    public static final BasicType ARRAY   = new BasicType("array",   13);
+    public static final BasicType VOID    = new BasicType("void",    14);
+    public static final BasicType ADDRESS = new BasicType("address", 15);
+    public static final BasicType ILLEGAL = new BasicType("illegal", 99);
+
+    private static BasicType basicTypes[] = {
+        BOOLEAN, CHAR, FLOAT, DOUBLE, BYTE, SHORT, INT, LONG, OBJECT,
+        ARRAY, VOID, ADDRESS, ILLEGAL
+    };
+
+    /**
+     * Convert enumeration value to a String.
+     *
+     * @return String - the string representation for the enumeration.
+     */
+    public String toString() {
+        return name;
+    }
+
+    /**
+     * Convert enumeration to an integer value.
+     *
+     * @return int - the integer representation for the enumeration.
+     */
+    public int intValue() {
+        return value;
+    }
+
+    /**
+     * Map an integer value to its corresponding BasicType object.
+     *
+     * @param i an integer representation of a BasicType
+     * @return BasicType - The BasicType enumeration object matching
+     *                     the value of <code>i</code>
+     */
+    public static BasicType toBasicType(int i) {
+        for (int j = 0; j < basicTypes.length; j++) {
+            if (basicTypes[j].intValue() == j) {
+                return (basicTypes[j]);
+            }
+        }
+        return ILLEGAL;
+    }
+
+    private BasicType(String name, int value) {
+        this.name = name;
+        this.value = value;
+    }
+}

jdkSrc/jdk8/sun/jvmstat/perfdata/monitor/v1_0/PerfDataBuffer.java

@@ -0,0 +1,650 @@
+/*
+ * Copyright (c) 2004, 2010, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.jvmstat.perfdata.monitor.v1_0;
+
+import sun.jvmstat.monitor.*;
+import sun.jvmstat.perfdata.monitor.*;
+import java.util.*;
+import java.util.regex.*;
+import java.nio.*;
+
+/**
+ * The concrete implementation of version 1.0 of the HotSpot PerfData
+ * Instrumentation buffer. This class is responsible for parsing the
+ * instrumentation memory and constructing the necessary objects to
+ * represent and access the instrumentation objects contained in the
+ * memory buffer.
+ *
+ * @author Brian Doherty
+ * @since 1.5
+ * @see AbstractPerfDataBuffer
+ */
+public class PerfDataBuffer extends PerfDataBufferImpl {
+
+    private static final boolean DEBUG = false;
+    private static final int syncWaitMs =
+            Integer.getInteger("sun.jvmstat.perdata.syncWaitMs", 5000);
+    private static final ArrayList EMPTY_LIST = new ArrayList(0);
+
+    /*
+     * the following constants must be kept in sync with struct
+     * PerfDataEntry in perfMemory.hpp
+     */
+    private final static int PERFDATA_ENTRYLENGTH_OFFSET=0;
+    private final static int PERFDATA_ENTRYLENGTH_SIZE=4;   // sizeof(int)
+    private final static int PERFDATA_NAMELENGTH_OFFSET=4;
+    private final static int PERFDATA_NAMELENGTH_SIZE=4;    // sizeof(int)
+    private final static int PERFDATA_VECTORLENGTH_OFFSET=8;
+    private final static int PERFDATA_VECTORLENGTH_SIZE=4;  // sizeof(int)
+    private final static int PERFDATA_DATATYPE_OFFSET=12;
+    private final static int PERFDATA_DATATYPE_SIZE=1;      // sizeof(byte)
+    private final static int PERFDATA_FLAGS_OFFSET=13;
+    private final static int PERFDATA_FLAGS_SIZE=1;        // sizeof(byte)
+    private final static int PERFDATA_DATAUNITS_OFFSET=14;
+    private final static int PERFDATA_DATAUNITS_SIZE=1;     // sizeof(byte)
+    private final static int PERFDATA_DATAATTR_OFFSET=15;
+    private final static int PERFDATA_DATAATTR_SIZE=1;      // sizeof(byte)
+    private final static int PERFDATA_NAME_OFFSET=16;
+
+    PerfDataBufferPrologue prologue;
+    int nextEntry;
+    int pollForEntry;
+    int perfDataItem;
+    long lastModificationTime;
+    int lastUsed;
+    IntegerMonitor overflow;
+    ArrayList<Monitor> insertedMonitors;
+
+    /**
+     * Construct a PerfDataBufferImpl instance.
+     * <p>
+     * This class is dynamically loaded by
+     * {@link AbstractPerfDataBuffer#createPerfDataBuffer}, and this
+     * constructor is called to instantiate the instance.
+     *
+     * @param buffer the buffer containing the instrumentation data
+     * @param lvmid the Local Java Virtual Machine Identifier for this
+     *              instrumentation buffer.
+     */
+    public PerfDataBuffer(ByteBuffer buffer, int lvmid)
+           throws MonitorException {
+        super(buffer, lvmid);
+        prologue = new PerfDataBufferPrologue(buffer);
+        this.buffer.order(prologue.getByteOrder());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected void buildMonitorMap(Map<String, Monitor> map) throws MonitorException {
+        assert Thread.holdsLock(this);
+
+        // start at the beginning of the buffer
+        buffer.rewind();
+
+        // create pseudo monitors
+        buildPseudoMonitors(map);
+
+        // position buffer to start of the data section
+        buffer.position(prologue.getSize());
+        nextEntry = buffer.position();
+        perfDataItem = 0;
+
+        int used = prologue.getUsed();
+        long modificationTime = prologue.getModificationTimeStamp();
+
+        Monitor m = getNextMonitorEntry();
+        while (m != null) {
+            map.put(m.getName(), m);
+            m = getNextMonitorEntry();
+        }
+
+        /*
+         * set the last modification data. These are set to the values
+         * recorded before parsing the data structure. This allows the
+         * the data structure to be modified while the Map is being built.
+         * The Map may contain more entries than indicated based on the
+         * time stamp, but this is handled by ignoring duplicate entries
+         * when the Map is updated in getNewMonitors().
+         */
+        lastUsed = used;
+        lastModificationTime = modificationTime;
+
+        // synchronize with the target jvm
+        synchWithTarget(map);
+
+        // work around 1.4.2 counter inititization bugs
+        kludge(map);
+
+        insertedMonitors = new ArrayList<Monitor>(map.values());
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected void getNewMonitors(Map<String, Monitor> map) throws MonitorException {
+        assert Thread.holdsLock(this);
+
+        int used = prologue.getUsed();
+        long modificationTime = prologue.getModificationTimeStamp();
+
+        if ((used > lastUsed) || (lastModificationTime > modificationTime)) {
+
+            lastUsed = used;
+            lastModificationTime = modificationTime;
+
+            Monitor monitor = getNextMonitorEntry();
+            while (monitor != null) {
+                String name = monitor.getName();
+
+                // guard against duplicate entries
+                if (!map.containsKey(name)) {
+                    map.put(name, monitor);
+
+                    /*
+                     * insertedMonitors is null when called from pollFor()
+                     * via buildMonitorMap(). Since we update insertedMonitors
+                     * at the end of buildMonitorMap(), it's ok to skip the
+                     * add here.
+                     */
+                    if (insertedMonitors != null) {
+                        insertedMonitors.add(monitor);
+                    }
+                }
+                monitor = getNextMonitorEntry();
+            }
+        }
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    protected MonitorStatus getMonitorStatus(Map<String, Monitor> map) throws MonitorException {
+        assert Thread.holdsLock(this);
+        assert insertedMonitors != null;
+
+        // load any new monitors
+        getNewMonitors(map);
+
+        // current implementation doesn't support deletion or reuse of entries
+        ArrayList removed = EMPTY_LIST;
+        ArrayList inserted = insertedMonitors;
+
+        insertedMonitors = new ArrayList<Monitor>();
+        return new MonitorStatus(inserted, removed);
+    }
+
+    /**
+     * Build the pseudo monitors used to map the prolog data into counters.
+     */
+    protected void buildPseudoMonitors(Map<String, Monitor> map) {
+        Monitor monitor = null;
+        String name = null;
+        IntBuffer ib = null;
+
+        name = PerfDataBufferPrologue.PERFDATA_MAJOR_NAME;
+        ib = prologue.majorVersionBuffer();
+        monitor = new PerfIntegerMonitor(name, Units.NONE,
+                                         Variability.CONSTANT, false, ib);
+        map.put(name, monitor);
+
+        name = PerfDataBufferPrologue.PERFDATA_MINOR_NAME;
+        ib = prologue.minorVersionBuffer();
+        monitor = new PerfIntegerMonitor(name, Units.NONE,
+                                         Variability.CONSTANT, false, ib);
+        map.put(name, monitor);
+
+        name = PerfDataBufferPrologue.PERFDATA_BUFFER_SIZE_NAME;
+        ib = prologue.sizeBuffer();
+        monitor = new PerfIntegerMonitor(name, Units.BYTES,
+                                         Variability.MONOTONIC, false, ib);
+        map.put(name, monitor);
+
+        name = PerfDataBufferPrologue.PERFDATA_BUFFER_USED_NAME;
+        ib = prologue.usedBuffer();
+        monitor = new PerfIntegerMonitor(name, Units.BYTES,
+                                         Variability.MONOTONIC, false, ib);
+        map.put(name, monitor);
+
+        name = PerfDataBufferPrologue.PERFDATA_OVERFLOW_NAME;
+        ib = prologue.overflowBuffer();
+        monitor = new PerfIntegerMonitor(name, Units.BYTES,
+                                         Variability.MONOTONIC, false, ib);
+        map.put(name, monitor);
+        this.overflow = (IntegerMonitor)monitor;
+
+        name = PerfDataBufferPrologue.PERFDATA_MODTIMESTAMP_NAME;
+        LongBuffer lb = prologue.modificationTimeStampBuffer();
+        monitor = new PerfLongMonitor(name, Units.TICKS,
+                                      Variability.MONOTONIC, false, lb);
+        map.put(name, monitor);
+    }
+
+    /**
+     * Method to provide a gross level of synchronization with the
+     * target monitored jvm.
+     *
+     * gross synchronization works by polling for the hotspot.rt.hrt.ticks
+     * counter, which is the last counter created by the StatSampler
+     * initialization code. The counter is updated when the watcher thread
+     * starts scheduling tasks, which is the last thing done in vm
+     * initialization.
+     */
+    protected void synchWithTarget(Map<String, Monitor> map) throws MonitorException {
+        /*
+         * synch must happen with syncWaitMs from now. Default is 5 seconds,
+         * which is reasonabally generous and should provide for extreme
+         * situations like startup delays due to allocation of large ISM heaps.
+         */
+        long timeLimit = System.currentTimeMillis() + syncWaitMs;
+
+        String name = "hotspot.rt.hrt.ticks";
+        LongMonitor ticks = (LongMonitor)pollFor(map, name, timeLimit);
+
+        /*
+         * loop waiting for the ticks counter to be non zero. This is
+         * an indication that the jvm is initialized.
+         */
+        log("synchWithTarget: " + lvmid + " ");
+        while (ticks.longValue() == 0) {
+            log(".");
+
+            try { Thread.sleep(20); } catch (InterruptedException e) { }
+
+            if (System.currentTimeMillis() > timeLimit) {
+                lognl("failed: " + lvmid);
+                throw new MonitorException("Could Not Synchronize with target");
+            }
+        }
+        lognl("success: " + lvmid);
+    }
+
+    /**
+     * Method to poll the instrumentation memory for a counter with
+     * the given name. The polling period is bounded by the timeLimit
+     * argument.
+     */
+    protected Monitor pollFor(Map<String, Monitor> map, String name, long timeLimit)
+                      throws MonitorException {
+        Monitor monitor = null;
+
+        log("polling for: " + lvmid + "," + name + " ");
+
+        pollForEntry = nextEntry;
+        while ((monitor = map.get(name)) == null) {
+            log(".");
+
+            try { Thread.sleep(20); } catch (InterruptedException e) { }
+
+            long t = System.currentTimeMillis();
+            if ((t > timeLimit) || (overflow.intValue() > 0)) {
+                lognl("failed: " + lvmid + "," + name);
+                dumpAll(map, lvmid);
+                throw new MonitorException("Could not find expected counter");
+            }
+
+            getNewMonitors(map);
+        }
+        lognl("success: " + lvmid + "," + name);
+        return monitor;
+    }
+
+    /**
+     * method to make adjustments for known counter problems. This
+     * method depends on the availability of certain counters, which
+     * is generally guaranteed by the synchWithTarget() method.
+     */
+    protected void kludge(Map<String, Monitor> map) {
+        if (Boolean.getBoolean("sun.jvmstat.perfdata.disableKludge")) {
+            // bypass all kludges
+            return;
+        }
+
+        String name = "java.vm.version";
+        StringMonitor jvm_version = (StringMonitor)map.get(name);
+        if (jvm_version == null) {
+            jvm_version = (StringMonitor)findByAlias(name);
+        }
+
+        name = "java.vm.name";
+        StringMonitor jvm_name = (StringMonitor)map.get(name);
+        if (jvm_name == null) {
+            jvm_name = (StringMonitor)findByAlias(name);
+        }
+
+        name = "hotspot.vm.args";
+        StringMonitor args = (StringMonitor)map.get(name);
+        if (args == null) {
+            args = (StringMonitor)findByAlias(name);
+        }
+
+        assert ((jvm_name != null) && (jvm_version != null) && (args != null));
+
+        if (jvm_name.stringValue().indexOf("HotSpot") >= 0) {
+            if (jvm_version.stringValue().startsWith("1.4.2")) {
+                kludgeMantis(map, args);
+            }
+        }
+    }
+
+    /**
+     * method to repair the 1.4.2 parallel scavenge counters that are
+     * incorrectly initialized by the JVM when UseAdaptiveSizePolicy
+     * is set. This bug couldn't be fixed for 1.4.2 FCS due to putback
+     * restrictions.
+     */
+    private void kludgeMantis(Map<String, Monitor> map, StringMonitor args) {
+        /*
+         * the HotSpot 1.4.2 JVM with the +UseParallelGC option along
+         * with its default +UseAdaptiveSizePolicy option has a bug with
+         * the initialization of the sizes of the eden and survivor spaces.
+         * See bugid 4890736.
+         *
+         * note - use explicit 1.4.2 counter names here - don't update
+         * to latest counter names or attempt to find aliases.
+         */
+
+        String cname = "hotspot.gc.collector.0.name";
+        StringMonitor collector = (StringMonitor)map.get(cname);
+
+        if (collector.stringValue().compareTo("PSScavenge") == 0) {
+            boolean adaptiveSizePolicy = true;
+
+            /*
+             * HotSpot processes the -XX:Flags/.hotspotrc arguments prior to
+             * processing the command line arguments. This allows the command
+             * line arguments to override any defaults set in .hotspotrc
+             */
+            cname = "hotspot.vm.flags";
+            StringMonitor flags = (StringMonitor)map.get(cname);
+            String allArgs = flags.stringValue() + " " + args.stringValue();
+
+            /*
+             * ignore the -XX: prefix as it only applies to the arguments
+             * passed from the command line (i.e. the invocation api).
+             * arguments passed through .hotspotrc omit the -XX: prefix.
+             */
+            int ahi = allArgs.lastIndexOf("+AggressiveHeap");
+            int aspi = allArgs.lastIndexOf("-UseAdaptiveSizePolicy");
+
+            if (ahi != -1) {
+                /*
+                 * +AggressiveHeap was set, check if -UseAdaptiveSizePolicy
+                 * is set after +AggressiveHeap.
+                 */
+                //
+                if ((aspi != -1) && (aspi > ahi)) {
+                    adaptiveSizePolicy = false;
+                }
+            } else {
+                /*
+                 * +AggressiveHeap not set, must be +UseParallelGC. The
+                 * relative position of -UseAdaptiveSizePolicy is not
+                 * important in this case, as it will override the
+                 * UseParallelGC default (+UseAdaptiveSizePolicy) if it
+                 * appears anywhere in the JVM arguments.
+                 */
+                if (aspi != -1) {
+                    adaptiveSizePolicy = false;
+                }
+            }
+
+            if (adaptiveSizePolicy) {
+                // adjust the buggy AdaptiveSizePolicy size counters.
+
+                // first remove the real counters.
+                String eden_size = "hotspot.gc.generation.0.space.0.size";
+                String s0_size = "hotspot.gc.generation.0.space.1.size";
+                String s1_size = "hotspot.gc.generation.0.space.2.size";
+                map.remove(eden_size);
+                map.remove(s0_size);
+                map.remove(s1_size);
+
+                // get the maximum new generation size
+                String new_max_name = "hotspot.gc.generation.0.capacity.max";
+                LongMonitor new_max = (LongMonitor)map.get(new_max_name);
+
+                /*
+                 * replace the real counters with pseudo counters that are
+                 * initialized to to the correct values. The maximum size of
+                 * the eden and survivor spaces are supposed to be:
+                 *    max_eden_size = new_size - (2*alignment).
+                 *    max_survivor_size = new_size - (2*alignment).
+                 * since we don't know the alignment value used, and because
+                 * of other parallel scavenge bugs that result in oversized
+                 * spaces, we just set the maximum size of each space to the
+                 * full new gen size.
+                 */
+                Monitor monitor = null;
+
+                LongBuffer lb = LongBuffer.allocate(1);
+                lb.put(new_max.longValue());
+                monitor = new PerfLongMonitor(eden_size, Units.BYTES,
+                                              Variability.CONSTANT, false, lb);
+                map.put(eden_size, monitor);
+
+                monitor = new PerfLongMonitor(s0_size, Units.BYTES,
+                                              Variability.CONSTANT, false, lb);
+                map.put(s0_size, monitor);
+
+                monitor = new PerfLongMonitor(s1_size, Units.BYTES,
+                                              Variability.CONSTANT, false, lb);
+                map.put(s1_size, monitor);
+            }
+        }
+    }
+
+    /**
+     * method to extract the next monitor entry from the instrumentation memory.
+     * assumes that nextEntry is the offset into the byte array
+     * at which to start the search for the next entry. method leaves
+     * next entry pointing to the next entry or to the end of data.
+     */
+    protected Monitor getNextMonitorEntry() throws MonitorException {
+        Monitor monitor = null;
+
+        // entries are always 4 byte aligned.
+        if ((nextEntry % 4) != 0) {
+            throw new MonitorStructureException(
+                   "Entry index not properly aligned: " + nextEntry);
+        }
+
+        // protect against a corrupted shared memory region.
+        if ((nextEntry < 0) || (nextEntry > buffer.limit())) {
+            throw new MonitorStructureException(
+                   "Entry index out of bounds: nextEntry = " + nextEntry
+                   + ", limit = " + buffer.limit());
+        }
+
+        // check for the end of the buffer
+        if (nextEntry == buffer.limit()) {
+            lognl("getNextMonitorEntry():"
+                  + " nextEntry == buffer.limit(): returning");
+            return null;
+        }
+
+        buffer.position(nextEntry);
+
+        int entryStart = buffer.position();
+        int entryLength = buffer.getInt();
+
+        // check for valid entry length
+        if ((entryLength < 0) || (entryLength > buffer.limit())) {
+            throw new MonitorStructureException(
+                   "Invalid entry length: entryLength = " + entryLength);
+        }
+
+        // check if last entry occurs before the eof.
+        if ((entryStart + entryLength) > buffer.limit()) {
+            throw new MonitorStructureException(
+                   "Entry extends beyond end of buffer: "
+                   + " entryStart = " + entryStart
+                   + " entryLength = " + entryLength
+                   + " buffer limit = " + buffer.limit());
+        }
+
+        if (entryLength == 0) {
+            // end of data
+            return null;
+        }
+
+        int nameLength = buffer.getInt();
+        int vectorLength = buffer.getInt();
+        byte dataType = buffer.get();
+        byte flags = buffer.get();
+        Units u = Units.toUnits(buffer.get());
+        Variability v = Variability.toVariability(buffer.get());
+        boolean supported = (flags & 0x01) != 0;
+
+        // defend against corrupt entries
+        if ((nameLength <= 0) || (nameLength > entryLength)) {
+            throw new MonitorStructureException(
+                   "Invalid Monitor name length: " + nameLength);
+        }
+
+        if ((vectorLength < 0) || (vectorLength > entryLength)) {
+            throw new MonitorStructureException(
+                   "Invalid Monitor vector length: " + vectorLength);
+        }
+
+        // read in the perfData item name, casting bytes to chars. skip the
+        // null terminator
+        //
+        byte[] nameBytes = new byte[nameLength-1];
+        for (int i = 0; i < nameLength-1; i++) {
+            nameBytes[i] = buffer.get();
+        }
+
+        // convert name into a String
+        String name = new String(nameBytes, 0, nameLength-1);
+
+        if (v == Variability.INVALID) {
+            throw new MonitorDataException("Invalid variability attribute:"
+                                           + " entry index = " + perfDataItem
+                                           + " name = " + name);
+        }
+        if (u == Units.INVALID) {
+            throw new MonitorDataException("Invalid units attribute: "
+                                           + " entry index = " + perfDataItem
+                                           + " name = " + name);
+        }
+
+        int offset;
+        if (vectorLength == 0) {
+            // scalar Types
+            if (dataType == BasicType.LONG.intValue()) {
+                offset = entryStart + entryLength - 8;  /* 8 = sizeof(long) */
+                buffer.position(offset);
+                LongBuffer lb = buffer.asLongBuffer();
+                lb.limit(1);
+                monitor = new PerfLongMonitor(name, u, v, supported, lb);
+                perfDataItem++;
+            } else {
+                // bad data types.
+                throw new MonitorTypeException("Invalid Monitor type:"
+                                    + " entry index = " + perfDataItem
+                                    + " name = " + name
+                                    + " type = " + dataType);
+            }
+        } else {
+            // vector types
+            if (dataType == BasicType.BYTE.intValue()) {
+                if (u != Units.STRING) {
+                    // only byte arrays of type STRING are currently supported
+                    throw new MonitorTypeException("Invalid Monitor type:"
+                                      + " entry index = " + perfDataItem
+                                      + " name = " + name
+                                      + " type = " + dataType);
+                }
+
+                offset = entryStart + PERFDATA_NAME_OFFSET + nameLength;
+                buffer.position(offset);
+                ByteBuffer bb = buffer.slice();
+                bb.limit(vectorLength);
+                bb.position(0);
+
+                if (v == Variability.CONSTANT) {
+                    monitor = new PerfStringConstantMonitor(name, supported,
+                                                            bb);
+                } else if (v == Variability.VARIABLE) {
+                    monitor = new PerfStringVariableMonitor(name, supported,
+                                                            bb, vectorLength-1);
+                } else {
+                    // Monotonically increasing byte arrays are not supported
+                    throw new MonitorDataException(
+                            "Invalid variability attribute:"
+                            + " entry index = " + perfDataItem
+                            + " name = " + name
+                            + " variability = " + v);
+                }
+                perfDataItem++;
+            } else {
+                // bad data types.
+                throw new MonitorTypeException(
+                        "Invalid Monitor type:" + " entry index = "
+                        + perfDataItem + " name = " + name
+                        + " type = " + dataType);
+            }
+        }
+
+        // setup index to next entry for next iteration of the loop.
+        nextEntry = entryStart + entryLength;
+        return monitor;
+    }
+
+    /**
+     * Method to dump debugging information
+     */
+    private void dumpAll(Map map, int lvmid) {
+        if (DEBUG) {
+            Set keys = map.keySet();
+
+            System.err.println("Dump for " + lvmid);
+            int j = 0;
+            for (Iterator i = keys.iterator(); i.hasNext(); j++) {
+                Monitor monitor = (Monitor)map.get(i.next());
+                System.err.println(j + "\t" + monitor.getName()
+                                   + "=" + monitor.getValue());
+            }
+            System.err.println("nextEntry = " + nextEntry
+                               + " pollForEntry = " + pollForEntry);
+            System.err.println("Buffer info:");
+            System.err.println("buffer = " + buffer);
+        }
+    }
+
+    private void lognl(String s) {
+        if (DEBUG) {
+            System.err.println(s);
+        }
+    }
+
+    private void log(String s) {
+        if (DEBUG) {
+            System.err.print(s);
+        }
+    }
+}

jdkSrc/jdk8/sun/jvmstat/perfdata/monitor/v1_0/PerfDataBufferPrologue.java

@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2004, 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.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.jvmstat.perfdata.monitor.v1_0;
+
+import sun.jvmstat.monitor.*;
+import sun.jvmstat.perfdata.monitor.*;
+import java.nio.*;
+
+/**
+ * Class representing the 1.0 version of the HotSpot PerfData instrumentation
+ * buffer header.
+ * <p>
+ * The PerfDataBufferPrologue2_0 class supports parsing of the version
+ * specific portions of the PerfDataPrologue C structure:
+ * <pre>
+ * typedef struct {
+ *   ...                      // handled by superclass
+ *   jint used;               // number of PerfData memory bytes used
+ *   jint overflow;           // number of bytes of overflow
+ *   jlong mod_time_stamp;    // time stamp of the last structural modification
+ * } PerfDataPrologue
+ * </pre>
+ *
+ * @author Brian Doherty
+ * @since 1.5
+ */
+public class PerfDataBufferPrologue extends AbstractPerfDataBufferPrologue {
+
+    private static final int SUPPORTED_MAJOR_VERSION = 1;
+    private static final int SUPPORTED_MINOR_VERSION = 0;
+
+    /*
+     * the following constants must match the field offsets and sizes
+     * in the PerfDataPrologue structure in perfMemory.hpp
+     */
+    final static int PERFDATA_PROLOG_USED_OFFSET=8;
+    final static int PERFDATA_PROLOG_USED_SIZE=4;              // sizeof(int)
+    final static int PERFDATA_PROLOG_OVERFLOW_OFFSET=12;
+    final static int PERFDATA_PROLOG_OVERFLOW_SIZE=4;          // sizeof(int)
+    final static int PERFDATA_PROLOG_MODTIMESTAMP_OFFSET=16;
+    final static int PERFDATA_PROLOG_MODTIMESTAMP_SIZE=8;      // sizeof(long)
+    final static int PERFDATA_PROLOG_SIZE=24;  // sizeof(struct PerfDataProlog)
+
+    // counter names for prologue psuedo counters
+    final static String PERFDATA_BUFFER_SIZE_NAME  = "sun.perfdata.size";
+    final static String PERFDATA_BUFFER_USED_NAME  = "sun.perfdata.used";
+    final static String PERFDATA_OVERFLOW_NAME     = "sun.perfdata.overflow";
+    final static String PERFDATA_MODTIMESTAMP_NAME = "sun.perfdata.timestamp";
+
+    /**
+     * Create an instance of PerfDataBufferPrologue from the given
+     * ByteBuffer object.
+     *
+     * @param byteBuffer the buffer containing the binary header data
+     */
+    public PerfDataBufferPrologue(ByteBuffer byteBuffer)
+           throws MonitorException  {
+        super(byteBuffer);
+        assert ((getMajorVersion() == 1) && (getMinorVersion() == 0));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public boolean supportsAccessible() {
+        return false;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public boolean isAccessible() {
+        return true;
+    }
+
+    /**
+     * Get the utilization of the instrumentation memory buffer.
+     *
+     * @return int - the utilization of the buffer
+     */
+    public int getUsed() {
+        byteBuffer.position(PERFDATA_PROLOG_USED_OFFSET);
+        return byteBuffer.getInt();
+    }
+
+    /**
+     * Get the size of the instrumentation memory buffer.
+     *
+     * @return int - the size of the buffer
+     */
+    public int getBufferSize() {
+        return byteBuffer.capacity();
+    }
+
+    /**
+     * Get the buffer overflow amount. This value is non-zero if the
+     * HotSpot JVM has overflowed the instrumentation memory buffer.
+     * The target JVM can be restarted with -XX:PerfDataMemSize=X to
+     * create a larger memory buffer.
+     *
+     * @return int - the size of the buffer
+     */
+    public int getOverflow() {
+        byteBuffer.position(PERFDATA_PROLOG_OVERFLOW_OFFSET);
+        return byteBuffer.getInt();
+    }
+
+    /**
+     * Get the time of last modification for the instrumentation
+     * memory buffer. This method returns the time, as ticks since the
+     * start of the target JVM, of the last structural modification to
+     * the instrumentation buffer. Structural modifications correspond to
+     * the addition or deletion of instrumentation objects. Updates to
+     * counter values are not structural modifications.
+     */
+    public long getModificationTimeStamp() {
+        byteBuffer.position(PERFDATA_PROLOG_MODTIMESTAMP_OFFSET);
+        return byteBuffer.getLong();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public int getSize() {
+        return PERFDATA_PROLOG_SIZE;  // sizeof(struct PerfDataProlog)
+    }
+
+    /**
+     * Return an IntBuffer that accesses the used value. This is used
+     * to create a Monitor object for this value.
+     *
+     * @return IntBuffer - a ByteBuffer that accesses the used value
+     *                     in the instrumentation buffer header.
+     * @see #getUsed()
+     */
+    public IntBuffer usedBuffer() {
+        byteBuffer.position(PERFDATA_PROLOG_USED_OFFSET);
+        IntBuffer ib = byteBuffer.asIntBuffer();
+        ib.limit(1);
+        return ib;
+    }
+
+    /**
+     * Return an IntBuffer that accesses the size value. This is used
+     * to create a Monitor object for this value.
+     *
+     * @return IntBuffer - a ByteBuffer that accesses the size value
+     *                     in the instrumentation buffer header.
+     * @see #getBufferSize()
+     */
+    public IntBuffer sizeBuffer() {
+        IntBuffer ib = IntBuffer.allocate(1);
+        ib.put(byteBuffer.capacity());
+        return ib;
+    }
+
+    /**
+     * Return an IntBuffer that accesses the overflow value. This is used
+     * to create a Monitor object for this value.
+     *
+     * @return IntBuffer - a ByteBuffer that accesses the overflow value
+     *                     in the instrumentation buffer header.
+     * @see #getOverflow()
+     */
+    public IntBuffer overflowBuffer() {
+        byteBuffer.position(PERFDATA_PROLOG_OVERFLOW_OFFSET);
+        IntBuffer ib = byteBuffer.asIntBuffer();
+        ib.limit(1);
+        return ib;
+    }
+
+    /**
+     * Return an LongBuffer that accesses the modification timestamp value.
+     * This is used* to create a Monitor object for this value.
+     *
+     * @return LongBuffer - a ByteBuffer that accesses the modification time
+     *                      stamp value in the instrumentation buffer header.
+     * @see #getModificationTimeStamp()
+     */
+    public LongBuffer modificationTimeStampBuffer() {
+        byteBuffer.position(PERFDATA_PROLOG_MODTIMESTAMP_OFFSET);
+        LongBuffer lb = byteBuffer.asLongBuffer();
+        lb.limit(1);
+        return lb;
+    }
+}