mutiple fixes: parallel printf, fixed cycle in cache, opencl refactored vecadd and sgemm, regen opencl kernels with hard-float, fixed vortex io bus interface, fixed dpi floats APi to support multicore mode, make vlsim multicore default, make rtlsim multi-core default, removed POCL binaries from repository, updated Makefiles to use external POCL

benchmarks/opencl/vecadd/Makefile

@@ -1,12 +1,16 @@
-LLVM_HOME ?= ~/dev/llvm-project/drops
-RISCV_TOOLCHAIN_PATH ?= ~/dev/riscv-gnu-toolchain/drops
+LLVM_PREFIX ?= /opt/llvm-riscv
+RISCV_TOOLCHAIN_PATH ?= /opt/riscv-gnu-toolchain
 SYSROOT ?= $(RISCV_TOOLCHAIN_PATH)/riscv32-unknown-elf
+POCL_CC_PATH ?= /opt/pocl/compiler
+POCL_RT_PATH ?= /opt/pocl/runtime
 
-POCL_CC_PATH ?= $(realpath ../compiler)
-POCL_RT_PATH ?= $(realpath ../runtime)
 VORTEX_DRV_PATH ?= $(realpath ../../../driver)
 VORTEX_RT_PATH ?= $(realpath ../../../runtime)
 
+K_LLCFLAGS += "-O3 -march=riscv32 -target-abi=ilp32f -mcpu=generic-rv32 -mattr=+m,+f -float-abi=hard -code-model=small"
+K_CFLAGS   += "-v -O3 --sysroot=$(SYSROOT) --gcc-toolchain=$(RISCV_TOOLCHAIN_PATH) -march=rv32imf -mabi=ilp32f -I$(VORTEX_RT_PATH)/include -fno-rtti -fno-exceptions -ffreestanding -nostartfiles -Wl,--gc-sections -Wl,-Bstatic,-T$(VORTEX_RT_PATH)/linker/vx_link.ld"
+K_LDFLAGS  += "$(VORTEX_RT_PATH)/libvortexrt.a -lm"
+
 CXXFLAGS += -std=c++11 -O0 -g -fpermissive -Wall -Wextra -pedantic -Wfatal-errors
 
 CXXFLAGS += -I$(POCL_RT_PATH)/include
@@ -17,10 +21,10 @@ PROJECT = vecadd
 
 SRCS = main.cc
 
-all: $(PROJECT)
+all: $(PROJECT) kernel.pocl
 
 kernel.pocl: kernel.cl
-	RISCV_TOOLCHAIN_PATH=$(RISCV_TOOLCHAIN_PATH) SYSROOT=$(SYSROOT) LLVM_HOME=$(LLVM_HOME) VORTEX_RT_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
+	LLVM_PREFIX=$(LLVM_PREFIX) POCL_DEBUG=all LD_LIBRARY_PATH=$(LLVM_PREFIX)/lib:$(POCL_CC_PATH)/lib $(POCL_CC_PATH)/bin/poclcc -LLCFLAGS $(K_LLCFLAGS) -CFLAGS $(K_CFLAGS) -LDFLAGS $(K_LDFLAGS) -o kernel.pocl kernel.cl
  
 $(PROJECT): $(SRCS)
 	$(CXX) $(CXXFLAGS) $^ $(LDFLAGS) -o $@

benchmarks/opencl/vecadd/kernel.cl

@@ -1,8 +1,7 @@
-kernel void
-vecadd (__global const int *a,
-	__global const int *b,
-	__global int *c)
+__kernel void vecadd (__global const float *A,
+	                    __global const float *B,
+	                    __global float *C)
 {
   int gid = get_global_id(0);
-  c[gid] = a[gid] + b[gid];
+  C[gid] = A[gid] + B[gid];
 }

benchmarks/opencl/vecadd/main.cc

@@ -1,11 +1,12 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
+#include <math.h>
 #include <CL/opencl.h>
 #include <string.h>
+#include <chrono>
 
-#define SIZE 4096
-#define NUM_WORK_GROUPS 2
+#define SIZE 256
 #define KERNEL_NAME "vecadd"
 
 #define CL_CHECK(_expr)                                                \
@@ -30,20 +31,6 @@
      _ret;                                                             \
    })
 
