Refactor Drivers (#6)

* refactor drivers

Author: Dando18

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "tpl/kokkos"]
+	path = tpl/kokkos
+	url = https://github.com/kokkos/kokkos

drivers/README.md

@@ -79,4 +79,7 @@ of threads as the first command line argument i.e. `./a.out 4`.
 
 Make sure you are running in a proper environment for the tests you want to run.
 For example, have a GPU for cuda tests or multiple nodes for MPI. Do not 
-execute `run-all.py` on a login node without the `--dry` flag.
+execute `run-all.py` on a login node without the `--dry` flag.
+
+MPI benchmarks require the correct result to be returned on rank 0. The initial
+data distribution varies by problem.

drivers/cpp/KokkosCMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.16)
+project(KokkosBenchmark)
+
+if (NOT DRIVER_PATH)
+    message(FATAL_ERROR "DRIVER_PATH not set")
+endif()
+
+if (NOT DRIVER_SRC_FILE)
+    message(FATAL_ERROR "DRIVER_SRC_FILE not set")
+endif()
+
+set(default_build_type "RelWithDebInfo")
+set(Kokkos_DIR ${DRIVER_PATH}/../tpl/kokkos/build)
+message(STATUS "Kokkos_DIR: ${Kokkos_DIR}")
+find_package(Kokkos REQUIRED)
+add_compile_definitions(USE_KOKKOS)
+
+add_executable(a.out ${DRIVER_PATH}/${DRIVER_SRC_FILE})
+target_link_libraries(a.out Kokkos::kokkos)
+target_link_libraries(a.out ${DRIVER_PATH}/cpp/models/kokkos-driver.o)
+target_include_directories(a.out PRIVATE ${DRIVER_PATH}/cpp)
+target_include_directories(a.out PRIVATE ${DRIVER_PATH}/cpp/models)
+target_include_directories(a.out PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})

drivers/cpp/Makefile

@@ -1,20 +1,39 @@
 CXX = g++
 MPICXX = mpicxx
 CXX_FLAGS = -std=c++17 -O3
+Kokkos_PATH ?= ../../tpl/kokkos/build
 
+SERIAL_DRIVERS = $(patsubst %.cc,%.o, $(wildcard */*serial-driver.cc))
 OMP_DRIVERS = $(patsubst %.cc,%.o, $(wildcard */*omp-driver.cc))
 MPI_DRIVERS = $(patsubst %.cc,%.o, $(wildcard */*mpi-driver.cc))
+MPI_OMP_DRIVERS = $(patsubst %.cc,%.o, $(wildcard */*mpi-omp-driver.cc))
+CUDA_DRIVERS = $(patsubst %.cu,%.o, $(wildcard */*cuda-driver.cu))
+KOKKOS_DRIVERS = $(patsubst %.cc,%.o, $(wildcard */*kokkos-driver.cc))
 
-all: $(OMP_DRIVERS) $(MPI_DRIVERS)
+ALL_DRIVERS = $(SERIAL_DRIVERS) $(OMP_DRIVERS) $(MPI_DRIVERS) $(MPI_OMP_DRIVERS) $(CUDA_DRIVERS) $(KOKKOS_DRIVERS)
+
+all: $(ALL_DRIVERS)
 
 %.o: %.cc
 	$(CXX) $(CXX_FLAGS) -o $@ -c $<
 
+%serial-driver.o: %serial-driver.cc
+	$(CXX) $(CXX_FLAGS) -o $@ -c $<
+
 %omp-driver.o: %omp-driver.cc
 	$(CXX) $(CXX_FLAGS) -fopenmp -o $@ -c $<
 
 %mpi-driver.o: %mpi-driver.cc
 	$(MPICXX) $(CXX_FLAGS) -o $@ -c $<
 
