/* * Copyright (c) 2004, 2007, 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.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * 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 sun.tools.jconsole; import java.awt.*;import java.io.*;import java.lang.management.*;import java.lang.reflect.*;import java.net.URL;import java.text.*;import java.util.*;import java.util.concurrent.*; import javax.swing.*;import javax.swing.event.*;import javax.swing.text.*; import static sun.tools.jconsole.Formatter.*;import static sun.tools.jconsole.Resources.*;import static sun.tools.jconsole.Utilities.*; @SuppressWarnings("serial")class SummaryTab extends Tab {    private static final String cpuUsageKey = "cpu";    private static final String cpuUsageName = getText("CPU Usage");    private static final String cpuUsageFormat = "CPUUsageFormat";     private static final String newDivider =   "<tr><td colspan=4><font size =-1><hr>";    private static final String newTable =     "<tr><td colspan=4 align=left><table cellpadding=1>";    private static final String newLeftTable = "<tr><td colspan=2 align=left><table cellpadding=1>";    private static final String newRightTable =  "<td colspan=2 align=left><table cellpadding=1>";    private static final String endTable = "</table>";     private static final int CPU_DECIMALS = 1;     private CPUOverviewPanel overviewPanel;    private DateFormat headerDateTimeFormat;    private String pathSeparator = null;    HTMLPane info;     private static class Result {        long upTime = -1L;        long processCpuTime = -1L;        long timeStamp;        int nCPUs;        String summary;    }     public static String getTabName() {        return Resources.getText("SummaryTab.tabName");    }     public SummaryTab(VMPanel vmPanel) {        super(vmPanel, getTabName());         setLayout(new BorderLayout());         info = new HTMLPane();        setAccessibleName(info, getTabName());        add(new JScrollPane(info));         headerDateTimeFormat =            getDateTimeFormat("SummaryTab.headerDateTimeFormat");    }     public SwingWorker<?, ?> newSwingWorker() {        return new SwingWorker<Result, Object>() {            public Result doInBackground() {                return formatSummary();            }              protected void done() {                try {                    Result result = get();                    if (result != null) {                        info.setText(result.summary);                        if (overviewPanel != null &&                            result.upTime > 0L &&                            result.processCpuTime >= 0L) {                             overviewPanel.updateCPUInfo(result);                        }                    }                } catch (InterruptedException ex) {                } catch (ExecutionException ex) {                    if (JConsole.isDebug()) {                        ex.printStackTrace();                    }                }            }        };    }     StringBuilder buf;     synchronized Result formatSummary() {        Result result = new Result();        ProxyClient proxyClient = vmPanel.getProxyClient();        if (proxyClient.isDead()) {            return null;        }         buf = new StringBuilder();        append("<table cellpadding=1>");         try {            RuntimeMXBean         rmBean     = proxyClient.getRuntimeMXBean();            CompilationMXBean     cmpMBean   = proxyClient.getCompilationMXBean();            ThreadMXBean          tmBean     = proxyClient.getThreadMXBean();            MemoryMXBean          memoryBean = proxyClient.getMemoryMXBean();            ClassLoadingMXBean    clMBean    = proxyClient.getClassLoadingMXBean();            OperatingSystemMXBean osMBean    = proxyClient.getOperatingSystemMXBean();            com.sun.management.OperatingSystemMXBean sunOSMBean  =               proxyClient.getSunOperatingSystemMXBean();             append("<tr><td colspan=4>");            append("<center><b>" + getText("SummaryTab.tabName") + "</b></center>");            String dateTime =                headerDateTimeFormat.format(System.currentTimeMillis());            append("<center>" + dateTime + "</center>");             append(newDivider);             {  // VM info                append(newLeftTable);                append("Connection name", vmPanel.getDisplayName());                append("Virtual Machine",                       getText("SummaryTab.vmVersion",                               rmBean.getVmName(), rmBean.getVmVersion()));                append("Vendor", rmBean.getVmVendor());                append("Name", rmBean.getName());                append(endTable);                 append(newRightTable);                result.upTime = rmBean.getUptime();                append("Uptime", formatTime(result.upTime));                if (sunOSMBean != null) {                    result.processCpuTime = sunOSMBean.getProcessCpuTime();                    append("Process CPU time", formatNanoTime(result.processCpuTime));                }                 if (cmpMBean != null) {                    append("JIT compiler", cmpMBean.getName());                    append("Total compile time",                           cmpMBean.isCompilationTimeMonitoringSupported()                                    ? formatTime(cmpMBean.getTotalCompilationTime())                                    : getText("Unavailable"));                } else {                    append("JIT compiler", getText("Unavailable"));                }                append(endTable);            }             append(newDivider);             {  // Threads and Classes                append(newLeftTable);                int tlCount = tmBean.getThreadCount();                int tdCount = tmBean.getDaemonThreadCount();                int tpCount = tmBean.getPeakThreadCount();                long ttCount = tmBean.getTotalStartedThreadCount();                String[] strings1 = formatLongs(tlCount, tpCount,                                                tdCount, ttCount);                append("Live Threads",          strings1[0]);                append("Peak",                  strings1[1]);                append("Daemon threads",        strings1[2]);                append("Total threads started", strings1[3]);                append(endTable);                 append(newRightTable);                long clCount = clMBean.getLoadedClassCount();                long cuCount = clMBean.getUnloadedClassCount();                long ctCount = clMBean.getTotalLoadedClassCount();                String[] strings2 = formatLongs(clCount, cuCount, ctCount);                append("Current classes loaded", strings2[0]);                append("Total classes loaded",   strings2[2]);                append("Total classes unloaded", strings2[1]);                append(null, "");                append(endTable);            }             append(newDivider);             {  // Memory                MemoryUsage u = memoryBean.getHeapMemoryUsage();                 append(newLeftTable);                String[] strings1 = formatKByteStrings(u.getUsed(), u.getMax());                append("Current heap size", strings1[0]);                append("Maximum heap size", strings1[1]);                append(endTable);                 append(newRightTable);                String[] strings2 = formatKByteStrings(u.getCommitted());                append("Committed memory",  strings2[0]);                append("SummaryTab.pendingFinalization.label",                       getText("SummaryTab.pendingFinalization.value",                               memoryBean.getObjectPendingFinalizationCount()));                append(endTable);                 append(newTable);                Collection<GarbageCollectorMXBean> garbageCollectors =                                            proxyClient.getGarbageCollectorMXBeans();                for (GarbageCollectorMXBean garbageCollectorMBean : garbageCollectors) {                    String gcName = garbageCollectorMBean.getName();                    long gcCount = garbageCollectorMBean.getCollectionCount();                    long gcTime = garbageCollectorMBean.getCollectionTime();                     append("Garbage collector",                           getText("GcInfo", gcName, gcCount,                                   (gcTime >= 0) ? formatTime(gcTime)                                                 : getText("Unavailable")),                           4);                }                append(endTable);            }             append(newDivider);             {  // Operating System info                append(newLeftTable);                String osName = osMBean.getName();                String osVersion = osMBean.getVersion();                String osArch = osMBean.getArch();                result.nCPUs = osMBean.getAvailableProcessors();                append("Operating System", osName + " " + osVersion);                append("Architecture", osArch);                append("Number of processors", result.nCPUs+"");                 if (pathSeparator == null) {                    // Must use separator of remote OS, not File.pathSeparator                    // from this local VM. In the future, consider using                    // RuntimeMXBean to get the remote system property.                    pathSeparator = osName.startsWith("Windows ") ? ";" : ":";                }                 if (sunOSMBean != null) {                    String[] kbStrings1 =                        formatKByteStrings(sunOSMBean.getCommittedVirtualMemorySize());                     String[] kbStrings2 =                        formatKByteStrings(sunOSMBean.getTotalPhysicalMemorySize(),                                           sunOSMBean.getFreePhysicalMemorySize(),                                           sunOSMBean.getTotalSwapSpaceSize(),                                           sunOSMBean.getFreeSwapSpaceSize());                     append("Committed virtual memory", kbStrings1[0]);                    append(endTable);                     append(newRightTable);                    append("Total physical memory", kbStrings2[0]);                    append("Free physical memory",  kbStrings2[1]);                    append("Total swap space",      kbStrings2[2]);                    append("Free swap space",       kbStrings2[3]);                }                 append(endTable);            }             append(newDivider);             {  // VM arguments and paths                append(newTable);                String args = "";                java.util.List<String> inputArguments = rmBean.getInputArguments();                for (String arg : inputArguments) {                    args += arg + " ";                }                append("VM arguments", args, 4);                append("Class path",   rmBean.getClassPath(), 4);                append("Library path", rmBean.getLibraryPath(), 4);                append("Boot class path",                       rmBean.isBootClassPathSupported()                                    ? rmBean.getBootClassPath()                                    : getText("Unavailable"),                       4);                append(endTable);            }        } catch (IOException e) {            if (JConsole.isDebug()) {                e.printStackTrace();            }            proxyClient.markAsDead();            return null;        } catch (UndeclaredThrowableException e) {            if (JConsole.isDebug()) {                e.printStackTrace();            }            proxyClient.markAsDead();            return null;        }         append("</table>");         result.timeStamp = System.currentTimeMillis();        result.summary = buf.toString();         return result;    }     private synchronized void append(String str) {        buf.append(str);    }     void append(String label, String value) {        append(newRow((label != null) ? getText(label) : label, value));    }     private void append(String label, String value, int columnPerRow) {        if (columnPerRow == 4 && pathSeparator != null) {            value = value.replace(pathSeparator,                                  "<b></b>" + pathSeparator);        }        append(newRow(getText(label), value, columnPerRow));    }     void append(String label1, String value1,                String label2, String value2) {        append(newRow(getText(label1), value1,                      getText(label2), value2));    }     OverviewPanel[] getOverviewPanels() {        if (overviewPanel == null) {            overviewPanel = new CPUOverviewPanel();        }        return new OverviewPanel[] { overviewPanel };    }     private static class CPUOverviewPanel extends OverviewPanel {        private long prevUpTime, prevProcessCpuTime;         CPUOverviewPanel() {            super(getText("CPU Usage"), cpuUsageKey, cpuUsageName, Plotter.Unit.PERCENT);            getPlotter().setDecimals(CPU_DECIMALS);        }         public void updateCPUInfo(Result result) {            if (prevUpTime > 0L && result.upTime > prevUpTime) {                // elapsedCpu is in ns and elapsedTime is in ms.                long elapsedCpu = result.processCpuTime - prevProcessCpuTime;                long elapsedTime = result.upTime - prevUpTime;                // cpuUsage could go higher than 100% because elapsedTime                // and elapsedCpu are not fetched simultaneously. Limit to                // 99% to avoid Plotter showing a scale from 0% to 200%.                float cpuUsage =                    Math.min(99F,                             elapsedCpu / (elapsedTime * 10000F * result.nCPUs));                 getPlotter().addValues(result.timeStamp,                                Math.round(cpuUsage * Math.pow(10.0, CPU_DECIMALS)));                getInfoLabel().setText(getText(cpuUsageFormat,                                               String.format("%."+CPU_DECIMALS+"f", cpuUsage)));            }            this.prevUpTime = result.upTime;            this.prevProcessCpuTime = result.processCpuTime;        }    }   }