seafoam 0.13 → 0.14

data/lib/seafoam/passes/truffle.rb

@@ -1,15 +1,22 @@
+# frozen_string_literal: true
+
+require "tsort"
+
 module Seafoam
   module Passes
     # The Truffle pass applies if it looks like it was compiled by Truffle.
     class TrufflePass < Pass
-      def self.applies?(graph)
-        graph.props.values.any? do |v|
-          TRIGGERS.any? { |t| v.to_s.include?(t) }
+      class << self
+        def applies?(graph)
+          graph.props.values.any? do |v|
+            TRIGGERS.any? { |t| v.to_s.include?(t) }
+          end
         end
       end
 
       def apply(graph)
-        simplify_truffle_args graph if @options[:simplify_truffle_args]
+        simplify_truffle_args(graph) if @options[:simplify_truffle_args]
+        simplify_alloc(graph) if @options[:simplify_alloc]
       end
 
       private
@@ -18,41 +25,132 @@ module Seafoam
       # like a Graal parameter node.
       def simplify_truffle_args(graph)
         graph.nodes.dup.each_value do |node|
-          next unless node.props.dig(:node_class, :node_class) == 'org.graalvm.compiler.nodes.java.LoadIndexedNode'
+          next unless node.node_class == "org.graalvm.compiler.nodes.java.LoadIndexedNode"
 
-          index_node = node.inputs.find { |edge| edge.props[:name] == 'index' }.from
-          array_node = Graal::Pi.follow_pi_object(node.inputs.find { |edge| edge.props[:name] == 'array' }.from)
+          index_node = node.inputs.find { |edge| edge.props[:name] == "index" }.from
+          array_node = Graal::Pi.follow_pi_object(node.inputs.find { |edge| edge.props[:name] == "array" }.from)
 
-          next unless index_node.props.dig(:node_class, :node_class) == 'org.graalvm.compiler.nodes.ConstantNode'
-          next unless array_node.props.dig(:node_class, :node_class) == 'org.graalvm.compiler.nodes.ParameterNode'
+          next unless index_node.node_class == "org.graalvm.compiler.nodes.ConstantNode"
+          next unless array_node.node_class == "org.graalvm.compiler.nodes.ParameterNode"
 
           node.props[:truffle_arg_load] = true
 
-          index = index_node.props['rawvalue']
+          index = index_node.props["rawvalue"]
 
-          arg_node = graph.create_node(graph.new_id, { synthetic: true, inlined: true, label: "T(#{index})", kind: 'input' })
+          arg_node = graph.create_node(graph.new_id,
+            { synthetic: true, inlined: true, label: "T(#{index})", kind: "input" })
 
           node.outputs.each do |output|
-            next if output.props[:name] == 'next'
+            next if output.props[:name] == "next"
 
-            graph.create_edge arg_node, output.to, output.props.dup
-            graph.remove_edge output
+            graph.create_edge(arg_node, output.to, output.props.dup)
+            graph.remove_edge(output)
           end
         end
 
         graph.nodes.each_value.select { |node| node.props[:truffle_arg_load] }.each do |node|
