Mercurial > hg > truffle
diff agent/src/share/classes/sun/jvm/hotspot/utilities/soql/JSJavaHeap.java @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | c18cbe5936b8 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/agent/src/share/classes/sun/jvm/hotspot/utilities/soql/JSJavaHeap.java Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,263 @@ +/* + * Copyright 2004-2007 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package sun.jvm.hotspot.utilities.soql; + +import java.util.*; +import javax.script.ScriptException; +import sun.jvm.hotspot.debugger.*; +import sun.jvm.hotspot.memory.*; +import sun.jvm.hotspot.oops.*; +import sun.jvm.hotspot.runtime.*; +import sun.jvm.hotspot.utilities.*; +import java.lang.reflect.Method; + +public class JSJavaHeap extends DefaultScriptObject { + private static final int FIELD_CAPACITY = 0; + private static final int FIELD_USED = 1; + private static final int FIELD_FOR_EACH_OBJECT = 2; + private static final int FIELD_FOR_EACH_CLASS = 3; + + private static final int FIELD_UNDEFINED = -1; + + public JSJavaHeap(JSJavaFactory fac) { + this.factory = fac; + } + + public Object get(String name) { + int fieldID = getFieldID(name); + switch (fieldID) { + case FIELD_CAPACITY: + return new Long(getCapacity()); + case FIELD_USED: + return new Long(getUsed()); + case FIELD_FOR_EACH_OBJECT: + return new MethodCallable(this, forEachObjectMethod); + case FIELD_FOR_EACH_CLASS: + return new MethodCallable(this, forEachClassMethod); + case FIELD_UNDEFINED: + default: + return super.get(name); + } + } + + public Object[] getIds() { + Object[] superIds = super.getIds(); + Object[] tmp = fields.keySet().toArray(); + Object[] res = new Object[superIds.length + tmp.length]; + System.arraycopy(tmp, 0, res, 0, tmp.length); + System.arraycopy(superIds, 0, res, tmp.length, superIds.length); + return res; + } + + public boolean has(String name) { + if (getFieldID(name) != FIELD_UNDEFINED) { + return true; + } else { + return super.has(name); + } + } + + public void put(String name, Object value) { + if (getFieldID(name) == FIELD_UNDEFINED) { + super.put(name, value); + } + } + + public void forEachObject(Object[] args) { + boolean subtypes = true; + Klass kls = null; + Callable func = null; + switch (args.length) { + case 3: { + Object b = args[2]; + if (b != null && b instanceof Boolean) { + subtypes = ((Boolean)b).booleanValue(); + } + } + case 2: { + Object k = args[1]; + if (k == null) return; + if (k instanceof JSJavaKlass) { + kls = ((JSJavaKlass)k).getKlass(); + } else if (k instanceof String) { + kls = SystemDictionaryHelper.findInstanceKlass((String)k); + if (kls == null) return; + } + } + case 1: { + Object f = args[0]; + if (f != null && f instanceof Callable) { + func = (Callable) f; + } else { + // unknown target - just return + return ; + } + } + break; + + default: + return; + } + + final Callable finalFunc = func; + HeapVisitor visitor = new DefaultHeapVisitor() { + public boolean doObj(Oop oop) { + JSJavaObject jo = factory.newJSJavaObject(oop); + if (jo != null) { + try { + finalFunc.call(new Object[] { jo }); + } catch (ScriptException exp) { + throw new RuntimeException(exp); + } + } + return false; + } + }; + ObjectHeap heap = VM.getVM().getObjectHeap(); + if (kls == null) { + kls = SystemDictionaryHelper.findInstanceKlass("java.lang.Object"); + } + heap.iterateObjectsOfKlass(visitor, kls, subtypes); + } + + public void forEachClass(Object[] args) { + boolean withLoader = false; + Callable func = null; + switch (args.length) { + case 2: { + Object b = args[1]; + if (b instanceof Boolean) { + withLoader = ((Boolean)b).booleanValue(); + } + } + case 1: { + Object f = args[0]; + if (f instanceof Callable) { + func = (Callable) f; + } else { + return; + } + } + break; + default: + return; + } + + final Callable finalFunc = func; + SystemDictionary sysDict = VM.getVM().getSystemDictionary(); + if (withLoader) { + sysDict.classesDo(new SystemDictionary.ClassAndLoaderVisitor() { + public void visit(Klass kls, Oop loader) { + JSJavaKlass jk = factory.newJSJavaKlass(kls); + if (jk == null) { + return; + } + JSJavaObject k = jk.getJSJavaClass(); + JSJavaObject l = factory.newJSJavaObject(loader); + if (k != null) { + if (k != null) { + try { + finalFunc.call(new Object[] { k, l }); + } catch (ScriptException exp) { + throw new RuntimeException(exp); + } + } + } + } + }); + + } else { + sysDict.classesDo(new SystemDictionary.ClassVisitor() { + public void visit(Klass kls) { + JSJavaKlass jk = factory.newJSJavaKlass(kls); + if (jk == null) { + return; + } + JSJavaClass k = jk.getJSJavaClass(); + if (k != null) { + if (k != null) { + try { + finalFunc.call(new Object[] { k }); + } catch (ScriptException exp) { + throw new RuntimeException(exp); + } + } + } + } + }); + } + } + + public String toString() { + StringBuffer buf = new StringBuffer(); + buf.append("Java Heap (capacity="); + buf.append(getCapacity()); + buf.append(", used="); + buf.append(getUsed()); + buf.append(")"); + return buf.toString(); + } + + //-- Internals only below this point + private static Map fields = new HashMap(); + private static void addField(String name, int fieldId) { + fields.put(name, new Integer(fieldId)); + } + + private static int getFieldID(String name) { + Integer res = (Integer) fields.get(name); + return (res != null)? res.intValue() : FIELD_UNDEFINED; + } + + static { + addField("capacity", FIELD_CAPACITY); + addField("used", FIELD_USED); + addField("forEachObject", FIELD_FOR_EACH_OBJECT); + addField("forEachClass", FIELD_FOR_EACH_CLASS); + try { + Class myClass = JSJavaHeap.class; + forEachObjectMethod = myClass.getMethod("forEachObject", + new Class[] { Object[].class }); + forEachClassMethod = myClass.getMethod("forEachClass", + new Class[] {Object[].class }); + } catch (RuntimeException re) { + throw re; + } catch (Exception exp) { + throw new RuntimeException(exp); + } + } + + private long getCapacity() { + return VM.getVM().getUniverse().heap().capacity(); + } + + private long getUsed() { + return VM.getVM().getUniverse().heap().used(); + } + + private final JSJavaFactory factory; + private static Method forEachObjectMethod; + private static Method forEachClassMethod; +}