Merge pull request oracle#5 from Shopify/thermometer

Introduce the thermometer tool

Author: chrisseaton

.gitignore

@@ -50,4 +50,6 @@ test-output/
 workingsets.xml
 bench-results.json
 jmh_result.json
-/vm/src/installer/dist/
+/vm/src/installer/dist/
+/sdk/latest_graalvm
+/sdk/latest_graalvm_home

compiler/src/org.graalvm.compiler.core.common/src/org/graalvm/compiler/core/common/CancellationBailoutException.java

@@ -32,7 +32,7 @@ public final class CancellationBailoutException extends RetryableBailoutExceptio
 
     private static final long serialVersionUID = 6551793589275293360L;
 
-    public CancellationBailoutException() {
+    private CancellationBailoutException() {
         super("Compilation cancelled.");
     }
 

compiler/src/org.graalvm.compiler.truffle.runtime/src/org/graalvm/compiler/truffle/runtime/BackgroundCompileQueue.java

@@ -118,6 +118,15 @@ public int getQueueSize() {
         }
     }
 
+    public int getRunning() {
+        final ExecutorService threadPool = compilationExecutorService;
+        if (threadPool instanceof ThreadPoolExecutor) {
+            return ((ThreadPoolExecutor) threadPool).getActiveCount();
+        } else {
+            return 0;
+        }
+    }
+
     public void shutdownAndAwaitTermination(long timeout) {
         final ExecutorService threadPool;
         synchronized (this) {

compiler/src/org.graalvm.compiler.truffle.runtime/src/org/graalvm/compiler/truffle/runtime/GraalTruffleRuntime.java

@@ -59,6 +59,7 @@
 import org.graalvm.compiler.truffle.common.TruffleDebugJavaMethod;
 import org.graalvm.compiler.truffle.common.TruffleOutputGroup;
 import org.graalvm.compiler.truffle.runtime.BackgroundCompileQueue.Priority;
+import org.graalvm.compiler.truffle.runtime.debug.CompilationStatusListener;
 import org.graalvm.compiler.truffle.runtime.debug.StatisticsListener;
 import org.graalvm.compiler.truffle.runtime.debug.TraceASTCompilationListener;
 import org.graalvm.compiler.truffle.runtime.debug.TraceCallTreeListener;
@@ -391,6 +392,7 @@ public ResolvedJavaType resolveType(MetaAccessProvider metaAccess, String classN
     }
 
     protected void installDefaultListeners() {
+        CompilationStatusListener.install(this);
         TraceCompilationListener.install(this);
         TraceCompilationPolymorphismListener.install(this);
         TraceCallTreeListener.install(this);
@@ -854,6 +856,10 @@ public int getCompilationQueueSize() {
         return getCompileQueue().getQueueSize();
     }
 
+    public int getCompilationsRunning() {
+        return getCompileQueue().getRunning();
+    }
+
     public boolean isCompiling(OptimizedCallTarget optimizedCallTarget) {
         return optimizedCallTarget.isCompiling();
     }

compiler/src/org.graalvm.compiler.truffle.runtime/src/org/graalvm/compiler/truffle/runtime/debug/CompilationStateImpl.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2019, 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 org.graalvm.compiler.truffle.runtime.debug;
+
+import com.oracle.truffle.api.instrumentation.CompilationState;
+
+public class CompilationStateImpl implements CompilationState {
+
+    private final int queued;
+    private final int running;
+    private final int finished;
+    private final int failures;
+    private final int dequeues;
+    private final int deoptimizations;
+
+    public CompilationStateImpl(int queued, int running, int finished, int failures, int dequeues, int deoptimizations) {
+        this.queued = queued;
+        this.running = running;
+        this.finished = finished;
+        this.failures = failures;
+        this.dequeues = dequeues;
+        this.deoptimizations = deoptimizations;
+    }
+
+    @Override
+    public int getQueued() {
+        return queued;
+    }
+
+    @Override
+    public int getRunning() {
+        return running;
+    }
+
+    @Override
+    public int getFinished() {
+        return finished;
+    }
+
+    @Override
+    public int getFailed() {
+        return failures;
+    }
+
+    @Override
+    public int getDequeued() {
+        return dequeues;
+    }
+
+    @Override
+    public int getDeoptimizations() {
+        return deoptimizations;
+    }
+
+}

compiler/src/org.graalvm.compiler.truffle.runtime/src/org/graalvm/compiler/truffle/runtime/debug/CompilationStatusListener.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2019, 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 org.graalvm.compiler.truffle.runtime.debug;
+
+import com.oracle.truffle.api.frame.Frame;
+import com.oracle.truffle.api.instrumentation.CompilationState;
+import com.oracle.truffle.api.instrumentation.CompilationStateBackdoor;
+import org.graalvm.compiler.truffle.common.TruffleCompilerListener.CompilationResultInfo;
+import org.graalvm.compiler.truffle.common.TruffleCompilerListener.GraphInfo;
+import org.graalvm.compiler.truffle.runtime.*;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+public final class CompilationStatusListener extends AbstractGraalTruffleRuntimeListener {
+
+    private AtomicInteger finished = new AtomicInteger();
+    private AtomicInteger failures = new AtomicInteger();
+    private AtomicInteger dequeues = new AtomicInteger();
+    private AtomicInteger deoptimizations = new AtomicInteger();
+
+    private CompilationStatusListener(GraalTruffleRuntime runtime) {
+        super(runtime);
+        CompilationStateBackdoor.ACCESSOR = this::sampleCompilationState;
+    }
+
+    public static void install(GraalTruffleRuntime runtime) {
+        runtime.addListener(new CompilationStatusListener(runtime));
+    }
+
+    @Override
+    public synchronized void onCompilationDequeued(OptimizedCallTarget target, Object source, CharSequence reason) {
+        dequeues.getAndIncrement();
+    }
+
+    @Override
+    public synchronized void onCompilationInvalidated(OptimizedCallTarget target, Object source, CharSequence reason) {
+        // We count invalidations as deoptimizations
+        deoptimizations.getAndIncrement();
+    }
+
+    @Override
+    public synchronized void onCompilationSuccess(OptimizedCallTarget target, TruffleInlining inliningDecision, GraphInfo graph, CompilationResultInfo result) {
+        finished.getAndIncrement();
+    }
+
+    @Override
+    public synchronized void onCompilationFailed(OptimizedCallTarget target, String reason, boolean bailout, boolean permanentBailout) {
+        if (TraceCompilationListener.isPermanentFailure(bailout, permanentBailout)) {
+            failures.getAndIncrement();
+        }
+    }
+
+    @Override
+    public synchronized void onCompilationDeoptimized(OptimizedCallTarget target, Frame frame) {
+        deoptimizations.getAndIncrement();
+    }
+
+    public synchronized CompilationState sampleCompilationState() {
+        return new CompilationStateImpl(
+                runtime.getCompilationQueueSize(),
+                runtime.getCompilationsRunning(),
+                finished.get(),
+                failures.get(),
+                dequeues.get(),
+                deoptimizations.get());
+    }
+
+}

compiler/src/org.graalvm.compiler.truffle.runtime/src/org/graalvm/compiler/truffle/runtime/debug/TraceCompilationListener.java

@@ -187,7 +187,7 @@ private static void addSourceInfo(Map<String, Object> properties, Object source)
      * @see GraalTruffleRuntimeListener#onCompilationFailed(OptimizedCallTarget, String, boolean,
      *      boolean)
      */
-    private static boolean isPermanentFailure(boolean bailout, boolean permanentBailout) {
+    public static boolean isPermanentFailure(boolean bailout, boolean permanentBailout) {
         return !bailout || permanentBailout;
     }
 

tools/docs/Thermometer-Manual.md

@@ -0,0 +1,134 @@
+# The Truffle Optimization Thermometer Tool
+
+The Truffle Optimization Thermometer Tool indicates how *warmed-up* your
+application is. A *cold* application is running mostly in the interpreter, still
+has code to compile, may still loading new code, and may be deoptimizing. A
+*warmed up* application is stable and running mostly in compiled code.
+
+It's difficult to talk quantitively about how warm an application is, and there
+are many subtle factors at work here, so the tool is more of an *indication* than
+a *measurement*.
+
+See https://arxiv.org/abs/1602.00602 for some interesting discussion about
+virtual machine warmup.
+
+## Basic usage
+
+Take this example Ruby program. It renders an ERB template. Every now and again
+another thread swaps the template. After a few seconds a compilation will be
+attempted which will fail.
+
+```ruby
+require 'erb'
+
+template = ERB.new('The time is <%= time %>')
+
+Thread.new do
+  loop do
+    sleep 3 + rand(3)
+    template = ERB.new("The time was #{Time.now} but is now <%= time #{'    ' * 10_000} %>")
+  end
+end
+
+Thread.new do
+  sleep 3 + rand(3)
+  loop do
+    Truffle::Graal.bailout 'demo compilation failure'
+  end
+end
+
+dev_null = File.open('/dev/null', 'w')
+
+loop do
+  time = Time.now
+  dev_null.puts template.result(binding)
+end
+```
+
+Run with the `--thermometer` flag (we use
+`--vm.Dgraal.TruffleCompilationExceptionsAreThrown=true` to stop the
+compilation failure being re-tried).
+
+```
+% ruby --vm.Dgraal.TruffleCompilationExceptionsAreThrown=true --thermometer demo.rb
+```
+
+You'll see log lines like this:
+
+```
+[thermometer] INFO:   5.34s  🥶   39°    0.77 MB  25 ▶  2 ▶ 17  (  2, 28 )   0 ▼
+[thermometer] INFO:   5.67s  🥶   44°    0.77 MB  25 ▶  2 ▶ 17  (  2, 28 )   0 ▼
+[thermometer] INFO:   6.00s  🤔   73°    0.77 MB   0 ▶  0 ▶ 20  (  2, 43 )   0 ▼
+[thermometer] INFO:   6.34s  😊   97°    0.77 MB   0 ▶  0 ▶ 20  (  2, 43 )   0 ▼
+[thermometer] INFO:   6.67s  😊  100°    0.77 MB   0 ▶  0 ▶ 20  (  2, 43 )   0 ▼
+[thermometer] INFO:   7.00s  🤮   52°    0.84 MB  33 ▶  2 ▶ 26  (  2, 45 )   4 ▼
+[thermometer] INFO:   7.33s  🥶   48°    0.84 MB  40 ▶  2 ▶ 26  (  2, 45 )   4 ▼
+[thermometer] INFO:   7.67s  🤔   70°    0.84 MB  25 ▶  2 ▶ 27  (  2, 77 )   4 ▼
+[thermometer] INFO:   8.00s  🤔   85°    0.84 MB   4 ▶  2 ▶ 29  (  2, 88 )   4 ▼
+[thermometer] INFO:   8.33s  😊   94°    0.84 MB   0 ▶  1 ▶ 30  (  2, 92 )   4 ▼
+[thermometer] INFO:   8.67s  😊  100°    0.84 MB   0 ▶  1 ▶ 30  (  2, 92 )   4 ▼
+```
+
+* `6.34s` is how long the application has been running by wall clock
+* `🥶🤔😊` indicate very broadly whether the application is very cold, warming up, or warmed up
+* `73°` indicates the *temperature* - how much of the application is compiled - see *Mechanism* below for details of how this is calculated
+* `0.84 MB` is how much code has been loaded
+* The next three numbers are the current compilation backlog, running compilations, and finished compilations
+* The numbers in brackets are failures and dequeued compilations
+* The final number is deoptimizations and invalidations
+
+## Monitoring performance
+
+`--thermometer.IterationPoint=test.rb:24` will install an iterations-per-second
+counter on any statements at this location. You should ensure there is just one
+statement at this location as each statement run will count as an iteration.
+
+```
+[thermometer] INFO:   6.67s  🤮   79°    0.167 M i/s    0.81 MB   5 ▶  2 ▶ 24  (  3, 45 )   3 ▼
+```
+
+## Advanced usage
+
+* `--thermometer.SamplingPeriod=10` sets the sampling period in ms.
+
+* `--thermometer.ReportingPeriod=300` sets the reporting period in ms.
+
+## Mechanism
+
+The *temperature* is the percentage of samples taken during the period where the
+top-most Truffle method activation is running in compiled code. Method preludes
+set a per-thread flag to indicate whether they're compiled or not. A separate
+high-priority timer thread samples this flag.
+
+The indicator is set to `🥶` for a temperature `< 0.5`, `🤔` for `< 0.9`, and
+`😊` otherwise. If there was a deoptimization in the period, it is instead set
+to `🤮`. If there was a compilation error in the period, it is instead set to
+`😡`.
+
+The indicator isn't set higher than `🤔` if new code was loaded in the period.
+
+## Overhead
+
+Setting the flag is a volatile write. There is some method indirection in the
+interpreter. In compiled code the flag is set with these machine instructions.
+Note that the flag is set at the root of each logical method, not at the root of
+each compilation unit.
+
+```
+movabs    $counter,%rax
+movl      $0x1,field(%rax)
+lock addl $0x0,(%rsp)
+```
+
+## Issues
+
+There is a single flag, so the thermometer works best with applications with a
+single thread running most of the time.
+
+The sample flag is set for each guest-language method root, so a compilation
+unit may set it multiple times increasing overhead.
+
+Counters are `int` so may overflow during a very long running process.
+
+(The `#{'    ' * 10_000}` in the demo is there so code size can be seen to
+grow more easily.)

tools/mx.tools/mx_tools.py

@@ -208,6 +208,19 @@ def _tools_gate_runner(args, tasks):
     include_by_default=True,
 ))
 
+mx_sdk_vm.register_graalvm_component(mx_sdk_vm.GraalVmTool(
+    suite=_suite,
+    name='GraalVM Thermometer',
+    short_name='temp',
+    dir_name='thermometer',
+    license_files=[],
+    third_party_license_files=[],
+    dependencies=['Truffle'],
+    truffle_jars=['tools:TRUFFLE_THERMOMETER'],
+    support_distributions=['tools:TRUFFLE_THERMOMETER_GRAALVM_SUPPORT'],
+    include_by_default=True,
+))
+
 mx_sdk_vm.register_graalvm_component(mx_sdk_vm.GraalVmJdkComponent(
     suite=_suite,
     name='VisualVM',