--- old/src/java.base/share/classes/java/lang/ClassLoader.java 2016-01-08 18:52:02.121440348 +0000 +++ new/src/java.base/share/classes/java/lang/ClassLoader.java 2016-01-08 18:52:01.981443330 +0000 @@ -50,6 +50,8 @@ import java.util.Hashtable; import java.util.WeakHashMap; import java.util.concurrent.ConcurrentHashMap; + +import jdk.internal.perf.PerfCounter; import sun.misc.Resource; import sun.misc.URLClassPath; import sun.reflect.CallerSensitive; @@ -423,9 +425,9 @@ c = findClass(name); // this is the defining class loader; record the stats - sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0); - sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1); - sun.misc.PerfCounter.getFindClasses().increment(); + PerfCounter.getParentDelegationTime().addTime(t1 - t0); + PerfCounter.getFindClassTime().addElapsedTimeFrom(t1); + PerfCounter.getFindClasses().increment(); } } if (resolve) { --- old/src/java.base/share/classes/java/net/URLClassLoader.java 2016-01-08 18:52:02.557431061 +0000 +++ new/src/java.base/share/classes/java/net/URLClassLoader.java 2016-01-08 18:52:02.409434213 +0000 @@ -52,6 +52,7 @@ import jdk.internal.misc.JavaNetAccess; import jdk.internal.misc.SharedSecrets; +import jdk.internal.perf.PerfCounter; import sun.misc.Resource; import sun.misc.URLClassPath; import sun.net.www.ParseUtil; @@ -459,14 +460,14 @@ // Use (direct) ByteBuffer: CodeSigner[] signers = res.getCodeSigners(); CodeSource cs = new CodeSource(url, signers); - sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0); + PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0); return defineClass(name, bb, cs); } else { byte[] b = res.getBytes(); // must read certificates AFTER reading bytes. CodeSigner[] signers = res.getCodeSigners(); CodeSource cs = new CodeSource(url, signers); - sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0); + PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0); return defineClass(name, b, 0, b.length, cs); } } --- old/src/java.base/share/classes/java/util/zip/ZipFile.java 2016-01-08 18:52:02.957422540 +0000 +++ new/src/java.base/share/classes/java/util/zip/ZipFile.java 2016-01-08 18:52:02.817425522 +0000 @@ -54,6 +54,7 @@ import java.util.stream.StreamSupport; import jdk.internal.misc.JavaUtilZipFileAccess; import jdk.internal.misc.SharedSecrets; +import jdk.internal.perf.PerfCounter; import static java.util.zip.ZipConstants.*; import static java.util.zip.ZipConstants64.*; @@ -210,8 +211,8 @@ this.name = name; long t0 = System.nanoTime(); this.zsrc = Source.get(file, (mode & OPEN_DELETE) != 0); - sun.misc.PerfCounter.getZipFileOpenTime().addElapsedTimeFrom(t0); - sun.misc.PerfCounter.getZipFileCount().increment(); + PerfCounter.getZipFileOpenTime().addElapsedTimeFrom(t0); + PerfCounter.getZipFileCount().increment(); } /** --- old/src/java.desktop/share/classes/sun/applet/AppletPanel.java 2016-01-08 18:52:03.377413593 +0000 +++ new/src/java.desktop/share/classes/sun/applet/AppletPanel.java 2016-01-08 18:52:03.241416490 +0000 @@ -39,12 +39,12 @@ import java.util.*; import java.util.Locale; import java.util.concurrent.LinkedBlockingQueue; +import jdk.internal.perf.PerformanceLogger; import sun.awt.AWTAccessor; import sun.awt.AppContext; import sun.awt.EmbeddedFrame; import sun.awt.SunToolkit; import sun.misc.ManagedLocalsThread; -import sun.misc.PerformanceLogger; import sun.security.util.SecurityConstants; /** --- old/src/java.desktop/share/classes/sun/java2d/SunGraphics2D.java 2016-01-08 18:52:03.797404646 +0000 +++ new/src/java.desktop/share/classes/sun/java2d/SunGraphics2D.java 2016-01-08 18:52:03.661407543 +0000 @@ -90,7 +90,7 @@ import sun.awt.SunHints; import java.util.Map; import java.util.Iterator; -import sun.misc.PerformanceLogger; +import jdk.internal.perf.PerformanceLogger; import java.lang.annotation.Native; import java.awt.image.MultiResolutionImage; --- old/src/java.desktop/unix/classes/sun/awt/X11/XToolkit.java 2016-01-08 18:52:04.237395274 +0000 +++ new/src/java.desktop/unix/classes/sun/awt/X11/XToolkit.java 2016-01-08 18:52:04.097398255 +0000 @@ -47,11 +47,11 @@ import java.util.*; import javax.swing.LookAndFeel; import javax.swing.UIDefaults; +import jdk.internal.perf.PerformanceLogger; import sun.awt.*; import sun.awt.datatransfer.DataTransferer; import sun.font.FontConfigManager; import sun.java2d.SunGraphicsEnvironment; -import sun.misc.*; import sun.awt.util.ThreadGroupUtils; import sun.print.PrintJob2D; import sun.security.action.GetPropertyAction; @@ -282,7 +282,7 @@ } }; String name = "XToolkt-Shutdown-Thread"; - Thread shutdownThread = new ManagedLocalsThread( + Thread shutdownThread = new sun.misc.ManagedLocalsThread( ThreadGroupUtils.getRootThreadGroup(), r, name); shutdownThread.setContextClassLoader(null); Runtime.getRuntime().addShutdownHook(shutdownThread); @@ -330,7 +330,7 @@ toolkitThread = AccessController.doPrivileged((PrivilegedAction) () -> { String name = "AWT-XAWT"; - Thread thread = new ManagedLocalsThread( + Thread thread = new sun.misc.ManagedLocalsThread( ThreadGroupUtils.getRootThreadGroup(), this, name); thread.setContextClassLoader(null); thread.setPriority(Thread.NORM_PRIORITY + 1); --- old/src/java.desktop/windows/classes/sun/awt/windows/WToolkit.java 2016-01-08 18:52:04.661386241 +0000 +++ new/src/java.desktop/windows/classes/sun/awt/windows/WToolkit.java 2016-01-08 18:52:04.513389394 +0000 @@ -67,10 +67,11 @@ import java.util.Map; import java.util.Properties; +import jdk.internal.perf.PerformanceLogger; + import sun.font.FontManager; import sun.font.FontManagerFactory; import sun.font.SunFontManager; -import sun.misc.PerformanceLogger; import sun.util.logging.PlatformLogger; public final class WToolkit extends SunToolkit implements Runnable { --- old/src/java.desktop/windows/classes/sun/java2d/d3d/D3DGraphicsDevice.java 2016-01-08 18:52:05.073377465 +0000 +++ new/src/java.desktop/windows/classes/sun/java2d/d3d/D3DGraphicsDevice.java 2016-01-08 18:52:04.925380618 +0000 @@ -38,6 +38,7 @@ import java.awt.peer.WindowPeer; import java.util.ArrayList; +import jdk.internal.perf.PerfCounter; import sun.awt.AWTAccessor; import sun.awt.AWTAccessor.ComponentAccessor; import sun.awt.Win32GraphicsDevice; @@ -69,9 +70,9 @@ if (d3dAvailable) { // we don't use pixel formats for the d3d pipeline pfDisabled = true; - sun.misc.PerfCounter.getD3DAvailable().set(1); + PerfCounter.getD3DAvailable().set(1); } else { - sun.misc.PerfCounter.getD3DAvailable().set(0); + PerfCounter.getD3DAvailable().set(0); } } --- old/src/java.management/share/classes/sun/management/ConnectorAddressLink.java 2016-01-08 18:52:05.481368774 +0000 +++ new/src/java.management/share/classes/sun/management/ConnectorAddressLink.java 2016-01-08 18:52:05.349371586 +0000 @@ -34,7 +34,7 @@ import java.util.Map; import java.util.concurrent.atomic.AtomicInteger; -import sun.misc.Perf; +import jdk.internal.perf.Perf; import sun.management.counter.Units; import sun.management.counter.Counter; import sun.management.counter.perf.PerfInstrumentation; --- old/src/java.management/share/classes/sun/management/VMManagementImpl.java 2016-01-08 18:52:05.881360253 +0000 +++ new/src/java.management/share/classes/sun/management/VMManagementImpl.java 2016-01-08 18:52:05.733363406 +0000 @@ -25,7 +25,7 @@ package sun.management; -import sun.misc.Perf; +import jdk.internal.perf.Perf; import sun.management.counter.*; import sun.management.counter.perf.*; import java.nio.ByteBuffer; --- old/src/jdk.jvmstat/share/classes/sun/jvmstat/perfdata/monitor/AbstractMonitoredVm.java 2016-01-08 18:52:06.245352499 +0000 +++ new/src/jdk.jvmstat/share/classes/sun/jvmstat/perfdata/monitor/AbstractMonitoredVm.java 2016-01-08 18:52:06.113355312 +0000 @@ -95,7 +95,7 @@ public void detach() { /* * no default action required because the detach operation for the - * native byte buffer is managed by the sun.misc.Perf class. + * native byte buffer is managed by the Perf class. */ } --- old/src/jdk.jvmstat/share/classes/sun/jvmstat/perfdata/monitor/AbstractPerfDataBuffer.java 2016-01-08 18:52:06.621344490 +0000 +++ new/src/jdk.jvmstat/share/classes/sun/jvmstat/perfdata/monitor/AbstractPerfDataBuffer.java 2016-01-08 18:52:06.485347387 +0000 @@ -25,7 +25,6 @@ package sun.jvmstat.perfdata.monitor; -import sun.misc.Perf; import sun.jvmstat.monitor.*; import java.util.*; import java.io.*; --- old/src/jdk.jvmstat/share/classes/sun/jvmstat/perfdata/monitor/protocol/local/PerfDataBuffer.java 2016-01-08 18:52:06.977336907 +0000 +++ new/src/jdk.jvmstat/share/classes/sun/jvmstat/perfdata/monitor/protocol/local/PerfDataBuffer.java 2016-01-08 18:52:06.849339633 +0000 @@ -25,7 +25,7 @@ package sun.jvmstat.perfdata.monitor.protocol.local; -import sun.misc.Perf; +import jdk.internal.perf.Perf; import sun.jvmstat.monitor.*; import sun.jvmstat.perfdata.monitor.*; import java.util.*; --- old/src/java.base/share/classes/sun/misc/Perf.java 2016-01-08 18:52:07.341329153 +0000 +++ /dev/null 2015-10-21 15:25:26.827416476 +0100 @@ -1,538 +0,0 @@ -/* - * Copyright (c) 2002, 2006, 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.misc; - -import java.nio.ByteBuffer; -import java.security.Permission; -import java.security.PrivilegedAction; -import java.io.IOException; -import java.io.UnsupportedEncodingException; - -/** - * The Perf class provides the ability to attach to an instrumentation - * buffer maintained by a Java virtual machine. The instrumentation - * buffer may be for the Java virtual machine running the methods of - * this class or it may be for another Java virtual machine on the - * same system. - *

