1 /* 2 * Copyright (c) 2003, 2014, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package com.sun.management; 27 28 import java.lang.management.MemoryUsage; 29 import javax.management.openmbean.CompositeData; 30 import javax.management.openmbean.CompositeDataView; 31 import javax.management.openmbean.CompositeType; 32 import java.util.Collection; 33 import java.util.Collections; 34 import java.util.HashMap; 35 import java.util.Map; 36 import java.util.List; 37 import sun.management.GcInfoCompositeData; 38 import sun.management.GcInfoBuilder; 39 40 /** 41 * Garbage collection information. It contains the following 42 * information for one garbage collection as well as GC-specific 43 * attributes: 44 * <blockquote> 45 * <ul> 46 * <li>Start time</li> 47 * <li>End time</li> 48 * <li>Duration</li> 49 * <li>Memory usage before the collection starts</li> 50 * <li>Memory usage after the collection ends</li> 51 * </ul> 52 * </blockquote> 53 * 54 * <p> 55 * <tt>GcInfo</tt> is a {@link CompositeData CompositeData} 56 * The GC-specific attributes can be obtained via the CompositeData 57 * interface. This is a historical relic, and other classes should 58 * not copy this pattern. Use {@link CompositeDataView} instead. 59 * 60 * <h4>MXBean Mapping</h4> 61 * <tt>GcInfo</tt> is mapped to a {@link CompositeData CompositeData} 62 * with attributes as specified in the {@link #from from} method. 63 * 64 * @author Mandy Chung 65 * @since 1.5 66 */ 67 @jdk.Exported 68 public class GcInfo implements CompositeData, CompositeDataView { 69 private final long index; 70 private final long startTime; 71 private final long endTime; 72 private final Map<String, MemoryUsage> usageBeforeGc; 73 private final Map<String, MemoryUsage> usageAfterGc; 74 private final Object[] extAttributes; 75 private final CompositeData cdata; 76 private final GcInfoBuilder builder; 77 78 private GcInfo(GcInfoBuilder builder, 79 long index, long startTime, long endTime, 80 MemoryUsage[] muBeforeGc, 81 MemoryUsage[] muAfterGc, 82 Object[] extAttributes) { 83 this.builder = builder; 84 this.index = index; 85 this.startTime = startTime; 86 this.endTime = endTime; 87 String[] poolNames = builder.getPoolNames(); 88 this.usageBeforeGc = new HashMap<String, MemoryUsage>(poolNames.length); 89 this.usageAfterGc = new HashMap<String, MemoryUsage>(poolNames.length); 90 for (int i = 0; i < poolNames.length; i++) { 91 this.usageBeforeGc.put(poolNames[i], muBeforeGc[i]); 92 this.usageAfterGc.put(poolNames[i], muAfterGc[i]); 93 } 94 this.extAttributes = extAttributes; 95 this.cdata = new GcInfoCompositeData(this, builder, extAttributes); 96 } 97 98 private GcInfo(CompositeData cd) { 99 GcInfoCompositeData.validateCompositeData(cd); 100 101 this.index = GcInfoCompositeData.getId(cd); 102 this.startTime = GcInfoCompositeData.getStartTime(cd); 103 this.endTime = GcInfoCompositeData.getEndTime(cd); 104 this.usageBeforeGc = GcInfoCompositeData.getMemoryUsageBeforeGc(cd); 105 this.usageAfterGc = GcInfoCompositeData.getMemoryUsageAfterGc(cd); 106 this.extAttributes = null; 107 this.builder = null; 108 this.cdata = cd; 109 } 110 111 /** 112 * Returns the identifier of this garbage collection which is 113 * the number of collections that this collector has done. 114 * 115 * @return the identifier of this garbage collection which is 116 * the number of collections that this collector has done. 117 */ 118 public long getId() { 119 return index; 120 } 121 122 /** 123 * Returns the start time of this GC in milliseconds 124 * since the Java virtual machine was started. 125 * 126 * @return the start time of this GC. 127 */ 128 public long getStartTime() { 129 return startTime; 130 } 131 132 /** 133 * Returns the end time of this GC in milliseconds 134 * since the Java virtual machine was started. 135 * 136 * @return the end time of this GC. 137 */ 138 public long getEndTime() { 139 return endTime; 140 } 141 142 /** 143 * Returns the elapsed time of this GC in milliseconds. 144 * 145 * @return the elapsed time of this GC in milliseconds. 146 */ 147 public long getDuration() { 148 return endTime - startTime; 149 } 150 151 /** 152 * Returns the memory usage of all memory pools 153 * at the beginning of this GC. 154 * This method returns 155 * a <tt>Map</tt> of the name of a memory pool 156 * to the memory usage of the corresponding 157 * memory pool before GC starts. 158 * 159 * @return a <tt>Map</tt> of memory pool names to the memory 160 * usage of a memory pool before GC starts. 161 */ 162 public Map<String, MemoryUsage> getMemoryUsageBeforeGc() { 163 return Collections.unmodifiableMap(usageBeforeGc); 164 } 165 166 /** 167 * Returns the memory usage of all memory pools 168 * at the end of this GC. 169 * This method returns 170 * a <tt>Map</tt> of the name of a memory pool 171 * to the memory usage of the corresponding 172 * memory pool when GC finishes. 173 * 174 * @return a <tt>Map</tt> of memory pool names to the memory 175 * usage of a memory pool when GC finishes. 176 */ 177 public Map<String, MemoryUsage> getMemoryUsageAfterGc() { 178 return Collections.unmodifiableMap(usageAfterGc); 179 } 180 181 /** 182 * Returns a <tt>GcInfo</tt> object represented by the 183 * given <tt>CompositeData</tt>. The given 184 * <tt>CompositeData</tt> must contain 185 * all the following attributes: 186 * 187 * <p> 188 * <blockquote> 189 * <table border> 190 * <tr> 191 * <th align=left>Attribute Name</th> 192 * <th align=left>Type</th> 193 * </tr> 194 * <tr> 195 * <td>index</td> 196 * <td><tt>java.lang.Long</tt></td> 197 * </tr> 198 * <tr> 199 * <td>startTime</td> 200 * <td><tt>java.lang.Long</tt></td> 201 * </tr> 202 * <tr> 203 * <td>endTime</td> 204 * <td><tt>java.lang.Long</tt></td> 205 * </tr> 206 * <tr> 207 * <td>memoryUsageBeforeGc</td> 208 * <td><tt>javax.management.openmbean.TabularData</tt></td> 209 * </tr> 210 * <tr> 211 * <td>memoryUsageAfterGc</td> 212 * <td><tt>javax.management.openmbean.TabularData</tt></td> 213 * </tr> 214 * </table> 215 * </blockquote> 216 * 217 * @throws IllegalArgumentException if <tt>cd</tt> does not 218 * represent a <tt>GcInfo</tt> object with the attributes 219 * described above. 220 * 221 * @return a <tt>GcInfo</tt> object represented by <tt>cd</tt> 222 * if <tt>cd</tt> is not <tt>null</tt>; <tt>null</tt> otherwise. 223 */ 224 public static GcInfo from(CompositeData cd) { 225 if (cd == null) { 226 return null; 227 } 228 229 if (cd instanceof GcInfoCompositeData) { 230 return ((GcInfoCompositeData) cd).getGcInfo(); 231 } else { 232 return new GcInfo(cd); 233 } 234 235 } 236 237 // Implementation of the CompositeData interface 238 public boolean containsKey(String key) { 239 return cdata.containsKey(key); 240 } 241 242 public boolean containsValue(Object value) { 243 return cdata.containsValue(value); 244 } 245 246 public boolean equals(Object obj) { 247 return cdata.equals(obj); 248 } 249 250 public Object get(String key) { 251 return cdata.get(key); 252 } 253 254 public Object[] getAll(String[] keys) { 255 return cdata.getAll(keys); 256 } 257 258 public CompositeType getCompositeType() { 259 return cdata.getCompositeType(); 260 } 261 262 public int hashCode() { 263 return cdata.hashCode(); 264 } 265 266 public String toString() { 267 return cdata.toString(); 268 } 269 270 public Collection<?> values() { 271 return cdata.values(); 272 } 273 274 /** 275 * <p>Return the {@code CompositeData} representation of this 276 * {@code GcInfo}, including any GC-specific attributes. The 277 * returned value will have at least all the attributes described 278 * in the {@link #from(CompositeData) from} method, plus optionally 279 * other attributes. 280 * 281 * @param ct the {@code CompositeType} that the caller expects. 282 * This parameter is ignored and can be null. 283 * 284 * @return the {@code CompositeData} representation. 285 */ 286 public CompositeData toCompositeData(CompositeType ct) { 287 return cdata; 288 } 289 }