seafoam 0.8 → 0.12

data/bin/cfg2asm

@@ -1,24 +0,0 @@
-#!/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/demos/box-unbox-stats

@@ -1,65 +0,0 @@
-#!/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/annotators.md

@@ -1,43 +0,0 @@
-# Annotators
-
-The model of Seafoam is that it is a directed graph, with nodes annotated with a
-bag of key-value properties. When graphs are read they'll have some initial
-properties. Seafoam may add more properties. The output routines then draw the
-graph using the graph structure itself and also the properties.
-
-*Annotators* are routines that add extra properties to graphs to help the user
-understand them. They usually have knowledge of how the graph is structured, and
-use this to make the graph easier to read or to make important information in
-them stand out.
-
-We call properties with symbol keys *annotations*, as they're added by the
-annotators.
-
-Annotators are similar to filters in IGV.
-
-Appropriate annotators are automatically selected and applied to graphs.
-
-The rendering commands recognize these annotations, so annotators will probably
-want to add them:
-
-* `:label` on nodes and edges
-* `:out_annotation` on nodes
-* `:hidden` on nodes only, to not show them (*remove frame state* for example in IGV terminology)
-* `:inlined` on nodes only, to indicate the node should be shown immediately above each node using it (*reduce edges* in IGV terminology)
-* `:kind` on nodes only, which can be `info`, `input`, `control`, `effect`, `virtual`, `calc`, `guard`, or `other`
-* `:kind` on edges only, which can be `info`, `control`, `loop`, or `data`
-* `:reverse` on edges only
-* `:spotlight` for nodes as part of spotlighting (`lit` are shown, `shaded` are shown but greyed out, and edges from `shaded` to `:hidden` nodes are also shown greyed out)
-
-Seafoam ships with an annotator for generic GraalVM graphs. If you work with a
-different compiler you'll probably want to write your own annotators - subclass
-`Seafoam::Annotator` and implement `#annotate(graph)`. You can add custom
-annotators by requiring them in your `.seafoam/config`. All subclasses of
-`Annotator` will be found, so you just need to define the subclass.
-
-A fallback annotator, run after all others, just labels the node with the
-`'label'` property if there is one.
-
-Options for annotations can be set on the command line with `--option key
-value`. Some options are built into Seafoam commands, like `--show-frame-state`,
-but they're doing the same thing as `--option hide_frame_state false`.

data/docs/bgv.md

