| Age | Commit message (Collapse) | Author |
|---|
| Notes: Merged: https://.com/ruby/ruby/pull/12736 Merged-By: nobu <[email protected]> |
| Notes: Merged: https://.com/ruby/ruby/pull/12415 |
| Notes: Merged: https://.com/ruby/ruby/pull/12411 |
| Notes: Merged: https://.com/ruby/ruby/pull/12102 |
| Instead of silently ignoring the key, we should raise to clearly tell the user that this key is read-only. Notes: Merged: https://.com/ruby/ruby/pull/11872 |
| Notes: Merged: https://.com/ruby/ruby/pull/11644 |
| Notes: Merged: https://.com/ruby/ruby/pull/11642 |
| Notes: Merged: https://.com/ruby/ruby/pull/11636 |
| Notes: Merged: https://.com/ruby/ruby/pull/11638 |
| Notes: Merged: https://.com/ruby/ruby/pull/11637 |
| Notes: Merged: https://.com/ruby/ruby/pull/11639 |
| Notes: Merged: https://.com/ruby/ruby/pull/11639 |
| |
| This feature provides a new method `GC.config` that configures internal GC configuration variables provided by an individual GC implementation. Implemented in this PR is the option `full_mark`: a boolean value that will determine whether the Ruby GC is allowed to run a major collection while the process is running. It has the following semantics This feature configures Ruby's GC to only run minor GC's. It's designed to give users relying on Out of Band GC complete control over when a major GC is run. Configuring `full_mark: false` does two main things: * Never runs a Major GC. When the heap runs out of space during a minor and when a major would traditionally be run, instead we allocate more heap pages, and mark objspace as needing a major GC. * Don't increment object ages. We don't promote objects during GC, this will cause every object to be scanned on every minor. This is an intentional trade-off between minor GC's doing more work every time, and potentially promoting objects that will then never be GC'd. The intention behind not aging objects is that users of this feature should use a preforking web server, or some other method of pre-warming the oldgen (like Nakayoshi fork)before disabling Majors. That way most objects that are going to be old will have already been promoted. This will interleave major and minor GC collections in exactly the same what that the Ruby GC runs in versions previously to this. This is the default behaviour. * This new method has the following extra semantics: - `GC.config` with no arguments returns a hash of the keys of the currently configured GC - `GC.config` with a key pair (eg. `GC.config(full_mark: true)` sets the matching config key to the corresponding value and returns the entire known config hash, including the new values. If the key does not exist, `nil` is returned * When a minor GC is run, Ruby sets an internal status flag to determine whether the next GC will be a major or a minor. When `full_mark: false` this flag is ignored and every GC will be a minor. This status flag can be accessed at `GC.latest_gc_info(:needs_major_by)`. Any value other than `nil` means that the next collection would have been a major. Thus it's possible to use this feature to check at a predetermined time, whether a major GC is necessary and run one if it is. eg. After a request has finished processing. ```ruby if GC.latest_gc_info(:needs_major_by) GC.start(full_mark: true) end ``` [Feature #20443] |
| This commit splits gc.c into two files: - gc.c now only contains code not specific to Ruby GC. This includes code to mark objects (which the GC implementation may choose not to use) and wrappers for internal APIs that the implementation may need to use (e.g. locking the VM). - gc_impl.c now contains the implementation of Ruby's GC. This includes marking, sweeping, compaction, and statistics. Most importantly, gc_impl.c only uses public APIs in Ruby and a limited set of functions exposed in gc.c. This allows us to build gc_impl.c independently of Ruby and plug Ruby's GC into itself. |
| The documentation for GC.start was incorrect. It said that the `immediate_sweep` keyword argument would defer sweeping when set to `true`, but it should have said that it would defer sweeping when set to `false`. The commit will also fix the typo "immedate_sweep" to "immediate_sweep". |
| |
| This commit adds key force_incremental_marking_finish_count to GC.stat_heap. This statistic returns the number of times the size pool has forced incremental marking to finish due to running out of slots. |
| Notes: Merged: https://.com/ruby/ruby/pull/8219 |
| Notes: Merged: https://.com/ruby/ruby/pull/8219 |
| Notes: Merged: https://.com/ruby/ruby/pull/8219 |
| Notes: Merged: https://.com/ruby/ruby/pull/8219 |
| There is a `time` key in GC.stat that gives us the total time spent in GC. However, we don't know what proportion of the time is spent between marking and sweeping. This makes it difficult to tune the GC as we're not sure where to focus our efforts on. This PR adds keys `marking_time` and `sweeping_time` to GC.stat for the time spent marking and sweeping, in milliseconds. [Feature #19437] Notes: Merged: https://.com/ruby/ruby/pull/7304 |
| |
| Notes: Merged: https://.com/ruby/ruby/pull/6985 |
| RDoc was making every usage of the word "GC" link to the page for GC (which is the same page). |
| RDoc parses the last arrow in the call-seq as the arrow for the return type. It was getting confused over the arrow in the hash. |
| |
| This commit adds a `capacity` field to shapes, and adds shape transitions whenever an object's capacity changes. Objects which are allocated out of a bigger size pool will also make a transition from the root shape to the shape with the correct capacity for their size pool when they are allocated. This commit will allow us to remove numiv from objects completely, and will also mean we can guarantee that if two objects share shapes, their IVs are in the same positions (an embedded and extended object cannot share shapes). This will enable us to implement ivar sets in YJIT using object shapes. Co-Authored-By: Aaron Patterson <[email protected]> Notes: Merged: https://.com/ruby/ruby/pull/6699 |
| In order to reliably test compaction we need to be able to move objects between size pools. In order for this to happen there must be pages in a size pool into which we can allocate. The existing implementation of `double_heap` only doubled the existing number of pages in the heap, so if a size pool had a low number of pages (or 0) it's not guaranteed that enough space will be created to move objects into that size pool. This commit deprecates the `double_heap` option and replaces it with `expand_heap` instead. expand heap will expand each heap by enough pages to hold a number of slots defined by `GC_HEAP_INIT_SLOTS` or by `heap->total_pags` whichever is larger. If both `double_heap` and `expand_heap` are present, a deprecation warning will be shown for `double_heap` and the `expand_heap` behaviour will take precedence Given that this is an API intended for debugging and testing GC compaction I'm not concerned about the extra memory usage or time taken to create the pages. However, for completeness: Running the following `test.rb` and using `time` on my Macbook Pro shows the following memory usage and time impact: pp "RSS (kb): #{`ps -o rss #{Process.pid}`.lines.last.to_i}" GC.verify_compaction_references(double_heap: true, toward: :empty) pp "RSS (kb): #{`ps -o rss #{Process.pid}`.lines.last.to_i}" ❯ time make run ./miniruby -I./lib -I. -I.ext/common -r./arm64-darwin21-fake ./test.rb "RSS (kb): 24000" <internal:gc>:251: warning: double_heap is deprecated and will be removed "RSS (kb): 25232" ________________________________________________________ Executed in 124.37 millis fish external usr time 82.22 millis 0.09 millis 82.12 millis sys time 28.76 millis 2.61 millis 26.15 millis ❯ time make run ./miniruby -I./lib -I. -I.ext/common -r./arm64-darwin21-fake ./test.rb "RSS (kb): 24000" "RSS (kb): 49040" ________________________________________________________ Executed in 150.13 millis fish external usr time 103.32 millis 0.10 millis 103.22 millis sys time 35.73 millis 2.59 millis 33.14 millis Notes: Merged: https://.com/ruby/ruby/pull/6107 |
| Define `GC.verify_compaction_references` as a built-in ruby method, according to GC compaction support via `GC::OPTS`. Notes: Merged: https://.com/ruby/ruby/pull/5972 |
| These methods are removed from gc.rb and added to gc.c: - GC.compact - GC.auto_compact - GC.auto_compact= - GC.latest_compact_info - GC.verify_compaction_references This is a prefactor to allow setting these methods to `rb_f_notimplement` in a followup commit. Notes: Merged: https://.com/ruby/ruby/pull/5934 |
| GC.stat_heap will return stats for memory heaps. This is used for the Variable Width Allocation feature. Notes: Merged: https://.com/ruby/ruby/pull/5177 |
| Adds documentation for keys `time`, `compact_count`, `read_barrier_faults`, `total_moved_objects`. Notes: Merged: https://.com/ruby/ruby/pull/5375 |
| Notes: Merged: https://.com/ruby/ruby/pull/5306 |
| Notes: Merged: https://.com/ruby/ruby/pull/5189 |
| This reverts commit 6157619bb68e4307cdf065cb73d5bfcec30d042d. We'll wait for comments in the open ticket: https://bugs.ruby-lang.org/issues/18364 Notes: Merged: https://.com/ruby/ruby/pull/5176 |
| GC.stat_size_pool will return stats for a particular size pool. This is used for the Variable Width Allocation feature. Notes: Merged: https://.com/ruby/ruby/pull/5169 |
| @nobu pointed out that ULL (unsigned long long) should have at least 64 bits so ULL2NUM(uint64_t) is not problem. Notes: Merged: https://.com/ruby/ruby/pull/4757 |
| * `GC.measure_total_time = true` enables total time measurement (default: true) * `GC.measure_total_time` returns current flag. * `GC.total_time` returns measured total time in nano seconds. * `GC.stat(:time)` (and Hash) returns measured total time in milli seconds. Notes: Merged: https://.com/ruby/ruby/pull/4757 |
| This commit adds support for embedded strings with variable capacity and uses Variable Width Allocation to allocate strings. Notes: Merged: https://.com/ruby/ruby/pull/4933 |
| Notes: Merged-By: peterzhu2118 <[email protected]> |
| [Misc #16443][ruby-core:96395] |
| Both explicit compaction routines (gc_compact and the verify references form) need to clear the heap before executing compaction. Otherwise some objects may not be alive, and we'll need the read barrier. The heap must only contain *live* objects if we want to disable the read barrier during explicit compaction. The previous commit was missing the "clear the heap" phase from the "verify references" explicit compaction function. Fixes [Bug #17306] |
| This reverts commit 63ad55cd882e4010fe313d271af006a430b5ffa8. Revert "Disable read barrier on explicit compaction request" This reverts commit 490b57783d80f0c5f7882c66d9fb6aa02713c9a5. |
| We don't need a read barrier when the user calls `GC.compact` because we don't allow allocations during GC, and all references should be "live" Notes: Merged: https://.com/ruby/ruby/pull/3809 |
| Combine everything in to one C function |
| * `GC.auto_compact=`, `GC.auto_compact` can be used to control when compaction runs. Setting `auto_compact=` to true will cause compaction to occurr duing major collections. At the moment, compaction adds significant overhead to major collections, so please test first! [Feature #17176] |
| Notes: Merged: https://.com/ruby/ruby/pull/3165 |
| Notes: Merged: https://.com/ruby/ruby/pull/3165 |
