omnizip 0.3.1

data/benchmark/filter_bench.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require "tempfile"
+require "fileutils"
+require_relative "models/benchmark_result"
+require_relative "models/comparison_result"
+
+module Benchmark
+  # Benchmarks filters combined with compression
+  class FilterBench
+    FILTERS = %w[bcj delta].freeze
+    BASE_ALGORITHM = "lzma"
+    ITERATIONS = 3
+
+    attr_reader :verbose
+
+    def initialize(verbose: false)
+      @verbose = verbose
+      @seven_zip_available = check_seven_zip_availability
+    end
+
+    def seven_zip_available?
+      @seven_zip_available
+    end
+
+    def benchmark_filter(filter, input_file, input_type)
+      puts "Benchmarking #{filter} filter..." if verbose
+
+      omnizip_result = benchmark_omnizip_with_filter(filter, input_file,
+                                                     input_type)
+      seven_zip_result = if seven_zip_available?
+                           benchmark_7z_with_filter(filter, input_file,
+                                                    input_type)
+                         else
+                           create_unavailable_result(filter, input_file,
+                                                     input_type)
+                         end
+
+      Models::ComparisonResult.new(
+        test_name: "#{filter}_filter_#{input_type}",
+        omnizip_result: omnizip_result,
+        seven_zip_result: seven_zip_result,
+      )
+    end
+
+    private
+
+    def check_seven_zip_availability
+      system("which 7z > /dev/null 2>&1") ||
+        system("which 7za > /dev/null 2>&1")
+    end
+
+    def get_7z_command
+      @get_7z_command ||= if system("which 7z > /dev/null 2>&1")
+                            "7z"
+                          elsif system("which 7za > /dev/null 2>&1")
+                            "7za"
+                          end
+    end
+
+    def benchmark_omnizip_with_filter(filter, input_file, input_type)
+      input_size = File.size(input_file)
+      compressed_file = create_temp_file(".7z")
+
+      begin
+        time = measure_time do
+          compress_with_filter(filter, input_file, compressed_file)
+        end
+
+        compressed_size = if File.exist?(compressed_file)
+                            File.size(compressed_file)
+                          end
+
+        Models::BenchmarkResult.new(
+          algorithm: "#{filter}+#{BASE_ALGORITHM}",
+          input_size: input_size,
+          input_type: input_type,
+          compressed_size: compressed_size,
+          compression_time: time,
+        )
+      rescue StandardError => e
+        Models::BenchmarkResult.new(
+          algorithm: "#{filter}+#{BASE_ALGORITHM}",
+          input_size: input_size,
+          input_type: input_type,
+          error: e.message,
+        )
+      ensure
+        FileUtils.rm_f(compressed_file)
+      end
+    end
+
+    def benchmark_7z_with_filter(filter, input_file, input_type)
+      input_size = File.size(input_file)
+      compressed_file = create_temp_file(".7z")
+
+      begin
+        time = measure_time do
+          compress_with_7z_filter(filter, input_file, compressed_file)
+        end
+
+        compressed_size = if File.exist?(compressed_file)
+                            File.size(compressed_file)
+                          end
+
+        Models::BenchmarkResult.new(
+          algorithm: "#{filter}+#{BASE_ALGORITHM}",
+          input_size: input_size,
+          input_type: input_type,
+          compressed_size: compressed_size,
+          compression_time: time,
+        )
+      rescue StandardError => e
+        Models::BenchmarkResult.new(
+          algorithm: "#{filter}+#{BASE_ALGORITHM}",
+          input_size: input_size,
+          input_type: input_type,
+          error: e.message,
+        )
+      ensure
+        FileUtils.rm_f(compressed_file)
+      end
+    end
+
+    def create_unavailable_result(filter, input_file, input_type)
+      Models::BenchmarkResult.new(
+        algorithm: "#{filter}+#{BASE_ALGORITHM}",
+        input_size: File.size(input_file),
+        input_type: input_type,
+        error: "7-Zip not available",
+      )
+    end
+
+    def compress_with_filter(filter, input_file, output_file)
+      require_relative "../lib/omnizip"
+
+      filter_class = case filter
+                     when "bcj" then Omnizip::Filters::BCJx86
+                     when "delta" then Omnizip::Filters::Delta
+                     else raise "Unknown filter: #{filter}"
+                     end
+
+      input = File.binread(input_file)
+      filtered = filter_class.encode(input)
+      compressed = Omnizip::Algorithms::LZMA.compress(filtered)
+      File.binwrite(output_file, compressed)
+    end
+
+    def compress_with_7z_filter(filter, input_file, output_file)
+      filter_flag = case filter
+                    when "bcj" then "BCJ"
+                    when "delta" then "Delta"
+                    else raise "Unknown filter: #{filter}"
+                    end
+
+      cmd = "#{get_7z_command} a -m0=LZMA -mf=#{filter_flag} -mx=5 " \
+            "#{output_file} #{input_file} > /dev/null 2>&1"
+      success = system(cmd)
+      raise "7z compression with filter failed" unless success
+    end
+
+    def measure_time(&block)
+      times = []
+      ITERATIONS.times do
+        time = ::Benchmark.realtime(&block)
+        times << time
+      end
+      times.sum / times.size
+    end
+
+    def create_temp_file(extension)
+      temp = Tempfile.new(["benchmark", extension])
+      path = temp.path
+      temp.close
+      temp.unlink
+      path
+    end
+  end
+end

