seafoam 0.2 → 0.7

data/bin/cfg2asm

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+require 'seafoam'
+
+# This is the 'cfg2asm' command line entry point.
+
+begin
+  # Load configuraiton.
+  config = Seafoam::Config.new
+  config.load_config
+
+  # Run the command line.
+  commands = Seafoam::Commands.new($stdout, config)
+  commands.cfg2asm(*ARGV)
+rescue StandardError => e
+  if $DEBUG
+    # Re-raise the exception so the user sees it, if debugging is
+    # enabled (ruby -d).
+    raise e
+  else
+    # Otherwise, just print the message.
+    warn "seafoam: #{e.message}"
+  end
+end

data/bin/seafoam

@@ -11,10 +11,10 @@ begin
 
   # Run the command line.
   commands = Seafoam::Commands.new($stdout, config)
-  commands.run(*ARGV)
+  commands.seafoam(*ARGV)
 rescue StandardError => e
   if $DEBUG
-    # Re-raise the exception so the user sees it, it debugging is
+    # Re-raise the exception so the user sees it, if debugging is
     # enabled (ruby -d).
     raise e
   else

data/demos/box-unbox-stats

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+
+# This demo analyses a directory full of graphs and looks for how many box nodes
+# take their value directly from an unbox node.
+
+require 'seafoam'
+
+box_nodes_count = 0
+box_nodes_from_unbox_count = 0
+
+graph_count = 0
+graph_match_count = 0
+
+ARGV.each do |dir|
+  Dir.glob(['*.bgv', '*.bgv.gz'], base: dir) do |file|
+    parser = Seafoam::BGV::BGVParser.new(File.join(dir, file))
+    parser.read_file_header
+    parser.skip_document_props
+
+    loop do
+      index, = parser.read_graph_preheader
+      break unless index
+
+      parser.skip_graph_header
+      graph = parser.read_graph
+
+      contains_box_unbox = false
+
+      graph.nodes.each_value do |node|
+        next unless node.props.dig(:node_class, :node_class).start_with?('org.graalvm.compiler.nodes.extended.BoxNode')
+
+        box_node = node
+        box_nodes_count += 1
+        value_edge = node.edges.find { |e| e.props[:name] == 'value' }
+        raise unless value_edge
+
+        value_node = value_edge.from
+        next unless value_node.props.dig(:node_class, :node_class).start_with?('org.graalvm.compiler.nodes.extended.UnboxNode')
+
+        unbox_node = value_node
+        box_nodes_from_unbox_count += 1
+        contains_box_unbox = true
+        puts "seafoam '#{File.join(dir, file)}:#{index}' render --spotlight #{box_node.id},#{unbox_node.id}"
+      end
+
+      graph_count += 1
+      graph_match_count += 1 if contains_box_unbox
+    end
+  end
+end
+
+if box_nodes_count.positive?
+  box_nodes_percent = (box_nodes_from_unbox_count / box_nodes_count.to_f) * 100
+else
+  box_nodes_percent = 0.0
+end
+
+if graph_count.positive?
+  graph_percent = (graph_match_count / graph_count.to_f) * 100
+else
+  graph_percent = 0.0
+end
+
+puts "     How many boxes take a value from an unbox?  #{box_nodes_percent.round(1)}%"
+puts "How many graphs contain at least one box-unbox?  #{graph_percent.round(1)}%"

data/docs/bgv.md

@@ -22,11 +22,11 @@ BGV {
   char[4] = 'BIGV'
   sint8 major
   sint8 minor
-  GroupOrGraph*
+  GroupDocumentGraph*
 }
 
