Java Code Examples for java.lang.management.MemoryUsage

MemoryPoolStat(String name,
               long usageThreshold,
               MemoryUsage usage,
               long lastGcId,
               long lastGcStartTime,
               long lastGcEndTime,
               long collectThreshold,
               MemoryUsage beforeGcUsage,
               MemoryUsage afterGcUsage) {
    this.poolName = name;
    this.usageThreshold = usageThreshold;
    this.usage = usage;
    this.lastGcId = lastGcId;
    this.lastGcStartTime = lastGcStartTime;
    this.lastGcEndTime = lastGcEndTime;
    this.collectThreshold = collectThreshold;
    this.beforeGcUsage = beforeGcUsage;
    this.afterGcUsage = afterGcUsage;
}
 

/**
 *  Get young gen memory usage.
 *
 *  For G1 it is EdenUsage + SurvivorUsage,
 *  for other GCs it is EdenUsage + 2 * SurvivorUsage.
 *  For G1 max value is just LONG_MAX.
 *  For all GCs used value is 0.
 */
private static MemoryUsage getYoungGenUsage() {
    MemoryUsage edenUsage = HeapRegionUsageTool.getEdenUsage();
    MemoryUsage survivorUsage = HeapRegionUsageTool.getSurvivorUsage();
    long edenUsageInit = edenUsage.getInit();
    long edenUsageCommited = edenUsage.getCommitted();
    long survivorUsageInit = survivorUsage.getInit();
    long survivorUsageCommited = survivorUsage.getCommitted();

    if (YOUNG_GC_TYPE == GCTypes.YoungGCType.G1) {
        return new MemoryUsage(edenUsageInit + survivorUsageInit, 0,
                edenUsageCommited + survivorUsageCommited, Long.MAX_VALUE);
    } else {
        return new MemoryUsage(edenUsageInit + survivorUsageInit * 2, 0,
                edenUsageCommited + survivorUsageCommited * 2,
                edenUsage.getMax() + survivorUsage.getMax() * 2);
    }
}
 

private List<Object> eatMetaspace(float targetUsage) {
    List<Object> list = new ArrayList<>();
    MemoryPoolMXBean metaspacePool = getMatchedMemoryPool(".*Metaspace.*");
    float currentUsage;
    GeneratedClassProducer gp = new GeneratedClassProducer();
    do {
        try {
            list.add(gp.create(0));
        } catch (OutOfMemoryError oome) {
            list = null;
            throw new RuntimeException("Unexpected OOME '" + oome.getMessage() + "' while eating " + targetUsage + " of Metaspace.");
        }
        MemoryUsage memoryUsage = metaspacePool.getUsage();
        currentUsage = (((float) memoryUsage.getUsed()) / memoryUsage.getMax());
    } while (currentUsage < targetUsage);
    return list;
}
 

public static void status(Scanner scanner, Message message) {
    StringBuffer buffer = new StringBuffer();
    buffer.append("My Memory:\n\n");
    buffer.append("\n\n");
    for (MemPool pool : getPools()) {
        MemoryUsage usage = pool.getUsage();
        buffer.append(pool.getName()).append("\n");
        buffer.append("\tINIT:     ").append(FileUtils.byteCountToDisplaySize(usage.getInit()))
                .append("\n");
        buffer.append("\tUSED:     ").append(FileUtils.byteCountToDisplaySize(usage.getUsed()))
                .append("\n");
        buffer.append("\tCOMMITED: ")
                .append(FileUtils.byteCountToDisplaySize(usage.getCommitted())).append("\n");
        buffer.append("\tMAX:      ").append(FileUtils.byteCountToDisplaySize(usage.getMax()))
                .append("\n");
    }
    Speaker.sayCode(message.getChannel(), buffer.toString());
}
 

@Override
public Object next() {
  if (!beforeFirst) {
    throw new IllegalStateException();
  }
  beforeFirst = false;
  final MemoryInfo memoryInfo = new MemoryInfo();

  final DrillbitEndpoint endpoint = context.getIdentity();
  memoryInfo.hostname = endpoint.getAddress();
  memoryInfo.user_port = endpoint.getUserPort();

  final MemoryUsage heapMemoryUsage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
  memoryInfo.heap_current = heapMemoryUsage.getUsed();
  memoryInfo.heap_max = heapMemoryUsage.getMax();

  BufferPoolMXBean directBean = getDirectBean();
  memoryInfo.jvm_direct_current = directBean.getMemoryUsed();


  memoryInfo.direct_current = context.getDrillbitContext().getAllocator().getAllocatedMemory();
  memoryInfo.direct_max = TopLevelAllocator.MAXIMUM_DIRECT_MEMORY;
  return memoryInfo;
}
 

MemoryPoolStat(String name,
               long usageThreshold,
               MemoryUsage usage,
               long lastGcId,
               long lastGcStartTime,
               long lastGcEndTime,
               long collectThreshold,
               MemoryUsage beforeGcUsage,
               MemoryUsage afterGcUsage) {
    this.poolName = name;
    this.usageThreshold = usageThreshold;
    this.usage = usage;
    this.lastGcId = lastGcId;
    this.lastGcStartTime = lastGcStartTime;
    this.lastGcEndTime = lastGcEndTime;
    this.collectThreshold = collectThreshold;
    this.beforeGcUsage = beforeGcUsage;
    this.afterGcUsage = afterGcUsage;
}
 

