Java tutorial
// Copyright 2014 The Bazel Authors. All rights reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package com.google.devtools.build.lib.util; import static java.nio.charset.StandardCharsets.US_ASCII; import com.google.common.base.CharMatcher; import com.google.common.base.Splitter; import com.google.common.collect.Iterables; import com.google.common.io.Files; import com.sun.management.OperatingSystemMXBean; import java.io.File; import java.io.IOException; import java.lang.management.ManagementFactory; import java.lang.management.MemoryMXBean; import java.util.Iterator; /** * Provides methods to measure the current resource usage of the current * process. Also provides some convenience methods to obtain several system * characteristics, like number of processors , total memory, etc. */ public final class ResourceUsage { /* * Use com.sun.management.OperatingSystemMXBean instead of * java.lang.management.OperatingSystemMXBean because the latter does not * support getTotalPhysicalMemorySize() and getFreePhysicalMemorySize(). */ private static final OperatingSystemMXBean OS_BEAN = (OperatingSystemMXBean) ManagementFactory .getOperatingSystemMXBean(); private static final MemoryMXBean MEM_BEAN = ManagementFactory.getMemoryMXBean(); private static final Splitter WHITESPACE_SPLITTER = Splitter.on(CharMatcher.whitespace()); /** * Calculates an estimate of the current total CPU usage and the CPU usage of * the process in percent measured from the two given measurements. The * returned CPU usages rea average values for the time between the two * measurements. The returned array contains the total CPU usage at index 0 * and the CPU usage of the measured process at index 1. */ public static float[] calculateCurrentCpuUsage(Measurement oldMeasurement, Measurement newMeasurement) { if (oldMeasurement == null) { return new float[2]; } long idleJiffies = newMeasurement.getTotalCpuIdleTimeInJiffies() - oldMeasurement.getTotalCpuIdleTimeInJiffies(); long oldProcessJiffies = oldMeasurement.getCpuUtilizationInJiffies()[0] + oldMeasurement.getCpuUtilizationInJiffies()[1]; long newProcessJiffies = newMeasurement.getCpuUtilizationInJiffies()[0] + newMeasurement.getCpuUtilizationInJiffies()[1]; long processJiffies = newProcessJiffies - oldProcessJiffies; long elapsedTimeJiffies = newMeasurement.getTimeInJiffies() - oldMeasurement.getTimeInJiffies(); int processors = getAvailableProcessors(); // TODO(bazel-team): Sometimes smaller then zero. Not sure why. double totalUsage = Math.max(0, 1.0D - (double) idleJiffies / elapsedTimeJiffies / processors); double usage = Math.max(0, (double) processJiffies / elapsedTimeJiffies / processors); return new float[] { (float) totalUsage * 100, (float) usage * 100 }; } private ResourceUsage() { } /** * Returns the number of processors available to the Java virtual machine. */ public static int getAvailableProcessors() { return OS_BEAN.getAvailableProcessors(); } /** * Returns the total physical memory in bytes. */ public static long getTotalPhysicalMemorySize() { return OS_BEAN.getTotalPhysicalMemorySize(); } /** * Returns the operating system architecture. */ public static String getOsArchitecture() { return OS_BEAN.getArch(); } /** * Returns the operating system name. */ public static String getOsName() { return OS_BEAN.getName(); } /** * Returns the operating system version. */ public static String getOsVersion() { return OS_BEAN.getVersion(); } /** * Returns the initial size of heap memory in bytes. * * @see MemoryMXBean#getHeapMemoryUsage() */ public static long getHeapMemoryInit() { return MEM_BEAN.getHeapMemoryUsage().getInit(); } /** * Returns the initial size of non heap memory in bytes. * * @see MemoryMXBean#getNonHeapMemoryUsage() */ public static long getNonHeapMemoryInit() { return MEM_BEAN.getNonHeapMemoryUsage().getInit(); } /** * Returns the maximum size of heap memory in bytes. * * @see MemoryMXBean#getHeapMemoryUsage() */ public static long getHeapMemoryMax() { return MEM_BEAN.getHeapMemoryUsage().getMax(); } /** * Returns the maximum size of non heap memory in bytes. * * @see MemoryMXBean#getNonHeapMemoryUsage() */ public static long getNonHeapMemoryMax() { return MEM_BEAN.getNonHeapMemoryUsage().getMax(); } /** * Returns a measurement of the current resource usage of the current process. */ public static Measurement measureCurrentResourceUsage() { return measureCurrentResourceUsage("self"); } /** * Returns a measurement of the current resource usage of the process with the * given process id. * * @param processId the process id or <code>self</code> for the current * process. */ public static Measurement measureCurrentResourceUsage(String processId) { return new Measurement(MEM_BEAN.getHeapMemoryUsage().getUsed(), MEM_BEAN.getHeapMemoryUsage().getCommitted(), MEM_BEAN.getNonHeapMemoryUsage().getUsed(), MEM_BEAN.getNonHeapMemoryUsage().getCommitted(), (float) OS_BEAN.getSystemLoadAverage(), OS_BEAN.getFreePhysicalMemorySize(), getCurrentTotalIdleTimeInJiffies(), getCurrentCpuUtilizationInJiffies(processId)); } /** * Returns the current total idle time of the processors since system boot. * Reads /proc/stat to obtain this information. */ private static long getCurrentTotalIdleTimeInJiffies() { try { File file = new File("/proc/stat"); String content = Files.toString(file, US_ASCII); String value = Iterables.get(WHITESPACE_SPLITTER.split(content), 5); return Long.parseLong(value); } catch (NumberFormatException | IOException e) { return 0L; } } /** * Returns the current cpu utilization of the current process with the given * id in jiffies. The returned array contains the following information: The * 1st entry is the number of jiffies that the process has executed in user * mode, and the 2nd entry is the number of jiffies that the process has * executed in kernel mode. Reads /proc/self/stat to obtain this information. * * @param processId the process id or <code>self</code> for the current * process. */ private static long[] getCurrentCpuUtilizationInJiffies(String processId) { try { File file = new File("/proc/" + processId + "/stat"); if (file.isDirectory()) { return new long[2]; } Iterator<String> stat = WHITESPACE_SPLITTER.split(Files.toString(file, US_ASCII)).iterator(); for (int i = 0; i < 13; ++i) { stat.next(); } long token13 = Long.parseLong(stat.next()); long token14 = Long.parseLong(stat.next()); return new long[] { token13, token14 }; } catch (NumberFormatException | IOException e) { return new long[2]; } } /** * A snapshot of the resource usage of the current process at a point in time. */ public static class Measurement { private final long timeInNanos; private final long heapMemoryUsed; private final long heapMemoryCommitted; private final long nonHeapMemoryUsed; private final long nonHeapMemoryCommitted; private final float loadAverageLastMinute; private final long freePhysicalMemory; private final long totalCpuIdleTimeInJiffies; private final long[] cpuUtilizationInJiffies; public Measurement(long heapMemoryUsed, long heapMemoryCommitted, long nonHeapMemoryUsed, long nonHeapMemoryCommitted, float loadAverageLastMinute, long freePhysicalMemory, long totalCpuIdleTimeInJiffies, long[] cpuUtilizationInJiffies) { super(); timeInNanos = System.nanoTime(); this.heapMemoryUsed = heapMemoryUsed; this.heapMemoryCommitted = heapMemoryCommitted; this.nonHeapMemoryUsed = nonHeapMemoryUsed; this.nonHeapMemoryCommitted = nonHeapMemoryCommitted; this.loadAverageLastMinute = loadAverageLastMinute; this.freePhysicalMemory = freePhysicalMemory; this.totalCpuIdleTimeInJiffies = totalCpuIdleTimeInJiffies; this.cpuUtilizationInJiffies = cpuUtilizationInJiffies; } /** * Returns the time of the measurement in jiffies. */ public long getTimeInJiffies() { return timeInNanos / 10000000; } /** * Returns the time of the measurement in ms. */ public long getTimeInMs() { return timeInNanos / 1000000; } /** * Returns the amount of used heap memory in bytes at the time of * measurement. * * @see MemoryMXBean#getHeapMemoryUsage() */ public long getHeapMemoryUsed() { return heapMemoryUsed; } /** * Returns the amount of used non heap memory in bytes at the time of * measurement. * * @see MemoryMXBean#getNonHeapMemoryUsage() */ public long getHeapMemoryCommitted() { return heapMemoryCommitted; } /** * Returns the amount of memory in bytes that is committed for the Java * virtual machine to use for the heap at the time of measurement. * * @see MemoryMXBean#getHeapMemoryUsage() */ public long getNonHeapMemoryUsed() { return nonHeapMemoryUsed; } /** * Returns the amount of memory in bytes that is committed for the Java * virtual machine to use for non heap memory at the time of measurement. * * @see MemoryMXBean#getNonHeapMemoryUsage() */ public long getNonHeapMemoryCommitted() { return nonHeapMemoryCommitted; } /** * Returns the system load average for the last minute at the time of * measurement. * * @see OperatingSystemMXBean#getSystemLoadAverage() */ public float getLoadAverageLastMinute() { return loadAverageLastMinute; } /** * Returns the free physical memmory in bytes at the time of measurement. */ public long getFreePhysicalMemory() { return freePhysicalMemory; } /** * Returns the current total cpu idle since system boot in jiffies. */ public long getTotalCpuIdleTimeInJiffies() { return totalCpuIdleTimeInJiffies; } /** * Returns the current cpu utilization of the current process in jiffies. * The returned array contains the following information: The 1st entry is * the number of jiffies that the process has executed in user mode, and the * 2nd entry is the number of jiffies that the process has executed in * kernel mode. Reads /proc/self/stat to obtain this information. */ public long[] getCpuUtilizationInJiffies() { return cpuUtilizationInJiffies; } /** * Returns the current cpu utilization of the current process in ms. The * returned array contains the following information: The 1st entry is the * number of ms that the process has executed in user mode, and the 2nd * entry is the number of ms that the process has executed in kernel mode. * Reads /proc/self/stat to obtain this information. */ public long[] getCpuUtilizationInMs() { return new long[] { cpuUtilizationInJiffies[0] * 10, cpuUtilizationInJiffies[1] * 10 }; } } }