| /* |
| * Copyright (c) 2003, 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.management.counter.perf; |
| |
| import sun.management.counter.*; |
| import java.nio.*; |
| import java.util.*; |
| import java.util.regex.*; |
| |
| public class PerfInstrumentation { |
| private ByteBuffer buffer; |
| private Prologue prologue; |
| private long lastModificationTime; |
| private long lastUsed; |
| private int nextEntry; |
| private SortedMap<String, Counter> map; |
| |
| public PerfInstrumentation(ByteBuffer b) { |
| prologue = new Prologue(b); |
| buffer = b; |
| buffer.order(prologue.getByteOrder()); |
| |
| // Check recognized versions |
| int major = getMajorVersion(); |
| int minor = getMinorVersion(); |
| |
| // Support only 2.0 version |
| if (major < 2) { |
| throw new InstrumentationException("Unsupported version: " + |
| major + "." + minor); |
| } |
| rewind(); |
| } |
| |
| public int getMajorVersion() { |
| return prologue.getMajorVersion(); |
| } |
| |
| public int getMinorVersion() { |
| return prologue.getMinorVersion(); |
| } |
| |
| public long getModificationTimeStamp() { |
| return prologue.getModificationTimeStamp(); |
| } |
| |
| void rewind() { |
| // rewind to the first entry |
| buffer.rewind(); |
| buffer.position(prologue.getEntryOffset()); |
| nextEntry = buffer.position(); |
| // rebuild all the counters |
| map = new TreeMap<String, Counter>(); |
| } |
| |
| boolean hasNext() { |
| return (nextEntry < prologue.getUsed()); |
| } |
| |
| Counter getNextCounter() { |
| if (! hasNext()) { |
| return null; |
| } |
| |
| if ((nextEntry % 4) != 0) { |
| // entries are always 4 byte aligned. |
| throw new InstrumentationException( |
| "Entry index not properly aligned: " + nextEntry); |
| } |
| |
| if (nextEntry < 0 || nextEntry > buffer.limit()) { |
| // defensive check to protect against a corrupted shared memory region. |
| throw new InstrumentationException( |
| "Entry index out of bounds: nextEntry = " + nextEntry + |
| ", limit = " + buffer.limit()); |
| } |
| |
| buffer.position(nextEntry); |
| PerfDataEntry entry = new PerfDataEntry(buffer); |
| nextEntry = nextEntry + entry.size(); |
| |
| Counter counter = null; |
| PerfDataType type = entry.type(); |
| if (type == PerfDataType.BYTE) { |
| if (entry.units() == Units.STRING && entry.vectorLength() > 0) { |
| counter = new PerfStringCounter(entry.name(), |
| entry.variability(), |
| entry.flags(), |
| entry.vectorLength(), |
| entry.byteData()); |
| } else if (entry.vectorLength() > 0) { |
| counter = new PerfByteArrayCounter(entry.name(), |
| entry.units(), |
| entry.variability(), |
| entry.flags(), |
| entry.vectorLength(), |
| entry.byteData()); |
| } else { |
| // ByteArrayCounter must have vectorLength > 0 |
| assert false; |
| } |
| } |
| else if (type == PerfDataType.LONG) { |
| if (entry.vectorLength() == 0) { |
| counter = new PerfLongCounter(entry.name(), |
| entry.units(), |
| entry.variability(), |
| entry.flags(), |
| entry.longData()); |
| } else { |
| counter = new PerfLongArrayCounter(entry.name(), |
| entry.units(), |
| entry.variability(), |
| entry.flags(), |
| entry.vectorLength(), |
| entry.longData()); |
| } |
| } |
| else { |
| // FIXME: Should we throw an exception for unsupported type? |
| // Currently skip such entry |
| assert false; |
| } |
| return counter; |
| } |
| |
| public synchronized List<Counter> getAllCounters() { |
| while (hasNext()) { |
| Counter c = getNextCounter(); |
| if (c != null) { |
| map.put(c.getName(), c); |
| } |
| } |
| return new ArrayList<Counter>(map.values()); |
| } |
| |
| public synchronized List<Counter> findByPattern(String patternString) { |
| while (hasNext()) { |
| Counter c = getNextCounter(); |
| if (c != null) { |
| map.put(c.getName(), c); |
| } |
| } |
| |
| Pattern pattern = Pattern.compile(patternString); |
| Matcher matcher = pattern.matcher(""); |
| List<Counter> matches = new ArrayList<Counter>(); |
| |
| Iterator iter = map.entrySet().iterator(); |
| while (iter.hasNext()) { |
| Map.Entry me = (Map.Entry) iter.next(); |
| String name = (String) me.getKey(); |
| |
| // apply pattern to counter name |
| matcher.reset(name); |
| |
| // if the pattern matches, then add Counter to list |
| if (matcher.lookingAt()) { |
| matches.add((Counter)me.getValue()); |
| } |
| } |
| return matches; |
| } |
| } |