Test both read and write device global

Author: sherry-yuan

include/acl_mem.h

@@ -89,6 +89,10 @@ cl_bool acl_is_sub_or_parent_buffer(cl_mem mem);
 void CL_CALLBACK acl_free_allocation_after_event_completion(
     cl_event event, cl_int event_command_exec_status, void *callback_data);
 
+void CL_CALLBACK acl_dev_global_cleanup(cl_event event,
+                                        cl_int event_command_exec_status,
+                                        void *callback_data);
+
 #ifdef __GNUC__
 #pragma GCC visibility pop
 #endif

src/acl_mem.cpp

@@ -410,15 +410,93 @@ 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_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_int status;
 
-  // 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);
+  cl_kernel kernel = clCreateKernelIntelFPGA(program, name, &status);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+
+  // dev_addr_t dev_global_address =
+  // kernel->dev_bin->get_devdef().autodiscovery_def.?
+  uintptr_t dev_global_address = 0x4000000;
+  void *dev_global_ptr =
+      (void *)(dev_global_address + offset * 8); // 1 unit of offset is 8 bits
+  status = set_kernel_arg_mem_pointer_without_checks(kernel, 0, dev_global_ptr);
+  // status = clSetKernelArgMemPointerINTEL(kernel, 1, dev_global_ptr);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+
+  // Copy device global memory to temporary device usm pointer first
+  void *tmp_dev_ptr = clDeviceMemAllocINTEL(
+      command_queue->context, command_queue->device, NULL, size, 1, &status);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+  if (!tmp_dev_ptr) {
+    return CL_MEM_OBJECT_ALLOCATION_FAILURE;
+  }
+
+  status = clSetKernelArgMemPointerINTEL(kernel, 1, tmp_dev_ptr);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+
+  // Set size kernel arg
+  status = clSetKernelArg(kernel, 2, sizeof(size_t), (const void *)(&size));
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+
+  cl_event tmp_event = 0;
+  status = clEnqueueTask(command_queue, kernel, num_events_in_wait_list,
+                         event_wait_list, &tmp_event);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+  std::cerr << tmp_event->cmd.info.ndrange_kernel.invocation_wrapper->image
+                   ->activation_id
+            << std::endl;
+
+  // copy from the temporary device memory into user provided pointer
+  std::cerr << "read: copy from tmp dev pointer to source pointer" << std::endl;
+  status = clEnqueueMemcpyINTEL(command_queue, blocking_read, ptr, tmp_dev_ptr,
+                                size, 1, &tmp_event, event);
+  if (status != CL_SUCCESS) {
+    return status;
+  }
+
+  if (blocking_read) {
+    status = clReleaseEvent(tmp_event);
+    if (status != CL_SUCCESS) {
+      return status;
+    }
+    status = clMemFreeINTEL(command_queue->context, tmp_dev_ptr);
+    if (status != CL_SUCCESS) {
+      return status;
+    }
+    status = clReleaseKernel(kernel);
+    if (status != CL_SUCCESS) {
+      return status;
+    }
+  } else {
+    // Clean up resources after event finishes
+    void **callback_data = (void **)acl_malloc(sizeof(void *) * 3);
+    if (!callback_data) {
+      return CL_OUT_OF_HOST_MEMORY;
+    }
+    callback_data[0] = (void *)(tmp_dev_ptr);
+    callback_data[1] = (void *)(kernel);
+    callback_data[2] = (void *)(tmp_event);
+    clSetEventCallback(*event, CL_COMPLETE, acl_dev_global_cleanup,
+                       (void *)callback_data);
+  }
+
+  return CL_SUCCESS;
 }
 
 ACL_EXPORT
