[GR-49708] Separate DynamicHub from HybridLayout.

PullRequest: graal/16090

Author: teshull

substratevm/src/com.oracle.svm.core.genscavenge/src/com/oracle/svm/core/genscavenge/ChunkedImageHeapPartition.java

@@ -39,6 +39,8 @@
 import com.oracle.svm.core.image.ImageHeapPartition;
 import com.oracle.svm.core.meta.SubstrateObjectConstant;
 
+import jdk.graal.compiler.debug.Assertions;
+
 /**
  * The image heap comes in partitions. Each partition holds objects with different properties
  * (read-only/writable, primitives/objects).
@@ -143,7 +145,7 @@ private NavigableMap<Long, Queue<ImageHeapObject>> createSortedObjectsMap() {
         for (ImageHeapObject obj : sorted) {
             long objSize = obj.getSize();
             if (objSize != currentObjectsSize) {
-                assert objSize > currentObjectsSize && objSize >= ConfigurationValues.getObjectLayout().getMinImageHeapObjectSize();
+                assert objSize > currentObjectsSize && objSize >= ConfigurationValues.getObjectLayout().getMinImageHeapObjectSize() : Assertions.errorMessage(obj, objSize);
                 currentObjectsSize = objSize;
                 currentQueue = new ArrayDeque<>();
                 map.put(currentObjectsSize, currentQueue);

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/config/ObjectLayout.java

@@ -54,6 +54,9 @@
  * object needs the field, the object is resized during garbage collection to accommodate the
  * field.</li>
  * </ol>
+ * 
+ * See this classes instantiation sites (such as {@code HostedConfiguration#createObjectLayout}) for
+ * more details on the exact object layout for a given configuration.
  */
 public final class ObjectLayout {
 

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/DynamicHub.java

@@ -132,7 +132,10 @@
 import sun.reflect.generics.factory.GenericsFactory;
 import sun.reflect.generics.repository.ClassRepository;
 
-@Hybrid
+/**
+ * Instantiations of this class have a special layout. See {@code DynamicHubLayout} for a
+ * description of how the object is arranged.
+ */
 @Substitute
 @TargetClass(java.lang.Class.class)
 @SuppressWarnings({"static-method", "serial"})
@@ -344,10 +347,10 @@ public final class DynamicHub implements AnnotatedElement, java.lang.reflect.Typ
      * match the assignee's type.
      */
     @UnknownObjectField(availability = AfterHostedUniverse.class)//
-    @Hybrid.TypeIDSlots private short[] typeCheckSlots;
+    private short[] typeCheckSlots;
 
     @UnknownObjectField(availability = AfterHostedUniverse.class)//
-    @Hybrid.Array private CFunctionPointer[] vtable;
+    private CFunctionPointer[] vtable;
 
     /** Field used for module information access at run-time. */
     private Module module;

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/Hybrid.java

@@ -29,21 +29,28 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import com.oracle.svm.core.config.ObjectLayout;
+import com.oracle.svm.core.monitor.MultiThreadedMonitorSupport;
+
 /**
  * Defines that the annotated class should have a Hybrid layout. Hybrid layouts are hybrids between
  * instance layouts and array layouts. The contents of a specified member array and (optional)
  * member type id slots are directly placed within the class layout. This saves one indirection when
  * accessing the array or type id slots.
- * 
+ *
+ * <p>
+ * The location of the identity hashcode is configuration-dependent and will follow the same
+ * placement convention as an array. The See {@link ObjectLayout} for more information on where the
+ * identity hash can be placed. @Hybrid objects are treated the same way as instance classes for
+ * determining whether (and where) they have a monitor slot; See {@link MultiThreadedMonitorSupport}
+ * for more information on monitor slot placement.
+ *
  * <pre>
  *    +--------------------------------------------------+
  *    | object header (same header as for arrays)        |
  *    +--------------------------------------------------+
  *    | array length                                     |
  *    +--------------------------------------------------+
- *    | type id slots (i.e., optional primitive data)    |
- *    |     ...                                          |
- *    +--------------------------------------------------+
  *    | instance fields (i.e., primitive or object data) |
  *    |     ...                                          |
  *    +--------------------------------------------------+
@@ -64,32 +71,7 @@
 public @interface Hybrid {
 
     /**
-     * The component type of the array part of the hybrid class. Must be specified if no field
-     * annotated with @{@link Hybrid.Array} is declared, otherwise that field's type determines the
-     * type of the array part.
+     * The component type of the array part of the hybrid class.
      */
-    Class<?> componentType() default void.class;
-
-    /**
-     * If {@code true}, allow the data in the hybrid fields to be duplicated between the hybrid
-     * object and a separate object for the array. For image heap objects, a duplication can occur
-     * if inlining and constant folding result in the internal reference to a hybrid field being
-     * folded to a constant value, which must be written into the image heap separately from the
-     * hybrid object.
-     *
-     * If {@code false}, a duplication of the hybrid fields must never happen.
-     */
-    boolean canHybridFieldsBeDuplicated() default false;
-
-    /** Designates at most one field that refers to the array part of the hybrid object. */
-    @Retention(RetentionPolicy.RUNTIME)
-    @Target(ElementType.FIELD)
-    @interface Array {
-    }
-
-    /** Designates at most one field that refers to the type ID slots of the hybrid object. */
-    @Retention(RetentionPolicy.RUNTIME)
-    @Target(ElementType.FIELD)
-    @interface TypeIDSlots {
-    }
+    Class<?> componentType();
 }

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/hub/LayoutEncoding.java

