- ### TL;DR Bundler is heavily limited by the connection pool which manages a single connection. By increasing the number of connection, we can drastiscally speed up the installation process when many gems need to be downloaded and installed. ### Benchmark There are various factors that are hard to control such as compilation time and network speed but after dozens of tests I can consistently get aroud 70% speed increase when downloading and installing 472 gems, most having no native extensions (on purpose). ``` # Before bundle install 28.60s user 12.70s system 179% cpu 23.014 total # After bundle install 30.09s user 15.90s system 281% cpu 16.317 total ``` You can find on this gist how this was benchmarked and the Gemfile used https://gist.github.com/Edouard-chin/c8e39148c0cdf324dae827716fbe24a0 ### Context A while ago in #869, Aaron introduced a connection pool which greatly improved Bundler speed. It was noted in the PR description that managing one connection was already good enough and it wasn't clear whether we needed more connections. Aaron also had the intuition that we may need to increase the pool for downloading gems and he was right. > We need to study how RubyGems uses connections and make a decision > based on request usage (e.g. only use one connection for many small > requests like bundler API, and maybe many connections for > downloading gems) When bundler downloads and installs gem in parallel4f85e02fdd/bundler/lib/bundler/installer/parallel_installer.rb (L128)most threads have to wait for the only connection in the pool to be available which is not efficient. ### Solution This commit modifies the pool size for the fetcher that Bundler uses. RubyGems fetcher will continue to use a single connection. The bundler fetcher is used in 2 places. 1. When downloading gems4f85e02fdd/bundler/lib/bundler/source/rubygems.rb (L481-L484)2. When grabing the index (not the compact index) using the `bundle install --full-index` flag.4f85e02fdd/bundler/lib/bundler/fetcher/index.rb (L9)Having more connections in 2) is not any useful but tweaking the size based on where the fetcher is used is a bit tricky so I opted to modify it at the class level. I fiddle with the pool size and found that 5 seems to be the sweet spot at least for my environment. https://github.com/ruby/rubygems/commit/6063fd9963
spec/bundler
spec/bundler is rspec examples for bundler library (lib/bundler.rb, lib/bundler/*).
Running spec/bundler
To run rspec for bundler:
make test-bundler
or run rspec with parallel execution:
make test-bundler-parallel
If you specify BUNDLER_SPECS=foo/bar_spec.rb then only spec/bundler/foo/bar_spec.rb will be run.
spec/ruby
ruby/spec (https://github.com/ruby/spec/) is a test suite for the Ruby language.
Once a month, @eregon merges the in-tree copy under spec/ruby with the upstream repository, preserving the commits and history. The same happens for other implementations such as JRuby and TruffleRuby.
Feel welcome to modify the in-tree spec/ruby. This is the purpose of the in-tree copy, to facilitate contributions to ruby/spec for MRI developers.
New features, additional tests for existing features and
regressions tests are all welcome in ruby/spec.
There is very little behavior that is implementation-specific,
as in the end user programs tend to rely on every behavior MRI exhibits.
In other words: If adding a spec might reveal a bug in
another implementation, then it is worth adding it.
Currently, the only module which is MRI-specific is RubyVM.
Changing behavior and versions guards
Version guards (ruby_version_is) must be added for new features or features
which change behavior or are removed. This is necessary for other Ruby implementations
to still be able to run the specs and contribute new specs.
For example, change:
describe "Some spec" do
it "some example" do
# Old behavior for Ruby < 2.7
end
end
to:
describe "Some spec" do
ruby_version_is ""..."2.7" do
it "some example" do
# Old behavior for Ruby < 2.7
end
end
ruby_version_is "2.7" do
it "some example" do
# New behavior for Ruby >= 2.7
end
end
end
See spec/ruby/CONTRIBUTING.md for more documentation about guards.
To verify specs are compatible with older Ruby versions:
cd spec/ruby
$RUBY_MANAGER use 2.4.9
../mspec/bin/mspec -j
Running ruby/spec
To run all specs:
make test-spec
Extra arguments can be added via SPECOPTS.
For instance, to show the help:
make test-spec SPECOPTS=-h
You can also run the specs in parallel, which is currently experimental. It takes around 10s instead of 60s on a quad-core laptop.
make test-spec SPECOPTS=-j
To run a specific test, add its path to the command:
make test-spec SPECOPTS=spec/ruby/language/for_spec.rb
If ruby trunk is your current ruby in $PATH, you can also run mspec directly:
# change ruby to trunk
ruby -v # => trunk
spec/mspec/bin/mspec spec/ruby/language/for_spec.rb
ruby/spec and test/
The main difference between a "spec" under spec/ruby/ and
a test under test/ is that specs are documenting what they test.
This is extremely valuable when reading these tests, as it
helps to quickly understand what specific behavior is tested,
and how a method should behave. Basic English is fine for spec descriptions.
Specs also tend to have few expectations (assertions) per spec,
as they specify one aspect of the behavior and not everything at once.
Beyond that, the syntax is slightly different but it does the same thing:
assert_equal 3, 1+2 is just (1+2).should == 3.
Example:
describe "The for expression" do
it "iterates over an Enumerable passing each element to the block" do
j = 0
for i in 1..3
j += i
end
j.should == 6
end
end
For more details, see spec/ruby/CONTRIBUTING.md.
spec/syntax_suggest
Running spec/syntax_suggest
To run rspec for syntax_suggest:
make test-syntax-suggest
If you specify SYNTAX_SUGGEST_SPECS=foo/bar_spec.rb then only spec/syntax_suggest/foo/bar_spec.rb will be run.