initial commit

Author: kevinushey

.Rbuildignore

@@ -0,0 +1,4 @@
+^.*\.Rproj$
+^\.Rproj\.user$
+^patch/
+^nt2/

.gitignore

@@ -0,0 +1,5 @@
+.Rproj.user
+.Rhistory
+.RData
+
+/nt2

DESCRIPTION

@@ -0,0 +1,16 @@
+Package: RcppNT2
+Title: 'Rcpp' Integration for the 'NT2' Scientific Computing Library
+Version: 0.1.0
+Authors@R: c(
+    person("Kevin", "Ushey", email = "[email protected]", role = c("aut", "cre")),
+    person("Joel", "Falcou", role = "aut", comment = "Author of NT2"))
+Description: The 'Numerical Template Toolbox (NT2)' is an open source C++
+    library aimed at simplifying the development, debugging and optimization of
+    high-performance computing applications.
+URL: https://github.com/RcppCore/RcppNT2
+BugReports: https://github.com/RcppCore/RcppNT2/issues
+Depends:
+    R (>= 3.1.0)
+License: BSL-1.0
+SystemRequirements: C++11
+RoxygenNote: 5.0.1

NAMESPACE

@@ -0,0 +1,2 @@
+# Generated by roxygen2: do not edit by hand
+

R/plugin.R

@@ -0,0 +1,9 @@
+# Inline plugin used by 'Rcpp::sourceCpp()'.
+inlineCxxPlugin <- function() {
+  list(
+    env = list(
+      PKG_CXXFLAGS = paste("$(CXX1XSTD)")
+    ),
+    includes = "#include <RcppNt2.h>"
+  )
+}

README.md

