Stories with Tag Ruby 3.5

• Fast Allocations in Ruby 3.5

  permalink

  Posted: 2025-05-22 14:01:55

  Verbose tl;dr

  Ruby 3.5 introduces a new object allocation mechanism called "layered compaction," which significantly speeds up object creation. Instead of relying solely on malloc for memory, Ruby now utilizes a multi-layered heap consisting of TLSF (Two-Level Segregated Fit) allocators within larger mmap'd regions. This approach reduces system calls, minimizes fragmentation, and improves cache locality, resulting in performance gains, especially in multi-threaded scenarios. The layered compaction mechanism manages these TLSF heaps, compacting them when necessary to reclaim fragmented memory and ensure efficient object allocation. This improvement translates to faster application performance and reduced memory usage.

  The blog post "Fast Allocations in Ruby 3.5" by Aaron Patterson on Rails at Scale details performance improvements related to object allocation in Ruby 3.5, focusing on the introduction of a new allocation system called "malloc_trim." The author begins by establishing the context of Ruby's memory management, explaining that Ruby uses system malloc for memory allocation and that frequent calls to malloc can lead to performance bottlenecks, especially in memory-intensive applications like Rails.

  The post then delves into the problems associated with fragmentation in memory management. Fragmentation occurs when free memory becomes divided into small, non-contiguous chunks, making it difficult to allocate larger objects despite having sufficient total free memory. This leads to increased system calls to obtain more memory from the operating system, further hindering performance. The traditional solution to this problem has been calling malloc_trim, a function that releases unused memory back to the operating system. However, indiscriminately calling malloc_trim can also be detrimental, as it introduces overhead.

  Patterson describes the new dynamic malloc_trim strategy implemented in Ruby 3.5. Instead of relying on a fixed or periodic approach, Ruby 3.5 intelligently decides when to call malloc_trim based on the amount of free memory available within Ruby's heap. This adaptive approach aims to minimize both fragmentation and the overhead of unnecessary malloc_trim calls. Specifically, the new algorithm calls malloc_trim when the amount of free memory exceeds a certain threshold, dynamically adjusted based on the maximum amount of memory ever allocated. This ensures malloc_trim is invoked only when there's a significant amount of potentially wasted memory.

  The blog post then presents benchmark results demonstrating the effectiveness of the new allocation system. These benchmarks involve creating and destroying many small objects, a scenario prone to fragmentation. The results show significant performance improvements in Ruby 3.5 compared to older Ruby versions, particularly under memory-intensive workloads. The benchmarks demonstrate substantial reductions in both the number of calls to malloc and the overall execution time.

  Finally, Patterson concludes by highlighting the potential benefits of these improvements for Rails applications and other Ruby programs that perform frequent object allocations. The dynamic malloc_trim strategy in Ruby 3.5 promises to reduce memory usage and improve performance, especially in environments where memory resources are constrained or where allocation patterns lead to significant fragmentation. This ultimately contributes to a more efficient and responsive Ruby runtime.

  • ruby
  • Ruby 3.5
  • performance
  • Allocation
  • memory management
  • Garbage Collection
  • optimization
  • rails
  • Web Development
  • Programming Languages

  Summary of Comments ( 61 )
  https://news.ycombinator.com/item?id=44062160

  Verbose tl;dr

  Hacker News users generally praised the Ruby 3.5 allocation improvements, with many noting the impressive performance gains demonstrated in the benchmarks. Some commenters pointed out that while the micro-benchmarks are promising, real-world application performance improvements would be the ultimate test. A few questioned the methodology of the benchmarks and suggested alternative scenarios to consider. There was also discussion about the tradeoffs of different memory allocation strategies and their impact on garbage collection. Several commenters expressed excitement about the future of Ruby performance and its potential to compete with other languages. One user highlighted the importance of these optimizations for Rails applications, given Rails' historical reputation for memory consumption.

  The Hacker News post titled "Fast Allocations in Ruby 3.5" linking to a Rails at Scale article has generated several comments discussing the performance improvements and their implications.

  One commenter expresses excitement about the potential of these improvements to reduce object allocation overhead in Ruby, a common performance bottleneck. They specifically highlight the benefit for workloads involving many small objects.

  Another commenter delves deeper into the technical details of the improvements, mentioning the reduced reliance on the garbage collector and the implications for memory fragmentation. They also compare Ruby's approach to memory management with other languages like Java and discuss the tradeoffs.

  A further comment thread discusses the historical context of memory management in Ruby and the various optimization efforts made over the years. This includes mentions of previous techniques like object pooling and how the changes in 3.5 build upon or replace those methods.

  Some skepticism is expressed regarding the real-world impact of these optimizations. One commenter questions whether the benchmarks presented accurately reflect typical Ruby application workloads, and suggests more comprehensive benchmarking is needed. They propose testing with different object sizes and lifespans to get a more complete picture of the performance gains.

  Another commenter raises the point that while allocation speed is improved, garbage collection times might still be a concern. They suggest focusing on reducing overall object creation as a more effective strategy for performance optimization.

  The discussion also touches on the trade-offs between raw performance and developer experience. One commenter argues that while these optimizations are beneficial, the complexity of Ruby's memory management might be a barrier for some developers. They suggest focusing on tools and techniques that simplify memory management for the average Ruby developer.

  Finally, a few commenters express anticipation for further advancements in Ruby's performance, and speculate on future directions for optimization efforts. They mention potential improvements in areas like concurrency and just-in-time compilation.

