diff options
Diffstat (limited to 'MLP')
| -rw-r--r-- | MLP/baselines/cpu/Makefile | 28 | ||||
| -rw-r--r-- | MLP/baselines/cpu/mlp_openmp.c | 340 | ||||
| -rw-r--r-- | MLP/dpu/task.c | 124 | ||||
| -rw-r--r-- | MLP/host/app.c | 176 | ||||
| -rwxr-xr-x | MLP/support/common.h | 16 | ||||
| -rw-r--r-- | MLP/support/params.h | 95 | ||||
| -rwxr-xr-x | MLP/support/timer.h | 131 |
7 files changed, 554 insertions, 356 deletions
diff --git a/MLP/baselines/cpu/Makefile b/MLP/baselines/cpu/Makefile index e2e6780..7eb5f00 100644 --- a/MLP/baselines/cpu/Makefile +++ b/MLP/baselines/cpu/Makefile @@ -1,7 +1,28 @@ +benchmark ?= 1 +debug ?= 0 +native ?= 1 +nop_sync ?= 0 +numa ?= 0 + +CFLAGS = +LDFLAGS = + +ifeq (${debug}, 1) + CFLAGS += -g +endif + +ifeq (${native}, 1) + CFLAGS += -march=native +endif + +ifeq (${numa}, 1) + LDFLAGS += -lnuma +endif + all: mlp_openmp mlp_openmp: mlp_openmp.c - gcc -O2 mlp_openmp.c -o mlp_openmp -fopenmp -std=c99 + gcc -Wall -Wextra -pedantic -O3 ${CFLAGS} mlp_openmp.c -o mlp_openmp -DNUMA=${numa} -DNOP_SYNC=${nop_sync} -DWITH_BENCHMARK=${benchmark} -fopenmp -std=c99 ${LDFLAGS} mlp_openmp_O0: mlp_openmp.c gcc mlp_openmp.c -o mlp_openmp_O0 -fopenmp -std=c99 @@ -18,4 +39,7 @@ run_O0: mlp_openmp_O0 run_O2: mlp_openmp_O2 ./mlp_openmp_O2 -.PHONY: all run run_O0 run_O2 +clean: + rm -f mlp_openmp mlp_openmp_O0 mlp_openmp_O2 + +.PHONY: all run run_O0 run_O2 clean diff --git a/MLP/baselines/cpu/mlp_openmp.c b/MLP/baselines/cpu/mlp_openmp.c index 8f95e7c..b473d7a 100644 --- a/MLP/baselines/cpu/mlp_openmp.c +++ b/MLP/baselines/cpu/mlp_openmp.c @@ -11,173 +11,261 @@ #include <getopt.h> #include <assert.h> #include <stdint.h> -#include "../../support/timer.h" #include "../../support/common.h" +#if WITH_BENCHMARK +#include "../../support/timer.h" +#else +#define start(...) +#define stop(...) +#endif + +#if NUMA +#include <numaif.h> +#include <numa.h> + +void *mp_pages[1]; +int mp_status[1]; +int mp_nodes[1]; +int numa_node_data = -1; +int numa_node_cpu = -1; +#endif + #define XSTR(x) STR(x) #define STR(x) #x -T** A; -T* B; -T* C; +// weights +T **A; + +// input/output +T *B; + +// intermediate +T *C; // Create input arrays -static void init_data(T** A, T* B, unsigned int m_size, unsigned int n_size){ - for (unsigned int l = 0; l < NUM_LAYERS; l++) - for (unsigned int i = 0; i < m_size * n_size; i++){ - if(i % 100 < 98){ +static void init_data(T **A, unsigned int m_size, unsigned int n_size) +{ + for (unsigned int l = 0; l < NUM_LAYERS; l++) { + for (unsigned int i = 0; i < m_size * n_size; i++) { + if (i % 100 < 98) { A[l][i] = 0; - }else{ - A[l][i] = (l+i) % 2; + } else { + A[l][i] = (l + i) % 2; } } - for (unsigned int i = 0; i < n_size; i++){ - if(i % 50 < 48){ + } +} + +static void init_B(T *B, unsigned int n_size) +{ + for (unsigned int i = 0; i < n_size; i++) { + if (i % 50 < 48) { B[i] = 0; - } - else{ + } else { B[i] = i % 2; } } } // Compute output in the host -static void mlp_host(T* C, T** A, T* B, unsigned int m_size, unsigned int n_size) { - for (unsigned int nl = 0; nl < NUM_LAYERS; nl++){ - for (unsigned int m = 0; m < m_size; m++){ +static void mlp_host(T *C, T **A, T *B, unsigned int m_size, + unsigned int n_size) +{ + for (unsigned int nl = 0; nl < NUM_LAYERS; nl++) { + for (unsigned int m = 0; m < m_size; m++) { C[m] = 0; } - #pragma omp parallel for - for (unsigned int m = 0; m < m_size; m++){ - for (unsigned int n = 0; n < n_size; n++){ +#pragma omp parallel for + for (unsigned int m = 0; m < m_size; m++) { + for (unsigned int n = 0; n < n_size; n++) { C[m] += A[nl][m * n_size + n] * B[n]; } C[m] = max(0, C[m]); } - for (unsigned int n = 0; n < n_size; n++){ + for (unsigned int n = 0; n < n_size; n++) { B[n] = C[n]; } } } -static uint64_t mlp_host_sum(uint64_t n_size, uint64_t m_size) { - uint64_t sum = 0; - for (uint64_t m = 0; m < n_size; m++){ - sum += B[m]; - } - return sum; +static uint64_t mlp_host_sum(uint64_t n_size) +{ + uint64_t sum = 0; + for (uint64_t m = 0; m < n_size; m++) { + sum += B[m]; + } + return sum; } // Params --------------------------------------------------------------------- typedef struct Params { - char* dpu_type; - int nr_of_ranks; - int input_size_n; - int input_size_m; - int n_warmup; - int n_reps; -}Params; - -void usage() { - fprintf(stderr, - "\nUsage: ./program [options]" - "\n" - "\nGeneral options:" - "\n -h help" - "\n -d <D> DPU type (default=fsim)" - "\n -r <R> # of ranks (default=2)" - "\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.dpu_type = "fsim"; - p.nr_of_ranks = 1; - p.input_size_n = 1 << 9; - p.input_size_m = 1 << 9; - p.n_warmup = 2; - p.n_reps = 3; - - int opt; - while((opt = getopt(argc, argv, "hd:r:i:")) >= 0) { - switch(opt) { - case 'h': - usage(); - exit(0); - break; - case 'd': p.dpu_type = optarg; break; - case 'r': p.nr_of_ranks = atoi(optarg); break; - case 'n': p.input_size_n = atoi(optarg); break; - case 'm': p.input_size_m = atoi(optarg); break; - default: - fprintf(stderr, "\nUnrecognized option!\n"); - usage(); - exit(0); - } - } - assert(p.nr_of_ranks > 0 && "Invalid # of ranks!"); - - return p; - } + int input_size_n; + int input_size_m; + int n_reps; +#if NUMA + struct bitmask *bitmask; + int numa_node_cpu; +#endif +} Params; + +void usage() +{ + fprintf(stderr, "\nUsage: ./program [options]" "\n"); +} + +struct Params input_params(int argc, char **argv) +{ + struct Params p; + p.input_size_n = 8192; + p.input_size_m = 20480; + p.n_reps = 100; +#if NUMA + p.bitmask = NULL; + p.numa_node_cpu = -1; +#endif + + int opt; + while ((opt = getopt(argc, argv, "e:n:m:A:C:")) >= 0) { + switch (opt) { + case 'h': + usage(); + exit(0); + break; + case 'e': + p.n_reps = atoi(optarg); + break; + case 'n': + p.input_size_n = atoi(optarg); + break; + case 'm': + p.input_size_m = atoi(optarg); + break; +#if NUMA + case 'A': + p.bitmask = numa_parse_nodestring(optarg); + break; + case 'C': + p.numa_node_cpu = atoi(optarg); + break; +#endif + default: + fprintf(stderr, "\nUnrecognized option!\n"); + usage(); + exit(0); + } + } + + return p; +} /** * @brief Main of the Host Application. */ - int main(int argc, char **argv) { +int main(int argc, char **argv) +{ - struct Params p = input_params(argc, argv); - uint64_t n_size = 8192; - uint64_t m_size = 20480; + struct Params p = input_params(argc, argv); + uint64_t n_size = p.input_size_n; + uint64_t m_size = p.input_size_m; - Timer timer; - A = malloc(NUM_LAYERS * sizeof(T*)); - for(int l = 0; l < NUM_LAYERS; l++) - A[l] = malloc(n_size*m_size*sizeof(unsigned int)); - B = malloc(m_size*sizeof(unsigned int)); - C = malloc(m_size*sizeof(unsigned int)); +#if WITH_BENCHMARK + Timer timer; +#endif - for (int i = 0; i < 100; i++) { - // Create an input file with arbitrary data. - init_data(A, B, m_size, n_size); +#if NUMA + if (p.bitmask) { + numa_set_membind(p.bitmask); + numa_free_nodemask(p.bitmask); + } + A = numa_alloc(NUM_LAYERS * sizeof(T *)); + for (int l = 0; l < NUM_LAYERS; l++) { + A[l] = numa_alloc(n_size * m_size * sizeof(unsigned int)); + } + B = numa_alloc(m_size * sizeof(unsigned int)); + C = numa_alloc(m_size * sizeof(unsigned int)); + + mp_pages[0] = A; + if (move_pages(0, 1, mp_pages, NULL, mp_status, 0) == -1) { + perror("move_pages(A)"); + } else if (mp_status[0] < 0) { + printf("move_pages error: %d", mp_status[0]); + } else { + numa_node_data = mp_status[0]; + } + + numa_node_cpu = p.numa_node_cpu; + if (numa_node_cpu != -1) { + if (numa_run_on_node(numa_node_cpu) == -1) { + perror("numa_run_on_node"); + numa_node_cpu = -1; + } + } +#else + A = malloc(NUM_LAYERS * sizeof(T *)); + for (int l = 0; l < NUM_LAYERS; l++) { + A[l] = malloc(n_size * m_size * sizeof(unsigned int)); + } + B = malloc(m_size * sizeof(unsigned int)); + C = malloc(m_size * sizeof(unsigned int)); +#endif + + // Create an input file with arbitrary data. + init_data(A, m_size, n_size); + + for (int i = 0; i < p.n_reps; i++) { + init_B(B, n_size); - start(&timer, 0, 0); - mlp_host(C, A, B, n_size, m_size); - stop(&timer, 0); + start(&timer, 0, 0); + mlp_host(C, A, B, n_size, m_size); + stop(&timer, 0); - unsigned int nr_threads = 0; +#if WITH_BENCHMARK + unsigned int nr_threads = 0; #pragma omp parallel #pragma omp atomic - nr_threads++; - - printf("[::] n_threads=%d e_type=%s n_elements=%lu " - "| throughput_cpu_omp_MBps=%f\n", - nr_threads, XSTR(T), n_size * m_size, - n_size * m_size * sizeof(T) / timer.time[0]); - printf("[::] n_threads=%d e_type=%s n_elements=%lu " - "| throughput_cpu_omp_MOpps=%f\n", - nr_threads, XSTR(T), n_size * m_size, - n_size * m_size / timer.time[0]); - printf("[::] n_threads=%d e_type=%s n_elements=%lu |", - nr_threads, XSTR(T), n_size * m_size); - printall(&timer, 0); - } - - uint32_t sum = mlp_host_sum(n_size, m_size); - - printf("Kernel "); - print(&timer, 0, 1); - printf("\n"); - - printf("SUM = %d \n", sum); - - for(int l = 0; l < NUM_LAYERS; l++) - free(A[l]); - free(A); - free(B); - free(C); - - return 0; + nr_threads++; + + printf("[::] MLP-CPU | n_threads=%d e_type=%s n_elements=%lu", + nr_threads, XSTR(T), n_size * m_size); +#if NUMA + printf + (" numa_node_data=%d numa_node_cpu=%d numa_distance_cpu_data=%d", + numa_node_data, numa_node_cpu, + numa_distance(numa_node_data, numa_node_cpu)); +#endif + printf(" | throughput_MBps=%f throughput_MOpps=%f", + n_size * m_size * sizeof(T) / timer.time[0], + n_size * m_size / timer.time[0]); + printf(" latency_us=%f\n", timer.time[0]); +#endif // WITH_BENCHMARK + } + +#if NOP_SYNC + for (int rep = 0; rep < 200000; rep++) { + asm volatile ("nop"::); + } +#endif + + uint32_t sum = mlp_host_sum(n_size); + + printf("SUM = %d \n", sum); + +#if NUMA + for (int l = 0; l < NUM_LAYERS; l++) { + numa_free(A[l], n_size * m_size * sizeof(unsigned int)); + } + numa_free(A, NUM_LAYERS * sizeof(T *)); + numa_free(B, m_size * sizeof(unsigned int)); + numa_free(C, m_size * sizeof(unsigned int)); +#else + for (int l = 0; l < NUM_LAYERS; l++) { + free(A[l]); + } + free(A); + free(B); + free(C); +#endif + + return 0; } diff --git a/MLP/dpu/task.c b/MLP/dpu/task.c index de3e554..4f85024 100644 --- a/MLP/dpu/task.c +++ b/MLP/dpu/task.c @@ -15,7 +15,8 @@ __host dpu_arguments_t DPU_INPUT_ARGUMENTS; // GEMV -static void gemv(T *bufferC, T *bufferA, T *bufferB, int pos) { +static void gemv(T *bufferC, T *bufferA, T *bufferB, int pos) +{ for (unsigned int i = 0; i < BLOCK_SIZE / sizeof(T); i++) { bufferC[pos] += bufferA[i] * bufferB[i]; } @@ -26,13 +27,14 @@ static void gemv(T *bufferC, T *bufferA, T *bufferB, int pos) { BARRIER_INIT(my_barrier, NR_TASKLETS); // main -int main() { +int main() +{ unsigned int tasklet_id = me(); #if PRINT printf("tasklet_id = %u\n", tasklet_id); #endif - if (tasklet_id == 0){ // Initialize once the cycle counter - mem_reset(); // Reset the heap + if (tasklet_id == 0) { // Initialize once the cycle counter + mem_reset(); // Reset the heap } // Barrier barrier_wait(&my_barrier); @@ -42,12 +44,11 @@ int main() { uint32_t nr_rows = DPU_INPUT_ARGUMENTS.nr_rows; uint32_t max_rows = DPU_INPUT_ARGUMENTS.max_rows; - unsigned int nrows = nr_rows; - unsigned int rows_per_tasklet; + unsigned int rows_per_tasklet; unsigned int start_row; unsigned int chunks = nrows / (NR_TASKLETS + NR_TASKLETS); - unsigned int dbl_chunks = chunks + chunks; + unsigned int dbl_chunks = chunks + chunks; rows_per_tasklet = dbl_chunks; unsigned int rest_rows = nrows % (NR_TASKLETS + NR_TASKLETS); @@ -57,19 +58,30 @@ int main() { if ((tasklet_id + tasklet_id) >= rest_rows) { unsigned int hlf_rest_rows = rest_rows >> 1; if ((rest_rows & 1) == 1) - start_row = (hlf_rest_rows + 1) * (dbl_chunks + 2) + (tasklet_id - 1 - hlf_rest_rows) * dbl_chunks; + start_row = + (hlf_rest_rows + 1) * (dbl_chunks + 2) + + (tasklet_id - 1 - + hlf_rest_rows) * dbl_chunks; else - start_row = (hlf_rest_rows) * (dbl_chunks + 2) + (tasklet_id - hlf_rest_rows) * dbl_chunks; - } else + start_row = + (hlf_rest_rows) * (dbl_chunks + 2) + + (tasklet_id - hlf_rest_rows) * dbl_chunks; + } else start_row = tasklet_id * (dbl_chunks + 2); } else { start_row = tasklet_id * (dbl_chunks); } // Address of the current row in MRAM - uint32_t mram_base_addr_A = (uint32_t) (DPU_MRAM_HEAP_POINTER + start_row * n_size * sizeof(T)); - uint32_t mram_base_addr_B = (uint32_t) (DPU_MRAM_HEAP_POINTER + max_rows * n_size_pad * sizeof(T)); - uint32_t mram_base_addr_C = (uint32_t) (DPU_MRAM_HEAP_POINTER + max_rows * n_size_pad * sizeof(T) + n_size_pad * sizeof(T) + start_row * sizeof(T)); + uint32_t mram_base_addr_A = + (uint32_t) (DPU_MRAM_HEAP_POINTER + start_row * n_size * sizeof(T)); + uint32_t mram_base_addr_B = + (uint32_t) (DPU_MRAM_HEAP_POINTER + + max_rows * n_size_pad * sizeof(T)); + uint32_t mram_base_addr_C = + (uint32_t) (DPU_MRAM_HEAP_POINTER + + max_rows * n_size_pad * sizeof(T) + + n_size_pad * sizeof(T) + start_row * sizeof(T)); uint32_t mram_temp_addr_A = mram_base_addr_A; uint32_t mram_temp_addr_B = mram_base_addr_B; @@ -82,34 +94,44 @@ int main() { int offset = 0; // Iterate over nr_rows - for (unsigned int i = start_row; i < start_row + rows_per_tasklet; i += 2) { + for (unsigned int i = start_row; i < start_row + rows_per_tasklet; + i += 2) { - mram_temp_addr_A = (uint32_t) (DPU_MRAM_HEAP_POINTER + i * n_size * sizeof(T)); + mram_temp_addr_A = + (uint32_t) (DPU_MRAM_HEAP_POINTER + i * n_size * sizeof(T)); mram_temp_addr_B = mram_base_addr_B; cache_C[0] = 0; cache_C[1] = 0; - for(unsigned int pos = 0; pos < 2 && i + pos < nr_rows; pos++){ + for (unsigned int pos = 0; pos < 2 && i + pos < nr_rows; pos++) { int n = 0, j; - for (n = 0; n < (int32_t) (n_size - (BLOCK_SIZE/sizeof(T))); n += (BLOCK_SIZE / sizeof(T))) - { - - mram_read((__mram_ptr void const*) (mram_temp_addr_A), cache_A, BLOCK_SIZE); - mram_read((__mram_ptr void const*) (mram_temp_addr_B), cache_B, BLOCK_SIZE); - - if(offset) - { - - for(unsigned int off = 0; off < (BLOCK_SIZE / sizeof(T)) - 1; off++) - { + for (n = 0; + n < (int32_t) (n_size - (BLOCK_SIZE / sizeof(T))); + n += (BLOCK_SIZE / sizeof(T))) { + + mram_read((__mram_ptr void const + *)(mram_temp_addr_A), cache_A, + BLOCK_SIZE); + mram_read((__mram_ptr void const + *)(mram_temp_addr_B), cache_B, + BLOCK_SIZE); + + if (offset) { + + for (unsigned int off = 0; + off < (BLOCK_SIZE / sizeof(T)) - 1; + off++) { cache_A[off] = cache_A[off + 1]; } - mram_read((__mram_ptr void const*) (mram_temp_addr_A + BLOCK_SIZE), cache_A_aux, 8); + mram_read((__mram_ptr void const + *)(mram_temp_addr_A + + BLOCK_SIZE), cache_A_aux, + 8); - cache_A[BLOCK_SIZE / sizeof(T) - 1] = cache_A_aux[0]; + cache_A[BLOCK_SIZE / sizeof(T) - 1] = + cache_A_aux[0]; } - // Compute GEMV gemv(cache_C, cache_A, cache_B, pos); @@ -118,49 +140,51 @@ int main() { mram_temp_addr_B += BLOCK_SIZE; } - mram_read((__mram_ptr void const*) (mram_temp_addr_A), cache_A, BLOCK_SIZE); + mram_read((__mram_ptr void const *)(mram_temp_addr_A), + cache_A, BLOCK_SIZE); - - if(offset) - { - for(unsigned int off = 0; off < (BLOCK_SIZE / sizeof(T)) -1; off++) - { + if (offset) { + for (unsigned int off = 0; + off < (BLOCK_SIZE / sizeof(T)) - 1; + off++) { cache_A[off] = cache_A[off + 1]; } - mram_read((__mram_ptr void const*) (mram_temp_addr_A + BLOCK_SIZE ), cache_A_aux, 8); + mram_read((__mram_ptr void const + *)(mram_temp_addr_A + BLOCK_SIZE), + cache_A_aux, 8); - cache_A[BLOCK_SIZE / sizeof(T) - 1] = cache_A_aux[0]; + cache_A[BLOCK_SIZE / sizeof(T) - 1] = + cache_A_aux[0]; } + mram_read((__mram_ptr void const *)(mram_temp_addr_B), + cache_B, BLOCK_SIZE); - mram_read((__mram_ptr void const*) (mram_temp_addr_B), cache_B, BLOCK_SIZE); - - for (j = 0; j < (int) (n_size - n); j++) { + for (j = 0; j < (int)(n_size - n); j++) { // Compute GEMV - if(j >= (int)(BLOCK_SIZE / sizeof(T))){ + if (j >= (int)(BLOCK_SIZE / sizeof(T))) { printf("error\n"); break; } cache_C[pos] += cache_A[j] * cache_B[j]; } - - mram_temp_addr_A += (BLOCK_SIZE - ((BLOCK_SIZE / sizeof(T)) - (n_size - n)) * sizeof(T)); + mram_temp_addr_A += + (BLOCK_SIZE - + ((BLOCK_SIZE / sizeof(T)) - + (n_size - n)) * sizeof(T)); mram_temp_addr_B = mram_base_addr_B; - if(mram_temp_addr_A % 8 != 0) - { + if (mram_temp_addr_A % 8 != 0) { offset = 1; - } - else - { + } else { offset = 0; } } // Write cache to current MRAM block - mram_write(cache_C, (__mram_ptr void *) (mram_base_addr_C), 8); + mram_write(cache_C, (__mram_ptr void *)(mram_base_addr_C), 8); // Update memory address mram_base_addr_C += 2 * sizeof(T); diff --git a/MLP/host/app.c b/MLP/host/app.c index 952cb3f..24243bf 100644 --- a/MLP/host/app.c +++ b/MLP/host/app.c @@ -27,28 +27,29 @@ #define DPU_BINARY "./bin/mlp_dpu" #endif -static T** A; -static T* B; -static T* B_host; -static T* B_tmp; -static T* C; -static T* C_dpu; +static T **A; +static T *B; +static T *B_host; +static T *B_tmp; +static T *C; +static T *C_dpu; // Create input arrays -static void init_data(T** A, T* B, T* B_host, unsigned int m_size, unsigned int n_size) { +static void init_data(T **A, T *B, T *B_host, unsigned int m_size, + unsigned int n_size) +{ for (unsigned int l = 0; l < NUM_LAYERS; l++) - for (unsigned int i = 0; i < m_size * n_size; i++){ - if(i % 100 < 98){ + for (unsigned int i = 0; i < m_size * n_size; i++) { + if (i % 100 < 98) { A[l][i] = 0; - }else{ - A[l][i] = (l+i) % 2; + } else { + A[l][i] = (l + i) % 2; } } - for (unsigned int i = 0; i < n_size; i++){ - if(i % 50 < 48){ + for (unsigned int i = 0; i < n_size; i++) { + if (i % 50 < 48) { B[i] = 0; - } - else{ + } else { B[i] = i % 2; } B_host[i] = B[i]; @@ -56,26 +57,29 @@ static void init_data(T** A, T* B, T* B_host, unsigned int m_size, unsigned int } // Compute output in the host -static void mlp_host(T* C, T** A, T* B, unsigned int m_size, unsigned int n_size) { +static void mlp_host(T *C, T **A, T *B, unsigned int m_size, + unsigned int n_size) +{ - for (unsigned int nl = 0; nl < NUM_LAYERS; nl++){ - for (unsigned int m = 0; m < m_size; m++){ + for (unsigned int nl = 0; nl < NUM_LAYERS; nl++) { + for (unsigned int m = 0; m < m_size; m++) { C[m] = 0; } - for (unsigned int m = 0; m < m_size; m++){ - for (unsigned int n = 0; n < n_size; n++){ + for (unsigned int m = 0; m < m_size; m++) { + for (unsigned int n = 0; n < n_size; n++) { C[m] += A[nl][m * n_size + n] * B[n]; } C[m] = max(0, C[m]); } - for (unsigned int n = 0; n < n_size; n++){ + for (unsigned int n = 0; n < n_size; n++) { B[n] = C[n]; } } } // Main of the Host Application -int main(int argc, char **argv) { +int main(int argc, char **argv) +{ struct Params p = input_params(argc, argv); @@ -97,14 +101,15 @@ int main(int argc, char **argv) { unsigned int n_size = p.n_size; // Initialize help data - dpu_info = (struct dpu_info_t *) malloc(nr_of_dpus * sizeof(struct dpu_info_t)); - dpu_arguments_t *input_args = (dpu_arguments_t *) malloc(nr_of_dpus * sizeof(dpu_arguments_t)); + dpu_info = + (struct dpu_info_t *)malloc(nr_of_dpus * sizeof(struct dpu_info_t)); + dpu_arguments_t *input_args = + (dpu_arguments_t *) malloc(nr_of_dpus * sizeof(dpu_arguments_t)); uint32_t max_rows_per_dpu = 0; uint32_t n_size_pad = n_size; - if(n_size % 2 == 1){ + if (n_size % 2 == 1) { n_size_pad++; } - // Timer Timer timer; i = 0; @@ -118,7 +123,10 @@ int main(int argc, char **argv) { rows_per_dpu++; if (rest_rows > 0) { if (i >= rest_rows) - prev_rows_dpu = rest_rows * (chunks + 1) + (i - rest_rows) * chunks; + prev_rows_dpu = + rest_rows * (chunks + 1) + (i - + rest_rows) * + chunks; else prev_rows_dpu = i * (chunks + 1); } else { @@ -127,7 +135,7 @@ int main(int argc, char **argv) { // Keep max rows for parallel transfers uint32_t rows_per_dpu_pad = rows_per_dpu; - if (rows_per_dpu_pad % 2 == 1) // 4-byte elements + if (rows_per_dpu_pad % 2 == 1) // 4-byte elements rows_per_dpu_pad++; if (rows_per_dpu_pad > max_rows_per_dpu) max_rows_per_dpu = rows_per_dpu_pad; @@ -142,14 +150,15 @@ int main(int argc, char **argv) { input_args[i].nr_rows = rows_per_dpu; } - A = (T**)malloc(NUM_LAYERS * sizeof(T*)); - for(l = 0; l < NUM_LAYERS; l++) - A[l] = (T*)malloc( max_rows_per_dpu * nr_of_dpus * n_size_pad * sizeof(T)); + A = (T **) malloc(NUM_LAYERS * sizeof(T *)); + for (l = 0; l < NUM_LAYERS; l++) + A[l] = + (T *) malloc(max_rows_per_dpu * nr_of_dpus * n_size_pad * + sizeof(T)); - - B = (T*)malloc(n_size * sizeof(T)); - B_host = (T*)malloc(n_size * sizeof(T)); - C = (T*)malloc(m_size * sizeof(T)); + B = (T *) malloc(n_size * sizeof(T)); + B_host = (T *) malloc(n_size * sizeof(T)); + C = (T *) malloc(m_size * sizeof(T)); C_dpu = malloc(max_rows_per_dpu * nr_of_dpus * sizeof(T)); B_tmp = malloc(max_rows_per_dpu * nr_of_dpus * sizeof(T)); @@ -170,26 +179,36 @@ int main(int argc, char **argv) { input_args[i].max_rows = max_rows_per_dpu; DPU_ASSERT(dpu_prepare_xfer(dpu, input_args + i)); } - DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, "DPU_INPUT_ARGUMENTS", 0, sizeof(dpu_arguments_t), DPU_XFER_DEFAULT)); - + DPU_ASSERT(dpu_push_xfer + (dpu_set, DPU_XFER_TO_DPU, "DPU_INPUT_ARGUMENTS", 0, + sizeof(dpu_arguments_t), DPU_XFER_DEFAULT)); // Copy input array and vector i = 0; DPU_FOREACH(dpu_set, dpu, i) { - DPU_ASSERT(dpu_prepare_xfer(dpu, A[0] + dpu_info[i].prev_rows_dpu * n_size)); + DPU_ASSERT(dpu_prepare_xfer + (dpu, + A[0] + dpu_info[i].prev_rows_dpu * n_size)); } - DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, DPU_MRAM_HEAP_POINTER_NAME, 0, max_rows_per_dpu * n_size_pad * sizeof(T), DPU_XFER_DEFAULT)); + DPU_ASSERT(dpu_push_xfer + (dpu_set, DPU_XFER_TO_DPU, + DPU_MRAM_HEAP_POINTER_NAME, 0, + max_rows_per_dpu * n_size_pad * sizeof(T), + DPU_XFER_DEFAULT)); i = 0; DPU_FOREACH(dpu_set, dpu, i) { DPU_ASSERT(dpu_prepare_xfer(dpu, B)); } - DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, DPU_MRAM_HEAP_POINTER_NAME, max_rows_per_dpu * n_size_pad * sizeof(T) , n_size_pad * sizeof(T), DPU_XFER_DEFAULT)); + DPU_ASSERT(dpu_push_xfer + (dpu_set, DPU_XFER_TO_DPU, + DPU_MRAM_HEAP_POINTER_NAME, + max_rows_per_dpu * n_size_pad * sizeof(T), + n_size_pad * sizeof(T), DPU_XFER_DEFAULT)); if (rep >= p.n_warmup) stop(&timer, 1); // Run kernel on DPUs - if (rep >= p.n_warmup) - { + if (rep >= p.n_warmup) { start(&timer, 2, rep - p.n_warmup); #if ENERGY DPU_ASSERT(dpu_probe_start(&probe)); @@ -198,31 +217,38 @@ int main(int argc, char **argv) { DPU_ASSERT(dpu_launch(dpu_set, DPU_SYNCHRONOUS)); - if (rep >= p.n_warmup) - { + if (rep >= p.n_warmup) { stop(&timer, 2); #if ENERGY DPU_ASSERT(dpu_probe_stop(&probe)); #endif } - for(int lay = 1; lay < NUM_LAYERS; lay++){ + for (int lay = 1; lay < NUM_LAYERS; lay++) { if (rep >= p.n_warmup) start(&timer, 4, rep - p.n_warmup); i = 0; // Copy C_dpu DPU_FOREACH(dpu_set, dpu, i) { - DPU_ASSERT(dpu_prepare_xfer(dpu, C_dpu + i * max_rows_per_dpu)); + DPU_ASSERT(dpu_prepare_xfer + (dpu, C_dpu + i * max_rows_per_dpu)); } - DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_FROM_DPU, DPU_MRAM_HEAP_POINTER_NAME, max_rows_per_dpu * n_size_pad * sizeof(T) + n_size_pad * sizeof(T), max_rows_per_dpu * sizeof(T), DPU_XFER_DEFAULT)); + DPU_ASSERT(dpu_push_xfer + (dpu_set, DPU_XFER_FROM_DPU, + DPU_MRAM_HEAP_POINTER_NAME, + max_rows_per_dpu * n_size_pad * sizeof(T) + + n_size_pad * sizeof(T), + max_rows_per_dpu * sizeof(T), + DPU_XFER_DEFAULT)); // B = C unsigned int n, j; i = 0; for (n = 0; n < nr_of_dpus; n++) { for (j = 0; j < dpu_info[n].rows_per_dpu; j++) { - B_tmp[i] = C_dpu[n * max_rows_per_dpu + j]; + B_tmp[i] = + C_dpu[n * max_rows_per_dpu + j]; i++; } } @@ -230,20 +256,31 @@ int main(int argc, char **argv) { DPU_FOREACH(dpu_set, dpu, i) { DPU_ASSERT(dpu_prepare_xfer(dpu, B_tmp)); } - DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, DPU_MRAM_HEAP_POINTER_NAME, max_rows_per_dpu * n_size_pad * sizeof(T) , n_size_pad * sizeof(T), DPU_XFER_DEFAULT)); + DPU_ASSERT(dpu_push_xfer + (dpu_set, DPU_XFER_TO_DPU, + DPU_MRAM_HEAP_POINTER_NAME, + max_rows_per_dpu * n_size_pad * sizeof(T), + n_size_pad * sizeof(T), DPU_XFER_DEFAULT)); // Copy next matrix of weights i = 0; DPU_FOREACH(dpu_set, dpu, i) { - DPU_ASSERT(dpu_prepare_xfer(dpu, A[lay] + dpu_info[i].prev_rows_dpu * n_size)); + DPU_ASSERT(dpu_prepare_xfer + (dpu, + A[lay] + + dpu_info[i].prev_rows_dpu * + n_size)); } - DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_TO_DPU, DPU_MRAM_HEAP_POINTER_NAME, 0, max_rows_per_dpu * n_size_pad * sizeof(T), DPU_XFER_DEFAULT)); + DPU_ASSERT(dpu_push_xfer + (dpu_set, DPU_XFER_TO_DPU, + DPU_MRAM_HEAP_POINTER_NAME, 0, + max_rows_per_dpu * n_size_pad * sizeof(T), + DPU_XFER_DEFAULT)); - if(rep >= p.n_warmup) + if (rep >= p.n_warmup) stop(&timer, 4); - if (rep >= p.n_warmup) - { + if (rep >= p.n_warmup) { start(&timer, 2, rep - p.n_warmup); #if ENERGY DPU_ASSERT(dpu_probe_start(&probe)); @@ -252,8 +289,7 @@ int main(int argc, char **argv) { DPU_ASSERT(dpu_launch(dpu_set, DPU_SYNCHRONOUS)); - if (rep >= p.n_warmup) - { + if (rep >= p.n_warmup) { stop(&timer, 2); #if ENERGY DPU_ASSERT(dpu_probe_stop(&probe)); @@ -273,16 +309,23 @@ int main(int argc, char **argv) { start(&timer, 3, rep - p.n_warmup); i = 0; DPU_FOREACH(dpu_set, dpu, i) { - DPU_ASSERT(dpu_prepare_xfer(dpu, C_dpu + i * max_rows_per_dpu)); + DPU_ASSERT(dpu_prepare_xfer + (dpu, C_dpu + i * max_rows_per_dpu)); } - DPU_ASSERT(dpu_push_xfer(dpu_set, DPU_XFER_FROM_DPU, DPU_MRAM_HEAP_POINTER_NAME, max_rows_per_dpu * n_size_pad * sizeof(T) + n_size_pad * sizeof(T), max_rows_per_dpu * sizeof(T), DPU_XFER_DEFAULT)); - if(rep >= p.n_warmup) + DPU_ASSERT(dpu_push_xfer + (dpu_set, DPU_XFER_FROM_DPU, + DPU_MRAM_HEAP_POINTER_NAME, + max_rows_per_dpu * n_size_pad * sizeof(T) + + n_size_pad * sizeof(T), + max_rows_per_dpu * sizeof(T), DPU_XFER_DEFAULT)); + if (rep >= p.n_warmup) stop(&timer, 3); } #if ENERGY double acc_energy, avg_energy, acc_time, avg_time; - DPU_ASSERT(dpu_probe_get(&probe, DPU_ENERGY, DPU_ACCUMULATE, &acc_energy)); + DPU_ASSERT(dpu_probe_get + (&probe, DPU_ENERGY, DPU_ACCUMULATE, &acc_energy)); DPU_ASSERT(dpu_probe_get(&probe, DPU_ENERGY, DPU_AVERAGE, &avg_energy)); DPU_ASSERT(dpu_probe_get(&probe, DPU_TIME, DPU_ACCUMULATE, &acc_time)); DPU_ASSERT(dpu_probe_get(&probe, DPU_TIME, DPU_AVERAGE, &avg_time)); @@ -311,23 +354,26 @@ int main(int argc, char **argv) { i = 0; for (n = 0; n < nr_of_dpus; n++) { for (j = 0; j < dpu_info[n].rows_per_dpu; j++) { - if(C[i] != C_dpu[n * max_rows_per_dpu + j]) { + if (C[i] != C_dpu[n * max_rows_per_dpu + j]) { status = false; #if PRINT - printf("%d: %d -- %d\n", i, C[i], C_dpu[n * max_rows_per_dpu + j]); + printf("%d: %d -- %d\n", i, C[i], + C_dpu[n * max_rows_per_dpu + j]); #endif } i++; } } if (status) { - printf("[" ANSI_COLOR_GREEN "OK" ANSI_COLOR_RESET "] Outputs are equal\n"); + printf("[" ANSI_COLOR_GREEN "OK" ANSI_COLOR_RESET + "] Outputs are equal\n"); } else { - printf("[" ANSI_COLOR_RED "ERROR" ANSI_COLOR_RESET "] Outputs differ!\n"); + printf("[" ANSI_COLOR_RED "ERROR" ANSI_COLOR_RESET + "] Outputs differ!\n"); } // Deallocation - for(i = 0; i < NUM_LAYERS; i++) + for (i = 0; i < NUM_LAYERS; i++) free(A[i]); free(A); free(B); diff --git a/MLP/support/common.h b/MLP/support/common.h index 53b2f1c..4b5031b 100755 --- a/MLP/support/common.h +++ b/MLP/support/common.h @@ -3,21 +3,21 @@ // Structures used by both the host and the dpu to communicate information typedef struct { - uint32_t n_size; - uint32_t n_size_pad; - uint32_t nr_rows; - uint32_t max_rows; + uint32_t n_size; + uint32_t n_size_pad; + uint32_t nr_rows; + uint32_t max_rows; } dpu_arguments_t; // Specific information for each DPU struct dpu_info_t { - uint32_t rows_per_dpu; - uint32_t rows_per_dpu_pad; - uint32_t prev_rows_dpu; + uint32_t rows_per_dpu; + uint32_t rows_per_dpu_pad; + uint32_t prev_rows_dpu; }; struct dpu_info_t *dpu_info; -#define NUM_LAYERS 3 +#define NUM_LAYERS 3 #define max(x, y) (x > y ? x : y) #define min(x, y) (x < y ? x : y) diff --git a/MLP/support/params.h b/MLP/support/params.h index f9e790e..4bfc2fc 100644 --- a/MLP/support/params.h +++ b/MLP/support/params.h @@ -4,53 +4,62 @@ #include "common.h" typedef struct Params { - unsigned int m_size; - unsigned int n_size; - unsigned int n_warmup; - unsigned int n_reps; -}Params; + unsigned int m_size; + unsigned int n_size; + unsigned int n_warmup; + unsigned int n_reps; +} Params; -static void usage() { - fprintf(stderr, - "\nUsage: ./program [options]" - "\n" - "\nGeneral options:" - "\n -h help" - "\n -w <W> # of untimed warmup iterations (default=1)" - "\n -e <E> # of timed repetition iterations (default=3)" - "\n" - "\nBenchmark-specific options:" - "\n -m <I> m_size (default=2048 elements)" - "\n -n <I> n_size (default=2048 elements)" - "\n"); +static void usage() +{ + fprintf(stderr, + "\nUsage: ./program [options]" + "\n" + "\nGeneral options:" + "\n -h help" + "\n -w <W> # of untimed warmup iterations (default=1)" + "\n -e <E> # of timed repetition iterations (default=3)" + "\n" + "\nBenchmark-specific options:" + "\n -m <I> m_size (default=2048 elements)" + "\n -n <I> n_size (default=2048 elements)" "\n"); } -struct Params input_params(int argc, char **argv) { - struct Params p; - p.m_size = 163840; - p.n_size = 4096; - p.n_warmup = 1; - p.n_reps = 3; +struct Params input_params(int argc, char **argv) +{ + struct Params p; + p.m_size = 163840; + p.n_size = 4096; + p.n_warmup = 1; + p.n_reps = 3; - int opt; - while((opt = getopt(argc, argv, "hm:n:w:e:")) >= 0) { - switch(opt) { - case 'h': - usage(); - exit(0); - break; - case 'm': p.m_size = atoi(optarg); break; - case 'n': p.n_size = atoi(optarg); break; - case 'w': p.n_warmup = atoi(optarg); break; - case 'e': p.n_reps = atoi(optarg); break; - default: - fprintf(stderr, "\nUnrecognized option!\n"); - usage(); - exit(0); - } - } - assert(NR_DPUS > 0 && "Invalid # of dpus!"); + int opt; + while ((opt = getopt(argc, argv, "hm:n:w:e:")) >= 0) { + switch (opt) { + case 'h': + usage(); + exit(0); + break; + case 'm': + p.m_size = atoi(optarg); + break; + case 'n': + p.n_size = atoi(optarg); + break; + case 'w': + p.n_warmup = atoi(optarg); + break; + case 'e': + p.n_reps = atoi(optarg); + break; + default: + fprintf(stderr, "\nUnrecognized option!\n"); + usage(); + exit(0); + } + } + assert(NR_DPUS > 0 && "Invalid # of dpus!"); - return p; + return p; } #endif diff --git a/MLP/support/timer.h b/MLP/support/timer.h index 886380a..961ed11 100755 --- a/MLP/support/timer.h +++ b/MLP/support/timer.h @@ -1,62 +1,69 @@ -/*
- * Copyright (c) 2016 University of Cordoba and University of Illinois
- * All rights reserved.
- *
- * Developed by: IMPACT Research Group
- * University of Cordoba and University of Illinois
- * http://impact.crhc.illinois.edu/
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * with the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * > Redistributions of source code must retain the above copyright notice,
- * this list of conditions and the following disclaimers.
- * > Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimers in the
- * documentation and/or other materials provided with the distribution.
- * > Neither the names of IMPACT Research Group, University of Cordoba,
- * University of Illinois nor the names of its contributors may be used
- * to endorse or promote products derived from this Software without
- * specific prior written permission.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH
- * THE SOFTWARE.
- *
- */
-
-#include <sys/time.h>
-
-typedef struct Timer{
-
- struct timeval startTime[5];
- struct timeval stopTime[5];
- double time[5];
-
-}Timer;
-
-void start(Timer *timer, int i, int rep) {
- if(rep == 0) {
- timer->time[i] = 0.0;
- }
- gettimeofday(&timer->startTime[i], NULL);
-}
-
-void stop(Timer *timer, int i) {
- gettimeofday(&timer->stopTime[i], NULL);
- timer->time[i] += (timer->stopTime[i].tv_sec - timer->startTime[i].tv_sec) * 1000000.0 +
- (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec);
- //printf("Time (ms): %f\t",((timer->stopTime[i].tv_sec - timer->startTime[i].tv_sec) * 1000000.0 +
- // (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec)) / 1000);
-
-}
-
-void print(Timer *timer, int i, int REP) { printf("%f\t", timer->time[i] / (1000 * REP)); }
+/* + * Copyright (c) 2016 University of Cordoba and University of Illinois + * All rights reserved. + * + * Developed by: IMPACT Research Group + * University of Cordoba and University of Illinois + * http://impact.crhc.illinois.edu/ + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * with the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * > Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimers. + * > Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimers in the + * documentation and/or other materials provided with the distribution. + * > Neither the names of IMPACT Research Group, University of Cordoba, + * University of Illinois nor the names of its contributors may be used + * to endorse or promote products derived from this Software without + * specific prior written permission. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH + * THE SOFTWARE. + * + */ + +#include <sys/time.h> + +typedef struct Timer { + + struct timeval startTime[5]; + struct timeval stopTime[5]; + double time[5]; + +} Timer; + +void start(Timer *timer, int i, int rep) +{ + if (rep == 0) { + timer->time[i] = 0.0; + } + gettimeofday(&timer->startTime[i], NULL); +} + +void stop(Timer *timer, int i) +{ + gettimeofday(&timer->stopTime[i], NULL); + timer->time[i] += + (timer->stopTime[i].tv_sec - + timer->startTime[i].tv_sec) * 1000000.0 + + (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec); + //printf("Time (ms): %f\t",((timer->stopTime[i].tv_sec - timer->startTime[i].tv_sec) * 1000000.0 + + // (timer->stopTime[i].tv_usec - timer->startTime[i].tv_usec)) / 1000); + +} + +void print(Timer *timer, int i, int REP) +{ + printf("%f\t", timer->time[i] / (1000 * REP)); +} |