Vortex 2.0 changes:

+ Microarchitecture optimizations + 64-bit support + Xilinx FPGA support + LLVM-16 support + Refactoring and quality control fixes minor update minor update minor update minor update minor update minor update cleanup cleanup cache bindings and memory perf refactory minor update minor update hw unit tests fixes minor update minor update minor update minor update minor update minor udpate minor update minor update minor update minor update minor update minor update minor update minor updates minor updates minor update minor update minor update minor update minor update minor update minor updates minor updates minor updates minor updates minor update minor update
2023-10-19 20:51:22 -07:00
parent d69a64c32c
commit c1e168fdbe
1309 changed files with 247412 additions and 311463 deletions
--- a/tests/regression/fence/Makefile
+++ b/tests/regression/fence/Makefile
@@ -1,78 +1,9 @@
-XLEN ?= 32
-
-RISCV_TOOLCHAIN_PATH ?= /opt/riscv-gnu-toolchain
-VORTEX_DRV_PATH ?= $(realpath ../../../driver)
-VORTEX_RT_PATH ?= $(realpath ../../../runtime)
-
-OPTS ?= -n64
-
-VX_CC  = $(RISCV_TOOLCHAIN_PATH)/bin/riscv32-unknown-elf-gcc
-VX_CXX = $(RISCV_TOOLCHAIN_PATH)/bin/riscv32-unknown-elf-g++
-VX_DP  = $(RISCV_TOOLCHAIN_PATH)/bin/riscv32-unknown-elf-objdump
-VX_CP  = $(RISCV_TOOLCHAIN_PATH)/bin/riscv32-unknown-elf-objcopy
-
-VX_CFLAGS += -march=rv32imf -mabi=ilp32f -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_link$(XLEN).ld -Wl,--gc-sections $(VORTEX_RT_PATH)/libvortexrt.a
-
-VX_SRCS = kernel.c
-
-CXXFLAGS += -std=c++11 -Wall -Wextra -pedantic -Wfatal-errors
-
-CXXFLAGS += -I$(VORTEX_DRV_PATH)/include
-
-LDFLAGS += -L$(VORTEX_DRV_PATH)/stub -lvortex
-
-# Debugigng
-ifdef DEBUG
-	CXXFLAGS += -g -O0
-else    
-	CXXFLAGS += -O2 -DNDEBUG
-endif
-
 PROJECT = fence

 SRCS = main.cpp

-all: $(PROJECT) kernel.bin kernel.dump
- 
-kernel.dump: kernel.elf
-	$(VX_DP) -D kernel.elf > kernel.dump
+VX_SRCS = kernel.cpp

-kernel.bin: kernel.elf
-	$(VX_CP) -O binary kernel.elf kernel.bin
+OPTS ?= -n64

-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
+include ../common.mk
--- a/tests/regression/fence/common.h
+++ b/tests/regression/fence/common.h
@@ -6,9 +6,9 @@
 typedef struct {
  uint32_t num_tasks;
  uint32_t task_size;
-  uint32_t src0_addr;
-  uint32_t src1_addr;
-  uint32_t dst_addr;
+  uint64_t src0_addr;
+  uint64_t src1_addr;
+  uint64_t dst_addr;
 } kernel_arg_t;

 #endif
--- a/tests/regression/fence/kernel.cpp
+++ b/tests/regression/fence/kernel.cpp
@@ -3,14 +3,13 @@
 #include <vx_spawn.h>
 #include "common.h"