@@ -139,6 +139,11 @@ public static int forHybrid(ResolvedJavaType type, boolean objectElements, int a
         return forArrayLike(type, true, objectElements, arrayBaseOffset, arrayIndexShift);
     }
 
+    @Platforms(Platform.HOSTED_ONLY.class)
+    public static int forDynamicHub(ResolvedJavaType type, int vtableOffset, int vtableIndexShift) {
+        return forArrayLike(type, true, false, vtableOffset, vtableIndexShift);
+    }
+
     @Platforms(Platform.HOSTED_ONLY.class)
     private static int forArrayLike(ResolvedJavaType type, boolean isHybrid, boolean objectElements, int arrayBaseOffset, int arrayIndexShift) {
         assert isHybrid != type.isArray();

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/HostedConfiguration.java

@@ -51,11 +51,13 @@
 import com.oracle.svm.core.config.ObjectLayout.IdentityHashMode;
 import com.oracle.svm.core.graal.code.SubstrateMetaAccessExtensionProvider;
 import com.oracle.svm.core.graal.meta.RuntimeConfiguration;
+import com.oracle.svm.core.hub.DynamicHub;
 import com.oracle.svm.core.monitor.MultiThreadedMonitorSupport;
 import com.oracle.svm.hosted.analysis.Inflation;
 import com.oracle.svm.hosted.analysis.flow.SVMMethodTypeFlowBuilder;
 import com.oracle.svm.hosted.classinitialization.ClassInitializationSupport;
 import com.oracle.svm.hosted.code.CompileQueue;
+import com.oracle.svm.hosted.config.DynamicHubLayout;
 import com.oracle.svm.hosted.config.HybridLayout;
 import com.oracle.svm.hosted.config.HybridLayoutSupport;
 import com.oracle.svm.hosted.image.LIRNativeImageCodeCache;
@@ -66,8 +68,10 @@
 import com.oracle.svm.hosted.meta.HostedField;
 import com.oracle.svm.hosted.meta.HostedInstanceClass;
 import com.oracle.svm.hosted.meta.HostedMetaAccess;
+import com.oracle.svm.hosted.meta.HostedType;
 import com.oracle.svm.hosted.meta.HostedUniverse;
 import com.oracle.svm.hosted.substitute.AnnotationSubstitutionProcessor;
+import com.oracle.svm.util.ReflectionUtil;
 
 import jdk.graal.compiler.api.replacements.SnippetReflectionProvider;
 import jdk.graal.compiler.core.common.CompressEncoding;
@@ -162,6 +166,37 @@ public static ObjectLayout createObjectLayout(JavaKind referenceKind, IdentityHa
         return new ObjectLayout(target, referenceSize, objectAlignment, hubOffset, firstFieldOffset, arrayLengthOffset, arrayBaseOffset, headerIdentityHashOffset, identityHashMode);
     }
 
+    public static void initializeDynamicHubLayout(HostedMetaAccess hMeta) {
+        ImageSingletons.add(DynamicHubLayout.class, createDynamicHubLayout(hMeta));
+    }
+
+    private static DynamicHubLayout createDynamicHubLayout(HostedMetaAccess hMetaAccess) {
+        var dynamicHubType = hMetaAccess.lookupJavaType(Class.class);
+        var typeIDSlotsField = hMetaAccess.lookupJavaField(ReflectionUtil.lookupField(DynamicHub.class, "typeCheckSlots"));
+        var vtableField = hMetaAccess.lookupJavaField(ReflectionUtil.lookupField(DynamicHub.class, "vtable"));
+
+        ObjectLayout layout = ConfigurationValues.getObjectLayout();
+        int typeIDSlotsOffset = layout.getArrayLengthOffset() + layout.sizeInBytes(JavaKind.Int);
+        int typeIDSlotsSize = layout.sizeInBytes(typeIDSlotsField.getType().getComponentType().getStorageKind());
+
+        JavaKind vTableSlotStorageKind = vtableField.getType().getComponentType().getStorageKind();
+        int vTableSlotSize = layout.sizeInBytes(vTableSlotStorageKind);
+
+        return new DynamicHubLayout(layout, dynamicHubType, typeIDSlotsField, typeIDSlotsOffset, typeIDSlotsSize, vtableField, vTableSlotStorageKind, vTableSlotSize);
+    }
+
+    public static boolean isArrayLikeLayout(HostedType clazz) {
+        return HybridLayout.isHybrid(clazz) || DynamicHubLayout.singleton().isDynamicHub(clazz);
+    }
+
+    /**
+     * The hybrid array field and the type fields of the dynamic hub are directly inlined to the
+     * object to remove a level of indirection.
+     */
+    public static boolean isInlinedField(HostedField field) {
+        return HybridLayout.isHybridField(field) || DynamicHubLayout.singleton().isInlinedField(field);
+    }
+
     public SVMHost createHostVM(OptionValues options, ImageClassLoader loader, ClassInitializationSupport classInitializationSupport, AnnotationSubstitutionProcessor annotationSubstitutions) {
         return new SVMHost(options, loader, classInitializationSupport, annotationSubstitutions);
     }
@@ -191,16 +226,22 @@ public MetaAccessExtensionProvider createCompilationMetaAccessExtensionProvider(
     public void findAllFieldsForLayout(HostedUniverse universe, @SuppressWarnings("unused") HostedMetaAccess metaAccess,
                     @SuppressWarnings("unused") Map<AnalysisField, HostedField> universeFields,
                     ArrayList<HostedField> rawFields, ArrayList<HostedField> allFields, HostedInstanceClass clazz) {
+        DynamicHubLayout dynamicHubLayout = DynamicHubLayout.singleton();
         for (ResolvedJavaField javaField : clazz.getWrapped().getInstanceFields(false)) {
             AnalysisField aField = (AnalysisField) javaField;
             HostedField hField = universe.lookup(aField);
 
             /* Because of @Alias fields, the field lookup might not be declared in our class. */
             if (hField.getDeclaringClass().equals(clazz)) {
-                if (HybridLayout.isHybridField(hField)) {
+                if (dynamicHubLayout.isInlinedField(hField)) {
+                    /*
+                     * The typeid slots and the vtable of the dynamic hub are not materialized, so
+                     * they need no field offset.
+                     */
+                    allFields.add(hField);
+                } else if (HybridLayout.isHybridField(hField)) {
                     /*
-                     * The array or bitset field of a hybrid is not materialized, so it needs no
-                     * field offset.
+                     * The array field of a hybrid is not materialized, so it needs no field offset.
                      */
                     allFields.add(hField);
                 } else if (hField.isAccessed()) {

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/config/DynamicHubLayout.java

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2023, 2023, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.svm.hosted.config;
+
+import org.graalvm.nativeimage.ImageSingletons;
+
+import com.oracle.svm.core.config.ObjectLayout;
+import com.oracle.svm.core.hub.DynamicHub;
+import com.oracle.svm.core.hub.HubType;
+import com.oracle.svm.core.hub.Hybrid;
+import com.oracle.svm.core.hub.LayoutEncoding;
+import com.oracle.svm.core.monitor.MultiThreadedMonitorSupport;
+import com.oracle.svm.hosted.meta.HostedField;
+import com.oracle.svm.hosted.meta.HostedInstanceClass;
+import com.oracle.svm.hosted.meta.HostedType;
+
+import jdk.graal.compiler.core.common.NumUtil;
+import jdk.vm.ci.meta.JavaKind;
+
+/**
+ * Provides sizes and offsets of the {@link DynamicHub} class. Like {@link Hybrid} layouts,
+ * DynamicHubs contain both instance fields and a variable length array to hold the virtual dispatch
+ * table. In addition, to save a level of indirection, there is a fixed-length typeid slot directly
+ * placed within the dynamic hub.
+ *
+ * <p>
+ * The location of the identity hashcode is configuration-dependent and will follow the same
+ * placement convention as an array. See {@link ObjectLayout} for more information on where the
+ * identity hash can be placed. DynamicHubs never have a monitor slot; See
+ * {@link MultiThreadedMonitorSupport} for more information.
+ *
+ * <pre>
+ *    +--------------------------------------------------+
+ *    | object header (same header as for arrays)        |
+ *    +--------------------------------------------------+
+ *    | vtable length                                    |
+ *    +--------------------------------------------------+
+ *    | type id slots (i.e., primitive data)             |
+ *    |     ...                                          |
+ *    +--------------------------------------------------+
+ *    | instance fields (i.e., primitive or object data) |
+ *    |     ...                                          |
+ *    +--------------------------------------------------+
+ *    | vtable dispatch addresses (i.e., primitive data) |
+ *    |     ...                                          |
+ *    +--------------------------------------------------+
+ * </pre>
+ *
+ * <p>
+ * Like {@link Hybrid}, DynamicHub objects have an instance {@link HubType}, but a
+ * {@link LayoutEncoding} like an array. See the javadoc for {@link Hybrid} more details its
+ * implications.
+ */
+public class DynamicHubLayout {
+
+    private final ObjectLayout layout;
+    private final HostedInstanceClass dynamicHubType;
+    public final HostedField typeIDSlotsField;
+    public final int typeIDSlotsOffset;
+    public final int typeIDSlotsSize;
+    public final HostedField vTableField;
+    public final int vTableSlotSize;
+    public final JavaKind vTableSlotStorageKind;
+
+    /*
+     * This is calculated lazily, as it requires the dynamicHub's instance fields to be finalized
+     * before being calculated.
+     */
+    private int vTableOffset;
+
+    public DynamicHubLayout(ObjectLayout layout, HostedType dynamicHubType, HostedField typeIDSlotsField, int typeIDSlotsOffset, int typeIDSlotsSize, HostedField vTableField,
+                    JavaKind vTableSlotStorageKind, int vTableSlotSize) {
+        this.layout = layout;
+        this.dynamicHubType = (HostedInstanceClass) dynamicHubType;
+        this.typeIDSlotsField = typeIDSlotsField;
+        this.typeIDSlotsOffset = typeIDSlotsOffset;
+        this.typeIDSlotsSize = typeIDSlotsSize;
+        this.vTableField = vTableField;
+        this.vTableSlotStorageKind = vTableSlotStorageKind;
+        this.vTableSlotSize = vTableSlotSize;
+    }
+
+    public static DynamicHubLayout singleton() {
+        return ImageSingletons.lookup(DynamicHubLayout.class);
+    }
+
+    public JavaKind getVTableSlotStorageKind() {
+        return vTableSlotStorageKind;
+    }
+
+    public boolean isDynamicHub(HostedType type) {
+        return type.equals(dynamicHubType);
+    }
+
+    public boolean isInlinedField(HostedField field) {
+        return field.equals(typeIDSlotsField) || field.equals(vTableField);
+    }
+
+    public int getVTableSlotOffset(int index) {
+        return vTableOffset() + index * vTableSlotSize;
+    }
+
+    public int getTypeIDSlotsOffset(int index) {
+        return typeIDSlotsOffset + index * typeIDSlotsSize;
+    }
+
+    public int getVTableLengthOffset() {
+        return layout.getArrayLengthOffset();
+    }
+
+    public int vTableOffset() {
+        if (vTableOffset == 0) {
+            vTableOffset = NumUtil.roundUp(dynamicHubType.getAfterFieldsOffset(), vTableSlotSize);
+        }
+        return vTableOffset;
+    }
+
+    public long getTotalSize(int vtableLength) {
+        return layout.computeArrayTotalSize(getVTableSlotOffset(vtableLength), true);
+    }
+
+    public long getIdentityHashOffset(int vTableLength) {
+        return layout.getArrayIdentityHashOffset(getVTableSlotOffset(vTableLength));
+    }
+}