灵感来自文章 http://gallery.rcpp.org/articles/parallel-distance-matrix/ ，我尝试使用 RcppParallel 在高维参数空间中运行强力搜索以使用多线程进行回测。我一直卡在如何在struct部分调用自定义函数。思路是这样的:

首先，先在R中创建一个参数矩阵NumericMatrix params_mat，使用List, NumericVector, CharacterVector数据类型的回测数据，如List Data_1， NumericVector Data_2, CharacterVector Data_3, ...，对于每个参数场景params_vec都是静态的(注意是params_mat的行)。

接下来，定义回测函数，输出一个包含 3 个关键变量的 vector 来评估策略性能。

这是我的 params_mat 和 Backtesting_Fun 的示例，它们可以分别在 R 和 Rcpp 中运行。

//[[Rcpp::export]]
NumericMatrix data_frame_rcpp(const Rcpp::List& list_params) 
{
  NumericMatrix res = list_params[0];
  return res;
}

# R codes to generate params_mat
params <- expand.grid (x_1=seq(1,100,1), x_2=seq(3,100,2), ..., x_n=seq(4,200,1));                           
list_params = list(ts(params));
tmp_params_data = data_frame_rcpp(list_params);                                              
params_mat = matrix(tmp_params_data, ncol = ncol(tmp_params_data), dimnames = NULL); 
params_vec = params_mat[ii,];

# User-defined Rcpp codes for backtesting
NumericVector Backtesting_Fun (List Data_1, NumericVector Data_2, CharacterVector Data_3, ..., NumericVector params_vec)
{
  // Main function parts to run backtesting for each params_vec scenario.
  ... etc

  // save 3 key result variables together with each params_vec (just a simple illustration).
  NumericVector res = NumericVector::create(params_vec[0],...,params_vec[size-1],
                                            key_1, key_2, key_3); 
  return res;
}

当然我们需要用RVector/RMatrix类型重写/修改原来的Rcpp Backtesting_Fun，然后使用下面的RcppParallel代码来调用Backtesting_Fun 在 struct Backtest_parallel 中:

// [[Rcpp::depends(RcppParallel)]]
#include <RcppParallel.h>
using namespace RcppParallel;

RVector<double> Backtesting_Fun (const RVector<double> Data_1, const RVector<double> Data_2, 
                                const RVector<string> Data_3,..., const RVector<double> params_vec)
{
   // Main function parts to run backtesting for each params_vec scenario.
   ... etc;

   // save 3 key result variables together with each params_vec
   ... etc; 

   return res;
}

struct Backtest_parallel : public Worker 
{       
   // input matrix to read from
   const RVector<List> Data_1;
   const RVector<double> Data_2;
   const RVector<string> Data_3;
   ...
   const RMatrix<double> params_mat;

   // output matrix to write to
   RMatrix<double> rmat;

   // initialize from Rcpp input and output matrixes (the RMatrix class
   // can be automatically converted to from the Rcpp matrix type)
   Backtest_parallel(const List Data_1, const NumericVector Data_2, 
   const CharacterVector Data_3, ..., const NumericMatrix params_mat)
      : Data_1(Data_1), Data_2(Data_2), Data_3(Data_3), ..., params_mat(params_mat) {}

   // function call operator that work for the specified range (begin/end)
   void operator()(std::size_t begin, std::size_t end) 
   {
      for (std::size_t ii = begin; ii < end; i++) 
      {
         // params rows that we will operate on
         RMatrix<double>::Row params_row = params_mat.row(ii);

         // Run the backtesting function defined above
         RVector<double> res = Backtesting_Fun(Data_1, Data_2, ..., params_row)
         for (std::size_t jj = 0; jj < res.length(); jj++) 
         {
            // write to output matrix
            rmat(ii,jj) = res[jj];
         }
      }
   }
};

// [[Rcpp::export]]
NumericMatrix rcpp_parallel_backtest(List Data_1, NumericVector Data_2, CharacterVector Data_3,
                                     ..., NumericMatrix params_mat) 
{      
   // allocate the matrix we will return
   NumericMatrix rmat(params_mat.nrow(), params_mat.nrow()+3);

   // create the worker
   Backtest_parallel backtest_parallel(Data_1, Date_2, ..., params_mat);

   // call it with parallelFor
   parallelFor(0, rmat.nrow(), backtest_parallel);

   return rmat;
}

这是我的问题:

1. RVector 是否可以包含List 数据类型，或者RcppParallel 中是否有任何特定的容器来包含List;

2. 在Backtesting_Fun中，输入应该是RVector/RMatrix类型，这是否意味着我们真的需要将原始Rcpp主代码转换为 NumericVector 转换为 RVector？

或者有没有更好的方法在 RcppParallel 中为我的案例进行并行计算？提前致谢。

编辑:

