8234541: C1 emits an empty message when it inlines successfully
Summary: Use "inline" as the message when successfull
Reviewed-by: thartmann, mdoerr
Contributed-by: navy.xliu@gmail.com
/*
* 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