How do I resolve compile error in RcppParallel function which points to an RcppParallel header file

Question

I'm trying to speed up numeric computation in my R code using RcppParallel and am attempting to edit an example that uses the Cpp sqrt() function to take the square root of each element of a matrix. My edited code replaces matrices with vectors and multiplies the sqrt() by a constant. (In actual use I will have 3 constants and my own operator function.)

The example comes from https://gallery.rcpp.org/articles/parallel-matrix-transform/

The compiler identifies the error as in the 'algorithm' file on a comment line:

Line 7 no matching function for call to object of type 'SquareRootPlus::sqrtWrapper'

This is my initial attempt to use RcppParallel and I've not used Cpp for several years.

Edit: running macOS Ventura on apple silicon, Rcpp ver 1.0.10, RcppParallel ver 5.1.6, and R version 4.2.1 (2022-06-23) -- "Funny-Looking Kid"

It would be called like this (if it compiled): where c is a numerical constant aka a double and res is a numerical vector res <- parallelMatrixSqrt(someNumericalVector, c)

My testing code is:

#include <Rcpp.h>
#include <RcppParallel.h>
using namespace RcppParallel;
using namespace Rcpp;

struct SquareRootPlus : public Worker
{
  // source vector etc
  const RVector<double> input;
  const double constParam;

  // destination vector
  RVector<double> output;

  // initialize with source and destination
  // get the data type correctly unless auto promoted/cast
  SquareRootPlus(const Rcpp::NumericVector input, const double constParam,
             Rcpp::NumericVector output)
    : input(input), constParam(constParam), output(output) {}

  struct sqrt_wrapper {  // describe worker function
    public: double operator()(double a, double cp) {
      return ::sqrt(a) * cp;
    }
  };

  // take the square root of the range of elements requested
  // (and multiply it by the constant)
  void operator()(std::size_t begin, std::size_t end) {
    std::transform(input.begin() + begin,
                   input.begin() + end,
                   output.begin() + begin,
                   sqrt_wrapper());
  }
};

// public called routine
// [[Rcpp::export]]
Rcpp::NumericVector paralleVectorSqrt(Rcpp::NumericVector x, double c) {
  // allocate the output matrix
  Rcpp::NumericVector output(x.length());
  // SquareRoot functor (pass input and output matrixes)
  SquareRootPlus squareRoot(x, c, output);
  // call parallelFor to do the work
  parallelFor(0, x.length(), squareRoot);
  // return the output matrix
  return output;
}

Answer 1

That still works fine for me (Ubuntu 22.10, g++-12) -- modulo same warnings we often get from libraries like Boost, and here now from the include TBB library (and the repo should have a newer one so you can try that).

I just did (straight from the Rcpp Gallery source directory):

> library(Rcpp)                                                                                          
> sourceCpp("2014-06-29-parallel-matrix-transform.cpp")
In file included from /usr/local/lib/R/site-library/RcppParallel/include/tbb/tbb.h:41,
                 from /usr/local/lib/R/site-library/RcppParallel/include/RcppParallel/TBB.h:10,
                 from /usr/local/lib/R/site-library/RcppParallel/include/RcppParallel.h:21,
                 from 2014-06-29-parallel-matrix-transform.cpp:59:
/usr/local/lib/R/site-library/RcppParallel/include/tbb/concurrent_hash_map.h:343:23: warning: ‘template<class _Category, class _Tp, class _Distance, class _Pointer, class _Reference> struct std::iterator’ is dep
recated [-Wdeprecated-declarations]  
[... more like this omitted for brevity ...]
> # allocate a matrix                                                                                    
> m <- matrix(as.numeric(c(1:1000000)), nrow = 1000, ncol = 1000)      
                                                                                                         
> # ensure that serial and parallel versions give the same result
> stopifnot(identical(matrixSqrt(m), parallelMatrixSqrt(m)))
                                                                                                         
> # compare performance of serial and parallel                                                           
> library(rbenchmark)                                                                                    
                                                                                                         
> res <- benchmark(matrixSqrt(m),                                                                        
+                  parallelMatrixSqrt(m),                                                                
+                  order="relative")                                                                     
                                                    
> res[,1:4]                                                                                              
                   test replications elapsed relative                                              
2 parallelMatrixSqrt(m)          100   0.496    1.000                                 
1         matrixSqrt(m)          100   0.565    1.139                                                                                                                                                              
> 

and as you can see it not only builds but also runs the example call from R.

You would have to give us more detail about how you call it and what OS and package versions you use. And I won't have time now to dig into your code and do a code review for you but given that (still relatively simple) reference example works maybe you can reduce your currently-not-working approach down to something simpler that works.

Edit Your example appears to have switched from a unary function to one with two arguments in the signature. Sadly it ain't that easy. The fuller error message is (on my side with g++-12)

/usr/include/c++/12/bits/stl_algo.h:4263:31: error: no match for call to ‘(SquareRootPlus::sqrt_wrapper) (const double&)’
 4263 |         *__result = __unary_op(*__first);
      |                     ~~~~~~~~~~^~~~~~~~~~
question.cpp:25:20: note: candidate: ‘double SquareRootPlus::sqrt_wrapper::operator()(double, double)’
   25 |     public: double operator()(double a, double cp) {
      |                    ^~~~~~~~
question.cpp:25:20: note:   candidate expects 2 arguments, 1 provided

So you need to rework / extend the example framework for this.

Edit 2: The gory details about std::transform() and its unary function are e.g. here at cppreference.com.

Edit 3: Building on the previous comment, when you step back a bit and look at what is happening here you may seen that RcppParellel excels at parceling up a large data structure, then submitting all the piece in parallel and finally reassemble the result. That still works. You simply cannot apply for 'richer signature function' via std::transform(). No more, no less. You need to work the guts of work which applies your function to the chunk it sees. Check the other RcppParallel examples for inspiration.