@@ -0,0 +1,13 @@
+RcppNT2
+=======
+
+## Overview
+
+The [Numerical Template Toolbox (NT<sup>2</sup>)](https://github.com/jfalcou/nt2)
+is an Open Source C++ library aimed at simplifying the development, debugging
+and optimization of high-performance computing applications by providing a
+Matlab like syntax that eases the transition between prototype and actual
+application.
+
+`RcppNT2` bundles the `NT<sup>2</sup>` library, and provides a number of helper
+wrappers, to make it easy to use in your own R packages.

RcppNT2.Rproj

@@ -0,0 +1,21 @@
+Version: 1.0
+
+RestoreWorkspace: No
+SaveWorkspace: No
+AlwaysSaveHistory: Default
+
+EnableCodeIndexing: Yes
+UseSpacesForTab: Yes
+NumSpacesForTab: 2
+Encoding: UTF-8
+
+RnwWeave: Sweave
+LaTeX: pdfLaTeX
+
+AutoAppendNewline: Yes
+StripTrailingWhitespace: Yes
+
+BuildType: Package
+PackageUseDevtools: Yes
+PackageInstallArgs: --no-multiarch --with-keep.source
+PackageRoxygenize: rd,collate,namespace

inst/configure/configure.R

@@ -0,0 +1,70 @@
+NT2_URL <- "https://github.com/jfalcou/nt2"
+COMMIT  <- "f19e80f55cad6db21ccb3c7f216efecf45c91250"
+
+# Helpers
+pathProg <- function(name) {
+  prog <- Sys.which(name)
+  if (!nzchar(prog))
+    stop("No program named '", name, "' on the PATH!", call. = FALSE)
+  prog
+}
+
+cmakeDef <- function(name, value) {
+  sprintf("-D%s=%s", name, value)
+}
+
+cmake <- pathProg("cmake")
+make <- pathProg("make")
+git <- pathProg("git")
+patch <- pathProg("patch")
+
+# End helpers
+
+owd <- getwd()
+
+# Check out the 'nt2' sources
+if (!dir.exists("nt2"))
+  system2(git, c("clone", NT2_URL))
+setwd("nt2")
+
+# Check out the relevant commit
+system2(git, c("checkout", COMMIT))
+
+# Prepare installation directory
+if (dir.exists("install"))
+  unlink("install", recursive = TRUE)
+dir.create("install")
+installDir <- file.path(getwd(), "install")
+
+# Enter 'nt2' directory, and check out relevant commit
+if (dir.exists("build"))
+  unlink("build", recursive = TRUE)
+dir.create("build")
+setwd("build")
+
+# Call cmake to prepare the build
+system2(cmake, c(
+  "..",
+  cmakeDef("CMAKE_INSTALL_PREFIX", installDir)
+))
+
+# Call 'make', 'make install' to build and install
+system2(make)
+system2(make, "install")
+
+# Go back to parent directory
+setwd(owd)
+
+# Copy all of the relevant headers over
+includePath <- file.path(installDir, "include")
+from <- list.files(includePath, full.names = TRUE)
+to   <- file.path("inst/include")
+if (!dir.exists(to))
+  dir.create(to, recursive = TRUE)
+file.copy(from, to, recursive = TRUE)
+
+# Apply all of our patches
+patches <- list.files("patch", full.names = TRUE)
+for (patch in patches) {
+  system2(patch, c("-p1", "<", patch))
+}

inst/examples/boost-simd/boost-simd-capabilities.cpp

@@ -0,0 +1,42 @@
+// Print the SIMD capabilities of your processor.
+
+// [[Rcpp::depends(RcppNt2)]]
+#include <RcppNt2.h>
+using namespace RcppNt2;
+
+#include <Rcpp.h>
+using namespace Rcpp;
+
+#include <boost/simd/sdk/simd/extensions/meta/tags.hpp>
+#include <boost/simd/sdk/config/is_supported.hpp>
+#include <boost/config.hpp>
+
+// Try playing around with the '-march' flag to see what support is detected.
+// Note that most modern processors will implement instructions up to SSE3,
+// but certain AVX and FMA instructions are only available on newer CPUs.
+
+// [[Rcpp::export]]
+void simd_capabilities() {
+
+   using boost::simd::is_supported;
+   using namespace boost::simd::tag;
+
+   std::cout << "SIMD Capabilities\n"
+             << "=================\n\n";
+
+   std::cout << "AVX2:   " << is_supported<avx2_>()   << "\n"
+             << "AVX:    " << is_supported<avx_>()    << "\n"
+             << "FMA4:   " << is_supported<fma4_>()   << "\n"
+             << "FMA3:   " << is_supported<fma3_>()   << "\n"
+             << "SSE4a:  " << is_supported<sse4a_>()  << "\n"
+             << "SSE4_2: " << is_supported<sse4_2_>() << "\n"
+             << "SSE4_1: " << is_supported<sse4_1_>() << "\n"
+             << "SSE3:   " << is_supported<sse3_>()   << "\n"
+             << "SSE2:   " << is_supported<sse2_>()   << "\n"
+             << "SSE:    " << is_supported<sse_>()    << "\n";
+}
+
+/***R
+simd_capabilities()
+*/
+

inst/examples/boost-simd/boost-simd-dot.cpp

@@ -0,0 +1,61 @@
+// Demonstrates how Boost.SIMD could be used to compute the dot product
+// of two vectors, using a lower-level iteration over packs.
+//
+// See: http://nt2.metascale.fr/doc/html/tutorials/processing_data_the_simd_way.html
+
+// [[Rcpp::depends(RcppNt2)]]
+#include <RcppNt2.h>
+using namespace RcppNt2;
+
+#include <Rcpp.h>
+using namespace Rcpp;
+
+template <typename Value>
+Value simd_dot_impl(Value* first1, Value* last1, Value* first2)
+{
+   using boost::simd::sum;
+   using boost::simd::pack;
+
+   typedef pack<Value> packed_type;
+   packed_type tmp;
+
+   // Let's consider that (last1-first1) is divisible by the size of the pack.
+   while (first1 != last1)
+   {
+      // Load current values from the datasets
+      packed_type x1 = boost::simd::load<packed_type>(first1);
+      packed_type x2 = boost::simd::load<packed_type>(first2);
+
+      // Computation
+      tmp = tmp + x1 * x2;
+
+      // Advance to the next SIMD vector
+      first1 += packed_type::static_size;
+      first2 += packed_type::static_size;
+   }
+
+   return sum(tmp);
+}
+
+// [[Rcpp::export]]
+double simd_dot(NumericVector lhs, NumericVector rhs)
+{
+   return simd_dot_impl(
+      REAL(lhs),
+      REAL(lhs) + lhs.size(),
+      REAL(rhs)
+   );
+}
+
+/*** R
+set.seed(123)
+lhs <- rnorm(1024 * 1000)
+rhs <- rnorm(1024 * 1000)
+stopifnot(all.equal(simd_dot(lhs, rhs), sum(lhs * rhs)))
+
+library(microbenchmark)
+microbenchmark(
+   simd = simd_dot(lhs, rhs),
+   R = sum(lhs * rhs)
+)
+*/

inst/examples/boost-simd/boost-simd-for-each.cpp

@@ -0,0 +1,41 @@
+// Showcases how a stateful functor can be used with `simdFor()`,
+// for arbitrary operations over a range of values.
+
+// [[Rcpp::depends(RcppParallel)]]
+#define RCPP_PARALLEL_USE_SIMD
+#include <RcppParallel.h>
+using namespace RcppParallel;
+
+#include <Rcpp.h>
+using namespace Rcpp;
+
+// Product of squared deviations
+class Accumulator
+{
+public:
+   
+   Accumulator() : result_(1.0) {}
+   
+   template <typename T>
+   void operator()(const T& data)
+   {
+      result_ *= boost::simd::prod(data);
+   }
+   
+   operator double() const {
+      return result_;
+   }
+   
+private:
+   double result_;
+};
+
+// [[Rcpp::export]]
+double simdProd(NumericVector x) {
+   return simdFor(x.begin(), x.end(), Accumulator());
+}
+
+/*** R
+x <- 1:16
+stopifnot(all.equal(prod(x), simdProd(x)))
+*/

inst/examples/boost-simd/boost-simd-hello-world.cpp

@@ -0,0 +1,30 @@
+// The 'hello world' of Boost.SIMD, showing how packs can be
+// used and manipulated at a low level.
+//
+// See: http://nt2.metascale.fr/doc/html/tutorials/simd_hello_world.html
+
+// [[Rcpp::depends(RcppParallel)]]
+#define RCPP_PARALLEL_USE_SIMD
+#include <RcppParallel.h>
+using namespace RcppParallel;
+
+#include <Rcpp.h>
+using namespace Rcpp;
+
+// [[Rcpp::export]]
+void HelloWorld()
+{
+   typedef boost::simd::pack<float> p_t;
+   
+   p_t res;
+   p_t u(10);
+   p_t r = boost::simd::splat<p_t>(11);
+   
+   res = (u + r) * 2.f;
+   
+   Rcout << res << std::endl;
+}
+
+/*** R
+HelloWorld()
+*/

inst/examples/boost-simd/boost-simd-map-reduce.cpp

@@ -0,0 +1,54 @@
+// Shows how 'simdMapReduce()' can be used to efficiently
+// transform and accumulate values.
+
+// [[Rcpp::depends(RcppParallel)]]
+#define RCPP_PARALLEL_USE_SIMD
+#include <RcppParallel.h>
+using namespace RcppParallel;
+
+#include <Rcpp.h>
+using namespace Rcpp;
+
+class SumOfSquaresReducer
+{
+public:
+   
+   explicit SumOfSquaresReducer(double mean)
+      : mean_(mean)
+   {}
+   
+   template <typename T>
+   void map(const T& self, T* pBuffer)
+   {
+      *pBuffer += boost::simd::sqr(self - mean_);
+   }
+   
+   template <typename T, typename U>
+   void reduce(const T& data, U* pBuffer)
+   {
+      *pBuffer += boost::simd::sum(data);
+   }
+   
+private:
+   double mean_;
+};
+
+// [[Rcpp::export]]
+double simdVar(NumericVector x)
+{
+   double total = simdReduce(x.begin(), x.end(), 0.0, simd_ops::plus());
+   double n = x.size();
+   double mean = total / n;
+   
+   double ssq = simdMapReduce(x.begin(), x.end(), 0.0, SumOfSquaresReducer(mean));
+   
+   return ssq / (n - 1);
+}
+
+/*** R
+set.seed(123)
+x <- rnorm(1024)
+stopifnot(all.equal(var(x), simdVar(x)))
+library(microbenchmark)
+microbenchmark(var(x), simdVar(x))
+*/