-GroupOrGraph {
-  BeginGroup GroupOrGraph* CloseGroup | Graph
+GroupDocumentGraph {
+  BeginGroup GroupDocumentGraph* CloseGroup | Document | Graph
 }
 
 BeginGroup {
@@ -37,6 +37,15 @@ BeginGroup {
   Props props
 }
 
+CloseGroup {
+  sint8 token = CLOSE_GROUP
+}
+
+Document {
+  sint8 token = BEGIN_DOCUMENT
+  Pops props
+}
+
 Graph {
   sint8 token = BEGIN_GRAPH
   String format
@@ -72,10 +81,6 @@ Blocks {
   sint32[followers_count] followers
 }
 
-CloseGroup {
-  sint8 token = CLOSE_GROUP
-}
-
 Props {
   sint16 props_count
   Prop[props_count] props
@@ -278,6 +283,10 @@ In order to 'seek' BGV files we have two code paths for reading the file, one
 with loads the data and one which loads as little as possible to know just how
 much further to advance in the file.
 
+## Compression
+
+Seafoam supports compressed BGV files in the gzip file format.
+
 ## Other information
 
 `seafoam file.bgv debug` checks that a file can be parsed and prints information

data/docs/getting-graphs.md

@@ -29,6 +29,14 @@ graph without significantly effecting too much how the logic in it is compiled.
   -Dgraal.VectorizeLoops=false
 ```
 
+## GraalVM's Native Image compiler
+
+When using `native-image` you will want to use the `-H:` format.
+
+```
+% native-image -H:Dump=:2 -H:MethodFilter=fib Fib
+```
+
 ## TruffleRuby and other Truffle languages
 
 Use the same options as for GraalVM for Java, except they're prefixed with
@@ -45,3 +53,7 @@ You may want to disable on-stack-replacement and inlining with
 easier to understand.
 
 You may need to use `--experimental-options`.
+
+## Getting CFG files
+
+To also get CFG files, add `-Dgraal.PrintBackendCFG=true`, or `--vm.Dgraal.PrintBackendCFG=true` for Truffle.

data/docs/json.md

@@ -0,0 +1,35 @@
+# JSON Output Format
+
+The `bgv2json` command outputs files in [JSON Lines](https://jsonlines.org/) format - one JSON object for each graph, one per line.
+
+Each graph is of the format:
+
+```js
+{
+  "name": ...,
+  "props": {...},
+  "nodes": [...],
+  "edges": [...]
+}
+```
+
+Each node is of the format:
+
+```js
+{
+  "id": ...,
+  "props": {...}
+}
+```
+
+Each edge is of the format:
+
+```js
+{
+  "from": ..., // node id
+  "to": ..., // node id
+  "props": {...}
+}
+```
+
+Note that `bgv2json` runs annotations, so for example all nodes have a `"label"` property with an easy-to-use name.

data/examples/fib.js

@@ -1,4 +1,4 @@
-// % node --experimental-options --engine.CompileOnly=fib --engine.Inlining=false --vm.Dgraal.Dump=Truffle:2 -f fib.js 14
+// % node --experimental-options --engine.CompileOnly=fib --engine.Inlining=false --vm.Dgraal.Dump=Truffle:2 fib.js 14
 
 function fib(n) {
   if (n <= 1) {

data/examples/java/JavaExamples.java

@@ -1,6 +1,6 @@
 /*
  * % javac JavaExamples.java
- * % java -XX:-UseOnStackReplacement '-XX:CompileCommand=dontinline,*::*' -XX:+PrintCompilation -Dgraal.Dump=:3 JavaExamples
+ * % java -XX:-UseOnStackReplacement '-XX:CompileCommand=dontinline,*::*' -XX:+PrintCompilation -Dgraal.PrintBackendCFG=true -Dgraal.Dump=:3 JavaExamples
  */
 
 import java.lang.reflect.Field;

data/examples/ruby/clamps.rb

@@ -0,0 +1,20 @@
+# ruby --experimental-options --engine.CompileOnly=clamp_low,clamp_high --vm.Dgraal.Dump=Truffle:2 --vm.Dgraal.PrintBackendCFG=true clamps.rb 
+
+def clamp_high(min, max, value)
+  [min, max, value].sort[1]
+end
+
+def clamp_low(min, max, value)
+  if value > max
+    max
+  elsif value < min
+    min
+  else
+    value
+  end
+end
+
+loop do
+  clamp_high(10, 90, rand(100))
+  clamp_low(10, 90, rand(100))
+end

data/examples/ruby/graal.patch

@@ -0,0 +1,15 @@
+diff --git a/compiler/src/org.graalvm.compiler.truffle.compiler/src/org/graalvm/compiler/truffle/compiler/phases/inlining/DefaultInliningPolicy.java b/compiler/src/org.graalvm.compiler.truffle.compiler/src/org/graalvm/compiler/truffle/compiler/phases/inlining/DefaultInliningPolicy.java
+index ffe01c1688f..d662a7096c4 100644
+--- a/compiler/src/org.graalvm.compiler.truffle.compiler/src/org/graalvm/compiler/truffle/compiler/phases/inlining/DefaultInliningPolicy.java
++++ b/compiler/src/org.graalvm.compiler.truffle.compiler/src/org/graalvm/compiler/truffle/compiler/phases/inlining/DefaultInliningPolicy.java
+@@ -114,6 +114,10 @@ final class DefaultInliningPolicy implements InliningPolicy {
+         final PriorityQueue<CallNode> inlineQueue = getQueue(tree, CallNode.State.Expanded);
+         CallNode candidate;
+         while ((candidate = inlineQueue.poll()) != null) {
++            if (candidate.getName().startsWith("Object#opaque_") || candidate.getName().equals("Object#static_call") || candidate.getName().equals("ExampleObject#instance_call")) {
++                continue;
++            }
++
+             if (candidate.isTrivial()) {
+                 candidate.inline();
+                 continue;

data/examples/ruby/ruby_examples.rb

@@ -0,0 +1,278 @@
+# truffleruby_primitives: true
+
+# We're using Graal with graal.patch, to disable some inlining.
+
+# % ruby --jvm --experimental-options --engine.OSR=false --engine.MultiTier=false --engine.TraceCompilation --vm.Dgraal.Dump=Truffle:1 ruby_examples.rb
+
+RANDOM = Random.new
+EXCEPTION = Exception.new
+
+def example_local_variables(x, y)
+  a = x + y
+  a * 2 + a
+end
+
+def example_local_variables_state(x, y)
+  a = x + y
+  opaque_call
+  a * 2 + a
+end
+
+def example_arith_operator(x, y)
+  x + y
+end
+
+def example_compare_operator(x, y)
+  x <= y
+end
+
+def example_phi(condition, x)
+  if condition
+    a = opaque_call_a
+  else
+    a = opaque_call_b
+  end
+  a + x
+end
+
+def example_simple_call(object, x)
+  object.instance_call(x)
+end
+
+def example_stamp(x)
+  x & 0x1234
+end
+
+def example_full_escape(x)
+  a = [x]
+  Primitive.blackhole a
+  a[0]
+end
+
+def example_no_escape(x)
+  a = [x]
+  a[0]
+end
+
+def example_partial_escape(condition, x)
+  a = [x]
+  if condition
+    Primitive.blackhole a
+    a[0]
+  else
+    a[0]
+  end
+end
+
+def example_if(condition, x, y)
+  if condition
+    Primitive.blackhole x
+    a = x
+  else
+    Primitive.blackhole y
+    a = y
+  end
+  a
+end
+
+def example_if_never_taken(condition, x, y)
+  if condition
+    Primitive.blackhole x
+    a = x
+  else
+    Primitive.blackhole y
+    a = y
+  end
+  a
+end
+
+def example_int_switch(value, x, y, z)
+  case value
+  when 0
+    Primitive.blackhole x
+    a = x
+  when 1
+    Primitive.blackhole y
+    a = y
+  else
+    Primitive.blackhole z
+    a = z
+  end
+  a
+end
+
+def example_string_switch(value, x, y, z)
+  case value
+  when 'foo'
+    Primitive.blackhole x
+    a = x
+  when 'bar'
+    Primitive.blackhole y
+    a = y
+  else
+    Primitive.blackhole z
+    a = z
+  end
+  a
+end
+
+def example_while(count)
+  a = count
+  while a > 0
+    Primitive.blackhole a
+    a -= 1
+  end
+  count
+end
+
+def example_for(count)
+  count.times do |a|
+    Primitive.blackhole a
+  end
+end
+
+def example_nested_while(count)
+  a = count
+  while (a > 0)
+    y = count
+    while (y > 0)
+      Primitive.blackhole a
+      y -= 1
+    end
+    a -= 1
+  end
+  count
+end
+
+def example_while_break(count)
+  a = count
+  while a > 0
+    if a == 4
+      break
+    end
+    Primitive.blackhole a
+    a -= 1
+  end
+  count
+end
+
+def example_raise
+  raise EXCEPTION
+end
+
+def example_rescue
+  begin
+    opaque_raise
+  rescue Exception => e
+    Primitive.blackhole e
+  end
+end
+
+def example_raise_rescue
+  begin
+    raise EXCEPTION
+  rescue Exception => e
+    Primitive.blackhole e
+  end
+end
+
+def example_object_allocation(x)
+  ExampleObject.new(x)
+end
+
+def example_array_allocation(x, y)
+  [x, y]
+end
+
+def example_field_write(object, x)
+  object.x = x
+end
+
+def example_field_read(object)
+  object.x
+end
+
+def example_array_write(array, n, x)
+  array[n] = x
+end
+
+def example_array_read(array, n)
+  array[n]
+end
+
+def example_instance_of(x)
+  x.is_a?(ExampleObject)
+end
+
+# no inline
+def opaque_call
+  RANDOM.rand(1000)
+end
+
+# no inline
+def opaque_call_a
+  opaque_call
+end
+
+# no inline
+def opaque_call_b
+  opaque_call
+end
+
+# no inline
+def opaque_raise
+  raise EXCEPTION
+end
+
+# no inline
+def static_call(x)
+  x
+end
+
+class ExampleObject
+  attr_accessor :x
+  
+  def initialize(x)
+    @x = x
+  end
+
+  # no inline
+  def instance_call(y)
+    @x + y
+  end
+end
+
+loop do
+  example_local_variables RANDOM.rand(1000), RANDOM.rand(1000)
+  example_local_variables_state RANDOM.rand(1000), RANDOM.rand(1000)
+  example_arith_operator RANDOM.rand(1000), RANDOM.rand(1000)
+  example_compare_operator RANDOM.rand(1000), RANDOM.rand(1000)
+  example_phi [true, false].sample, RANDOM.rand(1000)
+  example_simple_call ExampleObject.new(RANDOM.rand(1000)), RANDOM.rand(1000)
+  example_stamp RANDOM.rand(1000)
+  example_full_escape RANDOM.rand(1000)
+  example_no_escape RANDOM.rand(1000)
+  example_partial_escape [true, false].sample, RANDOM.rand(1000)
+  example_if [true, false].sample, RANDOM.rand(1000), RANDOM.rand(1000)
+  example_if_never_taken false, RANDOM.rand(1000), RANDOM.rand(1000)
+  example_int_switch RANDOM.rand(3), RANDOM.rand(1000), RANDOM.rand(1000), RANDOM.rand(1000)
+  example_string_switch ['foo', 'bar', 'baz'].sample, RANDOM.rand(1000), RANDOM.rand(1000), RANDOM.rand(1000)
+  example_while RANDOM.rand(10)
+  example_for RANDOM.rand(10)
+  example_nested_while RANDOM.rand(10)
+  example_while_break RANDOM.rand(10)
+  begin
+    example_raise
+  rescue Exception => e
+    #
+  end
+  example_rescue
+  example_raise_rescue
+  example_object_allocation RANDOM.rand(1000)
+  example_array_allocation RANDOM.rand(1000), RANDOM.rand(1000)
+  example_field_write ExampleObject.new(RANDOM.rand(1000)), RANDOM.rand(1000)
+  example_field_read ExampleObject.new(RANDOM.rand(1000))
+  example_array_write [RANDOM.rand(1000), RANDOM.rand(1000), RANDOM.rand(1000)], RANDOM.rand(3), RANDOM.rand(1000)
+  example_array_read [RANDOM.rand(1000), RANDOM.rand(1000), RANDOM.rand(1000)], RANDOM.rand(3)
+  example_instance_of [Object.new, ExampleObject.new(0)].sample
+end