From: Charlie Somerville <charlie@...>
Date: 2013-02-07T07:06:51+09:00
Subject: [ruby-core:51949] Re: [ruby-trunk - Feature #7791] Let symbols be garbage collected

@trans

You cannot 'purge the symbol table'. If a symbol used by a method name, etc is purged then you will encounter strange problems like:

* not being able to call the method
* the wrong code gets invoked when you call a method
* Ruby crashes 

Symbols are integral to the implementation of MRI. You cannot change how they work this easily.

ko1's approach is probably the best, but  even then it still has a few issues.

For example, say you create a GC-able Symbol and pass it to send. That symbol will need to be interned, but then you need a way to let the Symbol object know that it now represents an internal ID (or else you break the property of Symbols being unique)   

On 07/02/2013, at 6:28 AM, "trans (Thomas Sawyer)" <transfire@gmail.com> wrote:

> 
> Issue #7791 has been updated by trans (Thomas Sawyer).
> 
> 
> @rosenfeld Just had a thought... maybe we could combine these approaches. Maybe GCing Symbols is too difficult. But what if it were done manually? Would that be more doable? .e.g
> 
>  begin
>    ...
>  rescue SymbolExhaustion
>    purge_symbol_table(0.5)  # 50%
>    retry
>  end
> 
> This would allow you to continue on, but also log the offence.
> 
> Of course, I say this not knowing what the underlying problem with GCing symbols is, so maybe manually doing is no better. As I said, just a thought.
> ----------------------------------------
> Feature #7791: Let symbols be garbage collected
> https://bugs.ruby-lang.org/issues/7791#change-35943
> 
> Author: rosenfeld (Rodrigo Rosenfeld Rosas)
> Status: Feedback
> Priority: Normal
> Assignee: matz (Yukihiro Matsumoto)
> Category: core
> Target version: next minor
> 
> 
> Lots of Denial-of-Service security vulnerabilities exploited in Ruby programs rely on symbols not being collected by garbage collector.
> 
> Ideally I'd prefer symbols and strings to behave exactly the same being just alternate ways of writing strings but I'll let this to another ticket.
> 
> This one simply asks for symbols to be allowed to be garbage collected when low on memory. Maybe one could set up some up-limit memory constraints dedicated to storing symbols. That way, the most accessed symbols would remain in that memory region and the least used ones would be reclaimed when the memory for symbols is over and a new symbol is created.
> 
> Or you could just allow symbols to be garbage collected any time. Any reasons why this would be a bad idea? Any performance benchmark demonstrating how using symbols instead of strings would make a real-world software perform much better?
> 
> Currently I only see symbols slowing down processing because people don't want to worry about it and will often use something like ActiveSupport Hash#with_indifferent_access or some other method to convert a string to symbol or vice versa...
> 
> 
> -- 
> http://bugs.ruby-lang.org/
>