compare_compressors 0.0.1

data/lib/compare_compressors/group_result.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module CompareCompressors
+  #
+  # A single compressor-level result averaged the over targets.
+  #
+  GroupResult = Struct.new(
+    :compressor_name,
+    :compressor_level,
+    :mean_compression_elapsed_hours,
+    :mean_compression_cpu_hours,
+    :max_compression_max_rss,
+    :mean_compressed_gibytes,
+    :mean_compression_delta_gibytes,
+    :geomean_compression_ratio,
+    :mean_decompression_elapsed_hours,
+    :mean_decompression_cpu_hours,
+    :max_decompression_max_rss
+  ) do
+    DEFAULT_SCALE = 1.0
+
+    HOUR = 3600 # seconds
+    GIGABYTE = 1024**3 # bytes
+
+    #
+    # Create a GroupResult for a group of Results for the same compressor
+    # and level (but possibly multiple targets).
+    #
+    def self.new_from_results(compressor_name, compressor_level, results, scale)
+      new(
+        compressor_name,
+        compressor_level,
+        scale * Result.mean(results, :compression_elapsed_time) / HOUR,
+        scale * Result.mean(results, :compression_cpu_time) / HOUR,
+        results.map(&:compression_max_rss).max,
+        scale * Result.mean(results, :size) / GIGABYTE,
+        scale * Result.mean(results, :compression_delta) / GIGABYTE,
+        Result.geomean(results, :compression_ratio),
+        scale * Result.mean(results, :decompression_elapsed_time) / HOUR,
+        scale * Result.mean(results, :decompression_cpu_time) / HOUR,
+        results.map(&:decompression_max_rss).max
+      )
+    end
+
+    #
+    # Group individual result to average across targets in the sample.
+    #
+    # @param [Array.<Result>] results
+    # @return [Array.<GroupResult>]
+    #
+    def self.group(results, scale: DEFAULT_SCALE)
+      results.group_by(&:group_key).map do |_, group_results|
+        GroupResult.new_from_results(
+          group_results.first.compressor_name,
+          group_results.first.compressor_level,
+          group_results,
+          scale
+        )
+      end
+    end
+  end
+end

data/lib/compare_compressors/plotter.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module CompareCompressors
+  #
+  # Plot compression results to gnuplot.
+  #
+  class Plotter
+    DEFAULT_TERMINAL = 'png size 640, 480'
+    DEFAULT_OUTPUT = 'compare_compressors.png'
+    DEFAULT_LOGSCALE_SIZE = false
+    DEFAULT_AUTOSCALE_FIX = false
+    DEFAULT_SHOW_LABELS = true
+    DEFAULT_LMARGIN = nil
+    DEFAULT_TITLE = nil
+    DEFAULT_USE_CPU_TIME = false
+
+    def initialize(
+      terminal:, output:, logscale_size:, autoscale_fix:,
+      show_labels:, lmargin:, title:, use_cpu_time:
+    )
+      @terminal = terminal
+      @output = output
+      @logscale_size = logscale_size
+      @autoscale_fix = autoscale_fix
+      @show_labels = show_labels
+      @lmargin = lmargin
+      @title = title
+      @use_cpu_time = use_cpu_time
+
+      @group_results = nil
+      @io = nil
+    end
+
+    attr_reader :terminal
+    attr_reader :output
+    attr_reader :logscale_size
+    attr_reader :autoscale_fix
+    attr_reader :show_labels
+    attr_reader :lmargin
+    attr_reader :title
+    attr_reader :use_cpu_time
+
+    attr_reader :group_results
+    attr_reader :io
+
+    def plot(group_results, pareto_only:, io: STDOUT)
+      group_results = find_non_dominated(group_results) if pareto_only
+      @group_results = group_results
+      @io = io
+      write
+    end
+
+    private
+
+    def write
+      write_preamble
+      write_data
+      write_labels
+      write_style
+      write_plots
+    end
+
+    def write_preamble
+      io.puts "set terminal #{terminal}"
+      io.puts "set output '#{output}'"
+    end
+
+    def write_data
+      group_results_by_name = group_results.group_by(&:compressor_name)
+      group_results_by_name.each do |name, name_results|
+        io.puts "$#{name} << EOD"
+        name_results.each do |name_result|
+          io.puts name_result.to_a.join(' ')
+        end
+        io.puts 'EOD'
+      end
+    end
+
+    def write_style
+      io.puts "set title #{escape(title)}" if title
+      io.puts 'set key outside'
+      io.puts "set lmargin #{lmargin}" if lmargin
+
+      io.puts 'set logscale y' if logscale_size
+      io.puts 'set autoscale fix' if autoscale_fix
+    end
+
+    def write_labels
+      # Subclasses can label the axes.
+    end
+
+    def column_names
+      # Subclasses can declare their column names.
+    end
+
+    def splots
+      []
+    end
+
+    def write_plots
+      io.puts "splot #{splots.join(", \\\n  ")}"
+    end
+
+    def time_unit
+      if use_cpu_time
+        '(CPU Hours)'
+      else
+        '(Hours)'
+      end
+    end
+
+    def compressor_names
+      group_results.map(&:compressor_name).uniq.sort
+    end
+
+    def compressor_number(compressor_name)
+      COMPRESSORS.index { |c| c.name == compressor_name } + 1
+    end
+
+    def point_style(name)
+      number = compressor_number(name)
+      "linecolor #{number} pointtype #{number}"
+    end
+
+    def find_display_name(compressor_name)
+      compressor = COMPRESSORS.find { |c| c.name == compressor_name }
+      compressor&.display_name || compressor_name
+    end
+
+    def column_numbers(names = column_names)
+      struct = @group_results.first.class
+      names.map { |name| struct.members.index(name) + 1 }
+    end
+
+    #
+    # Find points on the Pareto frontier using the axes shown in the graph.
+    #
+    # @param [Array.<Struct>] points
+    # @return [Array.<Struct>]
+    #
+    def find_non_dominated(points)
+      points.reject do |point0|
+        points.any? do |point1|
+          dominates?(point1, point0)
+        end
+      end
+    end
+
+    #
+    # Check whether `point1` dominates `point0`. Here we assume that we are
+    # minimizing on all columns.
+    #
+    def dominates?(point1, point0)
+      column_names.all? { |name| point1[name] < point0[name] }
+    end
+
+    #
+    # Make at least some attempt to escape double quotes.
+    #
+    def escape(str)
+      str.dump
+    end
+  end
+end

