[WIP] Parallel Prototype

Jenkinsfile

@@ -150,7 +150,7 @@ pipeline {
         stage('Verify changes') {
             agent { label 'linux' }
             steps {
-                script {         
+                script {
 
                     retry(3) { checkout scm }
                     sh 'git clean -xffd'
@@ -205,7 +205,7 @@ pipeline {
                         deleteDir()
                         unstash 'MathSetup'
                         sh "echo CXX=${MPICXX} >> make/local"
-                        sh "echo CXX_TYPE=gcc >> make/local"                        
+                        sh "echo CXX_TYPE=gcc >> make/local"
                         sh "echo STAN_MPI=true >> make/local"
                         runTests("test/unit")
                     }
@@ -265,6 +265,7 @@ pipeline {
                     steps {
                         deleteDir()
                         unstash 'MathSetup'
+                        sh "export STAN_NUM_THREADS=2"
                         sh "echo CXX=${env.CXX} -Werror > make/local"
                         sh "echo CPPFLAGS+=-DSTAN_THREADS >> make/local"
                         runTests("test/unit -f thread")
@@ -288,6 +289,7 @@ pipeline {
                     steps {
                         deleteDirWin()
                         unstash 'MathSetup'
+                        bat "setx STAN_NUM_THREADS 2"
                         bat "echo CXX=${env.CXX} -Werror > make/local"
                         bat "echo CXXFLAGS+=-DSTAN_THREADS >> make/local"
                         runTestsWin("test/unit -f thread")
@@ -297,7 +299,7 @@ pipeline {
             }
         }
         stage('Additional merge tests') {
-            when { 
+            when {
                 allOf {
                     anyOf {
                         branch 'develop'
@@ -334,12 +336,12 @@ pipeline {
             }
         }
         stage('Upstream tests') {
-            when { 
+            when {
                 allOf {
-                    expression { 
-                        env.BRANCH_NAME ==~ /PR-\d+/ 
+                    expression {
+                        env.BRANCH_NAME ==~ /PR-\d+/
                     }
-                    expression { 
+                    expression {
                         !skipRemainingStages
                     }
                 }

make/compiler_flags

@@ -271,7 +271,7 @@ print-compiler-flags:
 	@echo '  - SUNDIALS                    ' $(SUNDIALS)
 	@echo '  - TBB                         ' $(TBB)
 	@echo '  - GTEST                       ' $(GTEST)
-	@echo '  - STAN_THREADS                ' $(STAN_THREADS) 
+	@echo '  - STAN_THREADS                ' $(STAN_THREADS)
 	@echo '  - STAN_OPENCL                 ' $(STAN_OPENCL)
 	@echo '  - STAN_MPI                    ' $(STAN_MPI)
 	@echo '  Compiler flags (each can be overriden separately):'

stan/math/prim/functor.hpp

@@ -1,6 +1,7 @@
 #ifndef STAN_MATH_PRIM_FUNCTOR_HPP
 #define STAN_MATH_PRIM_FUNCTOR_HPP
 
+#include <stan/math/prim/functor/apply.hpp>
 #include <stan/math/prim/functor/coupled_ode_observer.hpp>
 #include <stan/math/prim/functor/coupled_ode_system.hpp>
 #include <stan/math/prim/functor/finite_diff_gradient.hpp>
@@ -10,12 +11,14 @@
 #include <stan/math/prim/functor/finite_diff_hessian_helper.hpp>
 #include <stan/math/prim/functor/integrate_1d.hpp>
 #include <stan/math/prim/functor/integrate_ode_rk45.hpp>
+#include <stan/math/prim/functor/left_fold.hpp>
 #include <stan/math/prim/functor/map_rect.hpp>
 #include <stan/math/prim/functor/map_rect_combine.hpp>
 #include <stan/math/prim/functor/map_rect_concurrent.hpp>
 #include <stan/math/prim/functor/map_rect_reduce.hpp>
 #include <stan/math/prim/functor/mpi_cluster.hpp>
 #include <stan/math/prim/functor/mpi_command.hpp>
 #include <stan/math/prim/functor/mpi_distributed_apply.hpp>
+#include <stan/math/prim/functor/reduce_sum.hpp>
 
 #endif

stan/math/prim/functor/apply.hpp

@@ -0,0 +1,50 @@
+#ifndef STAN_MATH_PRIM_SCAL_FUNCTOR_APPLY_HPP
+#define STAN_MATH_PRIM_SCAL_FUNCTOR_APPLY_HPP
+
+#include <functional>
+#include <tuple>
+#include <utility>
+
+namespace stan {
+namespace math {
+/*
+ * Invoke the functor f with arguments given in t and indexed in the index
+ * sequence I
+ *
+ * @tparam F Type of functor
+ * @tparam Tuple Type of tuple containing arguments
+ * @tparam I Index sequence going from 0 to std::tuple_size<T>::value - 1
+ * inclusive
+ * @param f functor callable
+ * @param t tuple of arguments
+ * @param i placeholder variable for index sequence
+ */
+template <class F, class Tuple, std::size_t... I>
+constexpr decltype(auto) apply_impl(F&& f, Tuple&& t,
+                                    std::index_sequence<I...> i) {
+  return f(std::forward<decltype(std::get<I>(t))>(std::get<I>(t))...);
+}
+
+/*
+ * Call the functor f with the tuple of arguments t, like:
+ *
+ * f(std::get<0>(t), std::get<1>(t), ...)
+ *
+ * TODO: replace this with implementation in C++ std when C++17 is available
+ *
+ * @tparam F Type of functor
+ * @tparam Tuple Type of tuple containing arguments
+ * @param f functor callable
+ * @param t tuple of arguments
+ */
+template <class F, class Tuple>
+constexpr decltype(auto) apply(F&& f, Tuple&& t) {
+  return apply_impl(std::forward<F>(f), std::forward<Tuple>(t),
+                    std::make_index_sequence<
+                        std::tuple_size<std::remove_reference_t<Tuple>>{}>{});
+}
+
+}  // namespace math
+}  // namespace stan
+
+#endif

stan/math/prim/functor/left_fold.hpp

@@ -0,0 +1,41 @@
+#ifndef STAN_MATH_PRIM_SCAL_FUNCTOR_LEFT_FOLD_HPP
+#define STAN_MATH_PRIM_SCAL_FUNCTOR_LEFT_FOLD_HPP
+
+#include <stan/math/prim/meta.hpp>
+#include <functional>
+#include <tuple>
+#include <utility>
+
+namespace stan {
+namespace math {
+
+/**
+ * Performs a left fold on a tuple with a given operation
+ * @tparam index The index in this recursion for accessing tuple elemenTypes
+ * @tparam Op An operation to perform on the tuple elemenTypes
+ * @tparam Types types of tuple elements
+ * @param op operation to perform on individual tuple elements
+ * @param t A tuple to iterate over
+ */
+template <size_t index, class Op, class... Types>
+constexpr auto left_fold(Op op, const std::tuple<Types...>& t) {
+  if (index == sizeof...(Types) - 1) {
+    return std::get<index>(t);
+  } else {
+    return op(std::get<index>(t), left_fold<1 + index>(op, t));
+  }
+}
+
+/**
+ * Sum the elements of a tuple
+ * @tparam Types types of the tuple's elements
+ * @param t tuple whose elements are to be summed
+ */
+template <typename... Types, require_stan_scalar_t<Types>...>
+constexpr auto sum(const std::tuple<Types...>& t) {
+  return left_fold<0>(std::plus<>{}, t);
+}
+
+}  // namespace math
+}  // namespace stan
+#endif