From 4e7a536918638e09e9f4707685a91fa5e2bb451d Mon Sep 17 00:00:00 2001 From: Blaise Tine Date: Tue, 14 Nov 2023 05:37:46 -0800 Subject: [PATCH] adding tensor regression test. --- kernel/src/vx_spawn.c | 9 +- tests/opencl/matmul/kernel.cl | 54 +++--- tests/opencl/matmul/main.cc | 4 +- tests/regression/Makefile | 6 + tests/regression/basic/main.cpp | 7 +- tests/regression/demo/common.h | 6 +- tests/regression/demo/kernel.cpp | 8 +- tests/regression/demo/main.cpp | 94 ++++++++--- tests/regression/diverge/main.cpp | 7 +- tests/regression/fence/main.cpp | 7 +- tests/regression/io_addr/main.cpp | 11 +- tests/regression/mstress/main.cpp | 11 +- tests/regression/no_mf_ext/main.cpp | 11 +- tests/regression/no_smem/main.cpp | 9 +- tests/regression/printf/main.cpp | 11 +- tests/regression/sort/common.h | 8 +- tests/regression/sort/kernel.cpp | 8 +- tests/regression/sort/main.cpp | 19 +-- tests/regression/tensor/Makefile | 9 + tests/regression/tensor/common.h | 18 ++ tests/regression/tensor/kernel.cpp | 41 +++++ tests/regression/tensor/main.cpp | 249 ++++++++++++++++++++++++++++ 22 files changed, 474 insertions(+), 133 deletions(-) create mode 100644 tests/regression/tensor/Makefile create mode 100644 tests/regression/tensor/common.h create mode 100644 tests/regression/tensor/kernel.cpp create mode 100644 tests/regression/tensor/main.cpp diff --git a/kernel/src/vx_spawn.c b/kernel/src/vx_spawn.c index 14773707..fd8258e1 100644 --- a/kernel/src/vx_spawn.c +++ b/kernel/src/vx_spawn.c @@ -51,9 +51,8 @@ inline char is_log2(int x) { return ((x & (x-1)) == 0); } -inline int fast_log2(int x) { - float f = x; - return (*(int*)(&f)>>23) - 127; +inline int log2_fast(int x) { + return 31 - __builtin_clz (x); } static void __attribute__ ((noinline)) spawn_tasks_all_stub() { @@ -286,8 +285,8 @@ void vx_spawn_kernel(context_t * ctx, vx_spawn_kernel_cb callback, void * arg) { // fast path handling char isXYpow2 = is_log2(XY); - char log2XY = fast_log2(XY); - char log2X = fast_log2(X); + char log2XY = log2_fast(XY); + char log2X = log2_fast(X); wspawn_kernel_args_t wspawn_args = { ctx, callback, arg, core_id * tasks_per_core, fW, rW, isXYpow2, log2XY, log2X diff --git a/tests/opencl/matmul/kernel.cl b/tests/opencl/matmul/kernel.cl index ea9b2156..a0ef2d81 100644 --- a/tests/opencl/matmul/kernel.cl +++ b/tests/opencl/matmul/kernel.cl @@ -5,35 +5,37 @@ __kernel void matmul(__global float *A, __local float *localA, __local float *localB) { - int row = get_global_id(1); - int col = get_global_id(0); + int globalRow = get_global_id(1); + int globalCol = get_global_id(0); int localRow = get_local_id(1); int localCol = get_local_id(0); int localSize = get_local_size(0); // assuming square local size float sum = 0.0f; - // Loop over all blocks of both matrices - for (int k = 0; k < N; k += localSize) { - // Load block of matrix A to local memory - localA[localRow * localSize + localCol] = A[row * N + k + localCol]; + // Load initial blocks of A and B into local memory + int k = 0; + localA[localRow * localSize + localCol] = A[globalRow * N + k + localCol]; + localB[localRow * localSize + localCol] = B[(k + localRow) * N + globalCol]; - // Load block of matrix B to local memory, adjusting for column-major access - localB[localRow * localSize + localCol] = B[(k + localRow) * N + col]; - - // Synchronize to make sure the tiles are loaded + // Iterate over blocks + for (k = 0; k < N; k += 16) { + // Ensure the initial block is loaded barrier(CLK_LOCAL_MEM_FENCE); - // Multiply the two matrix blocks and accumulate result - for (int j = 0; j < localSize; j++) { + // Compute multiplication for this block + for (int j = 0; j < 16; j++) { sum += localA[localRow * localSize + j] * localB[j * localSize + localCol]; } - // Synchronize before loading the next block - barrier(CLK_LOCAL_MEM_FENCE); + // Load the next block of matrix A into local memory + if (k + 16 < N) { + localA[localRow * localSize + localCol] = A[globalRow * N + k + 16 + localCol]; + localB[localRow * localSize + localCol] = B[(k + 16 + localRow) * N + globalCol]; + } } - C[row * N + col] = sum; + C[globalRow * N + globalCol] = sum; } /*__kernel void matmul(__global float *A, __global float *B, __global float *C, const unsigned int N) @@ -49,15 +51,14 @@ __kernel void matmul(__global float *A, float sum = 0.0f; + // Load initial blocks of A and B into local memory + int k = 0; + localA[localRow][localCol] = A[globalRow * N + k + localCol]; + localB[localRow][localCol] = B[(k + localRow) * N + globalCol]; + // Iterate over blocks - for (int k = 0; k < N; k += 16) { - // Load a block of matrix A into local memory - localA[localRow][localCol] = A[globalRow * N + k + localCol]; - - // Load a block of matrix B into local memory - localB[localRow][localCol] = B[(k + localRow) * N + globalCol]; - - // Ensure the entire block is loaded + for (k = 0; k < N; k += 16) { + // Ensure the initial block is loaded barrier(CLK_LOCAL_MEM_FENCE); // Compute multiplication for this block @@ -65,8 +66,11 @@ __kernel void matmul(__global float *A, sum += localA[localRow][j] * localB[j][localCol]; } - // Wait until all threads have computed before loading the next block - barrier(CLK_LOCAL_MEM_FENCE); + // Load the next block of matrix A into local memory + if (k + 16 < N) { + localA[localRow][localCol] = A[globalRow * N + k + 16 + localCol]; + localB[localRow][localCol] = B[(k + 16 + localRow) * N + globalCol]; + } } C[globalRow * N + globalCol] = sum; diff --git a/tests/opencl/matmul/main.cc b/tests/opencl/matmul/main.cc index 8e20a3ef..f7714dd7 100644 --- a/tests/opencl/matmul/main.cc +++ b/tests/opencl/matmul/main.cc @@ -184,8 +184,8 @@ int main (int argc, char **argv) { CL_CHECK(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&b_memobj)); CL_CHECK(clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&c_memobj)); CL_CHECK(clSetKernelArg(kernel, 3, sizeof(uint32_t), &size)); - CL_CHECK(clSetKernelArg(kernel, 4, local_size[0]*local_size[1]*sizeof(float), NULL)); - CL_CHECK(clSetKernelArg(kernel, 5, local_size[0]*local_size[1]*sizeof(float), NULL)); + //CL_CHECK(clSetKernelArg(kernel, 4, local_size[0]*local_size[1]*sizeof(float), NULL)); + //CL_CHECK(clSetKernelArg(kernel, 5, local_size[0]*local_size[1]*sizeof(float), NULL)); // Allocate memories for input arrays and output arrays. std::vector h_a(size * size); diff --git a/tests/regression/Makefile b/tests/regression/Makefile index 5ba29d57..89fa25af 100644 --- a/tests/regression/Makefile +++ b/tests/regression/Makefile @@ -10,6 +10,7 @@ all: $(MAKE) -C fence $(MAKE) -C no_mf_ext $(MAKE) -C no_smem + $(MAKE) -C tensor run-simx: $(MAKE) -C basic run-simx @@ -23,6 +24,7 @@ run-simx: $(MAKE) -C fence run-simx $(MAKE) -C no_mf_ext run-simx $(MAKE) -C no_smem run-simx + $(MAKE) -C tensor run-simx run-rtlsim: $(MAKE) -C basic run-rtlsim @@ -36,6 +38,7 @@ run-rtlsim: $(MAKE) -C fence run-rtlsim $(MAKE) -C no_mf_ext run-rtlsim $(MAKE) -C no_smem run-rtlsim + $(MAKE) -C tensor run-rtlsim run-opae: $(MAKE) -C basic run-opae @@ -49,6 +52,7 @@ run-opae: $(MAKE) -C fence run-opae $(MAKE) -C no_mf_ext run-opae $(MAKE) -C no_smem run-opae + $(MAKE) -C tensor run-opae clean: $(MAKE) -C basic clean @@ -62,6 +66,7 @@ clean: $(MAKE) -C fence clean $(MAKE) -C no_mf_ext clean $(MAKE) -C no_smem clean + $(MAKE) -C tensor clean clean-all: $(MAKE) -C basic clean-all @@ -75,3 +80,4 @@ clean-all: $(MAKE) -C fence clean-all $(MAKE) -C no_mf_ext clean-all $(MAKE) -C no_smem clean-all + $(MAKE) -C tensor clean-all diff --git a/tests/regression/basic/main.cpp b/tests/regression/basic/main.cpp index e79387b5..0f6f3bde 100755 --- a/tests/regression/basic/main.cpp +++ b/tests/regression/basic/main.cpp @@ -262,11 +262,8 @@ int main(int argc, char *argv[]) { // upload kernel argument std::cout << "upload kernel argument" << std::endl; - { - auto buf_ptr = (void*)staging_buf.data(); - memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t)); - RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); - } + memcpy(staging_buf.data(), &kernel_arg, sizeof(kernel_arg_t)); + RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); std::cout << "run kernel test" << std::endl; RT_CHECK(run_kernel_test(kernel_arg, buf_size, num_points)); diff --git a/tests/regression/demo/common.h b/tests/regression/demo/common.h index e18b65a0..941983ac 100644 --- a/tests/regression/demo/common.h +++ b/tests/regression/demo/common.h @@ -3,6 +3,10 @@ #define KERNEL_ARG_DEV_MEM_ADDR 0x7ffff000 +#ifndef TYPE +#define TYPE float +#endif + typedef struct { uint32_t num_tasks; uint32_t task_size; @@ -11,4 +15,4 @@ typedef struct { uint64_t dst_addr; } kernel_arg_t; -#endif \ No newline at end of file +#endif diff --git a/tests/regression/demo/kernel.cpp b/tests/regression/demo/kernel.cpp index deb56169..49945440 100644 --- a/tests/regression/demo/kernel.cpp +++ b/tests/regression/demo/kernel.cpp @@ -4,11 +4,11 @@ #include "common.h" void kernel_body(int task_id, kernel_arg_t* __UNIFORM__ arg) { - uint32_t count = arg->task_size; - int32_t* src0_ptr = (int32_t*)arg->src0_addr; - int32_t* src1_ptr = (int32_t*)arg->src1_addr; - int32_t* dst_ptr = (int32_t*)arg->dst_addr; + auto src0_ptr = reinterpret_cast(arg->src0_addr); + auto src1_ptr = reinterpret_cast(arg->src1_addr); + auto dst_ptr = reinterpret_cast(arg->dst_addr); + uint32_t count = arg->task_size; uint32_t offset = task_id * count; for (uint32_t i = 0; i < count; ++i) { diff --git a/tests/regression/demo/main.cpp b/tests/regression/demo/main.cpp index dfe33377..63556a5f 100644 --- a/tests/regression/demo/main.cpp +++ b/tests/regression/demo/main.cpp @@ -5,6 +5,8 @@ #include #include "common.h" +#define FLOAT_ULP 6 + #define RT_CHECK(_expr) \ do { \ int _ret = _expr; \ @@ -17,10 +19,52 @@ /////////////////////////////////////////////////////////////////////////////// +union Float_t { + float f; + int i; + struct { + uint32_t man : 23; + uint32_t exp : 8; + uint32_t sign : 1; + } parts; +}; + +template +class Comparator {}; + +template <> +class Comparator { +public: + static const char* type_str() { + return "integer"; + } + static bool compare(int a, int b) { + return a == b; + } +}; + +template <> +class Comparator { +public: + static const char* type_str() { + return "float"; + } + static bool compare(float a, float b) { + Float_t fa{a}, fb{b}; + auto d = std::abs(fa.i - fb.i); + if (d > FLOAT_ULP) { + std::cout << "*** almost_equal_ulp: a=" << a << ", b=" << b << ", ulp=" << d << ", ia=" << std::hex << fa.i << ", ib=" << fb.i << std::endl; + return false; + } + return true; + } +}; + const char* kernel_file = "kernel.bin"; -uint32_t count = 0; +uint32_t count = 16; vx_device_h device = nullptr; +std::vector source_data; std::vector staging_buf; kernel_arg_t kernel_arg = {}; @@ -79,11 +123,11 @@ int run_test(const kernel_arg_t& kernel_arg, std::cout << "verify result" << std::endl; { int errors = 0; - auto buf_ptr = (int32_t*)staging_buf.data(); + auto buf_ptr = (TYPE*)staging_buf.data(); for (uint32_t i = 0; i < num_points; ++i) { - int ref = i + i; - int cur = buf_ptr[i]; - if (cur != ref) { + auto ref = source_data[2 * i + 0] + source_data[2 * i + 1]; + auto cur = buf_ptr[i]; + if (!Comparator::compare(cur, ref)) { std::cout << "error at result #" << std::dec << i << std::hex << ": actual 0x" << cur << ", expected 0x" << ref << std::endl; ++errors; @@ -103,9 +147,7 @@ int main(int argc, char *argv[]) { // parse command arguments parse_args(argc, argv); - if (count == 0) { - count = 1; - } + std::srand(50); // open device connection std::cout << "open device connection" << std::endl; @@ -118,8 +160,9 @@ int main(int argc, char *argv[]) { uint32_t num_tasks = num_cores * num_warps * num_threads; uint32_t num_points = count * num_tasks; - uint32_t buf_size = num_points * sizeof(int32_t); + uint32_t buf_size = num_points * sizeof(TYPE); + std::cout << "data type: " << Comparator::type_str() << std::endl; std::cout << "number of points: " << num_points << std::endl; std::cout << "buffer size: " << buf_size << " bytes" << std::endl; @@ -147,18 +190,22 @@ int main(int argc, char *argv[]) { // upload kernel argument std::cout << "upload kernel argument" << std::endl; - { - auto buf_ptr = (int*)staging_buf.data(); - memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t)); - RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); + memcpy(staging_buf.data(), &kernel_arg, sizeof(kernel_arg_t)); + RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); + + // generate source data + source_data.resize(2 * num_points); + for (uint32_t i = 0; i < source_data.size(); ++i) { + auto r = static_cast(std::rand()) / RAND_MAX; + source_data[i] = static_cast(r * 2 * num_points); } // upload source buffer0 { std::cout << "upload source buffer0" << std::endl; - auto buf_ptr = (int32_t*)staging_buf.data(); + auto buf_ptr = (TYPE*)staging_buf.data(); for (uint32_t i = 0; i < num_points; ++i) { - buf_ptr[i] = i-1; + buf_ptr[i] = source_data[2 * i + 0]; } RT_CHECK(vx_copy_to_dev(device, kernel_arg.src0_addr, staging_buf.data(), buf_size)); } @@ -166,23 +213,18 @@ int main(int argc, char *argv[]) { // upload source buffer1 { std::cout << "upload source buffer1" << std::endl; - auto buf_ptr = (int32_t*)staging_buf.data(); + auto buf_ptr = (TYPE*)staging_buf.data(); for (uint32_t i = 0; i < num_points; ++i) { - buf_ptr[i] = i+1; + buf_ptr[i] = source_data[2 * i + 1]; } RT_CHECK(vx_copy_to_dev(device, kernel_arg.src1_addr, staging_buf.data(), buf_size)); } // clear destination buffer - { - std::cout << "clear destination buffer" << std::endl; - auto buf_ptr = (int32_t*)staging_buf.data(); - for (uint32_t i = 0; i < num_points; ++i) { - buf_ptr[i] = 0xdeadbeef; - } - RT_CHECK(vx_copy_to_dev(device, kernel_arg.dst_addr, staging_buf.data(), buf_size)); - } - + std::cout << "clear destination buffer" << std::endl; + memset(staging_buf.data(), 0, num_points * sizeof(TYPE)); + RT_CHECK(vx_copy_to_dev(device, kernel_arg.dst_addr, staging_buf.data(), buf_size)); + // run tests std::cout << "run tests" << std::endl; RT_CHECK(run_test(kernel_arg, buf_size, num_points)); diff --git a/tests/regression/diverge/main.cpp b/tests/regression/diverge/main.cpp index 742f2419..d5de1bc1 100644 --- a/tests/regression/diverge/main.cpp +++ b/tests/regression/diverge/main.cpp @@ -233,11 +233,8 @@ int main(int argc, char *argv[]) { // upload kernel argument std::cout << "upload kernel argument" << std::endl; - { - auto buf_ptr = (int*)staging_buf.data(); - memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t)); - RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); - } + memcpy(staging_buf.data(), &kernel_arg, sizeof(kernel_arg_t)); + RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); // upload source buffer { diff --git a/tests/regression/fence/main.cpp b/tests/regression/fence/main.cpp index d9f2920f..c9225edc 100644 --- a/tests/regression/fence/main.cpp +++ b/tests/regression/fence/main.cpp @@ -147,11 +147,8 @@ int main(int argc, char *argv[]) { // upload kernel argument std::cout << "upload kernel argument" << std::endl; - { - auto buf_ptr = (int*)staging_buf.data(); - memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t)); - RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); - } + memcpy(staging_buf.data(), &kernel_arg, sizeof(kernel_arg_t)); + RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); // upload source buffer0 { diff --git a/tests/regression/io_addr/main.cpp b/tests/regression/io_addr/main.cpp index d4c74aad..0272bfbc 100644 --- a/tests/regression/io_addr/main.cpp +++ b/tests/regression/io_addr/main.cpp @@ -190,13 +190,10 @@ int main(int argc, char *argv[]) { staging_buf.resize(staging_buf_size); // upload kernel argument - { - std::cout << "upload kernel argument" << std::endl; - auto buf_ptr = (int*)staging_buf.data(); - memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t)); - RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); - } - + std::cout << "upload kernel argument" << std::endl; + memcpy(staging_buf.data(), &kernel_arg, sizeof(kernel_arg_t)); + RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); + // upload test address data { std::cout << "upload test address data" << std::endl; diff --git a/tests/regression/mstress/main.cpp b/tests/regression/mstress/main.cpp index ecc867bc..9b527126 100644 --- a/tests/regression/mstress/main.cpp +++ b/tests/regression/mstress/main.cpp @@ -236,13 +236,10 @@ int main(int argc, char *argv[]) { staging_buf.resize(staging_buf_size); // upload kernel argument - { - std::cout << "upload kernel argument" << std::endl; - auto buf_ptr = (int*)staging_buf.data(); - memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t)); - RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); - } - + std::cout << "upload kernel argument" << std::endl; + memcpy(staging_buf.data(), &kernel_arg, sizeof(kernel_arg_t)); + RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); + // upload source buffer0 { std::cout << "upload address buffer" << std::endl; diff --git a/tests/regression/no_mf_ext/main.cpp b/tests/regression/no_mf_ext/main.cpp index 7632dad1..e711b99a 100644 --- a/tests/regression/no_mf_ext/main.cpp +++ b/tests/regression/no_mf_ext/main.cpp @@ -136,13 +136,10 @@ int main(int argc, char *argv[]) { staging_buf.resize(alloc_size); // upload kernel argument - { - std::cout << "upload kernel argument" << std::endl; - auto buf_ptr = (int*)staging_buf.data(); - memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t)); - RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); - } - + std::cout << "upload kernel argument" << std::endl; + memcpy(staging_buf.data(), &kernel_arg, sizeof(kernel_arg_t)); + RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); + // upload source buffer0 { std::cout << "upload source buffer" << std::endl; diff --git a/tests/regression/no_smem/main.cpp b/tests/regression/no_smem/main.cpp index 8bb00389..53db0465 100644 --- a/tests/regression/no_smem/main.cpp +++ b/tests/regression/no_smem/main.cpp @@ -135,13 +135,10 @@ int main(int argc, char *argv[]) { uint32_t alloc_size = std::max(buf_size, sizeof(kernel_arg_t)); staging_buf.resize(alloc_size); - // upload kernel argument + // upload kernel argument std::cout << "upload kernel argument" << std::endl; - { - auto buf_ptr = (int*)staging_buf.data(); - memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t)); - RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); - } + memcpy(staging_buf.data(), &kernel_arg, sizeof(kernel_arg_t)); + RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); // upload source buffer0 { diff --git a/tests/regression/printf/main.cpp b/tests/regression/printf/main.cpp index 4b13faad..3a920294 100644 --- a/tests/regression/printf/main.cpp +++ b/tests/regression/printf/main.cpp @@ -110,13 +110,10 @@ int main(int argc, char *argv[]) { staging_buf.resize(alloc_size); // upload kernel argument - { - std::cout << "upload kernel argument" << std::endl; - auto buf_ptr = (void*)staging_buf.data(); - memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t)); - RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); - } - + std::cout << "upload kernel argument" << std::endl; + memcpy(staging_buf.data(), &kernel_arg, sizeof(kernel_arg_t)); + RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); + // upload source buffer0 { std::cout << "upload source buffer" << std::endl; diff --git a/tests/regression/sort/common.h b/tests/regression/sort/common.h index 492e03c6..92ceeb91 100644 --- a/tests/regression/sort/common.h +++ b/tests/regression/sort/common.h @@ -3,11 +3,7 @@ #define KERNEL_ARG_DEV_MEM_ADDR 0x7ffff000 -#define FP_ENABLE - -#ifdef FP_ENABLE -#define TYPE float -#else +#ifndef TYPE #define TYPE int #endif @@ -17,4 +13,4 @@ typedef struct { uint64_t dst_addr; } kernel_arg_t; -#endif \ No newline at end of file +#endif diff --git a/tests/regression/sort/kernel.cpp b/tests/regression/sort/kernel.cpp index 0cd7074e..2e9d3453 100644 --- a/tests/regression/sort/kernel.cpp +++ b/tests/regression/sort/kernel.cpp @@ -5,14 +5,14 @@ void kernel_body(int task_id, kernel_arg_t* __UNIFORM__ arg) { uint32_t num_points = arg->num_points; - TYPE* src_ptr = (TYPE*)arg->src_addr; - TYPE* dst_ptr = (TYPE*)arg->dst_addr; + auto src_ptr = (TYPE*)arg->src_addr; + auto dst_ptr = (TYPE*)arg->dst_addr; - TYPE ref_value = src_ptr[task_id]; + auto ref_value = src_ptr[task_id]; uint32_t pos = 0; for (uint32_t i = 0; i < num_points; ++i) { - TYPE cur_value = src_ptr[i]; + auto cur_value = src_ptr[i]; pos += (cur_value < ref_value) || ((cur_value == ref_value) && (i < task_id)); } dst_ptr[pos] = ref_value; diff --git a/tests/regression/sort/main.cpp b/tests/regression/sort/main.cpp index 59796f73..38d5d4d4 100644 --- a/tests/regression/sort/main.cpp +++ b/tests/regression/sort/main.cpp @@ -66,8 +66,8 @@ void gen_input_data(uint32_t num_points) { src_data.resize(num_points); for (uint32_t i = 0; i < num_points; ++i) { - float r = static_cast(std::rand()) / RAND_MAX; - TYPE value = r * num_points; + auto r = static_cast(std::rand()) / RAND_MAX; + auto value = static_cast(r * num_points); src_data[i] = value; std::cout << std::dec << i << ": value=" << value << std::endl; } @@ -172,19 +172,16 @@ int main(int argc, char *argv[]) { { std::cout << "allocate staging buffer" << std::endl; uint32_t staging_buf_size = std::max(src_buf_size, - std::max(dst_buf_size, - sizeof(kernel_arg_t))); + std::max(dst_buf_size, + sizeof(kernel_arg_t))); staging_buf.resize(staging_buf_size); } // upload kernel argument - { - std::cout << "upload kernel argument" << std::endl; - auto buf_ptr = staging_buf.data(); - memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t)); - RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); - } - + std::cout << "upload kernel argument" << std::endl; + memcpy(staging_buf.data(), &kernel_arg, sizeof(kernel_arg_t)); + RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); + // upload source buffer { std::cout << "upload source buffer" << std::endl; diff --git a/tests/regression/tensor/Makefile b/tests/regression/tensor/Makefile new file mode 100644 index 00000000..790664dc --- /dev/null +++ b/tests/regression/tensor/Makefile @@ -0,0 +1,9 @@ +PROJECT = tensor + +SRCS = main.cpp + +VX_SRCS = kernel.cpp + +OPTS ?= -s16 + +include ../common.mk \ No newline at end of file diff --git a/tests/regression/tensor/common.h b/tests/regression/tensor/common.h new file mode 100644 index 00000000..75cfc340 --- /dev/null +++ b/tests/regression/tensor/common.h @@ -0,0 +1,18 @@ +#ifndef _COMMON_H_ +#define _COMMON_H_ + +#define KERNEL_ARG_DEV_MEM_ADDR 0x7ffff000 + +#ifndef TYPE +#define TYPE float +#endif + +typedef struct { + uint32_t num_tasks; + uint32_t size; + uint64_t A_addr; + uint64_t B_addr; + uint64_t C_addr; +} kernel_arg_t; + +#endif diff --git a/tests/regression/tensor/kernel.cpp b/tests/regression/tensor/kernel.cpp new file mode 100644 index 00000000..5cf0851c --- /dev/null +++ b/tests/regression/tensor/kernel.cpp @@ -0,0 +1,41 @@ +#include +#include +#include +#include "common.h" + +inline char is_log2(uint32_t x) { + return ((x & (x-1)) == 0); +} + +inline uint32_t log2_fast(uint32_t x) { + return 31 - __builtin_clz (x); +} + +void kernel_body(uint32_t task_id, kernel_arg_t* __UNIFORM__ arg) { + auto size = arg->size; + auto A = reinterpret_cast(arg->A_addr); + auto B = reinterpret_cast(arg->B_addr); + auto C = reinterpret_cast(arg->C_addr); + + uint32_t row, col; + if (is_log2(size)) { + uint32_t log_size = log2_fast(size); + row = task_id >> log_size; + col = task_id & (size-1); + } else { + row = task_id / size; + col = task_id % size; + } + + TYPE sum (0); + for (int e = 0; e < size; ++e) { + sum += A[row * size + e] * B[e * size + col]; + } + C[row * size + col] = sum; +} + +int main() { + kernel_arg_t* arg = (kernel_arg_t*)KERNEL_ARG_DEV_MEM_ADDR; + vx_spawn_tasks(arg->num_tasks, (vx_spawn_tasks_cb)kernel_body, arg); + return 0; +} diff --git a/tests/regression/tensor/main.cpp b/tests/regression/tensor/main.cpp new file mode 100644 index 00000000..d93f3177 --- /dev/null +++ b/tests/regression/tensor/main.cpp @@ -0,0 +1,249 @@ +#include +#include +#include +#include +#include +#include "common.h" + +#define FLOAT_ULP 6 + +#define RT_CHECK(_expr) \ + do { \ + int _ret = _expr; \ + if (0 == _ret) \ + break; \ + printf("Error: '%s' returned %d!\n", #_expr, (int)_ret); \ + cleanup(); \ + exit(-1); \ + } while (false) + +/////////////////////////////////////////////////////////////////////////////// + +union Float_t { + float f; + int i; + struct { + uint32_t man : 23; + uint32_t exp : 8; + uint32_t sign : 1; + } parts; +}; + +template +class Comparator {}; + +template <> +class Comparator { +public: + static const char* type_str() { + return "integer"; + } + static bool compare(int a, int b) { + return a == b; + } +}; + +template <> +class Comparator { +public: + static const char* type_str() { + return "float"; + } + static bool compare(float a, float b) { + Float_t fa{a}, fb{b}; + auto d = std::abs(fa.i - fb.i); + if (d > FLOAT_ULP) { + std::cout << "*** almost_equal_ulp: a=" << a << ", b=" << b << ", ulp=" << d << ", ia=" << std::hex << fa.i << ", ib=" << fb.i << std::endl; + return false; + } + return true; + } +}; + +static void cpuMatrixMultiply(TYPE* out, const TYPE* A, const TYPE* B, uint32_t width, uint32_t height) { + for (uint32_t row = 0; row < height; ++row) { + for (uint32_t col = 0; col < width; ++col) { + TYPE sum(0); + for (uint32_t e = 0; e < width; ++e) { + sum += A[row * width + e] * B[e * width + col]; + } + out[row * width + col] = sum; + } + } +} + +const char* kernel_file = "kernel.bin"; +uint32_t size = 16; + +vx_device_h device = nullptr; +std::vector staging_buf; +kernel_arg_t kernel_arg = {}; + +static void show_usage() { + std::cout << "Vortex Test." << std::endl; + std::cout << "Usage: [-k: kernel] [-s size] [-h: help]" << std::endl; +} + +static void parse_args(int argc, char **argv) { + int c; + while ((c = getopt(argc, argv, "s:k:h?")) != -1) { + switch (c) { + case 's': + size = atoi(optarg); + break; + case 'k': + kernel_file = optarg; + break; + case 'h': + case '?': { + show_usage(); + exit(0); + } break; + default: + show_usage(); + exit(-1); + } + } +} + +void cleanup() { + if (device) { + vx_mem_free(device, kernel_arg.A_addr); + vx_mem_free(device, kernel_arg.B_addr); + vx_mem_free(device, kernel_arg.C_addr); + vx_dev_close(device); + } +} + +int run_test(const kernel_arg_t& kernel_arg, + uint32_t buf_size, + const std::vector& refs) { + // start device + std::cout << "start device" << std::endl; + RT_CHECK(vx_start(device)); + + // wait for completion + std::cout << "wait for completion" << std::endl; + RT_CHECK(vx_ready_wait(device, VX_MAX_TIMEOUT)); + + // download destination buffer + std::cout << "download destination buffer" << std::endl; + RT_CHECK(vx_copy_from_dev(device, staging_buf.data(), kernel_arg.C_addr, buf_size)); + + // verify result + std::cout << "verify result" << std::endl; + { + int errors = 0; + auto buf_ptr = (TYPE*)staging_buf.data(); + for (uint32_t i = 0; i < refs.size(); ++i) { + auto ref = refs[i]; + auto cur = buf_ptr[i]; + if (!Comparator::compare(cur, ref)) { + std::cout << "error at result #" << std::dec << i + << std::hex << ": actual 0x" << cur << ", expected 0x" << ref << std::endl; + ++errors; + } + } + if (errors != 0) { + std::cout << "Found " << std::dec << errors << " errors!" << std::endl; + std::cout << "FAILED!" << std::endl; + return 1; + } + } + + return 0; +} + +int main(int argc, char *argv[]) { + // parse command arguments + parse_args(argc, argv); + + std::srand(50); + + // open device connection + std::cout << "open device connection" << std::endl; + RT_CHECK(vx_dev_open(&device)); + + uint32_t num_points = size * size; + uint32_t buf_size = num_points * sizeof(TYPE); + + std::cout << "data type: " << Comparator::type_str() << std::endl; + std::cout << "matrix size: " << size << "x" << size << std::endl; + std::cout << "buffer size: " << buf_size << " bytes" << std::endl; + + // upload program + std::cout << "upload program" << std::endl; + RT_CHECK(vx_upload_kernel_file(device, kernel_file)); + + // allocate device memory + std::cout << "allocate device memory" << std::endl; + RT_CHECK(vx_mem_alloc(device, buf_size, VX_MEM_TYPE_GLOBAL, &kernel_arg.A_addr)); + RT_CHECK(vx_mem_alloc(device, buf_size, VX_MEM_TYPE_GLOBAL, &kernel_arg.B_addr)); + RT_CHECK(vx_mem_alloc(device, buf_size, VX_MEM_TYPE_GLOBAL, &kernel_arg.C_addr)); + + kernel_arg.num_tasks = num_points; + kernel_arg.size = size; + + std::cout << "dev_src0=0x" << std::hex << kernel_arg.A_addr << std::endl; + std::cout << "dev_src1=0x" << std::hex << kernel_arg.B_addr << std::endl; + std::cout << "dev_dst=0x" << std::hex << kernel_arg.C_addr << std::endl; + + // allocate staging buffer + std::cout << "allocate staging buffer" << std::endl; + uint32_t alloc_size = std::max(buf_size, sizeof(kernel_arg_t)); + staging_buf.resize(alloc_size); + + // upload kernel argument + std::cout << "upload kernel argument" << std::endl; + memcpy(staging_buf.data(), &kernel_arg, sizeof(kernel_arg_t)); + RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t))); + + // generate source data + std::vector src_A(num_points); + std::vector src_B(num_points); + std::vector refs(num_points); + for (uint32_t i = 0; i < num_points; ++i) { + auto a = static_cast(std::rand()) / RAND_MAX; + auto b = static_cast(std::rand()) / RAND_MAX; + src_A[i] = static_cast(a * size); + src_B[i] = static_cast(b * size); + } + cpuMatrixMultiply(refs.data(), src_A.data(), src_B.data(), size, size); + + // upload source buffer0 + { + std::cout << "upload source buffer0" << std::endl; + auto buf_ptr = (TYPE*)staging_buf.data(); + for (uint32_t i = 0; i < num_points; ++i) { + buf_ptr[i] = src_A[i]; + } + RT_CHECK(vx_copy_to_dev(device, kernel_arg.A_addr, staging_buf.data(), buf_size)); + } + + // upload source buffer1 + { + std::cout << "upload source buffer1" << std::endl; + auto buf_ptr = (TYPE*)staging_buf.data(); + for (uint32_t i = 0; i < num_points; ++i) { + buf_ptr[i] = src_B[i]; + } + RT_CHECK(vx_copy_to_dev(device, kernel_arg.B_addr, staging_buf.data(), buf_size)); + } + + // clear destination buffer + std::cout << "clear destination buffer" << std::endl; + memset(staging_buf.data(), 0, num_points * sizeof(TYPE)); + RT_CHECK(vx_copy_to_dev(device, kernel_arg.C_addr, staging_buf.data(), buf_size)); + + // run tests + std::cout << "run tests" << std::endl; + RT_CHECK(run_test(kernel_arg, buf_size, refs)); + + // cleanup + std::cout << "cleanup" << std::endl; + cleanup(); + + std::cout << "PASSED!" << std::endl; + + return 0; +} \ No newline at end of file