seafoam 0.13 → 0.14

data/lib/seafoam/formatters/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seafoam
   module Formatters
     module Base

data/lib/seafoam/formatters/formatters.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Seafoam
   # Formatters are the mechanism by which `seafoam` command output is presented to the user.
   module Formatters
-    autoload :Base, 'seafoam/formatters/base'
-    autoload :Json, 'seafoam/formatters/json'
-    autoload :Text, 'seafoam/formatters/text'
+    autoload :Base, "seafoam/formatters/base"
+    autoload :Json, "seafoam/formatters/json"
+    autoload :Text, "seafoam/formatters/text"
   end
 end

data/lib/seafoam/formatters/json.rb

@@ -1,4 +1,6 @@
-require 'json'
+# frozen_string_literal: true
+
+require "json"
 
 module Seafoam
   module Formatters
@@ -8,6 +10,7 @@ module Seafoam
         def format
           ret = Seafoam::Graal::GraphDescription::ATTRIBUTES.map { |attr| [attr, description.send(attr)] }.to_h
           ret[:node_count] = graph.nodes.size
+          ret[:node_counts] = description.sorted_node_counts
 
           ret.to_json
         end
@@ -22,7 +25,7 @@ module Seafoam
         def render_node_entry(node)
           {
             input: node.inputs.map { |input| build_edge(input) },
-            output: node.outputs.map { |output| build_edge(output) }
+            output: node.outputs.map { |output| build_edge(output) },
           }.to_json
         end
 
@@ -44,7 +47,7 @@ module Seafoam
         def format
           {
             major_version: major_version,
-            minor_version: minor_version
+            minor_version: minor_version,
           }.to_json
         end
       end
@@ -56,7 +59,7 @@ module Seafoam
             {
               graph_index: entry.index,
               graph_file: entry.file,
-              graph_name_components: entry.graph_name_components
+              graph_name_components: entry.graph_name_components,
             }
           end.to_json
         end
@@ -73,7 +76,7 @@ module Seafoam
           name = method[:method_name]
           {
             class: declaring_class,
-            method: name
+            method: name,
           }
         end
       end

data/lib/seafoam/formatters/text.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seafoam
   module Formatters
     module Text
@@ -5,8 +7,9 @@ module Seafoam
       class DescribeFormatter < Seafoam::Formatters::Base::DescribeFormatter
         def format
           notes = Seafoam::Graal::GraphDescription::ATTRIBUTES.select { |attr| description.send(attr) }
+          node_counts = description.sorted_node_counts.map { |node_class, count| "#{node_class}: #{count}" }.join("\n")
 
-          ["#{graph.nodes.size} nodes", *notes].join(', ')
+          ["#{graph.nodes.size} nodes", *notes].join(", ") + "\n#{node_counts}"
         end
       end
 
@@ -19,12 +22,12 @@ module Seafoam
         end
 
         def render_node_entry(node)
-          ret = ['Input:']
+          ret = ["Input:"]
           ret += node.inputs.map do |input|
             "  #{node.id_and_label} <-(#{input.props[:label]}) #{input.from.id_and_label}"
           end
 
-          ret << 'Output:'
+          ret << "Output:"
           ret += node.outputs.map do |output|
             "  #{node.id_and_label} ->(#{output.props[:label]}) #{output.to.id_and_label}"
           end
@@ -48,7 +51,7 @@ module Seafoam
       class ListFormatter < Seafoam::Formatters::Base::ListFormatter
         def format
           entries.map do |entry|
-            "#{entry.file}:#{entry.index}  #{entry.graph_name_components.join('/')}"
+            "#{entry.file}:#{entry.index}  #{entry.graph_name_components.join("/")}"
           end.join("\n")
         end
       end

data/lib/seafoam/graal/graph_description.rb

@@ -1,21 +1,29 @@
+# frozen_string_literal: true
+
 module Seafoam
   module Graal
     # Provides a high level description of a Graal graph's features.
     class GraphDescription
-      ATTRIBUTES = %i[branches calls deopts linear loops]
+      ATTRIBUTES = [:branches, :calls, :deopts, :linear, :loops]
 
       ATTRIBUTES.each { |attr| attr_accessor(attr) unless attr == :linear }
+      attr_reader :node_counts
 
       def initialize
         @branches = false
         @calls = false
         @deopts = false
         @loops = false
+        @node_counts = Hash.new(0)
       end
 
       def linear
         !branches && !loops
       end
