雑ベンチ

bench.rb

#!/usr/bin/env ruby

require 'benchmark'
require 'json'
require 'securerandom'
require 'objspace'

require 'active_model'
require 'hashie'
require 'dry-struct'

def columns
  [
    :id,
    :name,
    :param1,
    :param2,
    :param3,
    :param4,
    :param5,
  ]
end

def generate(size = 1000)
  chars = [*("a".."z"),*("A".."Z"), *("0".."9")]
  Array.new(size) { |i|
    [
      SecureRandom.uuid,
      Array.new(10) { chars.sample }.join,
      rand(1000),
      rand(1000),
      rand(1000),
      rand(1000),
      rand(1000),
    ]
  }
end

def hash_array(data)
  data.map do |c|
    columns.zip(c).to_h
  end
end

MyStruct = Struct.new(*columns, keyword_init: true)

def struct(data)
  data.map do |c|
    MyStruct.new(**columns.zip(c).to_h)
  end
end

MyStructWithValidation = Struct.new(*columns, keyword_init: true)

class MyStructWithValidation
  include ActiveModel::Validations
  validates :id, presence: true
  validates :name, presence: { strict: true}
  validates :param1, numericality: { strict: true}
  validates :param2, numericality: { strict: true}
  validates :param3, numericality: { strict: true}
  validates :param4, numericality: { strict: true}
  validates :param5, numericality: { strict: true}
end

def structv(data)
  data.map do |c|
    MyStructWithValidation.new(**columns.zip(c).to_h).tap(&:valid?)
  end
end


class MyModel
  include ActiveModel::Model
  include ActiveModel::Attributes

  attribute :id, :string
  attribute :name, :string
  (1..5).each do |i|
    attribute :"param#{i}", :integer
  end

end

def am(data)
  data.map do |c|
    MyModel.new(**columns.zip(c).to_h)
  end
end


class MyDash < Hashie::Dash
  columns.each do |i|
    property i
  end
end

def hashie(data)
  data.map do |c|
    MyDash.new(**columns.zip(c).to_h)
  end
end

module Types
  include Dry::Types.module
end

class MyDry < Dry::Struct
  attribute :id, Types::Strict::String
  attribute :name, Types::Strict::String
  (1..5).each do |i|
    attribute :"param#{i}", Types::Strict::Integer
  end
end

def dry(data)
  data.map do |c|
    MyDry.new(**columns.zip(c).to_h)
  end
end

def memsize_of_all_reachable_objects_from(obj, exclude_class = Module)
  objs = {}
  queue = [obj]
  while obj = queue.pop
    next if objs[obj.object_id]
    next unless reachable_objects = ObjectSpace.reachable_objects_from(obj)
    reachable_objects.each{|o|
      case o
      when ObjectSpace::InternalObjectWrapper
        next if objs[o.internal_object_id]
      else
        next if objs[o.object_id]
      end
      queue.push o if !exclude_class || !o.kind_of?(exclude_class)
    }
    objs[obj.respond_to?(:internal_object_id) ? obj.internal_object_id : obj.object_id] = obj
  end
  objs.inject(0){|r, (_, o)| r += ObjectSpace.memsize_of(o)}
end

def comma(i)
  i.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/){|d| "#{d}," }
end

n = 10000

all = generate(n)

result = {}

Benchmark.bmbm(10) do |x|
  x.report("hash") { result[:hash] = hash_array(all) }
  x.report("struct") { result[:struct] = struct(all) }
  x.report("structv") { result[:structv] = structv(all) }
  x.report("am") { result[:am] = am(all) }
  x.report("hashie") { result[:hashie] = hashie(all) }
  x.report("dry") { result[:dry] = dry(all) }
end

#puts
#result.each{|k,v| p v.first }

puts
puts '---->  mem'
result.each do |key, obj|
  puts "%10s %10s" % [key, comma(memsize_of_all_reachable_objects_from(obj))]
end