Mercurial > hg > graal-compiler
diff agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java @ 6725:da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes
Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland
Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author | coleenp |
---|---|
date | Sat, 01 Sep 2012 13:25:18 -0400 |
parents | 4f93f0d00802 |
children | ec0c4951286c |
line wrap: on
line diff
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java Fri Aug 31 16:39:35 2012 -0700 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java Sat Sep 01 13:25:18 2012 -0400 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2000, 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 @@ -48,35 +48,15 @@ DEBUG = System.getProperty("sun.jvm.hotspot.oops.ObjectHeap.DEBUG") != null; } - private OopHandle methodKlassHandle; - private OopHandle constMethodKlassHandle; - private OopHandle methodDataKlassHandle; - private OopHandle constantPoolKlassHandle; - private OopHandle constantPoolCacheKlassHandle; - private OopHandle klassKlassHandle; - private OopHandle instanceKlassKlassHandle; - private OopHandle typeArrayKlassKlassHandle; - private OopHandle objArrayKlassKlassHandle; - private OopHandle boolArrayKlassHandle; - private OopHandle byteArrayKlassHandle; - private OopHandle charArrayKlassHandle; - private OopHandle intArrayKlassHandle; - private OopHandle shortArrayKlassHandle; - private OopHandle longArrayKlassHandle; - private OopHandle singleArrayKlassHandle; - private OopHandle doubleArrayKlassHandle; - private OopHandle arrayKlassKlassHandle; - private OopHandle compiledICHolderKlassHandle; + private Address boolArrayKlassHandle; + private Address byteArrayKlassHandle; + private Address charArrayKlassHandle; + private Address intArrayKlassHandle; + private Address shortArrayKlassHandle; + private Address longArrayKlassHandle; + private Address singleArrayKlassHandle; + private Address doubleArrayKlassHandle; - private MethodKlass methodKlassObj; - private ConstMethodKlass constMethodKlassObj; - private MethodDataKlass methodDataKlassObj; - private ConstantPoolKlass constantPoolKlassObj; - private ConstantPoolCacheKlass constantPoolCacheKlassObj; - private KlassKlass klassKlassObj; - private InstanceKlassKlass instanceKlassKlassObj; - private TypeArrayKlassKlass typeArrayKlassKlassObj; - private ObjArrayKlassKlass objArrayKlassKlassObj; private TypeArrayKlass boolArrayKlassObj; private TypeArrayKlass byteArrayKlassObj; private TypeArrayKlass charArrayKlassObj; @@ -85,71 +65,34 @@ private TypeArrayKlass longArrayKlassObj; private TypeArrayKlass singleArrayKlassObj; private TypeArrayKlass doubleArrayKlassObj; - private ArrayKlassKlass arrayKlassKlassObj; - private CompiledICHolderKlass compiledICHolderKlassObj; public void initialize(TypeDataBase db) throws WrongTypeException { // Lookup the roots in the object hierarchy. Type universeType = db.lookupType("Universe"); - methodKlassHandle = universeType.getOopField("_methodKlassObj").getValue(); - methodKlassObj = new MethodKlass(methodKlassHandle, this); - - constMethodKlassHandle = universeType.getOopField("_constMethodKlassObj").getValue(); - constMethodKlassObj = new ConstMethodKlass(constMethodKlassHandle, this); + boolArrayKlassHandle = universeType.getAddressField("_boolArrayKlassObj").getValue(); + boolArrayKlassObj = new TypeArrayKlass(boolArrayKlassHandle); - constantPoolKlassHandle = universeType.getOopField("_constantPoolKlassObj").getValue(); - constantPoolKlassObj = new ConstantPoolKlass(constantPoolKlassHandle, this); - - constantPoolCacheKlassHandle = universeType.getOopField("_constantPoolCacheKlassObj").getValue(); - constantPoolCacheKlassObj = new ConstantPoolCacheKlass(constantPoolCacheKlassHandle, this); + byteArrayKlassHandle = universeType.getAddressField("_byteArrayKlassObj").getValue(); + byteArrayKlassObj = new TypeArrayKlass(byteArrayKlassHandle); - klassKlassHandle = universeType.getOopField("_klassKlassObj").getValue(); - klassKlassObj = new KlassKlass(klassKlassHandle, this); - - arrayKlassKlassHandle = universeType.getOopField("_arrayKlassKlassObj").getValue(); - arrayKlassKlassObj = new ArrayKlassKlass(arrayKlassKlassHandle, this); + charArrayKlassHandle = universeType.getAddressField("_charArrayKlassObj").getValue(); + charArrayKlassObj = new TypeArrayKlass(charArrayKlassHandle); - instanceKlassKlassHandle = universeType.getOopField("_instanceKlassKlassObj").getValue(); - instanceKlassKlassObj = new InstanceKlassKlass(instanceKlassKlassHandle, this); - - typeArrayKlassKlassHandle = universeType.getOopField("_typeArrayKlassKlassObj").getValue(); - typeArrayKlassKlassObj = new TypeArrayKlassKlass(typeArrayKlassKlassHandle, this); - - objArrayKlassKlassHandle = universeType.getOopField("_objArrayKlassKlassObj").getValue(); - objArrayKlassKlassObj = new ObjArrayKlassKlass(objArrayKlassKlassHandle, this); + intArrayKlassHandle = universeType.getAddressField("_intArrayKlassObj").getValue(); + intArrayKlassObj = new TypeArrayKlass(intArrayKlassHandle); - boolArrayKlassHandle = universeType.getOopField("_boolArrayKlassObj").getValue(); - boolArrayKlassObj = new TypeArrayKlass(boolArrayKlassHandle, this); - - byteArrayKlassHandle = universeType.getOopField("_byteArrayKlassObj").getValue(); - byteArrayKlassObj = new TypeArrayKlass(byteArrayKlassHandle, this); + shortArrayKlassHandle = universeType.getAddressField("_shortArrayKlassObj").getValue(); + shortArrayKlassObj = new TypeArrayKlass(shortArrayKlassHandle); - charArrayKlassHandle = universeType.getOopField("_charArrayKlassObj").getValue(); - charArrayKlassObj = new TypeArrayKlass(charArrayKlassHandle, this); - - intArrayKlassHandle = universeType.getOopField("_intArrayKlassObj").getValue(); - intArrayKlassObj = new TypeArrayKlass(intArrayKlassHandle, this); - - shortArrayKlassHandle = universeType.getOopField("_shortArrayKlassObj").getValue(); - shortArrayKlassObj = new TypeArrayKlass(shortArrayKlassHandle, this); + longArrayKlassHandle = universeType.getAddressField("_longArrayKlassObj").getValue(); + longArrayKlassObj = new TypeArrayKlass(longArrayKlassHandle); - longArrayKlassHandle = universeType.getOopField("_longArrayKlassObj").getValue(); - longArrayKlassObj = new TypeArrayKlass(longArrayKlassHandle, this); - - singleArrayKlassHandle = universeType.getOopField("_singleArrayKlassObj").getValue(); - singleArrayKlassObj = new TypeArrayKlass(singleArrayKlassHandle, this); + singleArrayKlassHandle = universeType.getAddressField("_singleArrayKlassObj").getValue(); + singleArrayKlassObj = new TypeArrayKlass(singleArrayKlassHandle); - doubleArrayKlassHandle = universeType.getOopField("_doubleArrayKlassObj").getValue(); - doubleArrayKlassObj = new TypeArrayKlass(doubleArrayKlassHandle, this); - - if (!VM.getVM().isCore()) { - methodDataKlassHandle = universeType.getOopField("_methodDataKlassObj").getValue(); - methodDataKlassObj = new MethodDataKlass(methodDataKlassHandle, this); - - compiledICHolderKlassHandle = universeType.getOopField("_compiledICHolderKlassObj").getValue(); - compiledICHolderKlassObj= new CompiledICHolderKlass(compiledICHolderKlassHandle ,this); - } + doubleArrayKlassHandle = universeType.getAddressField("_doubleArrayKlassObj").getValue(); + doubleArrayKlassObj = new TypeArrayKlass(doubleArrayKlassHandle); } public ObjectHeap(TypeDataBase db) throws WrongTypeException { @@ -195,16 +138,6 @@ public long getDoubleSize() { return doubleSize; } // Accessors for well-known system classes (from Universe) - public MethodKlass getMethodKlassObj() { return methodKlassObj; } - public ConstMethodKlass getConstMethodKlassObj() { return constMethodKlassObj; } - public MethodDataKlass getMethodDataKlassObj() { return methodDataKlassObj; } - public ConstantPoolKlass getConstantPoolKlassObj() { return constantPoolKlassObj; } - public ConstantPoolCacheKlass getConstantPoolCacheKlassObj() { return constantPoolCacheKlassObj; } - public KlassKlass getKlassKlassObj() { return klassKlassObj; } - public ArrayKlassKlass getArrayKlassKlassObj() { return arrayKlassKlassObj; } - public InstanceKlassKlass getInstanceKlassKlassObj() { return instanceKlassKlassObj; } - public ObjArrayKlassKlass getObjArrayKlassKlassObj() { return objArrayKlassKlassObj; } - public TypeArrayKlassKlass getTypeArrayKlassKlassObj() { return typeArrayKlassKlassObj; } public TypeArrayKlass getBoolArrayKlassObj() { return boolArrayKlassObj; } public TypeArrayKlass getByteArrayKlassObj() { return byteArrayKlassObj; } public TypeArrayKlass getCharArrayKlassObj() { return charArrayKlassObj; } @@ -213,12 +146,6 @@ public TypeArrayKlass getLongArrayKlassObj() { return longArrayKlassObj; } public TypeArrayKlass getSingleArrayKlassObj() { return singleArrayKlassObj; } public TypeArrayKlass getDoubleArrayKlassObj() { return doubleArrayKlassObj; } - public CompiledICHolderKlass getCompiledICHolderKlassObj() { - if (Assert.ASSERTS_ENABLED) { - Assert.that(!VM.getVM().isCore(), "must not be called for core build"); - } - return compiledICHolderKlassObj; - } /** Takes a BasicType and returns the corresponding primitive array klass */ @@ -301,22 +228,13 @@ visitor.epilogue(); } - // Iterates through only the perm generation for the purpose of - // finding static fields for liveness analysis - public void iteratePerm(HeapVisitor visitor) { - CollectedHeap heap = VM.getVM().getUniverse().heap(); - List liveRegions = new ArrayList(); - addPermGenLiveRegions(liveRegions, heap); - sortLiveRegions(liveRegions); - iterateLiveRegions(liveRegions, visitor, null); + public boolean isValidMethod(Address handle) { + try { + Method m = (Method)Metadata.instantiateWrapperFor(handle); + return true; + } catch (Exception e) { + return false; } - - public boolean isValidMethod(OopHandle handle) { - OopHandle klass = Oop.getKlassForOopHandle(handle); - if (klass != null && klass.equals(methodKlassHandle)) { - return true; - } - return false; } // Creates an instance from the Oop hierarchy based based on the handle @@ -329,60 +247,12 @@ // Handle the null reference if (handle == null) return null; - // First check if handle is one of the root objects - if (handle.equals(methodKlassHandle)) return getMethodKlassObj(); - if (handle.equals(constMethodKlassHandle)) return getConstMethodKlassObj(); - if (handle.equals(constantPoolKlassHandle)) return getConstantPoolKlassObj(); - if (handle.equals(constantPoolCacheKlassHandle)) return getConstantPoolCacheKlassObj(); - if (handle.equals(instanceKlassKlassHandle)) return getInstanceKlassKlassObj(); - if (handle.equals(objArrayKlassKlassHandle)) return getObjArrayKlassKlassObj(); - if (handle.equals(klassKlassHandle)) return getKlassKlassObj(); - if (handle.equals(arrayKlassKlassHandle)) return getArrayKlassKlassObj(); - if (handle.equals(typeArrayKlassKlassHandle)) return getTypeArrayKlassKlassObj(); - if (handle.equals(boolArrayKlassHandle)) return getBoolArrayKlassObj(); - if (handle.equals(byteArrayKlassHandle)) return getByteArrayKlassObj(); - if (handle.equals(charArrayKlassHandle)) return getCharArrayKlassObj(); - if (handle.equals(intArrayKlassHandle)) return getIntArrayKlassObj(); - if (handle.equals(shortArrayKlassHandle)) return getShortArrayKlassObj(); - if (handle.equals(longArrayKlassHandle)) return getLongArrayKlassObj(); - if (handle.equals(singleArrayKlassHandle)) return getSingleArrayKlassObj(); - if (handle.equals(doubleArrayKlassHandle)) return getDoubleArrayKlassObj(); - if (!VM.getVM().isCore()) { - if (handle.equals(compiledICHolderKlassHandle)) return getCompiledICHolderKlassObj(); - if (handle.equals(methodDataKlassHandle)) return getMethodDataKlassObj(); - } - // Then check if obj.klass() is one of the root objects - OopHandle klass = Oop.getKlassForOopHandle(handle); + Klass klass = Oop.getKlassForOopHandle(handle); if (klass != null) { - if (klass.equals(methodKlassHandle)) return new Method(handle, this); - if (klass.equals(constMethodKlassHandle)) return new ConstMethod(handle, this); - if (klass.equals(constantPoolKlassHandle)) return new ConstantPool(handle, this); - if (klass.equals(constantPoolCacheKlassHandle)) return new ConstantPoolCache(handle, this); - if (!VM.getVM().isCore()) { - if (klass.equals(compiledICHolderKlassHandle)) return new CompiledICHolder(handle, this); - if (klass.equals(methodDataKlassHandle)) return new MethodData(handle, this); - } - if (klass.equals(instanceKlassKlassHandle)) { - InstanceKlass ik = new InstanceKlass(handle, this); - if (ik.getName().asString().equals("java/lang/Class")) { - // We would normally do this using the vtable style - // lookup but since it's not used for these currently - // it's simpler to just check for the name. - return new InstanceMirrorKlass(handle, this); - } - return ik; - } - if (klass.equals(objArrayKlassKlassHandle)) return new ObjArrayKlass(handle, this); - if (klass.equals(typeArrayKlassKlassHandle)) return new TypeArrayKlass(handle, this); - - // Lastly check if obj.klass().klass() is on of the root objects - OopHandle klassKlass = Oop.getKlassForOopHandle(klass); - if (klassKlass != null) { - if (klassKlass.equals(instanceKlassKlassHandle)) return new Instance(handle, this); - if (klassKlass.equals(objArrayKlassKlassHandle)) return new ObjArray(handle, this); - if (klassKlass.equals(typeArrayKlassKlassHandle)) return new TypeArray(handle, this); - } + if (klass instanceof TypeArrayKlass) return new TypeArray(handle, this); + if (klass instanceof ObjArrayKlass) return new ObjArray(handle, this); + if (klass instanceof InstanceKlass) return new Instance(handle, this); } if (DEBUG) { @@ -434,21 +304,15 @@ visitor.prologue(totalSize); CompactibleFreeListSpace cmsSpaceOld = null; - CompactibleFreeListSpace cmsSpacePerm = null; CollectedHeap heap = VM.getVM().getUniverse().heap(); if (heap instanceof GenCollectedHeap) { GenCollectedHeap genHeap = (GenCollectedHeap) heap; Generation genOld = genHeap.getGen(1); - Generation genPerm = genHeap.permGen(); if (genOld instanceof ConcurrentMarkSweepGeneration) { ConcurrentMarkSweepGeneration concGen = (ConcurrentMarkSweepGeneration)genOld; cmsSpaceOld = concGen.cmsSpace(); } - if (genPerm instanceof ConcurrentMarkSweepGeneration) { - ConcurrentMarkSweepGeneration concGen = (ConcurrentMarkSweepGeneration)genPerm; - cmsSpacePerm = concGen.cmsSpace(); - } } for (int i = 0; i < liveRegions.size(); i += 2) { @@ -476,8 +340,6 @@ if ( (cmsSpaceOld != null) && cmsSpaceOld.contains(handle) ){ size = cmsSpaceOld.collector().blockSizeUsingPrintezisBits(handle); - } else if ((cmsSpacePerm != null) && cmsSpacePerm.contains(handle) ){ - size = cmsSpacePerm.collector().blockSizeUsingPrintezisBits(handle); } if (size <= 0) { @@ -494,8 +356,7 @@ break; } } - if ( (cmsSpaceOld != null) && cmsSpaceOld.contains(handle) || - (cmsSpacePerm != null) && cmsSpacePerm.contains(handle) ) { + if ( (cmsSpaceOld != null) && cmsSpaceOld.contains(handle)) { handle = handle.addOffsetToAsOopHandle(CompactibleFreeListSpace.adjustObjectSizeInBytes(obj.getObjectSize()) ); } else { handle = handle.addOffsetToAsOopHandle(obj.getObjectSize()); @@ -513,32 +374,6 @@ visitor.epilogue(); } - private void addPermGenLiveRegions(List output, CollectedHeap heap) { - LiveRegionsCollector lrc = new LiveRegionsCollector(output); - if (heap instanceof SharedHeap) { - if (Assert.ASSERTS_ENABLED) { - Assert.that(heap instanceof GenCollectedHeap || - heap instanceof G1CollectedHeap, - "Expecting GenCollectedHeap or G1CollectedHeap, " + - "but got " + heap.getClass().getName()); - } - // Handles both GenCollectedHeap and G1CollectedHeap - SharedHeap sharedHeap = (SharedHeap) heap; - Generation gen = sharedHeap.permGen(); - gen.spaceIterate(lrc, true); - } else if (heap instanceof ParallelScavengeHeap) { - ParallelScavengeHeap psh = (ParallelScavengeHeap) heap; - PSPermGen permGen = psh.permGen(); - addLiveRegions(permGen.objectSpace().getLiveRegions(), output); - } else { - if (Assert.ASSERTS_ENABLED) { - Assert.that(false, - "Expecting SharedHeap or ParallelScavengeHeap, " + - "but got " + heap.getClass().getName()); - } - } - } - private void addLiveRegions(List input, List output) { for (Iterator itr = input.iterator(); itr.hasNext();) { MemRegion reg = (MemRegion) itr.next(); @@ -608,9 +443,6 @@ } } - // handle perm generation - addPermGenLiveRegions(liveRegions, heap); - // If UseTLAB is enabled, snip out regions associated with TLABs' // dead regions. Note that TLABs can be present in any generation.