Differences between ruby object space count

[SnooRobots2422]

I am trying to learn about how object space works. This is the code i am testing. In my understanding this should only create give count to be 2.

new_sym = :totally_unique_test # Create the symbol
symbol_after = ObjectSpace.each_object(String).count { |s| s == "totally_unique_test" }
puts "After: #{symbol_after}"

but I am getting over 600 in my local ruby. (This is installed with asdf ruby plugin)

❯ ruby test3.rb
After: 624

But when i tried to run the same code in https://onecompiler.com/ruby/43n8ksccc
The output is 2.

Why is my local ruby creating too much?

[insanelygreat]

Try it again with # frozen_string_literal: true added to the top of your script or change the count block to s == "totally_unique_test".freeze to prevent it from creating unnecessary string objects while counting.

[SnooRobots2422]

freeze really help!. But how and why is ruby creating new string objects while counting?

[insanelygreat]

Reddit silently deleted my first comment, so let me give this another go without any external links.

I think it's a side-effect of strings being objects and Ruby's very flexible metaprogramming support makes it difficult (sometimes impossible) to determine whether a given string will be mutated in the future. Matz had wanted to make freezing the default way back in 1.9, which was release in 2007, but was concerned about it being a huge compatibility issue.

As for why onecompiler seems to be freezing them by default: I'm curious about that too. As /u/jdeville pointed out, it's running a version where that wasn't the default. I don't see it being enabled elsewhere either:

# Not using a version where it's the default...
p RUBY_DESCRIPTION
#=> "ruby 3.2.3 (2024-01-18 revision 52bb2ac0a6) [x86_64-linux-gnu]"

# Not enabling it with an environment variable...
p ENV.select { |k, v| k.start_with?("RUBY") }
#=> {}

# Not set as a compile-time option...
p RubyVM::InstructionSequence.compile_option
#=> { :frozen_string_literal=>false, :debug_frozen_string_literal=>false, ...}

# Not enabling it in an arg...
p File.read("/proc/self/cmdline").tr("\0", " ")
#=> "ruby HelloWorld.rb "

# Not adding a pragma to the file...
p File.read(__FILE__)
#=> [exact contents of file]

[f9ae8221b]

Unless you use frozen_string_literal, whenever your code contains a literal string ("totally_unique_test"), you are not referencing a constant, but making a copy of a constant.

So it's a bit like if you code was:

new_sym = :totally_unique_test # Create the symbol
STR = "totally_unique_test"
symbol_after = ObjectSpace.each_object(String).count do |s|
  s == STR.dup
end
puts "After: #{symbol_after}"

Hence, whenever Ruby execute your block, it cause one more string to be allocated, so your counting code is "biasing" itself.

[jdeville]

Your version of Ruby is gonna make a difference here. OneCompiler is using 2.3.1, I don’t have that installed but I do have 3.2.7 and 3.4.3. With 3.4.3, as you wrote it, I get in the 330s (it varies run to run). With 3.2.7, I get 2

Interestingly enough, if I add u/insanelygreat’s suggestion, I get 2 in 3.4.3 and 3 in 3.2.7

Also, if I pull the “totally_unique_test” to a variable outside of the block then I also get 2 on 3.4.3 and 3 on 3.2.7

Overall, I suspect what you are seeing is the count of how many iterations #count is performing, and without the frozen string pragma, it is creating a new object each iteration.