kernel_if: pass streaming control signal names to simulator

For the case of streaming control kernels in IP authoring, when passing
the start and done signals to the simulator MMD, instead of the kernel
interface name, pass the full signal names from the auto-discovery
string. Before this change, the runtime would pass the kernel name,
e.g., `_ZTSZ4mainE4MyIP` without the prefix including the kernel index
in case of multiple kernels. After this change, the runtime passes the
full signal names, e.g., `k0_ZTSZ4mainE4MyIP_streaming_start` including
the kernel index prefix and the streaming control signal suffix.

This amends #103

Signed-off-by: Peter Colberg <peter.colberg@intel.com>

Author: pcolberg

include/acl_hal.h

@@ -241,9 +241,9 @@ typedef struct {
                         mem_properties_t *properties, int *error);
 
   void (*simulation_streaming_kernel_start)(unsigned int physical_device_id,
-                                            const std::string &kernel_name);
+                                            const std::string &signal_name);
   void (*simulation_streaming_kernel_done)(unsigned int physical_device_id,
-                                           const std::string &kernel_name,
+                                           const std::string &signal_name,
                                            unsigned int &finish_counter);
 } acl_hal_t;
 

include/acl_hal_mmd.h

@@ -139,7 +139,7 @@ typedef struct {
 
   // Submits streaming kernel control start signal to simulator.
   void (*aocl_mmd_simulation_streaming_kernel_start)(
-      int handle, const std::string &kernel_name);
+      int handle, const std::string &signal_name);
 
   // Queries streaming kernel control done signal from simulator.
   // Returns non-negative number of finished kernels invocations.
@@ -148,7 +148,7 @@ typedef struct {
   // invocations that finish *while* this function is invoked are properly
   // accounted and returned in a subsequent invocation of this function.
   void (*aocl_mmd_simulation_streaming_kernel_done)(
-      int handle, const std::string &kernel_name, unsigned int &finish_counter);
+      int handle, const std::string &signal_name, unsigned int &finish_counter);
 } acl_mmd_dispatch_t;
 
 typedef struct {

include/acl_kernel_if.h

@@ -39,7 +39,8 @@ typedef struct {
   acl_kernel_if_addr_range *accel_perf_mon;
   unsigned int *accel_num_printfs;
 
-  std::vector<std::optional<std::string>> streaming_control_kernel_names;
+  std::vector<std::optional<acl_streaming_kernel_control_info>>
+      streaming_control_signal_names;
 
   // Track potential hangs
   time_ns last_kern_update;

src/acl_kernel_if.cpp

@@ -949,14 +949,14 @@ int acl_kernel_if_update(const acl_device_def_autodiscovery_t &devdef,
       }
     }
 
-    kern->streaming_control_kernel_names.clear();
-    kern->streaming_control_kernel_names.reserve(devdef.accel.size());
+    kern->streaming_control_signal_names.clear();
+    kern->streaming_control_signal_names.reserve(devdef.accel.size());
     for (const auto &accel : devdef.accel) {
-      std::optional<std::string> kernel_name;
+      std::optional<acl_streaming_kernel_control_info> signal_names;
       if (accel.streaming_control_info_available) {
-        kernel_name = accel.iface.name;
+        signal_names = accel.streaming_control_info;
       }
-      kern->streaming_control_kernel_names.emplace_back(kernel_name);
+      kern->streaming_control_signal_names.emplace_back(signal_names);
     }
   }
 
@@ -1266,10 +1266,10 @@ void acl_kernel_if_launch_kernel_on_custom_sof(
   }
   kern->accel_queue_front[accel_id] = next_launch_index;
 
-  if (kern->streaming_control_kernel_names[accel_id]) {
+  if (kern->streaming_control_signal_names[accel_id]) {
     acl_get_hal()->simulation_streaming_kernel_start(
         kern->physical_device_id,
-        *kern->streaming_control_kernel_names[accel_id]);
+        kern->streaming_control_signal_names[accel_id]->start);
     return;
   }
 
@@ -1510,10 +1510,10 @@ void acl_kernel_if_update_status(acl_kernel_if *kern) {
     unsigned int finish_counter = 0;
     unsigned int printf_size = 0;
 
-    if (kern->streaming_control_kernel_names[accel_id]) {
+    if (kern->streaming_control_signal_names[accel_id]) {
       acl_get_hal()->simulation_streaming_kernel_done(
           kern->physical_device_id,
-          *kern->streaming_control_kernel_names[accel_id], finish_counter);
+          kern->streaming_control_signal_names[accel_id]->done, finish_counter);
     } else {
       acl_kernel_if_update_status_query(kern, accel_id, activation_id,
                                         finish_counter, printf_size);
@@ -1531,7 +1531,7 @@ void acl_kernel_if_update_status(acl_kernel_if *kern) {
       // Tell the host library this job is done
       kern->accel_job_ids[accel_id][next_queue_back] = -1;
 
-      if (!kern->streaming_control_kernel_names[accel_id]) {
+      if (!kern->streaming_control_signal_names[accel_id]) {
         acl_kernel_if_update_status_finish(kern, accel_id, activation_id,
                                            printf_size);
       }