summaryrefslogtreecommitdiff
path: root/gc.c
AgeCommit message (Collapse)Author
2020-11-26Run rb_print_backtrace first on ruby_on_ciTakashi Kokubun
Unfortunately we couldn't see a C backtrace with the previous commit http://ci.rvm.jp/results/trunk-random2@phosphorus-docker/3272697.
2020-11-26Call rb_bug_without_die on CITakashi Kokubun
when GC.compact's SEGV handler is installed
2020-11-25Disable auto compaction on platforms that can't support itAaron Patterson
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]
2020-11-24Revert "Disable auto compaction on platforms that can't support it"Aaron Patterson
This reverts commit 63ad55cd882e4010fe313d271af006a430b5ffa8. Revert "Disable read barrier on explicit compaction request" This reverts commit 490b57783d80f0c5f7882c66d9fb6aa02713c9a5.
2020-11-24Disable auto compaction on platforms that can't support itAaron Patterson
Auto Compaction uses mprotect to implement a read barrier. mprotect can only work on regions of memory that are a multiple of the OS page size. Ruby's pages are a multiple of 4kb, but some platforms (like ppc64le) don't have 4kb page sizes. This commit disables the features on those platforms. Fixes [Bug #17306]
2020-11-24add HEAP_PAGE_SIZE to internal constantsAaron Patterson
2020-11-24Disable read barrier on explicit compaction requestAaron Patterson
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://github.com/ruby/ruby/pull/3809
2020-11-18fix public interfaceKoichi Sasada
To make some kind of Ractor related extensions, some functions should be exposed. * include/ruby/thread_native.h * rb_native_mutex_* * rb_native_cond_* * include/ruby/ractor.h * RB_OBJ_SHAREABLE_P(obj) * rb_ractor_shareable_p(obj) * rb_ractor_std*() * rb_cRactor and rm ractor_pub.h and rename srcdir/ractor.h to srcdir/ractor_core.h (to avoid conflict with include/ruby/ractor.h) Notes: Merged: https://github.com/ruby/ruby/pull/3775
2020-11-05gc_rest can change the total pages, so we need to do that firstAaron Patterson
2020-11-05add asserts to find crashAaron Patterson
2020-11-05Refactor verification methodAaron Patterson
Combine everything in to one C function
2020-11-05take VM lock when mutating the heapAaron Patterson
2020-11-04ensure T_OBJECT objects have internals initializedAaron Patterson
Notes: Merged: https://github.com/ruby/ruby/pull/3734
2020-11-02Add `GC.auto_compact= true/false` and `GC.auto_compact`Aaron Patterson
* `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]
2020-11-02suppport Ractor.send(move: true) for more detaKoichi Sasada
This patch allows to move more data types. Notes: Merged: https://github.com/ruby/ruby/pull/3727
2020-10-28Objects are born embedded, so we don't need to check ivprAaron Patterson
It's not necessary to check ivpt because objects are allocated as "embedded" by default
2020-10-28Remove another unnecessary testAaron Patterson
Same as 5be42c1ef4f7ed0a8004cad750a9ce61869bd768
2020-10-28Remove unnecessary conditionalAaron Patterson
As of 0b81a484f3453082d28a48968a063fd907daa5b5, `ROBJECT_IVPTR` will always return a value, so we don't need to test whether or not we got one. T_OBJECTs always come to life as embedded objects, so they will return an ivptr, and when they become "unembedded" they will have an ivptr at that point too
2020-10-28If an object isn't embedded it will have an ivptrAaron Patterson
We don't need to check the existence if an ivptr because non-embedded objects will always have one
2020-10-22Use a lock level for a less granular lock.Aaron Patterson
We are seeing an error where code that is generated with MJIT contains references to objects that have been moved. I believe this is due to a race condition in the compaction function. `gc_compact` has two steps: 1. Run a full GC to pin objects 2. Compact / update references Step one is executed with `garbage_collect`. `garbage_collect` calls `gc_enter` / `gc_exit`, these functions acquire a JIT lock and release a JIT lock. So a lock is held for the duration of step 1. Step two is executed by `gc_compact_after_gc`. It also holds a JIT lock. I believe the problem is that the JIT is free to execute between step 1 and step 2. It copies call cache values, but doesn't pin them when it copies them. So the compactor thinks it's OK to move the call cache even though it is not safe. We need to hold a lock for the duration of `garbage_collect` *and* `gc_compact_after_gc`. This patch introduces a lock level which increments and decrements. The compaction function can increment and decrement the lock level and prevent MJIT from executing during both steps. Notes: Merged: https://github.com/ruby/ruby/pull/3683
2020-10-21Ractor-safe rb_objspace_reachable_objects_fromKoichi Sasada
rb_objspace_reachable_objects_from(obj) is used to traverse all reachable objects from obj. This function modify objspace but it is not ractor-safe (thread-safe). This patch fix the problem. Strategy: (1) call GC mark process during_gc (2) call Ractor-local custom mark func when !during_gc Notes: Merged: https://github.com/ruby/ruby/pull/3680
2020-10-20ObjectSpace.each_object with RactorsKoichi Sasada
Unshareable objects should not be touched from multiple ractors so ObjectSpace.each_object should be restricted. On multi-ractor mode, ObjectSpace.each_object only iterates shareable objects. [Feature #17270] Notes: Merged: https://github.com/ruby/ruby/pull/3672
2020-10-17sync RClass::ext::iv_index_tblKoichi Sasada
iv_index_tbl manages instance variable indexes (ID -> index). This data structure should be synchronized with other ractors so introduce some VM locks. This patch also introduced atomic ivar cache used by set/getinlinecache instructions. To make updating ivar cache (IVC), we changed iv_index_tbl data structure to manage (ID -> entry) and an entry points serial and index. IVC points to this entry so that cache update becomes atomically. Notes: Merged: https://github.com/ruby/ruby/pull/3662
2020-10-03add NULL check.Koichi Sasada
DATA_PTR(ractor) can be NULL just after creation.
2020-09-28Fix ASAN and don't check SPECIAL_CONST_PAaron Patterson
Heap allocated objects are never special constants. Since we're walking the heap, we know none of these objects can be special. Also, adding the object to the freelist will poison the object, so we can't check that the type is T_NONE after poison.
2020-09-28Fix ASAN errors when updating call cacheAaron Patterson
Invalidating call cache walks the heap, so we need to take care to un-poison objects when examining them
2020-09-24sync rb_gc_register_mark_object()Koichi Sasada
rb_vm_t::mark_object_ary is global resource so we need to synchronize to access it.
2020-09-22Add a comment about why we're checking the finalizer tableAaron Patterson
2020-09-22Revert "Pin values in the finalizer table"Aaron Patterson
If an object has a finalizer flag set on it, prevent it from moving. This partially reverts commit 1a9dd31910699c7cd69f2a84c94af20eacd5875c.
2020-09-20Update heap_pages_himem after freeing pagesPeter Zhu
Notes: Merged: https://github.com/ruby/ruby/pull/3461
2020-09-19strip trailing spaces [ci skip]Nobuyoshi Nakada
2020-09-18Pin values in the finalizer tableAaron Patterson
When finalizers run (in `rb_objspace_call_finalizer`) the table is copied to a linked list that is not managed by the GC. If compaction runs, the references in the linked list can go bad. Finalizer table shouldn't be used frequently, so lets pin references in the table so that the linked list in `rb_objspace_call_finalizer` is safe. Notes: Merged: https://github.com/ruby/ruby/pull/3556
2020-09-18rb_obj_info() shows more info for T_SYMBOLKoichi Sasada
Notes: Merged: https://github.com/ruby/ruby/pull/3548
2020-09-16Warn on a finalizer that captures the object to be finalizedChris Seaton
Also improve specs and documentation for finalizers and more clearly recommend a safe code pattern to use them. Notes: Merged: https://github.com/ruby/ruby/pull/3444
2020-09-15pointers on the stack need to be pinnedAaron Patterson
Notes: Merged: https://github.com/ruby/ruby/pull/3544
2020-09-15Fix incorrect initialization of `rb_io_t::self`.Samuel Williams
Notes: Merged: https://github.com/ruby/ruby/pull/3542
2020-09-04Fixed heap-use-after-free on racterNobuyoshi Nakada
2020-09-03Avoid potential for rb_raise() while crashingAlan Wu
rb_obj_raw_info is called while printing out crash messages and sometimes called during garbage collection. Calling rb_raise() in these situations is undesirable because it can start executing ensure blocks. Notes: Merged: https://github.com/ruby/ruby/pull/3512
2020-09-03Introduce Ractor mechanism for parallel executionKoichi Sasada
This commit introduces Ractor mechanism to run Ruby program in parallel. See doc/ractor.md for more details about Ractor. See ticket [Feature #17100] to see the implementation details and discussions. [Feature #17100] This commit does not complete the implementation. You can find many bugs on using Ractor. Also the specification will be changed so that this feature is experimental. You will see a warning when you make the first Ractor with `Ractor.new`. I hope this feature can help programmers from thread-safety issues. Notes: Merged: https://github.com/ruby/ruby/pull/3365
2020-09-02Initialize new T_OBJECT as ROBJECT_EMBEDJohn Hawthorn
Previously, when an object is first initialized, ROBJECT_EMBED isn't set. This means that for brand new objects, ROBJECT_NUMIV(obj) is 0 and ROBJECT_IV_INDEX_TBL(obj) is NULL. Previously, this combination meant that the inline cache would never be initialized when setting an ivar on an object for the first time since iv_index_tbl was NULL, and if it were it would never be used because ROBJECT_NUMIV was 0. Both cases always fell through to the generic rb_ivar_set which would then set the ROBJECT_EMBED flag and initialize the ivar array. This commit changes rb_class_allocate_instance to set the ROBJECT_EMBED flag on the object initially and to initialize all members of the embedded array to Qundef. This allows the inline cache to be set correctly on first use and to be used on future uses. This moves rb_class_allocate_instance to gc.c, so that it has access to newobj_of. This seems appropriate given that there are other allocating methods in this file (ex. rb_data_object_wrap, rb_imemo_new). Notes: Merged: https://github.com/ruby/ruby/pull/3486
2020-09-01Fix error message for wb unprotected objects countPeter Zhu
This error is about wb unprotected objects, not old objects. Notes: Merged: https://github.com/ruby/ruby/pull/3463
2020-09-02Fixed argument typesNobuyoshi Nakada
2020-09-02Format with proper conversion specifiers instead of castsNobuyoshi Nakada
2020-09-01Use RSTRING_LENINT for overflow checkNobuyoshi Nakada
2020-09-01Don't read past the end of the Ruby stringPeter Zhu
Ruby strings don't always have a null terminator, so we can't use it as a regular C string. By reading only the first len bytes of the Ruby string, we won't read past the end of the Ruby string. Notes: Merged: https://github.com/ruby/ruby/pull/3487 Merged-By: nobu <nobu@ruby-lang.org>
2020-08-27include/ruby/backward/2/r_cast.h: deprecate卜部昌平
Remove all usages of RCAST() so that the header file can be excluded from ruby/ruby.h's dependency. Notes: Merged: https://github.com/ruby/ruby/pull/3346
2020-08-25Correctly account for heap_pages_final_slots so it does not underflowPeter Zhu
`rb_objspace_call_finalizer` creates zombies, but does not do the correct accounting (it should increment `heap_pages_final_slots` whenever it creates a zombie). When we do correct accounting, `heap_pages_final_slots` should never underflow (the check for underflow was introduced in 39725a4db6b121c7779b2b34f7da9d9339415a1c). The implementation moves the accounting from the functions that call `make_zombie` into `make_zombie` itself, which reduces code duplication. Notes: Merged: https://github.com/ruby/ruby/pull/3450
2020-08-17Remove write barrier exemption for T_ICLASSAlan Wu
Before this commit, iclasses were "shady", or not protected by write barriers. Because of that, the GC needs to spend more time marking these objects than otherwise. Applications that make heavy use of modules should see reduction in GC time as they have a significant number of live iclasses on the heap. - Put logic for iclass method table ownership into a function - Remove calls to WB_UNPROTECT and insert write barriers for iclasses This commit relies on the following invariant: for any non oirigin iclass `I`, `RCLASS_M_TBL(I) == RCLASS_M_TBL(RBasic(I)->klass)`. This invariant did not hold prior to 98286e9 for classes and modules that have prepended modules. [Feature #16984] Notes: Merged: https://github.com/ruby/ruby/pull/3410
2020-08-14Enable arm64 optimizations that exist for power/x86 (#3393)AGSaidi
* Enable unaligned accesses on arm64 64-bit Arm platforms support unaligned accesses. Running the string benchmarks this change improves performance by an average of 1.04x, min .96x, max 1.21x, median 1.01x * arm64 enable gc optimizations Similar to x86 and powerpc optimizations. | |compare-ruby|built-ruby| |:------|-----------:|---------:| |hash1 | 0.225| 0.237| | | -| 1.05x| |hash2 | 0.110| 0.110| | | 1.00x| -| * vm_exec.c: improve performance for arm64 | |compare-ruby|built-ruby| |:------------------------------|-----------:|---------:| |vm_array | 26.501M| 27.959M| | | -| 1.06x| |vm_attr_ivar | 21.606M| 31.429M| | | -| 1.45x| |vm_attr_ivar_set | 21.178M| 26.113M| | | -| 1.23x| |vm_backtrace | 6.621| 6.668| | | -| 1.01x| |vm_bigarray | 26.205M| 29.958M| | | -| 1.14x| |vm_bighash | 504.155k| 479.306k| | | 1.05x| -| |vm_block | 16.692M| 21.315M| | | -| 1.28x| |block_handler_type_iseq | 5.083| 7.004| | | -| 1.38x| Notes: Merged-By: nurse <naruse@airemix.jp>
2020-08-03Don't pin objects if we're just walking the heapAaron Patterson
Walking the heap can inadvertently pin objects. Only mark the object's pin bit if the mark_func_data pointer is NULL (similar to the mark bits) Notes: Merged: https://github.com/ruby/ruby/pull/3387
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-20 20:52:12 +0000