private GcInfo(GcInfoBuilder builder,
               long index, long startTime, long endTime,
               MemoryUsage[] muBeforeGc,
               MemoryUsage[] muAfterGc,
               Object[] extAttributes) {
    this.builder       = builder;
    this.index         = index;
    this.startTime     = startTime;
    this.endTime       = endTime;
    String[] poolNames = builder.getPoolNames();
    this.usageBeforeGc = new HashMap<String, MemoryUsage>(poolNames.length);
    this.usageAfterGc = new HashMap<String, MemoryUsage>(poolNames.length);
    for (int i = 0; i < poolNames.length; i++) {
        this.usageBeforeGc.put(poolNames[i],  muBeforeGc[i]);
        this.usageAfterGc.put(poolNames[i],  muAfterGc[i]);
    }
    this.extAttributes = extAttributes;
    this.cdata = new GcInfoCompositeData(this, builder, extAttributes);
}
 

/**
 * Returns a summary information about the memory pools.
 */
public static String poolSummaries() {
    // Why ? list-archive?4273859
    // How ? http://stackoverflow.com/questions/697336/how-do-i-programmatically-find-out-my-permgen-space-usage
    //       http://stackoverflow.com/questions/8356416/xxmaxpermsize-with-or-without-xxpermsize
    StringBuilder sb = new StringBuilder();
    Iterator<MemoryPoolMXBean> iter =
            ManagementFactory.getMemoryPoolMXBeans().iterator();
    while (iter.hasNext()) {
        MemoryPoolMXBean item = iter.next();
        String name = item.getName();
        MemoryType type = item.getType();
        MemoryUsage usage = item.getUsage();
        MemoryUsage peak = item.getPeakUsage();
        MemoryUsage collections = item.getCollectionUsage();
        sb.append(String.format("Memory pool name: " + name
                                + ", type: " + type
                                + ", usage: " + usage
                                + ", peak: " + peak
                                + ", collections: " + collections
                                + "\n"));
    }
    return sb.toString();
}
 

@Override
public Object next() {
  if (!beforeFirst) {
    throw new IllegalStateException();
  }
  beforeFirst = false;
  final MemoryInfo memoryInfo = new MemoryInfo();

  final NodeEndpoint endpoint = dbContext.getEndpoint();
  memoryInfo.hostname = endpoint.getAddress();
  memoryInfo.fabric_port = endpoint.getFabricPort();

  final MemoryUsage heapMemoryUsage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
  memoryInfo.heap_current = heapMemoryUsage.getUsed();
  memoryInfo.heap_max = heapMemoryUsage.getMax();

  BufferPoolMXBean directBean = getDirectBean();
  memoryInfo.jvm_direct_current = directBean.getMemoryUsed();


  memoryInfo.direct_current = dbContext.getAllocator().getAllocatedMemory();
  memoryInfo.direct_max = SabotConfig.getMaxDirectMemory();
  return memoryInfo;
}
 

static void createNotification(String notifType,
                               String poolName,
                               MemoryUsage usage,
                               long count) {
    MemoryImpl mbean = (MemoryImpl) ManagementFactory.getMemoryMXBean();
    if (!mbean.hasListeners()) {
        // if no listener is registered.
        return;
    }
    long timestamp = System.currentTimeMillis();
    String msg = getNotifMsg(notifType);
    Notification notif = new Notification(notifType,
                                          mbean.getObjectName(),
                                          getNextSeqNumber(),
                                          timestamp,
                                          msg);
    MemoryNotificationInfo info =
        new MemoryNotificationInfo(poolName,
                                   usage,
                                   count);
    CompositeData cd =
        MemoryNotifInfoCompositeData.toCompositeData(info);
    notif.setUserData(cd);
    mbean.sendNotification(notif);
}
 

static void createNotification(String notifType,
                               String poolName,
                               MemoryUsage usage,
                               long count) {
    MemoryImpl mbean = (MemoryImpl) ManagementFactory.getMemoryMXBean();
    if (!mbean.hasListeners()) {
        // if no listener is registered.
        return;
    }
    long timestamp = System.currentTimeMillis();
    String msg = getNotifMsg(notifType);
    Notification notif = new Notification(notifType,
                                          mbean.getObjectName(),
                                          getNextSeqNumber(),
                                          timestamp,
                                          msg);
    MemoryNotificationInfo info =
        new MemoryNotificationInfo(poolName,
                                   usage,
                                   count);
    CompositeData cd =
        MemoryNotifInfoCompositeData.toCompositeData(info);
    notif.setUserData(cd);
    mbean.sendNotification(notif);
}
 

private final void test() {
    System.gc();
    MemoryUsagePrinter.printMemoryUsage("init");

    eat();
    MemoryUsagePrinter.printMemoryUsage("eaten");
    MemoryUsage muFull = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();

    free();
    MemoryUsagePrinter.printMemoryUsage("free");
    MemoryUsage muFree = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();

    assertLessThan(muFree.getCommitted(), muFull.getCommitted(), String.format(
            "committed free heap size is not less than committed full heap size, heap hasn't been shrunk?%n"
            + "%s = %s%n%s = %s",
            MIN_FREE_RATIO_FLAG_NAME,
            ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class)
                .getVMOption(MIN_FREE_RATIO_FLAG_NAME).getValue(),
            MAX_FREE_RATIO_FLAG_NAME,
            ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class)
                .getVMOption(MAX_FREE_RATIO_FLAG_NAME).getValue()
    ));
}
 

