3

当使用 Rcpp 与外部库交互时，我们必须从 Rcpp 内置容器类转换为最常见的标准容器类。与往常一样，这种转换是有代价的。通常，这种开销是相当确定的，但在 Rcpp 转换LogicalVector 为 astd::vector<double>的情况下，成本似乎与其他类型的铸造/促销成本不一致......

考虑以下六个从 LogicalVector 到 std::vector 容器的简单转换的相等性...

// Equality check functions.
// [[Rcpp::export]]
svi test_auto_conversion_std_int(const svi& v) {
  return v;
}
// [[Rcpp::export]]
svi test_as_conversion_std_int(const lv& v) {
  svi v2 = as<svi>(v);
  return v2;
}
// [[Rcpp::export]]
svi test_manual_conversion_std_int(const nv& v) {
  svi v2(v.begin(),v.end());
  return v2;
}
// [[Rcpp::export]]
svd test_auto_conversion_std_dbl(const svd& v) {
  return v;
}
// [[Rcpp::export]]
svd test_as_conversion_std_dbl(const lv& v) {
  svd v2 = as<svd>(v);
  return v2;
}
// [[Rcpp::export]]
svd test_manual_conversion_std_dbl(const nv& v) {
  svd v2(v.begin(),v.end());
  return v2;
}

    > small_l_vec <- c(T,F,NA)
    > small_i_vec <- as.integer(small_l_vec)
    > small_n_vec <- as.numeric(small_l_vec)
    > all( identical(small_i_vec, test_auto_conversion_std_int(small_l_vec)),
    +      identical(small_i_vec, test_as_conversion_std_int(small_l_vec)),
    +    .... [TRUNCATED] 
    [1] TRUE

    > all( identical(small_n_vec, test_auto_conversion_std_dbl(small_l_vec)),
    +      identical(small_n_vec, test_as_conversion_std_dbl(small_l_vec)),
    +    .... [TRUNCATED] 
    [1] TRUE

由于 Rcpp 的模板魔法，我们得到了这种平等。我的模板 fu 不够强大，无法深入研究为什么手动转换与自动转换的开销存在如此大的差异，如这些基准结果所示......

    > benchmark_as_tested_for_equality()  # includes copy costs
    Unit: microseconds
                                      expr   median neval
         test_as_conversion_std_int(l_vec) 10121.17   500
     test_manual_conversion_std_int(l_vec) 12545.34   500
       test_auto_conversion_std_int(l_vec) 12654.28   500
     test_manual_conversion_std_dbl(l_vec) 18590.10   500
         test_as_conversion_std_dbl(l_vec) 19653.39   500
       test_auto_conversion_std_dbl(l_vec) 26897.93   500  <<< OUCH!

比较直接使用 Rcpp 容器、自动转换为类似类型的标准容器和提升类型的容器的成本......

# Functions return "size" only so no copy costs.

> declared_direct()      > declared_std_like_types()
          expr median               expr   median
rcpp_lv(l_vec) 1.1280    std_bool(l_vec) 7352.500


> declared_promoted_r()  > declared_promoted_std()
          expr   median            expr     median
rcpp_iv(l_vec) 2932.712  std_int(l_vec)   6790.508
rcpp_nv(l_vec) 5359.769  std_dbl(l_vec)  12810.550 <<< OUCH!

...很容易看到异常值。如果我们尝试将逻辑向量作为类似类型的 std 容器传递，然后让 c++ 在构造新容器时进行提升，结果也不会更好......

    > declared_std_like_types_promoted_using_std_promotion()
                            expr    median
     std_bool_promote_int(l_vec) 12725.724
     std_bool_promote_dbl(l_vec) 13626.782

但是，如果LogicalVector由 Rcpp 提升并用于直接填充标准容器，结果会好得多。

 > declared_promoted_r_to_std_like_type()
                            expr   median
  rcpp_lv_promote_std_int(l_vec) 5019.586
  rcpp_lv_promote_std_dbl(l_vec) 8007.522 <<< Much better!

我无法弄清楚为什么从 LogicalVectorto的自动转换std::vector<double>如此之慢......

4

0 回答 0