@@ -1,294 +0,0 @@
-# BGV File Format
-
-The BGV (*binary graph*, sometimes also called *BIGV*) file format is dumped by
-Graal graphs.
-
-The BGV parser was implemented from the [open-source writer code][graph-protocol]
-in the GraalVM compiler.
-
-[graph-protocol]: https://github.com/oracle/graal/blob/master/compiler/src/org.graalvm.graphio/src/org/graalvm/graphio/GraphProtocol.java
-
-## Format
-
-Seafoam supports BGV versions:
-
-* 7.0 (GraalVM 20.1.0 and up)
-* 6.1 (GraalVM 1.0.0-rc16 and up)
-
-The BGV file format is network-endian.
-
-```c
-BGV {
-  char[4] = 'BIGV'
-  sint8 major
-  sint8 minor
-  GroupDocumentGraph*
-}
-
-GroupDocumentGraph {
-  BeginGroup GroupDocumentGraph* CloseGroup | Document | Graph
-}
-
-BeginGroup {
-  sint8 token = BEGIN_GROUP
-  PoolObject name
-  PoolObject method
-  sint32 bci
-  Props props
-}
-
-CloseGroup {
-  sint8 token = CLOSE_GROUP
-}
-
-Document {
-  sint8 token = BEGIN_DOCUMENT
-  Pops props
-}
-
-Graph {
-  sint8 token = BEGIN_GRAPH
-  String format
-  Args args
-  GraphBody body
-}
-
-GraphBody {
-  Props props
-  sint32 nodes_count
-  Node[nodes_count] nodes
-  sint32 blocks_count
-  Blocks[blocks_count] blocks
-}
-
-Node {
-  sint32 id
-  PoolObject node_class
-  bool has_predecessor
-  Pops props
-  Edge[node_class.inputs.size] edges_in
-  Edge[node_class.outputs.size] edges_out
-}
-
-Edge {
-  sint32[inputs_count] nodes
-}
-
-Blocks {
-  sint32 id
-  sint32 nodes_count
-  sint32[nodes_count] nodes
-  sint32 followers_count
-  sint32[followers_count] followers
-}
-
-Props {
-  sint16 props_count
-  Prop[props_count] props
-}
-
-Prop {
-  PoolObject key
-  PropObject value
-}
-
-PropObject {
-  union {
-    struct {
-      sint8 PROPERTY_POOL
-      PoolObject object
-    }
-    struct {
-      sint8 PROPERTY_INT
-      sint32 value
-    }
-    struct {
-      sint8 PROPERTY_LONG
-      sint64 value
-    }
-    struct {
-      sint8 PROPERTY_DOUBLE
-      float64 value
-    }
-    struct {
-      sint8 PROPERTY_FLOAT
-      float32 value
-    }
-    struct {
-      sint8 PROPERTY_TRUE
-    }
-    struct {
-      sint8 PROPERTY_FALSE
-    }
-    struct {
-      sint8 PROPERTY_ARRAY
-      union {
-        struct {
-          sint8 PROPERTY_POOL
-          sint32 times
-          PoolObject[times] values
-        }
-      }
-    }
-    struct {
-      sint8 PROPERTY_SUBGRAPH
-      GraphBody graph
-    }
-  }
-}
-
-PoolObject {
-  union {
-    POOL_NULL
-    struct {
-      sint8 token = POOL_NEW
-      uint16 id
-      union {
-        struct {
-          sint8 type = POOL_STRING
-          String string
-        }
-        struct {
-          sint8 type = POOL_ENUM
-          PoolObject enum_class
-          sint32 enum_ordinal
-        }
-        struct {
-          sint8 type = POOL_CLASS
-          String type_name
-          union {
-            struct {
-              sint8 type = ENUM_KLASS
-              sint32 values_count
-              PoolObject values[values_count]
-            }
-            struct {
-              sint8 type = KLASS
-            }
-          }
-        }
-        struct {
-          sint8 type = POOL_METHOD
-          PoolObject declaring_class
-          PoolObject method_name
-          PoolObject signature
-          sint32 modifiers
-          sint32 bytes_length
-          uint8[bytes_length] bytes
-        }
-        struct {
-          sint8 type = POOL_NODE_CLASS
-          PoolObject node_class
-          String name_template
-          sint16 input_count
-          InputEdgeInfo inputs[input_count]
-          sint16 output_count
-          OutputEdgeInfo outputs[output_count]
-        }
-        struct {
-          sint8 type = POOL_FIELD
-          PoolObject field_class
-          PoolObject name
-          PoolObject type_name
-          sint32 modifiers
-        }
-        struct {
-          sint8 type = POOL_NODE_SIGNATURE
-          sint16 args_count
-          PoolObject args[args_count]
-        }
-        struct {
-          sint8 type = POOL_NODE_SOURCE_POSITION
-          PoolObject method
-          sint32 bci
-          SourcePosition source_positions[...until SourcePosition.uri = null]
-          PoolObject caller
-        }
-        struct {
-          sint8 type = POOL_NODE
-          sint32 node_id
-          PoolObject node_class
-        }
-      }
-    }
-    struct {
-      sint8 token = POOL_STRING | POOL_ENUM | POOL_CLASS | POOL_METHOD | POOL_NODE_CLASS | POOL_FIELD | POOL_SIGNATURE | POOL_NODE_SOURCE_POSITION | POOL_NODE
-      uint16 pool_id
-    }
-  }
-}
-
-InputEdgeInfo {
-  sint8 indirect
-  PoolObject name
-  PoolObject type
-}
-
-OutputEdgeInfo {
-  sint8 indirect
-  PoolObject name
-}
-
-SourcePosition {
-  PoolObject uri
-  String location
-  sint32 line
-  sint32 start
-  sint32 end
-}
-
-String {
-  sint32 length
-  char[length] chars
-}
-
-BEGIN_GROUP = 0x00
-BEGIN_GRAPH = 0x01
-CLOSE_GROUP = 0x02
-BEGIN_DOCUMENT = 0x03
-
-POOL_NEW = 0x00
-POOL_STRING = 0x01
-POOL_ENUM = 0x02
-POOL_CLASS = 0x03
-POOL_METHOD = 0x04
-POOL_NULL = 0x05
-POOL_NODE_CLASS = 0x06
-POOL_FIELD = 0x07
-POOL_SIGNATURE = 0x08
-POOL_NODE_SOURCE_POSITION = 0x09
-POOL_NODE = 0x0a
-
-PROPERTY_POOL = 0x00
-PROPERTY_INT = 0x01
-PROPERTY_LONG = 0x02
-PROPERTY_DOUBLE = 0x03
-PROPERTY_FLOAT = 0x04
-PROPERTY_TRUE = 0x05
-PROPERTY_FALSE = 0x06
-PROPERTY_ARRAY = 0x07
-PROPERTY_SUBGRAPH = 0x08
-
-KLASS = 0x00
-ENUM_KLASS = 0x01
-```
-
-## Seeking
-
-The BGV format is not particularly amenable to seeking. You must read each prior
-graph in order to read any subsequent graph, the length of nodes and edges
-depends on values within them, and there is an object pool that is incrementally
-built.
-
-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
-as it does so.

