问题描述
在优化代码库时，我们尝试使用bang方法减少有意义的对象分配，但是我们在基准测试中观察到分配的对象数量减少了，但总体内存大小却增加了。
复制脚本：
# frozen_string_literal: true
require 'bundler/inline'
gemfile(true) do
source "https://rubygems.org"
git_source(:github) { |repo| "https://github.com/#{repo}.git" }
gem 'benchmark-memory','0.1.2'
end
require 'benchmark/memory'
def with_bang(*methods)
methods.tap(&:flatten!)
end
def without_bang(*methods)
methods.flatten
end
Benchmark.memory do |x|
x.report("with_bang") { with_bang(:a,:b,:c,:d,:e,:f,:g,:h,:i,:j,:k,:l,:m,:n,:o) }
x.report("without_bang") { without_bang(:a,:o) }
x.compare!
end
# Output
# Ruby version: ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19]
# INPUT: (:a,:o)
# Calculating -------------------------------------
# with_bang 160.000 memsize ( 0.000 retained)
# 1.000 objects ( 0.000 retained)
# 0.000 strings ( 0.000 retained)
# without_bang 80.000 memsize ( 0.000 retained)
# 2.000 objects ( 0.000 retained)
# 0.000 strings ( 0.000 retained)
# Comparison:
# without_bang: 80 allocated
# with_bang: 160 allocated - 2.00x more
# INPUT: (:a,[:f,:g],:o)
# Calculating -------------------------------------
# with_bang 240.000 memsize ( 0.000 retained)
# 3.000 objects ( 0.000 retained)
# 0.000 strings ( 0.000 retained)
# without_bang 480.000 memsize ( 0.000 retained)
# 3.000 objects ( 0.000 retained)
# 0.000 strings ( 0.000 retained)
# Comparison:
# with_bang: 240 allocated
# without_bang: 480 allocated - 2.00x more
在我的实验中，我相信这是由于splat运算符转换为数组所致。以下是提示我该结论的脚本。
# frozen_string_literal: true
require 'bundler/inline'
gemfile(true) do
source "https://rubygems.org"
git_source(:github) { |repo| "https://github.com/#{repo}.git" }
gem 'benchmark-memory','0.1.2'
end
require 'benchmark/memory'
def with_splat(*methods)
methods.flatten!
end
def without_splat
methods = [:a,:o]
methods.flatten!
end
Benchmark.memory do |x|
x.report("with_splat") { with_splat(:a,:o) }
x.report("without_splat") { without_splat }
x.compare!
end
# Output
# Ruby version: ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19]
# INPUT: (:a,:o)
# Calculating -------------------------------------
# with_splat 160.000 memsize ( 0.000 retained)
# 1.000 objects ( 0.000 retained)
# 0.000 strings ( 0.000 retained)
# without_splat 40.000 memsize ( 0.000 retained)
# 1.000 objects ( 0.000 retained)
# 0.000 strings ( 0.000 retained)
# Comparison:
# without_splat: 40 allocated
# with_splat: 160 allocated - 4.00x more
# INPUT: (:a,:o)
# Calculating -------------------------------------
# with_splat 240.000 memsize ( 0.000 retained)
# 3.000 objects ( 0.000 retained)
# 0.000 strings ( 0.000 retained)
# without_splat 240.000 memsize ( 0.000 retained)
# 3.000 objects ( 0.000 retained)
# 0.000 strings ( 0.000 retained)
# Comparison:
# with_splat: 240 allocated
# without_splat: 240 allocated - same
我缺少什么才能了解这种行为？为什么会以这种方式运行？
谢谢！
编辑： 我向包含嵌套数组的基准比较添加了新的输入。通过新的输入，我们看到的结果与以前的基准测试有所不同，我感到更加困惑！
解决方法
让我们更仔细地检查两个数组：
require 'objspace'
def with_splat(*methods)
ObjectSpace.dump(methods,output: open('with_splat.json','w'))
end
def without_splat(methods)
ObjectSpace.dump(methods,output: open('without_splat.json','w'))
end
with_splat(:a,:b,:c,:d,:e,:f,:g,:h,:i,:j,:k,:l,:m,:n,:o)
without_splat([:a,:o])
ObjectSpace.dump_all(output: open('all_objects.json','w'))
该脚本生成3个文件：
-
with_splat.json包含有关数组阵列的数据 -
without_splat.json包含有关非分割数组的数据 -
all_objects.json包含有关所有对象的数据（很多！）
with_splat.json ：（格式化）
{
"address": "0x7feb941289a0","type": "ARRAY","class": "0x7feb940972c0","length": 15,"memsize": 160,"flags": {
"wb_protected": true
}
}
without_splat.json ：（格式化）
{
"address": "0x7feb941287e8","shared": true,"references": [
"0x7feb941328d8"
],"memsize": 40,"flags": {
"wb_protected": true
}
}
如您所见，后一个数组确实消耗较少的内存（40 vs 160），但是它也设置了"shared": true，并且引用了内存地址0x7feb941328d8上的另一个对象。
让我们通过jq在all_objects.json中找到该对象：
$ jq 'select(.address == "0x7feb941328d8")' all_objects.json
{
"address": "0x7feb941328d8","frozen": true,"flags": {
"wb_protected": true
}
}
这是具有与上面的第一个数组相同的内存大小的实际数组。
请注意，此数组已设置"frozen": true。我假设Ruby在遇到数组文字时会创建这些冻结的数组。然后可以根据评估结果创建便宜的（更）共享数组。