seafoam 0.2

data/spec/seafoam/annotators/graal_spec.rb

@@ -0,0 +1,96 @@
+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', 2)
+        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 negated GuardNodes with "Guard not, else ..."' do
+        expect(@graph.nodes[561].props['negated']).to be true
+        expect(@graph.nodes[561].props[:label]).to start_with 'Guard not, else'
+      end
+
+      it 'annotates not negated GuardNodes with "Guard, else ..."' do
+        expect(@graph.nodes[559].props['negated']).to be false
+        expect(@graph.nodes[559].props[:label]).to start_with 'Guard, 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

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

data/spec/seafoam/bgv/bgv_parser_spec.rb

@@ -0,0 +1,144 @@
+require 'seafoam'
+
+require 'rspec'
+
+require_relative '../spec_helpers'
+
+describe Seafoam::BGV::BGVParser do
+  before :all do
+    @fib_java_bgv = File.expand_path('../../../examples/fib-java.bgv', __dir__)
+  end
+
+  it 'can read full files' do
+    Seafoam::SpecHelpers::SAMPLE_BGV.each do |file|
+      parser = Seafoam::BGV::BGVParser.new(File.new(file))
+      parser.read_file_header
+      parser.skip_document_props
+      loop do
+        index, = parser.read_graph_preheader
+        break unless index
+
+        parser.read_graph_header
+        parser.read_graph
+      end
+    end
+  end
+
+  it 'can skip full files' do
+    Seafoam::SpecHelpers::SAMPLE_BGV.each do |file|
+      parser = Seafoam::BGV::BGVParser.new(File.new(file))
+      parser.read_file_header
+      parser.skip_document_props
+      loop do
+        index, = parser.read_graph_preheader
+        break unless index
+
+        parser.skip_graph_header
+        parser.skip_graph
+      end
+    end
+  end
+
+  it 'can alternate skipping and reading full files' do
+    Seafoam::SpecHelpers::SAMPLE_BGV.each do |file|
+      parser = Seafoam::BGV::BGVParser.new(File.new(file))
+      parser.read_file_header
+      parser.skip_document_props
+      skip = false
+      loop do
+        index, = parser.read_graph_preheader
+        break unless index
+
+        if skip
+          parser.skip_graph_header
+          parser.skip_graph
+        else
+          parser.read_graph_header
+          parser.read_graph
+        end
+        skip = !skip
+      end
+    end
+  end
+
+  describe '#read_file_header' do
+    it 'produces a version' do
+      parser = Seafoam::BGV::BGVParser.new(File.new(@fib_java_bgv))
+      expect(parser.read_file_header).to eq [6, 1]
+    end
+
+    it 'raises an error for files which are not BGV' do
+      parser = Seafoam::BGV::BGVParser.new(File.new(File.expand_path('fixtures/not.bgv', __dir__)))
+      expect { parser.read_file_header }.to raise_error(EncodingError)
+    end
+
+    it 'raises an error for files which are an unsupported version of BGV' do
+      parser = Seafoam::BGV::BGVParser.new(File.new(File.expand_path('fixtures/unsupported.bgv', __dir__)))
+      expect { parser.read_file_header }.to raise_error(NotImplementedError)
+    end
+
+    it 'does not raise an error for an unsupported version of BGV if version_check is disabled' do
+      parser = Seafoam::BGV::BGVParser.new(File.new(File.expand_path('fixtures/unsupported.bgv', __dir__)))
+      expect(parser.read_file_header(version_check: false)).to eq [7, 2]
+    end
+  end
+
+  describe '#read_graph_preheader' do
+    it 'produces an index and id' do
+      parser = Seafoam::BGV::BGVParser.new(File.new(@fib_java_bgv))
+      parser.read_file_header
+      parser.skip_document_props
+      expect(parser.read_graph_preheader).to eq [0, 0]
+    end
+
+    it 'returns nil for end of file' do
+      parser = Seafoam::BGV::BGVParser.new(File.new(@fib_java_bgv))
+      parser.read_file_header
+      parser.skip_document_props
+      51.times do
+        expect(parser.read_graph_preheader).to_not be_nil
+        parser.skip_graph_header
+        parser.skip_graph
+      end
+      expect(parser.read_graph_preheader).to be_nil
+    end
+
+    it 'returns unique indicies' do
+      parser = Seafoam::BGV::BGVParser.new(File.new(@fib_java_bgv))
+      parser.read_file_header
+      parser.skip_document_props
+      indicies = []
+      5.times do
+        index, = parser.read_graph_preheader
+        expect(indicies).to_not include index
+        indicies.push index
+        parser.skip_graph_header
+        parser.skip_graph
+      end
+    end
+  end
+
+  describe '#read_graph_header' do
+    it 'produces an expected header' do
+      parser = Seafoam::BGV::BGVParser.new(File.new(@fib_java_bgv))
+      parser.read_file_header
+      parser.skip_document_props
+      parser.read_graph_preheader
+      header = parser.read_graph_header
+      expect(header[:props]['scope']).to eq 'main.Compiling.GraalCompiler.FrontEnd.PhaseSuite.GraphBuilderPhase'
+    end
+  end
+
+  describe '#read_graph' do
+    it 'produces an expected graph' do
+      parser = Seafoam::BGV::BGVParser.new(File.new(@fib_java_bgv))
+      parser.read_file_header
+      parser.skip_document_props
+      parser.read_graph_preheader
+      parser.read_graph_header
+      graph = parser.read_graph
+      expect(graph.nodes.size).to eq 22
+      expect(graph.edges.size).to eq 30
+    end
+  end
+end

