[ruby-core:114827] [Ruby master Bug#19890] File#realine(chomp: true) slower/more allocations than readline.chomp!

Issue #19890 has been updated by Eregon (Benoit Daloze).





@Dan0042 There is a significant performance cost to deal with special varia=
bles in n callers like this.

I think it should remain an internal thing only and not be exposed via that=
 forward flag, as that would slow down such calls significantly and cause e=
xtra allocations (at least on some Ruby implementations), and prevent furth=
er optimizations.



TruffleRuby uses a way to propagate special variables from the caller to th=
e current method, that way things like String#gsub can be implemented in Ru=
by using Regexp#match internally.

That's much more reasonable performance-wise because this only happens expl=
icitly and only for a small numbers of methods.



----------------------------------------

Bug #19890: File#realine(chomp: true) slower/more allocations than readline=
.chomp!

https://bugs.ruby-lang.org/issues/19890#change-104670



* Author: segiddins (Samuel Giddins)

* Status: Open

* Priority: Normal

* ruby -v: 3.2.2

* Backport: 3.0: UNKNOWN, 3.1: UNKNOWN, 3.2: UNKNOWN

----------------------------------------

On ruby 3.2.2 running the following script:



``` ruby

#!/usr/bin/env ruby



require 'rubygems'

require 'bundler/inline'



puts RUBY_VERSION



gemfile do

  source "https://rubygems.org"

  gem "benchmark-ipsa"

end



Benchmark.ipsa do |x|

  x.report("f.readline(chomp: true)") do

    File.open("/usr/share/dict/words") do |f|

      f.readline(chomp: true) until f.eof?

    end

  end

 =20

  x.report("f.readline.chomp!") do

    File.open("/usr/share/dict/words") do |f|

      until f.eof?

        s =3D f.readline

        s.chomp!

        s

      end

    end

  end

 =20

  x.report("f.readline.chomp") do

    File.open("/usr/share/dict/words") do |f|

      until f.eof?

        f.readline.chomp

      end

    end

  end

 =20

  x.compare!

end

```



I get the following (surprising) result:



```

3.2.2

Allocations -------------------------------------

	f.readline(chomp: true)

                      707931/1  alloc/ret       50/1  strings/ret

   f.readline.chomp!  235979/1  alloc/ret       50/1  strings/ret

    f.readline.chomp  471955/1  alloc/ret       50/1  strings/ret

Warming up --------------------------------------

f.readline(chomp: true)

                         1.000  i/100ms

   f.readline.chomp!     2.000  i/100ms

    f.readline.chomp     2.000  i/100ms

Calculating -------------------------------------

f.readline(chomp: true)

                         16.165  (=B1 6.2%) i/s -     81.000=20

   f.readline.chomp!     25.246  (=B1 7.9%) i/s -    126.000=20

    f.readline.chomp     20.997  (=B1 9.5%) i/s -    106.000=20



Comparison:

   f.readline.chomp!:       25.2 i/s

    f.readline.chomp:       21.0 i/s - 1.20x slower

f.readline(chomp: true):       16.2 i/s - 1.56x slower

```



I would expect `File#readline(chomp: true)` to be comparable to `s =3D f.re=
adline; s.chomp!; s` at a bare minimum, but it is slower and has more alloc=
ations even than `readline.chomp`









--=20

https://bugs.ruby-lang.org/

 ______________________________________________
 ruby-core mailing list -- [e-mail]
 To unsubscribe send an email to [e-mail]
 ruby-core info -- https://ml.ruby-lang.org/mailman3/postorius/lists/ruby-c=
ore.ml.ruby-lang.org/