add and update samples for CUDA 11.5

Samples/MC_EstimatePiInlineP/src/main.cpp

@@ -0,0 +1,254 @@
+/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+///////////////////////////////////////////////////////////////////////////////
+// Monte Carlo: Estimate Pi
+// ========================
+//
+// This sample demonstrates a very simple Monte Carlo estimation for Pi.
+//
+// This file, main.cpp, contains the setup information to run the test, for
+// example parsing the command line and integrating this sample with the
+// samples framework. As such it is perhaps less interesting than the guts of
+// the sample. Readers wishing to skip the clutter are advised to skip straight
+// to Test.operator() in test.cpp.
+///////////////////////////////////////////////////////////////////////////////
+
+#include <cuda_runtime.h>
+#include <helper_cuda.h>
+
+#include <iomanip>
+#include <iostream>
+#include <stdexcept>
+
+#include "../inc/test.h"
+
+// SDK information
+static const char *printfFile = "MonteCarloEstimatePiInlineP.txt";
+
+// Forward declarations
+void showHelp(const int argc, const char **argv);
+template <typename Real>
+void runTest(int argc, const char **argv);
+
+int main(int argc, char **argv) {
+  using std::invalid_argument;
+  using std::string;
+
+  // Open the log file
+  printf("Monte Carlo Estimate Pi (with inline PRNG)\n");
+  printf("==========================================\n\n");
+
+  // If help flag is set, display help and exit immediately
+  if (checkCmdLineFlag(argc, (const char **)argv, "help")) {
+    printf("Displaying help on console\n");
+    showHelp(argc, (const char **)argv);
+    exit(EXIT_SUCCESS);
+  }
+
+  // Check the precision (checked against the device capability later)
+  try {
+    char *value;
+
+    if (getCmdLineArgumentString(argc, (const char **)argv, "precision",
+                                 &value)) {
+      // Check requested precision is valid
+      string prec(value);
+
+      if (prec.compare("single") == 0 || prec.compare("\"single\"") == 0) {
+        runTest<float>(argc, (const char **)argv);
+      } else if (prec.compare("double") == 0 ||
+                 prec.compare("\"double\"") == 0) {
+        runTest<double>(argc, (const char **)argv);
+      } else {
+        printf(
+            "specified precision (%s) is invalid, must be \"single\" or "
+            "\"double\".\n",
+            value);
+        throw invalid_argument("precision");
+      }
+    } else {
+      runTest<float>(argc, (const char **)argv);
+    }
+  } catch (invalid_argument &e) {
+    printf("invalid command line argument (%s)\n", e.what());
+    exit(EXIT_FAILURE);
+  }
+
+  // Finish
+  exit(EXIT_SUCCESS);
+}
+
+template <typename Real>
+void runTest(int argc, const char **argv) {
+  using std::invalid_argument;
+  using std::runtime_error;
+
+  try {
+    Test<Real> test;
+    int deviceCount = 0;
+    cudaError_t cudaResult = cudaSuccess;
+
+    // by default specify GPU Device == 0
+    test.device = 0;
+
+    // Get number of available devices
+    cudaResult = cudaGetDeviceCount(&deviceCount);
+
+    if (cudaResult != cudaSuccess) {
+      printf("could not get device count (%s).\n",
+             cudaGetErrorString(cudaResult));
+      throw runtime_error("cudaGetDeviceCount");
+    }
+
+    // (default parameters)
+    test.numSims = k_sims_qa;
+    test.threadBlockSize = k_bsize_qa;
+    test.seed = k_seed_def;
+
+    {
+      char *value = 0;
+
+      if (getCmdLineArgumentString(argc, argv, "device", &value)) {
+        test.device = (int)atoi(value);
+
+        if (test.device >= deviceCount) {
+          printf(
+              "invalid target device specified on command line (device %d does "
+              "not exist).\n",
+              test.device);
+          throw invalid_argument("device");
+        }
+      } else {
+        test.device = gpuGetMaxGflopsDeviceId();
+      }
+
+      if (getCmdLineArgumentString(argc, argv, "sims", &value)) {
+        test.numSims = (unsigned int)atoi(value);
+        printf("number of simulations = %d\n", test.numSims);
+
+        if (test.numSims < k_sims_min || test.numSims > k_sims_max) {
+          printf(
+              "specified number of simulations (%d) is invalid, must be "
+              "between %d and %d.\n",
+              test.numSims, k_sims_min, k_sims_max);
+          throw invalid_argument("sims");
+        }
+      } else {
+        test.numSims = k_sims_def;
+      }
+
+      if (getCmdLineArgumentString(argc, argv, "block-size", &value)) {
+        // Determine max threads per block
+        cudaDeviceProp deviceProperties;
+        cudaResult = cudaGetDeviceProperties(&deviceProperties, test.device);
+
+        if (cudaResult != cudaSuccess) {
+          printf("unable to get device properties for device %d.\n",
+                 test.device);
+          throw runtime_error("cudaGetDeviceProperties");
+        }
+
+        // Check requested size is valid
+        test.threadBlockSize = (unsigned int)atoi(value);
+        printf("block size = %d\n", test.threadBlockSize);
+
+        if (test.threadBlockSize < k_bsize_min ||
+            test.threadBlockSize > static_cast<unsigned int>(
+                                       deviceProperties.maxThreadsPerBlock)) {
+          printf(
+              "specified block size (%d) is invalid, must be between %d and %d "
+              "for device %d.\n",
+              test.threadBlockSize, k_bsize_min,
+              deviceProperties.maxThreadsPerBlock, test.device);
+          throw invalid_argument("block-size");
+        }
+
+        if (test.threadBlockSize & test.threadBlockSize - 1) {
+          printf(
+              "specified block size (%d) is invalid, must be a power of two "
+              "(see reduction function).\n",
+              test.threadBlockSize);
+          throw invalid_argument("block-size");
+        }
+      } else {
+        test.threadBlockSize = k_bsize_def;
+      }
+
+      if (getCmdLineArgumentString(argc, argv, "seed", &value)) {
+        // Check requested seed is valid
+        test.seed = (unsigned int)atoi(value);
+        printf("seed = %d\n", test.seed);
+
+        if (test.seed == 0) {
+          printf("specified seed (%d) is invalid, must be non-zero.\n",
+                 test.seed);
+          throw invalid_argument("seed");
+        }
+      } else {
+        test.seed = k_seed_def;
+      }
+    }
+
+    // Execute
+    test();
+  } catch (invalid_argument &e) {
+    printf("invalid command line argument (%s)\n", e.what());
+    exit(EXIT_FAILURE);
+  } catch (runtime_error &e) {
+    printf("runtime error (%s)\n", e.what());
+    exit(EXIT_FAILURE);
+  }
+}
+
+void showHelp(int argc, const char **argv) {
+  using std::cout;
+  using std::endl;
+  using std::left;
+  using std::setw;
+
+  if (argc > 0) {
+    cout << endl << argv[0] << endl;
+  }
+
+  cout << endl << "Syntax:" << endl;
+  cout << left;
+  cout << "    " << setw(20) << "--device=<device>"
+       << "Specify device to use for execution" << endl;
+  cout << "    " << setw(20) << "--sims=<N>"
+       << "Specify number of Monte Carlo simulations" << endl;
+  cout << "    " << setw(20) << "--block-size=<N>"
+       << "Specify number of threads per block" << endl;
+  cout << "    " << setw(20) << "--seed=<N>"
+       << "Specify the seed to use for the random number generator" << endl;
+  cout << "    " << setw(20) << "--precision=<P>"
+       << "Specify the precision (\"single\" or \"double\")" << endl;
+  cout << endl;
+  cout << "    " << setw(20) << "--noprompt"
+       << "Skip prompt before exit" << endl;
+  cout << endl;
+}

