From: jean.boussier@... Date: 2019-08-06T14:15:04+00:00 Subject: [ruby-core:94159] [Ruby master Misc#16047] Reconsider impact of frozen_string_literal on dynamic strings Issue #16047 has been updated by byroot (Jean Boussier). > I am interested in the claimed/perceived speedup. I had seen some benchmarks that claimed no difference in speed. And that made sense to me since deduplication is a memory optimization, not a significant CPU optimization. The speedup mostly come from reduced GC pressure. Consider the following snippet: ```ruby def call(env) env["HTTP_PATH_INFO"] end ``` Without `frozen_string_literal: true` it's pretty much equivalent to: ```ruby HTTP_PATH_INFO = "HTTP_PATH_INFO".freeze def call(env) env[HTTP_PATH_INFO.dup] end ``` That's a totally useless allocation. In itself it doesn't matter much, but if it's in a tight loop it can really participate in trashing the GC, and overall, it adds up. Also, if you profile a Ruby application you'll very often see 20-30% of the time spent in the GC, so reducing useless allocations as well as the size of the heap is a fairly good medium for increasing CPU performance. As for `.dup/+`, maybe that's me but I extremely rarely need it. > we could have the best of both worlds if dynamic string literals were not frozen by the magic comment I don't really see it as a upside. IMO these are literals before being "dynamic", and as such it seems much more consistent to me that they'd be frozen as well. ---------------------------------------- Misc #16047: Reconsider impact of frozen_string_literal on dynamic strings https://bugs.ruby-lang.org/issues/16047#change-80411 * Author: Dan0042 (Daniel DeLorme) * Status: Open * Priority: Normal * Assignee: matz (Yukihiro Matsumoto) ---------------------------------------- The rationale for introducing `frozen_string_literal` was because rubyists were starting to litter their code with `"".freeze` for optimization, and it's ugly. But by using frozen_string_literal we introduce the opposite problem: we must litter the code with `"".dup` in order to have mutable strings, and it's ugly. The rationale for freezing all strings including dynamic was because it's [easy to explain] (https://docs.google.com/document/u/1/d/1D0Eo5N7NE_unIySOKG9lVj_eyXf66BQPM4PKp7NvMyQ/pub) This may be true, but at the expense of making it cumbersome to use. And also completely useless for memory optimization. In my personal experience using frozen_string_literal, I find that static strings are usually ok to freeze without changing anything else, but that freezing dynamic strings often create bugs that require `+""` or `"".dup` boilerplate to circumvent. So in the end I found myself stopping regular use of that feature, since it's more trouble than it's worth. As such I'd like to ask other rubyists how has been their experience with **actually using** frozen_string_literal on a day-to-day basis; if my experience is unique or common. Thank you for sharing your thoughts. -- https://bugs.ruby-lang.org/ Unsubscribe: