Mercurial > hg > truffle
view agent/src/share/classes/sun/jvm/hotspot/utilities/AbstractHeapGraphWriter.java @ 17716:cdb71841f4bc
6498581: ThreadInterruptTest3 produces wrong output on Windows
Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set.
Reviewed-by: acorn, kvn
Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com
author | minqi |
---|---|
date | Wed, 26 Feb 2014 15:20:41 -0800 |
parents | 55fb97c4c58d |
children | 4ca6dc0799b6 |
line wrap: on
line source
/* * Copyright (c) 2004, 2013, 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; }