Update aocl_mmd.h version to 2024.2 and base buffer location support on MMD verison

Author: sophimao

include/MMD/aocl_mmd.h

@@ -466,6 +466,7 @@ typedef struct {
   cl_mem_alloc_flags_intel alloc_flags;
   cl_unified_shared_memory_type_intel type;
   cl_uint alignment; // May not be needed. Track for now.
+  cl_uint host_shared_mem_id;
 } acl_usm_allocation_t;
 
 typedef struct {
@@ -558,9 +559,10 @@ struct acl_sideband_signal_mapping {
 enum signal_type {
   SignalUnknown = -1,
   AvalonData = 0,
-  AvalonSop = 1,
-  AvalonEop = 2,
-  AvalonEmpty = 3
+  AvalonSOP = 1,
+  AvalonEOP = 2, // Same as AXILast
+  AvalonEmpty = 3,
+  AXIUser = 4
 };
 
 // Part of acl_device_def_t where members are populated from the information

include/acl.h

@@ -184,6 +184,8 @@ typedef struct {
   int (*has_svm_memory_support)(unsigned int physical_device_id, int *value);
   /// Returns 1 if physical mem is supported
   int (*has_physical_mem)(unsigned int physical_device_id);
+  /// Returns 1 if buffer location is supported across devices
+  int (*support_buffer_location)(const std::vector<cl_device_id> &devices);
 
   /// Get pointer to board specific extension functions
   void *(*get_board_extension_function_address)(
@@ -266,14 +268,7 @@ typedef struct {
       unsigned int physical_device_id, const char *interface_name,
       const void *host_addr, size_t dev_addr, size_t size);
 
-  /// Simulation only mmd call as of 2024.1
-  /// Return the sideband signal buffer corresponding to the side band signal
-  /// port identifier
-  void *(*hostchannel_get_sideband_buffer)(unsigned int physical_device_id,
-                                           unsigned int port_name,
-                                           int channel_handle,
-                                           size_t *buffer_size, int *status);
-
+  /// Simulation only hal function as of 2024.1
   /// Pull read_size of sideband data from the device into host_buffer, WITHOUT
   /// acknowledge
   size_t (*hostchannel_sideband_pull_no_ack)(unsigned int physical_device_id,
@@ -282,6 +277,7 @@ typedef struct {
                                              void *host_buffer,
                                              size_t read_size, int *status);
 
+  /// Simulation only hal function as of 2024.1
   /// Push write_size of sideband data to the device from host_buffer, WITHOUT
   /// acknowledge
   size_t (*hostchannel_sideband_push_no_ack)(unsigned int physical_device_id,

include/acl_hal.h

@@ -283,10 +283,9 @@ typedef struct {
   // port identifier Get a pointer to the mmd buffer for the host channel
   // Simulation only mmd call as of 2024.1. HW MMD developer needs to implement
   // this function in the future To support hostpipe sideband signals.
-  void *(*aocl_mmd_hostchannel_get_sideband_buffer)(int handle, int channel,
-                                                    int port_id,
-                                                    size_t *buffer_size,
-                                                    int *status);
+  void *(*aocl_mmd_hostchannel_get_sideband_buffer)(
+      int handle, int channel, aocl_mmd_hostchannel_port_id_t port_id,
+      size_t *buffer_size, int *status);
 
 } acl_mmd_dispatch_t;
 

include/acl_hal_mmd.h

@@ -185,10 +185,6 @@ int acl_hal_mmd_simulation_device_global_interface_write(
     unsigned int physical_device_id, const char *interface_name,
     const void *host_addr, size_t dev_addr, size_t size);
 
-void *acl_hal_mmd_hostchannel_get_sideband_buffer(
-    unsigned int physical_device_id, unsigned int port_name, int channel_handle,
-    size_t *buffer_size, int *status);
-
 size_t acl_hal_mmd_hostchannel_sideband_pull_no_ack(
     unsigned int physical_device_id, unsigned int port_name, int channel_handle,
     void *host_buffer, size_t read_size, int *status);
@@ -209,6 +205,8 @@ static time_ns acl_bsp_get_timestamp(void);
 
 int acl_hal_mmd_has_svm_support(unsigned int physical_device_id, int *value);
 int acl_hal_mmd_has_physical_mem(unsigned int physical_device_id);
+int acl_hal_mmd_support_buffer_location(
+    const std::vector<cl_device_id> &devices);
 
 static void *
 acl_hal_get_board_extension_function_address(const char *func_name,
@@ -296,6 +294,7 @@ static acl_hal_t acl_hal_mmd = {
     acl_hal_mmd_set_profile_stop_count,      // set_profile_stop_cycle
     acl_hal_mmd_has_svm_support,             // has_svm_memory_support
     acl_hal_mmd_has_physical_mem,            // has_physical_mem
+    acl_hal_mmd_support_buffer_location,     // support_buffer_location
     acl_hal_get_board_extension_function_address, // get_board_extension_function_address
     acl_hal_mmd_pll_reconfigure,                  // pll_reconfigure
     acl_hal_mmd_reset_kernels,                    // reset_kernels
@@ -319,9 +318,8 @@ static acl_hal_t acl_hal_mmd = {
     acl_hal_mmd_write_csr,                             // write_csr
     acl_hal_mmd_simulation_device_global_interface_read, // simulation_device_global_interface_read
     acl_hal_mmd_simulation_device_global_interface_write, // simulation_device_global_interface_write
-    acl_hal_mmd_hostchannel_get_sideband_buffer, // hostchannel_get_sideband_buffer
-    acl_hal_mmd_hostchannel_sideband_pull_no_ack, // hostchannel_sideband_push
-    acl_hal_mmd_hostchannel_sideband_push_no_ack, // hostchannel_sideband_push
+    acl_hal_mmd_hostchannel_sideband_pull_no_ack, // hostchannel_sideband_pull_no_ack
+    acl_hal_mmd_hostchannel_sideband_push_no_ack, // hostchannel_sideband_push_no_ack
     acl_hal_mmd_hostchannel_pull_no_ack,          // hostchannel_pull_no_ack
     acl_hal_mmd_hostchannel_push_no_ack,          // hostchannel_push_no_ack
 };
@@ -2496,23 +2494,6 @@ size_t acl_hal_mmd_hostchannel_ack_buffer(unsigned int physical_device_id,
           pcie_dev_handle, channel_handle, ack_size, status);
 }
 
-void *acl_hal_mmd_hostchannel_get_sideband_buffer(
-    unsigned int physical_device_id, unsigned int port_name, int channel_handle,
-    size_t *buffer_size, int *status) {
-
-  int pcie_dev_handle;
-
-  pcie_dev_handle = device_info[physical_device_id].handle;
-  *status = 0;
-
-  // get the pointer to host channel mmd buffer
-  assert(device_info[physical_device_id]
-             .mmd_dispatch->aocl_mmd_hostchannel_get_sideband_buffer);
-  return device_info[physical_device_id]
-      .mmd_dispatch->aocl_mmd_hostchannel_get_sideband_buffer(
-          pcie_dev_handle, channel_handle, port_name, buffer_size, status);
-}
-
 size_t acl_hal_mmd_hostchannel_sideband_pull_no_ack(
     unsigned int physical_device_id, unsigned int port_name, int channel_handle,
     void *host_buffer, size_t read_size, int *status) {
@@ -2688,6 +2669,28 @@ int acl_hal_mmd_has_physical_mem(unsigned int physical_device_id) {
   }
 }
 
+/**
+ * Returns if a set of devices all support buffer location mem property
+ * @param  a vector of devices on which to query
+ * @return 1 if supported, else 0
+ */
+int acl_hal_mmd_support_buffer_location(
+    const std::vector<cl_device_id> &devices) {
+  acl_assert_locked();
+
+  int bl_supported = 1;
+  for (const auto &device : devices) {
+    unsigned int physical_device_id = device->def.physical_device_id;
+    if (MMDVERSION_LESSTHAN(
+            device_info[physical_device_id].mmd_dispatch->mmd_version,
+            2024.2)) {
+      bl_supported = 0;
+    }
+  }
+
+  return bl_supported;
+}
+
 #ifdef _WIN32
 // Query the system timer, return a timer value in ns
 cl_ulong acl_hal_mmd_get_timestamp() {

src/acl_hal_mmd.cpp

@@ -143,6 +143,7 @@ static const acl_hal_t acl_offline_hal = {
     acl_offline_hal_set_profile_stop_cycle,
     acl_offline_hal_has_svm_memory_support,
     acl_offline_hal_has_physical_mem,
+    NULL,
     acl_offline_hal_get_board_extension_function_address,
     acl_offline_hal_pll_reconfigure,
     acl_offline_hal_reset_kernels,

src/acl_offline_hal.cpp

@@ -143,12 +143,14 @@ CL_API_ENTRY void *CL_API_CALL clHostMemAllocINTEL(
     }
   }
 
+  bool track_mem_id = false;
   if (acl_get_hal()->host_alloc) {
     std::array<mem_properties_t, 3> mmd_properties;
     {
       auto mmd_properties_it = mmd_properties.begin();
       if (mem_id) {
-        if (acl_platform.offline_mode == ACL_CONTEXT_MPSIM) {
+        if (acl_get_hal()->support_buffer_location(devices)) {
+          track_mem_id = true;
           *mmd_properties_it++ = AOCL_MMD_MEM_PROPERTIES_BUFFER_LOCATION;
           *mmd_properties_it++ = *mem_id;
         }
@@ -197,6 +199,10 @@ CL_API_ENTRY void *CL_API_CALL clHostMemAllocINTEL(
     usm_alloc->alloc_flags = alloc_flags;
     usm_alloc->type = CL_MEM_TYPE_HOST_INTEL;
     usm_alloc->alignment = alignment;
+    usm_alloc->host_shared_mem_id = 0; // Initialize to 0
+    if (track_mem_id) {
+      usm_alloc->host_shared_mem_id = *mem_id;
+    }
 
     l_add_usm_alloc_to_context(context, usm_alloc);
     return mem;
@@ -434,12 +440,15 @@ clSharedMemAllocINTEL(cl_context context, cl_device_id device,
     properties += 2;
   }
 
+  bool track_mem_id = false;
   if (acl_get_hal()->shared_alloc) {
     std::array<mem_properties_t, 3> mmd_properties;
     {
       auto mmd_properties_it = mmd_properties.begin();
       if (mem_id) {
-        if (acl_platform.offline_mode == ACL_CONTEXT_MPSIM) {
+        if (acl_get_hal()->support_buffer_location(
+                std::vector<cl_device_id>{device})) {
+          track_mem_id = true;
           *mmd_properties_it++ = AOCL_MMD_MEM_PROPERTIES_BUFFER_LOCATION;
           *mmd_properties_it++ = *mem_id;
         }
@@ -488,6 +497,10 @@ clSharedMemAllocINTEL(cl_context context, cl_device_id device,
     usm_alloc->alloc_flags = alloc_flags;
     usm_alloc->type = CL_MEM_TYPE_SHARED_INTEL;
     usm_alloc->alignment = alignment;
+    usm_alloc->host_shared_mem_id = 0; // Initialize to 0
+    if (track_mem_id) {
+      usm_alloc->host_shared_mem_id = *mem_id;
+    }
 
     l_add_usm_alloc_to_context(context, usm_alloc);
     return mem;
@@ -554,6 +567,7 @@ CL_API_ENTRY cl_int CL_API_CALL clMemFreeINTEL(cl_context context, void *ptr) {
 
   l_remove_usm_alloc_from_context(context, usm_alloc);
   acl_free(usm_alloc);
+  usm_alloc = nullptr;
 
   return CL_SUCCESS;
 }
@@ -617,6 +631,7 @@ CL_API_ENTRY cl_int CL_API_CALL clMemBlockingFreeINTEL(cl_context context,
 
   l_remove_usm_alloc_from_context(context, usm_alloc);
   acl_free(usm_alloc);
+  usm_alloc = nullptr;
 
   return CL_SUCCESS;
 }
@@ -650,7 +665,11 @@ CL_API_ENTRY cl_int CL_API_CALL clGetMemAllocInfoINTEL(
 
   case CL_MEM_ALLOC_BUFFER_LOCATION_INTEL: {
     if (usm_alloc) {
-      RESULT_UINT(usm_alloc->mem->mem_id);
+      if (usm_alloc->mem) {
+        RESULT_UINT(usm_alloc->mem->mem_id);
+      } else {
+        RESULT_UINT(usm_alloc->host_shared_mem_id);
+      }
     } else {
       RESULT_UINT(0);
     }

src/acl_usm.cpp

@@ -30,6 +30,7 @@ static int acl_test_svm_memory_support =
     (CL_DEVICE_SVM_COARSE_GRAIN_BUFFER | CL_DEVICE_SVM_FINE_GRAIN_BUFFER |
      CL_DEVICE_SVM_FINE_GRAIN_SYSTEM);
 static bool acl_test_physical_memory_support = true;
+static bool acl_test_buffer_location_support = true;
 
 // Parts of a valid HAL.
 void acltest_hal_init_device(const acl_system_def_t *def);
@@ -81,6 +82,8 @@ int acltest_hal_set_profile_stop_cycle(unsigned int physical_device_id,
                                        unsigned int accel_id, uint64_t value);
 int acl_test_hal_has_svm_support(unsigned int physical_device_id, int *value);
 int acl_test_hal_has_physical_mem(unsigned int physical_device_id);
+int acl_test_hal_support_buffer_location(
+    const std::vector<cl_device_id> &devices);
 int acl_test_hal_pll_reconfigure(unsigned int physical_device_id,
                                  const char *pll_settings_str);
 void acl_test_hal_reset_kernels(cl_device_id device);
@@ -128,6 +131,7 @@ static const acl_hal_t simple_hal = {acltest_hal_init_device,
                                      acltest_hal_set_profile_stop_cycle,
                                      acl_test_hal_has_svm_support,
                                      acl_test_hal_has_physical_mem,
+                                     acl_test_hal_support_buffer_location,
                                      0,
                                      acl_test_hal_pll_reconfigure,
                                      acl_test_hal_reset_kernels,
@@ -589,6 +593,10 @@ void acl_test_hal_set_physical_memory_support(bool value) {
   acl_test_physical_memory_support = value;
 }
 
+void acl_test_hal_set_buffer_location_support(bool value) {
+  acl_test_buffer_location_support = value;
+}
+
 int acl_test_hal_has_svm_support(unsigned int physical_device_id, int *value) {
   physical_device_id = physical_device_id; // Avoid Windows warning
   *value = acl_test_svm_memory_support;
@@ -600,6 +608,11 @@ int acl_test_hal_has_physical_mem(unsigned int physical_device_id) {
   return acl_test_physical_memory_support;
 }
 
+int acl_test_hal_support_buffer_location(
+    const std::vector<cl_device_id> &devices) {
+  return acl_test_buffer_location_support;
+}
+
 int acl_test_hal_pll_reconfigure(unsigned int physical_device_id,
                                  const char *pll_settings_str) {
   physical_device_id = physical_device_id;

test/acl_hal_test.cpp

@@ -16,6 +16,7 @@ void *acltest_translate_device_address(const void *device_ptr, size_t offset);
 
 void acl_test_hal_set_svm_memory_support(int value);
 void acl_test_hal_set_physical_memory_support(bool value);
+void acl_test_hal_set_buffer_location_support(bool value);
 
 extern bool acltest_hal_emulate_device_mem;