Device global implementation

---------------------------------

Currently the device global pointer is being mocked by passing an actual device allocation into the function. However this should be removed after the pointer is available through autodiscovery string.

Author: sherry-yuan

include/CL/cl_ext.h

@@ -2384,6 +2384,66 @@ clCreateBufferWithPropertiesINTEL_fn)(
     void *       host_ptr,
     cl_int *     errcode_ret) CL_API_SUFFIX__VERSION_1_0;
 
+/**********************************
+* cl_intel_global_variable_access *
+***********************************/
+
+#define CL_COMMAND_READ_GLOBAL_VARIABLE_INTEL   0x418E
+#define CL_COMMAND_WRITE_GLOBAL_VARIABLE_INTEL  0x418F
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueReadGlobalVariableINTEL(
+    cl_command_queue command_queue,
+    cl_program program,
+    const char* name,
+    cl_bool blocking_read,
+    size_t size,
+    size_t offset,
+    void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0;
+    
+
+typedef CL_API_ENTRY cl_int (CL_API_CALL *
+clEnqueueReadGlobalVariableINTEL_fn)(
+    cl_command_queue command_queue,
+    cl_program program,
+    const char* name,
+    cl_bool blocking_read,
+    size_t size,
+    size_t offset,
+    const void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0;
+
+extern CL_API_ENTRY cl_int CL_API_CALL
+clEnqueueWriteGlobalVariableINTEL(
+    cl_command_queue command_queue,
+    cl_program program,
+    const char* name,
+    cl_bool blocking_write,
+    size_t size,
+    size_t offset,
+    const void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0;
+
+typedef CL_API_ENTRY cl_int (CL_API_CALL *
+clEnqueueWriteGlobalVariableINTEL_fn)(
+    cl_command_queue command_queue,
+    cl_program program,
+    const char* name,
+    cl_bool blocking_read,
+    size_t size,
+    size_t offset,
+    void* ptr,
+    cl_uint num_events_in_wait_list,
+    const cl_event* event_wait_list,
+    cl_event* event) CL_API_SUFFIX__VERSION_1_0;
+
 /******************************************
 * cl_intel_mem_channel_property extension *
 *******************************************/

include/acl_kernel.h

@@ -54,6 +54,10 @@ void acl_receive_kernel_update(int activation_id, cl_int status);
 // safe to submit a kernel with subbuffers to the device_op_queue
 int acl_kernel_has_unmapped_subbuffers(acl_mem_migrate_t *mem_migration);
 
+cl_int set_kernel_arg_mem_pointer_without_checks(cl_kernel kernel,
+                                                 cl_uint arg_index,
+                                                 void *arg_value);
+
 #if defined(__cplusplus)
 } /* extern "C" */
 #endif

src/acl_icd_dispatch.cpp

@@ -50,6 +50,8 @@ clGetExtensionFunctionAddressIntelFPGA(const char *func_name) {
   ADDFUNCTIONLOOKUP(clResetKernelsIntelFPGA);
   ADDFUNCTIONLOOKUP(clSetBoardLibraryIntelFPGA);
   ADDFUNCTIONLOOKUP(clCreateBufferWithPropertiesINTEL);
+  ADDFUNCTIONLOOKUP(clEnqueueReadGlobalVariableINTEL);
+  ADDFUNCTIONLOOKUP(clEnqueueWriteGlobalVariableINTEL);
 
 // USM APIs are not currently supported on 32bit devices
 #ifndef __arm__

src/acl_kernel.cpp

@@ -837,6 +837,41 @@ CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer(
   return clSetKernelArgSVMPointerIntelFPGA(kernel, arg_index, arg_value);
 }
 
+cl_int set_kernel_arg_mem_pointer_without_checks(cl_kernel kernel,
+                                                 cl_uint arg_index,
+                                                 void *arg_value) {
+  acl_lock();
+  if (!acl_kernel_is_valid(kernel)) {
+    UNLOCK_RETURN(CL_INVALID_KERNEL);
+  }
+
+  cl_context context = kernel->program->context;
+
+  if (arg_index >= kernel->accel_def->iface.args.size()) {
+    UNLOCK_ERR_RET(CL_INVALID_ARG_INDEX, context,
+                   "Argument index is too large");
+  }
+
+  // Determine where to write the value.
+  size_t start_idx = 0;
+  size_t iface_arg_size = 0;
+  l_get_arg_offset_and_size(kernel, arg_index, &start_idx, &iface_arg_size);
+  safe_memcpy(&(kernel->arg_value[start_idx]), &arg_value, iface_arg_size,
+              kernel->arg_value_size - start_idx, iface_arg_size);
+  kernel->arg_is_svm[arg_index] = CL_FALSE;
+  kernel->arg_is_ptr[arg_index] = CL_TRUE;
+
+  kernel->arg_defined[arg_index] = 1;
+
+  // double vector size if size < arg_index
+  while (kernel->ptr_arg_vector.size() <= arg_index) {
+    kernel->ptr_arg_vector.resize(kernel->ptr_arg_vector.size() * 2);
+  }
+  kernel->ptr_arg_vector[arg_index] = arg_value;
+
+  UNLOCK_RETURN(CL_SUCCESS);
+}
+
 ACL_EXPORT
 CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgMemPointerINTEL(
     cl_kernel kernel, cl_uint arg_index, const void *arg_value) {

src/acl_mem.cpp

@@ -19,6 +19,7 @@
 #include <acl_globals.h>
 #include <acl_hal.h>
 #include <acl_icd_dispatch.h>
+#include <acl_kernel.h>
 #include <acl_mem.h>
 #include <acl_platform.h>
 #include <acl_support.h>
@@ -405,6 +406,119 @@ int acl_bind_buffer_to_device(cl_device_id device, cl_mem mem) {
   return 1;
 }
 
+ACL_EXPORT
+// CL_API_ENTRY cl_int clEnqueueReadGlobalVariableINTEL() {
+CL_API_ENTRY cl_int clEnqueueReadGlobalVariableINTEL(
+    cl_command_queue command_queue, cl_program program, const char *name,
+    cl_bool blocking_write, size_t size, size_t offset, void *ptr,
+    cl_uint num_events_in_wait_list, const cl_event *event_wait_list,
+    cl_event *event) {
+
+  // TODO: get dev_global_ptr from autodiscovery instead later
+  // return 0;
+  return clEnqueueWriteGlobalVariableINTEL(
+      command_queue, program, name, blocking_write, size, offset, ptr,
+      num_events_in_wait_list, event_wait_list, event);
+}
+
+ACL_EXPORT
+CL_API_ENTRY cl_int clEnqueueWriteGlobalVariableINTEL(
+    cl_command_queue command_queue, cl_program program, const char *name,
+    cl_bool blocking_write, size_t size, size_t offset, const void *ptr,
+    cl_uint num_events_in_wait_list, const cl_event *event_wait_list,
+    cl_event *event) {
+  cl_int status;
+
+  cl_kernel kernel = clCreateKernelIntelFPGA(program, name, &status);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+
+  // do we support ptr being a buffer instead of usm pointer? it seems to be the
+  // case on spec (only usm host pointer) Given kernel arg must be a deivce usm
+  // pointer: When ptr is a host/shared usm pointer, this function is expected
+  // to copy it to device first? yes (currently discussing whether kernel arg
+  // accept host usm instead)
+  void *src_dev_ptr = clDeviceMemAllocINTEL(
+      command_queue->context, command_queue->device, NULL, size, 1, &status);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+
+  // This copy operation have to be blocking
+  // cl_event to_dev_event = 0;
+  status = clEnqueueMemcpyINTEL(command_queue, CL_TRUE, src_dev_ptr, ptr, size,
+                                0, NULL, NULL);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+  // if (to_dev_event->execution_status != CL_COMPLETE) {
+  //   return CL_INVALID_OPERATION;
+  // }
+
+  status = clSetKernelArgMemPointerINTEL(kernel, 0, src_dev_ptr);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+  // should kernel header contain offset or not? no
+  // offset is always byte offset? yes
+  // Assuming below returns same thing as `clDeviceMemAllocINTEL`, where exactly
+  // is dev global ptr being read from? What format is the read dev global, is
+  // it a pointer just like the return value of `clDeviceMemAllocINTEL` or is it
+  // something else? (its an unsigned value indicating address)
+  // TODO: When passing dev global pointer directly to
+  // clSetKernelArgMemPointerINTEL, make sure REMOVE_VALID_CHECKS is defined.
+  // Otherwise this ptr is not existing in context -> cause checks to fail
+  // TODO: get dev_global_address from autodiscovery instead later
+  // dev_addr_t dev_global_address =
+  // kernel->dev_bin->get_devdef().autodiscovery_def.?
+  uintptr_t dev_global_address = 0x4000000;
+  void *dev_global_ptr2 =
+      (void *)(dev_global_address + offset * 8); // 1 unit of offset is 8 bits
+  status =
+      set_kernel_arg_mem_pointer_without_checks(kernel, 1, dev_global_ptr2);
+  // status = clSetKernelArgMemPointerINTEL(kernel, 1, dev_global_ptr2);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+  status = clSetKernelArg(kernel, 2, sizeof(size_t), (const void *)(&size));
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+
+  status = clEnqueueTask(command_queue, kernel, num_events_in_wait_list,
+                         event_wait_list, event);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+
+  acl_lock();
+  // If nothing's blocking, then complete right away
+  acl_idle_update(command_queue->context);
+  acl_unlock();
+
+  if (blocking_write) {
+    status = clWaitForEvents(1, event);
+  }
+
+  if (blocking_write &&
+      status == CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST) {
+    return status;
+  }
+
+  // Free allocated device memory
+  status = clMemFreeINTEL(command_queue->context, src_dev_ptr);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+  status = clReleaseKernel(kernel);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+
+  return CL_SUCCESS;
+}
+
 ACL_EXPORT
 CL_API_ENTRY cl_mem clCreateBufferWithPropertiesINTEL(
     cl_context context, const cl_mem_properties_intel *properties,

test/acl_globals_test.cpp

@@ -118,6 +118,14 @@ static acl_kernel_interface_t acltest_kernels[] = {
          {ACL_ARG_ADDR_GLOBAL, ACL_ARG_MEM_OBJ, sizeof(int *), 0, 0, 8},
          {ACL_ARG_ADDR_GLOBAL, ACL_ARG_MEM_OBJ, sizeof(int *), 0, 0, 16},
          {ACL_ARG_ADDR_GLOBAL, ACL_ARG_MEM_OBJ, sizeof(int *), 0, 0, 1024},
+     }},
+    {// interface
+     "kernel15_dev_global",
+     {
+         {ACL_ARG_ADDR_GLOBAL, ACL_ARG_MEM_OBJ, sizeof(int *), 0, 0, 1},
+         {ACL_ARG_ADDR_GLOBAL, ACL_ARG_MEM_OBJ, sizeof(int *), 0, 0, 1},
+         {ACL_ARG_ADDR_NONE, ACL_ARG_BY_VALUE, sizeof(size_t), 0, 0},
+         //  {ACL_ARG_ADDR_NONE, ACL_ARG_BY_VALUE, sizeof(size_t), 0, 0},
      }}};
 
 template <typename T, std::size_t N>
@@ -191,6 +199,20 @@ static std::vector<acl_accel_def_t> acltest_complex_system_device0_accel = {
      {},
      {32768, 0, 0},
      1},
+    {14,
+     ACL_RANGE_FROM_ARRAY(acltest_devicelocal[11]),
+     acltest_kernels[14],
+     acltest_laspace_info,
+     {0, 0, 0},
+     0,
+     0,
+     1,
+     0,
+     32768,
+     3,
+     {},
+     {32768, 0, 0},
+     1},
     {1,
      ACL_RANGE_FROM_ARRAY(acltest_devicelocal[1]),
      acltest_kernels[1],

test/acl_program_test.cpp

@@ -606,25 +606,25 @@ MT_TEST(acl_program, program_info) {
   // built stat. to success even before calling clbuildprogram
   CHECK_EQUAL(CL_SUCCESS, clGetProgramInfo(program, CL_PROGRAM_NUM_KERNELS,
                                            sizeof(size_t), &num_kernels, 0));
-  CHECK_EQUAL(14, num_kernels);
+  CHECK_EQUAL(15, num_kernels);
 
   // This won't happen if program is built with binary since we set the program
   // built stat. to success even before calling clbuildprogram
   CHECK_EQUAL(CL_SUCCESS, clGetProgramInfo(program, CL_PROGRAM_KERNEL_NAMES, 0,
                                            NULL, &size_ret));
-  CHECK_EQUAL(321, size_ret);
+  CHECK_EQUAL(341, size_ret);
 
   CHECK_EQUAL(CL_SUCCESS, clBuildProgram(program, 0, 0, "", 0, 0));
 
   // after building the program
   CHECK_EQUAL(CL_SUCCESS, clGetProgramInfo(program, CL_PROGRAM_NUM_KERNELS,
                                            sizeof(size_t), &num_kernels, 0));
-  CHECK_EQUAL(14, num_kernels);
+  CHECK_EQUAL(15, num_kernels);
 
   CHECK_EQUAL(CL_SUCCESS,
               clGetProgramInfo(program, CL_PROGRAM_NUM_KERNELS, sizeof(size_t),
                                &num_kernels, &size_ret));
-  CHECK_EQUAL(14, num_kernels);
+  CHECK_EQUAL(15, num_kernels);
   CHECK_EQUAL(sizeof(size_t), size_ret);
 
   CHECK_EQUAL(CL_SUCCESS, clGetProgramInfo(program, CL_PROGRAM_NUM_KERNELS, 0,
@@ -633,19 +633,21 @@ MT_TEST(acl_program, program_info) {
 
   CHECK_EQUAL(CL_SUCCESS, clGetProgramInfo(program, CL_PROGRAM_KERNEL_NAMES, 0,
                                            NULL, &size_ret));
-  CHECK_EQUAL(321, size_ret);
+  CHECK_EQUAL(341, size_ret);
+  // CHECK_EQUAL(321, size_ret);
 
   names[size_ret] = 100; // making sure extra bytes of memory are not affected.
   CHECK_EQUAL(CL_SUCCESS,
               clGetProgramInfo(program, CL_PROGRAM_KERNEL_NAMES,
                                2000 * sizeof(char), names, &size_ret));
-  CHECK_EQUAL(321, size_ret); // only one kernel named: "foo"
+  CHECK_EQUAL(341, size_ret); // only one kernel named: "foo"
   CHECK_EQUAL(100, names[size_ret]);
   CHECK_EQUAL(0, strcmp("kernel0_copy_vecin_vecout;"
                         "kernel11_task_double;"
                         "kernel12_task_double;"
                         "kernel13_multi_vec_lane;"
                         "kernel14_svm_arg_alignment;"
+                        "kernel15_dev_global;"
                         "kernel1_vecadd_vecin_vecin_vecout;"
                         "kernel2_vecscale_vecin_scalar_vecout;"
                         "kernel3_locals;"