include most boost.SIMD headers in SIMD.h

Author: kevinushey

examples/boost-simd-abssum.cpp

@@ -3,14 +3,6 @@
 #include <Rcpp.h>
 using namespace Rcpp;
 
-#include <boost/simd/sdk/simd/pack.hpp>
-#include <boost/simd/memory/allocator.hpp>
-#include <boost/simd/include/functions/sum.hpp>
-#include <boost/simd/include/functions/load.hpp>
-#include <boost/simd/include/functions/plus.hpp>
-#include <boost/simd/include/functions/multiplies.hpp>
-#include <boost/simd/include/functions/abs.hpp>
-
 // [[Rcpp::export]]
 double simd_abssum(NumericVector x)
 {

examples/boost-simd-accumulate.cpp

@@ -3,8 +3,6 @@
 #include <Rcpp.h>
 using namespace Rcpp;
 
-#include <boost/simd/sdk/simd/algorithm.hpp>
-
 struct plus
 {
    template <class T>

examples/boost-simd-dot.cpp

@@ -4,12 +4,6 @@
 using namespace Rcpp;
 
 // http://nt2.metascale.fr/doc/html/tutorials/processing_data_the_simd_way.html
-#include <boost/simd/memory/allocator.hpp>
-#include <boost/simd/sdk/simd/pack.hpp>
-#include <boost/simd/include/functions/sum.hpp>
-#include <boost/simd/include/functions/load.hpp>
-#include <boost/simd/include/functions/plus.hpp>
-#include <boost/simd/include/functions/multiplies.hpp>
 
 template <typename Value>
 Value simd_dot_impl(Value* first1, Value* last1, Value* first2)

examples/boost-simd-hello-world.cpp

@@ -4,12 +4,6 @@
 using namespace Rcpp;
 
 // http://nt2.metascale.fr/doc/html/tutorials/simd_hello_world.html
-#include <boost/simd/sdk/simd/pack.hpp>
-#include <boost/simd/sdk/simd/io.hpp>
-#include <boost/simd/include/functions/splat.hpp>
-#include <boost/simd/include/functions/plus.hpp>
-#include <boost/simd/include/functions/multiplies.hpp>
-#include <iostream>
 
 // [[Rcpp::export]]
 void HelloWorld()

examples/boost-simd-transform.cpp

@@ -3,8 +3,6 @@
 #include <Rcpp.h>
 using namespace Rcpp;
 
-#include <boost/simd/sdk/simd/algorithm.hpp>
-
 struct plus
 {
    template <class T>

examples/simd-operations.Rmd

@@ -11,11 +11,20 @@ vignette: >
 
 ## SIMD Basics
 
-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, it is often not possible for the compiler to reason about whether or not a particular block of code can be executed using SIMD instructions.
+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` 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 if not. `RcppParallel` wraps and exposes this library for use with R vectors.
+`Boost.SIMD` 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 if not. `RcppParallel` wraps and exposes this library
+for use with R vectors.
 
-Here's a quick example of how we might compute the sum of elements in a vector, using `Boost.SIMD`.
+Here's a quick example of how we might compute the sum of elements in a vector,
+using `Boost.SIMD`.
 
 ```{r, engine='Rcpp'}
 // [[Rcpp::depends(RcppParallel)]]
@@ -25,7 +34,7 @@ Here's a quick example of how we might compute the sum of elements in a vector,
 using namespace RcppParallel;
 using namespace Rcpp;
 
-// Define a functor -- a C++ class which defines a 'function call'
+// 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>
@@ -36,9 +45,8 @@ struct add_two {
 
 // [[Rcpp::export]]
 double simd_sum(NumericVector x) {
-   // Use 'simd::accumulate', to sum our vector (by successively adding
-   // up pairwise components of the vector)
-   return simd::accumulate(x, 0.0, add_two());
+   
+   return boost::simd::accumulate(x.begin(), x.end(), 0.0, add_two());
 }
 ```
 
@@ -60,24 +68,6 @@ Boost.SIMD provides two primary abstractions for the implementation of SIMD algo
 
 These functions operate like their `std::` counterparts, but expect a functor with a templated call operator. By making the call operator templated, `Boost.SIMD` can generate code using its own optimized SIMD functions when appropriate, and fall back to a default implementation (based on the types provided) when not.
 
-`Boost.SIMD` also provides a number of built in functions, which can be used effectively with `simd::accumulate()` or `simd::transform()`. For example, let's use SIMD instructions to compute the minimum:
-
-```{r, engine='Rcpp'}
-// [[Rcpp::depends(RcppParallel)]]
-#include <RcppParallel.h>
-#include <Rcpp.h>
-
-#include <boost/simd/arithmetic/functions/min.hpp>
-
-using namespace RcppParallel;
-using namespace Rcpp;
-
-// [[Rcpp::export]]
-NumericVector simd_min(NumericVector data) {
-   return simd::transform(data, boost::simd::tag::min_());
-}
-```
-
 ## Using SIMD in an R Package
 
 To build an R package that uses Boost.SIMD you need to make some modifications to the standard RcppParallel configuration:

inst/include/RcppParallel/SIMD.h

@@ -1,34 +1,32 @@
 #ifndef RCPP_PARALLEL_SIMD_H
 #define RCPP_PARALLEL_SIMD_H
 
+// Bring in the headers that automatically include the most
+// commonly used SIMD functions. We do this for a couple reasons:
+//
+//    1. Including each desired header 'by hand' can be tedious
+//       for the user,
+//
+//    2. Certain headers depend on others in such a way that attempting
+//       to include one without the other can lead to obscure compiler
+//       errors.
+//
+// The downside is the increased compile time, but this is something that users
+// have implicitly accepted given the heavy use of template meta-programming in
+// Boost.SIMD and its dependent libraries.
 #include <boost/simd/sdk/simd/algorithm.hpp>
 
-namespace RcppParallel {
-namespace simd {
-
-template <class T, class UnaryFunction>
-T transform(const T& data, UnaryFunction f)
-{
-   T result(data.size());
-   boost::simd::transform(data.begin(), data.end(), result.begin(), f);
-   return result;
-}
-
-template <class T, class BinaryFunction>
-T transform(const T& lhs, const T& rhs, BinaryFunction f)
-{
-   T result(lhs.size());
-   boost::simd::transform(lhs.begin(), lhs.end(), rhs.begin(), result.begin(), f);
-   return result;
-}
-
-template <class T, class U, class F>
-U accumulate(const T& data, U init, F f)
-{
-   return boost::simd::accumulate(data.begin(), data.end(), init, f);
-}
-
-} // namespace simd
-} // namespace RcppParallel
-
-#endif /* RCPP_PARALLEL_SIMD_H */
+#include <boost/simd/memory/memory.hpp>
+#include <boost/simd/memory/allocator.hpp>
+
+#include <boost/simd/arithmetic/arithmetic.hpp>
+
+#include <boost/simd/bitwise/bitwise.hpp>
+
+#include <boost/simd/boolean/boolean.hpp>
+
+#include <boost/simd/reduction/reduction.hpp>
+
+#include <boost/simd/swar/swar.hpp>
+
+#endif /* RCPP_PARALLEL_SIMD_H */