+
+      def sorted_node_counts
+        @node_counts.to_a.sort_by { |node_class, count| [-count, node_class] }.to_h
+      end
     end
   end
 end

data/lib/seafoam/graal/pi.rb

@@ -1,17 +1,21 @@
+# frozen_string_literal: true
+
 module Seafoam
   module Graal
     # Routines for understanding pi nodes in Graal.
     module Pi
-      # Find the actual value behind potentially a chain of pi nodes.
-      def self.follow_pi_object(node)
-        node = node.edges.find { |edge| edge.props[:name] == 'object' }.from while PI_NODES.include?(node.props.dig(:node_class, :node_class))
-        node
+      class << self
+        # Find the actual value behind potentially a chain of pi nodes.
+        def follow_pi_object(node)
+          node = node.edges.find { |edge| edge.props[:name] == "object" }.from while PI_NODES.include?(node.node_class)
+          node
+        end
       end
 
       # Pi nodes add type information.
       PI_NODES = [
-        'org.graalvm.compiler.nodes.PiNode',
-        'org.graalvm.compiler.nodes.PiArrayNode'
+        "org.graalvm.compiler.nodes.PiNode",
+        "org.graalvm.compiler.nodes.PiArrayNode",
       ]
     end
   end

data/lib/seafoam/graal/source.rb

@@ -1,18 +1,22 @@
+# frozen_string_literal: true
+
 module Seafoam
   module Graal
     # Routines for understanding source positions in Graal.
     module Source
-      def self.walk(source_position, &block)
-        results = []
+      class << self
+        def walk(source_position, &block)
+          results = []
 
-        caller = source_position
-        while caller
-          method = caller[:method]
-          results.push block.call(method)
-          caller = caller[:caller]
-        end
+          caller = source_position
+          while caller
+            method = caller[:method]
+            results.push(block.call(method))
+            caller = caller[:caller]
+          end
 
-        results
+          results
+        end
       end
     end
   end

data/lib/seafoam/graph.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seafoam
   # A graph, with properties, nodes, and edges. We don't encapsulate the graph
   # too much - be careful.
@@ -25,24 +27,24 @@ module Seafoam
     def create_edge(from, to, props = nil)
       props ||= {}
       edge = Edge.new(from, to, props)
-      @edges.push edge
-      from.outputs.push edge
-      to.inputs.push edge
+      @edges.push(edge)
+      from.outputs.push(edge)
+      to.inputs.push(edge)
       edge
     end
 
     # Add a new basic block with given id and node id list.
     def create_block(id, node_ids)
-      nodes = node_ids.select { |n| @nodes.key? n }.map { |n| @nodes[n] }
+      nodes = node_ids.select { |n| @nodes.key?(n) }.map { |n| @nodes[n] }
       block = Block.new(id, nodes)
-      @blocks.push block
+      @blocks.push(block)
       block
     end
 
     def remove_edge(edge)
-      edge.from.outputs.delete edge
-      edge.to.inputs.delete edge
-      edges.delete edge
+      edge.from.outputs.delete(edge)
+      edge.to.inputs.delete(edge)
+      edges.delete(edge)
     end
   end
 
@@ -58,6 +60,10 @@ module Seafoam
       @props = props
     end
 
+    def node_class
+      @props.dig(:node_class, :node_class)
+    end
+
     # All edges - input and output.
     def edges
       inputs + outputs
@@ -79,7 +85,7 @@ module Seafoam
 
     # Inspect.
     def inspect
-      "<Node #{id}>"
+      "<Node #{id} #{node_class}>"
     end
   end
 

data/lib/seafoam/graphviz_writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seafoam
   # A writer from graphs to the Graphviz DOT format, including all the
   # formatting.
@@ -11,25 +13,64 @@ module Seafoam
       inline_attrs = {}
       attrs = {}
       attrs[:dpi] = 200 if hidpi
-      attrs[:bgcolor] = 'white'
-      @stream.puts 'digraph G {'
+      attrs[:bgcolor] = "white"
+      start_graph(attrs)
+      write_nodes(inline_attrs, graph, draw_blocks)
+      write_edges(inline_attrs, graph)
+      end_graph
+    end
+
+    def start_graph(attrs)
+      @stream.puts "digraph G {"
       @stream.puts "  graph #{write_attrs(attrs)};"
