Talks
Speakers
Events
Topics
Sign in
Home
Talks
Speakers
Events
Topics
Leaderboard
Use
Analytics
Sign in
Suggest modification to this talk
Title
Description
Backtraces are very useful tools when debugging problems in Ruby programs. Unfortunately, backtrace generation is expensive for deep callstacks. In older versions of Ruby, this is true even if you only want a partial backtrace, such as a single backtrace frame. Thankfully, Ruby 3 has been optimized so that it no longer processes unnecessary backtrace frames, which can greatly speed up the generation of partial backtraces. Join me for an interesting look a Ruby backtraces, how they are generated, how we optimized partial backtraces in Ruby 3, and how we fixed bugs in the optimization in 3.0.1. RubyKaigi Takeout: https://rubykaigi.org/2021-takeout/presentations/jeremyevans0.html
Date
Summarized using AI?
If this talk's summary was generated by AI, please check this box. A "Summarized using AI" badge will be displayed in the summary tab to indicate that the summary was generated using AI.
Show "Summarized using AI" badge on summary page
Summary
Markdown supported
In this presentation titled 'Optimizing Partial Backtraces in Ruby 3', Jeremy Evans discusses the importance of backtraces in Ruby programming, particularly in the context of debugging. Backtraces provide a representation of the call stack, making it easier to diagnose errors. Evans explains that in prior versions of Ruby, obtaining partial backtraces was inefficient and costly, as the system processed unnecessary frames even when only a single frame or a few were requested. The talk delves into the improvements made in Ruby 3 to address this issue, emphasizing the distinction between different control frames during backtrace generation. Key points discussed include: - The significance of backtraces in error detection and debugging; they provide necessary information about where errors occur in the code. - The need for optimizing partial backtrace performance, which was triggered by an issue raised regarding memory usage. - The process of generating backtraces in Ruby and how Ruby’s virtual machine manages control frames. - The challenges faced during optimization, including bugs that emerged post-implementation. - Evans showcases specific examples, such as how a caller with a start argument returns only the required frame without processing the entire stack. - The presentation describes the evolution of solutions from Ruby 3.0.0 to the fixes in Ruby 3.0.1, including a realization that a completely new algorithm was warranted for better performance and simplicity. - The importance of maintaining appropriate control measures to ensure accurate backtrace generation. In conclusion, Evans emphasizes the lessons learned throughout the optimization process: - The value in tackling unfamiliar code to drive improvements. - The understanding that significant changes may lead to regressions in untested areas, which is a necessary risk for potential gains. - The recognition of when a new algorithm is required, advocating for fresh approaches to resolve persistent issues. By resolving issues with partial backtrace generation, Ruby 3 further enhances its debugging capabilities for developers.
Suggest modifications
Cancel
