Issue #20462 has been updated by maciej.mensfeld (Maciej Mensfeld). Not sure if related but here's a benchmark of the impact (written by Gordon Chan): ```ruby #!/usr/bin/env ruby # Disable GC during the benchmark GC.disable # Get the current memory usage mem_before = GC.stat[:malloc_increase_bytes] obj_before = GC.stat[:total_allocated_objects] # Perform the operation you want to benchmark result = 100_000.times { Thread.new{}.join } # Get the new memory usage and object count mem_after = GC.stat[:malloc_increase_bytes] obj_after = GC.stat[:total_allocated_objects] # Re-enable GC GC.enable GC.stress sleep(5) # Calculate the memory and object allocation deltas mem_delta = mem_after - mem_before obj_delta = obj_after - obj_before puts "Memory allocated: #{mem_delta} bytes" puts "Objects allocated: #{obj_delta}" ``` and the difference: ``` # 3.1.3 Memory allocated: 46402080 bytes Objects allocated: 700009 # 3.2.3 Memory allocated: 49603216 bytes Objects allocated: 700009 # 3.3.3 Memory allocated: 104926404048 bytes Objects allocated: 700010 ``` 3.1 and 3.2 are consistent, while 3.3 is as you can see above (2000x). ---------------------------------------- Bug #20462: Native threads are no longer reused https://bugs.ruby-lang.org/issues/20462#change-108857 * Author: tenderlovemaking (Aaron Patterson) * Status: Open * Backport: 3.1: DONTNEED, 3.2: DONTNEED, 3.3: UNKNOWN ---------------------------------------- Ruby used to reuse native threads in order to amortize the cost of making a pthread. For example this program: ```ruby ntids = 1000.times.map { Thread.new { Thread.current.native_thread_id }.value } p ntids.uniq.length ``` With Ruby 3.2.0, this would return 1. With Ruby 3.3.x, it returns 1000. It means we cannot amortize the cost of a pthread for short lived threads. I was able to bisect this to commit be1bbd5b7d40ad863ab35097765d3754726bbd54. But the change is big so I don't know how to fix it. -- https://bugs.ruby-lang.org/