Merge remote-tracking branch 'upstream/master' into kernels

tests/regression/Makefile

@@ -10,6 +10,8 @@ all:
 	$(MAKE) -C fence
 	$(MAKE) -C no_mf_ext
 	$(MAKE) -C no_smem
+	$(MAKE) -C vecaddx
+	$(MAKE) -C sgemmx
 
 run-simx:
 	$(MAKE) -C basic run-simx
@@ -23,6 +25,8 @@ run-simx:
 	$(MAKE) -C fence run-simx
 	$(MAKE) -C no_mf_ext run-simx
 	$(MAKE) -C no_smem run-simx
+	$(MAKE) -C vecaddx run-simx
+	$(MAKE) -C sgemmx run-simx
 
 run-rtlsim:
 	$(MAKE) -C basic run-rtlsim
@@ -36,6 +40,8 @@ run-rtlsim:
 	$(MAKE) -C fence run-rtlsim
 	$(MAKE) -C no_mf_ext run-rtlsim
 	$(MAKE) -C no_smem run-rtlsim
+	$(MAKE) -C vecaddx run-rtlsim
+	$(MAKE) -C sgemmx run-rtlsim
 
 run-opae:
 	$(MAKE) -C basic run-opae
@@ -49,6 +55,8 @@ run-opae:
 	$(MAKE) -C fence run-opae
 	$(MAKE) -C no_mf_ext run-opae
 	$(MAKE) -C no_smem run-opae
+	$(MAKE) -C vecaddx run-opae
+	$(MAKE) -C sgemmx run-opae
 
 clean:
 	$(MAKE) -C basic clean
@@ -62,6 +70,8 @@ clean:
 	$(MAKE) -C fence clean
 	$(MAKE) -C no_mf_ext clean
 	$(MAKE) -C no_smem clean
+	$(MAKE) -C vecaddx clean
+	$(MAKE) -C sgemmx clean
 
 clean-all:
 	$(MAKE) -C basic clean-all
@@ -75,3 +85,5 @@ clean-all:
 	$(MAKE) -C fence clean-all
 	$(MAKE) -C no_mf_ext clean-all
 	$(MAKE) -C no_smem clean-all
+	$(MAKE) -C vecaddx clean-all
+	$(MAKE) -C sgemmx clean-all

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));

tests/regression/common.mk

@@ -1,16 +1,18 @@
 XLEN ?= 32
 
+TOOLDIR ?= /opt
+
 TARGET ?= opaesim
 
 XRT_SYN_DIR ?= ../../../hw/syn/xilinx/xrt
 XRT_DEVICE_INDEX ?= 0
 
 ifeq ($(XLEN),64)
-RISCV_TOOLCHAIN_PATH ?= /opt/riscv64-gnu-toolchain
+RISCV_TOOLCHAIN_PATH ?= $(TOOLDIR)/riscv64-gnu-toolchain
 VX_CFLAGS += -march=rv64imafd -mabi=lp64d
 STARTUP_ADDR ?= 0x180000000
 else
-RISCV_TOOLCHAIN_PATH ?= /opt/riscv-gnu-toolchain
+RISCV_TOOLCHAIN_PATH ?= $(TOOLDIR)/riscv-gnu-toolchain
 VX_CFLAGS += -march=rv32imaf -mabi=ilp32f
 STARTUP_ADDR ?= 0x80000000
 endif
@@ -23,7 +25,7 @@ VORTEX_KN_PATH ?= $(realpath ../../../kernel)
 
 FPGA_BIN_DIR ?= $(VORTEX_RT_PATH)/opae
 
-LLVM_VORTEX ?= /opt/llvm-vortex
+LLVM_VORTEX ?= $(TOOLDIR)/llvm-vortex
 
 LLVM_CFLAGS += --sysroot=$(RISCV_SYSROOT)
 LLVM_CFLAGS += --gcc-toolchain=$(RISCV_TOOLCHAIN_PATH)

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
+#endif

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<TYPE*>(arg->src0_addr);
+	auto src1_ptr = reinterpret_cast<TYPE*>(arg->src1_addr);
+	auto dst_ptr = reinterpret_cast<TYPE*>(arg->dst_addr);
 	