+%mpi-omp-driver.o: %mpi-omp-driver.cc
+	$(MPICXX) $(CXX_FLAGS) -fopenmp -o $@ -c $<
+
+%cuda-driver.o: %cuda-driver.cu
+	nvcc -std=c++17 -O3 -o $@ -c $<
+
+%kokkos-driver.o: %kokkos-driver.cc
+	$(CXX) $(CXX_FLAGS) -I$(Kokkos_PATH)/include -L$(Kokkos_PATH)/lib64 -fopenmp -o $@ -c $<
+
 clean:
-	rm -f $(OMP_DRIVERS) $(MPI_DRIVERS)
+	rm -f $(ALL_DRIVERS)

drivers/cpp/benchmarks/scan/28_scan_sum_of_prefix_sum_array/baseline.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <numeric>
+#include <vector>
+
+/* Compute the prefix sum array of the vector x and return its sum.
+   Example:
+
+   input: [-7, 2, 1, 9, 4, 8]
+   output: 15
+*/
+double correctSumOfPrefixSum(std::vector<double> const& x) {
+    std::vector<double> prefixSum(x.size());
+    std::inclusive_scan(x.begin(), x.end(), prefixSum.begin());
+    return std::accumulate(prefixSum.begin(), prefixSum.end(), 0.0);
+}

drivers/cpp/benchmarks/scan/28_scan_sum_of_prefix_sum_array/cpu.cc