-      write_nodes inline_attrs, graph
-      write_edges inline_attrs, graph
-      write_blocks graph if draw_blocks
-      @stream.puts '}'
+    end
+
+    def end_graph
+      @stream.puts "}"
     end
 
     private
 
     # Write node declarations.
-    def write_nodes(inline_attrs, graph)
-      graph.nodes.each_value do |node|
-        write_node inline_attrs, node
+    def write_nodes(inline_attrs, graph, draw_blocks)
+      drawn_in_blocks = []
+
+      if draw_blocks
+        graph.blocks.each do |block|
+          next if block.nodes.all? { |n| n.props[:hidden] || n.props[:inlined] }
+
+          start_subgraph(block.id)
+
+          block.nodes.each do |node|
+            next if node.props[:hidden] || node.props[:inlined]
+
+            write_node("    ", inline_attrs, node)
+            drawn_in_blocks.push(node)
+          end
+
+          end_subgraph
+        end
+      end
+
+      (graph.nodes.values - drawn_in_blocks).each do |node|
+        write_node("  ", inline_attrs, node)
       end
     end
 
-    def write_node(inline_attrs, node)
+    def start_subgraph(id)
+      @stream.puts "  subgraph cluster_block#{id} {"
+      @stream.puts '    fontname = "Arial";'
+      @stream.puts "    label = \"B#{id}\";"
+      @stream.puts "    style = filled;"
+      @stream.puts "    color = #{DARK_YELLOW.inspect};"
+      @stream.puts "    fillcolor = #{LIGHT_YELLOW.inspect};"
+    end
+
+    def end_subgraph
+      @stream.puts "  }"
+    end
+
+    def write_node(indent, inline_attrs, node)
       # We're going to build up a hash of Graphviz drawing attributes.
       attrs = {}
 
@@ -39,71 +80,75 @@ module Seafoam
         # If the node has any adjacent nodes that are not hidden, and are
         # shaded, then we need to declare the node but make it invisible so
         # the edge appears, pointing off into space, but the node does not.
-        if node.adjacent.any? { |a| !a.props[:hidden] && a.props[:spotlight] == 'shaded' }
-          attrs[:style] = 'invis'
-          attrs[:label] = ''
-          @stream.puts "  node#{node.id} #{write_attrs(attrs)};"
+        if node.adjacent.any? { |a| !a.props[:hidden] && a.props[:spotlight] == "shaded" }
+          attrs[:style] = "invis"
+          attrs[:label] = ""
+          output_node(indent, "node#{node.id}", attrs)
         end
       else
         # This is a visible node.
 
         # Give it a label.
-        if node.props[:label]
-          attrs[:label] = "#{node.id} #{node.props[:label]}"
+        attrs[:label] = if node.props[:label]
+          "#{node.id} #{node.props[:label]}"
         else
           # If we really still don't have a label, just use the ID.
-          attrs[:label] = node.id.to_s
+          node.id.to_s
         end
 
         # Basic attributes for a node.
-        attrs[:shape] = 'rectangle'
-        attrs[:fontname] = 'Arial'
-        attrs[:style] = 'filled'
-        attrs[:color] = 'black'
+        attrs[:shape] = "rectangle"
+        attrs[:fontname] = "Arial"
+        attrs[:style] = "filled"
+        attrs[:color] = "black"
 
         # Color depends on the kind of node.
         back_color, fore_color = NODE_COLORS[node.props[:kind]]
         attrs[:fillcolor] = back_color
         attrs[:fontcolor] = fore_color
 
+        # If the node is shaded, convert the attributes to the shaded
+        # version.
+        attrs = shade(attrs) if node.props[:spotlight] == "shaded"
+
         if node.props[:inlined]
           # If the node is to be inlined then draw it smaller and a different
           # shape.
-          attrs[:shape] = 'oval'
-          attrs[:fontsize] = '8'
+          attrs[:shape] = "oval"
+          attrs[:fontsize] = "8"
 
           # Just record these attributes for where it's used by other nodes
           # so it can be drawn above them - don't actually declare a node.
           inline_attrs[node.id] = attrs
         else
-          attrs[:shape] = 'diamond' if node.props[:kind] == 'calc'
-
-          # If the node is shaded, convert the attributes to the shaded
-          # version.
-          attrs = shade(attrs) if node.props[:spotlight] == 'shaded'
+          attrs[:shape] = "diamond" if node.props[:kind] == "calc"
 
           # Declare the node.
-          @stream.puts "  node#{node.id} #{write_attrs(attrs)};"
+          output_node(indent, "node#{node.id}", attrs)
         end
       end
     end
 
