Parallel Programming with Boost.SIMD

Introduction

Modern CPU processors are built with new, extended instruction sets that optimize for certain operations. A class of these allow for vectorized operations, called Single Instruction / Multiple Data (SIMD) instructions. Although modern compilers will use these instructions when possible, they are often unable to reason about whether or not a particular block of code can be executed using SIMD instructions.

Boost.SIMD [PDF] is a C++ header-only library that makes it possible to explicitly request the use of SIMD instructions when possible, while falling back to regular scalar operations when not. RcppParallel wraps and exposes this library for use with R vectors.

The primary abstraction that Boost.SIMD uses under the hood is the boost::simd::pack<> data structure. This item represents a small, contiguous, pack of integral objects (e.g. doubles), and comes with a host of functions that facilitate the use of SIMD operations on those objects when possible. Although you don’t need to know the details to use the high-level functionality provided by Boost.SIMD, it’s useful for understanding what happens behind the scenes.

Here’s a quick example of how we might compute the sum of elements in a vector, using Boost.SIMD.

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

#include <Rcpp.h>
using namespace Rcpp;

// Define a functor -- a C++ class which defines a templated
// 'function call' operator -- to perform the addition of 
// two pieces of data.
struct add_two {
  template <typename T>
  T operator()(const T& lhs, const T& rhs) {
    return lhs + rhs;
  }
};

// [[Rcpp::export]]
double simd_sum(NumericVector x) {
  // Pass the functor to 'simdReduce()'.
  return simdReduce(x.begin(), x.end(), 0.0, add_two());
}

Behind the scenes, simdReduce() takes care of iteration over our sequence, and ensures that we use optimized SIMD instructions over packs of numbers when possible, and scalar instructions when not. By passing a templated functor, simdReduce() can automagically choose the correct template specialization depending on whether it’s working with a pack or not. In other words, two template specializations will be generated in this case: one with T = double, and another with T = boost::simd::pack<double>.

Let’s confirm that this produces the correct output, and run a small benchmark.

# helper function for printing microbenchmark output
printBm <- function(bm) {
  summary <- summary(bm)
  print(summary[, 1:7], row.names = FALSE)
}

# generate some data
data <- rnorm(1024 * 1000)

# verify that it produces the correct sum
all.equal(simd_sum(data), sum(data))

## [1] TRUE

# compare results
library(microbenchmark)
bm <- microbenchmark(sum(data), simd_sum(data))
printBm(bm)

##            expr     min       lq     mean   median       uq      max
##       sum(data) 824.013 836.9370 880.5446 870.0565 909.2475 1300.552
##  simd_sum(data) 416.062 421.2825 456.2859 432.6560 481.2070  595.670

We get a noticable gain by taking advantage of SIMD instructions here, although it’s worth noting that we don’t handle NA and NaN with the same granularity as R.

SIMD Algorithms

class simd_square {
template <typename T>
void operator()(const T& data) {
  return boost::simd::sqr(data);
}
};

Using SIMD in an R Package

IMPORTANT NOTE: Support for Boost.SIMD is currently only available in the development version of RcppParallel. Therefore, packages using Boost.SIMD should not yet be submitted to CRAN.

Imports: RcppParallel
LinkingTo: RcppParallel, BH
SystemRequirements: GNU make, C++11

#define RCPP_PARALLEL_USE_SIMD
#include <RcppParallel.h>

#define RCPP_PARALLEL_USE_SIMD
#include <RcppParallel.h>

#if RCPP_PARALLEL_USE_SIMD

IntegerVector transformDataImpl(IntegerVector x) {
  // Implement with Boost.SIMD
}

#else

IntegerVector transformDataImpl(IntegerVector x) {
  // Implement without Boost.SIMD
}

#endif

// [[Rcpp::export]]
IntegerVector transformData(IntegerVector x) {
   return transformDataImpl(x);
}

Learning More

If you want to dive deeper into Boost.SIMD, you can read the online documentation, and also browse the examples here.

If you want to try out Boost.SIMD yourself, please install the development version of RcppParallel with devtools::install_github("RcppCore/RcppParallel").