data/lib/compare_compressors/plotters/cost_plotter.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module CompareCompressors
+  #
+  # Plot compression results to gnuplot in 2D cost space (time cost and space
+  # cost).
+  #
+  class CostPlotter < Plotter
+    DEFAULT_SHOW_COST_CONTOURS = true
+
+    def initialize(cost_model, **options)
+      @cost_model = cost_model
+      @show_cost_contours = \
+        if options.key?(:show_cost_contours)
+          options.delete(:show_cost_contours)
+        else
+          DEFAULT_SHOW_COST_CONTOURS
+        end
+      super(**options)
+    end
+
+    attr_reader :cost_model
+    attr_reader :show_cost_contours
+
+    private
+
+    def column_values(column_name)
+      group_results.map(&column_name)
+    end
+
+    def color_palette_range
+      min_cost = column_names.map { |name| column_values(name).min }.inject(&:+)
+      max_cost = column_names.map { |name| column_values(name).max }.inject(&:+)
+      [min_cost / 2.0, max_cost]
+    end
+
+    def write_style
+      super
+
+      io.puts 'set view map'
+      io.puts 'set contour'
+      io.puts 'set palette gray'
+      io.puts 'set cntrlabel font ",10"'
+      io.puts 'set style textbox opaque noborder'
+      io.puts "set cbrange [#{color_palette_range.join(':')}]"
+      io.puts 'unset colorbox'
+    end
+
+    def write_labels
+      io.puts "set xlabel 'Time Cost (#{cost_model.currency})'"
+      io.puts "set ylabel 'Size Cost (#{cost_model.currency})'"
+    end
+
+    def column_names
+      [:hour_cost, :gibyte_cost]
+    end
+
+    def splots
+      splots = []
+      splots.concat(contour_splots) if show_cost_contours
+      splots.concat(points_splots)
+      splots.concat(point_label_splots) if show_labels
+      splots
+    end
+
+    def points_splots
+      compressor_names.map do |name|
+        columns = column_numbers + [0]
+        "'$#{name}' using #{columns.join(':')} with points nocontour" \
+        " #{point_style(name)}" \
+        " title '#{find_display_name(name)}'"
+      end
+    end
+
+    def point_label_splots
+      compressor_names.map do |name|
+        columns = column_numbers + [0] + column_numbers([:compressor_level])
+        "'$#{name}' using #{columns.join(':')} with labels" \
+        ' left nocontour notitle'
+      end
+    end
+
+    def contour_splots
+      [
+        'x + y with lines palette notitle nosurface',
+        'x + y with labels boxed notitle nosurface'
+      ]
+    end
+  end
+end