-          control_in = node.inputs.find { |edge| edge.props[:name] == 'next' }
-          control_out = node.outputs.find { |edge| edge.props[:name] == 'next' }
-          graph.create_edge control_in.from, control_out.to, { name: 'next' }
-          graph.remove_edge control_in
-          graph.remove_edge control_out
+          control_in = node.inputs.find { |edge| edge.props[:name] == "next" }
+          control_out = node.outputs.find { |edge| edge.props[:name] == "next" }
+          graph.create_edge(control_in.from, control_out.to, { name: "next" })
+          graph.remove_edge(control_in)
+          graph.remove_edge(control_out)
+        end
+      end
+
+      # Hide nodes that are uninteresting inputs to an allocation node. These
+      # are constants that are null or 0.
+      def simplify_alloc(graph)
+        commit_allocation_nodes = graph.nodes.each_value.select do |node|
+          node.node_class == "org.graalvm.compiler.nodes.virtual.CommitAllocationNode"
+        end
+
+        commit_allocation_nodes.each do |commit_allocation_node|
+          control_flow_pred = commit_allocation_node.inputs.first
+          control_flow_next = commit_allocation_node.outputs.first
+
+          objects = []
+          virtual_to_object = {}
+
+          # First step to fill virtual_to_object and avoid ordering issues
+          commit_allocation_node.props.each_pair do |key, value|
+            m = /^object\((\d+)\)$/.match(key)
+            next unless m
+
+            virtual_id = m[1].to_i
+
+            (m = /^(\w+(?:\[\])?)\[([0-9,]+)\]$/.match(value)) || raise(value)
+            class_name, values = m.captures
+            values = values.split(",").map(&:to_i)
+            virtual_node = graph.nodes[virtual_id]
+            if virtual_node.node_class == "org.graalvm.compiler.nodes.virtual.VirtualArrayNode"
+              label = "New #{class_name[0...-1]}#{virtual_node.props["length"]}]"
+              fields = values.size.times.to_a
+            else
+              label = "New #{class_name}"
+              fields = virtual_node.props["fields"].map { |field| field[:name] }
+            end
+            raise unless fields.size == values.size
+
+            new_node = graph.create_node(graph.new_id, { synthetic: true, label: label, kind: "alloc" })
+
+            object = [new_node, virtual_node, fields, values]
+            objects << object
+            virtual_to_object[virtual_id] = object
+          end
+
+          # Topological sort of the new nodes in the control flow according to data dependencies
+          # There can be cycles (e.g., instances referring one another),
+          # so we use TSort.strongly_connected_components instead of TSort.tsort.
+          objects = TSort.strongly_connected_components(
+            objects.method(:each),
+            lambda do |(_new_node, _virtual_node, _fields, values), &b|
+              values.each do |value_id|
+                usage = virtual_to_object[value_id]
+                b.call(usage) if usage
+              end
+            end
+          ).reduce(:concat)
+
+          prev = control_flow_pred.from
+          objects.each do |new_node, virtual_node, fields, values|
+            graph.create_edge(prev, new_node, control_flow_pred.props)
+
+            allocated_object_node = virtual_node.outputs.find do |output|
+              output.to.node_class == "org.graalvm.compiler.nodes.virtual.AllocatedObjectNode"
+            end
+            if allocated_object_node
+              allocated_object_node = allocated_object_node.to
+
+              allocated_object_node.outputs.each do |edge|
+                graph.create_edge(new_node, edge.to, edge.props)
+              end
+
+              allocated_object_node.props[:hidden] = true
+            end
+
+            fields.zip(values) do |field, value_id|
+              value_node = virtual_to_object[value_id]&.first || graph.nodes[value_id]
+              if @options[:hide_null_fields] &&
+                  (value_node.node_class == "org.graalvm.compiler.nodes.ConstantNode") &&
+                  ["Object[null]", "0"].include?(value_node.props["rawvalue"])
+                value_node.props[:hidden] = true
+              else
+                graph.create_edge(value_node, new_node, { name: field })
+              end
+            end
+
+            virtual_node.props[:hidden] = true
+
+            prev = new_node
+          end
+          graph.create_edge(prev, control_flow_next.to, control_flow_next.props)
+
+          commit_allocation_node.props[:hidden] = true
         end
       end
 
       # If we see these in the graph properties it's probably a Truffle graph.
-      TRIGGERS = %w[
-        TruffleCompiler
-      ]
+      TRIGGERS = ["TruffleCompiler"]
     end
   end
 end

data/lib/seafoam/passes.rb

@@ -1,39 +1,43 @@
+# frozen_string_literal: true
+
 module Seafoam
   # Passes are routines to read the graph and apply properties which tools,
   # such as the render command, can use to show more understandable output.
   module Passes
-    # Apply all applicable passes to a graph.
-    def self.apply(graph, options = {})
-      passes.each do |pass|
-        next unless pass.applies?(graph)
-
-        # Record for information that the pass was applied this graph.
-        passes_applied = graph.props[:passes_applied] ||= []
-        passes_applied.push pass
-
-        # Run the pass.
-        instance = pass.new(options)
-        instance.apply graph
+    class << self
+      # Apply all applicable passes to a graph.
+      def apply(graph, options = {})
+        passes.each do |pass|
+          next unless pass.applies?(graph)
+
+          # Record for information that the pass was applied this graph.
+          passes_applied = graph.props[:passes_applied] ||= []
+          passes_applied.push(pass)
+
+          # Run the pass.
+          instance = pass.new(options)
+          instance.apply(graph)
+        end
       end
-    end
 
-    # Get a list of all passes in the system.
-    def self.passes
-      # We have a defined order for passes to run - these passes at the start.
-      pre_passes = [
-        TrufflePass,
-        GraalPass
-      ]
+      # Get a list of all passes in the system.
+      def passes
+        # We have a defined order for passes to run - these passes at the start.
+        pre_passes = [
+          TrufflePass,
+          GraalPass,
+        ]
 
