| /* |
| * Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package nsk.monitoring.share; |
| |
| import java.lang.management.*; |
| import javax.management.*; |
| import javax.management.openmbean.*; |
| import java.util.*; |
| |
| import nsk.share.*; |
| |
| /** |
| * <code>MemoryMonitor</code> class is a wrapper of <code>MemoryMXBean</code> and |
| * <code>MemoryPoolMXBean</code> interfaces. Depending on command line arguments, |
| * an instance of this class redirects invocations to the |
| * <code>MemoryMXBean</code> (or <code>MemoryPoolMXBean</code>) interface. If |
| * <code>-testMode="directly"</code> option is set, this instance directly |
| * invokes corresponding method of the <code>MemoryMXBean</code> (or |
| * <code>MemoryPoolMXBean</code>) interface. If <code>-testMode="server"</code> |
| * option is set it will make invocations via MBeanServer. |
| * |
| * @see ArgumentHandler |
| */ |
| public class MemoryMonitor extends Monitor implements NotificationListener, |
| NotificationFilter { |
| |
| // Constants to define type of memory that will be allocated in |
| // MemoryMonitor. For heap memory objects will be allocated; for nonheap |
| // type classes will be loaded; for mixed type -- both (objects will be |
| // allocated and classes will be loaded). |
| public final static String HEAP_TYPE = "heap"; |
| public final static String NONHEAP_TYPE = "nonheap"; |
| public final static String MIXED_TYPE = "mixed"; |
| // Names of the attributes of MemoryMXBean |
| private final static String POOL_TYPE = "Type"; |
| private final static String POOL_RESET_PEAK = "resetPeakUsage"; |
| private final static String POOL_PEAK = "PeakUsage"; |
| private final static String POOL_VALID = "Valid"; |
| private final static String POOL_U = "Usage"; |
| private final static String UT = "UsageThreshold"; |
| private final static String UT_COUNT = "UsageThresholdCount"; |
| private final static String UT_SUPPORT = "UsageThresholdSupported"; |
| private final static String UT_EXCEEDED = "UsageThresholdExceeded"; |
| private final static String POOL_CU = "CollectionUsage"; |
| private final static String CT = "CollectionUsageThreshold"; |
| private final static String CT_COUNT = "CollectionUsageThresholdCount"; |
| private final static String CT_SUPPORT = "CollectionUsageThresholdSupported"; |
| private final static String CT_EXCEEDED = "CollectionUsageThresholdExceeded"; |
| // Varibales to store options that are passed to the test |
| private static String memory; |
| private static int mode; |
| private static boolean isNotification; |
| private static boolean isUsageThreshold; |
| private static volatile boolean passed = true; |
| private Polling polling = new Polling(); |
| |
| static { |
| Monitor.logPrefix = "MemoryMonitor > "; |
| } |
| |
| /** |
| * Creates a new <code>MemoryMonitor</code> object. |
| * |
| * @param log <code>Log</code> object to print info to. |
| * @param handler <code>ArgumentHandler</code> object that saves |
| * all info about test's arguments. |
| * |
| */ |
| public MemoryMonitor(Log log, ArgumentHandler handler) { |
| super(log, handler); |
| |
| memory = handler.getTestedMemory(); |
| mode = getTestMode(); |
| isNotification = (handler.MON_NOTIF.equals(handler.getMonitoring())); |
| isUsageThreshold = (handler.TH_USAGE.equals(handler.getThreshold())); |
| |
| String s = "\t(This setting is used in lowmem* tests only)"; |
| |
| display("Memory:\t" + handler.getTestedMemory() + s); |
| display("Monitoring:\t" + handler.getMonitoring() + s); |
| display("Threshold:\t" + handler.getThreshold() + s); |
| display("Timeout:\t" + handler.getTimeout() + s); |
| } |
| |
| /** |
| * Returns <code>true</code> if no failures were revealed during the test, |
| * <code>false</code> otherwise. |
| * |
| * @return <code>true</code> if no failures were revealed during the test, |
| * <code>false</code> otherwise. |
| * |
| */ |
| public boolean getPassedStatus() { |
| return passed; |
| } |
| |
| /** |
| * Enables memory monitoring. |
| * <p> |
| * If notification type of monitoring is chosen, the method adds {@link |
| * javax.management.NotificationListener |
| * <code>javax.management.NotificationListener</code>} to enables low |
| * memory detection support. If monitoring type is polling, a new thread |
| * that manages the low memory detection is started. |
| * |
| * @throws InstanceNotFoundException The MemoryMXBean is not registered on |
| * the server. |
| */ |
| public void enableMonitoring() throws InstanceNotFoundException { |
| if (isNotification) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryMXBean mbean = ManagementFactory.getMemoryMXBean(); |
| NotificationEmitter emitter = (NotificationEmitter) mbean; |
| emitter.addNotificationListener(this, this, null); |
| break; |
| |
| case SERVER_MODE: |
| case PROXY_MODE: |
| getMBeanServer().addNotificationListener(mbeanObjectName, |
| this, this, null); |
| break; |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } else { |
| |
| // Polling |
| // Start a thread that will manage all test modes |
| polling.start(); |
| |
| } |
| } // enableMonitoring() |
| |
| /** |
| * Disables memory monitoring. |
| * <p> |
| * If monitoring type is polling, the thread that manages the low memory |
| * detection is stopped. |
| */ |
| public void disableMonitoring() { |
| if (!isNotification) { |
| |
| // Stop polling thread |
| polling.goOn = false; |
| } |
| } // disableMonitoring() |
| |
| /** |
| * Updates thresholds. Thresholds values for all pools will be greater |
| * than <code>used</code> value. |
| * <p> |
| * If <code>usage</code> thresholds are chosen, the method updates just |
| * pools that support usage thresholds. If <code>collection</code> |
| * thresholds are chosen, the method updates memory pools that support |
| * collection usage thresholds. |
| * |
| * This method is synchronized because it may be invoked from |
| * <code>handleNotification</code> which is potentially done from |
| * multiple threads. |
| */ |
| public synchronized void updateThresholds() { |
| if (isUsageThreshold) { |
| updateUsageThresholds(); |
| } else { |
| updateCollectionThresholds(); |
| } |
| } |
| |
| /** |
| * Reset thresholds. Thresholds values for all pools will be 1. |
| * If <code>usage</code> thresholds are chosen, the method updates just |
| * pools that support usage thresholds. If <code>collection</code> |
| * thresholds are chosen, the method updates memory pools that support |
| * collection usage thresholds. |
| * |
| * This method is synchronized because it may be invoked from |
| * multiple threads. |
| */ |
| public synchronized void resetThresholds(MemoryType type) { |
| List pools = getMemoryPoolMBeans(); |
| for (int i = 0; i < pools.size(); i++) { |
| Object pool = pools.get(i); |
| if (isUsageThresholdSupported(pool)) { |
| if (getType(pool).equals(type)) { |
| setUsageThreshold(pool, 1); |
| } |
| } |
| } |
| } |
| |
| /** |
| * The method is invoked before sending the notification to the listener. |
| * |
| * @param notification The notification to be sent. |
| * @return <i>true</i> if the notification has to be sent to the listener; |
| * <i>false</i> otherwise. |
| * |
| * @see javax.management.NotificationFilter |
| */ |
| public boolean isNotificationEnabled(Notification notification) { |
| String type = notification.getType(); |
| String usage = MemoryNotificationInfo.MEMORY_THRESHOLD_EXCEEDED; |
| String collection = MemoryNotificationInfo.MEMORY_COLLECTION_THRESHOLD_EXCEEDED; |
| |
| if (isUsageThreshold) { |
| return type.equals(usage); |
| } else { |
| return type.equals(collection); |
| } |
| } // isNotificationEnabled() |
| |
| /** |
| * The method is invoked when a JMX notification occurs. |
| * |
| * @param notification The notification to be sent. |
| * @param handback An opaque object which helps the listener to associate |
| * information regarding the MBean emitter. |
| * @see javax.management.NotificationListener |
| */ |
| public void handleNotification(Notification notification, Object handback) { |
| CompositeData data = (CompositeData) notification.getUserData(); |
| MemoryNotificationInfo mn = MemoryNotificationInfo.from(data); |
| |
| display(mn.getCount() + " notification \"" + notification.getMessage() |
| + "\" is caught on " + (new Date(notification.getTimeStamp())) |
| + " by " + mn.getPoolName() + " (" + mn.getUsage() + ")"); |
| updateThresholds(); |
| } // handleNotification() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#resetPeakUsage |
| * <code>MemoryPoolMXBean.resetPeakUsage()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| */ |
| public void resetPeakUsage(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| directPool.resetPeakUsage(); |
| break; |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| |
| try { |
| getMBeanServer().invoke(serverPool, POOL_RESET_PEAK, |
| null, null); |
| } catch (Exception e) { |
| e.printStackTrace(logger.getOutStream()); |
| throw new Failure(e); |
| } |
| break; |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| proxyPool.resetPeakUsage(); |
| break; |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // resetPeakUsage() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#getPeakUsage |
| * <code>MemoryPoolMXBean.getPeakUsage()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return a <code>MemoryUsage</code> object representing the peak memory |
| * usage; <code>null</code> otherwise. |
| */ |
| public MemoryUsage getPeakUsage(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.getPeakUsage(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return getMemoryUsageAttribute(serverPool, POOL_PEAK); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.getPeakUsage(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // getPeakUsage() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#getUsage |
| * <code>MemoryPoolMXBean.getUsage()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return a <code>MemoryUsage</code> object; or <code>null</code> if this |
| * pool not valid. |
| */ |
| public MemoryUsage getUsage(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.getUsage(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return getUsageOnServer(serverPool); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.getUsage(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // getUsage() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#getCollectionUsage |
| * <code>MemoryPoolMXBean.getCollectionUsage()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return a <code>MemoryUsage</code> object; or <code>null</code> if this |
| * method is not supported. |
| */ |
| public MemoryUsage getCollectionUsage(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.getCollectionUsage(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return getCollectionUsageOnServer(serverPool); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.getCollectionUsage(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // getCollectionUsage() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#isValid |
| * <code>MemoryPoolMXBean.isValid()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return a <code>true</code> if the memory pool is valid in the running |
| * JVM; <code>null</code> otherwise. |
| */ |
| public boolean isValid(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.isValid(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return getBooleanAttribute(serverPool, POOL_VALID); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.isValid(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // isValid() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#isUsageThresholdSupported |
| * <code>MemoryPoolMXBean.isUsageThresholdSupported()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return a <code>true</code> if the memory pool supports usage threshold; |
| * <code>null</code> otherwise. |
| */ |
| public boolean isUsageThresholdSupported(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.isUsageThresholdSupported(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return isUsageThresholdSupportedOnServer(serverPool); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.isUsageThresholdSupported(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // isUsageThresholdSupported() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#isCollectionUsageThresholdSupported |
| * <code>MemoryPoolMXBean.isCollectionUsageThresholdSupported()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return a <code>true</code> if the memory pool supports collection |
| * usage threshold; <code>null</code> otherwise. |
| */ |
| public boolean isCollectionThresholdSupported(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.isCollectionUsageThresholdSupported(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return isCollectionThresholdSupportedOnServer(serverPool); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.isCollectionUsageThresholdSupported(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // isCollectionThresholdSupported() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#isUsageThresholdExceeded |
| * <code>MemoryPoolMXBean.isUsageThresholdExceeded()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return a <code>true</code> if the memory usage of this pool reaches or |
| * exceeds the threshold value; <code>null</code> otherwise. |
| */ |
| public boolean isUsageThresholdExceeded(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.isUsageThresholdExceeded(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return isUsageThresholdExceededOnServer(serverPool); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.isUsageThresholdExceeded(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // isUsageThresholdExceeded() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#isCollectionUsageThresholdExceeded |
| * <code>MemoryPoolMXBean.isCollectionUsageThresholdExceeded()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return a <code>true</code> if the memory usage of this pool reaches or |
| * exceeds the collection usage threshold value in the most recent |
| * collection; <code>null</code> otherwise. |
| */ |
| public boolean isCollectionThresholdExceeded(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.isCollectionUsageThresholdExceeded(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return isCollectionThresholdExceededOnServer(serverPool); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.isCollectionUsageThresholdExceeded(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // isCollectionThresholdExceeded() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#getUsageThreshold |
| * <code>MemoryPoolMXBean.getUsageThreshold()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return the usage threshold value of this memory pool in bytes. |
| */ |
| public long getUsageThreshold(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.getUsageThreshold(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return getUsageThresholdOnServer(serverPool); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.getUsageThreshold(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // getUsageThreshold() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#getCollectionUsageThreshold |
| * <code>MemoryPoolMXBean.getCollectionUsageThreshold()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return the collection usage threshold value of this memory pool in |
| * bytes. |
| */ |
| public long getCollectionThreshold(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.getCollectionUsageThreshold(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return getCollectionThresholdOnServer(serverPool); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.getCollectionUsageThreshold(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // getCollectionThreshold() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#getUsageThresholdCount |
| * <code>MemoryPoolMXBean.getUsageThresholdCount()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return number of times that the memory usage has crossed its usage |
| * threshold value. |
| */ |
| public long getUsageThresholdCount(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.getUsageThresholdCount(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return getUsageThresholdCountOnServer(serverPool); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.getUsageThresholdCount(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // getUsageThresholdCount() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#getCollectionUsageThresholdCount |
| * <code>MemoryPoolMXBean.getCollectionUsageThresholdCount()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return number of times that the memory usage has crossed its collection |
| * usage threshold value. |
| */ |
| public long getCollectionThresholdCount(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.getCollectionUsageThresholdCount(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return getCollectionThresholdCountOnServer(serverPool); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.getCollectionUsageThresholdCount(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // getCollectionThresholdCount() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#setUsageThreshold |
| * <code>MemoryPoolMXBean.setUsageThreshold()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @param threshold the new threshold value. |
| */ |
| public void setUsageThreshold(Object poolObject, long threshold) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| directPool.setUsageThreshold(threshold); |
| break; |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| setUsageThresholdOnServer(serverPool, threshold); |
| break; |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| proxyPool.setUsageThreshold(threshold); |
| break; |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // setUsageThreshold() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#setCollectionUsageThreshold |
| * <code>MemoryPoolMXBean.setCollectionUsageThreshold()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @param threshold the new collection usage threshold value. |
| */ |
| public void setCollectionThreshold(Object poolObject, long threshold) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| directPool.setCollectionUsageThreshold(threshold); |
| break; |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| setCollectionThresholdOnServer(serverPool, threshold); |
| break; |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| proxyPool.setCollectionUsageThreshold(threshold); |
| break; |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // setCollectionThreshold() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#getName |
| * <code>MemoryPoolMXBean.getName()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return the name of the memory pool. |
| */ |
| public String getName(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.getName(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return serverPool.toString(); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.getName(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // getName() |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.MemoryPoolMXBean#getType |
| * <code>MemoryPoolMXBean.getType()</code>}. |
| * |
| * @param poolObject reference to the pool. The pool may be specified |
| * either by <code>ObjectName</code>, or |
| * <code>MemoryPoolMXBean</code>. |
| * @return the name of the memory pool. |
| */ |
| public MemoryType getType(Object poolObject) { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| MemoryPoolMXBean directPool = (MemoryPoolMXBean) poolObject; |
| return directPool.getType(); |
| |
| case SERVER_MODE: |
| ObjectName serverPool = (ObjectName) poolObject; |
| return getType(serverPool); |
| |
| case PROXY_MODE: |
| MemoryPoolMXBean proxyPool = (MemoryPoolMXBean) poolObject; |
| return proxyPool.getType(); |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } |
| |
| /** |
| * Redirects the invocation to {@link |
| * java.lang.management.ManagementFactory#getMemoryPoolMXBeans |
| * <code>ManagementFactory.getMemoryPoolMXBeans()</code>}. |
| * |
| * @return a list of <code>MemoryPoolMXBean</code> objects. |
| */ |
| public List<? extends Object> getMemoryPoolMBeans() { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| return ManagementFactory.getMemoryPoolMXBeans(); |
| |
| case SERVER_MODE: { |
| ObjectName[] names = getMemoryPoolMXBeansOnServer(); |
| ArrayList<ObjectName> list = new ArrayList<ObjectName>(); |
| |
| for (int i = 0; i < names.length; i++) { |
| list.add(names[i]); |
| } |
| return list; |
| } |
| |
| case PROXY_MODE: { |
| ObjectName[] names = getMemoryPoolMXBeansOnServer(); |
| ArrayList<MemoryPoolMXBean> list = new ArrayList<MemoryPoolMXBean>(); |
| |
| for (int i = 0; i < names.length; i++) { |
| list.add(getProxy(names[i])); |
| } |
| return list; |
| } |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // getMemoryPoolMXBeans() |
| |
| // ********************************************************************** |
| // |
| // Private methods |
| // |
| // ********************************************************************** |
| private MemoryPoolMXBean getProxy(ObjectName objectName) { |
| try { |
| MemoryPoolMXBean proxy = (MemoryPoolMXBean) ManagementFactory.newPlatformMXBeanProxy( |
| getMBeanServer(), |
| objectName.toString(), |
| MemoryPoolMXBean.class); |
| return proxy; |
| } catch (Exception e) { |
| throw new Failure(e); |
| } |
| } |
| |
| // Sets new usage threasholds in all pools that match the tested memory and |
| // support low memory detetion. A new value will be greater than used value |
| // for the pool. |
| private void updateUsageThresholds() { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| // we can use the same code here for direct and proxy modes |
| case PROXY_MODE: |
| List poolsMBean = ManagementFactory.getMemoryPoolMXBeans(); |
| |
| for (int i = 0; i < poolsMBean.size(); i++) { |
| MemoryPoolMXBean pool = (MemoryPoolMXBean) poolsMBean.get(i); |
| if (!pool.isUsageThresholdSupported()) { |
| continue; |
| } |
| |
| MemoryType mt = pool.getType(); |
| if ((!mt.equals(MemoryType.HEAP) |
| || !memory.equals(HEAP_TYPE)) |
| && (!mt.equals(MemoryType.NON_HEAP) |
| || !memory.equals(NONHEAP_TYPE)) |
| && !memory.equals(MIXED_TYPE)) { |
| continue; |
| } |
| |
| // Yes! We got the pool that |
| // 1. supports usage threshold |
| // 2. has type that match tested type |
| // So, update the pool with new threshold |
| long oldT = pool.getUsageThreshold(); |
| MemoryUsage usage = pool.getUsage(); |
| long newT = newThreshold(usage, oldT, pool.getName()); |
| |
| try { |
| pool.setUsageThreshold(newT); |
| } catch (IllegalArgumentException e) { |
| /* |
| * Max value might have changed since the call to newThreshold() |
| * above. If it has fallen below the value of newT, which is certainly |
| * possible, an exception like this one will be thrown from |
| * sun.management.MemoryPoolImpl.setUsageThreshold(): |
| * |
| * java.lang.IllegalArgumentException: Invalid threshold: 48332800 > max (47251456). |
| * |
| * We don't know the max value at the time of the failed call, and it |
| * might have changed since the call once more. So there is no point |
| * trying to detect whether the IllegalArgumentException had been |
| * justified, we cannot know it at this point. |
| * |
| * The best we can do is log the fact and continue. |
| */ |
| displayInfo("setUsageThreshold() failed with " + e + ", ignoring... ", |
| pool, |
| "current usage after the call to setUsageThreshold(): ", getUsage(pool), |
| "threshold: ", newT); |
| continue; |
| } |
| displayInfo("Usage threshold is set", pool, "usage: ", pool.getUsage(), "threshold: ", pool.getUsageThreshold()); |
| if (pool.getUsageThreshold() != newT) { |
| complain("Cannot reset usage threshold from " + oldT |
| + " to " + newT + " in pool " + pool.getName() + " " |
| + pool.getUsageThreshold()); |
| passed = false; |
| } |
| } // for i |
| break; |
| |
| case SERVER_MODE: |
| ObjectName[] pools = getMemoryPoolMXBeansOnServer(); |
| |
| for (int i = 0; i < pools.length; i++) { |
| if (!isUsageThresholdSupportedOnServer(pools[i])) { |
| continue; |
| } |
| |
| MemoryType mt = getType(pools[i]); |
| if ((!mt.equals(MemoryType.HEAP) |
| || !memory.equals(HEAP_TYPE)) |
| && (!mt.equals(MemoryType.NON_HEAP) |
| || !memory.equals(NONHEAP_TYPE)) |
| && !memory.equals(MIXED_TYPE)) { |
| continue; |
| } |
| |
| // Yes! We got the pool that |
| // 1. supports usage threshold |
| // 2. has type that match tested type |
| // So, update the pool with new threshold |
| long oldT = getUsageThreshold(pools[i]); |
| long newT = newThreshold(getUsageOnServer(pools[i]), oldT, |
| pools[i].toString()); |
| try { |
| setUsageThresholdOnServer(pools[i], newT); |
| } catch (Failure e) { |
| /* |
| * Max value might have changed since the call to newThreshold() |
| * above. If it has fallen below the value of newT, which is certainly |
| * possible, an exception like this one will be thrown from |
| * sun.management.MemoryPoolImpl.setUsageThreshold(): |
| * |
| * java.lang.IllegalArgumentException: Invalid threshold: 48332800 > max (47251456). |
| * |
| * and we'll catch Failure here as a result (it'll be thrown by |
| * Monitor.setLongAttribute). |
| * |
| * We don't know the max value at the time of the failed call, and it |
| * might have changed since the call once more. So there is no point |
| * trying to detect whether the IllegalArgumentException had been |
| * justified, we cannot know it at this point. |
| * |
| * The best we can do is log the fact and continue. |
| */ |
| displayInfo("setUsageThresholdOnServer() failed with " + e + ", ignoring... ", |
| pools[i], |
| "current usage after the call to setUsageThresholdOnServer(): ", getUsageOnServer(pools[i]), |
| "threshold: ", newT); |
| continue; |
| } |
| displayInfo("Usage threshold is set", null, "pool: ", pools[i], "usage:", getUsageOnServer(pools[i])); |
| if (getUsageThreshold(pools[i]) != newT) { |
| complain("Cannot reset usage threshold from " + oldT + " to " |
| + newT + " in pool " + pools[i].toString()); |
| passed = false; |
| } |
| } // for i |
| break; |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // updateUsageThresholds() |
| |
| // Sets new collection usage threasholds in all pools that match the tested |
| // memory and support low memory detetion. A new value will be greater than |
| // used value for the pool. |
| private void updateCollectionThresholds() { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| // we can use the same code here for direct and proxy modes |
| case PROXY_MODE: |
| List poolsMBean = ManagementFactory.getMemoryPoolMXBeans(); |
| |
| for (int i = 0; i < poolsMBean.size(); i++) { |
| MemoryPoolMXBean pool = (MemoryPoolMXBean) poolsMBean.get(i); |
| if (!pool.isCollectionUsageThresholdSupported()) { |
| continue; |
| } |
| |
| MemoryType mt = pool.getType(); |
| if ((!mt.equals(MemoryType.HEAP) |
| || !memory.equals(HEAP_TYPE)) |
| && (!mt.equals(MemoryType.NON_HEAP) |
| || !memory.equals(NONHEAP_TYPE)) |
| && !memory.equals(MIXED_TYPE)) { |
| continue; |
| } |
| |
| // Yes! We got the pool that |
| // 1. supports collection threshold |
| // 2. has type that match tested type |
| // So, update the pool with new threshold |
| long oldT = pool.getCollectionUsageThreshold(); |
| MemoryUsage usage = pool.getUsage(); |
| long newT = newThreshold(usage, oldT, pool.getName()); |
| |
| try { |
| pool.setCollectionUsageThreshold(newT); |
| } catch (IllegalArgumentException e) { |
| |
| /* |
| * Max value might have changed since the call to newThreshold() |
| * above. If it has fallen below the value of newT, which is certainly |
| * possible, an exception like this one will be thrown from |
| * sun.management.MemoryPoolImpl.setCollectionUsageThreshold(): |
| * |
| * java.lang.IllegalArgumentException: Invalid threshold: 48332800 > max (47251456). |
| * |
| * We don't know the max value at the time of the failed call, and it |
| * might have changed since the call once more. So there is no point |
| * trying to detect whether the IllegalArgumentException had been |
| * justified, we cannot know it at this point. |
| * |
| * The best we can do is log the fact and continue. |
| */ |
| displayInfo("setCollectionUsageThreshold() failed with " + e + ", ignoring... ", |
| pool, |
| "current usage after the call to setCollectionUsageThreshold(): ", getUsage(pool), |
| "threshold: ", newT); |
| continue; |
| } |
| displayInfo("Collection threshold is set", pool, "usage: ", getUsage(pool), "threshold: ", newT); |
| if (pool.getCollectionUsageThreshold() != newT) { |
| complain("Cannot reset collection threshold from " + oldT |
| + " to " + newT + " in pool " + pool.getName() + " " |
| + pool.getCollectionUsageThreshold()); |
| passed = false; |
| } |
| } // for i |
| break; |
| |
| case SERVER_MODE: |
| ObjectName[] pools = getMemoryPoolMXBeansOnServer(); |
| |
| for (int i = 0; i < pools.length; i++) { |
| if (!isCollectionThresholdSupportedOnServer(pools[i])) { |
| continue; |
| } |
| |
| MemoryType mt = getType(pools[i]); |
| if ((!mt.equals(MemoryType.HEAP) |
| || !memory.equals(HEAP_TYPE)) |
| && (!mt.equals(MemoryType.NON_HEAP) |
| || !memory.equals(NONHEAP_TYPE)) |
| && !memory.equals(MIXED_TYPE)) { |
| continue; |
| } |
| |
| // Yes! We got the pool that |
| // 1. supports usage threshold |
| // 2. has type that match tested type |
| // So, update the pool with new threshold |
| long oldT = getCollectionThresholdOnServer(pools[i]); |
| long newT = newThreshold(getUsageOnServer(pools[i]), oldT, |
| pools[i].toString()); |
| try { |
| setCollectionThresholdOnServer(pools[i], newT); |
| } catch (Failure e) { |
| /* |
| * Max value might have changed since the call to newThreshold() |
| * above. If it has fallen below the value of newT, which is certainly |
| * possible, an exception like this one will be thrown from |
| * sun.management.MemoryPoolImpl.setCollectionUsageThreshold(): |
| * |
| * java.lang.IllegalArgumentException: Invalid threshold: 48332800 > max (47251456). |
| * |
| * and we'll catch Failure here as a result (it'll be thrown by |
| * Monitor.setLongAttribute). |
| * |
| * We don't know the max value at the time of the failed call, and it |
| * might have changed since the call once more. So there is no point |
| * trying to detect whether the IllegalArgumentException had been |
| * justified, we cannot know it at this point. |
| * |
| * The best we can do is log the fact and continue. |
| */ |
| displayInfo("setCollectionThresholdOnServer() failed with " + e + ", ignoring... ", |
| pools[i], |
| "current usage after the call to setCollectionThresholdOnServer(): ", getUsageOnServer(pools[i]), |
| "threshold: ", newT); |
| continue; |
| } |
| displayInfo("Collection threshold is set", pools[i], "usage: ", getUsageOnServer(pools[i]), "threshold: ", newT); |
| if (getCollectionThresholdOnServer(pools[i]) != newT) { |
| complain("Cannot reset collaction threshold from " + oldT |
| + " to " + newT + " in pool " + pools[i].toString()); |
| passed = false; |
| } |
| } // for i |
| break; |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } |
| } // updateCollectionThresholds() |
| |
| // Calculates a new value of threshold based on MemoryUsage and old value of |
| // the threshold. New one will be not less than previous one. |
| private long newThreshold(MemoryUsage mu, long oldT, String poolName) { |
| long newT = mu.getCommitted() / 2 + mu.getUsed() / 2; |
| long max = mu.getMax(); |
| |
| if (newT < oldT) { |
| newT = mu.getCommitted() / 2 + oldT / 2; |
| } |
| if ((max > -1) && (newT > max)) { |
| newT = max; |
| } |
| displayInfo("Changing threshold", poolName, null, null, "new threshold: ", newT); |
| return newT; |
| } |
| |
| // ********************************************************************** |
| // |
| // Methods to work with MBean server in SERVER_MODE |
| // |
| // ********************************************************************** |
| // Returns usage threshold value of the pool MBean that is accessed via |
| // MBeanServer |
| private long getUsageThresholdOnServer(ObjectName pool) { |
| return getLongAttribute(pool, UT); |
| } |
| |
| // Returns collection threshold value of the pool MBean that is accessed via |
| // MBeanServer |
| private long getCollectionThresholdOnServer(ObjectName pool) { |
| return getLongAttribute(pool, CT); |
| } |
| |
| // Sets new usage threshold value for the pool MBean that is accessed via |
| // MBeanServer |
| private void setUsageThresholdOnServer(ObjectName pool, long value) { |
| setLongAttribute(pool, UT, value); |
| } |
| |
| // Sets new collection threshold value for the pool MBean that is accessed |
| // via MBeanServer |
| private void setCollectionThresholdOnServer(ObjectName pool, long value) { |
| setLongAttribute(pool, CT, value); |
| } |
| |
| // Returns MemoryType of the pool MBean that is accessed via MBeanServer. |
| private MemoryType getType(ObjectName pool) { |
| try { |
| Object value = getMBeanServer().getAttribute(pool, POOL_TYPE); |
| if (value instanceof MemoryType) { |
| return (MemoryType) value; |
| } else if (value instanceof String) { |
| String name = (String) value; |
| return MemoryType.valueOf(name); |
| } else { |
| return null; |
| } |
| } catch (Exception e) { |
| e.printStackTrace(logger.getOutStream()); |
| throw new Failure(e); |
| } |
| } |
| |
| // Returns MemoryUsage of the pool MBean that is accessed via MBeanServer |
| private MemoryUsage getUsageOnServer(ObjectName pool) { |
| return getMemoryUsageAttribute(pool, POOL_U); |
| } |
| |
| // Returns collection usage of the pool MBean that is accessed via |
| // MBeanServer |
| private MemoryUsage getCollectionUsageOnServer(ObjectName pool) { |
| return getMemoryUsageAttribute(pool, POOL_CU); |
| } |
| |
| // Returns if usage threshold is supported in the pool |
| private boolean isUsageThresholdSupportedOnServer(ObjectName pool) { |
| return getBooleanAttribute(pool, UT_SUPPORT); |
| } |
| |
| // Returns if collection threshold is supported in the pool |
| private boolean isCollectionThresholdSupportedOnServer(ObjectName pool) { |
| return getBooleanAttribute(pool, CT_SUPPORT); |
| } |
| |
| // Returns if usage threshold is exceeded in the pool |
| private boolean isUsageThresholdExceededOnServer(ObjectName pool) { |
| return getBooleanAttribute(pool, UT_EXCEEDED); |
| } |
| |
| // Returns if collection threshold is exceeded in the pool |
| private boolean isCollectionThresholdExceededOnServer(ObjectName pool) { |
| return getBooleanAttribute(pool, CT_EXCEEDED); |
| } |
| |
| // Returns the usage threshold count of the pool |
| private long getUsageThresholdCountOnServer(ObjectName pool) { |
| return getLongAttribute(pool, UT_COUNT); |
| } |
| |
| // Returns the collection threshold count of the pool. |
| private long getCollectionThresholdCountOnServer(ObjectName pool) { |
| return getLongAttribute(pool, CT_COUNT); |
| } |
| private final StringBuffer buffer = new StringBuffer(1000); |
| |
| /** |
| * Display information about execution ignoring OOM. |
| */ |
| private void displayInfo(String message, Object pool, String message1, Object n1, String message2, long n2) { |
| try { |
| buffer.delete(0, buffer.length()); |
| buffer.append(message); |
| if (pool != null) { |
| buffer.append(", pool: "); |
| buffer.append(pool.toString()); |
| } |
| buffer.append(", "); |
| buffer.append(message1); |
| buffer.append(n1); |
| if (message2 != null) { |
| buffer.append(", "); |
| buffer.append(message2); |
| buffer.append(n2); |
| } |
| display(buffer.toString()); |
| } catch (OutOfMemoryError e) { |
| // Ignore. |
| } |
| } |
| |
| /** |
| * Display information about execution ignoring OOM. |
| */ |
| private void displayInfo(String message, MemoryPoolMXBean pool, String message1, Object n1, String message2, Object n2) { |
| try { |
| buffer.delete(0, buffer.length()); |
| buffer.append(message); |
| if (pool != null) { |
| buffer.append(", pool: "); |
| buffer.append(pool.getName()); |
| } |
| buffer.append(", "); |
| buffer.append(message1); |
| buffer.append(n1); |
| if (message2 != null) { |
| buffer.append(", "); |
| buffer.append(message2); |
| buffer.append(n2); |
| } |
| display(buffer.toString()); |
| } catch (OutOfMemoryError e) { |
| // Ignore. |
| } |
| } |
| |
| // Returns all MemoryPoolMXBeans that are registered on the MBeanServer |
| private ObjectName[] getMemoryPoolMXBeansOnServer() { |
| |
| // Get all registered MBeans on the server |
| ObjectName filterName = null; |
| try { |
| filterName = new ObjectName( |
| ManagementFactory.MEMORY_POOL_MXBEAN_DOMAIN_TYPE + ",*"); |
| |
| Set<ObjectName> filteredSet = getMBeanServer().queryNames(filterName, null); |
| return filteredSet.toArray(new ObjectName[0]); |
| } catch(Exception e) { |
| return new ObjectName[0]; |
| } |
| |
| } // getMemoryPoolMXBeansOnServer() |
| |
| // ********************************************************************** |
| // |
| // Class to implement polling mechanism of monitoring |
| // |
| // ********************************************************************** |
| class Polling extends Thread { |
| |
| final static long WAIT_TIME = 100; // Milliseconds |
| Object object = new Object(); |
| long[] thresholdCounts; |
| boolean goOn = true; |
| |
| public void run() { |
| try { |
| if (isUsageThreshold) { |
| pollUsageThresholds(); |
| } else { |
| pollCollectionThresholds(); |
| } |
| } catch (Failure e) { |
| complain("Unexpected " + e + " in Polling thread"); |
| e.printStackTrace(logger.getOutStream()); |
| passed = false; |
| } |
| } // run() |
| |
| private void pollUsageThresholds() { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| // we can use the same code here for direct and proxy modes |
| case PROXY_MODE: |
| List poolsMBean = ManagementFactory.getMemoryPoolMXBeans(); |
| |
| // Create an array to store all threshold values |
| thresholdCounts = new long[poolsMBean.size()]; |
| for (int i = 0; i < thresholdCounts.length; i++) { |
| thresholdCounts[i] = 0; |
| } |
| |
| while (goOn) { |
| synchronized (object) { |
| try { |
| object.wait(WAIT_TIME); |
| } catch (InterruptedException e) { |
| |
| // Stop the thread |
| return; |
| } |
| } // synchronized |
| |
| for (int i = 0; i < poolsMBean.size(); i++) { |
| MemoryPoolMXBean pool = (MemoryPoolMXBean) poolsMBean.get(i); |
| MemoryType mt = pool.getType(); |
| |
| if (!pool.isUsageThresholdSupported()) { |
| continue; |
| } |
| |
| if ((!mt.equals(MemoryType.HEAP) |
| || !memory.equals(HEAP_TYPE)) |
| && (!mt.equals(MemoryType.NON_HEAP) |
| || !memory.equals(NONHEAP_TYPE)) |
| && !memory.equals(MIXED_TYPE)) { |
| continue; |
| } |
| |
| boolean exceeded; |
| |
| // The exception is not documented, but it may be |
| // erroneously thrown |
| try { |
| exceeded = pool.isUsageThresholdExceeded(); |
| } catch (IllegalArgumentException e) { |
| complain("Unexpected exception while retrieving " |
| + "isUsageThresholdExceeded() for pool " |
| + pool.getName()); |
| e.printStackTrace(logger.getOutStream()); |
| passed = false; |
| continue; |
| } |
| |
| if (!exceeded |
| || pool.getUsageThresholdCount() == thresholdCounts[i]) { |
| continue; |
| } |
| |
| // Yes! We got the pool that |
| // 1. supports usage threshold |
| // 2. has type that match tested type |
| // 3. its threshold is exceeded |
| // So, update all thresholds |
| long c = pool.getUsageThresholdCount(); |
| if (c <= thresholdCounts[i]) { |
| complain("Usage threshold count is not greater " |
| + "than previous one: " + c + " < " |
| + thresholdCounts[i] + " in pool " |
| + pool.getName()); |
| passed = false; |
| } |
| thresholdCounts[i] = c; |
| displayInfo("Crossing is noticed", pool, "usage: ", pool.getUsage(), "count: ", c); |
| updateThresholds(); |
| } // for i |
| } // while |
| break; |
| |
| case SERVER_MODE: |
| ObjectName[] pools = getMemoryPoolMXBeansOnServer(); |
| |
| // Create an array to store all threshold values |
| thresholdCounts = new long[pools.length]; |
| for (int i = 0; i < thresholdCounts.length; i++) { |
| thresholdCounts[i] = 0; |
| } |
| |
| while (goOn) { |
| synchronized (object) { |
| try { |
| object.wait(WAIT_TIME); |
| } catch (InterruptedException e) { |
| |
| // Stop the thread |
| return; |
| } |
| } // synchronized |
| |
| for (int i = 0; i < pools.length; i++) { |
| MemoryType mt = getType(pools[i]); |
| |
| if (!isUsageThresholdSupportedOnServer(pools[i])) { |
| continue; |
| } |
| |
| if ((!mt.equals(MemoryType.HEAP) |
| || !memory.equals(HEAP_TYPE)) |
| && (!mt.equals(MemoryType.NON_HEAP) |
| || !memory.equals(NONHEAP_TYPE)) |
| && !memory.equals(MIXED_TYPE)) { |
| continue; |
| } |
| |
| boolean exceeded; |
| |
| // The exception is not documented, but it may be |
| // erroneously thrown |
| try { |
| exceeded = isUsageThresholdExceededOnServer(pools[i]); |
| } catch (Failure e) { |
| complain("Unexpected exception while retrieving " |
| + "isUsageThresholdExceeded() for pool " |
| + pools[i].toString()); |
| e.printStackTrace(logger.getOutStream()); |
| passed = false; |
| continue; |
| } |
| |
| if (!exceeded |
| || getUsageThresholdCount(pools[i]) == thresholdCounts[i]) { |
| continue; |
| } |
| |
| // Yes! We got the pool that |
| // 1. supports usage threshold |
| // 2. has type that match tested type |
| // 3. its threshold is exceeded |
| // So, update all thresholds |
| long c = getUsageThresholdCount(pools[i]); |
| if (c <= thresholdCounts[i]) { |
| complain("Usage threshold count is not greater " |
| + "than previous one: " + c + " < " |
| + thresholdCounts[i] + " in pool " |
| + pools[i].toString()); |
| passed = false; |
| } |
| thresholdCounts[i] = c; |
| displayInfo("Crossing is noticed", null, "pool: ", pools[i], "usage: ", getUsageOnServer(pools[i])); |
| updateThresholds(); |
| } // for i |
| } // while |
| break; |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } // switch |
| } // pollUsageThresholds() |
| |
| private void pollCollectionThresholds() { |
| switch (mode) { |
| case DIRECTLY_MODE: |
| // we can use the same code here for direct and proxy modes |
| case PROXY_MODE: |
| List poolsMBean = ManagementFactory.getMemoryPoolMXBeans(); |
| |
| // Create an array to store all threshold values |
| thresholdCounts = new long[poolsMBean.size()]; |
| for (int i = 0; i < thresholdCounts.length; i++) { |
| thresholdCounts[i] = 0; |
| } |
| |
| while (goOn) { |
| synchronized (object) { |
| try { |
| object.wait(WAIT_TIME); |
| } catch (InterruptedException e) { |
| |
| // Stop the thread |
| return; |
| } |
| } // synchronized |
| |
| for (int i = 0; i < poolsMBean.size(); i++) { |
| MemoryPoolMXBean pool = (MemoryPoolMXBean) poolsMBean.get(i); |
| MemoryType mt = pool.getType(); |
| |
| if (!pool.isCollectionUsageThresholdSupported()) { |
| continue; |
| } |
| |
| if ((!mt.equals(MemoryType.HEAP) |
| || !memory.equals(HEAP_TYPE)) |
| && (!mt.equals(MemoryType.NON_HEAP) |
| || !memory.equals(NONHEAP_TYPE)) |
| && !memory.equals(MIXED_TYPE)) { |
| continue; |
| } |
| |
| boolean exceeded; |
| |
| // The exception is not documented, but it may be |
| // erroneously thrown |
| try { |
| exceeded = pool.isCollectionUsageThresholdExceeded(); |
| } catch (IllegalArgumentException e) { |
| complain("Unexpected exception while retrieving " |
| + "isCollectionUsageThresholdExceeded()" |
| + " for pool " + pool.getName()); |
| e.printStackTrace(logger.getOutStream()); |
| passed = false; |
| continue; |
| } |
| |
| if (!exceeded |
| || pool.getCollectionUsageThresholdCount() |
| == thresholdCounts[i]) { |
| continue; |
| } |
| |
| // Yes! We got thet pool that |
| // 1. supports collection usage threshold |
| // 2. has type that match tested type |
| // 3. its threshold is exceeded |
| // So, update all thresholds |
| long c = pool.getCollectionUsageThresholdCount(); |
| if (c <= thresholdCounts[i]) { |
| complain("Collection usage threshold count is " |
| + "not greater than previous one: " + c |
| + " < " + thresholdCounts[i] + " in pool " |
| + pool.getName()); |
| passed = false; |
| } |
| thresholdCounts[i] = c; |
| displayInfo("Crossing is noticed", pool, "usage: ", pool.getUsage(), "count: ", c); |
| updateThresholds(); |
| } // for i |
| } // while |
| break; |
| |
| case SERVER_MODE: |
| ObjectName[] pools = getMemoryPoolMXBeansOnServer(); |
| |
| // Create an array to store all threshold values |
| thresholdCounts = new long[pools.length]; |
| for (int i = 0; i < thresholdCounts.length; i++) { |
| thresholdCounts[i] = 0; |
| } |
| |
| while (goOn) { |
| synchronized (object) { |
| try { |
| object.wait(WAIT_TIME); |
| } catch (InterruptedException e) { |
| |
| // Stop the thread |
| return; |
| } |
| } // synchronized |
| |
| for (int i = 0; i < pools.length; i++) { |
| MemoryType mt = getType(pools[i]); |
| |
| if (!isCollectionThresholdSupportedOnServer(pools[i])) { |
| continue; |
| } |
| |
| if ((!mt.equals(MemoryType.HEAP) |
| || !memory.equals(HEAP_TYPE)) |
| && (!mt.equals(MemoryType.NON_HEAP) |
| || !memory.equals(NONHEAP_TYPE)) |
| && !memory.equals(MIXED_TYPE)) { |
| continue; |
| } |
| |
| boolean exceeded; |
| |
| // The exception is not documented, but it may be |
| // erroneously thrown |
| try { |
| exceeded = isCollectionThresholdExceededOnServer(pools[i]); |
| } catch (Failure e) { |
| complain("Unexpected exception while retrieving " |
| + "isCollectionUsageThresholdExceeded() " |
| + "for pool " + pools[i].toString()); |
| e.printStackTrace(logger.getOutStream()); |
| passed = false; |
| continue; |
| } |
| |
| if (!exceeded |
| || getCollectionThresholdCountOnServer(pools[i]) |
| == thresholdCounts[i]) { |
| continue; |
| } |
| |
| // Yes! We got thet pool that |
| // 1. supports collection usage threshold |
| // 2. has type that match tested type |
| // 3. its threshold is exceeded |
| // So, update all thresholds |
| long c = getCollectionThresholdCountOnServer(pools[i]); |
| if (c <= thresholdCounts[i]) { |
| complain("Collection usage threshold count is " |
| + "not greater than previous one: " + c |
| + " < " + thresholdCounts[i] + " in pool " |
| + pools[i].toString()); |
| passed = false; |
| } |
| thresholdCounts[i] = c; |
| displayInfo("Crossing is noticed", pools[i], "usage: ", getUsageOnServer(pools[i]), "count: ", c); |
| updateThresholds(); |
| } // for i |
| } // while |
| break; |
| |
| default: |
| throw new TestBug("Unknown testMode " + mode); |
| } // switch |
| } // pollCollectionThresholds() |
| } // class Polling |
| } // MemoryMonitor |