- * In addition, this class provides methods to create instrumentation - * objects in the instrumentation buffer for the Java virtual machine - * that is running these methods. It also contains methods for acquiring - * the value of a platform specific high resolution clock for time - * stamp and interval measurement purposes. - * - * @author Brian Doherty - * @since 1.4.2 - * @see #getPerf - * @see sun.misc.Perf$GetPerfAction - * @see java.nio.ByteBuffer - */ -public final class Perf { - - private static Perf instance; - - private static final int PERF_MODE_RO = 0; - private static final int PERF_MODE_RW = 1; - - private Perf() { } // prevent instantiation - - /** - * The GetPerfAction class is a convenience class for acquiring access - * to the singleton Perf instance using the - * AccessController.doPrivileged() method. - *

- * An instance of this class can be used as the argument to - * AccessController.doPrivileged(PrivilegedAction). - *

Here is a suggested idiom for use of this class: - * - * 

{@code
-     * class MyTrustedClass {
-     *   private static final Perf perf =
-     *       AccessController.doPrivileged(new Perf.GetPerfAction());
-     *   ...
-     * }
-     * }
- *

- * In the presence of a security manager, the MyTrustedClass - * class in the above example will need to be granted the - * "sun.misc.Perf.getPerf" RuntimePermission - * permission in order to successfully acquire the singleton Perf instance. - *

- * Please note that the "sun.misc.Perf.getPerf" permission - * is not a JDK specified permission. - * - * @see java.security.AccessController#doPrivileged(PrivilegedAction) - * @see java.lang.RuntimePermission - */ - public static class GetPerfAction implements PrivilegedAction - { - /** - * Run the Perf.getPerf() method in a privileged context. - * - * @see #getPerf - */ - public Perf run() { - return getPerf(); - } - } - - /** - * Return a reference to the singleton Perf instance. - *

- * The getPerf() method returns the singleton instance of the Perf - * class. The returned object provides the caller with the capability - * for accessing the instrumentation buffer for this or another local - * Java virtual machine. - *

- * If a security manager is installed, its checkPermission - * method is called with a RuntimePermission with a target - * of "sun.misc.Perf.getPerf". A security exception will result - * if the caller has not been granted this permission. - *

- * Access to the returned Perf object should be protected - * by its caller and not passed on to untrusted code. This object can - * be used to attach to the instrumentation buffer provided by this Java - * virtual machine or for those of other Java virtual machines running - * on the same system. The instrumentation buffer may contain senstitive - * information. API's built on top of this interface may want to provide - * finer grained access control to the contents of individual - * instrumentation objects contained within the buffer. - *

- * Please note that the "sun.misc.Perf.getPerf" permission - * is not a JDK specified permission. - * - * @return A reference to the singleton Perf instance. - * @throws AccessControlException if a security manager exists and - * its checkPermission method doesn't allow - * access to the "sun.misc.Perf.getPerf" target. - * @see java.lang.RuntimePermission - * @see #attach - */ - public static Perf getPerf() - { - SecurityManager security = System.getSecurityManager(); - if (security != null) { - Permission perm = new RuntimePermission("sun.misc.Perf.getPerf"); - security.checkPermission(perm); - } - - return instance; - } - - /** - * Attach to the instrumentation buffer for the specified Java virtual - * machine. - *

- * This method will attach to the instrumentation buffer for the - * specified virtual machine. It returns a ByteBuffer object - * that is initialized to access the instrumentation buffer for the - * indicated Java virtual machine. The lvmid parameter is - * a integer value that uniquely identifies the target local Java virtual - * machine. It is typically, but not necessarily, the process id of - * the target Java virtual machine. - *

- * If the lvmid identifies a Java virtual machine different - * from the one running this method, then the coherency characteristics - * of the buffer are implementation dependent. Implementations that do - * not support named, coherent, shared memory may return a - * ByteBuffer object that contains only a snap shot of the - * data in the instrumentation buffer. Implementations that support named, - * coherent, shared memory, may return a ByteBuffer object - * that will be changing dynamically over time as the target Java virtual - * machine updates its mapping of this buffer. - *

- * If the lvmid is 0 or equal to the actual lvmid - * for the Java virtual machine running this method, then the returned - * ByteBuffer object will always be coherent and dynamically - * changing. - *

- * The attach mode specifies the access permissions requested for the - * instrumentation buffer of the target virtual machine. The permitted - * access permissions are: - *

- * - * @param lvmid an integer that uniquely identifies the - * target local Java virtual machine. - * @param mode a string indicating the attach mode. - * @return ByteBuffer a direct allocated byte buffer - * @throws IllegalArgumentException The lvmid or mode was invalid. - * @throws IOException An I/O error occurred while trying to acquire - * the instrumentation buffer. - * @throws OutOfMemoryError The instrumentation buffer could not be mapped - * into the virtual machine's address space. - * @see java.nio.ByteBuffer - */ - public ByteBuffer attach(int lvmid, String mode) - throws IllegalArgumentException, IOException - { - if (mode.compareTo("r") == 0) { - return attachImpl(null, lvmid, PERF_MODE_RO); - } - else if (mode.compareTo("rw") == 0) { - return attachImpl(null, lvmid, PERF_MODE_RW); - } - else { - throw new IllegalArgumentException("unknown mode"); - } - } - - /** - * Attach to the instrumentation buffer for the specified Java virtual - * machine owned by the given user. - *

