< prev index next >

agent/src/share/classes/sun/jvm/hotspot/gc/g1/G1CollectedHeap.java

Print this page
rev 8688 : 8131319: Move G1Allocator::_summary_bytes_used back to G1CollectedHeap
Reviewed-by:


  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 package sun.jvm.hotspot.gc.g1;
  26 
  27 import java.util.Iterator;
  28 import java.util.Observable;
  29 import java.util.Observer;
  30 
  31 import sun.jvm.hotspot.debugger.Address;
  32 import sun.jvm.hotspot.gc.shared.CollectedHeap;
  33 import sun.jvm.hotspot.gc.shared.CollectedHeapName;
  34 import sun.jvm.hotspot.gc.shared.SpaceClosure;
  35 import sun.jvm.hotspot.memory.MemRegion;
  36 import sun.jvm.hotspot.runtime.VM;
  37 import sun.jvm.hotspot.runtime.VMObjectFactory;
  38 import sun.jvm.hotspot.types.AddressField;

  39 import sun.jvm.hotspot.types.Type;
  40 import sun.jvm.hotspot.types.TypeDataBase;
  41 
  42 // Mirror class for G1CollectedHeap.
  43 
  44 public class G1CollectedHeap extends CollectedHeap {
  45     // HeapRegionManager _hrm;
  46     static private long hrmFieldOffset;
  47     // MemRegion _g1_reserved;
  48     static private long g1ReservedFieldOffset;
  49     // G1Allocator* _allocator
  50     static private AddressField g1Allocator;
  51     // G1MonitoringSupport* _g1mm;
  52     static private AddressField g1mmField;
  53     // HeapRegionSet _old_set;
  54     static private long oldSetFieldOffset;
  55     // HeapRegionSet _humongous_set;
  56     static private long humongousSetFieldOffset;
  57 
  58     static {
  59         VM.registerVMInitializedObserver(new Observer() {
  60                 public void update(Observable o, Object data) {
  61                     initialize(VM.getVM().getTypeDataBase());
  62                 }
  63             });
  64     }
  65 
  66     static private synchronized void initialize(TypeDataBase db) {
  67         Type type = db.lookupType("G1CollectedHeap");
  68 
  69         hrmFieldOffset = type.getField("_hrm").getOffset();
  70         g1Allocator = type.getAddressField("_allocator");
  71         g1mmField = type.getAddressField("_g1mm");
  72         oldSetFieldOffset = type.getField("_old_set").getOffset();
  73         humongousSetFieldOffset = type.getField("_humongous_set").getOffset();
  74     }
  75 
  76     public long capacity() {
  77         return hrm().capacity();
  78     }
  79 
  80     public long used() {
  81         return allocator().getSummaryBytes();
  82     }
  83 
  84     public long n_regions() {
  85         return hrm().length();
  86     }
  87 
  88     private HeapRegionManager hrm() {
  89         Address hrmAddr = addr.addOffsetTo(hrmFieldOffset);
  90         return (HeapRegionManager) VMObjectFactory.newObject(HeapRegionManager.class,
  91                                                          hrmAddr);
  92     }
  93 
  94     public G1MonitoringSupport g1mm() {
  95         Address g1mmAddr = g1mmField.getValue(addr);
  96         return (G1MonitoringSupport) VMObjectFactory.newObject(G1MonitoringSupport.class, g1mmAddr);
  97     }
  98 
  99     public G1Allocator allocator() {
 100         Address g1AllocatorAddr = g1Allocator.getValue(addr);
 101         return (G1Allocator) VMObjectFactory.newObject(G1Allocator.class, g1AllocatorAddr);
 102     }
 103 
 104     public HeapRegionSetBase oldSet() {
 105         Address oldSetAddr = addr.addOffsetTo(oldSetFieldOffset);
 106         return (HeapRegionSetBase) VMObjectFactory.newObject(HeapRegionSetBase.class,
 107                                                              oldSetAddr);
 108     }
 109 
 110     public HeapRegionSetBase humongousSet() {
 111         Address humongousSetAddr = addr.addOffsetTo(humongousSetFieldOffset);
 112         return (HeapRegionSetBase) VMObjectFactory.newObject(HeapRegionSetBase.class,
 113                                                              humongousSetAddr);
 114     }
 115 
 116     private Iterator<HeapRegion> heapRegionIterator() {
 117         return hrm().heapRegionIterator();
 118     }
 119 
 120     public void heapRegionIterate(SpaceClosure scl) {
 121         Iterator<HeapRegion> iter = heapRegionIterator();


  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 package sun.jvm.hotspot.gc.g1;
  26 
  27 import java.util.Iterator;
  28 import java.util.Observable;
  29 import java.util.Observer;
  30 
  31 import sun.jvm.hotspot.debugger.Address;
  32 import sun.jvm.hotspot.gc.shared.CollectedHeap;
  33 import sun.jvm.hotspot.gc.shared.CollectedHeapName;
  34 import sun.jvm.hotspot.gc.shared.SpaceClosure;
  35 import sun.jvm.hotspot.memory.MemRegion;
  36 import sun.jvm.hotspot.runtime.VM;
  37 import sun.jvm.hotspot.runtime.VMObjectFactory;
  38 import sun.jvm.hotspot.types.AddressField;
  39 import sun.jvm.hotspot.types.CIntegerField;
  40 import sun.jvm.hotspot.types.Type;
  41 import sun.jvm.hotspot.types.TypeDataBase;
  42 
  43 // Mirror class for G1CollectedHeap.
  44 
  45 public class G1CollectedHeap extends CollectedHeap {
  46     // HeapRegionManager _hrm;
  47     static private long hrmFieldOffset;
  48     // MemRegion _g1_reserved;
  49     static private long g1ReservedFieldOffset;
  50     // size_t _summary_bytes_used;
  51     static private CIntegerField summaryBytesUsedField;
  52     // G1MonitoringSupport* _g1mm;
  53     static private AddressField g1mmField;
  54     // HeapRegionSet _old_set;
  55     static private long oldSetFieldOffset;
  56     // HeapRegionSet _humongous_set;
  57     static private long humongousSetFieldOffset;
  58 
  59     static {
  60         VM.registerVMInitializedObserver(new Observer() {
  61                 public void update(Observable o, Object data) {
  62                     initialize(VM.getVM().getTypeDataBase());
  63                 }
  64             });
  65     }
  66 
  67     static private synchronized void initialize(TypeDataBase db) {
  68         Type type = db.lookupType("G1CollectedHeap");
  69 
  70         hrmFieldOffset = type.getField("_hrm").getOffset();
  71         summaryBytesUsedField = type.getCIntegerField("_summary_bytes_used");
  72         g1mmField = type.getAddressField("_g1mm");
  73         oldSetFieldOffset = type.getField("_old_set").getOffset();
  74         humongousSetFieldOffset = type.getField("_humongous_set").getOffset();
  75     }
  76 
  77     public long capacity() {
  78         return hrm().capacity();
  79     }
  80 
  81     public long used() {
  82         return summaryBytesUsedField.getValue();
  83     }
  84 
  85     public long n_regions() {
  86         return hrm().length();
  87     }
  88 
  89     private HeapRegionManager hrm() {
  90         Address hrmAddr = addr.addOffsetTo(hrmFieldOffset);
  91         return (HeapRegionManager) VMObjectFactory.newObject(HeapRegionManager.class,
  92                                                          hrmAddr);
  93     }
  94 
  95     public G1MonitoringSupport g1mm() {
  96         Address g1mmAddr = g1mmField.getValue(addr);
  97         return (G1MonitoringSupport) VMObjectFactory.newObject(G1MonitoringSupport.class, g1mmAddr);





  98     }
  99 
 100     public HeapRegionSetBase oldSet() {
 101         Address oldSetAddr = addr.addOffsetTo(oldSetFieldOffset);
 102         return (HeapRegionSetBase) VMObjectFactory.newObject(HeapRegionSetBase.class,
 103                                                              oldSetAddr);
 104     }
 105 
 106     public HeapRegionSetBase humongousSet() {
 107         Address humongousSetAddr = addr.addOffsetTo(humongousSetFieldOffset);
 108         return (HeapRegionSetBase) VMObjectFactory.newObject(HeapRegionSetBase.class,
 109                                                              humongousSetAddr);
 110     }
 111 
 112     private Iterator<HeapRegion> heapRegionIterator() {
 113         return hrm().heapRegionIterator();
 114     }
 115 
 116     public void heapRegionIterate(SpaceClosure scl) {
 117         Iterator<HeapRegion> iter = heapRegionIterator();
< prev index next >