project directories reorganization

benchmarks/opencl/vecadd/.gitignore

@@ -0,0 +1 @@
+vecadd

benchmarks/opencl/vecadd/Makefile

@@ -1,68 +1,47 @@
-RISCV_TOOL_PATH ?= $(wildcard ../../../../riscv-gnu-toolchain/drops)
-POCL_CC_PATH ?= $(wildcard ../../../../pocl/drops_riscv_cc)
-POCL_INC_PATH ?= $(wildcard ../include)
-POCL_LIB_PATH ?= $(wildcard ../lib)
-VX_RT_PATH ?= $(wildcard ../../../runtime)
-VX_SIMX_PATH ?= $(wildcard ../../../simX/obj_dir)
+LLVM_HOME ?= ~/dev/llvm-project/drops
+TOOLCHAIN_PATH ?= ~/dev/riscv-gnu-toolchain/drops
+SYSROOT ?= $(TOOLCHAIN_PATH)/riscv32-unknown-elf
+POCL_CC_PATH ?= $(realpath ../compiler)
+POCL_RT_PATH ?= $(realpath ../runtime)
+VORTEX_DRV_PATH ?= $(realpath ../../../driver/sw)
+VORTEX_RT_PATH ?= $(realpath ../../../runtime)
 
-CC  = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gcc
-CXX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-g++
-DMP = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objdump
-HEX = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-objcopy
-GDB = $(RISCV_TOOL_PATH)/bin/riscv32-unknown-elf-gdb
+CXXFLAGS += -std=c++11 -O0 -g -fpermissive -Wall -Wextra -pedantic -Wfatal-errors
 
-VX_SRCS =  $(VX_RT_PATH)/newlib/newlib.c
-VX_SRCS += $(VX_RT_PATH)/startup/vx_start.S
-VX_SRCS += $(VX_RT_PATH)/intrinsics/vx_intrinsics.s
-VX_SRCS += $(VX_RT_PATH)/io/vx_io.s $(VX_RT_PATH)/io/vx_io.c
-VX_SRCS += $(VX_RT_PATH)/fileio/fileio.s
-VX_SRCS += $(VX_RT_PATH)/tests/tests.c
-VX_SRCS += $(VX_RT_PATH)/vx_api/vx_api.c
-VX_SRCS += $(VX_STR) $(VX_FIO) $(VX_NEWLIB) $(VX_INT) $(VX_IO) $(VX_API) $(VX_TEST)
+CXXFLAGS += -I$(POCL_RT_PATH)/include
 
-VX_CFLAGS = -nostartfiles -Wl,-Bstatic,-T,$(VX_RT_PATH)/mains/vortex_link.ld
-
-CXXFLAGS =  -g -O0 -march=rv32im -mabi=ilp32 
-CXXFLAGS += -ffreestanding # program may not begin at main()
-CXXFLAGS += -Wl,--gc-sections # enable garbage collection of unused input sections
-CXXFLAGS += -fno-rtti -fno-non-call-exceptions # disable RTTI and exceptions
-CXXFLAGS += -I$(POCL_INC_PATH)
-
-VX_LIBS = -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
-QEMU_LIBS = $(VX_RT_PATH)/qemu/vx_api.c -Wl,--whole-archive lib$(PROJECT).a -Wl,--no-whole-archive $(POCL_LIB_PATH)/libOpenCL.a
+LDFLAGS += -L$(POCL_RT_PATH)/lib -L$(VORTEX_DRV_PATH)/stub -lOpenCL -lvortex
 
 PROJECT = vecadd
 
 SRCS = main.cc
 
-all: $(PROJECT).dump $(PROJECT).hex
+all: $(PROJECT)
 
