Patrick li/fix sim

golang/uPIMulator/benchmark/CMakeLists.txt

@@ -11,6 +11,7 @@ add_subdirectory(RED)
 add_subdirectory(SCAN-RSS)
 add_subdirectory(SCAN-SSA)
 add_subdirectory(SEL)
+add_subdirectory(SIM)
 add_subdirectory(TRNS)
 add_subdirectory(TS)
 add_subdirectory(UNI)

golang/uPIMulator/benchmark/SIM/CMakeLists.txt

@@ -0,0 +1,2 @@
+#add_subdirectory(host)
+add_subdirectory(dpu)

golang/uPIMulator/benchmark/SIM/Makefile

@@ -0,0 +1,48 @@
+DPU_DIR := dpu
+HOST_DIR := host
+BUILDDIR ?= bin
+NR_TASKLETS ?= 16
+BL ?= 10
+NR_DPUS ?= 1
+TYPE ?= INT32
+ENERGY ?= 0
+
+define conf_filename
+	${BUILDDIR}/.NR_DPUS_$(1)_NR_TASKLETS_$(2)_BL_$(3)_TYPE_$(4).conf
+endef
+CONF := $(call conf_filename,${NR_DPUS},${NR_TASKLETS},${BL},${TYPE})
+
+HOST_TARGET := ${BUILDDIR}/host_code
+DPU_TARGET := ${BUILDDIR}/dpu_code
+
+COMMON_INCLUDES := support
+HOST_SOURCES := $(wildcard ${HOST_DIR}/*.c)
+DPU_SOURCES := $(wildcard ${DPU_DIR}/*.c)
+
+.PHONY: all clean test
+
+__dirs := $(shell mkdir -p ${BUILDDIR})
+
+COMMON_FLAGS := -w -I${COMMON_INCLUDES}
+HOST_FLAGS := ${COMMON_FLAGS} -std=c11 -O3 `dpu-pkg-config --cflags --libs dpu` -DNR_TASKLETS=${NR_TASKLETS} -DNR_DPUS=${NR_DPUS} -DBL=${BL} -D${TYPE} -DENERGY=${ENERGY}
+DPU_FLAGS := ${COMMON_FLAGS} -O2 -DNR_TASKLETS=${NR_TASKLETS} -DBL=${BL} -D${TYPE}
+
+all: ${HOST_TARGET} ${DPU_TARGET}
+
+${CONF}:
+	$(RM) $(call conf_filename,*,*)
+	touch ${CONF}
+
+${HOST_TARGET}: ${HOST_SOURCES} ${COMMON_INCLUDES} ${CONF}
+	$(CC) -o ${HOST_TARGET}.bin ${HOST_SOURCES} ${HOST_FLAGS}
+	$(CC) -S -o ${HOST_TARGET}.S ${HOST_SOURCES} ${HOST_FLAGS}
+
+${DPU_TARGET}: ${DPU_SOURCES} ${COMMON_INCLUDES} ${CONF}
+	dpu-upmem-dpurte-clang ${DPU_FLAGS} -o $@ ${DPU_SOURCES}
+	dpu-upmem-dpurte-clang -S ${DPU_FLAGS} -o ${DPU_TARGET}.S ${DPU_SOURCES}
+
+clean:
+	$(RM) -r $(BUILDDIR)
+
+test: all
+	./${HOST_TARGET}

golang/uPIMulator/benchmark/SIM/baselines/cpu/Makefile

@@ -0,0 +1,5 @@
+all:
+	gcc -o va -fopenmp app_baseline.c 
+
+clean:
+	rm va

golang/uPIMulator/benchmark/SIM/baselines/cpu/README

@@ -0,0 +1,9 @@
+Vector addition (VA)
+
+Compilation instructions
+
+    make
+
+Execution instructions
+
+    ./va -t 4

golang/uPIMulator/benchmark/SIM/baselines/cpu/app_baseline.c

@@ -0,0 +1,132 @@
+/**
+* @file app.c
+* @brief Template for a Host Application Source File.
+*
+*/
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <assert.h>
+#include <stdint.h>
+
+#include <omp.h>
+#include "../../support/timer.h"
+
+static int32_t *A;
+static int32_t *B;
+static int32_t *C;
+static int32_t *C2; 
+
+/**
+* @brief creates a "test file" by filling a buffer of 64MB with pseudo-random values
+* @param nr_elements how many 32-bit elements we want the file to be
+* @return the buffer address
+*/
+void  *create_test_file(unsigned int nr_elements) {
+    srand(0);
+    printf("nr_elements\t%u\t", nr_elements);
+    A = (uint32_t*) malloc(nr_elements * sizeof(uint32_t));
+    B = (uint32_t*) malloc(nr_elements * sizeof(uint32_t));
+    C = (uint32_t*) malloc(nr_elements * sizeof(uint32_t));
+
+    for (int i = 0; i < nr_elements; i++) {
+        A[i] = (int) (rand());
+        B[i] = (int) (rand());
+    }
+
+}
+
+/**
+* @brief compute output in the host
+*/
+static void vector_addition_host(unsigned int nr_elements, int t) {
+    omp_set_num_threads(t);
+    #pragma omp parallel for
+    for (int i = 0; i < nr_elements; i++) {
+        C[i] = A[i] + B[i];
+    }
+}
+
+// Params ---------------------------------------------------------------------
+typedef struct Params {
+    int   input_size;
+    int   n_warmup;
+    int   n_reps;
+    int   n_threads;
+}Params;
+
+void usage() {
+    fprintf(stderr,
+        "\nUsage:  ./program [options]"
+        "\n"
+        "\nGeneral options:"
+        "\n    -h        help"
+        "\n    -t <T>    # of threads (default=8)"
+        "\n    -w <W>    # of untimed warmup iterations (default=1)"
+        "\n    -e <E>    # of timed repetition iterations (default=3)"
+        "\n"
+        "\nBenchmark-specific options:"
+        "\n    -i <I>    input size (default=8M elements)"
+        "\n");
+}
+
+struct Params input_params(int argc, char **argv) {
+    struct Params p;
+    p.input_size    = 16777216;
+    p.n_warmup      = 1;
+    p.n_reps        = 3;
+    p.n_threads     = 5;
+
+    int opt;
+    while((opt = getopt(argc, argv, "hi:w:e:t:")) >= 0) {
+        switch(opt) {
+        case 'h':
+        usage();
+        exit(0);
+        break;
+        case 'i': p.input_size    = atoi(optarg); break;
+        case 'w': p.n_warmup      = atoi(optarg); break;
+        case 'e': p.n_reps        = atoi(optarg); break;
+        case 't': p.n_threads        = atoi(optarg); break;
+        default:
+            fprintf(stderr, "\nUnrecognized option!\n");
+            usage();
+            exit(0);
+        }
+    }
+    assert(p.n_threads > 0 && "Invalid # of ranks!");
+
+    return p;
+}
+
+/**
+* @brief Main of the Host Application.
+*/
+int main(int argc, char **argv) {
+
+    struct Params p = input_params(argc, argv);
+
+    const unsigned int file_size = p.input_size;
+
+    // Create an input file with arbitrary data.
+    create_test_file(file_size);
+
+    Timer timer;
+    start(&timer, 0, 0);
+
+    vector_addition_host(file_size, p.n_threads);
+
+    stop(&timer, 0);
+    printf("Kernel ");
+    print(&timer, 0, 1);
+    printf("\n");
+
+    free(A);
+    free(B);
+    free(C);
+
+   return 0;
+ }

golang/uPIMulator/benchmark/SIM/baselines/gpu/Makefile

@@ -0,0 +1,5 @@
+all:
+	/usr/local/cuda/bin/nvcc vec_add.cu -I/usr/local/cuda/include -lm -o va
+
+clean:
+	rm va

golang/uPIMulator/benchmark/SIM/baselines/gpu/README

@@ -0,0 +1,9 @@
+Vector addition (VA)
+
+Compilation instructions
+
+    make
+
+Execution instructions
+
+    ./va

golang/uPIMulator/benchmark/SIM/baselines/gpu/vec_add.cu

@@ -0,0 +1,101 @@
+/* File:     vec_add.cu
+ * Purpose:  Implement vector addition on a gpu using cuda
+ *
+ * Compile:  nvcc [-g] [-G] -o vec_add vec_add.cu
+ * Run:      ./vec_add
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <math.h>
+
+__global__ void Vec_add(unsigned int x[], unsigned int y[], unsigned int z[], int n) {
+    int thread_id = blockIdx.x * blockDim.x + threadIdx.x;
+    if (thread_id < n){
+        z[thread_id] = x[thread_id] + y[thread_id];
+    }
+}
+
+
+int main(int argc, char* argv[]) {
+    int n, m;
+    unsigned int *h_x, *h_y, *h_z;
+    unsigned int *d_x, *d_y, *d_z;
+    size_t size;
+
+    /* Define vector length */
+    n = 2621440;
+    m = 320;
+    size = m * n * sizeof(unsigned int);
+
+    // Allocate memory for the vectors on host memory.
+    h_x = (unsigned int*) malloc(size);
+    h_y = (unsigned int*) malloc(size);
+    h_z = (unsigned int*) malloc(size);
+
+    for (int i = 0; i < n * m; i++) {
+        h_x[i] = i+1;
+        h_y[i] = n-i;
+    }
+
+    printf("Input size = %d\n", n * m);
+
+    // Print original vectors.
+    /*printf("h_x = ");
+    for (int i = 0; i < m; i++){
+        printf("%u ", h_x[i]);
+    }
+    printf("\n\n");
+    printf("h_y = ");
+    for (int i = 0; i < m; i++){
+        printf("%u ", h_y[i]);
+    }
+    printf("\n\n");*/
+
+    // Event creation
+    cudaEvent_t start, stop;
+    cudaEventCreate(&start);
+    cudaEventCreate(&stop);
+    float time1 = 0;
+
+    /* Allocate vectors in device memory */
+    cudaMalloc(&d_x, size);
+    cudaMalloc(&d_y, size);
+    cudaMalloc(&d_z, size);
+
+    /* Copy vectors from host memory to device memory */
+    cudaMemcpy(d_x, h_x, size, cudaMemcpyHostToDevice);
+    cudaMemcpy(d_y, h_y, size, cudaMemcpyHostToDevice);
+
+    // Start timer
+    cudaEventRecord( start, 0 );
+
+    /* Kernel Call */
+    Vec_add<<<(n * m) / 256, 256>>>(d_x, d_y, d_z, n * m);
+
+    // End timer
+    cudaEventRecord( stop, 0 );
+    cudaEventSynchronize( stop );
+    cudaEventElapsedTime( &time1, start, stop );
+
+    cudaMemcpy(h_z, d_z, size, cudaMemcpyDeviceToHost);
+    /*printf("The sum is: \n");
+    for (int i = 0; i < m; i++){
+        printf("%u ", h_z[i]);
+    }
+    printf("\n");*/
+
+    printf("Execution time = %f ms\n", time1);
+
+    /* Free device memory */
+    cudaFree(d_x);
+    cudaFree(d_y);
+    cudaFree(d_z);
+    /* Free host memory */
+    free(h_x);
+    free(h_y);
+    free(h_z);
+
+    return 0;
+}  /* main */

