Use inlined profiles

Author: otethal

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/code/CodeNodes.java

@@ -42,11 +42,11 @@
 
 import java.util.Arrays;
 
-import com.oracle.truffle.api.dsl.Bind;
 import org.graalvm.polyglot.io.ByteSequence;
 
 import com.oracle.graal.python.PythonLanguage;
 import com.oracle.graal.python.builtins.modules.MarshalModuleBuiltins;
+import com.oracle.graal.python.builtins.objects.code.CodeNodesFactory.GetCodeCallTargetNodeGen;
 import com.oracle.graal.python.builtins.objects.function.Signature;
 import com.oracle.graal.python.compiler.CodeUnit;
 import com.oracle.graal.python.nodes.IndirectCallNode;
@@ -63,18 +63,17 @@
 import com.oracle.truffle.api.Assumption;
 import com.oracle.truffle.api.CallTarget;
 import com.oracle.truffle.api.CompilerDirectives;
-import com.oracle.truffle.api.CompilerDirectives.CompilationFinal;
 import com.oracle.truffle.api.CompilerDirectives.TruffleBoundary;
 import com.oracle.truffle.api.RootCallTarget;
 import com.oracle.truffle.api.Truffle;
+import com.oracle.truffle.api.dsl.Bind;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.GenerateUncached;
 import com.oracle.truffle.api.dsl.NeverDefault;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.frame.VirtualFrame;
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.RootNode;
-import com.oracle.truffle.api.profiles.ConditionProfile;
 import com.oracle.truffle.api.profiles.InlinedConditionProfile;
 import com.oracle.truffle.api.source.Source;
 import com.oracle.truffle.api.strings.TruffleString;
@@ -183,69 +182,40 @@ public static CreateCodeNode create() {
         }
     }
 
-    public static final class GetCodeCallTargetNode extends Node {
-        private static final GetCodeCallTargetNode UNCACHED = new GetCodeCallTargetNode(false);
+    @GenerateUncached
+    public abstract static class GetCodeCallTargetNode extends PNodeWithContext {
 
-        private final boolean isAdoptable;
-        @CompilationFinal private ConditionProfile hasCtProfile;
-        @CompilationFinal private PCode cachedCode1;
-        @CompilationFinal private PCode cachedCode2;
-        @CompilationFinal private RootCallTarget cachedCt1;
-        @CompilationFinal private RootCallTarget cachedCt2;
+        GetCodeCallTargetNode() {
+        }
 
-        private GetCodeCallTargetNode(boolean isAdoptable) {
-            this.isAdoptable = isAdoptable;
+        public abstract RootCallTarget execute(PCode code);
+
+        @Specialization(guards = {"cachedCode == code", "isSingleContext()"}, limit = "2")
+        final RootCallTarget doCachedCode(@SuppressWarnings("unused") PCode code,
+                        @SuppressWarnings("unused") @Cached("code") PCode cachedCode,
+                        @Cached("code.initializeCallTarget()") RootCallTarget cachedRootCallTarget) {
+            return cachedRootCallTarget;
         }
 
-        public final RootCallTarget execute(PCode code) {
-            if (isAdoptable) {
-                if (hasCtProfile == null) {
-                    if (PythonLanguage.get(this).isSingleContext()) {
-                        if (cachedCode1 == null) {
-                            CompilerDirectives.transferToInterpreterAndInvalidate();
-                            cachedCode1 = code;
-                            cachedCt1 = code.initializeCallTarget();
-                            return cachedCt1;
-                        }
-                        if (cachedCode1 == code) {
-                            return cachedCt1;
-                        }
-                        if (cachedCode2 == null) {
-                            CompilerDirectives.transferToInterpreterAndInvalidate();
-                            cachedCode2 = code;
-                            cachedCt2 = code.initializeCallTarget();
-                            return cachedCt2;
-                        }
-                        if (cachedCode2 == code) {
-                            return cachedCt2;
-                        }
-                    }
-                    CompilerDirectives.transferToInterpreterAndInvalidate();
-                    cachedCode1 = cachedCode2 = null;
-                    cachedCt1 = cachedCt2 = null;
-                    hasCtProfile = ConditionProfile.create();
-                }
-                RootCallTarget ct = code.callTarget;
-                if (hasCtProfile.profile(ct == null)) {
-                    ct = code.initializeCallTarget();
-                }
-                return ct;
-            } else {
-                RootCallTarget ct = code.callTarget;
-                if (ct == null) {
-                    ct = code.initializeCallTarget();
-                }
-                return ct;
+        @Specialization(replaces = "doCachedCode")
+        final RootCallTarget doGeneric(PCode code,
+                        @Bind("this") Node inliningTarget,
+                        @Cached InlinedConditionProfile hasCtProfile) {
+            RootCallTarget ct = code.callTarget;
+            if (hasCtProfile.profile(inliningTarget, ct == null)) {
+                ct = code.initializeCallTarget();
             }
+            return ct;
         }
 
         @NeverDefault
         public static GetCodeCallTargetNode create() {
-            return new GetCodeCallTargetNode(true);
+            return GetCodeCallTargetNodeGen.create();
         }
 
+        @NeverDefault
         public static GetCodeCallTargetNode getUncached() {
-            return UNCACHED;
+            return GetCodeCallTargetNodeGen.getUncached();
         }
     }
 
@@ -297,7 +267,7 @@ public boolean isAdoptable() {
             return isAdoptable;
         }
 
-        public final RootNode execute(PCode code) {
+        public RootNode execute(PCode code) {
             if (getCodeCallTargetNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
                 getCodeCallTargetNode = insert(GetCodeCallTargetNode.create());