- * This method behaves just as the attach(int lvmid, String mode) - * method, except that it only searches for Java virtual machines - * owned by the specified user. - * - * @param user A String object containing the - * name of the user that owns the target Java - * virtual machine. - * @param lvmid an integer that uniquely identifies the - * target local Java virtual machine. - * @param mode a string indicating the attach mode. - * @return ByteBuffer a direct allocated byte buffer - * @throws IllegalArgumentException The lvmid or mode was invalid. - * @throws IOException An I/O error occurred while trying to acquire - * the instrumentation buffer. - * @throws OutOfMemoryError The instrumentation buffer could not be mapped - * into the virtual machine's address space. - * @see java.nio.ByteBuffer - */ - public ByteBuffer attach(String user, int lvmid, String mode) - throws IllegalArgumentException, IOException - { - if (mode.compareTo("r") == 0) { - return attachImpl(user, lvmid, PERF_MODE_RO); - } - else if (mode.compareTo("rw") == 0) { - return attachImpl(user, lvmid, PERF_MODE_RW); - } - else { - throw new IllegalArgumentException("unknown mode"); - } - } - - /** - * Call the implementation specific attach method. - *

- * This method calls into the Java virtual machine to perform the platform - * specific attach method. Buffers returned from this method are - * internally managed as PhantomRefereces to provide for - * guaranteed, secure release of the native resources. - * - * @param user A String object containing the - * name of the user that owns the target Java - * virtual machine. - * @param lvmid an integer that uniquely identifies the - * target local Java virtual machine. - * @param mode a string indicating the attach mode. - * @return ByteBuffer a direct allocated byte buffer - * @throws IllegalArgumentException The lvmid or mode was invalid. - * @throws IOException An I/O error occurred while trying to acquire - * the instrumentation buffer. - * @throws OutOfMemoryError The instrumentation buffer could not be mapped - * into the virtual machine's address space. - */ - private ByteBuffer attachImpl(String user, int lvmid, int mode) - throws IllegalArgumentException, IOException - { - final ByteBuffer b = attach(user, lvmid, mode); - - if (lvmid == 0) { - // The native instrumentation buffer for this Java virtual - // machine is never unmapped. - return b; - } - else { - // This is an instrumentation buffer for another Java virtual - // machine with native resources that need to be managed. We - // create a duplicate of the native ByteBuffer and manage it - // with a Cleaner object (PhantomReference). When the duplicate - // becomes only phantomly reachable, the native resources will - // be released. - - final ByteBuffer dup = b.duplicate(); - Cleaner.create(dup, new Runnable() { - public void run() { - try { - instance.detach(b); - } - catch (Throwable th) { - // avoid crashing the reference handler thread, - // but provide for some diagnosability - assert false : th.toString(); - } - } - }); - return dup; - } - } - - /** - * Native method to perform the implementation specific attach mechanism. - *

- * The implementation of this method may return distinct or identical - * ByteBuffer objects for two distinct calls requesting - * attachment to the same Java virtual machine. - *

- * For the Sun HotSpot JVM, two distinct calls to attach to the same - * target Java virtual machine will result in two distinct ByteBuffer - * objects returned by this method. This may change in a future release. - * - * @param user A String object containing the - * name of the user that owns the target Java - * virtual machine. - * @param lvmid an integer that uniquely identifies the - * target local Java virtual machine. - * @param mode a string indicating the attach mode. - * @return ByteBuffer a direct allocated byte buffer - * @throws IllegalArgumentException The lvmid or mode was invalid. - * @throws IOException An I/O error occurred while trying to acquire - * the instrumentation buffer. - * @throws OutOfMemoryError The instrumentation buffer could not be mapped - * into the virtual machine's address space. - */ - private native ByteBuffer attach(String user, int lvmid, int mode) - throws IllegalArgumentException, IOException; - - /** - * Native method to perform the implementation specific detach mechanism. - *

- * If this method is passed a ByteBuffer object that is - * not created by the attach method, then the results of - * this method are undefined, with unpredictable and potentially damaging - * effects to the Java virtual machine. To prevent accidental or malicious - * use of this method, all native ByteBuffer created by the - * attach method are managed internally as PhantomReferences - * and resources are freed by the system. - *

- * If this method is passed a ByteBuffer object created - * by the attach method with a lvmid for the Java virtual - * machine running this method (lvmid=0, for example), then the detach - * request is silently ignored. - * - * @param ByteBuffer A direct allocated byte buffer created by the - * attach method. - * @see java.nio.ByteBuffer - * @see #attach - */ - private native void detach(ByteBuffer bb); - - /** - * Create a long scalar entry in the instrumentation buffer - * with the given variability characteristic, units, and initial value. - *