data/docs/getting-graphs.md

@@ -1,63 +0,0 @@
-# Getting Graphs
-
-## GraalVM Compiler as a Java compiler
-
-`-Dgraal.Dump=:2` is a simple option to enable Graal graph dumping.
-
-The value of `Dump` is a *dump filter*. The format of dump filters is
-[documented][dump-filters], but in simple cases `:2` will be enough and will
-give you everything.
-
-[dump-filters]: https://github.com/oracle/graal/blob/master/compiler/src/org.graalvm.compiler.debug/src/org/graalvm/compiler/debug/doc-files/DumpHelp.txt
-
-You may want to combine with `-XX:CompileOnly=Foo::foo` (you can omit the class
-part) to restrict  compilation to a single method to give smaller dumps, and to
-some extent make graphs simpler by avoiding what you want to look at being
-inlined, or other things being inlined into it.
-
-Graal tends to be quite aggressive about loop unrolling, which can produce
-massive graphs with the logic repeated. I often use these flags to simplify the
-graph without significantly effecting too much how the logic in it is compiled.
-
-```
-  -Dgraal.FullUnroll=false \
-  -Dgraal.PartialUnroll=false \
-  -Dgraal.LoopPeeling=false \
-  -Dgraal.LoopUnswitch=false \
-  -Dgraal.OptLoopTransform=false \
-  -Dgraal.OptScheduleOutOfLoops=false \
-  -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
-`--vm.`, for example `--vm.Dgraal.Dump=Truffle:2`.
-
-Use with `--engine.CompileOnly=foo`.
-
-A good filter to use for Truffle languages is `--vm.Dgraal.Dump=Truffle:1`,
-which will only give you Truffle compilations if you don't care about the
-whole Graal compilation pipeline.
-
-You may want to disable on-stack-replacement and inlining with
-`--engine.Inlining=false` and `--engine.OSR=false` in order to make graphs
-easier to understand.
-
-You may need to use `--experimental-options`.
-
-## Getting basic blocks
-
-To get the graph when scheduled, so that you can see basic blocks, use `-Dgraal.PrintGraphWithSchedule=true`. Truffle graphs beyond the initial stages have scheduling information by default.
-
-## Getting CFG files
-
-To also get CFG files, add `-Dgraal.PrintBackendCFG=true`, or `--vm.Dgraal.PrintBackendCFG=true` for Truffle.

data/docs/json.md

@@ -1,35 +0,0 @@
-# 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.java

@@ -1,24 +0,0 @@
-/*
- * % javac Fib.java
- * % java -XX:CompileOnly=::fib -Dgraal.Dump=:2 -Dgraal.PrintGraphWithSchedule=true Fib 14
- */
-
-class Fib {
-
-  public static void main(String[] args) {
-    while (true) {
-      for (String arg : args) {
-        fib(Integer.parseInt(args[0]));
-      }
-    }
-  }
-
-  public static int fib(int n) {
-    if (n <= 1) {
-      return n;
-    } else {
-      return fib(n - 1) + fib(n - 2);
-    }
-  }
-
-}

data/examples/MatMult.java

@@ -1,39 +0,0 @@
-/*
- * % javac MatMult.java
- * % java -XX:CompileOnly=::matmult -Dgraal.Dump=:2 MatMult 100
- */
-
-class MatMult {
-
-  public static void main(String[] args) {
-    while (true) {
-      for (String arg : args) {
-        final int size = Integer.parseInt(args[0]);
-        final double[][] a = new double[size][];
-        final double[][] b = new double[size][];
-        final double[][] c = new double[size][];
-        for (int n = 0; n < size; n++) {
-          a[n] = new double[size];
-          b[n] = new double[size];
-          c[n] = new double[size];
-          for (int m = 0; m < size; m++) {
-            a[n][m] = Math.random();
-            b[n][m] = Math.random();
-          }
-        }
-        matmult(size, a, b, c);
-      }
-    }
-  }
-
-  public static void matmult(int size, double[][] a, double[][] b, double[][] c) {
-    for(int i = 0; i < size; i++) {
-      for (int j = 0; j < size; j++) {
-        for (int k = 0; k < size; k++) {
-          c[i][j] += a[i][k] * b[k][j];
-        }
-      }
-    }
-  }
-
-}

data/examples/fib.js

@@ -1,15 +0,0 @@
-// % node --experimental-options --engine.CompileOnly=fib --engine.Inlining=false --vm.Dgraal.Dump=Truffle:2 fib.js 14
-
-function fib(n) {
-  if (n <= 1) {
-    return n;
-  } else {
-    return fib(n - 1) + fib(n - 2);
-  }
-}
-
-while (true) {
-  for (let n = 2; n < process.argv.length; n++) {
-    fib(parseInt(process.argv[n]));
-  }
-}

data/examples/fib.rb

@@ -1,15 +0,0 @@
-# % ruby --experimental-options --engine.CompileOnly=fib --engine.Inlining=false --engine.OSR=false --vm.Dgraal.Dump=Truffle:2 fib.rb 14
-
-def fib(n)
-  if n <= 1
-    n
-  else
-    fib(n - 1) + fib(n - 2)
-  end
-end
-
-loop do
-  ARGV.each do |arg|
-    fib(Integer(arg))
-  end
-end

data/examples/identity.rb

@@ -1,13 +0,0 @@
-# % ruby --experimental-options --engine.CompileOnly=identity --engine.Inlining=false --engine.OSR=false --vm.Dgraal.Dump=Truffle:2 identity.rb 1 2 3
-
-# The purpose of this identity function is to learn what the Truffle prelude looks like.
-
-def identity(arg)
-  arg
-end
-
-loop do
-  ARGV.each do |arg|
-    identity(Integer(arg))
-  end
-end

data/examples/java/Irreducible.j

@@ -1,35 +0,0 @@
-; https://github.com/Storyyeller/Krakatau
-; Krakatau/assemble.py Irreducible.j
-
-.class public Irreducible
-  .super java/lang/Object
-  .field private static volatile intField I
-
-  .method public static exampleIrreducible : (ZI)I
-    .code stack 1 locals 3
-
-      iload_1
-      istore_2
-      iload_0
-      ifeq L_start_of_loop
-
-      goto L_inside_loop
-
-    L_start_of_loop:
-      iload_2
-      ifle L_end_of_loop
-      iload_2
-      putstatic Field Irreducible intField I
-
-    L_inside_loop:
-      iinc 2 -1
-      goto L_start_of_loop
-
-    L_end_of_loop:
-      iload_1
-      ireturn
-
-    .end code
-  .end method
-
-.end class