Mercurial > hg > truffle
view agent/src/share/classes/sun/jvm/hotspot/utilities/AbstractHeapGraphWriter.java @ 13705:ac5b0f31f7a2
Truffle API-change: FrameDescriptors are now stored in the RootNode in a final field instead of the CallTarget.
author | Christian Humer <christian.humer@gmail.com> |
---|---|
date | Fri, 17 Jan 2014 17:06:08 +0100 |
parents | 8ef918538e22 |
children | de6a9e811145 |
line wrap: on
line source
/* * Copyright (c) 2004, 2012, 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. * * 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.jvm.hotspot.utilities; import java.io.*; import sun.jvm.hotspot.debugger.*; import sun.jvm.hotspot.memory.*; import sun.jvm.hotspot.oops.*; import sun.jvm.hotspot.runtime.*; /** * This is abstract base class for heap graph writers. This class does * not assume any file format for the heap graph. It hides heap * iteration, object (fields) iteration mechanism from derived * classes. This class does not even accept OutputStream etc. so that * derived class can construct specific writer/filter from input * stream. */ public abstract class AbstractHeapGraphWriter implements HeapGraphWriter { // the function iterates heap and calls Oop type specific writers protected void write() throws IOException { SymbolTable symTbl = VM.getVM().getSymbolTable(); javaLangClass = symTbl.probe("java/lang/Class"); javaLangString = symTbl.probe("java/lang/String"); javaLangThread = symTbl.probe("java/lang/Thread"); ObjectHeap heap = VM.getVM().getObjectHeap(); try { heap.iterate(new DefaultHeapVisitor() { public void prologue(long usedSize) { try { writeHeapHeader(); } catch (IOException exp) { throw new RuntimeException(exp); } } public boolean doObj(Oop oop) { try { writeHeapRecordPrologue(); if (oop instanceof TypeArray) { writePrimitiveArray((TypeArray)oop); } else if (oop instanceof ObjArray) { Klass klass = oop.getKlass(); ObjArrayKlass oak = (ObjArrayKlass) klass; Klass bottomType = oak.getBottomKlass(); if (bottomType instanceof InstanceKlass || bottomType instanceof TypeArrayKlass) { writeObjectArray((ObjArray)oop); } else { writeInternalObject(oop); } } else if (oop instanceof Instance) { Instance instance = (Instance) oop; Klass klass = instance.getKlass(); Symbol name = klass.getName(); if (name.equals(javaLangString)) { writeString(instance); } else if (name.equals(javaLangClass)) { writeClass(instance); } else if (name.equals(javaLangThread)) { writeThread(instance); } else { klass = klass.getSuper(); while (klass != null) { name = klass.getName(); if (name.equals(javaLangThread)) { writeThread(instance); return false; } klass = klass.getSuper(); } writeInstance(instance); } } else { // not-a-Java-visible oop writeInternalObject(oop); } writeHeapRecordEpilogue(); } catch (IOException exp) { throw new RuntimeException(exp); } return false; } public void epilogue() { try { writeHeapFooter(); } catch (IOException exp) { throw new RuntimeException(exp); } } }); // write JavaThreads writeJavaThreads(); // write JNI global handles writeGlobalJNIHandles(); } catch (RuntimeException re) { handleRuntimeException(re); } } protected void writeJavaThreads() throws IOException { Threads threads = VM.getVM().getThreads(); JavaThread jt = threads.first(); int index = 1; while (jt != null) { if (jt.getThreadObj() != null) { // Note that the thread serial number range is 1-to-N writeJavaThread(jt, index); index++; } jt = jt.next(); } } protected void writeJavaThread(JavaThread jt, int index) throws IOException { } protected void writeGlobalJNIHandles() throws IOException { JNIHandles handles = VM.getVM().getJNIHandles(); JNIHandleBlock blk = handles.globalHandles(); if (blk != null) { try { blk.oopsDo(new AddressVisitor() { public void visitAddress(Address handleAddr) { try { if (handleAddr != null) { writeGlobalJNIHandle(handleAddr); } } catch (IOException exp) { throw new RuntimeException(exp); } } public void visitCompOopAddress(Address handleAddr) { throw new RuntimeException("Should not reach here. JNIHandles are not compressed"); } }); } catch (RuntimeException re) { handleRuntimeException(re); } } } protected void writeGlobalJNIHandle(Address handleAddr) throws IOException { } protected void writeHeapHeader() throws IOException { } // write non-Java-visible (hotspot internal) object protected void writeInternalObject(Oop oop) throws IOException { } // write Java primitive array protected void writePrimitiveArray(TypeArray array) throws IOException { writeObject(array); } // write Java object array protected void writeObjectArray(ObjArray array) throws IOException { writeObject(array); } protected void writeInstance(Instance instance) throws IOException { writeObject(instance); } protected void writeString(Instance instance) throws IOException { writeInstance(instance); } protected void writeClass(Instance instance) throws IOException { writeInstance(instance); } protected void writeThread(Instance instance) throws IOException { writeInstance(instance); } protected void writeObject(Oop oop) throws IOException { writeObjectHeader(oop); writeObjectFields(oop); writeObjectFooter(oop); } protected void writeObjectHeader(Oop oop) throws IOException { } // write instance fields of given object protected void writeObjectFields(final Oop oop) throws IOException { try { oop.iterate(new DefaultOopVisitor() { public void doOop(OopField field, boolean isVMField) { try { writeReferenceField(oop, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doByte(ByteField field, boolean isVMField) { try { writeByteField(oop, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doChar(CharField field, boolean isVMField) { try { writeCharField(oop, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doBoolean(BooleanField field, boolean vField) { try { writeBooleanField(oop, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doShort(ShortField field, boolean isVMField) { try { writeShortField(oop, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doInt(IntField field, boolean isVMField) { try { writeIntField(oop, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doLong(LongField field, boolean isVMField) { try { writeLongField(oop, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doFloat(FloatField field, boolean isVMField) { try { writeFloatField(oop, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doDouble(DoubleField field, boolean vField) { try { writeDoubleField(oop, field); } catch (IOException exp) { throw new RuntimeException(exp); } } }, false); } catch (RuntimeException re) { handleRuntimeException(re); } } // write instance fields of given object protected void writeObjectFields(final InstanceKlass oop) throws IOException { try { oop.iterateStaticFields(new DefaultOopVisitor() { public void doOop(OopField field, boolean isVMField) { try { writeReferenceField(null, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doByte(ByteField field, boolean isVMField) { try { writeByteField(null, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doChar(CharField field, boolean isVMField) { try { writeCharField(null, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doBoolean(BooleanField field, boolean vField) { try { writeBooleanField(null, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doShort(ShortField field, boolean isVMField) { try { writeShortField(null, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doInt(IntField field, boolean isVMField) { try { writeIntField(null, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doLong(LongField field, boolean isVMField) { try { writeLongField(null, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doFloat(FloatField field, boolean isVMField) { try { writeFloatField(null, field); } catch (IOException exp) { throw new RuntimeException(exp); } } public void doDouble(DoubleField field, boolean vField) { try { writeDoubleField(null, field); } catch (IOException exp) { throw new RuntimeException(exp); } } }); } catch (RuntimeException re) { handleRuntimeException(re); } } // object field writers protected void writeReferenceField(Oop oop, OopField field) throws IOException { } protected void writeByteField(Oop oop, ByteField field) throws IOException { } protected void writeCharField(Oop oop, CharField field) throws IOException { } protected void writeBooleanField(Oop oop, BooleanField field) throws IOException { } protected void writeShortField(Oop oop, ShortField field) throws IOException { } protected void writeIntField(Oop oop, IntField field) throws IOException { } protected void writeLongField(Oop oop, LongField field) throws IOException { } protected void writeFloatField(Oop oop, FloatField field) throws IOException { } protected void writeDoubleField(Oop oop, DoubleField field) throws IOException { } protected void writeObjectFooter(Oop oop) throws IOException { } protected void writeHeapFooter() throws IOException { } protected void writeHeapRecordPrologue() throws IOException { } protected void writeHeapRecordEpilogue() throws IOException { } // HeapVisitor, OopVisitor methods can't throw any non-runtime // exception. But, derived class write methods (which are called // from visitor callbacks) may throw IOException. Hence, we throw // RuntimeException with origianal IOException as cause from the // visitor methods. This method gets back the original IOException // (if any) and re-throws the same. protected void handleRuntimeException(RuntimeException re) throws IOException { Throwable cause = re.getCause(); if (cause != null && cause instanceof IOException) { throw (IOException) cause; } else { // some other RuntimeException, just re-throw throw re; } } // whether a given oop is Java visible or hotspot internal? protected boolean isJavaVisible(Oop oop) { if (oop instanceof Instance || oop instanceof TypeArray) { return true; } else if (oop instanceof ObjArray) { ObjArrayKlass oak = (ObjArrayKlass) oop.getKlass(); Klass bottomKlass = oak.getBottomKlass(); return bottomKlass instanceof InstanceKlass || bottomKlass instanceof TypeArrayKlass; } else { return false; } } protected Symbol javaLangClass; protected Symbol javaLangString; protected Symbol javaLangThread; }