public static void main(String[] args) {
// We create an instance of a File to represent a partition
// of our file system. For instance here we used a drive D:
// as in Windows operating system.
File file = new File("/home/local/ZOHOCORP/venkat-0773/webnms/5.2_astro/state/traps");
File file2 = new File("/home/local/ZOHOCORP/venkat-0773/webnms/5.2_astro/state/");
File file3 = new File("/home/local/ZOHOCORP/venkat-0773/webnms/5.2_astro");
// Using the getTotalSpace() we can get an information of
// the actual size of the partition, and we convert it to
// mega bytes.
long totalSpace = file.getTotalSpace() / (1024 * 1024);
/*System.err.println("file.length :: "+getFolderSize(file));
System.err.println("file2.length :: "+getFolderSize(file2));
System.err.println("file3.length :: "+getFolderSize(file3));*/
System.err.println(
"file.sizeOfDirectory :: " + org.apache.commons.io.FileUtils.sizeOfDirectory(file3));
// Next we get the free disk space as the name of the
// method shown us, and also get the size in mega bytes.
long freeSpace = file.getFreeSpace() / (1024 * 1024);
// Just print out the values.
System.out.println("Total Space1 = " + totalSpace + " Mega Bytes");
System.out.println("Free Space1 = " + freeSpace + " Mega Bytes");
System.out.println("Free Space3 = " + Runtime.getRuntime().totalMemory() + " Mega Bytes");
System.out.println("Free Space4 = " + Runtime.getRuntime().freeMemory() + " Mega Bytes");
System.out.println("Free Space5 = " + Runtime.getRuntime().maxMemory() + "Bytes");
System.out.println(
"Free Space6 = " + ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage() + "Bytes");
System.out.println(
"Free Space7 = " + ManagementFactory.getMemoryMXBean().getHeapMemoryUsage() + "Bytes");
System.out.println("Free Space8 = " + file.getUsableSpace() / 1024 / 1024 + " Mega Bytes");
}
/** Add JVM heap metrics. */
protected void addHeapMetrics(Collection<Metric<?>> result) {
MemoryUsage memoryUsage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
result.add(new Metric<Long>("heap.committed", memoryUsage.getCommitted() / 1024));
result.add(new Metric<Long>("heap.init", memoryUsage.getInit() / 1024));
result.add(new Metric<Long>("heap.used", memoryUsage.getUsed() / 1024));
result.add(new Metric<Long>("heap", memoryUsage.getMax() / 1024));
}
public void log() {
new Thread(new LogRunnable()).start();
List<MemoryPoolMXBean> beans = ManagementFactory.getMemoryPoolMXBeans();
MemoryPoolMXBean pool = null;
for (MemoryPoolMXBean bean : beans) {
if ("Tenured Gen".equals(bean.getName())) {
pool = bean;
break;
}
}
MemoryMXBean mbean = ManagementFactory.getMemoryMXBean();
NotificationEmitter emitter = (NotificationEmitter) mbean;
MemoryListener listener = new MemoryListener();
emitter.addNotificationListener(listener, null, null);
pool.setUsageThreshold(8 * 1024 * 1024);
consumeMemory();
System.gc();
checkMemory(pool);
consumeMemory();
checkMemory(pool);
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public String getInodeLimitText() {
long inodes = fsn.dir.totalInodes();
long blocks = fsn.getBlocksTotal();
long maxobjects = fsn.getMaxObjects();
MemoryMXBean mem = ManagementFactory.getMemoryMXBean();
MemoryUsage heap = mem.getHeapMemoryUsage();
long totalMemory = heap.getUsed();
long maxMemory = heap.getMax();
long used = (totalMemory * 100) / maxMemory;
String str =
inodes + " files and directories, " + blocks + " blocks = " + (inodes + blocks) + " total";
if (maxobjects != 0) {
long pct = ((inodes + blocks) * 100) / maxobjects;
str += " / " + maxobjects + " (" + pct + "%)";
}
str +=
". Heap Size is "
+ StringUtils.byteDesc(totalMemory)
+ " / "
+ StringUtils.byteDesc(maxMemory)
+ " ("
+ used
+ "%) <br>";
return str;
}
public static void main(String args[]) {
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
long init = heapMemoryUsage.getInit();
long used = heapMemoryUsage.getUsed();
long max = heapMemoryUsage.getMax();
long committed = heapMemoryUsage.getCommitted();
long free = max - used;
int usedPercent = (int) (used / max);
int freePercent = (int) (usedPercent / max);
MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
List<GarbageCollectorMXBean> garbageCollectorMXBeans =
ManagementFactory.getGarbageCollectorMXBeans();
List<MemoryPoolMXBean> memoryPoolMXBeans = ManagementFactory.getMemoryPoolMXBeans();
com.sun.management.OperatingSystemMXBean operatingSystemMXBean =
(com.sun.management.OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
long commitVirtual = operatingSystemMXBean.getCommittedVirtualMemorySize();
println(init, used, max, committed);
println(commitVirtual);
}
/*
* (non-Javadoc)
*
* @see com.orientechnologies.common.test.SpeedTest#startTimer(java.lang.String)
*/
public void startTimer(final String iName) {
Runtime.getRuntime().runFinalization();
Runtime.getRuntime().gc();
try {
Thread.sleep(TIME_WAIT);
} catch (InterruptedException e) {
}
final MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
final MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
final MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
currentTestName = iName;
currentTestHeapCommittedMemory = heapMemoryUsage.getCommitted();
currentTestHeapUsedMemory = heapMemoryUsage.getUsed();
currentTestHeapMaxMemory = heapMemoryUsage.getMax();
currentTestNonHeapCommittedMemory = nonHeapMemoryUsage.getCommitted();
currentTestNonHeapUsedMemory = nonHeapMemoryUsage.getUsed();
currentTestNonHeapMaxMemory = nonHeapMemoryUsage.getMax();
System.out.println("-> Started the test of '" + currentTestName + "' (" + cycles + " cycles)");
currentTestTimer = System.currentTimeMillis();
}
private void createRuntimeProps(MemberStateImpl memberState) {
Runtime runtime = Runtime.getRuntime();
ThreadMXBean threadMxBean = ManagementFactory.getThreadMXBean();
RuntimeMXBean runtimeMxBean = ManagementFactory.getRuntimeMXBean();
ClassLoadingMXBean clMxBean = ManagementFactory.getClassLoadingMXBean();
MemoryMXBean memoryMxBean = ManagementFactory.getMemoryMXBean();
MemoryUsage heapMemory = memoryMxBean.getHeapMemoryUsage();
MemoryUsage nonHeapMemory = memoryMxBean.getNonHeapMemoryUsage();
Map<String, Long> map = new HashMap<String, Long>();
map.put(
"runtime.availableProcessors", Integer.valueOf(runtime.availableProcessors()).longValue());
map.put("date.startTime", runtimeMxBean.getStartTime());
map.put("seconds.upTime", runtimeMxBean.getUptime());
map.put("memory.maxMemory", runtime.maxMemory());
map.put("memory.freeMemory", runtime.freeMemory());
map.put("memory.totalMemory", runtime.totalMemory());
map.put("memory.heapMemoryMax", heapMemory.getMax());
map.put("memory.heapMemoryUsed", heapMemory.getUsed());
map.put("memory.nonHeapMemoryMax", nonHeapMemory.getMax());
map.put("memory.nonHeapMemoryUsed", nonHeapMemory.getUsed());
map.put("runtime.totalLoadedClassCount", clMxBean.getTotalLoadedClassCount());
map.put(
"runtime.loadedClassCount", Integer.valueOf(clMxBean.getLoadedClassCount()).longValue());
map.put("runtime.unloadedClassCount", clMxBean.getUnloadedClassCount());
map.put("runtime.totalStartedThreadCount", threadMxBean.getTotalStartedThreadCount());
map.put("runtime.threadCount", Integer.valueOf(threadMxBean.getThreadCount()).longValue());
map.put(
"runtime.peakThreadCount", Integer.valueOf(threadMxBean.getPeakThreadCount()).longValue());
map.put(
"runtime.daemonThreadCount",
Integer.valueOf(threadMxBean.getDaemonThreadCount()).longValue());
memberState.setRuntimeProps(map);
}
@Override
public void closeOp(boolean abort) throws HiveException {
// ricardoj checking mapper hashmap usage
memoryMXBean = ManagementFactory.getMemoryMXBean();
System.gc();
System.gc();
System.gc();
System.gc();
System.gc();
System.gc();
long usedMemory = memoryMXBean.getHeapMemoryUsage().getUsed();
LOG.info("ricardoj memory usage after deleting tables: " + usedMemory / (1024 * 1024) + "MB");
if (mapJoinTables != null) {
for (HashMapWrapper<?, ?> hashTable : mapJoinTables.values()) {
hashTable.close();
}
}
mapJoinTables = null;
// ricardoj
System.gc();
System.gc();
System.gc();
System.gc();
System.gc();
System.gc();
usedMemory = memoryMXBean.getHeapMemoryUsage().getUsed();
LOG.info("ricardoj memory usage after deleting tables: " + usedMemory / (1024 * 1024) + "MB");
super.closeOp(abort);
}
public void init(final ServletContext context, final Map<String, String> paras) {
_startTime = new Date();
_context = context;
_sipFactory = (SipFactory) context.getAttribute(ServletContextConstants.SIP_FACTORY);
_mrcpFactory = (MrcpFactory) context.getAttribute(ServletContextConstants.MRCP_FACTORY);
_appJarUrl =
_context.getRealPath("/")
+ "WEB-INF"
+ File.separator
+ "lib"
+ File.separator
+ "tropo.jar";
_cache = Collections.synchronizedMap(new WeakHashMap<Object, Application>());
_tmx = ManagementFactory.getThreadMXBean();
_mmx = ManagementFactory.getMemoryMXBean();
try {
_tropoBuildDate = Utils.getManifestAttribute(_appJarUrl, "Build-Date");
} catch (final IOException t) {
LOG.error(t.toString(), t);
_tropoBuildDate = "Unknown";
}
try {
_tropoVersionNo = Utils.getManifestAttribute(_appJarUrl, "Version-No");
} catch (final IOException t) {
LOG.error(t.toString(), t);
_tropoVersionNo = "Unknown";
}
try {
_tropoBuildNo = Utils.getManifestAttribute(_appJarUrl, "Build-No");
} catch (final IOException t) {
LOG.error(t.toString(), t);
_tropoBuildNo = "Unknown";
}
LOG.info(toString() + " / " + getVersionNo() + " / " + getBuildNo());
}
public MemoryMonitor() {
LOG.info("initializing");
this.springContextId = "Unknown";
ManagementFactory.getThreadMXBean().setThreadContentionMonitoringEnabled(true);
ManagementFactory.getThreadMXBean().setThreadCpuTimeEnabled(true);
lowMemoryListener =
new NotificationListener() {
public void handleNotification(Notification n, Object hb) {
if (n.getType().equals(MemoryNotificationInfo.MEMORY_THRESHOLD_EXCEEDED)) {
Map<String, String> memoryUsageStatistics = new HashMap<String, String>();
memoryUsageStatistics.put(
"MemoryMXBean: " + MemoryType.HEAP,
ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().toString());
memoryUsageStatistics.put(
"MemoryMXBean:" + MemoryType.NON_HEAP,
ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage().toString());
for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) {
memoryUsageStatistics.put(
"MemoryPoolMXBean: " + pool.getType(), pool.getUsage().toString());
}
for (Listener listener : listeners) {
listener.memoryUsageLow(
springContextId,
memoryUsageStatistics,
Arrays.toString(
ManagementFactory.getThreadMXBean().findMonitorDeadlockedThreads()));
}
}
}
};
((NotificationEmitter) ManagementFactory.getMemoryMXBean())
.addNotificationListener(lowMemoryListener, null, null);
}
// 90, 1
private void __jamon_innerUnit__memoryStats(
@SuppressWarnings({"unused", "hiding"}) final java.io.Writer jamonWriter,
final MetricsRegionServerWrapper mWrap)
throws java.io.IOException {
// 94, 1
jamonWriter.write(
"<table class=\"table table-striped\">\n<tr>\n <tr>\n <th>Used Heap</th>\n <th>Max Heap</th>\n <th>Direct Memory Used</th>\n <th>Direct Memory Configured</th>\n <th>Memstore Size</th>\n </tr>\n</tr>\n<tr>\n <td>\n ");
// 106, 9
org.jamon.escaping.Escaping.HTML.write(
org.jamon.emit.StandardEmitter.valueOf(
StringUtils.humanReadableInt(
ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed())),
jamonWriter);
// 106, 111
jamonWriter.write("\n </td>\n <td>\n ");
// 109, 9
org.jamon.escaping.Escaping.HTML.write(
org.jamon.emit.StandardEmitter.valueOf(
StringUtils.humanReadableInt(
ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getMax())),
jamonWriter);
// 109, 110
jamonWriter.write("\n </td>\n <td>\n ");
// 112, 9
org.jamon.escaping.Escaping.HTML.write(
org.jamon.emit.StandardEmitter.valueOf(
StringUtils.humanReadableInt(DirectMemoryUtils.getDirectMemoryUsage())),
jamonWriter);
// 112, 85
jamonWriter.write("\n </td>\n <td>\n ");
// 115, 9
org.jamon.escaping.Escaping.HTML.write(
org.jamon.emit.StandardEmitter.valueOf(
StringUtils.humanReadableInt(DirectMemoryUtils.getDirectMemorySize())),
jamonWriter);
// 115, 84
jamonWriter.write("\n </td>\n <td>");
// 117, 9
org.jamon.escaping.Escaping.HTML.write(
org.jamon.emit.StandardEmitter.valueOf(
StringUtils.humanReadableInt(mWrap.getMemstoreSize())),
jamonWriter);
// 117, 68
jamonWriter.write("</td>\n</tr>\n</table>\n");
}
private void removeNotificationListener(NotificationListener notificationListener) {
MemoryMXBean mem = ManagementFactory.getMemoryMXBean();
try {
((NotificationBroadcaster) mem).removeNotificationListener(notificationListener);
} catch (ListenerNotFoundException lnfe) {
log.error("error in removeNotificationListener");
log.error(lnfe);
}
}
private void doMemoryUpdates() {
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
MemoryUsage memNonHeap = memoryMXBean.getNonHeapMemoryUsage();
MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
metrics.setMetric("memNonHeapUsedM", memNonHeap.getUsed() / M);
metrics.setMetric("memNonHeapCommittedM", memNonHeap.getCommitted() / M);
metrics.setMetric("memHeapUsedM", memHeap.getUsed() / M);
metrics.setMetric("memHeapCommittedM", memHeap.getCommitted() / M);
}
public void stop() {
try {
removeAllListeners();
((NotificationEmitter) ManagementFactory.getMemoryMXBean())
.removeNotificationListener(lowMemoryListener);
} catch (ListenerNotFoundException ex) {
LOG.error("Unable to unregister mbean listener", ex);
}
}
public void validateMemory(int mem) throws LicenseException {
MemoryMXBean memoryBean = ManagementFactory.getMemoryMXBean();
long max = memoryBean.getHeapMemoryUsage().getMax();
long conv = max / 1073741824;
if (conv > mem) {
throw new LicenseException("Too much memory allocated, decrease your XMX Limit");
}
}
/**
* Grid-enables method only if heap utilized over 80%. Otherwise, method method will proceed with
* local execution without calling grid at all.
*
* @param gridify {@inheritDoc}
* @param arg {@inheritDoc}
* @return {@inheritDoc}
* @throws GridException {@inheritDoc}
*/
@Override
public boolean isGridify(Annotation gridify, GridifyArgument arg) throws GridException {
MemoryUsage heap = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
// If heap memory for the local node is above 80% of maximum heap
// memory available, return true which means that method will
// be grid-enabled. Otherwise, return false, which means that
// method will execute locally without grid.
return heap.getUsed() > 0.8 * heap.getMax();
}
public SystemManager() {
memoryBean = ManagementFactory.getMemoryMXBean();
BufferPoolMXBean localBean = null;
List<BufferPoolMXBean> pools = ManagementFactory.getPlatformMXBeans(BufferPoolMXBean.class);
for (BufferPoolMXBean b : pools) {
if (b.getName().equals("direct")) {
localBean = b;
}
}
directBean = localBean;
}
/**
* Monitors the heap usage after full gc run and tells Cleaner to free memory if mem usage is too
* high. Stops new allocation if mem usage is critical.
*
* @author tomas
*/
private static class HeapUsageMonitor implements javax.management.NotificationListener {
MemoryMXBean _allMemBean = ManagementFactory.getMemoryMXBean(); // general
MemoryPoolMXBean _oldGenBean;
public long _gc_callback;
HeapUsageMonitor() {
int c = 0;
for (MemoryPoolMXBean m : ManagementFactory.getMemoryPoolMXBeans()) {
if (m.getType() != MemoryType.HEAP) // only interested in HEAP
continue;
if (m.isCollectionUsageThresholdSupported() && m.isUsageThresholdSupported()) {
// should be Old pool, get called when memory is critical
_oldGenBean = m;
_gc_callback = MEM_MAX;
// Really idiotic API: no idea what the usageThreshold is, so I have
// to guess. Start high, catch IAE & lower by 1/8th and try again.
while (true) {
try {
m.setCollectionUsageThreshold(_gc_callback);
break;
} catch (IllegalArgumentException iae) {
// Do NOT log this exception, it is expected and unavoidable and
// entirely handled.
_gc_callback -= (_gc_callback >> 3);
}
}
NotificationEmitter emitter = (NotificationEmitter) _allMemBean;
emitter.addNotificationListener(this, null, m);
++c;
}
}
assert c == 1;
}
/**
* Callback routine called by JVM after full gc run. Has two functions: 1) sets the amount of
* memory to be cleaned from the cache by the Cleaner 2) sets the CAN_ALLOC flag to false if
* memory level is critical
*
* <p>The callback happens in a system thread, and hence not through the usual water.Boot loader
* - and so any touched classes are in the wrong class loader and you end up with new classes
* with uninitialized global vars. Limit to touching global vars in the Boot class.
*/
public void handleNotification(Notification notification, Object handback) {
String notifType = notification.getType();
if (notifType.equals(MemoryNotificationInfo.MEMORY_COLLECTION_THRESHOLD_EXCEEDED)) {
// Memory used after this FullGC
Boot.TIME_AT_LAST_GC = System.currentTimeMillis();
Boot.HEAP_USED_AT_LAST_GC = _allMemBean.getHeapMemoryUsage().getUsed();
Boot.kick_store_cleaner();
}
}
}
public static final void createDefaultCache() {
long availableMemory =
(long)
(ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getMax()
* DEFAULT_HEAP_MEMORY_PERCENTAGE);
CacheBuilder<String, BlockReader> builder =
CacheBuilder.newBuilder().maximumWeight(availableMemory).weigher(new KVWeigher());
singleCache = buildCache(builder);
}
protected void updateMemory() {
// Determining current memory usage state
MemoryUsage mu = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
usedMemory = mu.getUsed();
allocatedMemory = mu.getCommitted();
// Updating bar text
setText(getMemoryBarText());
// Updating view
repaint();
}
@Before
public void openFileSystem() throws Exception {
conf = new Configuration();
fs = FileSystem.getLocal(conf);
testFilePath = new Path(workDir, "TestOrcFile." + testCaseName.getMethodName() + ".orc");
fs.delete(testFilePath, false);
// make sure constant memory is available for ORC always
memoryPercent =
(float) MEMORY_FOR_ORC
/ (float) ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getMax();
conf.setFloat(HiveConf.ConfVars.HIVE_ORC_FILE_MEMORY_POOL.varname, memoryPercent);
}
private void footerJvmAction() {
long jvmUsed = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getUsed();
long jvmMax = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getMax();
double jvmFrac = ((double) jvmUsed) / ((double) jvmMax);
display.jvmAvailLabel.setText(Utility.progressString(progressSize, jvmFrac));
//
display.footerExtraLabel.setText(
String.format(
" %d logs, %sused, %smax",
AllGroups.getLogCount(),
Utility.byteString(jvmUsed, true, true, false, false),
Utility.byteString(jvmMax, true, true, false, false)));
// Debug.print("jvm %d %s", jvmFrac,
// String.format("%d logs, %s used memory, %s max",
// AllGroups.getLogCount(), Utility.byteString(jvmUsed, true, true,
// false, false),
// Utility.byteString(jvmMax, true, true, false, false))
// );
}
/**
* (Re)Create the cache by limiting percentage of the total heap memory
*
* @param concurrencyLevel
* @param initialCapacity
* @param heapMemPercentage
* @return The cache.
*/
public static final Cache<String, BlockReader> createCache(
int concurrencyLevel, int initialCapacity, float heapMemPercentage) {
CacheBuilder builder =
CacheBuilder.newBuilder()
.concurrencyLevel(concurrencyLevel)
.initialCapacity(initialCapacity)
.maximumWeight(
(long)
(ManagementFactory.getMemoryMXBean().getHeapMemoryUsage().getMax()
* heapMemPercentage))
.weigher(new KVWeigher());
return buildCache(builder);
}
public static synchronized State release() {
long now = System.currentTimeMillis();
if (marks.empty())
throw new RuntimeException(
"TimeStiatistics: Called release() without a matching call to mark()");
State m = marks.pop();
m.garbageCounterDelta = garbageCounter.get() - m.garbageCounterMark;
m.end = now;
MemoryUsage memoryUsage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
m.memoryUsedEnd = memoryUsage.getUsed();
System.out.println(m.toString());
return m;
}
/**
* Creates a new instance. This can't be called outside of container b/c agents have no refs to
* the singleton container. So we can be sure this method is going to create services just once.
*
* @param c Reference to the container.
* @return The sole instance.
* @throws NullPointerException If the reference to the {@link Container} is <code>null</code>.
*/
public static PixelsServicesFactory getInstance(Container c) {
if (c == null) throw new NullPointerException(); // An agent called this method?
if (singleton == null) {
registry = c.getRegistry();
singleton = new PixelsServicesFactory();
// Retrieve the maximum heap size.
MemoryUsage usage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
String message = "Heap memory usage: max " + usage.getMax();
registry.getLogger().info(singleton, message);
// percentage of memory used for caching.
maxSize = (int) (RATIO * usage.getMax()) / FACTOR;
}
return singleton;
}
/**
* Puts a marker in the marker stack. Every call to this method should have a corresponding call
* to {@link #release()}. Calls to this method may be nested.
*
* @param markName the name of the marker
*/
public static synchronized void mark(String markName) {
State marker = new State();
marker.id = markName;
marker.start = System.currentTimeMillis();
MemoryUsage memoryUsage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
marker.memoryUsedStart = memoryUsage.getUsed();
marker.garbageCounterMark = garbageCounter.get();
marks.push(marker);
System.out.println(
"Set block marker \""
+ markName
+ "\", memory used "
+ Util.getFormatBytes(marker.memoryUsedStart));
}
@Override
public void calibrate() {
MemoryMXBean mxBean = ManagementFactory.getMemoryMXBean();
long lastUsed = memoryUsed();
for (int i = 0; i < 10; i++) {
System.gc();
System.runFinalization();
long used = memoryUsed();
if (mxBean.getObjectPendingFinalizationCount() == 0 && used >= lastUsed) {
break;
} else {
lastUsed = used;
}
}
super.calibrate();
}
@Override
public long[] getMaxSystemParameters() {
long[] systemData = new long[3];
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
systemData[0] = memoryMXBean.getHeapMemoryUsage().getMax();
systemData[1] = memoryMXBean.getNonHeapMemoryUsage().getMax();
List<MemoryPoolMXBean> mbeans = ManagementFactory.getMemoryPoolMXBeans();
if (mbeans != null) {
for (MemoryPoolMXBean mbean : mbeans) {
MemoryUsage memUsage = mbean.getUsage();
if (mbean.getName().equals(PERMGEN_MEMORY_POOL_NAME)) {
systemData[2] = memUsage.getMax();
}
}
}
return systemData;
}
public Map<String, String> getProperties() {
Map<String, String> map = new TreeMap<String, String>();
RuntimeMXBean runtimeMXBean = ManagementFactory.getRuntimeMXBean();
List<String> aList = runtimeMXBean.getInputArguments();
String parameters = "";
for (int i = 0; i < aList.size(); i++) {
parameters = parameters + " " + aList.get(i);
}
map.put("params", parameters);
map.put("name", runtimeMXBean.getVmName());
map.put("vendor", runtimeMXBean.getVmVendor());
map.put("version", runtimeMXBean.getVmVersion());
map.put("specification", runtimeMXBean.getSpecVersion());
map.put("uptime", DurationFormatUtils.formatDurationHMS(runtimeMXBean.getUptime()));
Date date = new Date(runtimeMXBean.getStartTime());
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
map.put("start time", sdf.format(date));
MemoryMXBean memory = ManagementFactory.getMemoryMXBean();
MemoryUsage heap = memory.getHeapMemoryUsage();
map.put(
"memory. (heap)",
readableFileSize(heap.getUsed())
+ "/"
+ readableFileSize(heap.getCommitted())
+ " min:"
+ readableFileSize(heap.getInit())
+ " max:"
+ readableFileSize(heap.getMax()));
MemoryUsage nonheap = memory.getNonHeapMemoryUsage();
map.put(
"memory (non heap)",
readableFileSize(nonheap.getUsed())
+ "/"
+ readableFileSize(nonheap.getCommitted())
+ " min:"
+ readableFileSize(nonheap.getInit())
+ " max:"
+ readableFileSize(nonheap.getMax()));
return map;
}
@Override
public long[] getSystemStatus() {
long[] systemData = new long[4];
MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
systemData[0] = memoryMXBean.getHeapMemoryUsage().getUsed();
systemData[1] = memoryMXBean.getNonHeapMemoryUsage().getUsed();
List<MemoryPoolMXBean> mbeans = ManagementFactory.getMemoryPoolMXBeans();
if (mbeans != null) {
for (MemoryPoolMXBean mbean : mbeans) {
MemoryUsage memUsage = mbean.getUsage();
if (mbean.getName().equals(PERMGEN_MEMORY_POOL_NAME)) {
systemData[2] = memUsage.getUsed();
}
}
}
ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
systemData[3] = threadMXBean.getThreadCount();
return systemData;
}