[#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:111198] [Ruby master Bug#19165] Method (with no param) delegation with *, **, and ... is slow
From:
"shugo (Shugo Maeda)" <noreply@...>
Date:
2022-12-04 07:14:30 UTC
List:
ruby-core #111198
Issue #19165 has been updated by shugo (Shugo Maeda).
It seems that `...` is faster without [Feature #19134]:
```
simple call 13.250M (=B1 2.0%) i/s - 66.792M in 5.043180s
delegate without splat
12.523M (=B1 1.3%) i/s - 62.863M in 5.020866s
delegate with splat 6.231M (=B1 1.8%) i/s - 31.452M in 5.049532s
delegate with splat with name
6.152M (=B1 3.3%) i/s - 30.958M in 5.038120s
delegate with splat and double splat
2.187M (=B1 2.0%) i/s - 10.981M in 5.024101s
delegate with triple dots
5.976M (=B1 1.6%) i/s - 30.120M in 5.041456s
delegate via forwardable
5.072M (=B1 1.4%) i/s - 25.818M in 5.091690s
```
`args =3D arg_append(p, args, new_hash(p, kwrest, loc), loc);` in the follo=
wing code seems to be slow.
```
static NODE *
new_args_forward_call(struct parser_params *p, NODE *leading, const YYLTYPE=
*loc, const YYLTYPE *argsloc)
{
NODE *rest =3D NEW_LVAR(idFWD_REST, loc);
NODE *kwrest =3D list_append(p, NEW_LIST(0, loc), NEW_LVAR(idFWD_KWREST=
, loc));
NODE *block =3D NEW_BLOCK_PASS(NEW_LVAR(idFWD_BLOCK, loc), loc);
NODE *args =3D leading ? rest_arg_append(p, leading, rest, loc) : NEW_S=
PLAT(rest, loc);
args =3D arg_append(p, args, new_hash(p, kwrest, loc), loc);
return arg_blk_pass(args, block);
}
```
Should we revert [Feature #19134]?
----------------------------------------
Bug #19165: Method (with no param) delegation with *, **, and ... is slow
https://bugs.ruby-lang.org/issues/19165#change-100481
* 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/