/**
 * @param c Configuration to use.
 * @param mu JMX Memory Bean
 * @return Returns L2 block cache instance (for now it is BucketCache BlockCache all the time)
 * or null if not supposed to be a L2.
 */
private static BlockCache getL2(final Configuration c, final MemoryUsage mu) {
  final boolean useExternal = c.getBoolean(EXTERNAL_BLOCKCACHE_KEY, EXTERNAL_BLOCKCACHE_DEFAULT);
  if (LOG.isDebugEnabled()) {
    LOG.debug("Trying to use " + (useExternal?" External":" Internal") + " l2 cache");
  }

  // If we want to use an external block cache then create that.
  if (useExternal) {
    return getExternalBlockcache(c);
  }

  // otherwise use the bucket cache.
  return getBucketCache(c, mu);

}
 

@Override
public String envi() {
    Map<String, String> result = new HashMap<String, String>();
    // 系统信息
    result.put(RegistryMonitorConstants.OSNAME, System.getProperty(RegistryMonitorConstants.OSNAME, "not specified"));
    result.put(RegistryMonitorConstants.JAVA_VERSION, System.getProperty(RegistryMonitorConstants.JAVA_VERSION, "not specified"));
    result.put(RegistryMonitorConstants.JDK_PATH, System.getProperty(RegistryMonitorConstants.JDK_PATH, "not specified"));
    result.put(RegistryMonitorConstants.APP_PATH, System.getProperty(RegistryMonitorConstants.APP_PATH, "not specified"));

    // jvm信息
    MemoryMXBean memorymbean = ManagementFactory.getMemoryMXBean();
    MemoryUsage usage = memorymbean.getHeapMemoryUsage();
    result.put(RegistryMonitorConstants.JVM_INIT, String.valueOf(usage.getInit()));
    result.put(RegistryMonitorConstants.JVM_MAX, String.valueOf(usage.getMax()));
    result.put(RegistryMonitorConstants.JVM_USED, String.valueOf(usage.getUsed()));
    
    //线程信息
    ThreadMXBean tm = (ThreadMXBean) ManagementFactory.getThreadMXBean();
    result.put(RegistryMonitorConstants.JVM_THREAD_COUNT, String.valueOf(tm.getThreadCount()));
    result.put(RegistryMonitorConstants.JVM_PEAKTHREAD_COUNT, String.valueOf(tm.getPeakThreadCount()));
    result.put(RegistryMonitorConstants.JVM_CURRENTTHREAD_CPUTIME, String.valueOf(tm.getCurrentThreadCpuTime()));
    result.put(RegistryMonitorConstants.JVM_CURRENTTHREAD_USERTIME, String.valueOf(tm.getCurrentThreadUserTime()));
    return JSON.toJSONString(result);
}
 

private final void test() {
    System.gc();
    MemoryUsagePrinter.printMemoryUsage("init");

    allocate();
    MemoryUsagePrinter.printMemoryUsage("allocated");
    MemoryUsage muFull = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();

    free();
    MemoryUsagePrinter.printMemoryUsage("free");
    MemoryUsage muFree = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();

    assertLessThan(muFree.getCommitted(), muFull.getCommitted(), String.format(
            "committed free heap size is not less than committed full heap size, heap hasn't been shrunk?%n"
            + "%s = %s%n%s = %s",
            MIN_FREE_RATIO_FLAG_NAME,
            ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class)
                .getVMOption(MIN_FREE_RATIO_FLAG_NAME).getValue(),
            MAX_FREE_RATIO_FLAG_NAME,
            ManagementFactory.getPlatformMXBean(HotSpotDiagnosticMXBean.class)
                .getVMOption(MAX_FREE_RATIO_FLAG_NAME).getValue()
    ));
}
 

public static Map<String, MemoryUsage>
        getMemoryUsageAfterGc(CompositeData cd) {
    try {
        TabularData td = (TabularData) cd.get(MEMORY_USAGE_AFTER_GC);
        //return (Map<String,MemoryUsage>)
        return cast(memoryUsageMapType.toJavaTypeData(td));
    } catch (InvalidObjectException | OpenDataException e) {
        // Should never reach here
        throw new AssertionError(e);
    }
}
 

static long calculateMaxSize(Set<GarbageCollectionEvent> events) {
    if (events.size() < 1) {
        return -1;
    }

    // Maximum pool size is fixed, so we should only need to get it from the first event
    MemoryUsage usage = events.iterator().next().getUsage();
    return usage.getMax();
}
 

public static Map<String, MemoryUsage>
        getMemoryUsageBeforeGc(CompositeData cd) {
    try {
        TabularData td = (TabularData) cd.get(MEMORY_USAGE_BEFORE_GC);
        return cast(memoryUsageMapType.toJavaTypeData(td));
    } catch (InvalidObjectException | OpenDataException e) {
        // Should never reach here
        throw new AssertionError(e);
    }
}
 

void triggerAction(MemoryUsage usage) {
    // create and send notification
    MemoryImpl.createNotification(MEMORY_THRESHOLD_EXCEEDED,
                                  pool.getName(),
                                  usage,
                                  getCount());
}
 