data/lib/compare_compressors/plotters/raw_plotter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module CompareCompressors
+  #
+  # Plot grouped compression results to gnuplot in 3D (compression time,
+  # decompression time, and compressed size).
+  #
+  class RawPlotter < Plotter
+    DEFAULT_VIEW_ROT_X = 30
+    DEFAULT_VIEW_ROT_Z = 350
+
+    def initialize(**options)
+      @view_rot_x = options.delete(:view_rot_x) || DEFAULT_VIEW_ROT_X
+      @view_rot_z = options.delete(:view_rot_z) || DEFAULT_VIEW_ROT_Z
+      super(**options)
+    end
+
+    attr_reader :view_rot_x
+    attr_reader :view_rot_z
+
+    def write_style
+      super
+      io.puts format('set view %d, %d', view_rot_x, view_rot_z)
+      io.puts 'set grid xtics ytics ztics'
+    end
+
+    def write_labels
+      io.puts "set xlabel 'Compression Time #{time_unit}' rotate parallel"
+      io.puts 'set ylabel "Compressed Size (GiB)" rotate parallel'
+      io.puts "set zlabel 'Decompression Time #{time_unit}' rotate parallel"
+    end
+
+    def column_names
+      if use_cpu_time
+        [
+          :mean_compression_cpu_hours,
+          :mean_compressed_gibytes,
+          :mean_decompression_cpu_hours
+        ]
+      else
+        [
+          :mean_compression_elapsed_hours,
+          :mean_compressed_gibytes,
+          :mean_decompression_elapsed_hours
+        ]
+      end
+    end
+
+    def splots
+      points_splots
+    end
+
+    def points_splots
+      compressor_names.map do |name|
+        "'$#{name}' using #{column_numbers.join(':')} with points" \
+        " #{point_style(name)}" \
+        " title '#{find_display_name(name)}'"
+      end
+    end
+  end
+end

data/lib/compare_compressors/plotters/size_plotter.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module CompareCompressors
+  #
+  # Plot grouped compression results to gnuplot in 2D --- just compression time
+  # or decompression time vs size.
+  #
+  class SizePlotter < Plotter
+    DEFAULT_DECOMPRESSION = false # plot compression by default
+
+    def initialize(**options)
+      @decompression = \
+        if options.key?(:decompression)
+          options.delete(:decompression)
+        else
+          DEFAULT_DECOMPRESSION
+        end
+      super(**options)
+    end
+
+    attr_reader :decompression
+
+    def write_labels
+      io.puts 'set ylabel "Compressed Size (GiB)"'
+      if decompression
+        io.puts "set xlabel 'Decompression Time #{time_unit}'"
+      else
+        io.puts "set xlabel 'Compression Time #{time_unit}'"
+      end
+    end
+
+    def time_column_name
+      if decompression && use_cpu_time
+        :mean_decompression_cpu_hours
+      elsif decompression
+        :mean_decompression_elapsed_hours
+      elsif use_cpu_time
+        :mean_compression_cpu_hours
+      else
+        :mean_compression_elapsed_hours
+      end
+    end
+
+    def column_names
+      [time_column_name, :mean_compressed_gibytes]
+    end
+
+    def write_plots
+      io.puts "plot #{plots.join(", \\\n  ")}"
+    end
+
+    def plots
+      if show_labels
+        point_plots + point_label_plots
+      else
+        point_plots
+      end
+    end
+
+    def point_plots
+      compressor_names.map do |name|
+        "'$#{name}' using #{column_numbers.join(':')} with points" \
+        " #{point_style(name)}" \
+        " title '#{find_display_name(name)}'"
+      end
+    end
+
+    def point_label_plots
+      compressor_names.map do |name|
+        columns = column_numbers(column_names + [:compressor_level])
+        "'$#{name}' using #{columns.join(':')}" \
+        ' with labels left offset 0, character 0.5 notitle'
+      end
+    end
+  end
+end