bytes.rb

# Refactoring proposal for ActiveSupport bytes calculations
require "benchmark"
ONE = 1

module Bytes
  def bytes
    self
  end
  alias :byte :bytes

  def kilobytes
    self * 1024
  end
  alias :kilobyte :kilobytes

  def megabytes
    self * 1024.kilobytes
  end
  alias :megabyte :megabytes

  def gigabytes
    self * 1024.megabytes 
  end
  alias :gigabyte :gigabytes

  def terabytes
    self * 1024.gigabytes
  end
  alias :terabyte :terabytes
  
  def petabytes
    self * 1024.terabytes
  end
  alias :petabyte :petabytes
  
  def exabytes
    self * 1024.petabytes
  end
  alias :exabyte :exabytes
end

module RefactoredBytes
  KILOBYTE = 1024
  MEGABYTE = KILOBYTE * 1024
  GIGABYTE = MEGABYTE * 1024
  TERABYTE = GIGABYTE * 1024
  PETABYTE = TERABYTE * 1024
  EXABYTE  = PETABYTE * 1024

  def refactored_bytes
    self
  end
  alias :refactored_byte :refactored_bytes

  def refactored_kilobytes
    self * KILOBYTE
  end
  alias :refactored_kilobyte :refactored_kilobytes

  def refactored_megabytes
    self * MEGABYTE
  end
  alias :refactored_megabyte :refactored_megabytes

  def refactored_gigabytes
    self * GIGABYTE
  end
  alias :refactored_gigabyte :refactored_gigabytes

  def refactored_terabytes
    self * TERABYTE
  end
  alias :refactored_terabyte :refactored_terabytes
  
  def refactored_petabytes
    self * PETABYTE
  end
  alias :refactored_petabyte :refactored_petabytes
  
  def refactored_exabytes
    self * EXABYTE
  end
  alias :refactored_exabyte :refactored_exabytes
end

class Numeric
  include Bytes, RefactoredBytes
end

Benchmark.bm(30) do |b|
  # kilobyte
  b.report("kilobyte") do
    5_000_000.times { ONE.kilobyte }
  end

  b.report("refactored_kilobyte") do
    5_000_000.times { ONE.refactored_kilobyte }
  end

  # megabyte
  b.report("megabyte") do
    5_000_000.times { ONE.megabyte }
  end

  b.report("refactored_megabyte") do
    5_000_000.times { ONE.refactored_megabyte }
  end

  # gigabyte
  b.report("gigabyte") do
    5_000_000.times { ONE.gigabyte }
  end

  b.report("refactored_gigabyte") do
    5_000_000.times { ONE.refactored_gigabyte }
  end

  # terabyte
  b.report("terabyte") do
    5_000_000.times { ONE.terabyte }
  end

  b.report("refactored_terabyte") do
    5_000_000.times { ONE.refactored_terabyte }
  end

  # petabyte
  b.report("petabyte") do
    5_000_000.times { ONE.petabyte }
  end

  b.report("refactored_petabyte") do
    5_000_000.times { ONE.refactored_petabyte }
  end

  # exabyte
  b.report("exabyte") do
    5_000_000.times { ONE.exabyte }
  end

  b.report("refactored_exabyte") do
    5_000_000.times { ONE.refactored_exabyte }
  end
end

__END__

                                    user     system      total        real
kilobyte                        2.450000   0.010000   2.460000 (  2.479556)
refactored_kilobyte             2.570000   0.010000   2.580000 (  2.583070)
megabyte                        4.360000   0.010000   4.370000 (  4.378750)
refactored_megabyte             2.570000   0.010000   2.580000 (  2.595025)
gigabyte                       16.590000   0.040000  16.630000 ( 16.678308)
refactored_gigabyte             8.580000   0.010000   8.590000 (  8.609626)
terabyte                       25.110000   0.060000  25.170000 ( 25.218141)
refactored_terabyte             8.630000   0.030000   8.660000 (  8.671909)
petabyte                       32.890000   0.100000  32.990000 ( 33.105326)
refactored_petabyte             8.650000   0.030000   8.680000 (  8.706800)
exabyte                        41.200000   0.120000  41.320000 ( 41.442681)
refactored_exabyte              8.660000   0.020000   8.680000 (  8.695625)