在我们的代码库上进行优化时，我们尝试使用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, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l, :m, :n, :o) }
x.compare!
end
# Output
# Ruby version: ruby 2.7.2p137 (2020-10-01 revision 5445e04352) [x86_64-darwin19]
# INPUT: (:a, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l, :m, :n, :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, :b, :c, :d, :e, [:f, :g], :h, :i, :j, :k, :l, :m, :n, :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, :b, :c, :d, :e, [:f, :g], :h, :i, :j, :k, :l, :m, :n, :o]
methods.flatten!
end
Benchmark.memory do |x|
x.report("with_splat") { with_splat(:a, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l, :m, :n, :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, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l, :m, :n, :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, :b, :c, :d, :e, [:f, :g], :h, :i, :j, :k, :l, :m, :n, :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, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l, :m, :n, :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",
"type": "ARRAY",
"class": "0x7feb940972c0",
"length": 15,
"shared": true,
"references": [
"0x7feb941328d8"
],
"memsize": 40,
"flags": {
"wb_protected": true
}
}
如您所见，后一个数组确实消耗较少的内存（40 vs 160），但是它也已"shared": true设置并且在内存address引用了另一个对象0x7feb941328d8。
让我们all_objects.json通过jq找到该对象：
$ jq 'select(.address == "0x7feb941328d8")' all_objects.json
{
"address": "0x7feb941328d8",
"type": "ARRAY",
"frozen": true,
"length": 15,
"memsize": 160,
"flags": {
"wb_protected": true
}
}
这就是实际的数组，其内存大小与上面的第一个数组相同。
请注意，此数组已"frozen": true设置。我假设Ruby在遇到数组文字时会创建这些冻结的数组。然后，它可以根据评估结果创建便宜的（更）共享阵列。
本文收集自互联网，转载请注明来源。
如有侵权，请联系 [email protected] 删除。
我来说两句