-lib$(PROJECT).a: kernel.cl
-	POCL_DEBUG=all POCL_DEBUG_LLVM_PASSES=1 LD_LIBRARY_PATH=$(RISCV_TOOL_PATH)/lib:$(POCL_CC_PATH)/lib $(POCL_CC_PATH)/bin/poclcc -o lib$(PROJECT).a kernel.cl
+kernel.pocl: kernel.cl
+	TOOLCHAIN_PATH=$(TOOLCHAIN_PATH) SYSROOT=$(SYSROOT) LLVM_HOME=$(LLVM_HOME) VORTEX_RUNTIME_PATH=$(VORTEX_RT_PATH) POCL_DEBUG=all LD_LIBRARY_PATH=$(LLVM_HOME)/lib:$(POCL_CC_PATH)/lib $(POCL_CC_PATH)/bin/poclcc -o kernel.pocl kernel.cl
+ 
+$(PROJECT): $(SRCS)
+	$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -o $@
 
-$(PROJECT).elf: $(SRCS) lib$(PROJECT).a
-	$(CXX) $(CXXFLAGS) $(VX_CFLAGS) $(VX_SRCS) $(SRCS) $(VX_LIBS) -o $(PROJECT).elf
+run-fpga: $(PROJECT) kernel.pocl   
+	LD_LIBRARY_PATH=$(POCL_RT_PATH)/lib:$(VORTEX_DRV_PATH)/opae:$(LD_LIBRARY_PATH) ./$(PROJECT)
 
-$(PROJECT).qemu: $(SRCS) lib$(PROJECT).a
-	$(CXX) $(CXXFLAGS) $(SRCS) $(QEMU_LIBS) -o $(PROJECT).qemu
+run-ase: $(PROJECT) kernel.pocl   
+	ASE_LOG=0 LD_LIBRARY_PATH=$(POCL_RT_PATH)/lib:$(VORTEX_DRV_PATH)/opae/ase:$(LD_LIBRARY_PATH) ./$(PROJECT)
 
-$(PROJECT).hex: $(PROJECT).elf
-	$(HEX) -O ihex $(PROJECT).elf $(PROJECT).hex
+run-simx: $(PROJECT) kernel.pocl   
+	LD_LIBRARY_PATH=$(POCL_RT_PATH)/lib:$(VORTEX_DRV_PATH)/simx:$(LD_LIBRARY_PATH) ./$(PROJECT)
 
-$(PROJECT).dump: $(PROJECT).elf
-	$(DMP) -D $(PROJECT).elf > $(PROJECT).dump
+run-rtlsim: $(PROJECT) kernel.pocl   
+	LD_LIBRARY_PATH=$(POCL_RT_PATH)/lib:$(VORTEX_DRV_PATH)/rtlsim:$(LD_LIBRARY_PATH) ./$(PROJECT)
 
-run: $(PROJECT).hex
-	POCL_DEBUG=all $(VX_SIMX_PATH)/Vcache_simX -E -a rv32i --core $(PROJECT).hex -s -b 1> emulator.debug
-
-qemu: $(PROJECT).qemu
-	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -d in_asm -D debug.log $(PROJECT).qemu
-
-gdb-s: $(PROJECT).qemu
-	POCL_DEBUG=all $(RISCV_TOOL_PATH)/bin/qemu-riscv32 -g 1234 -d in_asm -D debug.log $(PROJECT).qemu
-
-gdb-c: $(PROJECT).qemu
-	$(GDB) $(PROJECT).qemu
+.depend: $(SRCS)
+	$(CXX) $(CXXFLAGS) -MM $^ > .depend;
 
 clean:
-	rm -rf *.o *.elf *.dump *.hex *.qemu *.log *.debug
+	rm -rf $(PROJECT) *.o *.dump .depend 
+
+ifneq ($(MAKECMDGOALS),clean)
+    -include .depend
+endif

benchmarks/opencl/vecadd/main.cc

@@ -1,13 +1,12 @@
 #include <stdio.h>
 #include <stdlib.h>
+#include <assert.h>
 #include <CL/opencl.h>
 #include <string.h>
 
-#define MAX_KERNELS 1
-#define KERNEL_NAME "vecadd"
-#define KERNEL_FILE_NAME "vecadd.pocl"
 #define SIZE 4
 #define NUM_WORK_GROUPS 2