-      # The fallback pass runs last.
-      post_passes = [
-        FallbackPass
-      ]
+        # The fallback pass runs last.
+        post_passes = [
+          FallbackPass,
+        ]
 
-      # Any extra passes in the middle.
-      extra_passes = Pass::SUBCLASSES.dup - pre_passes - post_passes
+        # Any extra passes in the middle.
+        extra_passes = Pass::SUBCLASSES.dup - pre_passes - post_passes
 
-      pre_passes + extra_passes + post_passes
+        pre_passes + extra_passes + post_passes
+      end
     end
   end
 
@@ -54,8 +58,11 @@ module Seafoam
       raise NotImplementedError
     end
 
-    def self.inherited(pass)
-      SUBCLASSES.push pass
+    class << self
+      def inherited(pass)
+        super
+        SUBCLASSES.push(pass)
+      end
     end
   end
 end

data/lib/seafoam/spotlight.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seafoam
   # Spotlight can *light* nodes, which makes them visible, their adjacent nodes
   # visible by grey, and other nodes invisible. Multiple nodes can be *lit*.
@@ -9,11 +11,11 @@ module Seafoam
     # Mark a node as lit by the spotlight.
     def light(node)
       # This node is lit.
-      node.props[:spotlight] = 'lit'
+      node.props[:spotlight] = "lit"
 
       # Adjacent nodes are shaded, if they haven't be lit themselvs.
       node.adjacent.each do |adjacent|
-        adjacent.props[:spotlight] ||= 'shaded'
+        adjacent.props[:spotlight] ||= "shaded"
       end
     end
 

data/lib/seafoam/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Seafoam
   MAJOR_VERSION = 0
-  MINOR_VERSION = 13
+  MINOR_VERSION = 14
   VERSION = "#{MAJOR_VERSION}.#{MINOR_VERSION}"
 end

data/lib/seafoam.rb

@@ -1,20 +1,22 @@
-require 'seafoam/version'
-require 'seafoam/binary/io_binary_reader'
-require 'seafoam/bgv/bgv_parser'
-require 'seafoam/colors'
-require 'seafoam/graph'
-require 'seafoam/graal/graph_description'
-require 'seafoam/graal/source'
-require 'seafoam/graal/pi'
-require 'seafoam/passes'
-require 'seafoam/passes/truffle'
-require 'seafoam/passes/graal'
-require 'seafoam/passes/fallback'
-require 'seafoam/spotlight'
-require 'seafoam/isabelle_writer'
-require 'seafoam/json_writer'
-require 'seafoam/graphviz_writer'
-require 'seafoam/mermaid_writer'
-require 'seafoam/markdown_writer'
-require 'seafoam/commands'
-require 'seafoam/formatters/formatters'
+# frozen_string_literal: true
+
+require "seafoam/version"
+require "seafoam/binary/io_binary_reader"
+require "seafoam/bgv/bgv_parser"
+require "seafoam/colors"
+require "seafoam/graph"
+require "seafoam/graal/graph_description"
+require "seafoam/graal/source"
+require "seafoam/graal/pi"
+require "seafoam/passes"
+require "seafoam/passes/truffle"
+require "seafoam/passes/graal"
+require "seafoam/passes/fallback"
+require "seafoam/spotlight"
+require "seafoam/isabelle_writer"
+require "seafoam/json_writer"
+require "seafoam/graphviz_writer"
+require "seafoam/mermaid_writer"
+require "seafoam/markdown_writer"
+require "seafoam/commands"
+require "seafoam/formatters/formatters"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seafoam
 version: !ruby/object:Gem::Version
-  version: '0.13'
+  version: '0.14'
 platform: ruby
 authors:
 - Chris Seaton
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-16 00:00:00.000000000 Z
+date: 2022-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -39,21 +39,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.8'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rubocop-shopify
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.74'
+        version: 2.9.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.74'
-description:
-email:
+        version: 2.9.0
+description: 
+email: 
 executables:
 - seafoam
 - bgv2json
@@ -92,7 +92,7 @@ homepage: https://github.com/Shopify/seafoam
 licenses:
 - MIT
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -100,15 +100,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.9
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
-signing_key:
+rubygems_version: 3.3.7
+signing_key: 
 specification_version: 4
 summary: A tool for working with compiler graphs
 test_files: []