[#111472] [Ruby master Bug#19274] Error installing ruby 3.2.0 on RH 8 — "aalllop (Alberto Allegue) via ruby-core" <ruby-core@...>
Issue #19274 has been reported by aalllop (Alberto Allegue).
5 messages
2022/12/28
[#111508] Data support for versions before 3.2.0 — Eustáquio Rangel via ruby-core <ruby-core@...>
I was wondering that every piece of code (gems, etc) that use the new Data =
3 messages
2022/12/29
[ruby-core:111124] [Ruby master Bug#19165] Method (with no param) delegation with *, **, and ... is slow
From:
"matsuda (Akira Matsuda)" <noreply@...>
Date:
2022-12-01 08:55:59 UTC
List:
ruby-core #111124
Issue #19165 has been updated by matsuda (Akira Matsuda).
FYI for confirming "five Array objects and two Hash objects" that I wrote a=
bove, I used ko1's allocation_tracer as follows:
```
require 'allocation_tracer'
ObjectSpace::AllocationTracer.setup([:type])
o.foo_with_triple_dots
pp ObjectSpace::AllocationTracer.trace {
o.foo_with_triple_dots
}
```
----------------------------------------
Bug #19165: Method (with no param) delegation with *, **, and ... is slow
https://bugs.ruby-lang.org/issues/19165#change-100398
* Author: matsuda (Akira Matsuda)
* Status: Open
* Priority: Normal
* ruby -v: ruby 3.2.0dev (2022-12-01T08:05:41Z master 4e68b59431) +YJIT [ar=
m64-darwin21]
* Backport: 2.7: UNKNOWN, 3.0: UNKNOWN, 3.1: UNKNOWN
----------------------------------------
I found that method delegation via Forwardable is much slower than normal m=
ethod call when delegating a method that does not take parameters.
Here's a benchmark that explains what I mean.
```
require 'forwardable'
require 'pp'
require 'benchmark/ips'
class Obj
extend Forwardable
attr_accessor :other
def initialize
@other =3D Other.new
end
def foo_without_splat
@other.foo
end
def foo_with_splat(*)
@other.foo(*)
end
def foo_with_splat_with_name(*args)
@other.foo(*args)
end
def foo_with_splat_and_double_splat(*, **)
@other.foo(*, **)
end
def foo_with_triple_dots(...)
@other.foo(...)
end
delegate :foo =3D> :@other
end
class Other
def foo() end
end
o =3D Obj.new
Benchmark.ips do |x|
x.report 'simple call' do
o.other.foo
end
x.report 'delegate without splat' do
o.foo_without_splat
end
x.report 'delegate with splat' do
o.foo_with_splat
end
x.report 'delegate with splat with name' do
o.foo_with_splat_with_name
end
x.report 'delegate with splat and double splat' do
o.foo_with_splat_and_double_splat
end
x.report 'delegate with triple dots' do
o.foo_with_triple_dots
end
x.report 'delegate via forwardable' do
o.foo
end
end
(result)
simple call 38.918M (=B1 0.9%) i/s - 194.884M
delegate without splat
31.933M (=B1 1.6%) i/s - 159.611M
delegate with splat 10.269M (=B1 1.6%) i/s - 51.631M
delegate with splat with name
9.888M (=B1 1.0%) i/s - 49.588M
delegate with splat and double splat
4.117M (=B1 0.9%) i/s - 20.696M
delegate with triple dots
4.169M (=B1 0.9%) i/s - 20.857M
delegate via forwardable
9.204M (=B1 2.1%) i/s - 46.295M
```
It shows that Method delegation with a splat is 3-4 times slower (regardles=
s of whether the parameter is named or not), and delegation with a triple-d=
ot literal is 9-10 times slower than a method delegation without an argumen=
t.
This may be because calling a method taking a splat always assigns an Array=
object even when no actual argument was given, and calling a method taking=
triple-dots assigns five Array objects and two Hash objects (this is equiv=
alent to `*, **`).
Are there any chance reducing these object assignments and making them fast=
er? My concern is that the Rails framework heavily uses this kind of method=
delegations, and presumably it causes unignorable performance overhead.
--=20
https://bugs.ruby-lang.org/
______________________________________________
ruby-core mailing list -- [email protected]
To unsubscribe send an email to [email protected]
ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-c=
ore.ml.ruby-lang.org/