+#define KERNEL_NAME "vecadd"
 
 #define CL_CHECK(_expr)                                                \
    do {                                                                \
@@ -22,7 +21,7 @@
 #define CL_CHECK2(_expr)                                               \
    ({                                                                  \
      cl_int _err = CL_INVALID_VALUE;                                   \
-     typeof(_expr) _ret = _expr;                                       \
+     decltype(_expr) _ret = _expr;                                     \
      if (_err != CL_SUCCESS) {                                         \
        printf("OpenCL Error: '%s' returned %d!\n", #_expr, (int)_err); \
 	   cleanup();			                                                   \
@@ -42,9 +41,30 @@ cl_mem c_memobj = NULL;
 cl_int *A = NULL;
 cl_int *B = NULL;
 cl_int *C = NULL;
-char *binary = NULL;
+uint8_t *kernel_bin = NULL;
 
-void cleanup() {
+static int read_kernel_file(const char* filename, uint8_t** data, size_t* size) {
+  if (nullptr == filename || nullptr == data || 0 == size)
+    return -1;
+
+  FILE* fp = fopen(filename, "r");
+  if (NULL == fp) {
+    fprintf(stderr, "Failed to load kernel.");
+    return -1;
+  }
+  fseek(fp , 0 , SEEK_END);
+  long fsize = ftell(fp);
+  rewind(fp);
+
+  *data = (uint8_t*)malloc(fsize);
+  *size = fread(*data, 1, fsize, fp);
+  
+  fclose(fp);
+  
+  return 0;
+}
+
+static void cleanup() {
   if (commandQueue) clReleaseCommandQueue(commandQueue);
   if (kernel) clReleaseKernel(kernel);
   if (program) clReleaseProgram(program);
@@ -52,19 +72,46 @@ void cleanup() {
   if (b_memobj) clReleaseMemObject(b_memobj);
   if (c_memobj) clReleaseMemObject(c_memobj);  
   if (context) clReleaseContext(context);
-  if (binary) free(binary);
+  if (kernel_bin) free(kernel_bin);
   if (A) free(A);
   if (B) free(B);
   if (C) free(C);
 }
 
+static int find_device(char* name, cl_platform_id platform_id, cl_device_id *device_id) {
+  cl_device_id device_ids[64];
+  cl_uint num_devices = 0;
+
+  CL_CHECK(clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_ALL, 64, device_ids, &num_devices));
+
+  for (int i=0; i<num_devices; i++) 	{
+		char buffer[1024];
+		cl_uint buf_uint;
+		cl_ulong buf_ulong;
+
+		CL_CHECK(clGetDeviceInfo(device_ids[i], CL_DEVICE_NAME, sizeof(buffer), buffer, NULL));
+		
+    if (0 == strncmp(buffer, name, strlen(name))) {
+      *device_id = device_ids[i];
+      return 0;
+    }
+	}
+
+  return 1;
+}
+
 int main (int argc, char **argv) {
   printf("enter demo main\n");
 
   cl_platform_id platform_id;
   cl_device_id device_id;
-  size_t binary_size;
+  size_t kernel_size;
+  cl_int binary_status = 0;
   int i;
+
+  // read kernel binary from file  
+  if (0 != read_kernel_file("kernel.pocl", &kernel_bin, &kernel_size))
+    return -1;
   
   // Getting platform and device information
   CL_CHECK(clGetPlatformIDs(1, &platform_id, NULL));
@@ -90,7 +137,8 @@ int main (int argc, char **argv) {
   }
 
   // Create program from kernel source
-  program = CL_CHECK2(clCreateProgramWithBuiltInKernels(context, 1, &device_id, KERNEL_NAME, &_err));	
+  program = CL_CHECK2(clCreateProgramWithBinary(
+    context, 1, &device_id, &kernel_size, &kernel_bin, &binary_status, &_err));
 
   // Build program
   CL_CHECK(clBuildProgram(program, 1, &device_id, NULL, NULL, NULL));