Parse streaming kernel information from auto-discovery string

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

Author: pcolberg

include/acl.h

@@ -6,6 +6,7 @@
 
 #include <array>
 #include <assert.h>
+#include <optional>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -136,6 +137,11 @@ typedef enum {
 } acl_kernel_arg_access_qualifier_t; // this is defaulted to none, for non-pipe
                                      // and non-image args.
 
+struct acl_streaming_kernel_arg_info {
+  // name of the streaming interface at device image boundary
+  std::string interface_name;
+};
+
 // This defines everything "interface" of a kernel argument.
 // Be sure to keep this consistent with l_kernel_interface_match() in
 // acl_kernel.cpp. This struct must remain trivially copyable.
@@ -170,6 +176,8 @@ typedef struct {
   // allowed, e.g., "struct mystruct"
   std::string type_name;
   std::string name;
+
+  std::optional<acl_streaming_kernel_arg_info> streaming_info;
 } acl_kernel_arg_info_t;
 
 // This struct must remain trivially copyable.
@@ -191,6 +199,13 @@ typedef struct {
   std::string format_string;
 } acl_printf_info_t;
 
+struct acl_streaming_kernel_info {
+  std::string start;
+  std::string done;
+  std::string stall_in;
+  std::string stall_out;
+};
+
 /* The definition of a single accelerator.
  * It can run a single kernel type.
  * We assume binary compilation only.
@@ -231,6 +246,8 @@ typedef struct {
       fast_launch_depth; /* How many kernels can be buffered on the device, 0
                             means no buffering just one can execute*/
   unsigned int is_sycl_compile; /* [1] SYCL compile; [0] OpenCL compile*/