@Override
protected void chore() {
  // Sample heap occupancy
  MemoryUsage memUsage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
  heapOccupancyPercent = (float)memUsage.getUsed() / (float)memUsage.getCommitted();
  // If we are above the heap occupancy alarm low watermark, switch to short
  // sleeps for close monitoring. Stop autotuning, we are in a danger zone.
  if (heapOccupancyPercent >= heapOccupancyLowWatermark) {
    if (!alarming) {
      LOG.warn("heapOccupancyPercent " + heapOccupancyPercent +
        " is above heap occupancy alarm watermark (" + heapOccupancyLowWatermark + ")");
      alarming = true;
    }

    triggerNow();
    try {
      // Need to sleep ourselves since we've told the chore's sleeper
      // to skip the next sleep cycle.
      Thread.sleep(1000);
    } catch (InterruptedException e) {
      // Interrupted, propagate
      Thread.currentThread().interrupt();
    }
  } else {
    if (alarming) {
      LOG.info("heapOccupancyPercent " + heapOccupancyPercent +
        " is now below the heap occupancy alarm watermark (" +
        heapOccupancyLowWatermark + ")");
      alarming = false;
    }
  }
  // Autotune if tuning is enabled and allowed
  if (tunerOn && !alarming) {
    tune();
  }
}
 

/**
 * Returns the block cache or <code>null</code> in case none should be used.
 * Sets GLOBAL_BLOCK_CACHE_INSTANCE
 *
 * @param conf  The current configuration.
 * @return The block cache or <code>null</code>.
 */
public static synchronized BlockCache instantiateBlockCache(Configuration conf) {
  if (GLOBAL_BLOCK_CACHE_INSTANCE != null) return GLOBAL_BLOCK_CACHE_INSTANCE;
  if (blockCacheDisabled) return null;
  MemoryUsage mu = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
  LruBlockCache l1 = getL1(conf, mu);
  // blockCacheDisabled is set as a side-effect of getL1(), so check it again after the call.
  if (blockCacheDisabled) return null;
  BlockCache l2 = getL2(conf, mu);
  if (l2 == null) {
    GLOBAL_BLOCK_CACHE_INSTANCE = l1;
  } else {
    boolean useExternal = conf.getBoolean(EXTERNAL_BLOCKCACHE_KEY, EXTERNAL_BLOCKCACHE_DEFAULT);
    boolean combinedWithLru = conf.getBoolean(BUCKET_CACHE_COMBINED_KEY,
      DEFAULT_BUCKET_CACHE_COMBINED);
    if (useExternal) {
      GLOBAL_BLOCK_CACHE_INSTANCE = new InclusiveCombinedBlockCache(l1, l2);
    } else {
      if (combinedWithLru) {
        GLOBAL_BLOCK_CACHE_INSTANCE = new CombinedBlockCache(l1, l2);
      } else {
        // L1 and L2 are not 'combined'.  They are connected via the LruBlockCache victimhandler
        // mechanism.  It is a little ugly but works according to the following: when the
        // background eviction thread runs, blocks evicted from L1 will go to L2 AND when we get
        // a block from the L1 cache, if not in L1, we will search L2.
        GLOBAL_BLOCK_CACHE_INSTANCE = l1;
      }
    }
    l1.setVictimCache(l2);
  }
  return GLOBAL_BLOCK_CACHE_INSTANCE;
}
 

/**
 * Constructor accepts some system values and generates some Java values.
 *
 * @param rss Resident set size.
 */
Datum(long rss) {
    MemoryMXBean mmxb = ManagementFactory.getMemoryMXBean();
    MemoryUsage muheap = mmxb.getHeapMemoryUsage();
    MemoryUsage musys = mmxb.getNonHeapMemoryUsage();

    timestamp = System.currentTimeMillis();
    this.rss = rss;
    javatotalheapmem = muheap.getCommitted();
    javausedheapmem = muheap.getUsed();
    javatotalsysmem = musys.getCommitted();
    javausedsysmem = musys.getUsed();
}
 

private static void appendMemUsage(StringBuilder sb, Map<String, MemoryUsage> memUsage) {
    for(Map.Entry<String, MemoryUsage> entry: memUsage.entrySet()) {
        if (memRegions.get(entry.getKey()).isHeap()) {
            sb.append(entry.getKey()).append(" used=")
                    .append(entry.getValue().getUsed() >> 10)
                    .append("K; ");
        }
    }
}
 

private void getMemoryUsage(MetricsRecordBuilder rb) {
  MemoryUsage memNonHeap = memoryMXBean.getNonHeapMemoryUsage();
  MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
  Runtime runtime = Runtime.getRuntime();
  rb.addGauge(MemNonHeapUsedM, memNonHeap.getUsed() / M)
    .addGauge(MemNonHeapCommittedM, memNonHeap.getCommitted() / M)
    .addGauge(MemNonHeapMaxM, calculateMaxMemoryUsage(memNonHeap))
    .addGauge(MemHeapUsedM, memHeap.getUsed() / M)
    .addGauge(MemHeapCommittedM, memHeap.getCommitted() / M)
    .addGauge(MemHeapMaxM, calculateMaxMemoryUsage(memHeap))
    .addGauge(MemMaxM, runtime.maxMemory() / M);
}
 

public static void printMemoryUsage(String label) {
    MemoryUsage memusage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
    float freeratio = 1f - (float) memusage.getUsed() / memusage.getCommitted();
    System.out.format("[%-24s] init: %-7s, used: %-7s, comm: %-7s, freeRatio ~= %.1f%%%n",
            label,
            NF.format(memusage.getInit()),
            NF.format(memusage.getUsed()),
            NF.format(memusage.getCommitted()),
            freeratio * 100
    );
}
 