data/spec/seafoam/bgv/fixtures/not.bgv

@@ -0,0 +1 @@
+foobarbaz

data/spec/seafoam/bgv/fixtures/unsupported.bgv

@@ -0,0 +1 @@
+BIGV

data/spec/seafoam/binary/io_binary_reader_spec.rb

@@ -0,0 +1,176 @@
+require 'stringio'
+
+require 'seafoam'
+
+require 'rspec'
+
+describe Seafoam::Binary::IOBinaryReader do
+  describe '#read_utf8' do
+    it 'reads a UTF-8 string' do
+      string = 'abc😀'
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new(string))
+      expect(reader.read_utf8(string.bytesize)).to eq string
+    end
+  end
+
+  describe '#read_bytes' do
+    it 'reads bytes' do
+      string = 'abc😀'
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new(string))
+      expect(reader.read_bytes(string.bytesize)).to eq "abc\xF0\x9F\x98\x80".force_encoding(Encoding::ASCII_8BIT)
+    end
+  end
+
+  describe '#read_float64' do
+    it 'reads a double-precision float' do
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new("#{[1.5].pack('G')}hello"))
+      expect(reader.read_float64).to eq 1.5
+    end
+  end
+
+  describe '#read_float32' do
+    it 'reads a single-precision float' do
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new("#{[1.5].pack('g')}hello"))
+      expect(reader.read_float32).to eq 1.5
+    end
+  end
+
+  describe '#read_sint64' do
+    it 'reads a signed 64-bit network-endian integer' do
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new("#{[1234].pack('q>')}hello"))
+      expect(reader.read_sint64).to eq 1234
+    end
+  end
+
+  describe '#read_sint32' do
+    it 'reads a signed 32-bit network-endian integer' do
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new("#{[1234].pack('l>')}hello"))
+      expect(reader.read_sint32).to eq 1234
+    end
+  end
+
+  describe '#read_sint16' do
+    it 'reads a signed 16-bit network-endian integer' do
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new("#{[1234].pack('s>')}hello"))
+      expect(reader.read_sint16).to eq 1234
+    end
+  end
+
+  describe '#read_sint8' do
+    it 'reads a signed 8-bit integer' do
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new("#{[-123].pack('c')}hello"))
+      expect(reader.read_sint8).to eq(-123)
+    end
+  end
+
+  describe '#read_uint8' do
+    it 'reads an unsigned 8-bit integer' do
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new("#{[212].pack('C')}hello"))
+      expect(reader.read_uint8).to eq 212
+    end
+  end
+
+  describe '#skip_float64' do
+    it 'skips 8 bytes' do
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('12345678x'))
+      reader.skip_float64
+      expect(reader.read_uint8).to eq 'x'.ord
+    end
+
+    it 'accepts a count' do
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('1234567812345678x'))
+      reader.skip_float64 2
+      expect(reader.read_uint8).to eq 'x'.ord
+    end
+  end
+
+  describe '#skip_float32' do
+    it 'skips 4 bytes' do
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('1234x'))
+      reader.skip_float32
+      expect(reader.read_uint8).to eq 'x'.ord
+    end
+
+    it 'accepts a count' do
+      reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('12341234x'))
+      reader.skip_float32 2
+      expect(reader.read_uint8).to eq 'x'.ord
+    end
+
+    describe '#skip_int64' do
+      it 'skips 8 bytes' do
+        reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('12345678x'))
+        reader.skip_int64
+        expect(reader.read_uint8).to eq 'x'.ord
+      end
+
+      it 'accepts a count' do
+        reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('1234567812345678x'))
+        reader.skip_int64 2
+        expect(reader.read_uint8).to eq 'x'.ord
+      end
+    end
+
+    describe '#skip_int32' do
+      it 'skips 4 bytes' do
+        reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('1234x'))
+        reader.skip_int32
+        expect(reader.read_uint8).to eq 'x'.ord
+      end
+
+      it 'accepts a count' do
+        reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('12341234x'))
+        reader.skip_int32 2
+        expect(reader.read_uint8).to eq 'x'.ord
+      end
+    end
+
+    describe '#skip_int16' do
+      it 'skips 2 bytes' do
+        reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('12x'))
+        reader.skip_int16
+        expect(reader.read_uint8).to eq 'x'.ord
+      end
+
+      it 'accepts a count' do
+        reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('1212x'))
+        reader.skip_int16 2
+        expect(reader.read_uint8).to eq 'x'.ord
+      end
+    end
+
+    describe '#skip_int8' do
+      it 'skips 1 byte' do
+        reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('1x'))
+        reader.skip_int8
+        expect(reader.read_uint8).to eq 'x'.ord
+      end
+
+      it 'accepts a count' do
+        reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('11x'))
+        reader.skip_int8 2
+        expect(reader.read_uint8).to eq 'x'.ord
+      end
+    end
+
+    describe '#skip' do
+      it 'skips n bytes' do
+        reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('123x'))
+        reader.skip 3
+        expect(reader.read_uint8).to eq 'x'.ord
+      end
+    end
+
+    describe '#eof?' do
+      it 'returns false when not at the end of file' do
+        reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new('123'))
+        expect(reader.eof?).to be false
+      end
+
+      it 'returns true when at the end of file' do
+        reader = Seafoam::Binary::IOBinaryReader.new(StringIO.new(''))
+        expect(reader.eof?).to be true
+      end
+    end
+  end
+end