1. 我查看了 http://gallery.rcpp.org/articles/parallel-matrix-transform/ 中关于 RcppPararrel 的其他示例, http://gallery.rcpp.org/articles/parallel-inner-product/ , struct operator() 中的共同思想是使用指针来操作 operator() 的数据输入，所以有没有办法在我的中构建用户定义的函数指针输入的情况？

2. 如果上述方式不行，是否可以使用wrap将RVector/RMatrix转回Rcpp数据类型，即 operator()中的NumericVector..，使自定义函数Backtesting_Fun的输入类型保持不变。

最佳答案

我想我可能会找到另一种方法来解决这个问题:关键是使用线程安全访问器将变量包含在 struct 中，并保持 RVector/RMatrix 在外部 main 函数中，以便 parallelFor 可以正常工作，这是这个并行算法中最重要的部分。这是我的方法:

1. 摆脱 List 数据类型:相反，我们可以使用 NumericVector 转换 List 变量>/NumericMatrix 容器并记录其相应的索引，以便子 vector/子矩阵将指向与列表元素相同的元素。

2. 将 RVector/RMatrix 转换为 arma::vec/arma::mat:如RcppParallel Github所述, C++ Armadillo 在结构的运算符中是线程安全的。在这里，我修改了 Parallel Distance Matrix Calculation with RcppParallel 中给出的示例通过使用这个想法，它几乎保持相同的测试速度。

   struct JsDistance : public Worker
   {
     const RMatrix<double> tmp_MAT;  // input matrix to read from
     RMatrix<double> tmp_rmat;       // output matrix to write to
     std::size_t row_size, col_size;
   
     // Convert global input/output into RMatrix/RVector type
     JsDistance(const NumericMatrix& matrix_input, NumericMatrix& matrix_output, 
                std::size_t row_size, std::size_t col_size)
       : tmp_MAT(matrix_input), tmp_rmat(matrix_output), row_size(row_size), col_size(col_size) {}
   
     // convert RVector/RMatrix into arma type for Rcpp function
     // and the follwing arma data will be shared in parallel computing
     arma::mat convert()
     {
       RMatrix<double> tmp_mat = tmp_MAT;
       arma::mat MAT(tmp_mat.begin(), row_size, col_size, false);
       return MAT;
     }
   
   
     void operator()(std::size_t begin, std::size_t end)
     {
       for (std::size_t i = begin; i < end; i++)
       {
         for (std::size_t j = 0; j < i; j++)
         {
           // rows we will operate on
           arma::mat MAT = convert();
           arma::rowvec row1 = MAT.row(i);          // get the row of arma matrix
           arma::rowvec row2 = MAT.row(j);
   
           // compute the average using std::tranform from the STL
           std::vector<double> avg(row1.n_elem);
           std::transform(row1.begin(), row1.end(), // input range 1
                          row2.begin(),             // input range 2
                          avg.begin(),              // output range
                          average);                 // function to apply
   
           // calculate divergences
           double d1 = kl_divergence(row1.begin(), row1.end(), avg.begin());
           double d2 = kl_divergence(row2.begin(), row2.end(), avg.begin());
   
           // write to output matrix
           tmp_rmat(i,j) = sqrt(.5 * (d1 + d2));
         }
       }
     }
   };
   
   // [[Rcpp::export]]
   NumericMatrix rcpp_parallel_js_distance_modify(const Rcpp::NumericMatrix& matrix_input, int N_cores)
   {
     // allocate the matrix we will return
     NumericMatrix matrix_output(matrix_input.nrow(), matrix_input.nrow());
     std::size_t row_size = matrix_input.nrow();
     std::size_t col_size = matrix_input.ncol();
   
     // create the worker
     JsDistance jsDistance(matrix_input, matrix_output, row_size, col_size);
   
     // call it with parallelFor
     parallelFor(0, matrix_input.nrow(), jsDistance, matrix_input.nrow()/N_cores);           // parallelFor with grain size setting
   
     return matrix_output;
    }
   
    // Example compare: 
    n_row = 1E3;
    n_col = 1E2;
    m = matrix(runif(n_row*n_col), nrow = n_row, ncol = n_col);
    m = m/rowSums(m);
   
    res <- benchmark(rcpp_parallel_js_distance(m, 6),
            rcpp_parallel_js_distance_orignal(m, 6),
            order="relative")
    res[,1:4];
   
    #test                                    #elapsed   #relative
    rcpp_parallel_js_distance_orignal(m, 6)  128.069    1.000
    rcpp_parallel_js_distance(m, 6)          129.210    1.009
   

正如我们所见，operator 中的数据类型将是C++ arma，现在我们可以通过直接使用该对象来安全快速地调用我们的用户定义函数仅指针，可能不是通用的或易于设计的。

现在，这个parallelFor结构将在并行计算中共享相同的数据源，无需额外的拷贝，然后我们可以使用上述问题中提到的想法对回测进行一些微调。

关于c++ - RcppParallel 中如何调用自定义函数？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/30791410/