-void kernel_body(int task_id, kernel_arg_t* arg) {
+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;
 	
 	uint32_t offset = task_id * count;
-
 	for (uint32_t i = 0; i < count; ++i) {
 		dst_ptr[offset+i] = src0_ptr[offset+i] + src1_ptr[offset+i];
 	}
@@ -18,7 +17,8 @@ void kernel_body(int task_id, kernel_arg_t* arg) {
 	vx_fence();
 }

-void main() {
+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;
+}
--- a/tests/regression/fence/main.cpp
+++ b/tests/regression/fence/main.cpp
@@ -1,6 +1,7 @@
 #include <iostream>
 #include <unistd.h>
 #include <string.h>
+#include <vector>
 #include <vortex.h>
 #include "common.h"

@@ -20,8 +21,8 @@ const char* kernel_file = "kernel.bin";
 uint32_t count = 0;

 vx_device_h device = nullptr;
-vx_buffer_h staging_buf = nullptr;
-kernel_arg_t kernel_arg;
+std::vector<uint8_t> staging_buf;
+kernel_arg_t kernel_arg = {};

 static void show_usage() {
   std::cout << "Vortex Test." << std::endl;
@@ -51,9 +52,6 @@ static void parse_args(int argc, char **argv) {
 }

 void cleanup() {
-  if (staging_buf) {
-    vx_buf_free(staging_buf);
-  }
  if (device) {
    vx_mem_free(device, kernel_arg.src0_addr);
    vx_mem_free(device, kernel_arg.src1_addr);
@@ -71,17 +69,17 @@ int run_test(const kernel_arg_t& kernel_arg,

  // wait for completion
  std::cout << "wait for completion" << std::endl;
-  RT_CHECK(vx_ready_wait(device, MAX_TIMEOUT));
+  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(staging_buf, kernel_arg.dst_addr, buf_size, 0));
+  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 = (int32_t*)vx_host_ptr(staging_buf);
+    auto buf_ptr = (int32_t*)staging_buf.data();
    for (uint32_t i = 0; i < num_points; ++i) {
      int ref = i + i; 
      int cur = buf_ptr[i];
@@ -101,9 +99,7 @@ int run_test(const kernel_arg_t& kernel_arg,
  return 0;
 }

-int main(int argc, char *argv[]) {
-  size_t value;
-  
+int main(int argc, char *argv[]) {  
  // parse command arguments
  parse_args(argc, argv);

@@ -115,12 +111,12 @@ int main(int argc, char *argv[]) {
  std::cout << "open device connection" << std::endl;  
  RT_CHECK(vx_dev_open(&device));

-  uint64_t max_cores, max_warps, max_threads;
-  RT_CHECK(vx_dev_caps(device, VX_CAPS_MAX_CORES, &max_cores));
-  RT_CHECK(vx_dev_caps(device, VX_CAPS_MAX_WARPS, &max_warps));
-  RT_CHECK(vx_dev_caps(device, VX_CAPS_MAX_THREADS, &max_threads));
+  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));

-  uint32_t num_tasks  = max_cores * max_warps * max_threads;
+  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);

@@ -132,64 +128,60 @@ int main(int argc, char *argv[]) {
  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, &value));
-  kernel_arg.src0_addr = value;
-  RT_CHECK(vx_mem_alloc(device, buf_size, &value));
-  kernel_arg.src1_addr = value;
-  RT_CHECK(vx_mem_alloc(device, buf_size, &value));
-  kernel_arg.dst_addr = value;
+  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_tasks = num_tasks;
  kernel_arg.task_size = count;

-  std::cout << "dev_src0=" << std::hex << kernel_arg.src0_addr << std::endl;
-  std::cout << "dev_src1=" << std::hex << kernel_arg.src1_addr << std::endl;
-  std::cout << "dev_dst=" << std::hex << kernel_arg.dst_addr << std::endl;
+  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 shared memory  
-  std::cout << "allocate shared memory" << 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));
-  RT_CHECK(vx_buf_alloc(device, alloc_size, &staging_buf));
+  staging_buf.resize(alloc_size);
  
  // upload kernel argument
  std::cout << "upload kernel argument" << std::endl;
  {
-    auto buf_ptr = (int*)vx_host_ptr(staging_buf);
+    auto buf_ptr = (int*)staging_buf.data();
    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));
+    RT_CHECK(vx_copy_to_dev(device, KERNEL_ARG_DEV_MEM_ADDR, staging_buf.data(), sizeof(kernel_arg_t)));
  }

  // upload source buffer0
  {
-    auto buf_ptr = (int32_t*)vx_host_ptr(staging_buf);
+    std::cout << "upload source buffer0" << std::endl;
+    auto buf_ptr = (int32_t*)staging_buf.data();
    for (uint32_t i = 0; i < num_points; ++i) {
      buf_ptr[i] = i-1;
-    }
+    }  
+    RT_CHECK(vx_copy_to_dev(device, kernel_arg.src0_addr, staging_buf.data(), buf_size));
  }
-  std::cout << "upload source buffer0" << std::endl;      
-  RT_CHECK(vx_copy_to_dev(staging_buf, kernel_arg.src0_addr, buf_size, 0));

  // upload source buffer1
  {
-    auto buf_ptr = (int32_t*)vx_host_ptr(staging_buf);
+    std::cout << "upload source buffer1" << std::endl;
+    auto buf_ptr = (int32_t*)staging_buf.data();
    for (uint32_t i = 0; i < num_points; ++i) {
      buf_ptr[i] = i+1;
-    }
+    }  
+    RT_CHECK(vx_copy_to_dev(device, kernel_arg.src1_addr, staging_buf.data(), buf_size));
  }
-  std::cout << "upload source buffer1" << std::endl;      
-  RT_CHECK(vx_copy_to_dev(staging_buf, kernel_arg.src1_addr, buf_size, 0));

  // clear destination buffer
  {
-    auto buf_ptr = (int32_t*)vx_host_ptr(staging_buf);
+    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;      
-  RT_CHECK(vx_copy_to_dev(staging_buf, kernel_arg.dst_addr, buf_size, 0));  

  // run tests
  std::cout << "run tests" << std::endl;