@@ -0,0 +1,70 @@
+// Driver for 1_scan_sum_of_prefix_sum
+// /* Compute the prefix sum array of the vector x and return its sum.
+//    Example:
+// 
+//    input: [-7, 2, 1, 9, 4, 8]
+//    output: 15
+// */
+// double sumOfPrefixSum(std::vector<double> const& x) {
+
+#include <algorithm>
+#include <numeric>
+#include <random>
+#include <vector>
+
+#include "baseline.hpp"
+#include "utilities.hpp"
+#include "generated-code.hpp"   // code generated by LLM
+
+
+struct Context {
+    std::vector<double> x;
+};
+
+void reset(Context *ctx) {
+    fillRand(ctx->x, -100.0, 100.0);
+}
+
+Context *init() {
+    Context *ctx = new Context();
+    ctx->x.resize(1 << 20);
+    reset(ctx);
+    return ctx;
+}
+
+void compute(Context *ctx) {
+    double val = sumOfPrefixSum(ctx->x);
+    (void) val;
+}
+
+void best(Context *ctx) {
+    double val = correctSumOfPrefixSum(ctx->x);
+    (void) val;
+}
+
+bool validate(Context *ctx) {
+
+    const size_t numTries = 5;
+    for (int i = 0; i < numTries; i += 1) {
+        std::vector<double> input(2048);
+        fillRand(input, -100.0, 100.0);
+
+        // compute correct result
+        double correctResult = correctSumOfPrefixSum(input);
+
+        // compute test result
+        double testResult = sumOfPrefixSum(input);
+        
+        if (std::fabs(correctResult - testResult) > 1e-5) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void destroy(Context *ctx) {
+    delete ctx;
+}
+
+

drivers/cpp/benchmarks/scan/28_scan_sum_of_prefix_sum_array/kokkos.cc

@@ -0,0 +1,76 @@
+// Driver for 28_scan_sum_of_prefix_sum
+// /* Compute the prefix sum array of the vector x and return its sum.
+//    Example:
+// 
+//    input: [-7, 2, 1, 9, 4, 8]
+//    output: 15
+// */
+// double sumOfPrefixSum(std::vector<double> const& x) {
+
+#include <algorithm>
+#include <numeric>
+#include <random>
+#include <vector>
+
+#include "baseline.hpp"
+#include "utilities.hpp"
+#include "generated-code.hpp"   // code generated by LLM
+
+
+struct Context {
+    Kokkos::View<double*> x;
+    std::vector<double> xVec;
+};
+
+void reset(Context *ctx) {
+    fillRandKokkos(ctx->x, -100.0, 100.0);
+    fillRand(ctx->xVec, -100.0, 100.0);
+}
+
+Context *init() {
+    Context *ctx = new Context();
+    ctx->x = Kokkos::View<double*>("x", 1 << 20);
+    ctx->xVec.resize(1 << 20);
+    reset(ctx);
+    return ctx;
+}
+
+void compute(Context *ctx) {
+    double val = sumOfPrefixSum(ctx->x);
+    (void) val;
+}
+
+void best(Context *ctx) {
+    double val = correctSumOfPrefixSum(ctx->xVec);
+    (void) val;
+}
+
+bool validate(Context *ctx) {
+
+    const size_t numTries = 5;
+    for (int i = 0; i < numTries; i += 1) {
+        std::vector<double> input(2048);
+        fillRand(input, -100.0, 100.0);
+
+        Kokkos::View<double*> inputView("input", input.size());
+        copyVectorToView(input, inputView);
+
+        // compute correct result
+        double correctResult = correctSumOfPrefixSum(input);
+
+        // compute test result
+        double testResult = sumOfPrefixSum(inputView);
+        
+        if (std::fabs(correctResult - testResult) > 1e-5) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void destroy(Context *ctx) {
+    delete ctx;
+}
+
+

drivers/cpp/benchmarks/sort/41_sort_sort_non-zero_elements/baseline.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <algorithm>
+#include <vector>
+
+
+void correctSortIgnoreZero(std::vector<int> &x) {
+    std::vector<int> nonZeroElements;
+    for (int num : x) {
+        if (num != 0) {
+            nonZeroElements.push_back(num);
+        }
+    }
+
+    std::sort(nonZeroElements.begin(), nonZeroElements.end());
+
+    size_t nonZeroIndex = 0;
+    for (int i = 0; i < x.size(); i += 1) {
+        if (x[i] != 0) {
+            x[i] = nonZeroElements[nonZeroIndex];
+            nonZeroIndex += 1;
+        }
+    }
+}

drivers/cpp/benchmarks/sort/41_sort_sort_non-zero_elements/cpu.cc

@@ -0,0 +1,81 @@
+// Driver for 0_sort_non-zero
+// /* Sort the vector x in ascending order ignoring elements with value 0.
+//    Leave zero valued elements in-place.
+//    Example:
+// 
+// 	  input: [8, 4, 0, 9, 8, 0, 1, -1, 7]
+//    output: [-1, 1, 0, 4, 7, 0, 8, 8, 9]
+// */
+// void sortIgnoreZero(std::vector<int> &x) {
+
+#include <algorithm>
+#include <numeric>
+#include <random>
+#include <vector>
+
+#include "baseline.hpp"
+#include "utilities.hpp"
+#include "generated-code.hpp"   // code generated by LLM
+
+
+struct Context {
+    std::vector<int> x;
+};
+
+void fillRandWithZeroes(std::vector<int> &x) {
+    // fill x with random values, but set some to zero
+    for (int i = 0; i < x.size(); i += 1) {
+        x[i] = rand();
+        if (rand() % 5) {
+            x[i] = 0;
+        }
+    }
+}
+
+void reset(Context *ctx) {
+    fillRandWithZeroes(ctx->x);
+}
+
+Context *init() {
+    Context *ctx = new Context();
+    ctx->x.resize(100000);
+    reset(ctx);
+    return ctx;
+}
+
+void compute(Context *ctx) {
+    sortIgnoreZero(ctx->x);
+}
+
+void best(Context *ctx) {
+    correctSortIgnoreZero(ctx->x);
+}
+
+bool validate(Context *ctx) {
+
+    const size_t numTries = 5;
+    for (int i = 0; i < numTries; i += 1) {
+        std::vector<int> input(1024);
+        fillRandWithZeroes(input);
+
+        // compute correct result
+        std::vector<int> correctResult = input;
+        correctSortIgnoreZero(correctResult);
+
+        // compute test result
+        std::vector<int> testResult = input;
+        sortIgnoreZero(testResult);
+        
+        if (!std::equal(correctResult.begin(), correctResult.end(), testResult.begin())) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void destroy(Context *ctx) {
+    delete ctx;
+}
+
+