- * Access to the instrument is provided through the returned - * ByteBuffer object. Typically, this object should be wrapped - * with LongBuffer view object. - * - * @param variability the variability characteristic for this entry. - * @param units the units for this entry. - * @param name the name of this entry. - * @param value the initial value for this entry. - * @return ByteBuffer a direct allocated ByteBuffer object that - * allows write access to a native memory location - * containing a long value. - * - * see sun.misc.perf.Variability - * see sun.misc.perf.Units - * @see java.nio.ByteBuffer - */ - public native ByteBuffer createLong(String name, int variability, - int units, long value); - - /** - * Create a String entry in the instrumentation buffer with - * the given variability characteristic, units, and initial value. - *

- * The maximum length of the String stored in this string - * instrument is given in by maxLength parameter. Updates - * to this instrument with String values with lengths greater - * than maxLength will be truncated to maxLength. - * The truncated value will be terminated by a null character. - *

- * The underlying implementation may further limit the length of the - * value, but will continue to preserve the null terminator. - *

- * Access to the instrument is provided through the returned - * ByteBuffer object. - * - * @param variability the variability characteristic for this entry. - * @param units the units for this entry. - * @param name the name of this entry. - * @param value the initial value for this entry. - * @param maxLength the maximum string length for this string - * instrument. - * @return ByteBuffer a direct allocated ByteBuffer that allows - * write access to a native memory location - * containing a long value. - * - * see sun.misc.perf.Variability - * see sun.misc.perf.Units - * @see java.nio.ByteBuffer - */ - public ByteBuffer createString(String name, int variability, - int units, String value, int maxLength) - { - byte[] v = getBytes(value); - byte[] v1 = new byte[v.length+1]; - System.arraycopy(v, 0, v1, 0, v.length); - v1[v.length] = '\0'; - return createByteArray(name, variability, units, v1, Math.max(v1.length, maxLength)); - } - - /** - * Create a String entry in the instrumentation buffer with - * the given variability characteristic, units, and initial value. - *

- * The maximum length of the String stored in this string - * instrument is implied by the length of the value parameter. - * Subsequent updates to the value of this instrument will be truncated - * to this implied maximum length. The truncated value will be terminated - * by a null character. - *

- * The underlying implementation may further limit the length of the - * initial or subsequent value, but will continue to preserve the null - * terminator. - *

- * Access to the instrument is provided through the returned - * ByteBuffer object. - * - * @param variability the variability characteristic for this entry. - * @param units the units for this entry. - * @param name the name of this entry. - * @param value the initial value for this entry. - * @return ByteBuffer a direct allocated ByteBuffer that allows - * write access to a native memory location - * containing a long value. - * - * see sun.misc.perf.Variability - * see sun.misc.perf.Units - * @see java.nio.ByteBuffer - */ - public ByteBuffer createString(String name, int variability, - int units, String value) - { - byte[] v = getBytes(value); - byte[] v1 = new byte[v.length+1]; - System.arraycopy(v, 0, v1, 0, v.length); - v1[v.length] = '\0'; - return createByteArray(name, variability, units, v1, v1.length); - } - - /** - * Create a byte vector entry in the instrumentation buffer - * with the given variability characteristic, units, and initial value. - *

- * The maxLength parameter limits the size of the byte - * array instrument such that the initial or subsequent updates beyond - * this length are silently ignored. No special handling of truncated - * updates is provided. - *

- * The underlying implementation may further limit the length of the - * length of the initial or subsequent value. - *

- * Access to the instrument is provided through the returned - * ByteBuffer object. - * - * @param variability the variability characteristic for this entry. - * @param units the units for this entry. - * @param name the name of this entry. - * @param value the initial value for this entry. - * @param maxLength the maximum length of this byte array. - * @return ByteBuffer a direct allocated byte buffer that allows - * write access to a native memory location - * containing a long value. - * - * see sun.misc.perf.Variability - * see sun.misc.perf.Units - * @see java.nio.ByteBuffer - */ - public native ByteBuffer createByteArray(String name, int variability, - int units, byte[] value, - int maxLength); - - - /** - * convert string to an array of UTF-8 bytes - */ - private static byte[] getBytes(String s) - { - byte[] bytes = null; - - try { - bytes = s.getBytes("UTF-8"); - } - catch (UnsupportedEncodingException e) { - // ignore, UTF-8 encoding is always known - } - - return bytes; - } - - /** - * Return the value of the High Resolution Counter. - * - * The High Resolution Counter returns the number of ticks since - * since the start of the Java virtual machine. The resolution of - * the counter is machine dependent and can be determined from the - * value return by the {@link #highResFrequency} method. - * - * @return the number of ticks of machine dependent resolution since - * the start of the Java virtual machine. - * - * @see #highResFrequency - * @see java.lang.System#currentTimeMillis() - */ - public native long highResCounter(); - - /** - * Returns the frequency of the High Resolution Counter, in ticks per - * second. - * - * This value can be used to convert the value of the High Resolution - * Counter, as returned from a call to the {@link #highResCounter} method, - * into the number of seconds since the start of the Java virtual machine. - * - * @return the frequency of the High Resolution Counter. - * @see #highResCounter - */ - public native long highResFrequency(); - - private static native void registerNatives(); - - static { - registerNatives(); - instance = new Perf(); - } -} --- /dev/null 2015-10-21 15:25:26.827416476 +0100 +++ new/src/java.base/share/classes/jdk/internal/perf/Perf.java 2016-01-08 18:52:07.213331880 +0000 @@ -0,0 +1,547 @@ +/* + * Copyright (c) 2002, 2006, 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 jdk.internal.perf; + +import java.nio.ByteBuffer; +import java.security.Permission; +import java.security.PrivilegedAction; +import java.io.IOException; +import java.io.UnsupportedEncodingException; +import jdk.internal.ref.CleanerFactory; + +/** + * The Perf class provides the ability to attach to an instrumentation + * buffer maintained by a Java virtual machine. The instrumentation + * buffer may be for the Java virtual machine running the methods of + * this class or it may be for another Java virtual machine on the + * same system. + *

+ * In addition, this class provides methods to create instrumentation + * objects in the instrumentation buffer for the Java virtual machine + * that is running these methods. It also contains methods for acquiring + * the value of a platform specific high resolution clock for time + * stamp and interval measurement purposes. + * + * @author Brian Doherty + * @since 1.4.2 + * @see #getPerf + * @see jdk.internal.perf.Perf.GetPerfAction + * @see java.nio.ByteBuffer + */ +public final class Perf { + + private static Perf instance; + + private static final int PERF_MODE_RO = 0; + private static final int PERF_MODE_RW = 1; + + private Perf() { } // prevent instantiation + + /** + * The GetPerfAction class is a convenience class for acquiring access + * to the singleton Perf instance using the + * AccessController.doPrivileged() method. + *

+ * An instance of this class can be used as the argument to + * AccessController.doPrivileged(PrivilegedAction). + *

Here is a suggested idiom for use of this class: + * + * 

{@code
+     * class MyTrustedClass {
+     *   private static final Perf perf =
+     *       AccessController.doPrivileged(new Perf.GetPerfAction());
+     *   ...
+     * }
+     * }
+ *

+ * In the presence of a security manager, the MyTrustedClass + * class in the above example will need to be granted the + * "sun.misc.Perf.getPerf" RuntimePermission + * permission in order to successfully acquire the singleton Perf instance. + *

+ * Please note that the "sun.misc.Perf.getPerf" permission + * is not a JDK specified permission. + * + * @see java.security.AccessController#doPrivileged(PrivilegedAction) + * @see java.lang.RuntimePermission + */ + public static class GetPerfAction implements PrivilegedAction + { + /** + * Run the Perf.getPerf() method in a privileged context. + * + * @see #getPerf + */ + public Perf run() { + return getPerf(); + } + } + + /** + * Return a reference to the singleton Perf instance. + *

+ * The getPerf() method returns the singleton instance of the Perf + * class. The returned object provides the caller with the capability + * for accessing the instrumentation buffer for this or another local + * Java virtual machine. + *

+ * If a security manager is installed, its checkPermission + * method is called with a RuntimePermission with a target + * of "sun.misc.Perf.getPerf". A security exception will result + * if the caller has not been granted this permission. + *

+ * Access to the returned Perf object should be protected + * by its caller and not passed on to untrusted code. This object can + * be used to attach to the instrumentation buffer provided by this Java + * virtual machine or for those of other Java virtual machines running + * on the same system. The instrumentation buffer may contain senstitive + * information. API's built on top of this interface may want to provide + * finer grained access control to the contents of individual + * instrumentation objects contained within the buffer. + *

+ * Please note that the "sun.misc.Perf.getPerf" permission + * is not a JDK specified permission. + * + * @return A reference to the singleton Perf instance. + * @throws SecurityException if a security manager exists and its + * checkPermission method doesn't allow access + * to the "jdk.internal.perf.Perf.getPerf"" target. + * @see java.lang.RuntimePermission + * @see #attach + */ + public static Perf getPerf() + { + SecurityManager security = System.getSecurityManager(); + if (security != null) { + Permission perm = new RuntimePermission("jdk.internal.perf.Perf.getPerf"); + security.checkPermission(perm); + } + + return instance; + } + + /** + * Attach to the instrumentation buffer for the specified Java virtual + * machine. + *

+ * This method will attach to the instrumentation buffer for the + * specified virtual machine. It returns a ByteBuffer object + * that is initialized to access the instrumentation buffer for the + * indicated Java virtual machine. The lvmid parameter is + * a integer value that uniquely identifies the target local Java virtual + * machine. It is typically, but not necessarily, the process id of + * the target Java virtual machine. + *

+ * If the lvmid identifies a Java virtual machine different + * from the one running this method, then the coherency characteristics + * of the buffer are implementation dependent. Implementations that do + * not support named, coherent, shared memory may return a + * ByteBuffer object that contains only a snap shot of the + * data in the instrumentation buffer. Implementations that support named, + * coherent, shared memory, may return a ByteBuffer object + * that will be changing dynamically over time as the target Java virtual + * machine updates its mapping of this buffer. + *

+ * If the lvmid is 0 or equal to the actual lvmid + * for the Java virtual machine running this method, then the returned + * ByteBuffer object will always be coherent and dynamically + * changing. + *

+ * The attach mode specifies the access permissions requested for the + * instrumentation buffer of the target virtual machine. The permitted + * access permissions are: + *

+ * + * @param lvmid an integer that uniquely identifies the + * target local Java virtual machine. + * @param mode a string indicating the attach mode. + * @return ByteBuffer a direct allocated byte buffer + * @throws IllegalArgumentException The lvmid or mode was invalid. + * @throws IOException An I/O error occurred while trying to acquire + * the instrumentation buffer. + * @throws OutOfMemoryError The instrumentation buffer could not be mapped + * into the virtual machine's address space. + * @see java.nio.ByteBuffer + */ + public ByteBuffer attach(int lvmid, String mode) + throws IllegalArgumentException, IOException + { + if (mode.compareTo("r") == 0) { + return attachImpl(null, lvmid, PERF_MODE_RO); + } + else if (mode.compareTo("rw") == 0) { + return attachImpl(null, lvmid, PERF_MODE_RW); + } + else { + throw new IllegalArgumentException("unknown mode"); + } + } + + /** + * Attach to the instrumentation buffer for the specified Java virtual + * machine owned by the given user. + *

+ * This method behaves just as the attach(int lvmid, String mode) + * method, except that it only searches for Java virtual machines + * owned by the specified user. + * + * @param user A String object containing the + * name of the user that owns the target Java + * virtual machine. + * @param lvmid an integer that uniquely identifies the + * target local Java virtual machine. + * @param mode a string indicating the attach mode. + * @return ByteBuffer a direct allocated byte buffer + * @throws IllegalArgumentException The lvmid or mode was invalid. + * @throws IOException An I/O error occurred while trying to acquire + * the instrumentation buffer. + * @throws OutOfMemoryError The instrumentation buffer could not be mapped + * into the virtual machine's address space. + * @see java.nio.ByteBuffer + */ + public ByteBuffer attach(String user, int lvmid, String mode) + throws IllegalArgumentException, IOException + { + if (mode.compareTo("r") == 0) { + return attachImpl(user, lvmid, PERF_MODE_RO); + } + else if (mode.compareTo("rw") == 0) { + return attachImpl(user, lvmid, PERF_MODE_RW); + } + else { + throw new IllegalArgumentException("unknown mode"); + } + } + + /** + * Call the implementation specific attach method. + *

+ * This method calls into the Java virtual machine to perform the platform + * specific attach method. Buffers returned from this method are + * internally managed as PhantomRefereces to provide for + * guaranteed, secure release of the native resources. + * + * @param user A String object containing the + * name of the user that owns the target Java + * virtual machine. + * @param lvmid an integer that uniquely identifies the + * target local Java virtual machine. + * @param mode a string indicating the attach mode. + * @return ByteBuffer a direct allocated byte buffer + * @throws IllegalArgumentException The lvmid or mode was invalid. + * @throws IOException An I/O error occurred while trying to acquire + * the instrumentation buffer. + * @throws OutOfMemoryError The instrumentation buffer could not be mapped + * into the virtual machine's address space. + */ + private ByteBuffer attachImpl(String user, int lvmid, int mode) + throws IllegalArgumentException, IOException + { + final ByteBuffer b = attach(user, lvmid, mode); + + if (lvmid == 0) { + // The native instrumentation buffer for this Java virtual + // machine is never unmapped. + return b; + } + else { + // This is an instrumentation buffer for another Java virtual + // machine with native resources that need to be managed. We + // create a duplicate of the native ByteBuffer and manage it + // with a Cleaner. When the duplicate becomes phantom reachable, + // the native resources will be released. + + final ByteBuffer dup = b.duplicate(); + + CleanerFactory.cleaner() + .register(dup, new CleanerAction(instance, b)); + return dup; + } + } + + private static class CleanerAction implements Runnable { + private final ByteBuffer bb; + private final Perf perf; + CleanerAction(Perf perf, ByteBuffer bb) { + this.perf = perf; + this.bb = bb; + } + public void run() { + try { + perf.detach(bb); + } catch (Throwable th) { + // avoid crashing the reference handler thread, + // but provide for some diagnosability + assert false : th.toString(); + } + } + } + + /** + * Native method to perform the implementation specific attach mechanism. + *

+ * The implementation of this method may return distinct or identical + * ByteBuffer objects for two distinct calls requesting + * attachment to the same Java virtual machine. + *

+ * For the Sun HotSpot JVM, two distinct calls to attach to the same + * target Java virtual machine will result in two distinct ByteBuffer + * objects returned by this method. This may change in a future release. + * + * @param user A String object containing the + * name of the user that owns the target Java + * virtual machine. + * @param lvmid an integer that uniquely identifies the + * target local Java virtual machine. + * @param mode a string indicating the attach mode. + * @return ByteBuffer a direct allocated byte buffer + * @throws IllegalArgumentException The lvmid or mode was invalid. + * @throws IOException An I/O error occurred while trying to acquire + * the instrumentation buffer. + * @throws OutOfMemoryError The instrumentation buffer could not be mapped + * into the virtual machine's address space. + */ + private native ByteBuffer attach(String user, int lvmid, int mode) + throws IllegalArgumentException, IOException; + + /** + * Native method to perform the implementation specific detach mechanism. + *

+ * If this method is passed a ByteBuffer object that is + * not created by the attach method, then the results of + * this method are undefined, with unpredictable and potentially damaging + * effects to the Java virtual machine. To prevent accidental or malicious + * use of this method, all native ByteBuffer created by the + * attach method are managed internally as PhantomReferences + * and resources are freed by the system. + *

+ * If this method is passed a ByteBuffer object created + * by the attach method with a lvmid for the Java virtual + * machine running this method (lvmid=0, for example), then the detach + * request is silently ignored. + * + * @param bb A direct allocated byte buffer created by the + * attach method. + * @see java.nio.ByteBuffer + * @see #attach + */ + private native void detach(ByteBuffer bb); + + /** + * Create a long scalar entry in the instrumentation buffer + * with the given variability characteristic, units, and initial value. + *

+ * Access to the instrument is provided through the returned + * ByteBuffer object. Typically, this object should be wrapped + * with LongBuffer view object. + * + * @param variability the variability characteristic for this entry. + * @param units the units for this entry. + * @param name the name of this entry. + * @param value the initial value for this entry. + * @return ByteBuffer a direct allocated ByteBuffer object that + * allows write access to a native memory location + * containing a long value. + * + * see sun.misc.perf.Variability + * see sun.misc.perf.Units + * @see java.nio.ByteBuffer + */ + public native ByteBuffer createLong(String name, int variability, + int units, long value); + + /** + * Create a String entry in the instrumentation buffer with + * the given variability characteristic, units, and initial value. + *

+ * The maximum length of the String stored in this string + * instrument is given in by maxLength parameter. Updates + * to this instrument with String values with lengths greater + * than maxLength will be truncated to maxLength. + * The truncated value will be terminated by a null character. + *

+ * The underlying implementation may further limit the length of the + * value, but will continue to preserve the null terminator. + *

+ * Access to the instrument is provided through the returned + * ByteBuffer object. + * + * @param variability the variability characteristic for this entry. + * @param units the units for this entry. + * @param name the name of this entry. + * @param value the initial value for this entry. + * @param maxLength the maximum string length for this string + * instrument. + * @return ByteBuffer a direct allocated ByteBuffer that allows + * write access to a native memory location + * containing a long value. + * + * see sun.misc.perf.Variability + * see sun.misc.perf.Units + * @see java.nio.ByteBuffer + */ + public ByteBuffer createString(String name, int variability, + int units, String value, int maxLength) + { + byte[] v = getBytes(value); + byte[] v1 = new byte[v.length+1]; + System.arraycopy(v, 0, v1, 0, v.length); + v1[v.length] = '\0'; + return createByteArray(name, variability, units, v1, Math.max(v1.length, maxLength)); + } + + /** + * Create a String entry in the instrumentation buffer with + * the given variability characteristic, units, and initial value. + *

+ * The maximum length of the String stored in this string + * instrument is implied by the length of the value parameter. + * Subsequent updates to the value of this instrument will be truncated + * to this implied maximum length. The truncated value will be terminated + * by a null character. + *

+ * The underlying implementation may further limit the length of the + * initial or subsequent value, but will continue to preserve the null + * terminator. + *

+ * Access to the instrument is provided through the returned + * ByteBuffer object. + * + * @param variability the variability characteristic for this entry. + * @param units the units for this entry. + * @param name the name of this entry. + * @param value the initial value for this entry. + * @return ByteBuffer a direct allocated ByteBuffer that allows + * write access to a native memory location + * containing a long value. + * + * see sun.misc.perf.Variability + * see sun.misc.perf.Units + * @see java.nio.ByteBuffer + */ + public ByteBuffer createString(String name, int variability, + int units, String value) + { + byte[] v = getBytes(value); + byte[] v1 = new byte[v.length+1]; + System.arraycopy(v, 0, v1, 0, v.length); + v1[v.length] = '\0'; + return createByteArray(name, variability, units, v1, v1.length); + } + + /** + * Create a byte vector entry in the instrumentation buffer + * with the given variability characteristic, units, and initial value. + *

+ * The maxLength parameter limits the size of the byte + * array instrument such that the initial or subsequent updates beyond + * this length are silently ignored. No special handling of truncated + * updates is provided. + *

+ * The underlying implementation may further limit the length of the + * length of the initial or subsequent value. + *

+ * Access to the instrument is provided through the returned + * ByteBuffer object. + * + * @param variability the variability characteristic for this entry. + * @param units the units for this entry. + * @param name the name of this entry. + * @param value the initial value for this entry. + * @param maxLength the maximum length of this byte array. + * @return ByteBuffer a direct allocated byte buffer that allows + * write access to a native memory location + * containing a long value. + * + * see sun.misc.perf.Variability + * see sun.misc.perf.Units + * @see java.nio.ByteBuffer + */ + public native ByteBuffer createByteArray(String name, int variability, + int units, byte[] value, + int maxLength); + + + /** + * convert string to an array of UTF-8 bytes + */ + private static byte[] getBytes(String s) + { + byte[] bytes = null; + + try { + bytes = s.getBytes("UTF-8"); + } + catch (UnsupportedEncodingException e) { + // ignore, UTF-8 encoding is always known + } + + return bytes; + } + + /** + * Return the value of the High Resolution Counter. + * + * The High Resolution Counter returns the number of ticks since + * since the start of the Java virtual machine. The resolution of + * the counter is machine dependent and can be determined from the + * value return by the {@link #highResFrequency} method. + * + * @return the number of ticks of machine dependent resolution since + * the start of the Java virtual machine. + * + * @see #highResFrequency + * @see java.lang.System#currentTimeMillis() + */ + public native long highResCounter(); + + /** + * Returns the frequency of the High Resolution Counter, in ticks per + * second. + * + * This value can be used to convert the value of the High Resolution + * Counter, as returned from a call to the {@link #highResCounter} method, + * into the number of seconds since the start of the Java virtual machine. + * + * @return the frequency of the High Resolution Counter. + * @see #highResCounter + */ + public native long highResFrequency(); + + private static native void registerNatives(); + + static { + registerNatives(); + instance = new Perf(); + } +} --- old/src/java.base/share/classes/sun/misc/PerfCounter.java 2016-01-08 18:52:07.749320462 +0000 +++ /dev/null 2015-10-21 15:25:26.827416476 +0100 @@ -1,191 +0,0 @@ -/* - * Copyright (c) 2009, 2013, 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.misc; - -import java.nio.ByteBuffer; -import java.nio.ByteOrder; -import java.nio.LongBuffer; -import java.security.AccessController; - -/** - * Performance counter support for internal JRE classes. - * This class defines a fixed list of counters for the platform - * to use as an interim solution until RFE# 6209222 is implemented. - * The perf counters will be created in the jvmstat perf buffer - * that the HotSpot VM creates. The default size is 32K and thus - * the number of counters is bounded. You can alter the size - * with {@code -XX:PerfDataMemorySize=} option. If there is - * insufficient memory in the jvmstat perf buffer, the C heap memory - * will be used and thus the application will continue to run if - * the counters added exceeds the buffer size but the counters - * will be missing. - * - * See HotSpot jvmstat implementation for certain circumstances - * that the jvmstat perf buffer is not supported. - * - */ -public class PerfCounter { - private static final Perf perf = - AccessController.doPrivileged(new Perf.GetPerfAction()); - - // Must match values defined in hotspot/src/share/vm/runtime/perfdata.hpp - private static final int V_Constant = 1; - private static final int V_Monotonic = 2; - private static final int V_Variable = 3; - private static final int U_None = 1; - - private final String name; - private final LongBuffer lb; - - private PerfCounter(String name, int type) { - this.name = name; - ByteBuffer bb = perf.createLong(name, type, U_None, 0L); - bb.order(ByteOrder.nativeOrder()); - this.lb = bb.asLongBuffer(); - } - - static PerfCounter newPerfCounter(String name) { - return new PerfCounter(name, V_Variable); - } - - static PerfCounter newConstantPerfCounter(String name) { - PerfCounter c = new PerfCounter(name, V_Constant); - return c; - } - - /** - * Returns the current value of the perf counter. - */ - public synchronized long get() { - return lb.get(0); - } - - /** - * Sets the value of the perf counter to the given newValue. - */ - public synchronized void set(long newValue) { - lb.put(0, newValue); - } - - /** - * Adds the given value to the perf counter. - */ - public synchronized void add(long value) { - long res = get() + value; - lb.put(0, res); - } - - /** - * Increments the perf counter with 1. - */ - public void increment() { - add(1); - } - - /** - * Adds the given interval to the perf counter. - */ - public void addTime(long interval) { - add(interval); - } - - /** - * Adds the elapsed time from the given start time (ns) to the perf counter. - */ - public void addElapsedTimeFrom(long startTime) { - add(System.nanoTime() - startTime); - } - - @Override - public String toString() { - return name + " = " + get(); - } - - static class CoreCounters { - static final PerfCounter pdt = newPerfCounter("sun.classloader.parentDelegationTime"); - static final PerfCounter lc = newPerfCounter("sun.classloader.findClasses"); - static final PerfCounter lct = newPerfCounter("sun.classloader.findClassTime"); - static final PerfCounter rcbt = newPerfCounter("sun.urlClassLoader.readClassBytesTime"); - static final PerfCounter zfc = newPerfCounter("sun.zip.zipFiles"); - static final PerfCounter zfot = newPerfCounter("sun.zip.zipFile.openTime"); - } - - static class WindowsClientCounters { - static final PerfCounter d3dAvailable = newConstantPerfCounter("sun.java2d.d3d.available"); - } - - /** - * Number of findClass calls - */ - public static PerfCounter getFindClasses() { - return CoreCounters.lc; - } - - /** - * Time (ns) spent in finding classes that includes - * lookup and read class bytes and defineClass - */ - public static PerfCounter getFindClassTime() { - return CoreCounters.lct; - } - - /** - * Time (ns) spent in finding classes - */ - public static PerfCounter getReadClassBytesTime() { - return CoreCounters.rcbt; - } - - /** - * Time (ns) spent in the parent delegation to - * the parent of the defining class loader - */ - public static PerfCounter getParentDelegationTime() { - return CoreCounters.pdt; - } - - /** - * Number of zip files opened. - */ - public static PerfCounter getZipFileCount() { - return CoreCounters.zfc; - } - - /** - * Time (ns) spent in opening the zip files that - * includes building the entries hash table - */ - public static PerfCounter getZipFileOpenTime() { - return CoreCounters.zfot; - } - - /** - * D3D graphic pipeline available - */ - public static PerfCounter getD3DAvailable() { - return WindowsClientCounters.d3dAvailable; - } -} --- /dev/null 2015-10-21 15:25:26.827416476 +0100 +++ new/src/java.base/share/classes/jdk/internal/perf/PerfCounter.java 2016-01-08 18:52:07.617323274 +0000 @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2009, 2013, 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 jdk.internal.perf; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.LongBuffer; +import java.security.AccessController; + +/** + * Performance counter support for internal JRE classes. + * This class defines a fixed list of counters for the platform + * to use as an interim solution until RFE# 6209222 is implemented. + * The perf counters will be created in the jvmstat perf buffer + * that the HotSpot VM creates. The default size is 32K and thus + * the number of counters is bounded. You can alter the size + * with {@code -XX:PerfDataMemorySize=} option. If there is + * insufficient memory in the jvmstat perf buffer, the C heap memory + * will be used and thus the application will continue to run if + * the counters added exceeds the buffer size but the counters + * will be missing. + * + * See HotSpot jvmstat implementation for certain circumstances + * that the jvmstat perf buffer is not supported. + * + */ +public class PerfCounter { + private static final Perf perf = + AccessController.doPrivileged(new Perf.GetPerfAction()); + + // Must match values defined in hotspot/src/share/vm/runtime/perfdata.hpp + private static final int V_Constant = 1; + private static final int V_Monotonic = 2; + private static final int V_Variable = 3; + private static final int U_None = 1; + + private final String name; + private final LongBuffer lb; + + private PerfCounter(String name, int type) { + this.name = name; + ByteBuffer bb = perf.createLong(name, type, U_None, 0L); + bb.order(ByteOrder.nativeOrder()); + this.lb = bb.asLongBuffer(); + } + + static PerfCounter newPerfCounter(String name) { + return new PerfCounter(name, V_Variable); + } + + static PerfCounter newConstantPerfCounter(String name) { + PerfCounter c = new PerfCounter(name, V_Constant); + return c; + } + + /** + * Returns the current value of the perf counter. + */ + public synchronized long get() { + return lb.get(0); + } + + /** + * Sets the value of the perf counter to the given newValue. + */ + public synchronized void set(long newValue) { + lb.put(0, newValue); + } + + /** + * Adds the given value to the perf counter. + */ + public synchronized void add(long value) { + long res = get() + value; + lb.put(0, res); + } + + /** + * Increments the perf counter with 1. + */ + public void increment() { + add(1); + } + + /** + * Adds the given interval to the perf counter. + */ + public void addTime(long interval) { + add(interval); + } + + /** + * Adds the elapsed time from the given start time (ns) to the perf counter. + */ + public void addElapsedTimeFrom(long startTime) { + add(System.nanoTime() - startTime); + } + + @Override + public String toString() { + return name + " = " + get(); + } + + static class CoreCounters { + static final PerfCounter pdt = newPerfCounter("sun.classloader.parentDelegationTime"); + static final PerfCounter lc = newPerfCounter("sun.classloader.findClasses"); + static final PerfCounter lct = newPerfCounter("sun.classloader.findClassTime"); + static final PerfCounter rcbt = newPerfCounter("sun.urlClassLoader.readClassBytesTime"); + static final PerfCounter zfc = newPerfCounter("sun.zip.zipFiles"); + static final PerfCounter zfot = newPerfCounter("sun.zip.zipFile.openTime"); + } + + static class WindowsClientCounters { + static final PerfCounter d3dAvailable = newConstantPerfCounter("sun.java2d.d3d.available"); + } + + /** + * Number of findClass calls + */ + public static PerfCounter getFindClasses() { + return CoreCounters.lc; + } + + /** + * Time (ns) spent in finding classes that includes + * lookup and read class bytes and defineClass + */ + public static PerfCounter getFindClassTime() { + return CoreCounters.lct; + } + + /** + * Time (ns) spent in finding classes + */ + public static PerfCounter getReadClassBytesTime() { + return CoreCounters.rcbt; + } + + /** + * Time (ns) spent in the parent delegation to + * the parent of the defining class loader + */ + public static PerfCounter getParentDelegationTime() { + return CoreCounters.pdt; + } + + /** + * Number of zip files opened. + */ + public static PerfCounter getZipFileCount() { + return CoreCounters.zfc; + } + + /** + * Time (ns) spent in opening the zip files that + * includes building the entries hash table + */ + public static PerfCounter getZipFileOpenTime() { + return CoreCounters.zfot; + } + + /** + * D3D graphic pipeline available + */ + public static PerfCounter getD3DAvailable() { + return WindowsClientCounters.d3dAvailable; + } +} --- old/src/java.base/share/classes/sun/misc/PerformanceLogger.java 2016-01-08 18:52:08.145312026 +0000 +++ /dev/null 2015-10-21 15:25:26.827416476 +0100 @@ -1,317 +0,0 @@ -/* - * Copyright (c) 2002, 2013, 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.misc; - -import java.util.Vector; -import java.io.FileWriter; -import java.io.File; -import java.io.OutputStreamWriter; -import java.io.Writer; - -/** - * This class is intended to be a central place for the jdk to - * log timing events of interest. There is pre-defined event - * of startTime, as well as a general - * mechanism of setting arbitrary times in an array. - * All unreserved times in the array can be used by callers - * in application-defined situations. The caller is responsible - * for setting and getting all times and for doing whatever - * analysis is interesting; this class is merely a central container - * for those timing values. - * Note that, due to the variables in this class being static, - * use of particular time values by multiple applets will cause - * confusing results. For example, if plugin runs two applets - * simultaneously, the initTime for those applets will collide - * and the results may be undefined. - *

- * To automatically track startup performance in an app or applet, - * use the command-line parameter sun.perflog as follows:
- * 

{@code
- *     -Dsun.perflog[=file:]
- * }
- *
- * where simply using the parameter with no value will enable output - * to the console and a value of "{@code file:}" will cause - * that given filename to be created and used for all output. - *

- * By default, times are measured using System.currentTimeMillis(). To use - * System.nanoTime() instead, add the command-line parameter:
- -Dsun.perflog.nano=true - *
- *

- * Warning: Use at your own risk! - * This class is intended for internal testing - * purposes only and may be removed at any time. More - * permanent monitoring and profiling APIs are expected to be - * developed for future releases and this class will cease to - * exist once those APIs are in place. - * @author Chet Haase - */ -public class PerformanceLogger { - - // Timing values of global interest - private static final int START_INDEX = 0; // VM start - private static final int LAST_RESERVED = START_INDEX; - - private static boolean perfLoggingOn = false; - private static boolean useNanoTime = false; - private static Vector times; - private static String logFileName = null; - private static Writer logWriter = null; - private static long baseTime; - - static { - String perfLoggingProp = - java.security.AccessController.doPrivileged( - new sun.security.action.GetPropertyAction("sun.perflog")); - if (perfLoggingProp != null) { - perfLoggingOn = true; - - // Check if we should use nanoTime - String perfNanoProp = - java.security.AccessController.doPrivileged( - new sun.security.action.GetPropertyAction("sun.perflog.nano")); - if (perfNanoProp != null) { - useNanoTime = true; - } - - // Now, figure out what the user wants to do with the data - if (perfLoggingProp.regionMatches(true, 0, "file:", 0, 5)) { - logFileName = perfLoggingProp.substring(5); - } - if (logFileName != null) { - if (logWriter == null) { - java.security.AccessController.doPrivileged( - new java.security.PrivilegedAction() { - public Void run() { - try { - File logFile = new File(logFileName); - logFile.createNewFile(); - logWriter = new FileWriter(logFile); - } catch (Exception e) { - System.out.println(e + ": Creating logfile " + - logFileName + - ". Log to console"); - } - return null; - } - }); - } - } - if (logWriter == null) { - logWriter = new OutputStreamWriter(System.out); - } - } - times = new Vector(10); - // Reserve predefined slots - for (int i = 0; i <= LAST_RESERVED; ++i) { - times.add(new TimeData("Time " + i + " not set", 0)); - } - } - - /** - * Returns status of whether logging is enabled or not. This is - * provided as a convenience method so that users do not have to - * perform the same GetPropertyAction check as above to determine whether - * to enable performance logging. - */ - public static boolean loggingEnabled() { - return perfLoggingOn; - } - - - /** - * Internal class used to store time/message data together. - */ - static class TimeData { - String message; - long time; - - TimeData(String message, long time) { - this.message = message; - this.time = time; - } - - String getMessage() { - return message; - } - - long getTime() { - return time; - } - } - - /** - * Return the current time, in millis or nanos as appropriate - */ - private static long getCurrentTime() { - if (useNanoTime) { - return System.nanoTime(); - } else { - return System.currentTimeMillis(); - } - } - - /** - * Sets the start time. Ideally, this is the earliest time available - * during the startup of a Java applet or application. This time is - * later used to analyze the difference between the initial startup - * time and other events in the system (such as an applet's init time). - */ - public static void setStartTime(String message) { - if (loggingEnabled()) { - long nowTime = getCurrentTime(); - setStartTime(message, nowTime); - } - } - - /** - * Sets the base time, output can then - * be displayed as offsets from the base time;. - */ - public static void setBaseTime(long time) { - if (loggingEnabled()) { - baseTime = time; - } - } - - /** - * Sets the start time. - * This version of the method is - * given the time to log, instead of expecting this method to - * get the time itself. This is done in case the time was - * recorded much earlier than this method was called. - */ - public static void setStartTime(String message, long time) { - if (loggingEnabled()) { - times.set(START_INDEX, new TimeData(message, time)); - } - } - - /** - * Gets the start time, which should be the time when - * the java process started, prior to the VM actually being - * loaded. - */ - public static long getStartTime() { - if (loggingEnabled()) { - return times.get(START_INDEX).getTime(); - } else { - return 0; - } - } - - /** - * Sets the value of a given time and returns the index of the - * slot that that time was stored in. - */ - public static int setTime(String message) { - if (loggingEnabled()) { - long nowTime = getCurrentTime(); - return setTime(message, nowTime); - } else { - return 0; - } - } - - /** - * Sets the value of a given time and returns the index of the - * slot that that time was stored in. - * This version of the method is - * given the time to log, instead of expecting this method to - * get the time itself. This is done in case the time was - * recorded much earlier than this method was called. - */ - public static int setTime(String message, long time) { - if (loggingEnabled()) { - // times is already synchronized, but we need to ensure that - // the size used in times.set() is the same used when returning - // the index of that operation. - synchronized (times) { - times.add(new TimeData(message, time)); - return (times.size() - 1); - } - } else { - return 0; - } - } - - /** - * Returns time at given index. - */ - public static long getTimeAtIndex(int index) { - if (loggingEnabled()) { - return times.get(index).getTime(); - } else { - return 0; - } - } - - /** - * Returns message at given index. - */ - public static String getMessageAtIndex(int index) { - if (loggingEnabled()) { - return times.get(index).getMessage(); - } else { - return null; - } - } - - /** - * Outputs all data to parameter-specified Writer object - */ - public static void outputLog(Writer writer) { - if (loggingEnabled()) { - try { - synchronized(times) { - for (int i = 0; i < times.size(); ++i) { - TimeData td = times.get(i); - if (td != null) { - writer.write(i + " " + td.getMessage() + ": " + - (td.getTime() - baseTime) + "\n"); - - } - } - } - writer.flush(); - } catch (Exception e) { - System.out.println(e + ": Writing performance log to " + - writer); - } - } - } - - /** - * Outputs all data to whatever location the user specified - * via sun.perflog command-line parameter. - */ - public static void outputLog() { - outputLog(logWriter); - } -} --- /dev/null 2015-10-21 15:25:26.827416476 +0100 +++ new/src/java.base/share/classes/jdk/internal/perf/PerformanceLogger.java 2016-01-08 18:52:08.005315009 +0000 @@ -0,0 +1,317 @@ +/* + * Copyright (c) 2002, 2013, 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 jdk.internal.perf; + +import java.util.Vector; +import java.io.FileWriter; +import java.io.File; +import java.io.OutputStreamWriter; +import java.io.Writer; + +/** + * This class is intended to be a central place for the jdk to + * log timing events of interest. There is pre-defined event + * of startTime, as well as a general + * mechanism of setting arbitrary times in an array. + * All unreserved times in the array can be used by callers + * in application-defined situations. The caller is responsible + * for setting and getting all times and for doing whatever + * analysis is interesting; this class is merely a central container + * for those timing values. + * Note that, due to the variables in this class being static, + * use of particular time values by multiple applets will cause + * confusing results. For example, if plugin runs two applets + * simultaneously, the initTime for those applets will collide + * and the results may be undefined. + *

+ * To automatically track startup performance in an app or applet, + * use the command-line parameter sun.perflog as follows:
+ * 

{@code
+ *     -Dsun.perflog[=file:]
+ * }
+ *
+ * where simply using the parameter with no value will enable output + * to the console and a value of "{@code file:}" will cause + * that given filename to be created and used for all output. + *

+ * By default, times are measured using System.currentTimeMillis(). To use + * System.nanoTime() instead, add the command-line parameter:
+ -Dsun.perflog.nano=true + *
+ *

+ * Warning: Use at your own risk! + * This class is intended for internal testing + * purposes only and may be removed at any time. More + * permanent monitoring and profiling APIs are expected to be + * developed for future releases and this class will cease to + * exist once those APIs are in place. + * @author Chet Haase + */ +public class PerformanceLogger { + + // Timing values of global interest + private static final int START_INDEX = 0; // VM start + private static final int LAST_RESERVED = START_INDEX; + + private static boolean perfLoggingOn = false; + private static boolean useNanoTime = false; + private static Vector times; + private static String logFileName = null; + private static Writer logWriter = null; + private static long baseTime; + + static { + String perfLoggingProp = + java.security.AccessController.doPrivileged( + new sun.security.action.GetPropertyAction("sun.perflog")); + if (perfLoggingProp != null) { + perfLoggingOn = true; + + // Check if we should use nanoTime + String perfNanoProp = + java.security.AccessController.doPrivileged( + new sun.security.action.GetPropertyAction("sun.perflog.nano")); + if (perfNanoProp != null) { + useNanoTime = true; + } + + // Now, figure out what the user wants to do with the data + if (perfLoggingProp.regionMatches(true, 0, "file:", 0, 5)) { + logFileName = perfLoggingProp.substring(5); + } + if (logFileName != null) { + if (logWriter == null) { + java.security.AccessController.doPrivileged( + new java.security.PrivilegedAction() { + public Void run() { + try { + File logFile = new File(logFileName); + logFile.createNewFile(); + logWriter = new FileWriter(logFile); + } catch (Exception e) { + System.out.println(e + ": Creating logfile " + + logFileName + + ". Log to console"); + } + return null; + } + }); + } + } + if (logWriter == null) { + logWriter = new OutputStreamWriter(System.out); + } + } + times = new Vector(10); + // Reserve predefined slots + for (int i = 0; i <= LAST_RESERVED; ++i) { + times.add(new TimeData("Time " + i + " not set", 0)); + } + } + + /** + * Returns status of whether logging is enabled or not. This is + * provided as a convenience method so that users do not have to + * perform the same GetPropertyAction check as above to determine whether + * to enable performance logging. + */ + public static boolean loggingEnabled() { + return perfLoggingOn; + } + + + /** + * Internal class used to store time/message data together. + */ + static class TimeData { + String message; + long time; + + TimeData(String message, long time) { + this.message = message; + this.time = time; + } + + String getMessage() { + return message; + } + + long getTime() { + return time; + } + } + + /** + * Return the current time, in millis or nanos as appropriate + */ + private static long getCurrentTime() { + if (useNanoTime) { + return System.nanoTime(); + } else { + return System.currentTimeMillis(); + } + } + + /** + * Sets the start time. Ideally, this is the earliest time available + * during the startup of a Java applet or application. This time is + * later used to analyze the difference between the initial startup + * time and other events in the system (such as an applet's init time). + */ + public static void setStartTime(String message) { + if (loggingEnabled()) { + long nowTime = getCurrentTime(); + setStartTime(message, nowTime); + } + } + + /** + * Sets the base time, output can then + * be displayed as offsets from the base time;. + */ + public static void setBaseTime(long time) { + if (loggingEnabled()) { + baseTime = time; + } + } + + /** + * Sets the start time. + * This version of the method is + * given the time to log, instead of expecting this method to + * get the time itself. This is done in case the time was + * recorded much earlier than this method was called. + */ + public static void setStartTime(String message, long time) { + if (loggingEnabled()) { + times.set(START_INDEX, new TimeData(message, time)); + } + } + + /** + * Gets the start time, which should be the time when + * the java process started, prior to the VM actually being + * loaded. + */ + public static long getStartTime() { + if (loggingEnabled()) { + return times.get(START_INDEX).getTime(); + } else { + return 0; + } + } + + /** + * Sets the value of a given time and returns the index of the + * slot that that time was stored in. + */ + public static int setTime(String message) { + if (loggingEnabled()) { + long nowTime = getCurrentTime(); + return setTime(message, nowTime); + } else { + return 0; + } + } + + /** + * Sets the value of a given time and returns the index of the + * slot that that time was stored in. + * This version of the method is + * given the time to log, instead of expecting this method to + * get the time itself. This is done in case the time was + * recorded much earlier than this method was called. + */ + public static int setTime(String message, long time) { + if (loggingEnabled()) { + // times is already synchronized, but we need to ensure that + // the size used in times.set() is the same used when returning + // the index of that operation. + synchronized (times) { + times.add(new TimeData(message, time)); + return (times.size() - 1); + } + } else { + return 0; + } + } + + /** + * Returns time at given index. + */ + public static long getTimeAtIndex(int index) { + if (loggingEnabled()) { + return times.get(index).getTime(); + } else { + return 0; + } + } + + /** + * Returns message at given index. + */ + public static String getMessageAtIndex(int index) { + if (loggingEnabled()) { + return times.get(index).getMessage(); + } else { + return null; + } + } + + /** + * Outputs all data to parameter-specified Writer object + */ + public static void outputLog(Writer writer) { + if (loggingEnabled()) { + try { + synchronized(times) { + for (int i = 0; i < times.size(); ++i) { + TimeData td = times.get(i); + if (td != null) { + writer.write(i + " " + td.getMessage() + ": " + + (td.getTime() - baseTime) + "\n"); + + } + } + } + writer.flush(); + } catch (Exception e) { + System.out.println(e + ": Writing performance log to " + + writer); + } + } + } + + /** + * Outputs all data to whatever location the user specified + * via sun.perflog command-line parameter. + */ + public static void outputLog() { + outputLog(logWriter); + } +}