seafoam 0.6 → 0.10

data/examples/ruby/ruby_examples.rb

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

data/lib/seafoam/annotators.rb

@@ -1,54 +0,0 @@
-module Seafoam
-  # Annotators are routines to read the graph and apply properties which tools,
-  # such as the render command, can use to show more understandable output.
-  module Annotators
-    # Apply all applicable annotators to a graph.
-    def self.apply(graph, options = {})
-      annotators.each do |annotator|
-        next unless annotator.applies?(graph)
-
-        # Record for information that the annotator annotated this graph.
-        annotated_by = graph.props[:annotated_by] ||= []
-        annotated_by.push annotator
-
-        # Run the annotator.
-        instance = annotator.new(options)
-        instance.annotate graph
-      end
-    end
-
-    # Get a list of all annotators in the system.
-    def self.annotators
-      # Get all subclasses of Annotator.
-      annotators = Annotator::SUBCLASSES.dup
-
-      # We want the FallbackAnnotator to run last.
-      annotators.delete FallbackAnnotator
-      annotators.push FallbackAnnotator
-
-      annotators
-    end
-  end
-
-  # The base class for all annotators. You must subclass this to be recognized
-  # as an annotator.
-  class Annotator
-    SUBCLASSES = []
-
-    def initialize(options = {})
-      @options = options
-    end
-
-    def applies?(_graph)
-      raise NotImplementedError
-    end
-
-    def annotate(_graph)
-      raise NotImplementedError
-    end
-
-    def self.inherited(annotator)
-      SUBCLASSES.push annotator
-    end
-  end
-end

data/lib/seafoam/config.rb

@@ -1,34 +0,0 @@
-module Seafoam
-  # Finds and loads configuration.
-  class Config
-    def initialize
-      @dot_dir = find_dot_dir
-    end
-
-    # Load the configuration.
-    def load_config
-      config_file = File.expand_path('config', @dot_dir)
-      if File.exist?(config_file)
-        puts "loading config #{config_file}" if $DEBUG
-        load config_file
-      end
-    end
-
-    private
-
-    # Walk up the directory chain from the current directory to root, looking
-    # for .seafoam.
-    def find_dot_dir
-      dir = Dir.getwd
-      loop do
-        dot_dir = File.expand_path('.seafoam', dir)
-        return dot_dir if Dir.exist?(dot_dir)
-
-        new_dir = File.expand_path('..', dir)
-        break if new_dir == dir
-
-        dir = new_dir
-      end
-    end
-  end
-end

data/seafoam.gemspec

@@ -1,21 +0,0 @@
-require_relative 'lib/seafoam/version'
-
-Gem::Specification.new do |spec|
-  spec.name     = 'seafoam'
-  spec.version  = Seafoam::VERSION
-  spec.summary  = 'A tool for working with compiler graphs'
-  spec.authors  = ['Chris Seaton']
-  spec.homepage = 'https://github.com/Shopify/seafoam'
-  spec.license = 'MIT'
-
-  spec.files = `git ls-files`.split("\n").reject { |f| f.end_with?('.bgv') || f.end_with?('.cfg') }
-  spec.bindir = 'bin'
-  spec.executables = %w[seafoam bgv2json bgv2isabelle cfg2asm]
-
-  spec.required_ruby_version = '>= 2.5.8'
-
-  spec.add_development_dependency 'benchmark-ips', '~> 2.7'
-  spec.add_development_dependency 'crabstone', '~> 4.0'
-  spec.add_development_dependency 'rspec', '~> 3.8'
-  spec.add_development_dependency 'rubocop', '~> 0.74'
-end

data/spec/seafoam/annotators/fallback_spec.rb