• Ruby 3.5 Feature: Namespace on read

  permalink

  Posted: 2025-05-12 13:39:34

  Verbose tl;dr

  Ruby 3.5 introduces a new feature to address the "namespace pollution" problem caused by global constants. Currently, referencing an undefined constant triggers an autoload, potentially loading unwanted code or creating unexpected dependencies. The proposed solution allows defining a namespace for constant lookup on a per-file basis, using a comment like # frozen_string_literal: true, scope: Foo. This restricts the search for unqualified constants within the Foo namespace, preventing unintended autoloads and improving code isolation. If a constant isn't found within the specified namespace, a NameError will be raised, giving developers more control and predictability over constant resolution. This change promotes better code organization, reduces unwanted side effects, and enhances the robustness of Ruby applications.

  The proposed Ruby 3.5 feature, "Namespace on read," aims to introduce a more streamlined and potentially performant mechanism for accessing nested constants within modules and classes. Currently, referencing a deeply nested constant like ModuleA::ModuleB::ModuleC::ConstantD requires Ruby to traverse the entire namespace hierarchy, starting from the top-level and successively looking up ModuleA, then ModuleB within ModuleA, ModuleC within ModuleB, and finally ConstantD within ModuleC. This process can be computationally expensive, especially in scenarios with numerous nested modules or frequent access to such constants.

  The "Namespace on read" feature proposes an optimization wherein the entire path to the constant, ModuleA::ModuleB::ModuleC::ConstantD in this example, is stored as a single unit – a frozen array representing the namespace path – alongside the constant itself. This frozen array effectively "caches" the namespace traversal. Subsequent accesses to the same constant can then directly utilize this stored path, bypassing the repetitive lookup process. This direct access potentially yields performance improvements, particularly when dealing with deeply nested structures.

  The implementation details involve creating a new internal object type specifically for these namespace-prefixed constants. This new object stores both the constant's value and the associated frozen path. When the constant is referenced, the runtime checks for this specialized object. If found, it uses the stored path for direct access. If not, it performs the traditional lookup, creates the specialized object with the calculated path, and stores it for future use. This approach effectively combines the benefits of eager and lazy loading: the initial access performs the full lookup, but subsequent accesses benefit from the cached path. This mechanism aims to minimize overhead while ensuring correct behavior.

  The proposal acknowledges potential limitations and complexities, particularly regarding constant redefinition and reloading. If a constant within the nested hierarchy is redefined, the cached path might become invalid. The implementation needs to handle such scenarios gracefully, potentially by invalidating and recalculating the cached paths when necessary. Additionally, concerns exist regarding the memory overhead introduced by storing these namespace paths for potentially numerous constants. These challenges need to be addressed to ensure the feature's stability and efficiency.

  • ruby
  • Ruby 3.5
  • Namespaces
  • Read
  • Feature
  • programming language
  • syntax
  • Ruby Feature
  • Constant Lookup
  • Scope
  • Name Resolution
  • Lexical Scope

  Summary of Comments ( 53 )
  https://news.ycombinator.com/item?id=43962770

  Verbose tl;dr

  Hacker News users discuss the implications of Ruby 3.5's proposed namespace on read feature, primarily focusing on the potential confusion and complexity it introduces. Some argue that the feature addresses a niche problem and might not be worth the added cognitive overhead for developers. Others suggest alternative solutions, like using symbols or dedicated data structures, rather than relying on this implicit behavior. The potential for subtle bugs arising from unintended namespace clashes is also a concern. Several commenters express skepticism about the feature's overall value and whether it significantly improves Ruby's usability. Some even question the motivation behind its inclusion. There's a general sentiment that the proposal lacks clear justification and adds complexity without addressing a widespread issue.

  The Hacker News post titled "Ruby 3.5 Feature: Namespace on read" (https://news.ycombinator.com/item?id=43962770) discusses the proposed Ruby feature outlined in the linked bug report. The discussion in the comments section is relatively brief and doesn't delve too deep into the technicalities. No one expresses strong opinions for or against the feature.

  One commenter points out that the proposed solution feels like a workaround for a larger problem, specifically that constants are global by default in Ruby. They suggest exploring alternative approaches, although they don't elaborate on what those approaches might be. This comment highlights a potential underlying issue with Ruby's design that the proposed feature addresses only superficially.

  Another comment simply expresses mild interest in the proposal, stating that they'll be "watching this". This doesn't offer much in the way of analysis but indicates a degree of curiosity within the community.

  The remaining comments are primarily jokes or brief acknowledgements of the proposed feature, with no substantial discussion of its implications or potential benefits/drawbacks. There's a general lack of in-depth analysis or strong opinions expressed within the limited number of comments.