rcpp function [实际上不是] package 内部比外部慢很多

Question

I recently wrote a compute intense function in Rcpp. Now, I would like to port this code to an R package. However, I notice that the code is much (~100x) slower when run inside an R package.

I already read here , that this may have to do with how the function is called. However, this is not a one-time cost. Instead, it scaled with the number of iterations in the Rcpp function (only a single call to Rcpp is made).

Please find a minimally complete verifiable example below. The function below doesn't do anything useful but shows the behavior I am worried about.

How can I troubleshoot this issue?

Steps to recreate package.

• Use Rcpp.package.skeleton to create a new package skeleton with Rcpp.

• Add the following example.cpp file to \src .

  example.cpp

   #include <Rcpp.h> // [[Rcpp::export]] int example_cpp(Rcpp::IntegerMatrix mat, int iters) { for(int i = 0; i < iters; ++i) { std::vector<int> vec; std::iota(std::begin(vec), std::end(vec), 0); } return 0; }

• Add the following example.R file to \R .

  example.R

   # @export example <- function(mat, iters) { example_cpp(mat, iters) }

• Test the Rcpp function inside/outside the package using the following script.

   library(examplePackage) Rcpp::sourceCpp('src/example.cpp') exampleOutside <- function(mat, iters) { example_cpp(mat, iters) } set.seed(42) mat <- replicate(n=1000, sample(1:10)) for(iters in c(1e4, 1e5, 1e6)) { res <- microbenchmark::microbenchmark( example(mat, iters), exampleOutside(mat, iters), times=10 ) print(iters) print(res) }

Output.

[1] 10000
Unit: microseconds
                       expr     min      lq     mean  median      uq      max neval
        example(mat, iters) 629.550 630.977 696.1131 686.488 719.399  858.081    10
 exampleOutside(mat, iters)   3.143   4.203 239.7205   5.021   6.981 2340.719    10
[1] 1e+05
Unit: microseconds
                       expr      min       lq      mean    median       uq      max neval
        example(mat, iters) 6512.453 6625.420 6717.6595 6713.2375 6843.519 6921.158    10
 exampleOutside(mat, iters)    2.637    3.226    7.6473    4.1205   12.647   16.489    10
[1] 1e+06
Unit: microseconds
                       expr       min        lq       mean    median        uq       max neval
        example(mat, iters) 64091.144 66392.745 67491.8759 68001.405 68609.006 69028.736    10
 exampleOutside(mat, iters)     2.885     3.574    10.6664     4.792    17.653    35.927    10

Answer 1

Edit: See below for the full discussion. You are measuring noise as the functions are empty returning immediately. For a real problem I replace your function and it unused argument and data with a simple summation of the log of the loop value:

#include <Rcpp.h>

// [[Rcpp::export]]
double nontrivial(int iters) {
    double sum = 0;
    for (int i = 0; i < iters; ++i) {
        sum += log(i * 1.0);
    }
    return sum;
}

Running over 10 million elements the default one hundred takes just under five seconds, and post approaches are equally fast:

edd@rob:~/git/stackoverflow/74688018(master)$ Rscript nontrivial.R
     test replications elapsed relative
1  inside          100   4.743    1.000
2 outside          100   4.920    1.037
edd@rob:~/git/stackoverflow/74688018(master)$ 

Updated files are in the repo linked below. The original reply from yesterday follows.

---

Thanks for making the problem smaller. There are numerous problems here:

• you risk naming collission by calling the function you source the same as the one the package when you load the package, I would avoid that
• the matrix creations
  • nonsensical: what is replicate doing there
  • pointless: the matrix is not used in the code
• after I made some rearrangements I set up a simpler test (see below) and it made it pretty clear that neither function is doing anything as the compiler looked through your empty loop. You can return zero faster by just returning zero, what is happening here:

Simpler Test

Rcpp::sourceCpp("exampleOutside.cpp")

set.seed(42)
mat <- matrix(sample(1:10, 100, replace=TRUE), 10, 10)

rbenchmark::benchmark(examplePackage::example_cpp(mat, 10),
                      exampleOutside(mat, 10),
                      replications = 10)[,1:4]

Outcome

> rbenchmark::benchmark(examplePackage::example_cpp(mat, 10), 
+                       exampleOutside(mat, 10), replications = 10)[,1:4]
                                  test replications elapsed relative
2              exampleOutside(mat, 10)           10   0.001       NA
1 examplePackage::example_cpp(mat, 10)           10   0.000       NA
> 

Modified 'outside' function

#include <Rcpp.h>

// [[Rcpp::export]]
int exampleOutside(Rcpp::IntegerMatrix mat, int iters) {
  for(int i = 0; i < iters; ++i) {
    std::vector<int> vec;
    std::iota(std::begin(vec), std::end(vec), 0);
  }
  return 0;
}

Overall, this is a fairly good "teachable moment" about why minimal examples are recommended. You were chasing a mirage, and you didn't notice because you put up too many barriers for yourself to see that maybe your comparison setup was not quite right.

In short, "when something cannot be true" (as in 'massive difference between same function compiled two different ways') it often is not.

(And for reproducibility all my files are in this directory on github .)