Performance

[latot]

Hi hi, I'm looking this great project, and I think would be great in the docs, add a section about performance, because actually, even with this great features, I have the question, Box vs Packages in performace...., for larger projects, for small projects. For this type of projects, even loose performance in some extent is acceptable to get scalability, the point is, how much, in any case, every project have its own need, so, in some cases will be acceptable, and in others not.

Is there any tests for this?

Thx.

[klmr]

You’re absolutely right! For version 1.0 of ‘box’, the answer was “it is fast enough”. But this was never intended to be the final answer, and performance is on my radar. I haven’t yet run any general benchmarks but I’m aware of two points in which ‘box’ modules potentially lag behind R packages:

• Modules aren’t currently installed, and loading modules re-parses their source code rather than a compact binary representation (Keep secondary storage cache of installed modules #264).
  • However, during an R session module loading is cached: only the first box::use actually hits the disk. Subsequent loads use the version already in memory. So using box::use inside a loop doesn’t have a large overhead.
• Modules are not currently byte-compiled (Byte-compile modules #14).

On the flip side:

• Loading packages with box::use should be virtually as fast as using library, because most of the code is shared. The only difference is that box::use performs more argument parsing to figure out the attach list etc. It would be a good idea to benchmark this.
• Accessing names of loaded module or package objects via mod$name is already implemented in native code, and has been benchmarked against alternative candidate implementations. It’s probably as fast as I can reasonably make it, and should be roughly on par with conventional package access via :: (Improve error message for undefined module exports #180) — but it’s still worth having an explicit comparative benchmark.

For now, in the absence of comprehensive benchmarks, this is the takeaway:

1. Packages
   1. Loading packages via box::use should be similar (or identical) to loading via library
   2. Accessing names from loaded packages has identical performance for attached names, and should have performance that’s identical or very close when using $ vs ::
2. Modules
   1. Loading modules is probably going to be a bit slower than loading packages, since they are loaded from source rather than having the compact disk representation used by installed R packages
   2. Accessing loaded modules might also be slower since they’re not byte-compiled

Hopefully I’ll find time to produce actual benchmarks to be included in the documentation soon!