seafoam 0.2

data/docs/getting-graphs.md

@@ -0,0 +1,47 @@
+# 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
+```
+
+## 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`.

data/examples/Fib.java

@@ -0,0 +1,24 @@
+/*
+ * % javac Fib.java
+ * % java -XX:CompileOnly=::fib -Dgraal.Dump=:2 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

@@ -0,0 +1,39 @@
+/*
+ * % 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

@@ -0,0 +1,15 @@
+// % node --experimental-options --engine.CompileOnly=fib --engine.Inlining=false --vm.Dgraal.Dump=Truffle:2 -f 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

@@ -0,0 +1,15 @@
+# % 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

@@ -0,0 +1,13 @@
+# % 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

@@ -0,0 +1,35 @@
+; 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

data/examples/java/IrreducibleDecompiled.java

@@ -0,0 +1,21 @@
+//
+// Source code recreated from a .class file by IntelliJ IDEA
+// (powered by Fernflower decompiler)
+//
+
+public class IrreducibleDecompiled {
+    private static volatile int intField;
+
+    public static int exampleIrreducible(boolean var0, int var1) {
+        int var2 = var1;
+        if (var0) {
+            var2 = var1 - 1;
+        }
+
+        while(var2 > 0) {
+            intField = var2--;
+        }
+
+        return var1;
+    }
+}

data/examples/java/JavaExamples.java

@@ -0,0 +1,418 @@
+/*
+ * % javac JavaExamples.java
+ * % java -XX:-UseOnStackReplacement '-XX:CompileCommand=dontinline,*::*' -XX:+PrintCompilation -Dgraal.Dump=:3 JavaExamples
+ */
+
+import java.lang.reflect.Field;
+import java.util.Random;
+import sun.misc.Unsafe;
+
+class JavaExamples {
+
+    private final static Random RANDOM = new Random();
+    private final static Unsafe UNSAFE = getUnsafe();
+    private final static long UNSAFE_MEMORY = UNSAFE.allocateMemory(1024);
+
+    public static void main(String[] args) {
+        if (args.length != 0) {
+            throw new UnsupportedOperationException("not expecting any arguments");
+        }
+
+        while (true) {
+            exampleLocalVariables(RANDOM.nextInt(), RANDOM.nextInt());
+            exampleLocalVariablesState(RANDOM.nextInt(), RANDOM.nextInt());
+            exampleArithOperator(RANDOM.nextInt(), RANDOM.nextInt());
+            exampleCompareOperator(RANDOM.nextInt(), RANDOM.nextInt());
+            try {
+              exampleExactArith(RANDOM.nextInt(), RANDOM.nextInt());
+            } catch (ArithmeticException e) { }
+            examplePhi(RANDOM.nextBoolean(), RANDOM.nextInt());
+            exampleSimpleCall(new ExampleObject(RANDOM.nextInt()), RANDOM.nextInt());
+            exampleInterfaceCallOneImpl(new OneImpl());
+            exampleInterfaceCallManyImpls(RANDOM.nextBoolean() ? new ManyImplsA() : new ManyImplsB());
+            exampleStaticCall(RANDOM.nextInt());
+            exampleStamp(RANDOM.nextInt());
+            exampleFullEscape(RANDOM.nextInt());
+            exampleNoEscape(RANDOM.nextInt());
+            examplePartialEscape(RANDOM.nextBoolean(), RANDOM.nextInt());
+            exampleIf(RANDOM.nextBoolean(), RANDOM.nextInt(), RANDOM.nextInt());
+            exampleIfNeverTaken(false, RANDOM.nextInt(), RANDOM.nextInt());
+            exampleIntSwitch(RANDOM.nextInt(3), RANDOM.nextInt(), RANDOM.nextInt(), RANDOM.nextInt());
+            exampleStringSwitch(new String[]{"foo", "bar", "baz"}[RANDOM.nextInt(3)], RANDOM.nextInt(), RANDOM.nextInt(), RANDOM.nextInt());
+            exampleWhile(RANDOM.nextInt(10));
+            exampleFor(RANDOM.nextInt(10));
+            exampleReducible(RANDOM.nextBoolean(), RANDOM.nextInt(10));
+            Irreducible.exampleIrreducible(RANDOM.nextBoolean(), RANDOM.nextInt(10));
+            exampleNestedWhile(RANDOM.nextInt(10));
+            exampleWhileBreak(RANDOM.nextInt(10));
+            exampleNestedWhileBreak(RANDOM.nextInt(10));
+            try {
+              exampleThrow();
+            } catch (RuntimeException e) { }
+            exampleCatch();
+            exampleThrowCatch();
+            exampleObjectAllocation(RANDOM.nextInt());
+            exampleArrayAllocation(RANDOM.nextInt(), RANDOM.nextInt());
+            exampleFieldWrite(new ExampleObject(RANDOM.nextInt()), RANDOM.nextInt());
+            exampleFieldRead(new ExampleObject(RANDOM.nextInt()));
+            exampleArrayWrite(new int[]{RANDOM.nextInt(), RANDOM.nextInt(), RANDOM.nextInt()}, RANDOM.nextInt(3), RANDOM.nextInt());
+            exampleArrayRead(new int[]{RANDOM.nextInt(), RANDOM.nextInt(), RANDOM.nextInt()}, RANDOM.nextInt(3));
+            exampleUnsafeRead(UNSAFE_MEMORY + RANDOM.nextInt(4) * 4);
+            exampleUnsafeWrite(UNSAFE_MEMORY + RANDOM.nextInt(4) * 4, RANDOM.nextInt());
+            exampleInstanceOfOneImpl(new OneImpl());
+            exampleInstanceOfManyImpls(RANDOM.nextBoolean() ? new ManyImplsA() : new ManyImplsB());
+            exampleSynchronized(new Object(), RANDOM.nextInt());
+            exampleDoubleSynchronized(new Object(), RANDOM.nextInt());
+            exampleLocalSynchronized(RANDOM.nextInt());
+        }
+    }
+
+    private static int exampleLocalVariables(int x, int y) {
+        int a = x + y;
+        return a * 2 + a;
+    }
+
+    private static int exampleLocalVariablesState(int x, int y) {
+        int a = x + y;
+        opaqueCall();
+        return a * 2 + a;
+    }
+
+    private static int exampleArithOperator(int x, int y) {
+        return x + y;
+    }
+
+    private static boolean exampleCompareOperator(int x, int y) {
+        return x <= y;
+    }
+
+    private static int exampleExactArith(int x, int y) throws ArithmeticException {
+        return Math.addExact(x, y);
+    }
+
+    private static int examplePhi(boolean condition, int x) {
+        final int a;
+        if (condition) {
+            a = opaqueCall();
+        } else {
+            a = opaqueCall();
+        }
+        return a + x;
+    }
+
+    private static int exampleSimpleCall(ExampleObject object, int x) {
+        return object.instanceCall(x);
+    }
+
+    private static int exampleInterfaceCallOneImpl(InterfaceOneImpl x) {
+        return x.interfaceCall();
+    }
+
+    private static int exampleInterfaceCallManyImpls(InterfaceManyImpls x) {
+        return x.interfaceCall();
+    }
+
+    private static int exampleStaticCall(int x) {
+        return staticCall(x);
+    }
+
+    private static int exampleStamp(int x) {
+        return x & 0x1234;
+    }
+
+    private static int exampleFullEscape(int x) {
+        final int[] a = new int[]{x};
+        objectField = a;
+        return a[0];
+    }
+
+    private static int exampleNoEscape(int x) {
+        final int[] a = new int[]{x};
+        return a[0];
+    }
+
+    private static int examplePartialEscape(boolean condition, int x) {
+        final int[] a = new int[]{x};
+        if (condition) {
+            objectField = a;
+            return a[0];
+        } else {
+            return a[0];
+        }
+    }
+
+    private static int exampleIf(boolean condition, int x, int y) {
+        final int a;
+        if (condition) {
+            intField = x;
+            a = x;
+        } else {
+            intField = y;
+            a = y;
+        }
+        return a;
+    }
+
+    private static int exampleIfNeverTaken(boolean condition, int x, int y) {
+        final int a;
+        if (condition) {
+            intField = x;
+            a = x;
+        } else {
+            intField = y;
+            a = y;
+        }
+        return a;
+    }
+
+    private static int exampleIntSwitch(int value, int x, int y, int z) {
+        final int a;
+        switch (value) {
+            case 0:
+                intField = x;
+                a = x;
+                break;
+            case 1:
+                intField = y;
+                a = y;
+                break;
+            default:
+                intField = z;
+                a = z;
+                break;
+        }
+        return a;
+    }
+
+    private static int exampleStringSwitch(String value, int x, int y, int z) {
+        final int a;
+        switch (value) {
+            case "foo":
+                intField = x;
+                a = x;
+                break;
+            case "bar":
+                intField = y;
+                a = y;
+                break;
+            default:
+                intField = z;
+                a = z;
+                break;
+        }
+        return a;
+    }
+
+    private static int exampleWhile(int count) {
+        int a = count;
+        while (a > 0) {
+            intField = a;
+            a--;
+        }
+        return count;
+    }
+
+    private static int exampleReducible(boolean condition, int count) {
+        int a = count;
+        if (condition) {
+            a = count - 1;
+        }
+        while (a > 0) {
+            intField = a;
+          inner:
+            a--;
+        }
+        return count;
+    }
+
+    private static int exampleFor(int count) {
+        for (int a = count; a > 0; a--) {
+            intField = a;
+        }
+        return count;
+    }
+
+    private static int exampleNestedWhile(int count) {
+        int a = count;
+        while (a > 0) {
+            int y = count;
+            while (y > 0) {
+                intField = a;
+                y--;
+            }
+            a--;
+        }
+        return count;
+    }
+
+    private static int exampleWhileBreak(int count) {
+        int a = count;
+        while (a > 0) {
+            if (a == 4) {
+                break;
+            }
+            intField = a;
+            a--;
+        }
+        return count;
+    }
+
+    private static int exampleNestedWhileBreak(int count) {
+        int a = count;
+        outer: while (a > 0) {
+            int b = count;
+            while (b > 0) {
+                if (b == 4) {
+                    break outer;
+                }
+                intField = a;
+                b--;
+            }
+            a--;
+        }
+        return count;
+    }
+
+    private static void exampleThrow() {
+        throw RUNTIME_EXCEPTION;
+    }
+
+    private static void exampleCatch() {
+      try {
+          exampleThrow();
+      } catch (RuntimeException e) {
+          objectField = e;
+      }
+    }
+
+    private static void exampleThrowCatch() {
+      try {
+          throw RUNTIME_EXCEPTION;
+      } catch (RuntimeException e) {
+      }
+    }
+
+    private static ExampleObject exampleObjectAllocation(int x) {
+        return new ExampleObject(x);
+    }
+
+    private static int[] exampleArrayAllocation(int x, int y) {
+        return new int[]{x, y};
+    }
+
+    private static void exampleFieldWrite(ExampleObject object, int x) {
+        object.x = x;
+    }
+
+    private static int exampleFieldRead(ExampleObject object) {
+        assert object != null; // otherwise this is a 'trivial' method and won't go past tier 1
+        return object.x;
+    }
+
+    private static void exampleArrayWrite(int[] array, int n, int x) {
+        array[n] = x;
+    }
+
+    private static int exampleArrayRead(int[] array, int n) {
+        return array[n];
+    }
+
+    private static int exampleUnsafeRead(long unsafeMemory) {
+        return UNSAFE.getInt(unsafeMemory);
+    }
+
+    private static void exampleUnsafeWrite(long unsafeMemory, int x) {
+        UNSAFE.putInt(unsafeMemory, x);
+    }
+
+    private static boolean exampleInstanceOfOneImpl(Object x) {
+        return x instanceof InterfaceOneImpl;
+    }
+
+    private static boolean exampleInstanceOfManyImpls(Object x) {
+        return x instanceof InterfaceManyImpls;
+    }
+
+    private static void exampleSynchronized(Object object, int x) {
+        synchronized (object) {
+            intField = x;
+        }
+    }
+
+    private static void exampleDoubleSynchronized(Object object, int x) {
+        synchronized (object) {
+            intField = x;
+        }
+        synchronized (object) {
+            intField = x;
+        }
+    }
+
+    private static void exampleLocalSynchronized(int x) {
+        final Object object = new Object();
+        synchronized (object) {
+            intField = x;
+        }
+    }
+
+    private static int opaqueCall() {
+        return RANDOM.nextInt();
+    }
+
+    private static int staticCall(int x) {
+        return x;
+    }
+
+    private static final RuntimeException RUNTIME_EXCEPTION = new RuntimeException();
+    private static volatile int intField;
+    private static volatile Object objectField;
+
+    private static class ExampleObject {
+        public int x;
+
+        public ExampleObject(int x) {
+            this.x = x;
+        }
+
+        public int instanceCall(int y) {
+            return x + y;
+        }
+    }
+
+    private interface InterfaceOneImpl {
+        int interfaceCall();
+    }
+
+    private static class OneImpl implements InterfaceOneImpl {
+        public int interfaceCall() {
+            return 14;
+        }
+    }
+
+    private interface InterfaceManyImpls {
+        int interfaceCall();
+    }
+
+    private static class ManyImplsA implements InterfaceManyImpls {
+        public int interfaceCall() {
+            return 14;
+        }
+    }
+
+    private static class ManyImplsB implements InterfaceManyImpls {
+        public int interfaceCall() {
+            return 14;
+        }
+    }
+
+    private static Unsafe getUnsafe() {
+        try {
+            final Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
+            theUnsafe.setAccessible(true);
+            return (Unsafe) theUnsafe.get(null);
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+}