Mercurial > hg > truffle
annotate agent/src/share/classes/sun/jvm/hotspot/runtime/PerfDataEntry.java @ 12226:7944aba7ba41
8015107: NPG: Use consistent naming for metaspace concepts
Reviewed-by: coleenp, mgerdin, hseigel
| author | ehelin |
|---|---|
| date | Mon, 12 Aug 2013 17:37:02 +0200 |
| parents | c18cbe5936b8 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
2 * Copyright (c) 2004, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 25 package sun.jvm.hotspot.runtime; | |
| 26 | |
| 27 import java.util.*; | |
| 28 import sun.jvm.hotspot.debugger.*; | |
| 29 import sun.jvm.hotspot.oops.*; | |
| 30 import sun.jvm.hotspot.types.*; | |
| 31 import sun.jvm.hotspot.utilities.*; | |
| 32 | |
| 33 public class PerfDataEntry extends VMObject { | |
| 34 private static JIntField entryLengthField; | |
| 35 private static JIntField nameOffsetField; | |
| 36 private static JIntField vectorLengthField; | |
| 37 private static JByteField dataTypeField; | |
| 38 private static JByteField flagsField; | |
| 39 private static JByteField dataUnitsField; | |
| 40 private static JByteField dataVariabilityField; | |
| 41 private static JIntField dataOffsetField; | |
| 42 | |
| 43 static { | |
| 44 VM.registerVMInitializedObserver(new Observer() { | |
| 45 public void update(Observable o, Object data) { | |
| 46 initialize(VM.getVM().getTypeDataBase()); | |
| 47 } | |
| 48 }); | |
| 49 } | |
| 50 | |
| 51 private static synchronized void initialize(TypeDataBase db) { | |
| 52 Type type = db.lookupType("PerfDataEntry"); | |
| 53 entryLengthField = type.getJIntField("entry_length"); | |
| 54 nameOffsetField = type.getJIntField("name_offset"); | |
| 55 vectorLengthField = type.getJIntField("vector_length"); | |
| 56 dataTypeField = type.getJByteField("data_type"); | |
| 57 flagsField = type.getJByteField("flags"); | |
| 58 dataUnitsField = type.getJByteField("data_units"); | |
| 59 dataVariabilityField = type.getJByteField("data_variability"); | |
| 60 dataOffsetField = type.getJIntField("data_offset"); | |
| 61 } | |
| 62 | |
| 63 public PerfDataEntry(Address addr) { | |
| 64 super(addr); | |
| 65 } | |
| 66 | |
| 67 // Accessors | |
| 68 | |
| 69 public int entryLength() { | |
| 70 return (int) entryLengthField.getValue(addr); | |
| 71 } | |
| 72 | |
| 73 public int nameOffset() { | |
| 74 return (int) nameOffsetField.getValue(addr); | |
| 75 } | |
| 76 | |
| 77 public int vectorLength() { | |
| 78 return (int) vectorLengthField.getValue(addr); | |
| 79 } | |
| 80 | |
| 81 // returns one of the constants in BasicType class | |
| 82 public int dataType() { | |
| 83 char ch = (char) (byte) dataTypeField.getValue(addr); | |
| 84 return BasicType.charToType(ch); | |
| 85 } | |
| 86 | |
| 87 public byte flags() { | |
| 88 return (byte) flagsField.getValue(addr); | |
| 89 } | |
| 90 | |
| 91 public boolean supported() { | |
| 92 return (flags() & 0x1) != 0; | |
| 93 } | |
| 94 | |
| 95 // NOTE: Keep this in sync with PerfData::Units enum in VM code | |
| 96 public interface PerfDataUnits { | |
| 97 public static final int U_None = 1; | |
| 98 public static final int U_Bytes = 2; | |
| 99 public static final int U_Ticks = 3; | |
| 100 public static final int U_Events = 4; | |
| 101 public static final int U_String = 5; | |
| 102 public static final int U_Hertz = 6; | |
| 103 } | |
| 104 | |
| 105 // returns one of the constants in PerfDataUnits | |
| 106 public int dataUnits() { | |
| 107 return (int) dataUnitsField.getValue(addr); | |
| 108 } | |
| 109 | |
| 110 // NOTE: Keep this in sync with PerfData::Variability enum in VM code | |
| 111 public interface PerfDataVariability { | |
| 112 public static final int V_Constant = 1; | |
| 113 public static final int V_Monotonic = 2; | |
| 114 public static final int V_Variable = 3; | |
| 115 } | |
| 116 | |
| 117 // returns one of the constants in PerfDataVariability | |
| 118 public int dataVariability() { | |
| 119 return (int) dataVariabilityField.getValue(addr); | |
| 120 } | |
| 121 | |
| 122 public int dataOffset() { | |
| 123 return (int) dataOffsetField.getValue(addr); | |
| 124 } | |
| 125 | |
| 126 public String name() { | |
| 127 int off = nameOffset(); | |
| 128 return CStringUtilities.getString(addr.addOffsetTo(off)); | |
| 129 } | |
| 130 | |
| 131 public boolean booleanValue() { | |
| 132 if (Assert.ASSERTS_ENABLED) { | |
| 133 Assert.that(vectorLength() == 0 && | |
| 134 dataType() == BasicType.tBoolean, "not a boolean"); | |
| 135 } | |
| 136 return addr.getJBooleanAt(dataOffset()); | |
| 137 } | |
| 138 | |
| 139 public char charValue() { | |
| 140 if (Assert.ASSERTS_ENABLED) { | |
| 141 Assert.that(vectorLength() == 0 && | |
| 142 dataType() == BasicType.tChar, "not a char"); | |
| 143 } | |
| 144 return addr.getJCharAt(dataOffset()); | |
| 145 } | |
| 146 | |
| 147 public byte byteValue() { | |
| 148 if (Assert.ASSERTS_ENABLED) { | |
| 149 Assert.that(vectorLength() == 0 && | |
| 150 dataType() == BasicType.tByte, "not a byte"); | |
| 151 } | |
| 152 return addr.getJByteAt(dataOffset()); | |
| 153 | |
| 154 } | |
| 155 | |
| 156 public short shortValue() { | |
| 157 if (Assert.ASSERTS_ENABLED) { | |
| 158 Assert.that(vectorLength() == 0 && | |
| 159 dataType() == BasicType.tShort, "not a short"); | |
| 160 } | |
| 161 return addr.getJShortAt(dataOffset()); | |
| 162 } | |
| 163 | |
| 164 public int intValue() { | |
| 165 if (Assert.ASSERTS_ENABLED) { | |
| 166 Assert.that(vectorLength() == 0 && | |
| 167 dataType() == BasicType.tInt, "not an int"); | |
| 168 } | |
| 169 return addr.getJIntAt(dataOffset()); | |
| 170 } | |
| 171 | |
| 172 public long longValue() { | |
| 173 if (Assert.ASSERTS_ENABLED) { | |
| 174 Assert.that(vectorLength() == 0 && | |
| 175 dataType() == BasicType.tLong, "not a long"); | |
| 176 } | |
| 177 return addr.getJLongAt(dataOffset()); | |
| 178 } | |
| 179 | |
| 180 public float floatValue() { | |
| 181 if (Assert.ASSERTS_ENABLED) { | |
| 182 Assert.that(vectorLength() == 0 && | |
| 183 dataType() == BasicType.tFloat, "not a float"); | |
| 184 } | |
| 185 return addr.getJFloatAt(dataOffset()); | |
| 186 } | |
| 187 | |
| 188 public double doubleValue() { | |
| 189 if (Assert.ASSERTS_ENABLED) { | |
| 190 Assert.that(vectorLength() == 0 && | |
| 191 dataType() == BasicType.tDouble, "not a double"); | |
| 192 } | |
| 193 return addr.getJDoubleAt(dataOffset()); | |
| 194 } | |
| 195 | |
| 196 public boolean[] booleanArrayValue() { | |
| 197 int len = vectorLength(); | |
| 198 if (Assert.ASSERTS_ENABLED) { | |
| 199 Assert.that(len > 0 && | |
| 200 dataType() == BasicType.tBoolean, "not a boolean vector"); | |
| 201 } | |
| 202 boolean[] res = new boolean[len]; | |
| 203 final int off = dataOffset(); | |
| 204 final long size = getHeap().getBooleanSize(); | |
| 205 for (int i = 0; i < len; i++) { | |
| 206 res[i] = addr.getJBooleanAt(off + i * size); | |
| 207 } | |
| 208 return res; | |
| 209 } | |
| 210 | |
| 211 public char[] charArrayValue() { | |
| 212 int len = vectorLength(); | |
| 213 if (Assert.ASSERTS_ENABLED) { | |
| 214 Assert.that(len > 0 && | |
| 215 dataType() == BasicType.tChar, "not a char vector"); | |
| 216 } | |
| 217 char[] res = new char[len]; | |
| 218 final int off = dataOffset(); | |
| 219 final long size = getHeap().getCharSize(); | |
| 220 for (int i = 0; i < len; i++) { | |
| 221 res[i] = addr.getJCharAt(off + i * size); | |
| 222 } | |
| 223 return res; | |
| 224 } | |
| 225 | |
| 226 public byte[] byteArrayValue() { | |
| 227 int len = vectorLength(); | |
| 228 if (Assert.ASSERTS_ENABLED) { | |
| 229 Assert.that(len > 0 && | |
| 230 dataType() == BasicType.tByte, "not a byte vector"); | |
| 231 } | |
| 232 byte[] res = new byte[len]; | |
| 233 final int off = dataOffset(); | |
| 234 final long size = getHeap().getByteSize(); | |
| 235 for (int i = 0; i < len; i++) { | |
| 236 res[i] = addr.getJByteAt(off + i * size); | |
| 237 } | |
| 238 return res; | |
| 239 } | |
| 240 | |
| 241 public short[] shortArrayValue() { | |
| 242 int len = vectorLength(); | |
| 243 if (Assert.ASSERTS_ENABLED) { | |
| 244 Assert.that(len > 0 && | |
| 245 dataType() == BasicType.tShort, "not a short vector"); | |
| 246 } | |
| 247 short[] res = new short[len]; | |
| 248 final int off = dataOffset(); | |
| 249 final long size = getHeap().getShortSize(); | |
| 250 for (int i = 0; i < len; i++) { | |
| 251 res[i] = addr.getJShortAt(off + i * size); | |
| 252 } | |
| 253 return res; | |
| 254 } | |
| 255 | |
| 256 public int[] intArrayValue() { | |
| 257 int len = vectorLength(); | |
| 258 if (Assert.ASSERTS_ENABLED) { | |
| 259 Assert.that(len > 0 && | |
| 260 dataType() == BasicType.tInt, "not an int vector"); | |
| 261 } | |
| 262 int[] res = new int[len]; | |
| 263 final int off = dataOffset(); | |
| 264 final long size = getHeap().getIntSize(); | |
| 265 for (int i = 0; i < len; i++) { | |
| 266 res[i] = addr.getJIntAt(off + i * size); | |
| 267 } | |
| 268 return res; | |
| 269 } | |
| 270 | |
| 271 public long[] longArrayValue() { | |
| 272 int len = vectorLength(); | |
| 273 if (Assert.ASSERTS_ENABLED) { | |
| 274 Assert.that(len > 0 && | |
| 275 dataType() == BasicType.tLong, "not a long vector"); | |
| 276 } | |
| 277 long[] res = new long[len]; | |
| 278 final int off = dataOffset(); | |
| 279 final long size = getHeap().getLongSize(); | |
| 280 for (int i = 0; i < len; i++) { | |
| 281 res[i] = addr.getJLongAt(off + i * size); | |
| 282 } | |
| 283 return res; | |
| 284 } | |
| 285 | |
| 286 public float[] floatArrayValue() { | |
| 287 int len = vectorLength(); | |
| 288 if (Assert.ASSERTS_ENABLED) { | |
| 289 Assert.that(len > 0 && | |
| 290 dataType() == BasicType.tFloat, "not a float vector"); | |
| 291 } | |
| 292 float[] res = new float[len]; | |
| 293 final int off = dataOffset(); | |
| 294 final long size = getHeap().getFloatSize(); | |
| 295 for (int i = 0; i < len; i++) { | |
| 296 res[i] = addr.getJFloatAt(off + i * size); | |
| 297 } | |
| 298 return res; | |
| 299 } | |
| 300 | |
| 301 public double[] doubleArrayValue() { | |
| 302 int len = vectorLength(); | |
| 303 if (Assert.ASSERTS_ENABLED) { | |
| 304 Assert.that(len > 0 && | |
| 305 dataType() == BasicType.tDouble, "not a double vector"); | |
| 306 } | |
| 307 double[] res = new double[len]; | |
| 308 final int off = dataOffset(); | |
| 309 final long size = getHeap().getDoubleSize(); | |
| 310 for (int i = 0; i < len; i++) { | |
| 311 res[i] = addr.getJDoubleAt(off + i * size); | |
| 312 } | |
| 313 return res; | |
| 314 } | |
| 315 | |
| 316 // value as String | |
| 317 public String valueAsString() { | |
| 318 int dataType = dataType(); | |
| 319 int len = vectorLength(); | |
| 320 String str = null; | |
| 321 if (len == 0) { // scalar | |
| 322 switch (dataType) { | |
| 323 case BasicType.tBoolean: | |
| 324 str = Boolean.toString(booleanValue()); | |
| 325 break; | |
| 326 case BasicType.tChar: | |
| 327 str = "'" + Character.toString(charValue()) + "'"; | |
| 328 break; | |
| 329 case BasicType.tByte: | |
| 330 str = Byte.toString(byteValue()); | |
| 331 break; | |
| 332 case BasicType.tShort: | |
| 333 str = Short.toString(shortValue()); | |
| 334 break; | |
| 335 case BasicType.tInt: | |
| 336 str = Integer.toString(intValue()); | |
| 337 break; | |
| 338 case BasicType.tLong: | |
| 339 str = Long.toString(longValue()); | |
| 340 break; | |
| 341 case BasicType.tFloat: | |
| 342 str = Float.toString(floatValue()); | |
| 343 break; | |
| 344 case BasicType.tDouble: | |
| 345 str = Double.toString(doubleValue()); | |
| 346 break; | |
| 347 default: | |
| 348 str = "<unknown scalar value>"; | |
| 349 break; | |
| 350 } | |
| 351 } else { // vector | |
| 352 switch (dataType) { | |
| 353 case BasicType.tBoolean: { | |
| 354 boolean[] res = booleanArrayValue(); | |
| 355 StringBuffer buf = new StringBuffer(); | |
| 356 buf.append('['); | |
| 357 for (int i = 0; i < res.length; i++) { | |
| 358 buf.append(Boolean.toString(res[i])); | |
| 359 buf.append(", "); | |
| 360 } | |
| 361 buf.append(']'); | |
| 362 str = buf.toString(); | |
| 363 break; | |
| 364 } | |
| 365 | |
| 366 case BasicType.tChar: { | |
| 367 // char[] is returned as a String | |
| 368 str = new String(charArrayValue()); | |
| 369 break; | |
| 370 } | |
| 371 | |
| 372 case BasicType.tByte: { | |
| 373 // byte[] is returned as a String | |
| 374 try { | |
| 375 str = new String(byteArrayValue(), "US-ASCII"); | |
| 376 } catch (java.io.UnsupportedEncodingException e) { | |
| 377 str = "can't decode string : " + e.getMessage(); | |
| 378 } | |
| 379 break; | |
| 380 } | |
| 381 | |
| 382 case BasicType.tShort: { | |
| 383 short[] res = shortArrayValue(); | |
| 384 StringBuffer buf = new StringBuffer(); | |
| 385 buf.append('['); | |
| 386 for (int i = 0; i < res.length; i++) { | |
| 387 buf.append(Short.toString(res[i])); | |
| 388 buf.append(", "); | |
| 389 } | |
| 390 buf.append(']'); | |
| 391 str = buf.toString(); | |
| 392 break; | |
| 393 } | |
| 394 | |
| 395 case BasicType.tInt: { | |
| 396 int[] res = intArrayValue(); | |
| 397 StringBuffer buf = new StringBuffer(); | |
| 398 buf.append('['); | |
| 399 for (int i = 0; i < res.length; i++) { | |
| 400 buf.append(Integer.toString(res[i])); | |
| 401 buf.append(", "); | |
| 402 } | |
| 403 buf.append(']'); | |
| 404 str = buf.toString(); | |
| 405 break; | |
| 406 } | |
| 407 | |
| 408 case BasicType.tLong: { | |
| 409 long[] res = longArrayValue(); | |
| 410 StringBuffer buf = new StringBuffer(); | |
| 411 buf.append('['); | |
| 412 for (int i = 0; i < res.length; i++) { | |
| 413 buf.append(Long.toString(res[i])); | |
| 414 buf.append(", "); | |
| 415 } | |
| 416 buf.append(']'); | |
| 417 str = buf.toString(); | |
| 418 break; | |
| 419 } | |
| 420 | |
| 421 case BasicType.tFloat: { | |
| 422 float[] res = floatArrayValue(); | |
| 423 StringBuffer buf = new StringBuffer(); | |
| 424 buf.append('['); | |
| 425 for (int i = 0; i < res.length; i++) { | |
| 426 buf.append(Float.toString(res[i])); | |
| 427 buf.append(", "); | |
| 428 } | |
| 429 buf.append(']'); | |
| 430 str = buf.toString(); | |
| 431 break; | |
| 432 } | |
| 433 | |
| 434 case BasicType.tDouble: { | |
| 435 double[] res = doubleArrayValue(); | |
| 436 StringBuffer buf = new StringBuffer(); | |
| 437 buf.append('['); | |
| 438 for (int i = 0; i < res.length; i++) { | |
| 439 buf.append(Double.toString(res[i])); | |
| 440 buf.append(", "); | |
| 441 } | |
| 442 buf.append(']'); | |
| 443 str = buf.toString(); | |
| 444 break; | |
| 445 } | |
| 446 | |
| 447 default: | |
| 448 str = "<unknown vector value>"; | |
| 449 break; | |
| 450 } | |
| 451 } | |
| 452 | |
| 453 // add units | |
| 454 switch (dataUnits()) { | |
| 455 case PerfDataUnits.U_None: | |
| 456 break; | |
| 457 case PerfDataUnits.U_Bytes: | |
| 458 str += " byte(s)"; | |
| 459 break; | |
| 460 case PerfDataUnits.U_Ticks: | |
| 461 str += " tick(s)"; | |
| 462 break; | |
| 463 case PerfDataUnits.U_Events: | |
| 464 str += " event(s)"; | |
| 465 break; | |
| 466 case PerfDataUnits.U_String: | |
| 467 break; | |
| 468 case PerfDataUnits.U_Hertz: | |
| 469 str += " Hz"; | |
| 470 break; | |
| 471 } | |
| 472 | |
| 473 return str; | |
| 474 } | |
| 475 | |
| 476 // -- Internals only below this point | |
| 477 private ObjectHeap getHeap() { | |
| 478 return VM.getVM().getObjectHeap(); | |
| 479 } | |
| 480 } |