data/benchmark/models/benchmark_result.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Benchmark
+  module Models
+    # Represents the result of a single benchmark test
+    class BenchmarkResult
+      attr_reader :algorithm, :input_size, :input_type, :compressed_size,
+                  :compression_time, :decompression_time, :error
+
+      def initialize(
+        algorithm:,
+        input_size:,
+        input_type:,
+        compressed_size: nil,
+        compression_time: nil,
+        decompression_time: nil,
+        error: nil
+      )
+        @algorithm = algorithm
+        @input_size = input_size
+        @input_type = input_type
+        @compressed_size = compressed_size
+        @compression_time = compression_time
+        @decompression_time = decompression_time
+        @error = error
+      end
+
+      def success?
+        error.nil?
+      end
+
+      def compression_ratio
+        return nil unless success? && compressed_size && input_size.positive?
+
+        input_size.to_f / compressed_size
+      end
+
+      def compression_percentage
+        return nil unless compression_ratio
+
+        (1.0 - (1.0 / compression_ratio)) * 100
+      end
+
+      def to_h
+        {
+          algorithm: algorithm,
+          input_size: input_size,
+          input_type: input_type,
+          compressed_size: compressed_size,
+          compression_time: compression_time,
+          decompression_time: decompression_time,
+          compression_ratio: compression_ratio,
+          compression_percentage: compression_percentage,
+          error: error,
+        }
+      end
+    end
+  end
+end

data/benchmark/models/comparison_result.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "benchmark_result"
+
+module Benchmark
+  module Models
+    # Represents a comparison between omnizip and 7-Zip results
+    class ComparisonResult
+      attr_reader :test_name, :omnizip_result, :seven_zip_result
+
+      def initialize(test_name:, omnizip_result:, seven_zip_result:)
+        @test_name = test_name
+        @omnizip_result = omnizip_result
+        @seven_zip_result = seven_zip_result
+      end
+
+      def size_difference_bytes
+        return nil unless both_successful?
+
+        omnizip_result.compressed_size - seven_zip_result.compressed_size
+      end
+
+      def size_difference_percentage
+        return nil unless both_successful?
+
+        ((size_difference_bytes.to_f / seven_zip_result.compressed_size) *
+         100).round(2)
+      end
+
+      def compression_speed_ratio
+        return nil unless both_successful?
+
+        return nil if seven_zip_result.compression_time.nil? ||
+          seven_zip_result.compression_time.zero?
+
+        (omnizip_result.compression_time /
+         seven_zip_result.compression_time).round(2)
+      end
+
+      def decompression_speed_ratio
+        return nil unless both_successful?
+
+        return nil if seven_zip_result.decompression_time.nil? ||
+          seven_zip_result.decompression_time.zero?
+
+        (omnizip_result.decompression_time /
+         seven_zip_result.decompression_time).round(2)
+      end
+
+      def both_successful?
+        omnizip_result.success? && seven_zip_result.success?
+      end
+
+      def to_h
+        {
+          test_name: test_name,
+          omnizip: omnizip_result.to_h,
+          seven_zip: seven_zip_result.to_h,
+          comparison: {
+            size_difference_bytes: size_difference_bytes,
+            size_difference_percentage: size_difference_percentage,
+            compression_speed_ratio: compression_speed_ratio,
+            decompression_speed_ratio: decompression_speed_ratio,
+          },
+        }
+      end
+    end
+  end
+end