-int exitcode = 0;
-cl_device_id device_id = NULL;
-cl_context context = NULL;
-cl_command_queue commandQueue = NULL;
-cl_program program = NULL;
-cl_kernel kernel = NULL;
-cl_mem a_memobj = NULL;
-cl_mem b_memobj = NULL;
-cl_mem c_memobj = NULL;  
-cl_int *A = NULL;
-cl_int *B = NULL;
-cl_int *C = NULL;
-uint8_t *kernel_bin = NULL;
-
 static int read_kernel_file(const char* filename, uint8_t** data, size_t* size) {
   if (nullptr == filename || nullptr == data || 0 == size)
     return -1;
@@ -65,6 +52,27 @@ static int read_kernel_file(const char* filename, uint8_t** data, size_t* size)
   return 0;
 }
 
+static bool almost_equal(float a, float b, int ulp = 4) {
+  union fi_t { int i; float f; };
+  fi_t fa, fb;
+  fa.f = a;
+  fb.f = b;
+  return std::abs(fa.i - fb.i) <= ulp;
+}
+
+cl_device_id device_id = NULL;
+cl_context context = NULL;
+cl_command_queue commandQueue = NULL;
+cl_program program = NULL;
+cl_kernel kernel = NULL;
+cl_mem a_memobj = NULL;
+cl_mem b_memobj = NULL;
+cl_mem c_memobj = NULL;  
+float *h_a = NULL;
+float *h_b = NULL;
+float *h_c = NULL;
+uint8_t *kernel_bin = NULL;
+
 static void cleanup() {
   if (commandQueue) clReleaseCommandQueue(commandQueue);
   if (kernel) clReleaseKernel(kernel);
@@ -76,40 +84,15 @@ static void cleanup() {
   if (device_id) clReleaseDevice(device_id);
   
   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;
+  if (h_a) free(h_a);
+  if (h_b) free(h_b);
+  if (h_c) free(h_c);
 }
 
 int main (int argc, char **argv) {
-  printf("enter demo main\n");
-
   cl_platform_id platform_id;
   size_t kernel_size;
-  cl_int binary_status = 0;
-  int i;
+  cl_int binary_status;
 
   // read kernel binary from file  
   if (0 != read_kernel_file("kernel.pocl", &kernel_bin, &kernel_size))
@@ -119,30 +102,19 @@ int main (int argc, char **argv) {
   CL_CHECK(clGetPlatformIDs(1, &platform_id, NULL));
   CL_CHECK(clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_DEFAULT, 1, &device_id, NULL));
 
-  // Creating context.
+  printf("Create context\n");
   context = CL_CHECK2(clCreateContext(NULL, 1, &device_id, NULL, NULL,  &_err));
 
-  // Memory buffers for each array
-  a_memobj = CL_CHECK2(clCreateBuffer(context, CL_MEM_READ_ONLY, SIZE * sizeof(cl_int), NULL, &_err));
-  b_memobj = CL_CHECK2(clCreateBuffer(context, CL_MEM_READ_ONLY, SIZE * sizeof(cl_int), NULL, &_err));
-  c_memobj = CL_CHECK2(clCreateBuffer(context, CL_MEM_WRITE_ONLY, SIZE * sizeof(cl_int), NULL, &_err));
+  printf("Allocate device buffers\n");
+  size_t nbytes = SIZE * sizeof(float);
+  a_memobj = CL_CHECK2(clCreateBuffer(context, CL_MEM_READ_ONLY, nbytes, NULL, &_err));
+  b_memobj = CL_CHECK2(clCreateBuffer(context, CL_MEM_READ_ONLY, nbytes, NULL, &_err));
+  c_memobj = CL_CHECK2(clCreateBuffer(context, CL_MEM_WRITE_ONLY, nbytes, NULL, &_err));
 
-  // Allocate memories for input arrays and output arrays.  
-  A = (cl_int*)malloc(sizeof(cl_int)*SIZE);
-  B = (cl_int*)malloc(sizeof(cl_int)*SIZE);
-  C = (cl_int*)malloc(sizeof(cl_int)*SIZE);	
-	
-  // Initialize values for array members.  
-  for (i=0; i<SIZE; ++i) {
-    A[i] = i*2+0;
-    B[i] = i*2+1;
-  }
-
-  // Create program from kernel source
+  printf("Create program from kernel source\n");
   program = CL_CHECK2(clCreateProgramWithBinary(
     context, 1, &device_id, &kernel_size, &kernel_bin, &binary_status, &_err));
   if (program == NULL) {
-    printf("clCreateProgramWithBinary() failed\n");
     cleanup();
     return -1;
   }
@@ -153,42 +125,61 @@ int main (int argc, char **argv) {
   // Create kernel
   kernel = CL_CHECK2(clCreateKernel(program, KERNEL_NAME, &_err));
 
-  // Set arguments for kernel
+  // Set kernel arguments
   CL_CHECK(clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&a_memobj));	
   CL_CHECK(clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&b_memobj));	
   CL_CHECK(clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&c_memobj));
 