/**
 * Format contents of a MemoryUsage object.
 * @param name a text prefix used in formatting
 * @param usage the MemoryUsage object to format
 * @return the formatted contents
 */
private static String formatMemoryUsage(String name, MemoryUsage usage) {
    if (usage != null) {
        StringBuilder sb = new StringBuilder();
        sb.append(INDENT1 + name + " init: " + usage.getInit() + CRLF);
        sb.append(INDENT1 + name + " used: " + usage.getUsed() + CRLF);
        sb.append(INDENT1 + name + " committed: " + usage.getCommitted() + CRLF);
        sb.append(INDENT1 + name + " max: " + usage.getMax() + CRLF);
        return sb.toString();
    }
    return "";
}
 

public void run() {
	bContinue = true;
	
	try {
		while (bContinue) {
	        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
	        MemoryUsage memoryUsageHeap = memoryMXBean.getHeapMemoryUsage(); 
	        MemoryUsage memoryUsageNonHeap = memoryMXBean.getNonHeapMemoryUsage();
	        
	        setUsageCounter("[Memory] Heap memory usage", memoryUsageHeap);
	        setUsageCounter("[Memory] Non heap memory usage", memoryUsageNonHeap);
	        setUsageCounter("[Memory] Total used", (memoryUsageHeap.getUsed() + memoryUsageNonHeap.getUsed()) / 1024 + "K");
	        
			synchronized (usageCounters) {
				List<String> ls = new ArrayList<String>();
				ls.addAll(usageCounters.keySet());
				Collections.sort(ls);
				for (String counter : ls) {
					Engine.logUsageMonitor.info(counter + ": " + usageCounters.get(counter));
				}
			}
		
			Thread.sleep(30000);
		}
	} catch (NullPointerException npe) {
		if (Engine.theApp == null) {
			// Engine.theApp == null probably means the engine is getting stopped
			// so gracefully ignore and exit thread
			return;
		}
		else {
			npe.printStackTrace();
		}
	} catch (Exception e) {
		e.printStackTrace();
	}

	usageCounters = null;
}
 

/**
 * Constructor accepts some system values and generates some Java values.
 *
 * @param rss Resident set size.
 */
Datum(long rss) {
    MemoryMXBean mmxb = ManagementFactory.getMemoryMXBean();
    MemoryUsage muheap = mmxb.getHeapMemoryUsage();
    MemoryUsage musys = mmxb.getNonHeapMemoryUsage();

    timestamp = System.currentTimeMillis();
    this.rss = rss;
    javatotalheapmem = muheap.getCommitted();
    javausedheapmem = muheap.getUsed();
    javatotalsysmem = musys.getCommitted();
    javausedsysmem = musys.getUsed();
}
 

private static void verifyPSSurvivorRatio(int expectedRatio) {
    MemoryUsage edenUsage = HeapRegionUsageTool.getEdenUsage();
    MemoryUsage survivorUsage = HeapRegionUsageTool.getSurvivorUsage();

    long youngGenSize = edenUsage.getMax() + 2 * survivorUsage.getMax();
    // for Paralle GC Min/InitialSurvivorRatio = SurvivorRatio + 2
    long expectedSize = HeapRegionUsageTool.alignDown(youngGenSize / (expectedRatio + 2),
            wb.psHeapGenerationAlignment());

    if (expectedSize != survivorUsage.getCommitted()) {
        throw new RuntimeException("Expected survivor size is: " + expectedSize
                + ", but observed size is: " + survivorUsage.getCommitted());
    }
}
 

GcInfo getLastGcInfo() {
    MemoryUsage[] usageBeforeGC = new MemoryUsage[poolNames.length];
    MemoryUsage[] usageAfterGC = new MemoryUsage[poolNames.length];
    Object[] values = new Object[gcExtItemCount];

    return getLastGcInfo0(gc, gcExtItemCount, values, gcExtItemTypes,
                          usageBeforeGC, usageAfterGC);
}
 

public static void badTypeCompositeData() throws Exception {
    final int K = 1024;
    final Object[] values = {
        new Integer(5 * K),
        new Long(1 * K),
        new Long(10 * K),
        new Long(2 * K),
        "Dummy",
        "Dummy",
    };

    CompositeType muct =
        new CompositeType("MyMemoryUsageCompositeType",
                          "CompositeType for MemoryUsage",
                          memoryUsageItemNames,
                          memoryUsageItemNames,
                          badMUItemTypes);
    CompositeData cd =
       new CompositeDataSupport(muct,
                                memoryUsageItemNames,
                                values);
    try {
        MemoryUsage u = MemoryUsage.from(cd);
    } catch (IllegalArgumentException e) {
        System.out.println("Expected exception: " +
            e.getMessage());
        return;
    }
    throw new RuntimeException(
        "IllegalArgumentException not thrown");
}
 

@Override
public MemoryPool getHeapMemoryPool(final MemoryMXBean memoryBean) {
  return new MemoryPoolImpl(MemoryPool.Type.HEAP, new Supplier<MemoryUsage>() {
    @Override
    public MemoryUsage get() {
      return memoryBean.getHeapMemoryUsage();
    }
  });
}
 

public static Map<String, Long> readHeapUsage(MemoryUsage mu) {

        Map<String, Long> m = new LinkedHashMap<String, Long>();

        m.put("heap_use", mu.getUsed());
        m.put("heap_commit", mu.getCommitted());
        m.put("heap_max", mu.getMax());
        m.put("heap_init", mu.getInit());

        return m;
    }
 