Samples/MC_EstimatePiInlineP/src/piestimator.cu

@@ -0,0 +1,283 @@
+/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "../inc/piestimator.h"
+
+#include <string>
+#include <vector>
+#include <numeric>
+#include <stdexcept>
+#include <typeinfo>
+#include <cuda_runtime.h>
+#include <cooperative_groups.h>
+
+namespace cg = cooperative_groups;
+#include <curand_kernel.h>
+
+using std::string;
+using std::vector;
+
+// RNG init kernel
+__global__ void initRNG(curandState *const rngStates, const unsigned int seed) {
+  // Determine thread ID
+  unsigned int tid = blockIdx.x * blockDim.x + threadIdx.x;
+
+  // Initialise the RNG
+  curand_init(seed, tid, 0, &rngStates[tid]);
+}
+
+__device__ unsigned int reduce_sum(unsigned int in, cg::thread_block cta) {
+  extern __shared__ unsigned int sdata[];
+
+  // Perform first level of reduction:
+  // - Write to shared memory
+  unsigned int ltid = threadIdx.x;
+
+  sdata[ltid] = in;
+  cg::sync(cta);
+
+  // Do reduction in shared mem
+  for (unsigned int s = blockDim.x / 2; s > 0; s >>= 1) {
+    if (ltid < s) {
+      sdata[ltid] += sdata[ltid + s];
+    }
+
+    cg::sync(cta);
+  }
+
+  return sdata[0];
+}
+
+__device__ inline void getPoint(float &x, float &y, curandState &state) {
+  x = curand_uniform(&state);
+  y = curand_uniform(&state);
+}
+__device__ inline void getPoint(double &x, double &y, curandState &state) {
+  x = curand_uniform_double(&state);
+  y = curand_uniform_double(&state);
+}
+
+// Estimator kernel
+template <typename Real>
+__global__ void computeValue(unsigned int *const results,
+                             curandState *const rngStates,
+                             const unsigned int numSims) {
+  // Handle to thread block group
+  cg::thread_block cta = cg::this_thread_block();
+  // Determine thread ID
+  unsigned int bid = blockIdx.x;
+  unsigned int tid = blockIdx.x * blockDim.x + threadIdx.x;
+  unsigned int step = gridDim.x * blockDim.x;
+
+  // Initialise the RNG
+  curandState localState = rngStates[tid];
+
+  // Count the number of points which lie inside the unit quarter-circle
+  unsigned int pointsInside = 0;
+
+  for (unsigned int i = tid; i < numSims; i += step) {
+    Real x;
+    Real y;
+    getPoint(x, y, localState);
+    Real l2norm2 = x * x + y * y;
+
+    if (l2norm2 < static_cast<Real>(1)) {
+      pointsInside++;
+    }
+  }
+
+  // Reduce within the block
+  pointsInside = reduce_sum(pointsInside, cta);
+
+  // Store the result
+  if (threadIdx.x == 0) {
+    results[bid] = pointsInside;
+  }
+}
+
+template <typename Real>
+PiEstimator<Real>::PiEstimator(unsigned int numSims, unsigned int device,
+                               unsigned int threadBlockSize, unsigned int seed)
+    : m_numSims(numSims),
+      m_device(device),
+      m_threadBlockSize(threadBlockSize),
+      m_seed(seed) {}
+
+template <typename Real>
+Real PiEstimator<Real>::operator()() {
+  cudaError_t cudaResult = cudaSuccess;
+  struct cudaDeviceProp deviceProperties;
+  struct cudaFuncAttributes funcAttributes;
+
+  // Get device properties
+  cudaResult = cudaGetDeviceProperties(&deviceProperties, m_device);
+
+  if (cudaResult != cudaSuccess) {
+    string msg("Could not get device properties: ");
+    msg += cudaGetErrorString(cudaResult);
+    throw std::runtime_error(msg);
+  }
+
+  // Check precision is valid
+  if (typeid(Real) == typeid(double) &&
+      (deviceProperties.major < 1 ||
+       (deviceProperties.major == 1 && deviceProperties.minor < 3))) {
+    throw std::runtime_error("Device does not have double precision support");
+  }
+
+  // Attach to GPU
+  cudaResult = cudaSetDevice(m_device);
+
+  if (cudaResult != cudaSuccess) {
+    string msg("Could not set CUDA device: ");
+    msg += cudaGetErrorString(cudaResult);
+    throw std::runtime_error(msg);
+  }
+
+  // Determine how to divide the work between cores
+  dim3 block;
+  dim3 grid;
+  block.x = m_threadBlockSize;
+  grid.x = (m_numSims + m_threadBlockSize - 1) / m_threadBlockSize;
+
+  // Aim to launch around ten or more times as many blocks as there
+  // are multiprocessors on the target device.
+  unsigned int blocksPerSM = 10;
+  unsigned int numSMs = deviceProperties.multiProcessorCount;
+
+  while (grid.x > 2 * blocksPerSM * numSMs) {
+    grid.x >>= 1;
+  }
+
+  // Get initRNG function properties and check the maximum block size
+  cudaResult = cudaFuncGetAttributes(&funcAttributes, initRNG);
+
+  if (cudaResult != cudaSuccess) {
+    string msg("Could not get function attributes: ");
+    msg += cudaGetErrorString(cudaResult);
+    throw std::runtime_error(msg);
+  }
+
+  if (block.x > (unsigned int)funcAttributes.maxThreadsPerBlock) {
+    throw std::runtime_error(
+        "Block X dimension is too large for initRNG kernel");
+  }
+
+  // Get computeValue function properties and check the maximum block size
+  cudaResult = cudaFuncGetAttributes(&funcAttributes, computeValue<Real>);
+
+  if (cudaResult != cudaSuccess) {
+    string msg("Could not get function attributes: ");
+    msg += cudaGetErrorString(cudaResult);
+    throw std::runtime_error(msg);
+  }
+
+  if (block.x > (unsigned int)funcAttributes.maxThreadsPerBlock) {
+    throw std::runtime_error(
+        "Block X dimension is too large for computeValue kernel");
+  }
+
+  // Check the dimensions are valid
+  if (block.x > (unsigned int)deviceProperties.maxThreadsDim[0]) {
+    throw std::runtime_error("Block X dimension is too large for device");
+  }
+
+  if (grid.x > (unsigned int)deviceProperties.maxGridSize[0]) {
+    throw std::runtime_error("Grid X dimension is too large for device");
+  }
+
+  // Allocate memory for RNG states
+  curandState *d_rngStates = 0;
+  cudaResult =
+      cudaMalloc((void **)&d_rngStates, grid.x * block.x * sizeof(curandState));
+
+  if (cudaResult != cudaSuccess) {
+    string msg("Could not allocate memory on device for RNG states: ");
+    msg += cudaGetErrorString(cudaResult);
+    throw std::runtime_error(msg);
+  }
+
+  // Allocate memory for result
+  // Each thread block will produce one result
+  unsigned int *d_results = 0;
+  cudaResult = cudaMalloc((void **)&d_results, grid.x * sizeof(unsigned int));
+
+  if (cudaResult != cudaSuccess) {
+    string msg("Could not allocate memory on device for partial results: ");
+    msg += cudaGetErrorString(cudaResult);
+    throw std::runtime_error(msg);
+  }
+
+  // Initialise RNG
+  initRNG<<<grid, block>>>(d_rngStates, m_seed);
+
+  // Count the points inside unit quarter-circle
+  computeValue<Real><<<grid, block, block.x * sizeof(unsigned int)>>>(
+      d_results, d_rngStates, m_numSims);
+
+  // Copy partial results back
+  vector<unsigned int> results(grid.x);
+  cudaResult = cudaMemcpy(&results[0], d_results, grid.x * sizeof(unsigned int),
+                          cudaMemcpyDeviceToHost);
+
+  if (cudaResult != cudaSuccess) {
+    string msg("Could not copy partial results to host: ");
+    msg += cudaGetErrorString(cudaResult);
+    throw std::runtime_error(msg);
+  }
+
+  // Complete sum-reduction on host
+  Real value =
+      static_cast<Real>(std::accumulate(results.begin(), results.end(), 0));
+
+  // Determine the proportion of points inside the quarter-circle,
+  // i.e. the area of the unit quarter-circle
+  value /= m_numSims;
+
+  // Value is currently an estimate of the area of a unit quarter-circle, so we
+  // can scale to a full circle by multiplying by four. Now since the area of a
+  // circle is pi * r^2, and r is one, the value will be an estimate for the
+  // value of pi.
+  value *= 4;
+
+  // Cleanup
+  if (d_rngStates) {
+    cudaFree(d_rngStates);
+    d_rngStates = 0;
+  }
+
+  if (d_results) {
+    cudaFree(d_results);
+    d_results = 0;
+  }
+
+  return value;
+}
+
+// Explicit template instantiation
+template class PiEstimator<float>;
+template class PiEstimator<double>;