golang/uPIMulator/benchmark/SIM/dpu/CMakeLists.txt

@@ -0,0 +1,10 @@
+SET(BL 10)
+SET(TYPE INT32)
+
+set(CMAKE_C_COMPILER "/root/upmem-2023.2.0-Linux-x86_64/bin/dpu-upmem-dpurte-clang")
+set(CMAKE_C_FLAGS "-w -I/root/uPIMulator/benchmark/SIM/support -O2 -S -DNR_TASKLETS=${NR_TASKLETS} -DBL=${BL} -D${TYPE}")
+
+file(GLOB_RECURSE SRCS *.c)
+
+add_executable(SIM_device ${SRCS})
+

golang/uPIMulator/benchmark/SIM/dpu/task.c

@@ -0,0 +1,34 @@
+/*
+* Vector addition with multiple tasklets
+*
+*/
+#include <stdint.h>
+#include <stdio.h>
+#include <defs.h>
+#include <mram.h>
+#include <alloc.h>
+#include <perfcounter.h>
+#include <barrier.h>
+
+#include "../support/common.h"
+
+// Barrier
+BARRIER_INIT(my_barrier, NR_TASKLETS);
+// main_kernel
+int main(void) {
+    unsigned int tasklet_id = me();
+    if (tasklet_id == 0){ // Initialize once the cycle counter
+        mem_reset(); // Reset the heap
+    }
+    // Barrier
+    barrier_wait(&my_barrier);
+    uint64_t result = 0;
+    uint64_t task_num = -1;
+    mram_read(DPU_MRAM_HEAP_POINTER, &task_num, 8);
+    for (uint64_t i = 0; i < task_num; i++) {
+        result += task_num;
+    }
+    mram_write(&result, DPU_MRAM_HEAP_POINTER + 64, 8);
+
+    return 0;
+}