'functors' -> 'ops'

Author: kevinushey

examples/boost-simd-abssum.cpp

@@ -1,5 +1,5 @@
 // [[Rcpp::depends(RcppParallel)]]
-#define RCPP_PARALLEL_USE_SIMD 1
+#define RCPP_PARALLEL_USE_SIMD
 #include <RcppParallel.h>
 #include <Rcpp.h>
 using namespace Rcpp;

gallery/simd-vector-sum.cpp

@@ -102,9 +102,9 @@ print(res)
  * similarly efficient code when the `-ffast-math` optimization flag is set.
  * By default, the compiler is somewhat 'pessimistic' about the set of 
  * optimizations it can perform around floating point arithmetic. This is 
- * because it must respect the [IEEE floating 
- * point](https://en.wikipedia.org/wiki/IEEE_floating_point) standard, and
- * this means respecting the fact that, for example, floating point
+ * because it must respect the
+ * [IEEE floating point standard](https://en.wikipedia.org/wiki/IEEE_floating_point),
+ * and this means respecting the fact that, for example, floating point 
  * operations are not assocative:
  */
 
@@ -116,6 +116,6 @@ print(res)
  * Surprisingly, the above computation does not evaluate to zero!
  *
  * In practice, you're likely safe to take advantage of the `-ffast-math`
- * optimizations, or Boost.SIMD, in your own work. However, be sure to test and
+ * optimizations, or `Boost.SIMD`, in your own work. However, be sure to test and
  * verify!
  */

gen/simd-functors.R gen/simd-ops.Rgen/simd-functors.R renamed to gen/simd-ops.R

@@ -1,17 +1,29 @@
-path <- "inst/include/RcppParallel/simd/functors.h"
+path <- "inst/include/RcppParallel/simd/ops.h"
 dir.create(dirname(path), recursive = TRUE, showWarnings = FALSE)
 
+forEach <- function(data, f) {
+   nm <- names(data)
+   for (i in seq_along(data)) {
+      f(nm[[i]], data[[i]])
+   }
+}
+
+indent <- function(code, indent = "    ") {
+   code <- paste(indent, code, sep = "")
+   gsub("\n", "    \n", code, fixed = TRUE)
+}
+
 template <- paste(c(
    "// Auto-generated functors for functions provided by Boost.SIMD.",
-   "// See 'gen/simd-functors.R' for implementation.",
+   "// See 'gen/simd-ops.R' for implementation.",
    "",
    "namespace boost {",
    "namespace simd {",
-   "namespace functors {",
+   "namespace ops {",
    "",
    "%s",
    "",
-   "} // namespace functors",
+   "} // namespace ops",
    "} // namespace simd",
    "} // namespace boost"
 ), collapse = "\n")
@@ -20,43 +32,43 @@ code <- NULL
 
 # NOTE: Each function should accept a parameter called 'data'.
 unary <- list(
-   sum = "boost::simd::sum(data)"
+   sum = "return sum(data);"
 )
 
 unary_template <- paste(c(
    "struct %s {",
    "template <typename T>",
    "inline T operator()(const T& data) {",
-   "    return %s;",
+   "%s",
    "}",
    "};",
    ""
 ), collapse = "\n")
 
-for (i in seq_along(unary)) {
-   code <- c(code, sprintf(unary_template, names(unary)[i], unary[[i]]))
-}
+forEach(unary, function(name, value) {
+   code <<- c(code, sprintf(unary_template, name, indent(value)))
+})
 
 binary <- list(
-   plus = "lhs + rhs",
-   minus = "lhs - rhs",
-   times = "lhs * rhs",
-   divide = "lhs / rhs"
+   plus = "return lhs + rhs;",
+   minus = "return lhs - rhs;",
+   times = "return lhs * rhs;",
+   divide = "return lhs / rhs;"
 )
 
 binary_template <- paste(c(
    "struct %s {",
    "template <typename T>",
    "inline T operator()(const T& lhs, const T& rhs) {",
-   "    return %s;",
+   "%s",
    "}",
    "};",
    ""
 ), collapse = "\n")
 
-for (i in seq_along(binary)) {
-   code <- c(code, sprintf(binary_template, names(binary)[[i]], binary[[i]]))
-}
+forEach(binary, function(name, value) {
+   code <<- c(code, sprintf(binary_template, name, indent(value)))
+})
 
 compiled <- sprintf(template, paste(code, collapse = "\n"))
 cat(compiled, file = path, sep = "\n")

inst/include/RcppParallel.h

@@ -53,13 +53,15 @@ inline void parallelReduce(std::size_t begin, std::size_t end,
 } // namespace RcppParallel
 
 // Refuse request for RCPP_PARALLEL_USE_SIMD if we don't have C++11
-#if RCPP_PARALLEL_USE_SIMD
-   #if (__cplusplus <= 199711L)
-      #undef RCPP_PARALLEL_USE_SIMD
-   #endif
+#ifdef RCPP_PARALLEL_USE_SIMD
+# if (__cplusplus <= 199711L)
+#  undef RCPP_PARALLEL_USE_SIMD
+# endif
 #endif
-#if RCPP_PARALLEL_USE_SIMD
-  #include "RcppParallel/SIMD.h"
+
+// Conditionally include SIMD
+#ifdef RCPP_PARALLEL_USE_SIMD
+# include "RcppParallel/SIMD.h"
 #endif
 
 #endif // __RCPP_PARALLEL__

inst/include/RcppParallel/SIMD.h

@@ -30,30 +30,6 @@
 #include <boost/simd/swar/swar.hpp>
 
 // Auto-generated functors for use in 'transform()', 'accumulate()'
-#include <RcppParallel/simd/functors.h>
-
-namespace RcppParallel {
-
-template <typename DataType>
-class SimdTransformer
-{
-public:
-   typedef DataType value_type;
-   typedef boost::simd::pack<DataType> packed_type;
-};
-
-template <typename DataType, class Transformer>
-DataType simdTransformAndReduce(const DataType* it, const DataType* end, Transformer transformer)
-{
-   using boost::simd::pack;
-   using boost::simd::load;
-   
-   pack<DataType> accumulated = transformer.initialize(it, end);
-   for (; it != end; it += pack<DataType>::static_size)
-      transformer.update(load<pack<DataType>>(it), &accumulated);
-   return transformer.reduce(accumulated);
-}
-
-} // namespace RcppParallel
+#include <RcppParallel/simd/ops.h>
 
 #endif /* RCPP_PARALLEL_SIMD_H */

inst/include/RcppParallel/simd/functors.h inst/include/RcppParallel/simd/ops.hinst/include/RcppParallel/simd/functors.h renamed to inst/include/RcppParallel/simd/ops.h

@@ -1,14 +1,14 @@
 // Auto-generated functors for functions provided by Boost.SIMD.
-// See 'gen/simd-functors.R' for implementation.
+// See 'gen/simd-ops.R' for implementation.
 
 namespace boost {
 namespace simd {
-namespace functors {
+namespace ops {
 
 struct sum {
 template <typename T>
 inline T operator()(const T& data) {
-    return boost::simd::sum(data);
+    return sum(data);
 }
 };
 
@@ -41,6 +41,6 @@ inline T operator()(const T& lhs, const T& rhs) {
 };
 
 
-} // namespace functors
+} // namespace ops
 } // namespace simd
 } // namespace boost