Remove virtual call to PythonNativeWrapper#getReplacement

Author: steve-s

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/capi/PyMemoryViewWrapper.java

@@ -159,7 +159,6 @@ private static Object allocate(PMemoryView object) {
         return mem;
     }
 
-    @Override
     public Object getReplacement(InteropLibrary lib) {
         if (replacement == null) {
             Object pointerObject = allocate((PMemoryView) getDelegate());

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/capi/PythonClassNativeWrapper.java

@@ -191,37 +191,40 @@ public String toString() {
         return PythonUtils.formatJString("PythonClassNativeWrapper(%s, isNative=%s)", getDelegate(), isNative());
     }
 
-    @Override
-    @TruffleBoundary
     public Object getReplacement(InteropLibrary lib) {
-        if (replacement == null) {
-            /*
-             * Note: it's important that we first allocate the empty 'PyTypeStruct' and register it
-             * to the wrapper before we do the type's initialization. Otherwise, we will run into an
-             * infinite recursion because, e.g., some type uses 'None', so the 'NoneType' will be
-             * transformed to native but 'NoneType' may have some field that is initialized with
-             * 'None' and so on.
-             *
-             * If we first set the empty struct and initialize it afterward, everything is fine.
-             */
-            PythonManagedClass clazz = (PythonManagedClass) getDelegate();
-            boolean heaptype = (GetTypeFlagsNode.executeUncached(clazz) & TypeFlags.HEAPTYPE) != 0;
-            long size = CStructs.PyTypeObject.size();
-            if (heaptype) {
-                size = CStructs.PyHeapTypeObject.size();
-                if (GetClassNode.executeUncached(clazz) instanceof PythonAbstractNativeObject nativeMetatype) {
-                    // TODO should call the metatype's tp_alloc
-                    size = TypeNodes.GetBasicSizeNode.executeUncached(nativeMetatype);
-                }
-            }
-            Object pointerObject = AllocateNode.allocUncached(size);
-            replacement = registerReplacement(pointerObject, true, lib);
-
-            ToNativeTypeNode.initializeType(this, pointerObject, heaptype);
+        if (CompilerDirectives.injectBranchProbability(CompilerDirectives.SLOWPATH_PROBABILITY, replacement == null)) {
+            initializeReplacement(lib);
         }
         return replacement;
     }
 
+    @TruffleBoundary
+    private void initializeReplacement(InteropLibrary lib) {
+        /*
+         * Note: it's important that we first allocate the empty 'PyTypeStruct' and register it to
+         * the wrapper before we do the type's initialization. Otherwise, we will run into an
+         * infinite recursion because, e.g., some type uses 'None', so the 'NoneType' will be
+         * transformed to native but 'NoneType' may have some field that is initialized with 'None'
+         * and so on.
+         *
+         * If we first set the empty struct and initialize it afterward, everything is fine.
+         */
+        PythonManagedClass clazz = (PythonManagedClass) getDelegate();
+        boolean heaptype = (GetTypeFlagsNode.executeUncached(clazz) & TypeFlags.HEAPTYPE) != 0;
+        long size = CStructs.PyTypeObject.size();
+        if (heaptype) {
+            size = CStructs.PyHeapTypeObject.size();
+            if (GetClassNode.executeUncached(clazz) instanceof PythonAbstractNativeObject nativeMetatype) {
+                // TODO should call the metatype's tp_alloc
+                size = TypeNodes.GetBasicSizeNode.executeUncached(nativeMetatype);
+            }
+        }
+        Object pointerObject = AllocateNode.allocUncached(size);
+        replacement = registerReplacement(pointerObject, true, lib);
+
+        ToNativeTypeNode.initializeType(this, pointerObject, heaptype);
+    }
+
     /**
      * Does not initialize the replacement.
      */

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/capi/PythonNativeWrapper.java

@@ -117,8 +117,9 @@ public final boolean isNative() {
      * <p>
      * Therefore, wrappers may return {@code true} and the appropriate <it>Python-to-native</it>
      * transition code will consider that and eagerly return the pointer object. If {@code true} is
-     * returned, the wrapper must also implement {@link #getReplacement(InteropLibrary)} which
-     * returns the pointer object. Furthermore, wrappers must use
+     * returned, the wrapper must also implement specialization in
+     * {@link com.oracle.graal.python.builtins.objects.cext.capi.transitions.GetReplacementNode}
+     * which returns the pointer object. Furthermore, wrappers must use
      * {@link #registerReplacement(Object, boolean, InteropLibrary)} to register the allocated
      * native memory in order that the native pointer can be resolved to the managed wrapper in the
      * <it>native-to-Python</it> transition.
@@ -134,10 +135,6 @@ public final void setReplacement(Object replacement) {
         this.replacement = replacement;
     }
 
-    public Object getReplacement(@SuppressWarnings("unused") InteropLibrary lib) {
-        throw CompilerDirectives.shouldNotReachHere();
-    }
-
     @TruffleBoundary
     public final Object registerReplacement(Object pointer, boolean freeAtCollection, InteropLibrary lib) {
         LOGGER.finest(() -> PythonUtils.formatJString("assigning %s with %s", getDelegate(), pointer));

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/capi/transitions/GetReplacementNode.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2023, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * The Universal Permissive License (UPL), Version 1.0
@@ -40,9 +40,12 @@
  */
 package com.oracle.graal.python.builtins.objects.cext.capi.transitions;
 
+import com.oracle.graal.python.builtins.objects.cext.capi.PyMemoryViewWrapper;
+import com.oracle.graal.python.builtins.objects.cext.capi.PythonClassNativeWrapper;
 import com.oracle.graal.python.builtins.objects.cext.capi.PythonNativeWrapper;
 import com.oracle.graal.python.builtins.objects.cext.capi.PythonNativeWrapper.PythonAbstractObjectNativeWrapper;
 import com.oracle.graal.python.runtime.PythonContext;
+import com.oracle.truffle.api.CompilerDirectives;
 import com.oracle.truffle.api.dsl.Cached.Shared;
 import com.oracle.truffle.api.dsl.GenerateCached;
 import com.oracle.truffle.api.dsl.GenerateInline;
@@ -60,27 +63,24 @@ public abstract class GetReplacementNode extends Node {
     public abstract Object execute(Node inliningTarget, PythonNativeWrapper wrapper);
 
     @Specialization(guards = "isReplacingWrapper(wrapper)")
-    static Object doReplacingWrapper(PythonNativeWrapper wrapper,
+    static Object doReplacingWrapper(PyMemoryViewWrapper wrapper,
                     @Shared @CachedLibrary(limit = "3") InteropLibrary lib) {
         return wrapper.getReplacement(lib);
     }
 
-    @Specialization(guards = "!isReplacingWrapper(wrapper)")
-    static Object doWrapper(Node inliningTarget, PythonNativeWrapper wrapper) {
-        if (wrapper instanceof PythonAbstractObjectNativeWrapper objectNativeWrapper && !PythonContext.get(inliningTarget).isNativeAccessAllowed()) {
-            // LLVM managed code path
-            return objectNativeWrapper;
-        }
-        return null;
+    @Specialization(guards = "isReplacingWrapper(wrapper)")
+    static Object doReplacingWrapper(PythonClassNativeWrapper wrapper,
+                    @Shared @CachedLibrary(limit = "3") InteropLibrary lib) {
+        return wrapper.getReplacement(lib);
     }
 
-    @Specialization(replaces = {"doReplacingWrapper", "doWrapper"})
-    static Object doGeneric(Node inliningTarget, PythonNativeWrapper wrapper,
-                    @Shared @CachedLibrary(limit = "3") InteropLibrary lib) {
+    @Specialization(guards = "isReplacingWrapper(wrapper)")
+    static Object doReplacingWrapper(PythonNativeWrapper wrapper) {
+        throw CompilerDirectives.shouldNotReachHere("Unexpected replacing wrapper");
+    }
 
-        if (wrapper.isReplacingWrapper()) {
-            return wrapper.getReplacement(lib);
-        }
+    @Specialization(guards = "!isReplacingWrapper(wrapper)")
+    static Object doWrapper(Node inliningTarget, PythonNativeWrapper wrapper) {
         if (wrapper instanceof PythonAbstractObjectNativeWrapper objectNativeWrapper && !PythonContext.get(inliningTarget).isNativeAccessAllowed()) {
             // LLVM managed code path
             return objectNativeWrapper;