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,68 @@ 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
+
+// TODO; remove dev_global_ptr from parameter
+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,
+    const void* dev_global_ptr) 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, const void* dev_global_ptr) 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, const void* dev_global_ptr) 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, const void* dev_global_ptr) CL_API_SUFFIX__VERSION_1_0;
+
 /******************************************
 * cl_intel_mem_channel_property extension *
 *******************************************/

include/acl_kernel.h

@@ -54,6 +54,9 @@ 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_event.cpp

@@ -812,7 +812,6 @@ cl_int acl_create_event(cl_command_queue command_queue, cl_uint num_events,
 #endif
 
   context = command_queue->context;
-
   event = l_get_unused_event(context);
   if (event == 0) {
     acl_context_callback(context, "Could not allocate an event or command");
@@ -861,7 +860,6 @@ cl_int acl_create_event(cl_command_queue command_queue, cl_uint num_events,
           events[i]->depend_on_me.pop_back();
         }
       }
-
       // Return event back to free pool
       event->depend_on.clear();
       l_return_event_to_free_pool(event);
@@ -871,7 +869,6 @@ cl_int acl_create_event(cl_command_queue command_queue, cl_uint num_events,
 
   if (event) {
     // Success!
-
     // Normally, the command info union usage is determined only
     // by the command type.  But in the case of CL_COMMAND_MAP_BUFFER
     // and CL_COMMAND_UNMAP_MEM_OBJECT, we need this extra bit to know
@@ -919,7 +916,6 @@ cl_int acl_create_event(cl_command_queue command_queue, cl_uint num_events,
       printf("  Notify: Event [%d] has been created:\n", event->id);
       acl_dump_event(event);
     }
-
     acl_track_object(ACL_OBJ_EVENT, event);
   } else {
     acl_context_callback(context, "Could not allocate an event");

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,40 @@ 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

@@ -24,6 +24,7 @@
 #include <acl_support.h>
 #include <acl_svm.h>
 #include <acl_util.h>
+#include <acl_kernel.h>
 #include <check_copy_overlap.h>
 
 #ifdef __GNUC__
@@ -405,6 +406,122 @@ 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,
+    const void* dev_global_ptr) {
+    
+  // 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, dev_global_ptr);
+}
+
+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,
+    const void* dev_global_ptr) {
+  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,

src/acl_usm.cpp

@@ -863,7 +863,6 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueMemcpyINTEL(
     UNLOCK_ERR_RET(CL_MEM_COPY_OVERLAP, command_queue->context,
                    "Source and destination memory overlaps");
   }
-
   acl_usm_allocation_t *dst_usm_alloc =
       acl_get_usm_alloc_from_ptr(command_queue->context, dst_ptr);
 

test/acl_globals_test.cpp

@@ -118,7 +118,16 @@ 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>
 static inline constexpr acl_addr_range_t ACL_RANGE_FROM_ARRAY(T (&a)[N]) {
@@ -191,6 +200,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],