com.oracle.svm.core.genscavenge

Class AlignedHeapChunk

java.lang.Object

com.oracle.svm.core.genscavenge.HeapChunk

com.oracle.svm.core.genscavenge.AlignedHeapChunk

public class AlignedHeapChunk
extends HeapChunk

An AlignedHeapChunk can hold many Objects.

This is the key to the chunk-allocated heap: Because these chunks are allocated on aligned boundaries, I can map from a Pointer to (or into) an Object to the AlignedChunk that contains it. From there I can get to the meta-data the AlignedChunk contains, without a table lookup on the Pointer.

Most allocation within a AlignedHeapChunk is via fast-path allocation snippets, but a slow-path allocation method is available.

Objects in a AlignedHeapChunk have to be promoted by copying from their current HeapChunk to a destination HeapChunk.

An Object in an AlignedHeapChunk can be pinned, by pinning the whole AlignedHeapChunk, so that promotion does not copy the objects in the AlignedHeapChunk, but moves the whole AlignedHeapChunk from one Space to another, that is, without changing the addresses of any of the Objects in the AlignedHeapChunk. An AlignedHeapChunk is laid out:

 +===============+-------+--------+----------------------+
 | AlignedHeader | Card  | First  | Object ...           |
 | Fields        | Table | Object |                      |
 |               |       | Table  |                      |
 +===============+-------+--------+----------------------+
 

The HeapChunk fields can be accessed via methods from HeapChunk, or more type-specifically via methods defined here. But the CardTable and the FirstObjectTable and the start of the Objects are just computed addresses. The two tables each need 1/512th of the size of the space for Objects, so I conservatively compute them as 1/512th of the size of the chunk.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static interface	AlignedHeapChunk.AlignedHeader Additional fields beyond what is in HeapChunk.Header.
protected static class	AlignedHeapChunk.MemoryWalkerAccessImpl Methods for a MemoryWalker to access an aligned heap chunk.
static class	AlignedHeapChunk.TestingBackDoor Expose some methods that should be protected.

Nested classes/interfaces inherited from class com.oracle.svm.core.genscavenge.HeapChunk

HeapChunk.Header<T extends HeapChunk.Header<T>>

Constructor Summary

Constructors

Constructor and Description
AlignedHeapChunk()

Method Summary

Modifier and Type	Method and Description
static void	dirtyCardForObjectOfAlignedHeapChunk(Object object, boolean verifyOnly) Dirty the card corresponding to the given Object.
static org.graalvm.word.UnsignedWord	getAlignedHeapOverhead() The overhead of an aligned chunk.
static MemoryWalker.HeapChunkAccess<AlignedHeapChunk.AlignedHeader>	getMemoryWalkerAccess()
protected static org.graalvm.word.UnsignedWord	usedObjectMemoryOfAlignedHeapChunk(AlignedHeapChunk.AlignedHeader that) How much space is used for the objects in an AlignedHeapChunk?

Methods inherited from class com.oracle.svm.core.genscavenge.HeapChunk

asPointer, availableObjectMemory, setTopCarefully, walkObjectsFrom

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

AlignedHeapChunk

public AlignedHeapChunk()

Method Detail

getAlignedHeapOverhead

public static org.graalvm.word.UnsignedWord getAlignedHeapOverhead()

The overhead of an aligned chunk. All of the overhead is before the start of the objects in the chunk.

usedObjectMemoryOfAlignedHeapChunk

protected static org.graalvm.word.UnsignedWord usedObjectMemoryOfAlignedHeapChunk(AlignedHeapChunk.AlignedHeader that)

How much space is used for the objects in an AlignedHeapChunk?

dirtyCardForObjectOfAlignedHeapChunk

public static void dirtyCardForObjectOfAlignedHeapChunk(Object object,
                                                        boolean verifyOnly)

Dirty the card corresponding to the given Object. This has to be fast, because it is used by the post-write barrier.

getMemoryWalkerAccess

public static MemoryWalker.HeapChunkAccess<AlignedHeapChunk.AlignedHeader> getMemoryWalkerAccess()