Samples/MC_EstimatePiInlineP/src/test.cpp

@@ -0,0 +1,112 @@
+/* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *  * Neither the name of NVIDIA CORPORATION nor the names of its
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+#include "../inc/test.h"
+
+#include <sstream>
+#include <iomanip>
+#include <stdexcept>
+#include <memory>
+#include <iostream>
+#include <cassert>
+#include <typeinfo>
+#include <stdio.h>
+#include <helper_timer.h>
+#include <math.h>
+#include <cuda_runtime.h>
+
+#include "../inc/piestimator.h"
+
+template <typename Real>
+bool Test<Real>::operator()() {
+  using std::endl;
+  using std::setw;
+  using std::stringstream;
+
+  StopWatchInterface *timer = NULL;
+  sdkCreateTimer(&timer);
+
+  // Get device properties
+  struct cudaDeviceProp deviceProperties;
+  cudaError_t cudaResult = cudaGetDeviceProperties(&deviceProperties, device);
+
+  if (cudaResult != cudaSuccess) {
+    std::string msg("Could not get device properties: ");
+    msg += cudaGetErrorString(cudaResult);
+    throw std::runtime_error(msg);
+  }
+
+  // Evaluate on GPU
+  printf("Estimating Pi on GPU (%s)\n\n", deviceProperties.name);
+  PiEstimator<Real> estimator(numSims, device, threadBlockSize, seed);
+  sdkStartTimer(&timer);
+  Real result = estimator();
+  sdkStopTimer(&timer);
+  elapsedTime = sdkGetAverageTimerValue(&timer) / 1000.0f;
+
+  // Tolerance to compare result with expected
+  // This is just to check that nothing has gone very wrong with the
+  // test, the actual accuracy of the result depends on the number of
+  // Monte Carlo trials
+  const Real tolerance = static_cast<Real>(0.01);
+
+  // Display results
+  Real abserror = fabs(result - static_cast<Real>(PI));
+  Real relerror = abserror / static_cast<float>(PI);
+  printf("Precision:      %s\n",
+         (typeid(Real) == typeid(double)) ? "double" : "single");
+  printf("Number of sims: %d\n", numSims);
+  printf("Tolerance:      %e\n", tolerance);
+  printf("GPU result:     %e\n", result);
+  printf("Expected:       %e\n", PI);
+  printf("Absolute error: %e\n", abserror);
+  printf("Relative error: %e\n\n", relerror);
+
+  // Check result
+  if (relerror > tolerance) {
+    printf("computed result (%e) does not match expected result (%e).\n",
+           result, PI);
+    pass = false;
+  } else {
+    pass = true;
+  }
+
+  // Print results
+  printf(
+      "MonteCarloEstimatePiInlineP, Performance = %.2f sims/s, Time = "
+      "%.2f(ms), NumDevsUsed = %u, Blocksize = %u\n",
+      numSims / elapsedTime, elapsedTime * 1000.0f, 1, threadBlockSize);
+
+  sdkDeleteTimer(&timer);
+
+  return pass;
+}
+
+// Explicit template instantiation
+template struct Test<float>;
+template struct Test<double>;