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.g1.*;
38 import sun.jvm.hotspot.gc.parallel.*;
39 import sun.jvm.hotspot.memory.*;
40 import sun.jvm.hotspot.runtime.*;
41 import sun.jvm.hotspot.types.*;
42 import sun.jvm.hotspot.utilities.*;
43
44 public class ObjectHeap {
45
46 private static final boolean DEBUG;
47
48 static {
49 DEBUG = System.getProperty("sun.jvm.hotspot.oops.ObjectHeap.DEBUG") != null;
50 }
51
52 private Address boolArrayKlassHandle;
53 private Address byteArrayKlassHandle;
54 private Address charArrayKlassHandle;
55 private Address intArrayKlassHandle;
56 private Address shortArrayKlassHandle;
57 private Address longArrayKlassHandle;
58 private Address singleArrayKlassHandle;
59 private Address doubleArrayKlassHandle;
60
61 private TypeArrayKlass boolArrayKlassObj;
62 private TypeArrayKlass byteArrayKlassObj;
63 private TypeArrayKlass charArrayKlassObj;
64 private TypeArrayKlass intArrayKlassObj;
65 private TypeArrayKlass shortArrayKlassObj;
66 private TypeArrayKlass longArrayKlassObj;
67 private TypeArrayKlass singleArrayKlassObj;
68 private TypeArrayKlass doubleArrayKlassObj;
69
70 public void initialize(TypeDataBase db) throws WrongTypeException {
71 // Lookup the roots in the object hierarchy.
72 Type universeType = db.lookupType("Universe");
73
74 boolArrayKlassHandle = universeType.getAddressField("_boolArrayKlassObj").getValue();
75 boolArrayKlassObj = new TypeArrayKlass(boolArrayKlassHandle);
76
77 byteArrayKlassHandle = universeType.getAddressField("_byteArrayKlassObj").getValue();
78 byteArrayKlassObj = new TypeArrayKlass(byteArrayKlassHandle);
79
80 charArrayKlassHandle = universeType.getAddressField("_charArrayKlassObj").getValue();
81 charArrayKlassObj = new TypeArrayKlass(charArrayKlassHandle);
82
83 intArrayKlassHandle = universeType.getAddressField("_intArrayKlassObj").getValue();
84 intArrayKlassObj = new TypeArrayKlass(intArrayKlassHandle);
85
86 shortArrayKlassHandle = universeType.getAddressField("_shortArrayKlassObj").getValue();
87 shortArrayKlassObj = new TypeArrayKlass(shortArrayKlassHandle);
88
89 longArrayKlassHandle = universeType.getAddressField("_longArrayKlassObj").getValue();
90 longArrayKlassObj = new TypeArrayKlass(longArrayKlassHandle);
91
92 singleArrayKlassHandle = universeType.getAddressField("_singleArrayKlassObj").getValue();
93 singleArrayKlassObj = new TypeArrayKlass(singleArrayKlassHandle);
94
95 doubleArrayKlassHandle = universeType.getAddressField("_doubleArrayKlassObj").getValue();
96 doubleArrayKlassObj = new TypeArrayKlass(doubleArrayKlassHandle);
97 }
98
99 public ObjectHeap(TypeDataBase db) throws WrongTypeException {
100 // Get commonly used sizes of basic types
101 oopSize = VM.getVM().getOopSize();
102 byteSize = db.getJByteType().getSize();
103 charSize = db.getJCharType().getSize();
104 booleanSize = db.getJBooleanType().getSize();
105 intSize = db.getJIntType().getSize();
106 shortSize = db.getJShortType().getSize();
107 longSize = db.getJLongType().getSize();
108 floatSize = db.getJFloatType().getSize();
109 doubleSize = db.getJDoubleType().getSize();
110
111 initialize(db);
112 }
113
114 /** Comparison operation for oops, either or both of which may be null */
115 public boolean equal(Oop o1, Oop o2) {
116 if (o1 != null) return o1.equals(o2);
117 return (o2 == null);
118 }
119
120 // Cached sizes of basic types
121 private long oopSize;
122 private long byteSize;
123 private long charSize;
124 private long booleanSize;
125 private long intSize;
126 private long shortSize;
127 private long longSize;
128 private long floatSize;
129 private long doubleSize;
130
131 public long getOopSize() { return oopSize; }
132 public long getByteSize() { return byteSize; }
133 public long getCharSize() { return charSize; }
134 public long getBooleanSize() { return booleanSize; }
135 public long getIntSize() { return intSize; }
136 public long getShortSize() { return shortSize; }
137 public long getLongSize() { return longSize; }
138 public long getFloatSize() { return floatSize; }
139 public long getDoubleSize() { return doubleSize; }
140
141 // Accessors for well-known system classes (from Universe)
142 public TypeArrayKlass getBoolArrayKlassObj() { return boolArrayKlassObj; }
143 public TypeArrayKlass getByteArrayKlassObj() { return byteArrayKlassObj; }
144 public TypeArrayKlass getCharArrayKlassObj() { return charArrayKlassObj; }
145 public TypeArrayKlass getIntArrayKlassObj() { return intArrayKlassObj; }
146 public TypeArrayKlass getShortArrayKlassObj() { return shortArrayKlassObj; }
147 public TypeArrayKlass getLongArrayKlassObj() { return longArrayKlassObj; }
148 public TypeArrayKlass getSingleArrayKlassObj() { return singleArrayKlassObj; }
149 public TypeArrayKlass getDoubleArrayKlassObj() { return doubleArrayKlassObj; }
150
151 /** Takes a BasicType and returns the corresponding primitive array
152 klass */
153 public Klass typeArrayKlassObj(int t) {
154 if (t == BasicType.getTBoolean()) return getBoolArrayKlassObj();
155 if (t == BasicType.getTChar()) return getCharArrayKlassObj();
156 if (t == BasicType.getTFloat()) return getSingleArrayKlassObj();
157 if (t == BasicType.getTDouble()) return getDoubleArrayKlassObj();
158 if (t == BasicType.getTByte()) return getByteArrayKlassObj();
159 if (t == BasicType.getTShort()) return getShortArrayKlassObj();
160 if (t == BasicType.getTInt()) return getIntArrayKlassObj();
161 if (t == BasicType.getTLong()) return getLongArrayKlassObj();
162 throw new RuntimeException("Illegal basic type " + t);
163 }
164
165 /** an interface to filter objects while walking heap */
166 public static interface ObjectFilter {
167 public boolean canInclude(Oop obj);
168 }
169
170 /** The base heap iteration mechanism */
171 public void iterate(HeapVisitor visitor) {
172 iterateLiveRegions(collectLiveRegions(), visitor, null);
173 }
174
175 /** iterate objects satisfying a specified ObjectFilter */
176 public void iterate(HeapVisitor visitor, ObjectFilter of) {
177 iterateLiveRegions(collectLiveRegions(), visitor, of);
178 }
179
180 /** iterate objects of given Klass. param 'includeSubtypes' tells whether to
181 * include objects of subtypes or not */
182 public void iterateObjectsOfKlass(HeapVisitor visitor, final Klass k, boolean includeSubtypes) {
183 if (includeSubtypes) {
184 if (k.isFinal()) {
185 // do the simpler "exact" klass loop
186 iterateExact(visitor, k);
187 } else {
188 iterateSubtypes(visitor, k);
189 }
190 } else {
191 // there can no object of abstract classes and interfaces
192 if (!k.isAbstract() && !k.isInterface()) {
193 iterateExact(visitor, k);
194 }
195 }
196 }
197
198 /** iterate objects of given Klass (objects of subtypes included) */
199 public void iterateObjectsOfKlass(HeapVisitor visitor, final Klass k) {
200 iterateObjectsOfKlass(visitor, k, true);
201 }
202
203 /** This routine can be used to iterate through the heap at an
204 extremely low level (stepping word-by-word) to provide the
205 ability to do very low-level debugging */
206 public void iterateRaw(RawHeapVisitor visitor) {
207 List liveRegions = collectLiveRegions();
208
209 // Summarize size
210 long totalSize = 0;
211 for (int i = 0; i < liveRegions.size(); i += 2) {
212 Address bottom = (Address) liveRegions.get(i);
213 Address top = (Address) liveRegions.get(i+1);
214 totalSize += top.minus(bottom);
215 }
216 visitor.prologue(totalSize);
217
218 for (int i = 0; i < liveRegions.size(); i += 2) {
219 Address bottom = (Address) liveRegions.get(i);
220 Address top = (Address) liveRegions.get(i+1);
221
222 // Traverses the space from bottom to top
223 while (bottom.lessThan(top)) {
224 visitor.visitAddress(bottom);
225 bottom = bottom.addOffsetTo(VM.getVM().getAddressSize());
226 }
227 }
228
229 visitor.epilogue();
230 }
231
232 public boolean isValidMethod(Address handle) {
233 try {
234 Method m = (Method)Metadata.instantiateWrapperFor(handle);
235 return true;
236 } catch (Exception e) {
237 return false;
238 }
239 }
240
241 // Creates an instance from the Oop hierarchy based based on the handle
242 public Oop newOop(OopHandle handle) {
243 // The only known way to detect the right type of an oop is
244 // traversing the class chain until a well-known klass is recognized.
245 // A more direct solution would require the klasses to expose
246 // the C++ vtbl structure.
247
248 // Handle the null reference
249 if (handle == null) return null;
250
251 // Then check if obj.klass() is one of the root objects
252 Klass klass = Oop.getKlassForOopHandle(handle);
253 if (klass != null) {
254 if (klass instanceof TypeArrayKlass) return new TypeArray(handle, this);
255 if (klass instanceof ObjArrayKlass) return new ObjArray(handle, this);
256 if (klass instanceof InstanceKlass) return new Instance(handle, this);
257 }
258
259 if (DEBUG) {
260 System.err.println("Unknown oop at " + handle);
261 System.err.println("Oop's klass is " + klass);
262 }
263
264 throw new UnknownOopException();
265 }
266
267 // Print all objects in the object heap
268 public void print() {
269 HeapPrinter printer = new HeapPrinter(System.out);
270 iterate(printer);
271 }
272
273 //---------------------------------------------------------------------------
274 // Internals only below this point
275 //
276
277 private void iterateExact(HeapVisitor visitor, final Klass k) {
278 iterateLiveRegions(collectLiveRegions(), visitor, new ObjectFilter() {
279 public boolean canInclude(Oop obj) {
280 Klass tk = obj.getKlass();
281 // null Klass is seen sometimes!
282 return (tk != null && tk.equals(k));
283 }
284 });
285 }
286
287 private void iterateSubtypes(HeapVisitor visitor, final Klass k) {
288 iterateLiveRegions(collectLiveRegions(), visitor, new ObjectFilter() {
289 public boolean canInclude(Oop obj) {
290 Klass tk = obj.getKlass();
291 // null Klass is seen sometimes!
292 return (tk != null && tk.isSubtypeOf(k));
293 }
294 });
295 }
296
297 private void iterateLiveRegions(List liveRegions, HeapVisitor visitor, ObjectFilter of) {
298 // Summarize size
299 long totalSize = 0;
300 for (int i = 0; i < liveRegions.size(); i += 2) {
301 Address bottom = (Address) liveRegions.get(i);
302 Address top = (Address) liveRegions.get(i+1);
303 totalSize += top.minus(bottom);
304 }
305 visitor.prologue(totalSize);
306
307 CompactibleFreeListSpace cmsSpaceOld = null;
308 CollectedHeap heap = VM.getVM().getUniverse().heap();
309
310 if (heap instanceof GenCollectedHeap) {
311 GenCollectedHeap genHeap = (GenCollectedHeap) heap;
312 Generation genOld = genHeap.getGen(1);
313 if (genOld instanceof ConcurrentMarkSweepGeneration) {
314 ConcurrentMarkSweepGeneration concGen = (ConcurrentMarkSweepGeneration)genOld;
315 cmsSpaceOld = concGen.cmsSpace();
316 }
317 }
318
319 for (int i = 0; i < liveRegions.size(); i += 2) {
320 Address bottom = (Address) liveRegions.get(i);
321 Address top = (Address) liveRegions.get(i+1);
322
323 try {
324 // Traverses the space from bottom to top
325 OopHandle handle = bottom.addOffsetToAsOopHandle(0);
326
327 while (handle.lessThan(top)) {
328 Oop obj = null;
329
330 try {
331 obj = newOop(handle);
332 } catch (UnknownOopException exp) {
333 if (DEBUG) {
334 throw new RuntimeException(" UnknownOopException " + exp);
335 }
336 }
337 if (obj == null) {
338 //Find the object size using Printezis bits and skip over
339 long size = 0;
340
341 if ( (cmsSpaceOld != null) && cmsSpaceOld.contains(handle) ){
342 size = cmsSpaceOld.collector().blockSizeUsingPrintezisBits(handle);
343 }
344
345 if (size <= 0) {
346 //Either Printezis bits not set or handle is not in cms space.
347 throw new UnknownOopException();
348 }
349
350 handle = handle.addOffsetToAsOopHandle(CompactibleFreeListSpace.adjustObjectSizeInBytes(size));
351 continue;
352 }
353 if (of == null || of.canInclude(obj)) {
354 if (visitor.doObj(obj)) {
355 // doObj() returns true to abort this loop.
356 break;
357 }
358 }
359 if ( (cmsSpaceOld != null) && cmsSpaceOld.contains(handle)) {
360 handle = handle.addOffsetToAsOopHandle(CompactibleFreeListSpace.adjustObjectSizeInBytes(obj.getObjectSize()) );
361 } else {
362 handle = handle.addOffsetToAsOopHandle(obj.getObjectSize());
363 }
364 }
365 }
366 catch (AddressException e) {
367 // This is okay at the top of these regions
368 }
369 catch (UnknownOopException e) {
370 // This is okay at the top of these regions
371 }
372 }
373
374 visitor.epilogue();
375 }
376
377 private void addLiveRegions(String name, List input, List output) {
378 for (Iterator itr = input.iterator(); itr.hasNext();) {
379 MemRegion reg = (MemRegion) itr.next();
380 Address top = reg.end();
381 Address bottom = reg.start();
382 if (Assert.ASSERTS_ENABLED) {
383 Assert.that(top != null, "top address in a live region should not be null");
384 }
385 if (Assert.ASSERTS_ENABLED) {
386 Assert.that(bottom != null, "bottom address in a live region should not be null");
387 }
388 output.add(top);
389 output.add(bottom);
390 if (DEBUG) {
391 System.err.println("Live region: " + name + ": " + bottom + ", " + top);
392 }
393 }
394 }
395
396 private class LiveRegionsCollector implements SpaceClosure {
397 LiveRegionsCollector(List l) {
398 liveRegions = l;
399 }
400
401 public void doSpace(Space s) {
402 addLiveRegions(s.toString(), s.getLiveRegions(), liveRegions);
403 }
404 private List liveRegions;
405 }
406
407 // Returns a List<Address> where the addresses come in pairs. These
408 // designate the live regions of the heap.
409 private List collectLiveRegions() {
410 // We want to iterate through all live portions of the heap, but
411 // do not want to abort the heap traversal prematurely if we find
412 // a problem (like an allocated but uninitialized object at the
413 // top of a generation). To do this we enumerate all generations'
414 // bottom and top regions, and factor in TLABs if necessary.
415
416 // List<Address>. Addresses come in pairs.
417 List liveRegions = new ArrayList();
418 LiveRegionsCollector lrc = new LiveRegionsCollector(liveRegions);
419
420 CollectedHeap heap = VM.getVM().getUniverse().heap();
421
422 if (heap instanceof GenCollectedHeap) {
423 GenCollectedHeap genHeap = (GenCollectedHeap) heap;
424 // Run through all generations, obtaining bottom-top pairs.
425 for (int i = 0; i < genHeap.nGens(); i++) {
426 Generation gen = genHeap.getGen(i);
427 gen.spaceIterate(lrc, true);
428 }
429 } else if (heap instanceof ParallelScavengeHeap) {
430 ParallelScavengeHeap psh = (ParallelScavengeHeap) heap;
431 PSYoungGen youngGen = psh.youngGen();
432 // Add eden space
433 addLiveRegions("eden", youngGen.edenSpace().getLiveRegions(), liveRegions);
434 // Add from-space but not to-space
435 addLiveRegions("from", youngGen.fromSpace().getLiveRegions(), liveRegions);
436 PSOldGen oldGen = psh.oldGen();
437 addLiveRegions("old ", oldGen.objectSpace().getLiveRegions(), liveRegions);
438 } else if (heap instanceof G1CollectedHeap) {
439 G1CollectedHeap g1h = (G1CollectedHeap) heap;
440 g1h.heapRegionIterate(lrc);
441 } else {
442 if (Assert.ASSERTS_ENABLED) {
443 Assert.that(false, "Expecting GenCollectedHeap, G1CollectedHeap, " +
444 "or ParallelScavengeHeap, but got " +
445 heap.getClass().getName());
446 }
447 }
448
449 // If UseTLAB is enabled, snip out regions associated with TLABs'
450 // dead regions. Note that TLABs can be present in any generation.
451
452 // FIXME: consider adding fewer boundaries to live region list.
453 // Theoretically only need to stop at TLAB's top and resume at its
454 // end.
455
456 if (VM.getVM().getUseTLAB()) {
457 for (JavaThread thread = VM.getVM().getThreads().first(); thread != null; thread = thread.next()) {
458 ThreadLocalAllocBuffer tlab = thread.tlab();
459 if (tlab.start() != null) {
460 if ((tlab.top() == null) || (tlab.end() == null)) {
461 System.err.print("Warning: skipping invalid TLAB for thread ");
462 thread.printThreadIDOn(System.err);
463 System.err.println();
464 } else {
465 if (DEBUG) {
466 System.err.print("TLAB for " + thread.getThreadName() + ", #");
467 thread.printThreadIDOn(System.err);
468 System.err.print(": ");
469 tlab.printOn(System.err);
470 }
471 // Go from:
472 // - below start() to start()
473 // - start() to top()
474 // - end() and above
475 liveRegions.add(tlab.start());
476 liveRegions.add(tlab.start());
477 liveRegions.add(tlab.top());
478 liveRegions.add(tlab.hardEnd());
479 }
480 }
481 }
482 }
483
484 // Now sort live regions
485 sortLiveRegions(liveRegions);
486
487 if (Assert.ASSERTS_ENABLED) {
488 Assert.that(liveRegions.size() % 2 == 0, "Must have even number of region boundaries");
489 }
490
491 if (DEBUG) {
492 System.err.println("liveRegions:");
493 for (int i = 0; i < liveRegions.size(); i += 2) {
494 Address bottom = (Address) liveRegions.get(i);
495 Address top = (Address) liveRegions.get(i+1);
496 System.err.println(" " + bottom + " - " + top);
497 }
498 }
499
500 return liveRegions;
501 }
502
503 private void sortLiveRegions(List liveRegions) {
504 Collections.sort(liveRegions, new Comparator() {
505 public int compare(Object o1, Object o2) {
506 Address a1 = (Address) o1;
507 Address a2 = (Address) o2;
508 if (AddressOps.lt(a1, a2)) {
509 return -1;
510 } else if (AddressOps.gt(a1, a2)) {
511 return 1;
512 }
513 return 0;
514 }
515 });
516 }
517 }