+	uint32_t count = arg->task_size;
 	uint32_t offset = task_id * count;
 
 	for (uint32_t i = 0; i < count; ++i) {

tests/regression/demo/main.cpp

@@ -5,6 +5,8 @@
 #include <vortex.h>
 #include "common.h"
 
+#define FLOAT_ULP 6
+
 #define RT_CHECK(_expr)                                         \
    do {                                                         \
      int _ret = _expr;                                          \
@@ -17,10 +19,61 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
+template <typename Type>
+class Comparator {};
+
+template <>
+class Comparator<int> {
+public:
+  static const char* type_str() {
+    return "integer";
+  }
+  static int generate() { 
+    return rand(); 
+  }
+  static bool compare(int a, int b, int index, int errors) { 
+    if (a != b) {
+      if (errors < 100) {
+        printf("*** error: [%d] expected=%d, actual=%d\n", index, a, b);
+      }
+      return false;
+    }
+    return true;
+  }  
+};
+
+template <>
+class Comparator<float> {
+private:
+  union Float_t { float f; int i; };
+public:
+  static const char* type_str() {
+    return "float";
+  }
+  static int generate() { 
+    return static_cast<float>(rand()) / RAND_MAX;
+  }
+  static bool compare(float a, float b, int index, int errors) {     
+    union fi_t { float f; int32_t i; };
+    fi_t fa, fb;
+    fa.f = a;
+    fb.f = b;
+    auto d = std::abs(fa.i - fb.i);
+    if (d > FLOAT_ULP) {
+      if (errors < 100) {
+        printf("*** error: [%d] expected=%f, actual=%f\n", index, a, b);
+      }
+      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<TYPE> source_data;
 std::vector<uint8_t> staging_buf;
 kernel_arg_t kernel_arg = {};
 
@@ -79,13 +132,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) {
-        std::cout << "error at result #" << std::dec << i
-                  << std::hex << ": actual 0x" << cur << ", expected 0x" << ref << std::endl;
+      auto ref = source_data[2 * i + 0] + source_data[2 * i + 1];
+      auto cur = buf_ptr[i];
+      if (!Comparator<TYPE>::compare(cur, ref, i, errors)) {
         ++errors;
       }
     }
@@ -103,9 +154,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 +167,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>::type_str() << std::endl;
   std::cout << "number of points: " << num_points << std::endl;
   std::cout << "buffer size: " << buf_size << " bytes" << std::endl;
 
@@ -147,18 +197,21 @@ 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) {
+    source_data[i] = Comparator<TYPE>::generate();
   }
 
   // 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 +219,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));

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
   {

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
   {

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;

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;

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;

tests/regression/no_smem/main.cpp

@@ -135,13 +135,10 @@ int main(int argc, char *argv[]) {
   uint32_t alloc_size = std::max<uint32_t>(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
   {

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;

tests/regression/sgemmx/Makefile

@@ -0,0 +1,9 @@
+PROJECT = sgemmx
+
+SRCS = main.cpp
+
+VX_SRCS = kernel.cpp
+
+OPTS ?= -n32
+
+include ../common.mk

tests/regression/sgemmx/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

tests/regression/sgemmx/kernel.cpp

@@ -0,0 +1,41 @@
+#include <stdint.h>
+#include <vx_intrinsics.h>
+#include <vx_spawn.h>
+#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 A = reinterpret_cast<TYPE*>(arg->A_addr);
+	auto B = reinterpret_cast<TYPE*>(arg->B_addr);
+	auto C = reinterpret_cast<TYPE*>(arg->C_addr);
+    auto size  = arg->size;
+
+    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;
+}

tests/regression/sgemmx/main.cpp

@@ -0,0 +1,251 @@
+#include <iostream>
+#include <unistd.h>
+#include <string.h>
+#include <vector>
+#include <chrono>
+#include <vortex.h>
+#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)
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename Type>
+class Comparator {};
+
+template <>
+class Comparator<int> {
+public:
+  static const char* type_str() {
+    return "integer";
+  }
+  static int generate() { 
+    return rand(); 
+  }
+  static bool compare(int a, int b, int index, int errors) { 
+    if (a != b) {
+      if (errors < 100) {
+        printf("*** error: [%d] expected=%d, actual=%d\n", index, a, b);
+      }
+      return false;
+    }
+    return true;
+  }  
+};
+
+template <>
+class Comparator<float> {
+public:
+  static const char* type_str() {
+    return "float";
+  }
+  static int generate() { 
+    return static_cast<float>(rand()) / RAND_MAX;
+  }
+  static bool compare(float a, float b, int index, int errors) { 
+    union fi_t { float f; int32_t i; };
+    fi_t fa, fb;
+    fa.f = a;
+    fb.f = b;
+    auto d = std::abs(fa.i - fb.i);
+    if (d > FLOAT_ULP) {
+      if (errors < 100) {
+        printf("*** error: [%d] expected=%f, actual=%f\n", index, a, b);
+      }
+      return false;
+    }
+    return true;
+  }  
+};
+
+static void matmul_cpu(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 = 32;
+
+vx_device_h device = nullptr;
+std::vector<uint8_t> staging_buf;
+kernel_arg_t kernel_arg = {};
+
+static void show_usage() {
+   std::cout << "Vortex Test." << std::endl;
+   std::cout << "Usage: [-k: kernel] [-n size] [-h: help]" << std::endl;
+}
+
+static void parse_args(int argc, char **argv) {
+  int c;
+  while ((c = getopt(argc, argv, "n:k:h?")) != -1) {
+    switch (c) {
+    case 'n':
+      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 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>::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<uint32_t>(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<TYPE> src_A(num_points);
+  std::vector<TYPE> src_B(num_points);
+  std::vector<TYPE> refs(num_points);
+  for (uint32_t i = 0; i < num_points; ++i) {
+    auto a = static_cast<float>(std::rand()) / RAND_MAX;
+    auto b = static_cast<float>(std::rand()) / RAND_MAX;
+    src_A[i] = static_cast<TYPE>(a * size);
+    src_B[i] = static_cast<TYPE>(b * size);
+  }
+  matmul_cpu(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));  
+
+  auto time_start = std::chrono::high_resolution_clock::now();
+  
+  // 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));  
+
+  auto time_end = std::chrono::high_resolution_clock::now();
+  double elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(time_end - time_start).count();
+  printf("Elapsed time: %lg ms\n", elapsed);
+
+  // 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<TYPE>::compare(cur, ref, i, errors)) {
+        ++errors;
+      }
+    }
+    if (errors != 0) {
+      std::cout << "Found " << std::dec << errors << " errors!" << std::endl;
+      std::cout << "FAILED!" << std::endl;
+      return 1;  
+    }
+  }
+
+  // cleanup
+  std::cout << "cleanup" << std::endl;  
+  cleanup();
+
+  std::cout << "PASSED!" << std::endl;
+
+  return 0;
+}

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
+#endif

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;

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<float>(std::rand()) / RAND_MAX;
-    TYPE value = r * num_points;
+    auto r = static_cast<float>(std::rand()) / RAND_MAX;
+    auto value = static_cast<TYPE>(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<uint32_t>(src_buf_size,
-                                    std::max<uint32_t>(dst_buf_size, 
-                                      sizeof(kernel_arg_t)));
+                                  std::max<uint32_t>(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;

tests/regression/vecaddx/Makefile

@@ -0,0 +1,9 @@
+PROJECT = vecaddx
+
+SRCS = main.cpp
+
+VX_SRCS = kernel.cpp
+
+OPTS ?= -n64
+
+include ../common.mk

tests/regression/vecaddx/common.h

@@ -0,0 +1,17 @@
+#ifndef _COMMON_H_
+#define _COMMON_H_
+
+#define KERNEL_ARG_DEV_MEM_ADDR 0x7ffff000
+
+#ifndef TYPE
+#define TYPE float
+#endif
+
+typedef struct {
+  uint32_t num_points;
+  uint64_t src0_addr;
+  uint64_t src1_addr;
+  uint64_t dst_addr;  
+} kernel_arg_t;
+
+#endif

tests/regression/vecaddx/kernel.cpp

@@ -0,0 +1,18 @@
+#include <stdint.h>
+#include <vx_intrinsics.h>
+#include <vx_spawn.h>
+#include "common.h"
+
+void kernel_body(int task_id, kernel_arg_t* __UNIFORM__ arg) {
+	auto src0_ptr = reinterpret_cast<TYPE*>(arg->src0_addr);
+	auto src1_ptr = reinterpret_cast<TYPE*>(arg->src1_addr);
+	auto dst_ptr  = reinterpret_cast<TYPE*>(arg->dst_addr);
+
+	dst_ptr[task_id] = src0_ptr[task_id] + src1_ptr[task_id];
+}
+
+int main() {
+	kernel_arg_t* arg = (kernel_arg_t*)KERNEL_ARG_DEV_MEM_ADDR;
+	vx_spawn_tasks(arg->num_points, (vx_spawn_tasks_cb)kernel_body, arg);
+	return 0;
+}

tests/regression/vecaddx/main.cpp

@@ -0,0 +1,246 @@
+#include <iostream>
+#include <unistd.h>
+#include <string.h>
+#include <vector>
+#include <vortex.h>
+#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)
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <typename Type>
+class Comparator {};
+
+template <>
+class Comparator<int> {
+public:
+  static const char* type_str() {
+    return "integer";
+  }
+  static int generate() { 
+    return rand(); 
+  }
+  static bool compare(int a, int b, int index, int errors) { 
+    if (a != b) {
+      if (errors < 100) {
+        printf("*** error: [%d] expected=%d, actual=%d\n", index, a, b);
+      }
+      return false;
+    }
+    return true;
+  }  
+};
+
+template <>
+class Comparator<float> {
+private:
+  union Float_t { float f; int i; };
+public:
+  static const char* type_str() {
+    return "float";
+  }
+  static int generate() { 
+    return static_cast<float>(rand()) / RAND_MAX;
+  }
+  static bool compare(float a, float b, int index, int errors) {     
+    union fi_t { float f; int32_t i; };
+    fi_t fa, fb;
+    fa.f = a;
+    fb.f = b;
+    auto d = std::abs(fa.i - fb.i);
+    if (d > FLOAT_ULP) {
+      if (errors < 100) {
+        printf("*** error: [%d] expected=%f, actual=%f\n", index, a, b);
+      }
+      return false;
+    }
+    return true;
+  }  
+};
+
+const char* kernel_file = "kernel.bin";
+uint32_t size = 16;
+
+vx_device_h device = nullptr;
+std::vector<TYPE> source_data;
+std::vector<uint8_t> staging_buf;
+kernel_arg_t kernel_arg = {};
+
+static void show_usage() {
+   std::cout << "Vortex Test." << std::endl;
+   std::cout << "Usage: [-k: kernel] [-n words] [-h: help]" << std::endl;
+}
+
+static void parse_args(int argc, char **argv) {
+  int c;
+  while ((c = getopt(argc, argv, "n:k:h?")) != -1) {
+    switch (c) {
+    case 'n':
+      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.src0_addr);
+    vx_mem_free(device, kernel_arg.src1_addr);
+    vx_mem_free(device, kernel_arg.dst_addr);
+    vx_dev_close(device);
+  }
+}
+
+int run_test(const kernel_arg_t& kernel_arg,
+             uint32_t buf_size, 
+             uint32_t num_points) {              
+  // 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.dst_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 < num_points; ++i) {
+      auto ref = source_data[2 * i + 0] + source_data[2 * i + 1];
+      auto cur = buf_ptr[i];
+      if (!Comparator<TYPE>::compare(cur, ref, i, errors)) {
+        ++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));
+
+  uint64_t num_cores, num_warps, num_threads;
+  RT_CHECK(vx_dev_caps(device, VX_CAPS_NUM_CORES, &num_cores));
+  RT_CHECK(vx_dev_caps(device, VX_CAPS_NUM_WARPS, &num_warps));
+  RT_CHECK(vx_dev_caps(device, VX_CAPS_NUM_THREADS, &num_threads));
+  std::cout << "number of cores: " << num_cores << std::endl;
+  std::cout << "number of warps: " << num_warps << std::endl;
+  std::cout << "number of threads: " << num_threads << std::endl;
+
+  uint32_t num_points = size;  
+  uint32_t buf_size = num_points * sizeof(TYPE);
+
+  std::cout << "number of points: " << num_points << std::endl;  
+  std::cout << "data type: " << Comparator<TYPE>::type_str() << 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.src0_addr));
+  RT_CHECK(vx_mem_alloc(device, buf_size, VX_MEM_TYPE_GLOBAL, &kernel_arg.src1_addr));
+  RT_CHECK(vx_mem_alloc(device, buf_size, VX_MEM_TYPE_GLOBAL, &kernel_arg.dst_addr));
+
+  kernel_arg.num_points = num_points;
+
+  std::cout << "dev_src0=0x" << std::hex << kernel_arg.src0_addr << std::endl;
+  std::cout << "dev_src1=0x" << std::hex << kernel_arg.src1_addr << std::endl;
+  std::cout << "dev_dst=0x" << std::hex << kernel_arg.dst_addr << std::endl;
+  
+  // allocate staging buffer  
+  std::cout << "allocate staging buffer" << std::endl;    
+  uint32_t alloc_size = std::max<uint32_t>(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
+  source_data.resize(2 * num_points);
+  for (uint32_t i = 0; i < source_data.size(); ++i) {
+    source_data[i] = Comparator<TYPE>::generate();
+  }
+
+  // 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] = source_data[2 * i + 0];
+    }
+    RT_CHECK(vx_copy_to_dev(device, kernel_arg.src0_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] = 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;
+  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));
+
+  // cleanup
+  std::cout << "cleanup" << std::endl;  
+  cleanup();
+
+  std::cout << "PASSED!" << std::endl;
+
+  return 0;
+}