Parse logical to physical host-pipe mappings from auto-discovery string

Author: pcolberg

include/acl.h

@@ -524,6 +524,14 @@ struct acl_device_global_mem_def_t {
   bool reset_on_reuse;
 };
 
+// Mapping of logical to physical host pipes.
+struct acl_hostpipe_mapping {
+  std::string logical_name;
+  std::string physical_name;
+  bool implement_in_csr;
+  uintptr_t csr_address;
+};
+
 // Part of acl_device_def_t where members are populated from the information
 // in the autodiscovery string. This will get updated every time the device
 // is programmed with a new device binary as the new binary would contain a
@@ -548,6 +556,8 @@ typedef struct acl_device_def_autodiscovery_t {
       device_global_mem_defs;
   bool cra_ring_root_exist =
       true; // Set the default value to true for backwards compatibility flows.
+
+  std::vector<acl_hostpipe_mapping> hostpipe_mappings;
 } acl_device_def_autodiscovery_t;
 
 typedef struct acl_device_def_t {

src/acl_auto_configure.cpp

@@ -198,6 +198,36 @@ static bool read_ulonglong_counters(const std::string &str,
   return true;
 }
 
+// Reads the next word in str and converts it into a uintptr_t.
+// Returns true if a valid integer was read or false if an error occurred.
+// pos is updated to the position immediately following the parsed word
+// even if an error occurs.
+static bool read_uintptr_counters(const std::string &str,
+                                  std::string::size_type &pos, uintptr_t &val,
+                                  std::vector<int> &counters) noexcept {
+  std::string result;
+  pos = read_word(str, pos, result);
+  decrement_section_counters(counters);
+
+  size_t end = 0;
+  unsigned long long parsed;
+  try {
+    parsed = std::stoull(result, &end);
+  } catch (const std::exception &) {
+    return false;
+  }
+  if (end != result.size()) {
+    return false;
+  }
+
+  val = static_cast<uintptr_t>(parsed);
+  if (val != parsed) {
+    return false;
+  }
+
+  return true;
+}
+
 // Reads the next word in str and converts it into an unsigned or using its
 // default value. Returns true if a valid integer was read or false if an error
 // occurred. pos is updated to the position immediately following the parsed
@@ -593,6 +623,44 @@ static bool read_streaming_kernel_arg_info(
     result = read_string_counters(config_str, curr_pos,
                                   streaming_arg_info.interface_name, counters);
   }
+  return result;
+}
+
+static bool read_hostpipe_mappings(
+    const std::string &config_str, std::string::size_type &curr_pos,
+    std::vector<acl_hostpipe_mapping> &hostpipe_mappings,
+    std::vector<int> &counters, std::string &err_str) noexcept {
+  unsigned int num_mappings = 0;
+  bool result =
+      read_uint_counters(config_str, curr_pos, num_mappings, counters);
+
+  unsigned int num_fields_per_mapping = 0;
+  if (result) {
+    result = read_uint_counters(config_str, curr_pos, num_fields_per_mapping,
+                                counters);
+  }
+
+  for (unsigned int i = 0; result && (i < num_mappings); i++) {
+    counters.emplace_back(num_fields_per_mapping);
+
+    acl_hostpipe_mapping mapping{};
+    result = read_string_counters(config_str, curr_pos, mapping.logical_name,
+                                  counters) &&
+             read_string_counters(config_str, curr_pos, mapping.physical_name,
+                                  counters) &&
+             read_bool_counters(config_str, curr_pos, mapping.implement_in_csr,
+                                counters) &&
+             read_uintptr_counters(config_str, curr_pos, mapping.csr_address,
+                                   counters);
+    hostpipe_mappings.emplace_back(mapping);
+
+    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;
 }
@@ -1129,6 +1197,11 @@ bool acl_load_device_def_from_str(const std::string &config_str,
   if (result && counters.back() > 0) {
     result = read_bool_counters(config_str, curr_pos,
                                 devdef.cra_ring_root_exist, counters);
+
+  // Read program scoped hostpipes mappings
+  if (result && counters.back() > 0) {
+    result = read_hostpipe_mappings(
+        config_str, curr_pos, devdef.hostpipe_mappings, counters, err_str);
   }
 
   // forward compatibility: bypassing remaining fields at the end of device

test/acl_auto_configure_test.cpp

@@ -1487,3 +1487,63 @@ TEST(auto_configure, cra_ring_root_exist) {
 
   CHECK_EQUAL(1, devdef.cra_ring_root_exist);
 }
+
+// Will finalize later, Zibai todo.
+
+// TEST(auto_configure, hostpipe_mappings) {
+//   const std::string config_str{
+//       "23 45 " RANDOM_HASH
+//       " pac_a10 0 1 13 DDR 2 2 24 1 2 0 4294967296 4294967296 8589934592 0 - 0 "
+//       "0 0 0 0 0 5 4 pipe_logical_name1 pipe_physical_name1 1 12345 "
+//       "pipe_logical_name2 pipe_physical_name2 0 12323 pipe_logical_name3 "
+//       "pipe_physical_name1 1 12313 pipe_logical_name1 pipe_physical_name1 0 "
+//       "12316 pipe_logical_name1 pipe_physical_name3 0 12342 3 90 "
+//       "_ZTS3CRCILi0EE 512 256 1 0 0 1 0 1 0 9 6 0 0 8 1 0 0 6 2 1 8 1024 0 3 6 "
+//       "0 0 8 1 0 0 6 0 0 8 1 0 0 6 0 0 8 1 0 0 6 2 1 8 1024 0 2 6 0 0 8 1 0 0 "
+//       "6 0 0 8 1 0 0 6 0 0 8 1 0 0 0 0 1 2 64 4096 1 1 1 3 1 1 1 3 1 0 64 "
+//       "_ZTS11LZReductionILi0EE 0 256 1 0 0 0 0 1 0 5 6 0 0 8 1 0 0 6 2 1 8 "
+//       "1024 0 3 6 0 0 8 1 0 0 6 0 0 8 1 0 0 6 0 0 8 1 0 0 0 0 2 2 64 131072 65 "
+//       "32768 1 1 1 3 1 1 1 3 1 0 125 _ZTS13StaticHuffmanILi0EE 256 256 1 0 0 1 "
+//       "0 1 0 10 6 0 0 8 1 0 0 6 0 0 4 1 0 0 6 2 1 8 1024 0 2 6 0 0 8 1 0 0 6 0 "
+//       "0 8 1 0 0 6 0 0 8 1 0 0 6 2 1 8 1024 0 2 6 0 0 8 1 0 0 6 0 0 8 1 0 0 6 "
+//       "0 0 8 1 0 0 0 0 15 2 64 116 65 116 66 1152 67 512 68 256 69 120 70 120 "
+//       "71 1152 72 116 73 1152 74 512 75 256 76 120 77 120 78 1152 1 1 1 3 1 1 "
+//       "1 3 1 0"};
+
+//   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(5, devdef.hostpipe_mappings.size());
+
+//   CHECK(devdef.hostpipe_mappings[0].logical_name == "pipe_logical_name1");
+//   CHECK(devdef.hostpipe_mappings[0].physical_name == "pipe_physical_name1");
+//   CHECK(devdef.hostpipe_mappings[0].implement_in_csr);
+//   CHECK(devdef.hostpipe_mappings[0].csr_address == 12345);
+
+//   CHECK(devdef.hostpipe_mappings[1].logical_name == "pipe_logical_name2");
+//   CHECK(devdef.hostpipe_mappings[1].physical_name == "pipe_physical_name2");
+//   CHECK(!devdef.hostpipe_mappings[1].implement_in_csr);
+//   CHECK(devdef.hostpipe_mappings[1].csr_address == 12323);
+
+//   CHECK(devdef.hostpipe_mappings[2].logical_name == "pipe_logical_name3");
+//   CHECK(devdef.hostpipe_mappings[2].physical_name == "pipe_physical_name1");
+//   CHECK(devdef.hostpipe_mappings[2].implement_in_csr);
+//   CHECK(devdef.hostpipe_mappings[2].csr_address == 12313);
+
+//   CHECK(devdef.hostpipe_mappings[3].logical_name == "pipe_logical_name1");
+//   CHECK(devdef.hostpipe_mappings[3].physical_name == "pipe_physical_name1");
+//   CHECK(!devdef.hostpipe_mappings[3].implement_in_csr);
+//   CHECK(devdef.hostpipe_mappings[3].csr_address == 12316);
+
+//   CHECK(devdef.hostpipe_mappings[4].logical_name == "pipe_logical_name1");
+//   CHECK(devdef.hostpipe_mappings[4].physical_name == "pipe_physical_name3");
+//   CHECK(!devdef.hostpipe_mappings[4].implement_in_csr);
+//   CHECK(devdef.hostpipe_mappings[4].csr_address == 12342);
+// }