/**
 * Triggers this sensor piggybacking a memory usage object.
 * This method sets this sensor on
 * and increments the count with the input <tt>increment</tt>.
 */
public void trigger(int increment, MemoryUsage usage) {
    synchronized (lock) {
        on = true;
        count += increment;
        // Do something here...
    }
    triggerAction(usage);
}
 

private MemoryUsage getMemoryUsage(MemoryType type) {
    if (type == MemoryType.HEAP) {
        return ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
    } else {
        return ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage();
    }
}
 

MemoryUsage getNonHeapMemoryUsage() {
    try {
        final Map<Object, Object> m = JvmContextFactory.getUserData();

        if (m != null) {
            final MemoryUsage cached = (MemoryUsage)
                m.get(nonHeapMemoryTag);
            if (cached != null) {
                log.debug("getNonHeapMemoryUsage",
                      "jvmMemory.getNonHeapMemoryUsage found in cache.");
                return cached;
            }

            final MemoryUsage u = getMemoryUsage(MemoryType.NON_HEAP);

            //  getNonHeapMemoryUsage() never returns null.
            //
            // if (u == null) u=MemoryUsage.INVALID;

            m.put(nonHeapMemoryTag,u);
            return u;
        }
        // Should never come here.
        // Log error!
        log.trace("getNonHeapMemoryUsage",
                  "ERROR: should never come here!");
        return getMemoryUsage(MemoryType.NON_HEAP);
    } catch (RuntimeException x) {
        log.trace("getNonHeapMemoryUsage",
              "Failed to get NonHeapMemoryUsage: " + x);
        log.debug("getNonHeapMemoryUsage",x);
        throw x;
    }

}
 

void printMemoryUsage() {
    if (options.verbose) {
        MemoryUsage memusage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
        float freeratio = 1f - (float) memusage.getUsed() / memusage.getCommitted();
        log.format(" [used: %-7s, comm: %-7s, freeRatio ~= %.1f%%]",
                        humanReadableByteCount(memusage.getUsed()),
                        humanReadableByteCount(memusage.getCommitted()),
                        freeratio * 100);
    }
}
 

private static void verifyG1SurvivorRatio(int expectedRatio) {
    MemoryUsage survivorUsage = HeapRegionUsageTool.getSurvivorUsage();

    int regionSize = wb.g1RegionSize();
    int youngListLength = (int) Math.max(NEW_SIZE / regionSize, 1);
    int expectedSurvivorRegions = (int) Math.ceil(youngListLength / (double) expectedRatio);
    int observedSurvivorRegions = (int) (survivorUsage.getCommitted() / regionSize);

    if (expectedSurvivorRegions < observedSurvivorRegions) {
        throw new RuntimeException("Expected amount of G1 survivor regions is "
                + expectedSurvivorRegions + ", but observed "
                + observedSurvivorRegions);
    }
}
 

public boolean isCollectionUsageThresholdExceeded() {
    if (!isCollectionUsageThresholdSupported()) {
        throw new UnsupportedOperationException(
            "CollectionUsage threshold is not supported");
    }

    // return false if usage threshold crossing checking is disabled
    if (collectionThreshold == 0) {
        return false;
    }

    MemoryUsage u = getCollectionUsage0();
    return (gcSensor.isOn() ||
            (u != null && u.getUsed() >= collectionThreshold));
}
 

public static Map<String, MemoryUsage>
        getMemoryUsageBeforeGc(CompositeData cd) {
    try {
        TabularData td = (TabularData) cd.get(MEMORY_USAGE_BEFORE_GC);
        return cast(memoryUsageMapType.toJavaTypeData(td));
    } catch (InvalidObjectException | OpenDataException e) {
        // Should never reach here
        throw new AssertionError(e);
    }
}
 

public static Map<String, MemoryUsage>
        getMemoryUsageBeforeGc(CompositeData cd) {
    try {
        TabularData td = (TabularData) cd.get(MEMORY_USAGE_BEFORE_GC);
        return cast(memoryUsageMapType.toJavaTypeData(td));
    } catch (InvalidObjectException | OpenDataException e) {
        // Should never reach here
        throw new AssertionError(e);
    }
}
 

public static Map<String, MemoryUsage>
        getMemoryUsageAfterGc(CompositeData cd) {
    try {
        TabularData td = (TabularData) cd.get(MEMORY_USAGE_AFTER_GC);
        //return (Map<String,MemoryUsage>)
        return cast(memoryUsageMapType.toJavaTypeData(td));
    } catch (InvalidObjectException | OpenDataException e) {
        // Should never reach here
        throw new AssertionError(e);
    }
}
 

public static Map<String, MemoryUsage>
        getMemoryUsageAfterGc(CompositeData cd) {
    try {
        TabularData td = (TabularData) cd.get(MEMORY_USAGE_AFTER_GC);
        //return (Map<String,MemoryUsage>)
        return cast(memoryUsageMapType.toJavaTypeData(td));
    } catch (InvalidObjectException | OpenDataException e) {
        // Should never reach here
        throw new AssertionError(e);
    }
}
 

/**
 * Format contents of a MemoryUsage object.
 * 
 * @param name
 *            a text prefix used in formatting
 * @param usage
 *            the MemoryUsage object to format
 * @return the formatted contents
 */