+    def output_node(indent, id, attrs)
+      @stream.puts "#{indent}#{id} #{write_attrs(attrs)};"
+    end
+
     # Write edge declarations.
 
     def write_edges(inline_attrs, graph)
       graph.edges.each do |edge|
         # Skip the edge if it's from a node that is hidden and it doesn't point
         # to a shaded node.
-        next if edge.from.props[:hidden] && edge.to.props[:spotlight] != 'shaded'
+        next if edge.from.props[:hidden] && edge.to.props[:spotlight] != "shaded"
 
         # Skip the edge if it's to a node that is hidden and it doesn't come
         # from a shaded node.
-        next if edge.to.props[:hidden] && edge.from.props[:spotlight] != 'shaded'
+        next if edge.to.props[:hidden] && edge.from.props[:spotlight] != "shaded"
 
         # Skip the edge if it's hidden itself
         next if edge.props[:hidden]
 
-        write_edge inline_attrs, edge
+        write_edge(inline_attrs, edge)
       end
     end
 
@@ -118,74 +163,64 @@ module Seafoam
       attrs[:label] = label
 
       # Basic edge attributes.
-      attrs[:fontname] = 'arial'
+      attrs[:fontname] = "arial"
       color = EDGE_COLORS[edge.props[:kind]]
       attrs[:color] = EDGE_COLORS[edge.props[:kind]]
       attrs[:fontcolor] = color
 
       # Properties depending on the kind of edge.
       case edge.props[:kind]
-      when 'control'
+      when "control"
         attrs[:penwidth] = 2
-      when 'loop'
+      when "loop"
         attrs[:penwidth] = 4
-      when 'info'
-        attrs[:style] = 'dashed'
+      when "info"
+        attrs[:style] = "dashed"
       end
 
       # Reversed edges.
-      attrs[:dir] = 'back' if edge.props[:reverse]
+      attrs[:dir] = "back" if edge.props[:reverse]
 
       # Convert attributes to shaded if any edges involved are shaded.
-      attrs = shade(attrs) if edge.nodes.any? { |n| n.props[:spotlight] == 'shaded' }
+      attrs = shade(attrs) if edge.nodes.any? { |n| n.props[:spotlight] == "shaded" }
 
       # Does this edge come from an inlined node?
 
       if edge.from.props[:inlined]
-        # An inlined edge is drawn as a new version of the from-node and an
-        # edge from that new version directly to the to-node. With only one
-        # user it's a short edge and the from-node is show directly above the
-        # to-node.
-
-        if edge.to.props[:spotlight] == 'shaded'
-          # Draw inlined edges to shaded nodes as invisible.
-          node_attrs = { label: '', style: 'invis' }
-        else
-          # Get attributes from when we went through nodes earlier.
-          node_attrs = inline_attrs[edge.from.id]
+        # Don't draw inlined nodes to hidden nodes.
+        unless edge.to.props[:hidden]
+
+          # An inlined edge is drawn as a new version of the from-node and an
+          # edge from that new version directly to the to-node. With only one
+          # user it's a short edge and the from-node is show directly above the
+          # to-node.
+
+          node_attrs = if edge.to.props[:spotlight] == "shaded"
+            # Draw inlined edges to shaded nodes as invisible.
+            { label: "", style: "invis" }
+          else
+            # Get attributes from when we went through nodes earlier.
+            inline_attrs[edge.from.id]
+          end
+
+          # Inlined nodes skip the arrow for simplicity.
+          attrs[:arrowhead] = "none"
+          attrs[:fontsize] = "8"
+
+          # Declare a new node just for this user.
+          output_node("  ", "inline#{edge.from.id}x#{edge.to.id}", node_attrs)
+
+          # Declare the edge.
+          output_edge("inline#{edge.from.id}x#{edge.to.id}", "node#{edge.to.id}", attrs)
         end
-
-        # Inlined nodes skip the arrow for simplicity.
-        attrs[:arrowhead] = 'none'
-        attrs[:fontsize] = '8'
-
-        # Declare a new node just for this user.
-        @stream.puts "  inline#{edge.from.id}x#{edge.to.id} #{write_attrs(node_attrs)};"
-
-        # Declare the edge.
-        @stream.puts "  inline#{edge.from.id}x#{edge.to.id} -> node#{edge.to.id} #{write_attrs(attrs)};"
       else
         # Declare the edge.