@@ -1,69 +0,0 @@
-require 'seafoam'
-
-require 'rspec'
-
-describe Seafoam::Annotators::FallbackAnnotator do
-  it 'always applies' do
-    expect(Seafoam::Annotators::FallbackAnnotator.applies?(Seafoam::Graph.new)).to be true
-  end
-
-  it 'adds a label annotation when there is a label property' do
-    graph = Seafoam::Graph.new
-    node = graph.create_node(0, 'label' => 'foo')
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(node.props[:label]).to eq 'foo'
-  end
-
-  it 'does not overwrite an existing label annotation' do
-    graph = Seafoam::Graph.new
-    node = graph.create_node(0, 'label' => 'foo', :label => 'bar')
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(node.props[:label]).to eq 'bar'
-  end
-
-  it 'adds nothing when there is no label property' do
-    graph = Seafoam::Graph.new
-    node = graph.create_node(0, 'xlabel' => 'foo')
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(node.props[:label]).to be nil
-  end
-
-  it 'sets node kind to other when there is no kind' do
-    graph = Seafoam::Graph.new
-    node = graph.create_node(0)
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(node.props[:kind]).to eq 'other'
-  end
-
-  it 'does not overwrite an existing node kind annotations' do
-    graph = Seafoam::Graph.new
-    node = graph.create_node(0, kind: 'control')
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(node.props[:kind]).to eq 'control'
-  end
-
-  it 'sets edge kind to other when there is no kind' do
-    graph = Seafoam::Graph.new
-    node_a = graph.create_node(0)
-    node_b = graph.create_node(1)
-    edge = graph.create_edge(node_a, node_b)
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(edge.props[:kind]).to eq 'other'
-  end
-
-  it 'does not overwrite an existing edge kind annotations' do
-    graph = Seafoam::Graph.new
-    node_a = graph.create_node(0)
-    node_b = graph.create_node(1)
-    edge = graph.create_edge(node_a, node_b, kind: 'control')
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(edge.props[:kind]).to eq 'control'
-  end
-end

data/spec/seafoam/annotators/graal_spec.rb

