project directories reorganization

sw/driver/tests/basic/Makefile

@@ -0,0 +1,67 @@
+RISCV_TOOL_PATH ?= $(wildcard ~/dev/riscv-gnu-toolchain/drops)
+VX_RT_PATH ?= $(wildcard ../../../runtime)
+
+VX_CC  = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gcc
+VX_CXX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-g++
+VX_DMP = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objdump
+VX_CPY = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objcopy
+
+VX_NEWLIB = $(VX_RT_PATH)/newlib/newlib.c
+VX_STR = $(VX_RT_PATH)/startup/vx_start.S
+VX_INT = $(VX_RT_PATH)/intrinsics/vx_intrinsics.s
+VX_IO  = $(VX_RT_PATH)/io/vx_io.s $(VX_RT_PATH)/io/vx_io.c
+VX_API = $(VX_RT_PATH)/vx_api/vx_api.c
+VX_FIO = $(VX_RT_PATH)/fileio/fileio.s
+
+VX_CFLAGS = -march=rv32im -mabi=ilp32 -O3 -Wl,-Bstatic,-T,$(VX_RT_PATH)/mains/vortex_link.ld -ffreestanding -nostartfiles -Wl,--gc-sections
+
+VX_SRCS = kernel.c
+
+CXXFLAGS += -std=c++11 -O0 -g -Wall -Wextra -pedantic -Wfatal-errors
+
+CXXFLAGS += -I../../sw/include
+
+LDFLAGS += 
+
+PROJECT = basic
+
+SRCS = basic.cpp
+
+all: $(PROJECT)
+
+kernel.dump:  kernel.elf
+	$(VX_DMP) -D  kernel.elf > kernel.dump
+
+kernel.hex:  kernel.elf
+	$(VX_CPY) -O ihex kernel.elf kernel.hex
+
+kernel.bin:  kernel.elf
+	$(VX_CPY) -O binary kernel.elf kernel.bin
+
+kernel.elf: $(SRCS)
+	$(VX_CC) $(VX_CFLAGS) $(VX_STR) $(VX_FIO) $(VX_NEWLIB) $(VX_INT) $(VX_IO) $(VX_API) $(VX_SRCS) -I$(VX_RT_PATH) -o kernel.elf
+
+$(PROJECT): $(SRCS)
+	$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -L../../sw/dummy -lvortex -o $@
+
+run-fpga: $(PROJECT)
+	LD_LIBRARY_PATH=../../sw/opae:$(LD_LIBRARY_PATH) ./$(PROJECT)
+
+run-ase: $(PROJECT)
+	ASE_LOG=0 LD_LIBRARY_PATH=../../sw/opae/ase:$(LD_LIBRARY_PATH) ./$(PROJECT)
+
+run-rtlsim: $(PROJECT)
+	LD_LIBRARY_PATH=../../sw/rtlsim:$(LD_LIBRARY_PATH) ./$(PROJECT)
+
+run-simx: $(PROJECT)
+	LD_LIBRARY_PATH=../../sw/simx:$(LD_LIBRARY_PATH) ./$(PROJECT)
+
+.depend: $(SRCS)
+	$(CXX) $(CXXFLAGS) -MM $^ > .depend;
+
+clean:
+	rm -rf $(PROJECT) *.o .depend 
+
+ifneq ($(MAKECMDGOALS),clean)
+    -include .depend
+endif

sw/driver/tests/basic/basic.cpp