-        @stream.puts "  node#{edge.from.id} -> node#{edge.to.id} #{write_attrs(attrs)};"
+        output_edge("node#{edge.from.id}", "node#{edge.to.id}", attrs)
       end
     end
 
-    # Write basic block outlines.
-    def write_blocks(graph)
-      graph.blocks.each do |block|
-        @stream.puts "  subgraph cluster_block#{block.id} {"
-        @stream.puts '    fontname = "Arial";'
-        @stream.puts "    label = \"B#{block.id}\";"
-        @stream.puts '    style=dotted;'
-
-        block.nodes.each do |node|
-          next if node.props[:hidden] || node.props[:inlined]
-
-          @stream.puts "    node#{node.id};"
-        end
-
-        @stream.puts '  }'
-      end
+    def output_edge(from, to, attrs)
+      @stream.puts "  #{from} -> #{to} #{write_attrs(attrs)};"
     end
 
     # Return attributes for a node or edge modified to 'shade' them in terms
@@ -200,36 +235,31 @@ module Seafoam
 
     # Write a hash of key-value attributes into the DOT format.
     def write_attrs(attrs)
-      '[' + attrs.reject { |_k, v| v.nil? }.map { |k, v| "#{k}=#{quote(v)}" }.join(',') + ']'
-    end
-
-    # Quote and escape a string.
-    def quote(string)
-      string = string.to_s
-      string = string.gsub('\\', '\\\\')
-      string = string.gsub('"', '\\"')
-      "\"#{string}\""
+      "[" + attrs.reject { |_k, v| v.nil? }.map { |k, v| "#{k}=#{v.inspect}" }.join(",") + "]"
     end
 
     # Color theme.
 
     EDGE_COLORS = {
-      'info' => BIG_STONE,
-      'control' => AMARANTH,
-      'loop' => AMARANTH,
-      'data' => KEPPEL,
-      'other' => BLACK
+      "info" => BIG_STONE,
+      "control" => AMARANTH,
+      "loop" => AMARANTH,
+      "data" => KEPPEL,
+      "other" => BLACK,
     }
 
     NODE_COLORS = {
-      'info' => [DUST, BLACK],
-      'input' => [WHITE_ICE, BLACK],
-      'control' => [CARISSMA, BLACK],
-      'effect' => [AMARANTH, WHITE],
-      'virtual' => [BIG_STONE, WHITE],
-      'guard' => [ORANGE, BLACK],
-      'calc' => [KEPPEL, BLACK],
-      'other' => [DUST, BLACK]
+      "info" => [DUST, BLACK],
+      "input" => [WHITE_ICE, BLACK],
+      "control" => [CARISSMA, BLACK],
+      "memory" => [LIGHT_PURPLE, BLACK],
+      "call" => [AMARANTH, WHITE],
+      "sync" => [AMARANTH, WHITE],
+      "alloc" => [AMARANTH, WHITE],
+      "virtual" => [BIG_STONE, WHITE],
+      "guard" => [ORANGE, BLACK],
+      "calc" => [KEPPEL, BLACK],
+      "other" => [DUST, BLACK],
     }
   end
 end

data/lib/seafoam/isabelle_writer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seafoam
   # Write graphs in the Isabelle file format.
   class IsabelleWriter
@@ -28,19 +30,19 @@ module Seafoam
 
       graph.nodes.each_value do |node|
         node_class = node.props[:node_class][:node_class]
-        case node_class
-        when 'org.graalvm.compiler.nodes.ConstantNode'
-          desc = "(ConstantNode #{node.props['rawvalue']})"
-        when 'org.graalvm.compiler.nodes.ParameterNode'
-          desc = "(ParameterNode #{node.props['index']})"
+        desc = case node_class
+        when "org.graalvm.compiler.nodes.ConstantNode"
+          "(ConstantNode #{node.props["rawvalue"]})"
+        when "org.graalvm.compiler.nodes.ParameterNode"
+          "(ParameterNode #{node.props["index"]})"
         else
-          desc = node_class.split('.').last
+          node_class.split(".").last
         end
         inputs = node.inputs.map(&:from).map(&:id)
         outputs = node.outputs.map(&:to).map(&:id)
         @out.puts " (add_node #{node.id} #{desc} #{inputs.inspect} #{outputs.inspect}"
       end
-      @out.puts ' empty_graph' + (')' * graph.nodes.size)
+      @out.puts " empty_graph" + (")" * graph.nodes.size)
     end
   end
 end