@@ -1,96 +0,0 @@
-require 'seafoam'
-
-require 'rspec'
-
-require_relative '../spec_helpers'
-
-describe Seafoam::Annotators::GraalAnnotator do
-  it 'applies to Graal graphs' do
-    expect(Seafoam::Annotators::GraalAnnotator.applies?(Seafoam::SpecHelpers.example_graph('fib-java', 0))).to be true
-  end
-
-  it 'does not apply to Truffle trees' do
-    expect(Seafoam::Annotators::GraalAnnotator.applies?(Seafoam::SpecHelpers.example_graph('fib-js', 0))).to be false
-  end
-
-  it 'applies to Truffle graphs' do
-    expect(Seafoam::Annotators::GraalAnnotator.applies?(Seafoam::SpecHelpers.example_graph('fib-js', 2))).to be true
-  end
-
-  describe 'when run' do
-    describe 'without options' do
-      before :all do
-        @graph = Seafoam::SpecHelpers.example_graph('matmult-ruby', 8)
-        annotator = Seafoam::Annotators::GraalAnnotator.new({})
-        annotator.annotate @graph
-      end
-
-      it 'annotates all nodes with a kind' do
-        expect(@graph.nodes.values.any? { |n| n.props[:kind].nil? }).to be_falsey
-      end
-
-      it 'annotates all nodes with a label' do
-        expect(@graph.nodes.values.any? { |n| n.props[:label].nil? }).to be_falsey
-      end
-
-      it 'annotates all edges with a kind' do
-        expect(@graph.edges.any? { |e| e.props[:kind].nil? }).to be_falsey
-      end
-
-      it 'annotates not negated GuardNodes with "Guard, else ..."' do
-        expect(@graph.nodes[7101].props['negated']).to be false
-        expect(@graph.nodes[7101].props[:label]).to start_with 'Guard, else'
-      end
-
-      it 'annotates negated GuardNodes with "Guard not, else ..."' do
-        expect(@graph.nodes[7102].props['negated']).to be true
-        expect(@graph.nodes[7102].props[:label]).to start_with 'Guard not, else'
-      end
-    end
-
-    describe 'with :hide_frame_state' do
-      before :all do
-        @graph = Seafoam::SpecHelpers.example_graph('matmult-ruby', 2)
-        annotator = Seafoam::Annotators::GraalAnnotator.new(hide_frame_state: true)
-        annotator.annotate @graph
-      end
-
-      it 'sets the hidden property on all frame state nodes' do
-        frame_state_nodes = @graph.nodes.values.select do |n|
-          Seafoam::Annotators::GraalAnnotator::FRAME_STATE_NODES.include?(n.props.dig(:node_class, :node_class))
-        end
-        expect(frame_state_nodes.all? { |n| n.props[:hidden] }).to be_truthy
-      end
-    end
-
-    describe 'with :hide_floating' do
-      before :all do
-        @graph = Seafoam::SpecHelpers.example_graph('matmult-ruby', 2)
-        annotator = Seafoam::Annotators::GraalAnnotator.new(hide_floating: true)
-        annotator.annotate @graph
-      end
-
-      it 'sets the hidden property on all nodes without a control edge' do
-        nodes_without_control_edge = @graph.nodes.values.select do |n|
-          n.edges.none? { |e| e.props[:kind] == 'control' }
-        end
-        expect(nodes_without_control_edge.all? { |n| n.props[:hidden] }).to be_truthy
-      end
-    end
-
-    describe 'with :reduce_edges' do
-      before :all do
-        @graph = Seafoam::SpecHelpers.example_graph('matmult-ruby', 2)
-        annotator = Seafoam::Annotators::GraalAnnotator.new(reduce_edges: true)
-        annotator.annotate @graph
-      end
-
-      it 'inlines all constant nodes' do
-        constant_nodes = @graph.nodes.values.select do |n|
-          Seafoam::Annotators::GraalAnnotator::SIMPLE_INPUTS.include?(n.props.dig(:node_class, :node_class))
-        end
-        expect(constant_nodes.all? { |n| n.props[:inlined] }).to be_truthy
-      end
-    end
-  end
-end

data/spec/seafoam/annotators_spec.rb

@@ -1,61 +0,0 @@
-require 'seafoam'
-
-require 'rspec'
-
-describe Seafoam::Annotators do
-  describe '#annotate' do
-    it 'asks annotators if they apply' do
-      check_applied = false
-
-      Class.new(Seafoam::Annotator) do
-        singleton_class.define_method(:applies?) do |_graph|
-          check_applied = true
-          false
-        end
-      end
-
-      Seafoam::Annotators.apply(Seafoam::Graph.new)
-      expect(check_applied).to be true
-    end
-
-    it 'runs annotators that apply' do
-      check_annotated = false
-
-      Class.new(Seafoam::Annotator) do
-        singleton_class.define_method(:applies?) do |_graph|
-          true
-        end
-
-        define_method(:annotate) do |_graph|
-          check_annotated = true
-        end
-      end
-
-      Seafoam::Annotators.apply(Seafoam::Graph.new)
-      expect(check_annotated).to be true
-    end
-  end
-
-  describe '#annotators' do
-    it 'returns the standard annotators' do
-      annotators = Seafoam::Annotators.annotators
-      expect(annotators).to include Seafoam::Annotators::FallbackAnnotator
-      expect(annotators).to include Seafoam::Annotators::GraalAnnotator
-    end
-
-    it 'returns custom annotators' do
-      custom_annotator = Class.new(Seafoam::Annotator) do
-        def self.applies?(_graph)
-          false
-        end
-      end
-      annotators = Seafoam::Annotators.annotators
-      expect(annotators).to include custom_annotator
-    end
-
-    it 'returns the FallbackAnnotator annotator last' do
-      annotators = Seafoam::Annotators.annotators
-      expect(annotators.last).to eq Seafoam::Annotators::FallbackAnnotator
-    end
-  end
-end