1 /*
   2  * Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  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 //
  26 // The ObjectHeap is an abstraction over all generations in the VM
  27 // It gives access to all present objects and classes.
  28 //
  29 
  30 package sun.jvm.hotspot.oops;
  31 
  32 import java.util.*;
  33 
  34 import sun.jvm.hotspot.debugger.*;
  35 import sun.jvm.hotspot.gc.cms.*;
  36 import sun.jvm.hotspot.gc.shared.*;
  37 import sun.jvm.hotspot.gc.epsilon.*;
  38 import sun.jvm.hotspot.gc.g1.*;
  39 import sun.jvm.hotspot.gc.parallel.*;
  40 import sun.jvm.hotspot.memory.*;
  41 import sun.jvm.hotspot.runtime.*;
  42 import sun.jvm.hotspot.types.*;
  43 import sun.jvm.hotspot.utilities.*;
  44 
  45 public class ObjectHeap {
  46 
  47   private static final boolean DEBUG;
  48 
  49   static {
  50     DEBUG = System.getProperty("sun.jvm.hotspot.oops.ObjectHeap.DEBUG") != null;
  51   }
  52 
  53   private Address              boolArrayKlassHandle;
  54   private Address              byteArrayKlassHandle;
  55   private Address              charArrayKlassHandle;
  56   private Address              intArrayKlassHandle;
  57   private Address              shortArrayKlassHandle;
  58   private Address              longArrayKlassHandle;
  59   private Address              singleArrayKlassHandle;
  60   private Address              doubleArrayKlassHandle;
  61 
  62   private TypeArrayKlass         boolArrayKlassObj;
  63   private TypeArrayKlass         byteArrayKlassObj;
  64   private TypeArrayKlass         charArrayKlassObj;
  65   private TypeArrayKlass         intArrayKlassObj;
  66   private TypeArrayKlass         shortArrayKlassObj;
  67   private TypeArrayKlass         longArrayKlassObj;
  68   private TypeArrayKlass         singleArrayKlassObj;
  69   private TypeArrayKlass         doubleArrayKlassObj;
  70 
  71   public void initialize(TypeDataBase db) throws WrongTypeException {
  72     // Lookup the roots in the object hierarchy.
  73     Type universeType = db.lookupType("Universe");
  74 
  75     boolArrayKlassHandle      = universeType.getAddressField("_boolArrayKlassObj").getValue();
  76     boolArrayKlassObj         = new TypeArrayKlass(boolArrayKlassHandle);
  77 
  78     byteArrayKlassHandle      = universeType.getAddressField("_byteArrayKlassObj").getValue();
  79     byteArrayKlassObj         = new TypeArrayKlass(byteArrayKlassHandle);
  80 
  81     charArrayKlassHandle      = universeType.getAddressField("_charArrayKlassObj").getValue();
  82     charArrayKlassObj         = new TypeArrayKlass(charArrayKlassHandle);
  83 
  84     intArrayKlassHandle       = universeType.getAddressField("_intArrayKlassObj").getValue();
  85     intArrayKlassObj          = new TypeArrayKlass(intArrayKlassHandle);
  86 
  87     shortArrayKlassHandle     = universeType.getAddressField("_shortArrayKlassObj").getValue();
  88     shortArrayKlassObj        = new TypeArrayKlass(shortArrayKlassHandle);
  89 
  90     longArrayKlassHandle      = universeType.getAddressField("_longArrayKlassObj").getValue();
  91     longArrayKlassObj         = new TypeArrayKlass(longArrayKlassHandle);
  92 
  93     singleArrayKlassHandle    = universeType.getAddressField("_singleArrayKlassObj").getValue();
  94     singleArrayKlassObj       = new TypeArrayKlass(singleArrayKlassHandle);
  95 
  96     doubleArrayKlassHandle    = universeType.getAddressField("_doubleArrayKlassObj").getValue();
  97     doubleArrayKlassObj       = new TypeArrayKlass(doubleArrayKlassHandle);
  98   }
  99 
 100   public ObjectHeap(TypeDataBase db) throws WrongTypeException {
 101     // Get commonly used sizes of basic types
 102     oopSize     = VM.getVM().getOopSize();
 103     byteSize    = db.getJByteType().getSize();
 104     charSize    = db.getJCharType().getSize();
 105     booleanSize = db.getJBooleanType().getSize();
 106     intSize     = db.getJIntType().getSize();
 107     shortSize   = db.getJShortType().getSize();
 108     longSize    = db.getJLongType().getSize();
 109     floatSize   = db.getJFloatType().getSize();
 110     doubleSize  = db.getJDoubleType().getSize();
 111 
 112     initialize(db);
 113   }
 114 
 115   /** Comparison operation for oops, either or both of which may be null */
 116   public boolean equal(Oop o1, Oop o2) {
 117     if (o1 != null) return o1.equals(o2);
 118     return (o2 == null);
 119   }
 120 
 121   // Cached sizes of basic types
 122   private long oopSize;
 123   private long byteSize;
 124   private long charSize;
 125   private long booleanSize;
 126   private long intSize;
 127   private long shortSize;
 128   private long longSize;
 129   private long floatSize;
 130   private long doubleSize;
 131 
 132   public long getOopSize()     { return oopSize;     }
 133   public long getByteSize()    { return byteSize;    }
 134   public long getCharSize()    { return charSize;    }
 135   public long getBooleanSize() { return booleanSize; }
 136   public long getIntSize()     { return intSize;     }
 137   public long getShortSize()   { return shortSize;   }
 138   public long getLongSize()    { return longSize;    }
 139   public long getFloatSize()   { return floatSize;   }
 140   public long getDoubleSize()  { return doubleSize;  }
 141 
 142   // Accessors for well-known system classes (from Universe)
 143   public TypeArrayKlass         getBoolArrayKlassObj()         { return boolArrayKlassObj; }
 144   public TypeArrayKlass         getByteArrayKlassObj()         { return byteArrayKlassObj; }
 145   public TypeArrayKlass         getCharArrayKlassObj()         { return charArrayKlassObj; }
 146   public TypeArrayKlass         getIntArrayKlassObj()          { return intArrayKlassObj; }
 147   public TypeArrayKlass         getShortArrayKlassObj()        { return shortArrayKlassObj; }
 148   public TypeArrayKlass         getLongArrayKlassObj()         { return longArrayKlassObj; }
 149   public TypeArrayKlass         getSingleArrayKlassObj()       { return singleArrayKlassObj; }
 150   public TypeArrayKlass         getDoubleArrayKlassObj()       { return doubleArrayKlassObj; }
 151 
 152   /** Takes a BasicType and returns the corresponding primitive array
 153       klass */
 154   public Klass typeArrayKlassObj(int t) {
 155     if (t == BasicType.getTBoolean()) return getBoolArrayKlassObj();
 156     if (t == BasicType.getTChar())    return getCharArrayKlassObj();
 157     if (t == BasicType.getTFloat())   return getSingleArrayKlassObj();
 158     if (t == BasicType.getTDouble())  return getDoubleArrayKlassObj();
 159     if (t == BasicType.getTByte())    return getByteArrayKlassObj();
 160     if (t == BasicType.getTShort())   return getShortArrayKlassObj();
 161     if (t == BasicType.getTInt())     return getIntArrayKlassObj();
 162     if (t == BasicType.getTLong())    return getLongArrayKlassObj();
 163     throw new RuntimeException("Illegal basic type " + t);
 164   }
 165 
 166   /** an interface to filter objects while walking heap */
 167   public static interface ObjectFilter {
 168     public boolean canInclude(Oop obj);
 169   }
 170 
 171   /** The base heap iteration mechanism */
 172   public void iterate(HeapVisitor visitor) {
 173     iterateLiveRegions(collectLiveRegions(), visitor, null);
 174   }
 175 
 176   /** iterate objects satisfying a specified ObjectFilter */
 177   public void iterate(HeapVisitor visitor, ObjectFilter of) {
 178     iterateLiveRegions(collectLiveRegions(), visitor, of);
 179   }
 180 
 181   /** iterate objects of given Klass. param 'includeSubtypes' tells whether to
 182    *  include objects of subtypes or not */
 183   public void iterateObjectsOfKlass(HeapVisitor visitor, final Klass k, boolean includeSubtypes) {
 184     if (includeSubtypes) {
 185       if (k.isFinal()) {
 186         // do the simpler "exact" klass loop
 187         iterateExact(visitor, k);
 188       } else {
 189         iterateSubtypes(visitor, k);
 190       }
 191     } else {
 192       // there can no object of abstract classes and interfaces
 193       if (!k.isAbstract() && !k.isInterface()) {
 194         iterateExact(visitor, k);
 195       }
 196     }
 197   }
 198 
 199   /** iterate objects of given Klass (objects of subtypes included) */
 200   public void iterateObjectsOfKlass(HeapVisitor visitor, final Klass k) {
 201     iterateObjectsOfKlass(visitor, k, true);
 202   }
 203 
 204   /** This routine can be used to iterate through the heap at an
 205       extremely low level (stepping word-by-word) to provide the
 206       ability to do very low-level debugging */
 207   public void iterateRaw(RawHeapVisitor visitor) {
 208     List liveRegions = collectLiveRegions();
 209 
 210     // Summarize size
 211     long totalSize = 0;
 212     for (int i = 0; i < liveRegions.size(); i += 2) {
 213       Address bottom = (Address) liveRegions.get(i);
 214       Address top    = (Address) liveRegions.get(i+1);
 215       totalSize += top.minus(bottom);
 216     }
 217     visitor.prologue(totalSize);
 218 
 219     for (int i = 0; i < liveRegions.size(); i += 2) {
 220       Address bottom = (Address) liveRegions.get(i);
 221       Address top    = (Address) liveRegions.get(i+1);
 222 
 223       // Traverses the space from bottom to top
 224       while (bottom.lessThan(top)) {
 225         visitor.visitAddress(bottom);
 226         bottom = bottom.addOffsetTo(VM.getVM().getAddressSize());
 227       }
 228     }
 229 
 230     visitor.epilogue();
 231   }
 232 
 233   public boolean isValidMethod(Address handle) {
 234     try {
 235       Method m = (Method)Metadata.instantiateWrapperFor(handle);
 236       return true;
 237     } catch (Exception e) {
 238       return false;
 239   }
 240   }
 241 
 242   // Creates an instance from the Oop hierarchy based based on the handle
 243   public Oop newOop(OopHandle handle) {
 244     // The only known way to detect the right type of an oop is
 245     // traversing the class chain until a well-known klass is recognized.
 246     // A more direct solution would require the klasses to expose
 247     // the C++ vtbl structure.
 248 
 249     // Handle the null reference
 250     if (handle == null) return null;
 251 
 252     // Then check if obj.klass() is one of the root objects
 253     Klass klass = Oop.getKlassForOopHandle(handle);
 254     if (klass != null) {
 255       if (klass instanceof TypeArrayKlass) return new TypeArray(handle, this);
 256       if (klass instanceof ObjArrayKlass) return new ObjArray(handle, this);
 257       if (klass instanceof InstanceKlass) return new Instance(handle, this);
 258     }
 259 
 260     if (DEBUG) {
 261       System.err.println("Unknown oop at " + handle);
 262       System.err.println("Oop's klass is " + klass);
 263     }
 264 
 265     throw new UnknownOopException();
 266   }
 267 
 268   // Print all objects in the object heap
 269   public void print() {
 270     HeapPrinter printer = new HeapPrinter(System.out);
 271     iterate(printer);
 272   }
 273 
 274   //---------------------------------------------------------------------------
 275   // Internals only below this point
 276   //
 277 
 278   private void iterateExact(HeapVisitor visitor, final Klass k) {
 279     iterateLiveRegions(collectLiveRegions(), visitor, new ObjectFilter() {
 280           public boolean canInclude(Oop obj) {
 281             Klass tk = obj.getKlass();
 282             // null Klass is seen sometimes!
 283             return (tk != null && tk.equals(k));
 284           }
 285         });
 286   }
 287 
 288   private void iterateSubtypes(HeapVisitor visitor, final Klass k) {
 289     iterateLiveRegions(collectLiveRegions(), visitor, new ObjectFilter() {
 290           public boolean canInclude(Oop obj) {
 291             Klass tk = obj.getKlass();
 292             // null Klass is seen sometimes!
 293             return (tk != null && tk.isSubtypeOf(k));
 294           }
 295         });
 296   }
 297 
 298   private void iterateLiveRegions(List liveRegions, HeapVisitor visitor, ObjectFilter of) {
 299     // Summarize size
 300     long totalSize = 0;
 301     for (int i = 0; i < liveRegions.size(); i += 2) {
 302       Address bottom = (Address) liveRegions.get(i);
 303       Address top    = (Address) liveRegions.get(i+1);
 304       totalSize += top.minus(bottom);
 305     }
 306     visitor.prologue(totalSize);
 307 
 308     CompactibleFreeListSpace cmsSpaceOld = null;
 309     CollectedHeap heap = VM.getVM().getUniverse().heap();
 310 
 311     if (heap instanceof GenCollectedHeap) {
 312       GenCollectedHeap genHeap = (GenCollectedHeap) heap;
 313       Generation genOld = genHeap.getGen(1);
 314       if (genOld instanceof ConcurrentMarkSweepGeneration) {
 315           ConcurrentMarkSweepGeneration concGen = (ConcurrentMarkSweepGeneration)genOld;
 316           cmsSpaceOld = concGen.cmsSpace();
 317       }
 318     }
 319 
 320     for (int i = 0; i < liveRegions.size(); i += 2) {
 321       Address bottom = (Address) liveRegions.get(i);
 322       Address top    = (Address) liveRegions.get(i+1);
 323 
 324       try {
 325         // Traverses the space from bottom to top
 326         OopHandle handle = bottom.addOffsetToAsOopHandle(0);
 327 
 328         while (handle.lessThan(top)) {
 329         Oop obj = null;
 330 
 331           try {
 332             obj = newOop(handle);
 333           } catch (UnknownOopException exp) {
 334             if (DEBUG) {
 335               throw new RuntimeException(" UnknownOopException  " + exp);
 336             }
 337           }
 338           if (obj == null) {
 339              //Find the object size using Printezis bits and skip over
 340              long size = 0;
 341 
 342              if ( (cmsSpaceOld != null) && cmsSpaceOld.contains(handle) ){
 343                  size = cmsSpaceOld.collector().blockSizeUsingPrintezisBits(handle);
 344              }
 345 
 346              if (size <= 0) {
 347                 //Either Printezis bits not set or handle is not in cms space.
 348                 throw new UnknownOopException();
 349              }
 350 
 351              handle = handle.addOffsetToAsOopHandle(CompactibleFreeListSpace.adjustObjectSizeInBytes(size));
 352              continue;
 353           }
 354           if (of == null || of.canInclude(obj)) {
 355                   if (visitor.doObj(obj)) {
 356                          // doObj() returns true to abort this loop.
 357                           break;
 358                   }
 359           }
 360           if ( (cmsSpaceOld != null) && cmsSpaceOld.contains(handle)) {
 361               handle = handle.addOffsetToAsOopHandle(CompactibleFreeListSpace.adjustObjectSizeInBytes(obj.getObjectSize()) );
 362           } else {
 363               handle = handle.addOffsetToAsOopHandle(obj.getObjectSize());
 364           }
 365         }
 366       }
 367       catch (AddressException e) {
 368         // This is okay at the top of these regions
 369           }
 370       catch (UnknownOopException e) {
 371         // This is okay at the top of these regions
 372       }
 373     }
 374 
 375     visitor.epilogue();
 376   }
 377 
 378   private void addLiveRegions(String name, List input, List output) {
 379      for (Iterator itr = input.iterator(); itr.hasNext();) {
 380         MemRegion reg = (MemRegion) itr.next();
 381         Address top = reg.end();
 382         Address bottom = reg.start();
 383         if (Assert.ASSERTS_ENABLED) {
 384            Assert.that(top != null, "top address in a live region should not be null");
 385         }
 386         if (Assert.ASSERTS_ENABLED) {
 387            Assert.that(bottom != null, "bottom address in a live region should not be null");
 388         }
 389         output.add(top);
 390         output.add(bottom);
 391         if (DEBUG) {
 392           System.err.println("Live region: " + name + ": " + bottom + ", " + top);
 393         }
 394      }
 395   }
 396 
 397   private class LiveRegionsCollector implements SpaceClosure {
 398      LiveRegionsCollector(List l) {
 399         liveRegions = l;
 400      }
 401 
 402      public void doSpace(Space s) {
 403         addLiveRegions(s.toString(), s.getLiveRegions(), liveRegions);
 404      }
 405      private List liveRegions;
 406   }
 407 
 408   // Returns a List<Address> where the addresses come in pairs. These
 409   // designate the live regions of the heap.
 410   private List collectLiveRegions() {
 411     // We want to iterate through all live portions of the heap, but
 412     // do not want to abort the heap traversal prematurely if we find
 413     // a problem (like an allocated but uninitialized object at the
 414     // top of a generation). To do this we enumerate all generations'
 415     // bottom and top regions, and factor in TLABs if necessary.
 416 
 417     // List<Address>. Addresses come in pairs.
 418     List liveRegions = new ArrayList();
 419     LiveRegionsCollector lrc = new LiveRegionsCollector(liveRegions);
 420 
 421     CollectedHeap heap = VM.getVM().getUniverse().heap();
 422 
 423     if (heap instanceof GenCollectedHeap) {
 424        GenCollectedHeap genHeap = (GenCollectedHeap) heap;
 425        // Run through all generations, obtaining bottom-top pairs.
 426        for (int i = 0; i < genHeap.nGens(); i++) {
 427          Generation gen = genHeap.getGen(i);
 428          gen.spaceIterate(lrc, true);
 429        }
 430     } else if (heap instanceof ParallelScavengeHeap) {
 431        ParallelScavengeHeap psh = (ParallelScavengeHeap) heap;
 432        PSYoungGen youngGen = psh.youngGen();
 433        // Add eden space
 434        addLiveRegions("eden", youngGen.edenSpace().getLiveRegions(), liveRegions);
 435        // Add from-space but not to-space
 436        addLiveRegions("from", youngGen.fromSpace().getLiveRegions(), liveRegions);
 437        PSOldGen oldGen = psh.oldGen();
 438        addLiveRegions("old ", oldGen.objectSpace().getLiveRegions(), liveRegions);
 439     } else if (heap instanceof G1CollectedHeap) {
 440         G1CollectedHeap g1h = (G1CollectedHeap) heap;
 441         g1h.heapRegionIterate(lrc);
 442     } else if (heap instanceof EpsilonHeap) {
 443        EpsilonHeap eh = (EpsilonHeap) heap;
 444        liveRegions.add(eh.space().top());
 445        liveRegions.add(eh.space().bottom());
 446     } else {
 447        if (Assert.ASSERTS_ENABLED) {
 448           Assert.that(false, "Unexpected CollectedHeap type: " + heap.getClass().getName());


 449        }
 450     }
 451 
 452     // If UseTLAB is enabled, snip out regions associated with TLABs'
 453     // dead regions. Note that TLABs can be present in any generation.
 454 
 455     // FIXME: consider adding fewer boundaries to live region list.
 456     // Theoretically only need to stop at TLAB's top and resume at its
 457     // end.
 458 
 459     if (VM.getVM().getUseTLAB()) {
 460       for (JavaThread thread = VM.getVM().getThreads().first(); thread != null; thread = thread.next()) {
 461         ThreadLocalAllocBuffer tlab = thread.tlab();
 462         if (tlab.start() != null) {
 463           if ((tlab.top() == null) || (tlab.end() == null)) {
 464             System.err.print("Warning: skipping invalid TLAB for thread ");
 465             thread.printThreadIDOn(System.err);
 466             System.err.println();
 467           } else {
 468             if (DEBUG) {
 469               System.err.print("TLAB for " + thread.getThreadName() + ", #");
 470               thread.printThreadIDOn(System.err);
 471               System.err.print(": ");
 472               tlab.printOn(System.err);
 473             }
 474             // Go from:
 475             //  - below start() to start()
 476             //  - start() to top()
 477             //  - end() and above
 478             liveRegions.add(tlab.start());
 479             liveRegions.add(tlab.start());
 480             liveRegions.add(tlab.top());
 481             liveRegions.add(tlab.hardEnd());
 482           }
 483         }
 484       }
 485     }
 486 
 487     // Now sort live regions
 488     sortLiveRegions(liveRegions);
 489 
 490     if (Assert.ASSERTS_ENABLED) {
 491       Assert.that(liveRegions.size() % 2 == 0, "Must have even number of region boundaries");
 492     }
 493 
 494     if (DEBUG) {
 495       System.err.println("liveRegions:");
 496       for (int i = 0; i < liveRegions.size(); i += 2) {
 497           Address bottom = (Address) liveRegions.get(i);
 498           Address top    = (Address) liveRegions.get(i+1);
 499           System.err.println(" " + bottom + " - " + top);
 500       }
 501     }
 502 
 503     return liveRegions;
 504   }
 505 
 506   private void sortLiveRegions(List liveRegions) {
 507     Collections.sort(liveRegions, new Comparator() {
 508         public int compare(Object o1, Object o2) {
 509           Address a1 = (Address) o1;
 510           Address a2 = (Address) o2;
 511           if (AddressOps.lt(a1, a2)) {
 512             return -1;
 513           } else if (AddressOps.gt(a1, a2)) {
 514             return 1;
 515           }
 516           return 0;
 517         }
 518       });
 519   }
 520 }
--- EOF ---