[Truffle] Switch set_trace_func to the new instrumentation API.

jruby · Jul 5, 2015 · 698dde7 · 698dde7
1 parent 9c2d6e8
commit 698dde7
Showing 5 changed files with 129 additions and 121 deletions.
diff --git a/truffle/src/main/java/org/jruby/truffle/nodes/control/TraceNode.java b/truffle/src/main/java/org/jruby/truffle/nodes/control/TraceNode.java
diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/RubyContext.java b/truffle/src/main/java/org/jruby/truffle/runtime/RubyContext.java
@@ -167,7 +167,7 @@ public RubyContext(Ruby runtime, TruffleLanguage.Env env) {
         coreLibrary.initialize();
 
         featureManager = new FeatureManager(this);
-        traceManager = new TraceManager();
+        traceManager = new TraceManager(this);
         atExitManager = new AtExitManager(this);
 
         threadManager = new ThreadManager(this);

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/subsystems/AttachmentsManager.java b/truffle/src/main/java/org/jruby/truffle/runtime/subsystems/AttachmentsManager.java
@@ -63,8 +63,7 @@ public void notifyFailure(Node node, VirtualFrame virtualFrame, RuntimeException
             public AdvancedInstrumentRoot createInstrumentRoot(Probe probe, Node node) {
                 return new AdvancedInstrumentRoot() {
 
-                    @Node.Child
-                    private DirectCallNode callNode;
+                    @Child private DirectCallNode callNode;
 
                     @Override
                     public Object executeRoot(Node node, VirtualFrame frame) {
@@ -75,7 +74,16 @@ public Object executeRoot(Node node, VirtualFrame frame) {
 
                         if (callNode == null) {
                             CompilerDirectives.transferToInterpreterAndInvalidate();
+
                             callNode = insert(Truffle.getRuntime().createDirectCallNode(block.getCallTargetForBlocks()));
+
+                            if (callNode.isCallTargetCloningAllowed()) {
+                                callNode.cloneCallTarget();
+                            }
+
+                            if (callNode.isInlinable()) {
+                                callNode.forceInlining();
+                            }
                         }
 
                         callNode.call(frame, RubyArguments.pack(
@@ -85,8 +93,6 @@ public Object executeRoot(Node node, VirtualFrame frame) {
                                 block.getBlockCapturedInScope(),
                                 new Object[]{binding}));
 
-                        // TODO CS 7-May-15 why does this have a return value?
-
                         return null;
                     }
 
@@ -98,7 +104,7 @@ public String instrumentationInfo() {
                 };
             }
 
-        }, Object.class, info);
+        }, null, info);
 
         final Source source = context.getSourceManager().forFileBestFuzzily(file);
 

diff --git a/truffle/src/main/java/org/jruby/truffle/runtime/subsystems/TraceManager.java b/truffle/src/main/java/org/jruby/truffle/runtime/subsystems/TraceManager.java
@@ -9,35 +9,134 @@
  */
 package org.jruby.truffle.runtime.subsystems;
 
-import com.oracle.truffle.api.Assumption;
-import com.oracle.truffle.api.utilities.CyclicAssumption;
+import com.oracle.truffle.api.CompilerDirectives;
+import com.oracle.truffle.api.Truffle;
+import com.oracle.truffle.api.frame.VirtualFrame;
+import com.oracle.truffle.api.instrument.*;
+import com.oracle.truffle.api.nodes.DirectCallNode;
+import com.oracle.truffle.api.nodes.Node;
+import com.oracle.truffle.api.source.SourceSection;
+import com.oracle.truffle.api.utilities.ConditionProfile;
+import org.jruby.truffle.nodes.core.StringNodes;
+import org.jruby.truffle.runtime.RubyArguments;
+import org.jruby.truffle.runtime.RubyContext;
+import org.jruby.truffle.runtime.core.RubyBasicObject;
+import org.jruby.truffle.runtime.core.RubyBinding;
 import org.jruby.truffle.runtime.core.RubyProc;
 
+import java.util.ArrayList;
+import java.util.Collection;
+
 public class TraceManager {
 
-    private final CyclicAssumption traceAssumption = new CyclicAssumption("trace-func");
-    private RubyProc traceFunc = null;
+    private final RubyContext context;
+
+    private Collection<Instrument> instruments;
     private boolean isInTraceFunc = false;
 
-    public void setTraceFunc(RubyProc traceFunc) {
-        this.traceFunc = traceFunc;
-        traceAssumption.invalidate();
+    public TraceManager(RubyContext context) {
+        this.context = context;
     }
 
-    public RubyProc getTraceFunc() {
-        return traceFunc;
-    }
+    public void setTraceFunc(final RubyProc traceFunc) {
+        if (instruments != null) {
+            for (Instrument instrument : instruments) {
+                instrument.dispose();
+            }
+        }
 
-    public Assumption getTraceAssumption() {
-        return traceAssumption.getAssumption();
-    }
+        if (traceFunc == null) {
+            instruments = null;
+            return;
+        }
 
-    public boolean isInTraceFunc() {
-        return isInTraceFunc;
-    }
+        final AdvancedInstrumentResultListener listener = new AdvancedInstrumentResultListener() {
+
+            @Override
+            public void notifyResult(Node node, VirtualFrame virtualFrame, Object o) {
+            }
+
+            @Override
+            public void notifyFailure(Node node, VirtualFrame virtualFrame, RuntimeException e) {
+            }
+
+        };
+
+        final AdvancedInstrumentRootFactory factory = new AdvancedInstrumentRootFactory() {
+
+            @Override
+            public AdvancedInstrumentRoot createInstrumentRoot(Probe probe, Node node) {
+                final RubyBasicObject event = StringNodes.createString(context.getCoreLibrary().getStringClass(), "line");
+
+                final SourceSection sourceSection = node.getEncapsulatingSourceSection();
+
+                final RubyBasicObject file = StringNodes.createString(context.getCoreLibrary().getStringClass(), sourceSection.getSource().getName());
+                final int line = sourceSection.getStartLine();
+
+                return new AdvancedInstrumentRoot() {
+
+                    @Child private DirectCallNode callNode;
+
+                    private final ConditionProfile inTraceFuncProfile = ConditionProfile.createBinaryProfile();
+
+                    @Override
+                    public Object executeRoot(Node node, VirtualFrame frame) {
+                        if (!inTraceFuncProfile.profile(isInTraceFunc)) {
+                            final Object self = RubyArguments.getSelf(frame.getArguments());
+                            final int id = 0;
+                            final Object classname = self;
+
+                            final RubyBinding binding = new RubyBinding(
+                                    context.getCoreLibrary().getBindingClass(),
+                                    self,
+                                    frame.materialize());
+
+                            if (callNode == null) {
+                                CompilerDirectives.transferToInterpreterAndInvalidate();
+
+                                callNode = insert(Truffle.getRuntime().createDirectCallNode(traceFunc.getCallTargetForBlocks()));
+
+                                if (callNode.isCallTargetCloningAllowed()) {
+                                    callNode.cloneCallTarget();
+                                }
+
+                                if (callNode.isInlinable()) {
+                                    callNode.forceInlining();
+                                }
+                            }
+
+                            isInTraceFunc = true;
+
+                            callNode.call(frame, RubyArguments.pack(
+                                    traceFunc.getMethod(),
+                                    traceFunc.getDeclarationFrame(),
+                                    traceFunc.getSelfCapturedInScope(),
+                                    traceFunc.getBlockCapturedInScope(),
+                                    new Object[]{event, file, line, id, binding, classname}));
+
+                            isInTraceFunc = false;
+                        }
+
+                        return null;
+                    }
+
+                    @Override
+                    public String instrumentationInfo() {
+                        return "set_trace_func";
+                    }
+
+                };
+            }
+
+        };
+
+        instruments = new ArrayList<>();
 
-    public void setInTraceFunc(boolean isInTraceFunc) {
-        this.isInTraceFunc = isInTraceFunc;
+        for (Probe probe : Probe.findProbesTaggedAs(StandardSyntaxTag.STATEMENT)) {
+            final Instrument instrument = Instrument.create(listener, factory, null, "set_trace_func");
+            instruments.add(instrument);
+            probe.attach(instrument);
+        }
     }
 
 }
diff --git a/truffle/src/main/java/org/jruby/truffle/translator/BodyTranslator.java b/truffle/src/main/java/org/jruby/truffle/translator/BodyTranslator.java
@@ -2209,7 +2209,6 @@ public RubyNode visitNewlineNode(org.jruby.ast.NewlineNode node) {
             }
         }
 
-        lineSequence.add(new TraceNode(context, sourceSection));
         lineSequence.add(node.getNextNode().accept(this));
 
         lineSequence.get(0).setAtNewline();