Added 64 bit basic test

tests/regression/basic64/Makefile

@@ -0,0 +1,74 @@
+RISCV64_TOOLCHAIN_PATH ?= /nethome/ssrivatsan8/riscv
+RISCV_TOOLCHAIN_PATH ?= /opt/riscv-gnu-toolchain
+VORTEX_DRV_PATH ?= $(realpath ../../../driver)
+VORTEX_RT_PATH ?= $(realpath ../../../runtime)
+
+OPTS ?= -n256
+
+VX_CC  = $(RISCV64_TOOLCHAIN_PATH)/bin/riscv64-unknown-elf-gcc
+VX_CXX = $(RISCV64_TOOLCHAIN_PATH)/bin/riscv64-unknown-elf-g++
+VX_DP  = $(RISCV64_TOOLCHAIN_PATH)/bin/riscv64-unknown-elf-objdump
+VX_CP  = $(RISCV64_TOOLCHAIN_PATH)/bin/riscv64-unknown-elf-objcopy
+
+# https://www.sifive.com/blog/all-aboard-part-1-compiler-args
+# find march and mabi combinations by navigating to the riscv64-unknown-elf-toolchain directory
+# and running ./riscv64-unknown-elf-gcc --print-multi-lib
+VX_CFLAGS += -march=rv64i -mabi=lp64 -O3 -Wstack-usage=1024 -ffreestanding -nostartfiles -fdata-sections -ffunction-sections
+VX_CFLAGS += -I$(VORTEX_RT_PATH)/include -I$(VORTEX_RT_PATH)/../hw
+
+VX_LDFLAGS += -Wl,-Bstatic,-T,$(VORTEX_RT_PATH)/linker/vx_link64.ld -Wl,--noinhibit-exec,--gc-sections $(VORTEX_RT_PATH)/libvortexrt.a
+
+VX_SRCS = kernel.c
+
+#CXXFLAGS += -std=c++11 -O2 -Wall -Wextra -pedantic -Wfatal-errors
+CXXFLAGS += -std=c++11 -O0 -g -Wall -Wextra -pedantic -Wfatal-errors
+
+CXXFLAGS += -I$(VORTEX_DRV_PATH)/include
+
+LDFLAGS += -L$(VORTEX_DRV_PATH)/stub -lvortex
+
+PROJECT = basic64
+
+SRCS = main.cpp
+
+all: $(PROJECT) kernel.bin kernel.dump
+
+kernel.dump:  kernel.elf
+	$(VX_DP) -D  kernel.elf > kernel.dump
+
+kernel.bin:  kernel.elf
+	$(VX_CP) -O binary kernel.elf kernel.bin
+
+kernel.elf: $(VX_SRCS)
+	$(VX_CC) $(VX_CFLAGS) $(VX_SRCS) $(VX_LDFLAGS) -o kernel.elf
+
+$(PROJECT): $(SRCS)
+	$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -o $@
+
+run-simx: $(PROJECT) kernel.bin   
+	LD_LIBRARY_PATH=$(POCL_RT_PATH)/lib:$(VORTEX_DRV_PATH)/simx:$(LD_LIBRARY_PATH) ./$(PROJECT) $(OPTS)
+	
+run-fpga: $(PROJECT) kernel.bin   
+	LD_LIBRARY_PATH=$(POCL_RT_PATH)/lib:$(VORTEX_DRV_PATH)/fpga:$(LD_LIBRARY_PATH) ./$(PROJECT) $(OPTS)
+
+run-asesim: $(PROJECT) kernel.bin   
+	LD_LIBRARY_PATH=$(POCL_RT_PATH)/lib:$(VORTEX_DRV_PATH)/asesim:$(LD_LIBRARY_PATH) ./$(PROJECT) $(OPTS)
+	
+run-vlsim: $(PROJECT) kernel.bin   
+	LD_LIBRARY_PATH=$(POCL_RT_PATH)/lib:$(VORTEX_DRV_PATH)/vlsim:$(LD_LIBRARY_PATH) ./$(PROJECT) $(OPTS)
+
+run-rtlsim: $(PROJECT) kernel.bin   
+	LD_LIBRARY_PATH=$(POCL_RT_PATH)/lib:$(VORTEX_DRV_PATH)/rtlsim:$(LD_LIBRARY_PATH) ./$(PROJECT) $(OPTS)
+
+.depend: $(SRCS)
+	$(CXX) $(CXXFLAGS) -MM $^ > .depend;
+
+clean:
+	rm -rf $(PROJECT) *.o .depend
+
+clean-all: clean
+	rm -rf *.elf *.bin *.dump
+
+ifneq ($(MAKECMDGOALS),clean)
+    -include .depend
+endif