data/benchmark/profile_suite.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../lib/omnizip"
+require_relative "../lib/omnizip/profiler"
+require_relative "../lib/omnizip/profiler/method_profiler"
+require_relative "../lib/omnizip/profiler/memory_profiler"
+require_relative "../lib/omnizip/profiler/report_generator"
+require_relative "test_data"
+
+module Benchmark
+  # Profiling suite for performance analysis of compression algorithms
+  class ProfileSuite
+    attr_reader :profiler, :verbose
+
+    def initialize(verbose: false)
+      @verbose = verbose
+      @profiler = Omnizip::Profiler.new(profile_name: "compression_profile")
+      @test_data = TestData.new
+
+      # Register profiler strategies
+      @profiler.register_profiler(:method,
+                                  Omnizip::Profiler::MethodProfiler.new)
+      @profiler.register_profiler(:memory,
+                                  Omnizip::Profiler::MemoryProfiler.new)
+    end
+
+    def run_all
+      puts "Starting performance profiling suite..." if verbose
+
+      generate_test_data
+      profile_lzma_encoding
+      profile_lzma_decoding
+      profile_range_coder
+      profile_bwt_transform
+      cleanup_test_data
+
+      analyze_results
+      self
+    end
+
+    def profile_lzma_encoding
+      puts "\nProfiling LZMA encoding..." if verbose
+
+      test_file = File.join(@test_data.data_dir, "text_10240.dat")
+      data = File.binread(test_file)
+
+      @profiler.profile("LZMA::encode", profiler_type: :method) do
+        output = StringIO.new
+        encoder = Omnizip::Algorithms::LZMA::Encoder.new(output)
+        encoder.encode_stream(data)
+      end
+    end
+
+    def profile_lzma_decoding
+      puts "Profiling LZMA decoding..." if verbose
+
+      test_file = File.join(@test_data.data_dir, "text_10240.dat")
+      data = File.binread(test_file)
+
+      # Encode data first
+      encoded_output = StringIO.new
+      encoder = Omnizip::Algorithms::LZMA::Encoder.new(encoded_output)
+      encoder.encode_stream(data)
+      encoded = encoded_output.string
+
+      @profiler.profile("LZMA::decode", profiler_type: :method) do
+        input = StringIO.new(encoded)
+        decoder = Omnizip::Algorithms::LZMA::Decoder.new(input)
+        decoder.decode_stream
+      end
+    end
+
+    def profile_range_coder
+      puts "Profiling Range Coder..." if verbose
+
+      data = Array.new(1000) { rand(256) }
+
+      @profiler.profile("RangeCoder::encode", profiler_type: :method) do
+        output = StringIO.new
+        encoder = Omnizip::Algorithms::LZMA::RangeEncoder.new(output)
+        data.each { |byte| encoder.encode_direct_bits(byte, 8) }
+        encoder.flush
+      end
+    end
+
+    def profile_bwt_transform
+      puts "Profiling BWT transform..." if verbose
+
+      test_file = File.join(@test_data.data_dir, "text_10240.dat")
+      data = File.binread(test_file)
+
+      @profiler.profile("BWT::encode", profiler_type: :method) do
+        bwt = Omnizip::Algorithms::BZip2::Bwt.new
+        bwt.encode(data)
+      end
+    end
+
+    def analyze_results
+      puts "\nAnalyzing performance results..." if verbose
+
+      @profiler.analyze_hot_paths(threshold_percentage: 15.0)
+      @profiler.identify_bottlenecks
+
+      generate_report
+      generate_suggestions
+    end
+
+    def generate_report
+      generator = Omnizip::Profiler::ReportGenerator.new(@profiler.report)
+
+      if verbose
+        puts "\n"
+        generator.print_report
+      end
+
+      generator
+    end
+
+    def generate_suggestions
+      suggestions = @profiler.generate_suggestions
+
+      return if suggestions.empty?
+
+      puts "\n#{'=' * 80}"
+      puts "OPTIMIZATION SUGGESTIONS"
+      puts "=" * 80
+
+      suggestions.take(5).each_with_index do |suggestion, index|
+        puts "\n#{index + 1}. [#{suggestion.severity.to_s.upcase}] " \
+             "#{suggestion.title}"
+        puts "   #{suggestion.description}"
+        puts "   Category: #{suggestion.category}"
+        puts "   Priority Score: #{suggestion.priority_score.round(2)}"
+      end
+
+      suggestions
+    end
+
+    def save_report(filename, format: :text)
+      generator = Omnizip::Profiler::ReportGenerator.new(@profiler.report)
+      generator.save_to_file(filename, format: format)
+    end
+
+    private
+
+    def generate_test_data
+      puts "\nGenerating test data..." if verbose
+
+      @test_data.generate_text(10_240, filename: "text_10240.dat")
+      @test_data.generate_repetitive(10_240, filename: "repetitive_10240.dat")
+    end
+
+    def cleanup_test_data
+      puts "\nCleaning up test data..." if verbose
+      @test_data.cleanup
+    end
+  end
+end
+
+# Run profiling if executed directly
+if __FILE__ == $PROGRAM_NAME
+  suite = Benchmark::ProfileSuite.new(verbose: true)
+  suite.run_all
+  suite.save_report("profile_report.txt", format: :text)
+  suite.save_report("profile_report.json", format: :json)
+end