private static String formatMemoryUsage(String name, MemoryUsage usage) {
	if (usage != null) {
		StringBuilder sb = new StringBuilder();
		sb.append(INDENT1 + name + " init: " + usage.getInit() + CRLF);
		sb.append(INDENT1 + name + " used: " + usage.getUsed() + CRLF);
		sb.append(INDENT1 + name + " committed: " + usage.getCommitted() + CRLF);
		sb.append(INDENT1 + name + " max: " + usage.getMax() + CRLF);
		return sb.toString();
	}
	return "";
}
 

public static void printMemoryUsage(String label) {
    MemoryUsage memusage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
    float freeratio = 1f - (float) memusage.getUsed() / memusage.getCommitted();
    System.out.format("[%-24s] init: %-7s, used: %-7s, comm: %-7s, freeRatio ~= %.1f%%%n",
            label,
            NF.format(memusage.getInit()),
            NF.format(memusage.getUsed()),
            NF.format(memusage.getCommitted()),
            freeratio * 100
    );
}
 

public void setCollectionUsageThreshold(long newThreshold) {
    if (!isCollectionUsageThresholdSupported()) {
        throw new UnsupportedOperationException(
            "CollectionUsage threshold is not supported");
    }

    Util.checkControlAccess();

    MemoryUsage usage = getUsage0();
    if (newThreshold < 0) {
        throw new IllegalArgumentException(
            "Invalid threshold: " + newThreshold);
    }

    if (usage.getMax() != -1 && newThreshold > usage.getMax()) {
        throw new IllegalArgumentException(
            "Invalid threshold: " + newThreshold +
                 " > max (" + usage.getMax() + ").");
    }

    synchronized (this) {
        if (!gcSensorRegistered) {
            // pass the sensor to VM to begin monitoring
            gcSensorRegistered = true;
            setPoolCollectionSensor(gcSensor);
        }
        setCollectionThreshold0(collectionThreshold, newThreshold);
        this.collectionThreshold = newThreshold;
    }
}
 

public static void badNameCompositeData() throws Exception {
    final int K = 1024;
    final Object[] values = {
        new Long(5 * K),
        new Long(1 * K),
        new Long(10 * K),
        new Long(2 * K),
        "Dummy",
        "Dummy",
    };

    CompositeType muct =
        new CompositeType("MyMemoryUsageCompositeType",
                          "CompositeType for MemoryUsage",
                           badMUItemNames,
                           badMUItemNames,
                           memoryUsageItemTypes);
    CompositeData cd =
        new CompositeDataSupport(muct,
                                 badMUItemNames,
                                 values);
    try {
        MemoryUsage u = MemoryUsage.from(cd);
    } catch (IllegalArgumentException e) {
        System.out.println("Expected exception: " +
            e.getMessage());
        return;
    }
    throw new RuntimeException(
        "IllegalArgumentException not thrown");
}
 

protected void readHeapUsage(MonitorElementInstance instance) {

        MemoryUsage mu = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();

        instance.setValue("heap_use", mu.getUsed());
        instance.setValue("heap_commit", mu.getCommitted());
        instance.setValue("heap_max", mu.getMax());
        instance.setValue("heap_init", mu.getInit());
    }
 

private static void verifyMemoryPool(MemoryPoolMXBean pool, boolean isMaxDefined) {
    MemoryUsage mu = pool.getUsage();
    assertDefined(mu.getInit(), "init");
    assertDefined(mu.getUsed(), "used");
    assertDefined(mu.getCommitted(), "committed");

    if (isMaxDefined) {
        assertDefined(mu.getMax(), "max");
    } else {
        assertUndefined(mu.getMax(), "max");
    }
}
 

private void doMemoryUpdates() {
    MemoryMXBean memoryMXBean =
           ManagementFactory.getMemoryMXBean();
    MemoryUsage memNonHeap =
            memoryMXBean.getNonHeapMemoryUsage();
    MemoryUsage memHeap =
            memoryMXBean.getHeapMemoryUsage();
    Runtime runtime = Runtime.getRuntime();

    metrics.setMetric("memNonHeapUsedM", memNonHeap.getUsed()/M);
    metrics.setMetric("memNonHeapCommittedM", memNonHeap.getCommitted()/M);
    metrics.setMetric("memHeapUsedM", memHeap.getUsed()/M);
    metrics.setMetric("memHeapCommittedM", memHeap.getCommitted()/M);
    metrics.setMetric("maxMemoryM", runtime.maxMemory()/M);
}
 

private void getMemoryUsage(MetricsRecordBuilder rb) {
  MemoryUsage memNonHeap = memoryMXBean.getNonHeapMemoryUsage();
  MemoryUsage memHeap = memoryMXBean.getHeapMemoryUsage();
  Runtime runtime = Runtime.getRuntime();
  rb.addGauge(MemNonHeapUsedM, memNonHeap.getUsed() / M)
    .addGauge(MemNonHeapCommittedM, memNonHeap.getCommitted() / M)
    .addGauge(MemNonHeapMaxM, memNonHeap.getMax() / M)
    .addGauge(MemHeapUsedM, memHeap.getUsed() / M)
    .addGauge(MemHeapCommittedM, memHeap.getCommitted() / M)
    .addGauge(MemHeapMaxM, memHeap.getMax() / M)
    .addGauge(MemMaxM, runtime.maxMemory() / M);
}
 