tests/regression/basic64/common.h

@@ -0,0 +1,12 @@
+#ifndef _COMMON_H_
+#define _COMMON_H_
+
+#define KERNEL_ARG_DEV_MEM_ADDR 0x7ffff000
+
+typedef struct {
+  uint32_t count;
+  uint32_t src_ptr;
+  uint32_t dst_ptr;  
+} kernel_arg_t;
+
+#endif

tests/regression/basic64/kernel.c

@@ -0,0 +1,16 @@
+#include <stdint.h>
+#include <vx_intrinsics.h>
+#include "common.h"
+
+void main() {
+	kernel_arg_t* arg = (kernel_arg_t*)KERNEL_ARG_DEV_MEM_ADDR;
+	uint32_t count   = arg->count;
+	int32_t* src_ptr = (int32_t*)arg->src_ptr;
+	int32_t* dst_ptr = (int32_t*)arg->dst_ptr;
+	
+	uint32_t offset  = vx_core_id() * count;
+	
+	for (uint32_t i = 0; i < count; ++i) {
+		dst_ptr[offset + i] = src_ptr[offset + i];
+	}
+}

tests/regression/basic64/kernel_scheduler.h

@@ -0,0 +1,153 @@
+#include <iostream>
+#include <assert.h>
+
+#define NUM_CORES_MAX 32
+
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
+struct context_t {
+  uint32_t num_groups[3];
+  uint32_t global_offset[3];
+  uint32_t local_size[3];
+  char * printf_buffer;
+  uint32_t *printf_buffer_position;
+  uint32_t printf_buffer_capacity;
+  uint32_t work_dim;
+};
+
+typedef void (*vx_pocl_workgroup_func) (
+  const void * /* args */,
+	const struct context_t * /* context */,
+	uint32_t /* group_x */,
+	uint32_t /* group_y */,
+	uint32_t /* group_z */
+);
+
+typedef struct {
+  struct context_t * ctx;
+  vx_pocl_workgroup_func pfn;
+  const void * args;
+  int offset; 
+  int N;
+  int R;
+} wspawn_args_t;
+
+void kernel_spawn_callback(int core_id, int NW, int NT, int nW, wspawn_args_t* p_wspawn_args) {
+  assert(nW <= NW);
+  for (int wid = 0; wid < nW; ++wid) {
+    for (int tid = 0; tid < NT; ++tid) {
+      int wK = (p_wspawn_args->N * wid) + MIN(p_wspawn_args->R, wid);
+      int tK = p_wspawn_args->N + (wid < p_wspawn_args->R);
+      int offset = p_wspawn_args->offset + (wK * NT) + (tid * tK);
+
+      int X = p_wspawn_args->ctx->num_groups[0];
+      int Y = p_wspawn_args->ctx->num_groups[1];
+      int XY = X * Y;
+
+      for (int wg_id = offset, N = wg_id + tK; wg_id < N; ++wg_id) {    
+        int k = wg_id / XY;
+        int wg_2d = wg_id - k * XY;
+        int j = wg_2d / X;
+        int i = wg_2d - j * X;
+
+        int gid0 = p_wspawn_args->ctx->global_offset[0] + i;
+        int gid1 = p_wspawn_args->ctx->global_offset[1] + j;
+        int gid2 = p_wspawn_args->ctx->global_offset[2] + k;
+
+        printf("c%d w%d t%d: g={%d, %d, %d}\n", core_id, wid, tid, gid0, gid1, gid2);
+      }
+    }
+  }
+}
+
+void kernel_spawn_remaining_callback(int core_id, int NW, int NT, int wid, int nT, wspawn_args_t* p_wspawn_args) {    
+  assert(wid < NW);
+  assert(nT <= NT);
+  for (int t = 0; t < nT; ++t) {
+    int tid = core_id * NW * NT + wid * NT + t;
+
+    int wg_id = p_wspawn_args->offset + tid;
+
+    int X = p_wspawn_args->ctx->num_groups[0];
+    int Y = p_wspawn_args->ctx->num_groups[1];
+    int XY = X * Y;
+    
+    int k = wg_id / XY;
+    int wg_2d = wg_id - k * XY;
+    int j = wg_2d / X;
+    int i = wg_2d - j * X;
+
+    int gid0 = p_wspawn_args->ctx->global_offset[0] + i;
+    int gid1 = p_wspawn_args->ctx->global_offset[1] + j;
+    int gid2 = p_wspawn_args->ctx->global_offset[2] + k;
+
+    printf("c%d w%d t%d: g={%d, %d, %d}\n", core_id, wid, tid, gid0, gid1, gid2);
+  }
+}
+
+void kernel_run_once(context_t* ctx, int NC, int NW, int NT, int core_id) {
+    // total number of WGs
+    int X = ctx->num_groups[0];
+    int Y = ctx->num_groups[1];
+    int Z = ctx->num_groups[2];
+    int Q = X * Y * Z;
+
+    // current core id
+    if (core_id >= NUM_CORES_MAX)
+      return;
+
+    // calculate necessary active cores
+    int WT = NW * NT;
+    int nC = (Q > WT) ? (Q / WT) : 1;
+    int nc = MIN(nC, NC);
+    if (core_id >= nc)
+      return; // terminate extra cores
+
+    // number of workgroups per core
+    int wgs_per_core = Q / nc;
+    int wgs_per_core0 = wgs_per_core;  
+    if (core_id == (NC-1)) {    
+      int QC_r = Q - (nc * wgs_per_core0); 
+      wgs_per_core0 += QC_r; // last core executes remaining WGs
+    }
+
+    // number of workgroups per warp
+    int nW = wgs_per_core0 / NT;              // total warps per core
+    int rT = wgs_per_core0 - (nW * NT);       // remaining threads
+    int fW = (nW >= NW) ? (nW / NW) : 0;      // full warps iterations
+    int rW = (fW != 0) ? (nW - fW * NW) : 0;  // reamining full warps
+    if (0 == fW)
+      fW = 1;
+
+    //--
+    wspawn_args_t wspawn_args = { ctx, NULL, NULL, core_id * wgs_per_core, fW, rW };
+
+    //--
+    if (nW >= 1)	{ 
+      int nw = MIN(nW, NW);
+      kernel_spawn_callback(core_id, NW, NT, nw, &wspawn_args);
+    }  
+
+    //--    
+    if (rT != 0) {
+      wspawn_args.offset = wgs_per_core0 - rT;
+      kernel_spawn_remaining_callback(core_id, NW, NT, 0, rT, &wspawn_args);
+    }
+  }
+
+  void kernel_run(int X, int Y, int Z, int NC, int NW, int NT) {
+    context_t ctx;
+
+    ctx.num_groups[0] = X;
+    ctx.num_groups[1] = Y;
+    ctx.num_groups[2] = Z;
+    ctx.global_offset[0] = 0;
+    ctx.global_offset[1] = 0;
+    ctx.global_offset[2] = 0;
+
+    for (int cid = 0; cid < NC; ++cid) {
+      kernel_run_once(&ctx, NC, NW, NT, cid);
+    }
+
+    exit (0);
+  }