+
+  std::optional<acl_streaming_kernel_info> streaming_info;
 } acl_accel_def_t;
 
 /* An ACL system definition.

src/acl_auto_configure.cpp

@@ -504,6 +504,30 @@ static bool read_device_global_mem_defs(
   return result;
 }
 
+static bool read_streaming_kernel_arg_info(
+    const std::string &config_str, std::string::size_type &curr_pos,
+    std::optional<acl_streaming_kernel_arg_info> &streaming_info,
+    std::vector<int> &counters) noexcept {
+  int num_fields = 0;
+  bool result = read_int_counters(config_str, curr_pos, num_fields, counters);
+  counters.emplace_back(num_fields);
+
+  if (result && counters.back() > 0) {
+    streaming_info = std::make_optional(acl_streaming_kernel_arg_info{});
+    result = read_string_counters(config_str, curr_pos,
+                                  streaming_info->interface_name, counters);
+  }
+
+  while (result && counters.back() > 0) {
+    std::string tmp;
+    result = read_string_counters(config_str, curr_pos, tmp, counters);
+  }
+  check_section_counters(counters);
+  counters.pop_back();
+
+  return result;
+}
+
 static bool read_kernel_args(const std::string &config_str,
                              const bool kernel_arg_info_available,
                              std::string::size_type &curr_pos,
@@ -597,6 +621,12 @@ static bool read_kernel_args(const std::string &config_str,
         type_name = "";
     }
 
+    std::optional<acl_streaming_kernel_arg_info> streaming_info;
+    if (result && counters.back() > 0) {
+      result = read_streaming_kernel_arg_info(config_str, curr_pos,
+                                              streaming_info, counters);
+    }
+
     /*****************************************************************
       Since the introduction of autodiscovery forwards-compatibility,
       new entries for each kernel argument section start here.
@@ -619,6 +649,7 @@ static bool read_kernel_args(const std::string &config_str,
       args[j].host_accessible = host_accessible;
       args[j].pipe_channel_id = pipe_channel_id;
       args[j].buffer_location = buffer_location;
+      args[j].streaming_info = streaming_info;
     }
     // forward compatibility: bypassing remaining fields at the end of
     // arguments section
@@ -635,6 +666,36 @@ static bool read_kernel_args(const std::string &config_str,
   return result;
 }
 
+static bool read_streaming_kernel_info(
+    const std::string &config_str, std::string::size_type &curr_pos,
+    std::optional<acl_streaming_kernel_info> &streaming_info,
+    std::vector<int> &counters) noexcept {
+  int num_fields = 0;
+  bool result = read_int_counters(config_str, curr_pos, num_fields, counters);
+  counters.emplace_back(num_fields);
+
+  if (result && counters.back() > 0) {
+    streaming_info = std::make_optional(acl_streaming_kernel_info{});
+    result = read_string_counters(config_str, curr_pos, streaming_info->start,
+                                  counters) &&
+             read_string_counters(config_str, curr_pos, streaming_info->done,
+                                  counters) &&
+             read_string_counters(config_str, curr_pos,
+                                  streaming_info->stall_in, counters) &&
+             read_string_counters(config_str, curr_pos,
+                                  streaming_info->stall_out, counters);
+  }
+
+  while (result && counters.back() > 0) {
+    std::string tmp;
+    result = read_string_counters(config_str, curr_pos, tmp, counters);
+  }
+  check_section_counters(counters);
+  counters.pop_back();
+
+  return result;
+}
+
 static bool read_accel_defs(const std::string &config_str,
                             std::string::size_type &curr_pos,
                             const bool kernel_arg_info_available,
@@ -872,6 +933,11 @@ static bool read_accel_defs(const std::string &config_str,
                                   accel[i].is_sycl_compile, counters);
     }
 
+    if (result && counters.back() > 0) {
+      result = read_streaming_kernel_info(config_str, curr_pos,
+                                          accel[i].streaming_info, counters);
+    }
+
     // forward compatibility: bypassing remaining fields at the end of kernel
     // description section
     while (result && counters.size() > 0 &&

test/acl_auto_configure_test.cpp

@@ -1227,3 +1227,57 @@ TEST(auto_configure, hostpipe) {
     CHECK_EQUAL(1, (int)device_def.autodiscovery_def.hal_info.size());
   }
 }
+
+TEST(auto_configure, streaming) {
+  const std::string config_str{
+      "23 26 " RANDOM_HASH
+      " pac_a10 0 1 13 DDR 2 2 24 1 2 0 4294967296 4294967296 8589934592 0 - 0 "
+      "0 0 0 1 3 device_global_name 256 128 1 107 _ZTS3CRCILi0EE 0 256 1 0 0 1 "
+      "0 1 0 9 8 0 0 8 1 0 0 1 k0_ZTS3CRCILi0EE_arg0 8 2 1 8 1024 0 3 1 "
+      "k0_ZTS3CRCILi0EE_arg1 8 0 0 8 1 0 0 1 k0_ZTS3CRCILi0EE_arg2 7 0 0 8 1 0 "
+      "0 0 7 0 0 8 1 0 0 0 7 2 1 8 1024 0 2 0 7 0 0 8 1 0 0 0 7 0 0 8 1 0 0 0 "
+      "7 0 0 8 1 0 0 0 0 0 1 2 64 4096 1 1 1 3 1 1 1 3 1 0 4 "
+      "k0_ZTS3CRCILi0EE_streaming_start k0_ZTS3CRCILi0EE_streaming_done "
+      "k0_ZTS3CRCILi0EE_streaming_stall_in "
+      "k0_ZTS3CRCILi0EE_streaming_stall_out"};
+
+  acl_device_def_autodiscovery_t devdef;
+  {
+    bool result;
+    std::string err_str;
+    ACL_LOCKED(result =
+                   acl_load_device_def_from_str(config_str, devdef, err_str));
+    std::cerr << err_str;
+    CHECK(result);
+  }
+
+  CHECK_EQUAL(1, devdef.accel.size());
+
+  CHECK(!!devdef.accel[0].streaming_info);
+  CHECK("k0_ZTS3CRCILi0EE_streaming_start" ==
+        devdef.accel[0].streaming_info->start);
+  CHECK("k0_ZTS3CRCILi0EE_streaming_done" ==
+        devdef.accel[0].streaming_info->done);
+  CHECK("k0_ZTS3CRCILi0EE_streaming_stall_in" ==
+        devdef.accel[0].streaming_info->stall_in);
+  CHECK("k0_ZTS3CRCILi0EE_streaming_stall_out" ==
+        devdef.accel[0].streaming_info->stall_out);
+
+  CHECK_EQUAL(9, devdef.accel[0].iface.args.size());
+
+  CHECK(!!devdef.accel[0].iface.args[0].streaming_info);
+  CHECK("k0_ZTS3CRCILi0EE_arg0" ==
+        devdef.accel[0].iface.args[0].streaming_info->interface_name);
+
+  CHECK(!!devdef.accel[0].iface.args[1].streaming_info);
+  CHECK("k0_ZTS3CRCILi0EE_arg1" ==
+        devdef.accel[0].iface.args[1].streaming_info->interface_name);
+
+  CHECK(!!devdef.accel[0].iface.args[2].streaming_info);
+  CHECK("k0_ZTS3CRCILi0EE_arg2" ==
+        devdef.accel[0].iface.args[2].streaming_info->interface_name);
+
+  for (size_t i = 3; i < 9; ++i) {
+    CHECK(!devdef.accel[0].iface.args[i].streaming_info);
+  }
+}