@@ -452,6 +530,7 @@ CL_API_ENTRY cl_int clEnqueueWriteGlobalVariableINTEL(
   if (status != CL_SUCCESS) {
     return status;
   }
+
   // if (to_dev_event->execution_status != CL_COMPLETE) {
   //   return CL_INVALID_OPERATION;
   // }
@@ -473,11 +552,10 @@ CL_API_ENTRY cl_int clEnqueueWriteGlobalVariableINTEL(
   // 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_ptr =
       (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);
+  status = set_kernel_arg_mem_pointer_without_checks(kernel, 1, dev_global_ptr);
+  // status = clSetKernelArgMemPointerINTEL(kernel, 1, dev_global_ptr);
   if (status != CL_SUCCESS) {
     return status;
   }
@@ -499,24 +577,54 @@ CL_API_ENTRY cl_int clEnqueueWriteGlobalVariableINTEL(
 
   if (blocking_write) {
     status = clWaitForEvents(1, event);
+    if (status == CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST) {
+      return status;
+    }
+    status = clMemFreeINTEL(command_queue->context, src_dev_ptr);
+    if (status != CL_SUCCESS) {
+      return status;
+    }
+    status = clReleaseKernel(kernel);
+    if (status != CL_SUCCESS) {
+      return status;
+    }
+  } else {
+    // Clean up resources after event finishes
+    void **callback_data = (void **)acl_malloc(sizeof(void *) * 3);
+    if (!callback_data) {
+      return CL_OUT_OF_HOST_MEMORY;
+    }
+    callback_data[0] = (void *)(src_dev_ptr);
+    callback_data[1] = (void *)(kernel);
+    clSetEventCallback(*event, CL_COMPLETE, acl_dev_global_cleanup,
+                       (void *)callback_data);
   }
 
-  if (blocking_write &&
-      status == CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST) {
-    return status;
-  }
+  return CL_SUCCESS;
+}
 
-  // Free allocated device memory
-  status = clMemFreeINTEL(command_queue->context, src_dev_ptr);
-  if (status != CL_SUCCESS) {
-    return status;
+void CL_CALLBACK acl_dev_global_cleanup(cl_event event,
+                                        cl_int event_command_exec_status,
+                                        void *callback_data) {
+  void **callback_ptrs =
+      (void **)callback_data; // callback_ptrs[0] is usm device pointer
+                              // callback_ptrs[1] kernel to be released
+                              // callback_ptrs[2] temporary event to be released
+  event_command_exec_status =
+      event_command_exec_status; // Avoiding Windows warning.
+  event = event;
+  acl_lock();
+  if (callback_ptrs[0]) {
+    clMemFreeINTEL(event->context, callback_ptrs[0]);
   }
-  // status = clReleaseKernel(kernel);
-  // if (status != CL_SUCCESS) {
-  //   return status;
-  // }
-
-  return CL_SUCCESS;
+  if (callback_ptrs[1]) {
+    clReleaseKernel(((cl_kernel)callback_ptrs[1]));
+  }
+  if (callback_ptrs[2]) {
+    clReleaseEvent(((cl_event)callback_ptrs[2]));
+  }
+  acl_free(callback_data);
+  acl_unlock();
 }
 
 ACL_EXPORT

test/acl_usm_test.cpp

@@ -1246,13 +1246,7 @@ MT_TEST(acl_usm, read_device_global) {
   char resultbuf[strsize];
   cl_int status;
 
-  // Don't translate device addresses in the test HAL because we already
-  // will be passing in "device" memory that are actually in the host
-  // address space of the test executable. Ugh.
-  acltest_hal_emulate_device_mem = false;
-
   cl_event write_event = 0;
-  cl_event copy_event = 0;
   cl_event read_event = 0;
 
   // Prepare host memory
@@ -1266,18 +1260,46 @@ MT_TEST(acl_usm, read_device_global) {
   // CHECK(src_ptr != NULL);
 
   syncThreads();
+  // Write to device global
+  status = clEnqueueWriteGlobalVariableINTEL(
+      m_cq, m_program, "kernel15_dev_global", CL_FALSE, strsize, 0, src_ptr, 0,
+      NULL, &write_event);
+  CHECK_EQUAL(CL_SUCCESS, status);
 
-  // Function of interest
+  // Read from device global, with dependence on write event
   status = clEnqueueReadGlobalVariableINTEL(
-      m_cq, m_program, "kernel15_dev_global", CL_FALSE, strsize, 0, src_ptr, 0,
-      NULL, &copy_event);
+      m_cq, m_program, "kernel15_dev_global", CL_FALSE, strsize, 0, src_ptr, 1,
+      &write_event, &read_event);
   CHECK_EQUAL(CL_SUCCESS, status);
-  int activation_id = copy_event->cmd.info.ndrange_kernel.invocation_wrapper
-                          ->image->activation_id;
-  acltest_call_kernel_update_callback(activation_id, CL_RUNNING);
-  acltest_call_kernel_update_callback(activation_id, CL_COMPLETE);
+
+  // Manually set "write device global" event done
+  int write_activation_id = write_event->cmd.info.ndrange_kernel
+                                .invocation_wrapper->image->activation_id;
+  acltest_call_kernel_update_callback(write_activation_id, CL_RUNNING);
+  acltest_call_kernel_update_callback(write_activation_id, CL_COMPLETE);
+
+  // Nudge the scheduler to take above finish into account
+  acl_lock();
+  // If nothing's blocking, then complete right away
+  acl_idle_update(m_cq->context);
+  acl_unlock();
+
+  // The event returned from read device global is not the copy kernel launch
+  // event Therefore need to first get the event that it depend on, then
+  // manually set it to complete
+  auto last_event = read_event->depend_on.end();
+  last_event--;
+  cl_event read_copy_kernel_event = *last_event;
+  int read_activation_id = read_copy_kernel_event->cmd.info.ndrange_kernel
+                               .invocation_wrapper->image->activation_id;
+  acltest_call_kernel_update_callback(read_activation_id, CL_RUNNING);
+  acltest_call_kernel_update_callback(read_activation_id, CL_COMPLETE);
+  // Now the usm copy operation will execute
+
+  // Block on all event completion
   CHECK_EQUAL(CL_SUCCESS, clFinish(m_cq));
-  CHECK_EQUAL(CL_SUCCESS, clReleaseEvent(copy_event));
+  CHECK_EQUAL(CL_SUCCESS, clReleaseEvent(write_event));
+  CHECK_EQUAL(CL_SUCCESS, clReleaseEvent(read_event));
 
   // Host pointer example
   free(src_ptr);