tests/regression/basic64/main.cpp

@@ -0,0 +1,286 @@
+#include <iostream>
+#include <unistd.h>
+#include <string.h>
+#include <vortex.h>
+#include <chrono>
+#include "common.h"
+#include "kernel_scheduler.h"
+
+#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)
+
+///////////////////////////////////////////////////////////////////////////////
+
+const char* kernel_file = "kernel.bin";
+int test = -1;
+uint32_t count = 0;
+
+vx_device_h device = nullptr;
+vx_buffer_h staging_buf = nullptr;
+
+static void show_usage() {
+   std::cout << "Vortex Test." << std::endl;
+   std::cout << "Usage: [-t testno][-k: kernel][-n words][-h: help]" << std::endl;
+}
+
+static void parse_args(int argc, char **argv) {
+  int c;
+  while ((c = getopt(argc, argv, "n:t:k:h?")) != -1) {
+    switch (c) {
+    case 'n':
+      count = atoi(optarg);
+      break;
+    case 't':
+      test = 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 (staging_buf) {
+    vx_buf_release(staging_buf);
+  }
+  if (device) {
+    vx_dev_close(device);
+  }
+}
+
+uint64_t shuffle(int i, uint64_t value) {
+  return (value << i) | (value & ((1 << i)-1));;
+}
+
+int run_memcopy_test(uint32_t dev_addr, uint64_t value, int num_blocks) {
+  int errors = 0;
+  
+  auto time_start = std::chrono::high_resolution_clock::now();
+
+  int num_blocks_8 = (64 * num_blocks) / 8;
+
+  // update source buffer
+  for (int i = 0; i < num_blocks_8; ++i) {
+    ((uint64_t*)vx_host_ptr(staging_buf))[i] = shuffle(i, value);
+  }
+
+  /*for (int i = 0; i < num_blocks; ++i) {
+    std::cout << "data[" << i << "]=0x";
+    for (int j = 7; j >= 0; --j) {
+      std::cout << std::hex << ((uint64_t*)vx_host_ptr(staging_buf))[i * 8 +j];
+    }
+    std::cout << std::endl;
+  }*/
+  
+  // write source buffer to local memory
+  std::cout << "write source buffer to local memory" << std::endl;
+  auto t0 = std::chrono::high_resolution_clock::now();
+  RT_CHECK(vx_copy_to_dev(staging_buf, dev_addr, 64 * num_blocks, 0));
+  auto t1 = std::chrono::high_resolution_clock::now();
+
+  // clear destination buffer
+  for (int i = 0; i < num_blocks_8; ++i) {
+    ((uint64_t*)vx_host_ptr(staging_buf))[i] = 0;
+  }
+
+  // read destination buffer from local memory
+  std::cout << "read destination buffer from local memory" << std::endl;
+  auto t2 = std::chrono::high_resolution_clock::now();
+  RT_CHECK(vx_copy_from_dev(staging_buf, dev_addr, 64 * num_blocks, 0));
+  auto t3 = std::chrono::high_resolution_clock::now();
+
+  // verify result
+  std::cout << "verify result" << std::endl;
+  for (int i = 0; i < num_blocks_8; ++i) {
+    auto curr = ((uint64_t*)vx_host_ptr(staging_buf))[i];
+    auto ref = shuffle(i, value);
+    if (curr != ref) {
+      std::cout << "error at 0x" << std::hex << (dev_addr + 8 * i)
+                << ": actual 0x" << curr << ", 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;
+  }
+
+  auto time_end = std::chrono::high_resolution_clock::now();
+
+  double elapsed;
+  elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(t1 - t0).count();  
+  printf("upload time: %lg ms\n", elapsed);
+  elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(t3 - t2).count();  
+  printf("download time: %lg ms\n", elapsed);
+  elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(time_end - time_start).count();  
+  printf("Total elapsed time: %lg ms\n", elapsed);
+
+  return 0;
+}
+
+int run_kernel_test(const kernel_arg_t& kernel_arg, 
+                    uint32_t buf_size, 
+                    uint32_t num_points) {
+  int errors = 0; 
+
+  auto time_start = std::chrono::high_resolution_clock::now();
+  
+  // update source buffer
+  {
+    auto buf_ptr = (int32_t*)vx_host_ptr(staging_buf);
+    for (uint32_t i = 0; i < num_points; ++i) {
+      buf_ptr[i] = i;
+    }
+  }
+  std::cout << "upload source buffer" << std::endl;
+  auto t0 = std::chrono::high_resolution_clock::now();
+  RT_CHECK(vx_copy_to_dev(staging_buf, kernel_arg.src_ptr, buf_size, 0));
+  auto t1 = std::chrono::high_resolution_clock::now();
+
+  // clear destination buffer
+  {
+    auto buf_ptr = (int32_t*)vx_host_ptr(staging_buf);
+    for (uint32_t i = 0; i < num_points; ++i) {
+      buf_ptr[i] = 0xdeadbeef;
+    }
+  }  
+  std::cout << "clear destination buffer" << std::endl;
+  RT_CHECK(vx_copy_to_dev(staging_buf, kernel_arg.dst_ptr, buf_size, 0));
+
+  // start device
+  std::cout << "start execution" << std::endl;
+  auto t2 = std::chrono::high_resolution_clock::now();
+  RT_CHECK(vx_start(device));
+  RT_CHECK(vx_ready_wait(device, -1));
+  auto t3 = std::chrono::high_resolution_clock::now();
+
+  // read destination buffer from local memory
+  std::cout << "read destination buffer from local memory" << std::endl;
+  auto t4 = std::chrono::high_resolution_clock::now();
+  RT_CHECK(vx_copy_from_dev(staging_buf, kernel_arg.dst_ptr, buf_size, 0));
+  auto t5 = std::chrono::high_resolution_clock::now();
+
+  
+  // verify result
+  std::cout << "verify result" << std::endl;
+  for (uint32_t i = 0; i < num_points; ++i) {
+    int32_t curr = ((int32_t*)vx_host_ptr(staging_buf))[i];
+    int32_t ref = i;
+    if (curr != ref) {
+      std::cout << "error at result #" << std::dec << i
+                << std::hex << ": actual 0x" << curr << ", 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;
+  }
+
+  auto time_end = std::chrono::high_resolution_clock::now();
+
+  double elapsed;
+  elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(t1 - t0).count();  
+  printf("upload time: %lg ms\n", elapsed);
+  elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(t3 - t2).count();  
+  printf("execute time: %lg ms\n", elapsed);
+  elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(t5 - t4).count();  
+  printf("download time: %lg ms\n", elapsed);
+  elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(time_end - time_start).count();  
+  printf("Total elapsed time: %lg ms\n", elapsed);
+
+  return 0;
+}
+
+int main(int argc, char *argv[]) {
+
+  size_t value; 
+  kernel_arg_t kernel_arg;
+
+  // parse command arguments
+  parse_args(argc, argv);
+
+  if (count == 0) {
+    count = 1;
+  }
+
+  // open device connection
+  std::cout << "open device connection" << std::endl;
+  RT_CHECK(vx_dev_open(&device));
+  
+  unsigned max_cores;
+  RT_CHECK(vx_dev_caps(device, VX_CAPS_MAX_CORES, &max_cores));
+  uint32_t num_points = count;
+  uint32_t num_blocks = (num_points * sizeof(int32_t) + 63) / 64;
+  uint32_t buf_size   = num_blocks * 64;
+
+  std::cout << "number of points: " << num_points << std::endl;
+  std::cout << "buffer size: " << buf_size << " bytes" << std::endl;
+
+  // allocate device memory
+  RT_CHECK(vx_alloc_dev_mem(device, buf_size, &value));
+  kernel_arg.src_ptr = value;
+  RT_CHECK(vx_alloc_dev_mem(device, buf_size, &value));
+  kernel_arg.dst_ptr = value;
+
+  kernel_arg.count = num_points;
+
+  std::cout << "dev_src=" << std::hex << kernel_arg.src_ptr << std::endl;
+  std::cout << "dev_dst=" << std::hex << kernel_arg.dst_ptr << std::endl;
+
+  // allocate shared memory  
+  std::cout << "allocate shared memory" << std::endl;
+  uint32_t alloc_size = std::max<uint32_t>(buf_size, sizeof(kernel_arg_t));
+  RT_CHECK(vx_alloc_shared_mem(device, alloc_size, &staging_buf));
+
+  // run tests  
+  if (0 == test || -1 == test) {
+    std::cout << "run memcopy test" << std::endl;
+    RT_CHECK(run_memcopy_test(kernel_arg.src_ptr, 0x0badf00d40ff40ff, num_blocks));
+  }
+
+  if (1 == test || -1 == test) {
+    // upload program
+    std::cout << "upload program" << std::endl;  
+    RT_CHECK(vx_upload_kernel_file(device, kernel_file));
+
+    // upload kernel argument
+    std::cout << "upload kernel argument" << std::endl;
+    {
+      auto buf_ptr = (void*)vx_host_ptr(staging_buf);
+      memcpy(buf_ptr, &kernel_arg, sizeof(kernel_arg_t));
+      RT_CHECK(vx_copy_to_dev(staging_buf, KERNEL_ARG_DEV_MEM_ADDR, sizeof(kernel_arg_t), 0));
+    }
+
+    std::cout << "run kernel test" << std::endl;
+    RT_CHECK(run_kernel_test(kernel_arg, buf_size, num_points));
+  }
+
+  // cleanup
+  std::cout << "cleanup" << std::endl;  
+  cleanup();
+
+  std::cout << "Test PASSED" << std::endl;  
+  
+  return 0;
+}