private void test() throws InterruptedException {
    MemoryUsagePrinter.printMemoryUsage("init");

    allocate();
    System.gc();
    MemoryUsage muFull = getHeapMemoryUsage();
    MemoryUsagePrinter.printMemoryUsage("allocated");

    free();
    //Thread.sleep(1000); // sleep before measures due lags in JMX
    MemoryUsage muFree = getHeapMemoryUsage();
    MemoryUsagePrinter.printMemoryUsage("free");

    assertLessThan(muFree.getCommitted(), muFull.getCommitted(), prepareMessageCommittedIsNotLess() );
}
 

/**
 * Triggers this sensor piggybacking a memory usage object.
 * This method sets this sensor on
 * and increments the count with the input <tt>increment</tt>.
 */
public void trigger(int increment, MemoryUsage usage) {
    synchronized (lock) {
        on = true;
        count += increment;
        // Do something here...
    }
    triggerAction(usage);
}
 

/**
 * Get MemoryUsage from MemoryPoolMXBean which name matches passed string.
 *
 * @param name
 * @return MemoryUsage
 */
private static MemoryUsage getUsage(String name){
    for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) {
        if (pool.getName().matches(name)) {
            return pool.getUsage();
        }
    }
    return null;
}
 

MemoryUsage getNonHeapMemoryUsage() {
    try {
        final Map<Object, Object> m = JvmContextFactory.getUserData();

        if (m != null) {
            final MemoryUsage cached = (MemoryUsage)
                m.get(nonHeapMemoryTag);
            if (cached != null) {
                log.debug("getNonHeapMemoryUsage",
                      "jvmMemory.getNonHeapMemoryUsage found in cache.");
                return cached;
            }

            final MemoryUsage u = getMemoryUsage(MemoryType.NON_HEAP);

            //  getNonHeapMemoryUsage() never returns null.
            //
            // if (u == null) u=MemoryUsage.INVALID;

            m.put(nonHeapMemoryTag,u);
            return u;
        }
        // Should never come here.
        // Log error!
        log.trace("getNonHeapMemoryUsage",
                  "ERROR: should never come here!");
        return getMemoryUsage(MemoryType.NON_HEAP);
    } catch (RuntimeException x) {
        log.trace("getNonHeapMemoryUsage",
              "Failed to get NonHeapMemoryUsage: " + x);
        log.debug("getNonHeapMemoryUsage",x);
        throw x;
    }

}
 

void addMemoryPoolBean(final String poolName, final long max, final long usage) {
  final MemoryUsage memoryUsage = mock(MemoryUsage.class);
  doReturn(max).when(memoryUsage).getMax();
  doReturn(usage).when(memoryUsage).getUsed();

  final MemoryPoolMXBean bean = mock(MemoryPoolMXBean.class);
  doReturn(poolName).when(bean).getName();
  doReturn(memoryUsage).when(bean).getUsage();
  memoryPoolBeans.add(bean);
}
 

public void setUsageThreshold(long newThreshold) {
    if (!isUsageThresholdSupported()) {
        throw new UnsupportedOperationException(
            "Usage threshold is not supported");
    }

    Util.checkControlAccess();

    MemoryUsage usage = getUsage0();
    if (newThreshold < 0) {
        throw new IllegalArgumentException(
            "Invalid threshold: " + newThreshold);
    }

    if (usage.getMax() != -1 && newThreshold > usage.getMax()) {
        throw new IllegalArgumentException(
            "Invalid threshold: " + newThreshold +
            " must be <= maxSize." +
            " Committed = " + usage.getCommitted() +
            " Max = " + usage.getMax());
    }

    synchronized (this) {
        if (!usageSensorRegistered) {
            // pass the sensor to VM to begin monitoring
            usageSensorRegistered = true;
            setPoolUsageSensor(usageSensor);
        }
        setUsageThreshold0(usageThreshold, newThreshold);
        this.usageThreshold = newThreshold;
    }
}
 

public boolean isUsageThresholdExceeded() {
    if (!isUsageThresholdSupported()) {
        throw new UnsupportedOperationException(
            "Usage threshold is not supported");
    }

    // return false if usage threshold crossing checking is disabled
    if (usageThreshold == 0) {
        return false;
    }

    MemoryUsage u = getUsage0();
    return (u.getUsed() >= usageThreshold ||
            usageSensor.isOn());
}
 

public void setCollectionUsageThreshold(long newThreshold) {
    if (!isCollectionUsageThresholdSupported()) {
        throw new UnsupportedOperationException(
            "CollectionUsage threshold is not supported");
    }

    Util.checkControlAccess();

    MemoryUsage usage = getUsage0();
    if (newThreshold < 0) {
        throw new IllegalArgumentException(
            "Invalid threshold: " + newThreshold);
    }

    if (usage.getMax() != -1 && newThreshold > usage.getMax()) {
        throw new IllegalArgumentException(
            "Invalid threshold: " + newThreshold +
                 " > max (" + usage.getMax() + ").");
    }

    synchronized (this) {
        if (!gcSensorRegistered) {
            // pass the sensor to VM to begin monitoring
            gcSensorRegistered = true;
            setPoolCollectionSensor(gcSensor);
        }
        setCollectionThreshold0(collectionThreshold, newThreshold);
        this.collectionThreshold = newThreshold;
    }
}
 

public GarbageCollectionEvent(long timestamp, MemoryUsage usage, long count) {
    this.timestamp = timestamp;
    this.usage = usage;
    this.count = count;
}