为什么这段Rcpp代码比字节编译的R慢？

Question

正如问题标题所说，我想知道为什么使用compiler::cmpfun编译的字节码R代码比等效的Rcpp代码在以下数学函数中更快：

func1 <- function(alpha, tau, rho, phi) {
     abs((alpha + 1)^(tau) * phi - rho * (1- (1 + alpha)^(tau))/(1 - (1 + alpha)))
}

由于这是一个简单的数值运算，我本来期望 Rcpp (funcCpp 和 funcCpp2) 比字节编译的 R (func1c 和 func2c) 快得多，尤其是因为 R 需要更多的开销来存储 (1+alpha)**tau 或需要重新计算它。实际上，计算这个指数两次似乎比在 R 中分配内存 (func1c vs func2c) 更快，这似乎特别反直觉，因为 n 很大。我的另一个猜想是，也许 compiler::cmpfun 在发挥一些魔力，但我想知道是否确实如此。

所以，我真正想知道的两件事是：

1. 为什么 funcCpp 和 funcCpp2 比 func1c 和 func2c 慢？（Rcpp 比编译后的 R 函数慢）
2. 为什么 funcCpp 比 func2 慢？（Rcpp 代码比纯 R 慢）

顺便说一下，这是我的 C++ 和 R 版本数据。

user% g++ --version
Configured with: --prefix=/Library/Developer/CommandLineTools/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
Apple LLVM version 7.0.0 (clang-700.0.72)
Target: x86_64-apple-darwin14.3.0
Thread model: posix

user% R --version
R version 3.2.2 (2015-08-14) -- "Fire Safety"
Copyright (C) 2015 The R Foundation for Statistical Computing
Platform: x86_64-apple-darwin14.5.0 (64-bit)

以下是R和Rcpp代码：

library(Rcpp)
library(rbenchmark)

func1 <- function(alpha, tau, rho, phi) {
    abs((1 + alpha)^(tau) * phi - rho * (1- (1 + alpha)^(tau))/(1 - (1 + alpha)))
}

func2 <- function(alpha, tau, rho, phi) {
    pval <- (alpha + 1)^(tau)
    abs( pval * phi - rho * (1- pval)/(1 - (1 + alpha)))
}

func1c <- compiler::cmpfun(func1)
func2c <- compiler::cmpfun(func2)

func3c <- Rcpp::cppFunction('
    double funcCpp(double alpha, int tau, double rho, double phi) {
        double pow_val = std::exp(tau * std::log(alpha + 1.0));
        double pAg = rho/alpha;
        return std::abs(pow_val * (phi -  pAg) + pAg);
    }')

func4c <- Rcpp::cppFunction('
    double funcCpp2(double alpha, int tau, double rho, double phi) {
        double pow_val = pow(alpha + 1.0, tau) ;
        double pAg = rho/alpha;
        return std::abs(pow_val * (phi -  pAg) + pAg);
    }')

res <- benchmark(
           func1(0.01, 200, 100, 1000000),
           func1c(0.01, 200, 100, 1000000),
           func2(0.01, 200, 100, 1000000),
           func2c(0.01, 200, 100, 1000000),
           func3c(0.01, 200, 100, 1000000),
           func4c(0.01, 200, 100, 1000000),
           funcCpp(0.01, 200, 100, 1000000),
           funcCpp2(0.01, 200, 100, 1000000),
           replications = 100000,
           order='relative',
           columns=c("test", "replications", "elapsed", "relative"))

这是 rbenchmark 的输出结果:

                             test replications elapsed relative
   func1c(0.01, 200, 100, 1e+06)       100000   0.349    1.000
   func2c(0.01, 200, 100, 1e+06)       100000   0.372    1.066
 funcCpp2(0.01, 200, 100, 1e+06)       100000   0.483    1.384
   func4c(0.01, 200, 100, 1e+06)       100000   0.509    1.458
    func2(0.01, 200, 100, 1e+06)       100000   0.510    1.461
  funcCpp(0.01, 200, 100, 1e+06)       100000   0.524    1.501
   func3c(0.01, 200, 100, 1e+06)       100000   0.546    1.564
    func1(0.01, 200, 100, 1e+06)       100000   0.549    1.573K

- lostinarandomforest

---

“func1c”比“func2c”更快，可能是由于垃圾回收器或其他难以确定的原因。多次运行你的“benchmark”调用，你会看到这两个函数在排名中交换位置。尝试测量只需要1微秒运行时间的东西是非常困难的。 - Joshua Ulrich

“C函数比C++函数快，这真的那么令人惊讶吗？”——是的，绝对是。没有理由期望这种情况。事实上，C++代码通常可以被制作得比相同抽象级别的C代码更快，并且永远不应该更慢。这里有更多信息：http://programmers.stackexchange.com/a/29136/2366 - Konrad Rudolph

@bunk 对，它们都是“十二”。无论哪种方式都不应该有任何区别。当然，Rcpp所产生的“魔力”可能会带来开销 —— 但是这里甚至调用了UN/PROTECT吗？我对R的C API了解甚少，但既然这些都是参数，就不需要进行保护，是吗？ - Konrad Rudolph

@bunk：只有在你仍在使用对象时垃圾回收器可能运行时，才需要使用PROTECT。请参见《编写R扩展》第5.9.1节。 - Joshua Ulrich

@bunk：我只是在提到你的函数，你只调用了一次allocVector。你不需要res变量，因为你可以将fabs调用包装在ScalarReal中：return ScalarReal(fabs(...));。 - Joshua Ulrich

Answer 1

这实际上是一个不太明确的问题。当你提出

func1 <- function(alpha, tau, rho, phi) {
     abs((alpha + 1)^(tau) * phi - rho * (1- (1 + alpha)^(tau))/(1 - (1 + alpha)))
}

即使不指定参数（例如标量？向量？大型？小型？内存开销），您最多只能直接从已分析的表达式中获得一小组（基本，高效）函数调用。

自从我们有了字节编译器以来，它在随后的R版本中由Luke Tierney进行了改进，我们就知道它可以很好地处理代数表达式。

现在，编译的C / C ++代码也可以做到这一点 - 但是调用编译的代码会产生开销，并且在“足够琐碎”的问题上，这种开销并没有得到很好的摊销。

因此，您最终得到的就是几乎相同的结果。 据我所知，这并不令人惊讶。

- Dirk Eddelbuettel

---

“但是调用编译后的代码会有开销” - 我认为这是问题的关键。有多少开销呢？因为调用传统的R函数当然也会带来开销，并且上述R函数中的所有单个数学操作都会产生此开销。因此，总体而言，它应该比仅调用一次C++编译函数的单个开销要大得多。 - Konrad Rudolph

你对此过于深究了。一个本地函数调用了一个原始函数。由Rcpp和Rcpp Attributes生成的函数将具有一个或两个非常简单的包装器和间接引用。在非病态示例中，这些并不重要，但是这个问题是病态的。 - Dirk Eddelbuettel

是的和是的（尽管我从未看到@bunk写了什么）。 - Dirk Eddelbuettel

@DirkEddelbuettel 所以如果我理解正确的话，你的意思是字节编译器正在编译为其期望的最有效的基本情况。如果我使用向量而不是标量进行测试，可能会看到不同的性能，因为字节编译器不会针对它进行优化。另一方面，有趣的是C++调用中的开销足够大，以至于拖慢了性能，但这可能是微秒级别代码基准测试的问题。 - lostinarandomforest

不，那并不是我真正想说的。 - Dirk Eddelbuettel