data/benchmark/reporter.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Benchmark
+  # Formats and reports benchmark results
+  class Reporter
+    def initialize(results)
+      @results = results
+    end
+
+    def print_summary
+      puts "\n#{'=' * 80}"
+      puts "OMNIZIP vs 7-ZIP BENCHMARK RESULTS"
+      puts "=" * 80
+
+      @results.each do |result|
+        print_comparison(result)
+      end
+
+      print_overall_summary
+    end
+
+    def save_to_file(filename)
+      File.write(filename, to_json)
+      puts "\nResults saved to #{filename}"
+    end
+
+    def to_json(*_args)
+      JSON.pretty_generate({
+                             timestamp: Time.now.iso8601,
+                             results: @results.map(&:to_h),
+                           })
+    end
+
+    private
+
+    def print_comparison(result)
+      puts "\n#{'-' * 80}"
+      puts "Test: #{result.test_name}"
+      puts "-" * 80
+
+      if result.both_successful?
+        print_successful_comparison(result)
+      else
+        print_failed_comparison(result)
+      end
+    end
+
+    def print_successful_comparison(result)
+      omni = result.omnizip_result
+      seven = result.seven_zip_result
+
+      puts "Metric                                 Omnizip           7-Zip"
+      puts "-" * 80
+
+      puts format("%-30s %15s %15s",
+                  "Input Size",
+                  format_bytes(omni.input_size),
+                  format_bytes(seven.input_size))
+
+      puts format("%-30s %15s %15s",
+                  "Compressed Size",
+                  format_bytes(omni.compressed_size),
+                  format_bytes(seven.compressed_size))
+
+      puts format("%-30s %15.2f %15.2f",
+                  "Compression Ratio",
+                  omni.compression_ratio || 0.0,
+                  seven.compression_ratio || 0.0)
+
+      puts format("%-30s %15.3fs %15.3fs",
+                  "Compression Time",
+                  omni.compression_time || 0.0,
+                  seven.compression_time || 0.0)
+
+      puts "\n#{'-' * 80}"
+      puts "Comparison:"
+      puts "-" * 80
+
+      if result.size_difference_bytes
+        puts format("  Size difference: %+d bytes (%+.1f%%)",
+                    result.size_difference_bytes,
+                    result.size_difference_percentage)
+      end
+
+      return unless result.compression_speed_ratio
+
+      puts format("  Speed ratio: %.1fx slower",
+                  result.compression_speed_ratio)
+    end
+
+    def print_failed_comparison(result)
+      puts "\nOmnizip:"
+      print_result_status(result.omnizip_result)
+
+      puts "\n7-Zip:"
+      print_result_status(result.seven_zip_result)
+    end
+
+    def print_result_status(result)
+      if result.success?
+        puts "  Success"
+        puts "  Compressed: #{format_bytes(result.compressed_size)}"
+        puts "  Time: #{format_time(result.compression_time)}"
+      else
+        puts "  Failed: #{result.error}"
+      end
+    end
+
+    def print_overall_summary
+      puts "\n#{'=' * 80}"
+      puts "OVERALL SUMMARY"
+      puts "=" * 80
+
+      successful = @results.select(&:both_successful?)
+      total = @results.size
+
+      puts "Successful comparisons: #{successful.size}/#{total}"
+
+      return if successful.empty?
+
+      avg_size_diff = successful.filter_map(&:size_difference_percentage)
+        .sum / successful.size
+      avg_speed_ratio = successful.filter_map(&:compression_speed_ratio)
+        .sum / successful.size
+
+      puts format("\nAverage size difference: %+.1f%%", avg_size_diff)
+      puts format("Average speed ratio: %.1fx slower", avg_speed_ratio)
+    end
+
+    def format_bytes(bytes)
+      return "N/A" if bytes.nil?
+
+      if bytes < 1024
+        "#{bytes}B"
+      elsif bytes < 1024 * 1024
+        "#{(bytes / 1024.0).round(1)}KB"
+      else
+        "#{(bytes / (1024.0 * 1024)).round(1)}MB"
+      end
+    end
+
+    def format_time(seconds)
+      return "N/A" if seconds.nil?
+
+      "#{seconds.round(3)}s"
+    end
+  end
+end