@@ -0,0 +1,233 @@
+#include <iostream>
+#include <unistd.h>
+#include <vortex.h>
+
+int test = -1;
+
+static void parse_args(int argc, char **argv) {
+  int c;
+  while ((c = getopt(argc, argv, "t:h?")) != -1) {
+    switch (c) {
+    case 't': {
+      test = atoi(optarg);
+    } break;
+    case 'h': 
+    case '?': {
+      std::cout << "Test." << std::endl;
+      std::cout << "Usage: [-t testno][-h: help]" << std::endl;
+      exit(0);
+    } break;
+    default:
+      exit(-1);
+    }
+  }
+}
+
+uint64_t shuffle(int i, uint64_t value) {
+  return (value << i) | (value & ((1 << i)-1));;
+}
+
+int run_memcopy_test(vx_buffer_h sbuf, 
+                     vx_buffer_h dbuf, 
+                     uint32_t address, 
+                     uint64_t value, 
+                     int num_blocks) {
+  int ret;
+  int errors = 0;
+
+  // write sbuf data
+  for (int i = 0; i < 8 * num_blocks; ++i) {
+    ((uint64_t*)vx_host_ptr(sbuf))[i] = shuffle(i, value);
+  }
+
+  // write buffer to local memory
+  std::cout << "write buffer to local memory" << std::endl;
+  ret = vx_copy_to_dev(sbuf, address, 64 * num_blocks, 0);
+  if (ret != 0)
+    return ret;
+
+  // read buffer from local memory
+  std::cout << "read buffer from local memory" << std::endl;
+  ret = vx_copy_from_dev(dbuf, address, 64 * num_blocks, 0);
+  if (ret != 0)
+    return ret;
+
+  // verify result
+  std::cout << "verify result" << std::endl;
+  for (int i = 0; i < 8 * num_blocks; ++i) {
+    auto curr = ((uint64_t*)vx_host_ptr(dbuf))[i];
+    auto ref = shuffle(i, value);
+    if (curr != ref) {
+      std::cout << "error @ " << std::hex << (address + 64 * i)
+                << ": actual " << curr << ", expected " << ref << std::endl;
+      ++errors;
+    }
+  } 
+  
+  if (errors != 0) {
+    std::cout << "Found " << errors << " errors!" << std::endl;
+    std::cout << "FAILED!" << std::endl;
+    return 1;
+  }
+
+  return 0;
+}
+
+int run_kernel_test(vx_device_h device, 
+                    vx_buffer_h sbuf, 
+                    vx_buffer_h dbuf, 
+                    const char* program) {
+  int ret;
+  int errors = 0;
+
+  uint64_t seed = 0x0badf00d40ff40ff;
+  int num_blocks = 4;
+
+  unsigned src_dev_addr = 0x10000000;
+  unsigned dest_dev_addr = 0x20000000;
+
+  // write sbuf data
+  for (int i = 0; i < 8 * num_blocks; ++i) {
+    ((uint64_t*)vx_host_ptr(sbuf))[i] = shuffle(i, seed);
+  }
+
+  // write buffer to local memory
+  std::cout << "write buffer to local memory" << std::endl;
+  ret = vx_copy_to_dev(sbuf, src_dev_addr, 64 * num_blocks, 0);
+  if (ret != 0)
+    return ret;
+  
+  // upload program
+  std::cout << "upload program" << std::endl;  
+  ret = vx_upload_kernel_file(device, program);
+  if (ret != 0) {
+    return ret;  
+  }
+
+  // start device
+  std::cout << "start device" << std::endl;
+  ret = vx_start(device);
+  if (ret != 0) {
+    return ret;  
+  }
+
+  // wait for completion
+  std::cout << "wait for completion" << std::endl;
+  ret = vx_ready_wait(device, -1);
+  if (ret != 0) {
+    return ret;  
+  }
+
+  // flush the caches
+  std::cout << "flush the caches" << std::endl;
+  ret = vx_flush_caches(device, dest_dev_addr, 64 * num_blocks);
+  if (ret != 0) {
+    return ret;  
+  }
+
+  // read buffer from local memory
+  std::cout << "read buffer from local memory" << std::endl;
+  ret = vx_copy_from_dev(dbuf, dest_dev_addr, 64 * num_blocks, 0);
+  if (ret != 0)
+    return ret;
+
+  // verify result
+  std::cout << "verify result" << std::endl;
+  for (int i = 0; i < 8 * num_blocks; ++i) {
+    auto curr = ((uint64_t*)vx_host_ptr(dbuf))[i];
+    auto ref = shuffle(i, seed);
+    if (curr != ref) {
+      std::cout << "error @ " << std::hex << (dest_dev_addr + 64 * i)
+                << ": actual " << curr << ", expected " << ref << std::endl;
+      ++errors;
+    }
+  } 
+  
+  if (errors != 0) {
+    std::cout << "Found " << errors << " errors!" << std::endl;
+    std::cout << "FAILED!" << std::endl;
+    return 1;
+  }
+
+  return 0;
+}
+
+vx_device_h device = nullptr;
+vx_buffer_h sbuf = nullptr;
+vx_buffer_h dbuf = nullptr;
+
+void cleanup() {
+  if (sbuf) {
+    vx_buf_release(sbuf);
+  }
+  if (dbuf) {
+    vx_buf_release(dbuf);
+  }
+  if (device) {
+    vx_dev_close(device);
+  }
+}
+
+int main(int argc, char *argv[]) {
+  int ret;
+
+  // parse command arguments
+  parse_args(argc, argv);
+
+  // open device connection
+  std::cout << "open device connection" << std::endl;
+  vx_device_h device;
+  ret = vx_dev_open(&device);
+  if (ret != 0)
+    return ret;
+
+  // create source buffer
+  std::cout << "create source buffer" << std::endl;
+  ret = vx_alloc_shared_mem(device, 4096, &sbuf);
+  if (ret != 0) {
+    cleanup();
+    return ret;
+  }
+  
+  // create destination buffer
+  std::cout << "create destination buffer" << std::endl;
+  ret = vx_alloc_shared_mem(device, 4096, &dbuf);
+  if (ret != 0) {
+    cleanup();
+    return ret;
+  }
+
+  // run tests  
+  if (0 == test || -1 == test) {
+    std::cout << "run memcopy test" << std::endl;
+
+    ret = run_memcopy_test(sbuf, dbuf, 0x10000000, 0x0badf00d00ff00ff, 1);
+    if (ret != 0) {
+      cleanup();
+      return ret;
+    }
+
+    ret = run_memcopy_test(sbuf, dbuf, 0x20000000, 0x0badf00d40ff40ff, 8);
+    if (ret != 0) {
+      cleanup();
+      return ret;
+    }
+  }
+
+  if (1 == test || -1 == test) {
+    std::cout << "run kernel test" << std::endl;
+    ret = run_kernel_test(device, sbuf, dbuf, "kernel.bin");
+    if (ret != 0) {
+      cleanup();
+      return ret;
+    }
+  }
+
+  // cleanup
+  std::cout << "cleanup" << std::endl;  
+  cleanup();
+
+  std::cout << "Test PASSED" << std::endl;
+
+  return 0;
+}

sw/driver/tests/basic/kernel.c

@@ -0,0 +1,9 @@
+#include <stdint.h>
+
+void main() {
+	int64_t* x = (int64_t*)0x10000000;
+	int64_t* y = (int64_t*)0x20000000;
+	for (int  i = 0; i < 8 * 4; ++i) {
+		y[i] = x[i];
+	}
+}