+  // Allocate memories for input arrays and output arrays.    
+  h_a = (float*)malloc(nbytes);
+  h_b = (float*)malloc(nbytes);
+  h_c = (float*)malloc(nbytes);	
+	
+  // Initialize values for array members.  
+  for (int i = 0; i < SIZE; ++i) {
+    h_a[i] = sinf(i)*sinf(i);
+    h_b[i] = cosf(i)*cosf(i);
+    h_c[i] = 0xdeadbeef;
+    //printf("*** [%d]: h_a=%f, h_b=%f\n", i, h_a[i], h_b[i]);
+  }
+
   // Creating command queue
-  commandQueue = CL_CHECK2(clCreateCommandQueue(context, device_id, 0, &_err));
+  commandQueue = CL_CHECK2(clCreateCommandQueue(context, device_id, 0, &_err));  
 
-	// Copy lists to memory buffers
-  CL_CHECK(clEnqueueWriteBuffer(commandQueue, a_memobj, CL_TRUE, 0, SIZE * sizeof(float), A, 0, NULL, NULL));
-  CL_CHECK(clEnqueueWriteBuffer(commandQueue, b_memobj, CL_TRUE, 0, SIZE * sizeof(float), B, 0, NULL, NULL));
+	printf("Upload source buffers\n");
+  CL_CHECK(clEnqueueWriteBuffer(commandQueue, a_memobj, CL_TRUE, 0, nbytes, h_a, 0, NULL, NULL));
+  CL_CHECK(clEnqueueWriteBuffer(commandQueue, b_memobj, CL_TRUE, 0, nbytes, h_b, 0, NULL, NULL));
 
-  // Execute the kernel
-  size_t globalItemSize = SIZE;
-  size_t localItemSize = SIZE/NUM_WORK_GROUPS;
-  CL_CHECK(clEnqueueNDRangeKernel(commandQueue, kernel, 1, NULL, &globalItemSize, &localItemSize, 0, NULL, NULL));
+  printf("Execute the kernel\n");
+  size_t global_work_size[1] = {SIZE};
+  size_t local_work_size[1] = {1};
+  auto time_start = std::chrono::high_resolution_clock::now();
+  CL_CHECK(clEnqueueNDRangeKernel(commandQueue, kernel, 1, NULL, global_work_size, local_work_size, 0, NULL, NULL));
   CL_CHECK(clFinish(commandQueue));
+  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);
 
-  // Read from device back to host.
-  CL_CHECK(clEnqueueReadBuffer(commandQueue, c_memobj, CL_TRUE, 0, SIZE * sizeof(float), C, 0, NULL, NULL));
+  printf("Download destination buffer\n");
+  CL_CHECK(clEnqueueReadBuffer(commandQueue, c_memobj, CL_TRUE, 0, nbytes, h_c, 0, NULL, NULL));
 
-  // Test if correct answer
-  int exitcode = 0;
-  for (i=0; i<SIZE; ++i) {
-    if (C[i] != (A[i] + B[i])) {
-      printf("Failed!\n");
-      exitcode = 1;
-      break;
+  printf("Verify result\n");
+  int errors = 0;
+  for (int i = 0; i < SIZE; ++i) {
+    float ref = h_a[i] + h_b[i];
+    if (!almost_equal(h_c[i], ref)) {
+      printf("*** error: [%d] expected=%f, actual=%f, a=%f, b=%f\n", i, ref, h_c[i], h_a[i], h_b[i]);
+      ++errors;
     }
   }
-  if (i == SIZE) {
-    printf("Ok!\n");
+  if (0 == errors) {
+    printf("PASSED!\n");
+  } else {
+    printf("FAILED! - %d errors\n", errors);    
   }
 
   // Clean up		
   cleanup();  
 
-  return exitcode;
+  return errors;
 }