data/benchmark/run_benchmarks.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "benchmark_suite"
+
+# Parse command-line options
+options = {
+  verbose: false,
+  quick: false,
+  mode: :all,
+  output: nil,
+}
+
+ARGV.each do |arg|
+  case arg
+  when "--verbose", "-v"
+    options[:verbose] = true
+  when "--quick", "-q"
+    options[:quick] = true
+  when "--compression-only"
+    options[:mode] = :compression
+  when "--filters-only"
+    options[:mode] = :filters
+  when /--output=(.+)/
+    options[:output] = Regexp.last_match(1)
+  when "--help", "-h"
+    puts <<~HELP
+      Usage: ruby benchmark/run_benchmarks.rb [OPTIONS]
+
+      Options:
+        -v, --verbose          Enable verbose output
+        -q, --quick            Run quick benchmarks (1 size, 1 type)
+        --compression-only     Run only compression benchmarks
+        --filters-only         Run only filter benchmarks
+        --output=FILE          Save results to JSON file
+        -h, --help             Show this help message
+
+      Examples:
+        ruby benchmark/run_benchmarks.rb
+        ruby benchmark/run_benchmarks.rb --quick --verbose
+        ruby benchmark/run_benchmarks.rb --output=results.json
+    HELP
+    exit 0
+  end
+end
+
+# Run benchmarks
+suite = Benchmark::BenchmarkSuite.new(
+  verbose: options[:verbose],
+  quick: options[:quick],
+)
+
+case options[:mode]
+when :compression
+  suite.run_compression_only
+when :filters
+  suite.run_filters_only
+else
+  suite.run_all
+end
+
+# Display results
+suite.report
+
+# Save results if requested
+suite.save_results(options[:output]) if options[:output]