ran: add CSI Part 2 size calculator

ran: review UCI part 2 related

ran: add missing new line

apply clang-format

Author: xavierarteaga

include/srsran/ran/csi_report/csi_report_configuration.h

@@ -79,13 +79,10 @@ inline const char* to_string(csi_report_quantities quantities)
   switch (quantities) {
     case srsran::csi_report_quantities::cri_ri_pmi_cqi:
       return "cri-ri-pmi-cqi";
-      break;
     case srsran::csi_report_quantities::cri_ri_cqi:
       return "cri-ri-cqi";
-      break;
     case srsran::csi_report_quantities::cri_ri_li_pmi_cqi:
       return "cri-ri-li-pmi-cqi";
-      break;
     case srsran::csi_report_quantities::other:
     default:
       return "other";

include/srsran/ran/uci/uci_part2_size_calculator.h

@@ -0,0 +1,23 @@
+/*
+ *
+ * Copyright 2013-2022 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#pragma once
+#include "srsran/adt/span.h"
+#include "srsran/ran/uci/uci_part2_size_description.h"
+
+namespace srsran {
+
+/// \brief Calculates the UCI part 2 from UCI part 1.
+/// \param[in] part1 UCI part 1 decoded data.
+/// \param[in] descr UCI part 1 parameters correspondence to UCI part 2 size.
+/// \return The size of UCI part 2 payload.
+unsigned uci_part2_get_size(span<const uint8_t> part1, const uci_part2_size_description& descr);
+
+} // namespace srsran

include/srsran/ran/uci/uci_part2_size_description.h

@@ -0,0 +1,48 @@
+/*
+ *
+ * Copyright 2013-2022 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#pragma once
+#include "srsran/adt/static_vector.h"
+
+namespace srsran {
+
+/// Collects the parameters that describe the UCI Part 1 correspondence to Part 2 sizes.
+struct uci_part2_size_description {
+  /// Maximum number of parameters.
+  static constexpr unsigned max_nof_parameters = 2;
+  /// Maximum number of Part 2 entries.
+  static constexpr unsigned max_nof_entries = 2;
+  /// Maximum number of aggregated bits per entry.
+  static constexpr unsigned max_nof_entry_bits = 4;
+  /// Maximum number of Part 2 sizes per entry.
+  static constexpr unsigned max_size_table = 1U << max_nof_entry_bits;
+
+  /// Collects parameter attributes.
+  struct parameter {
+    /// Bit offset of the parameter from the beginning of the Part 1.
+    uint16_t offset;
+    /// CSI Part 1 parameter bit width.
+    uint8_t width;
+  };
+
+  /// Collects the parameters to determine a single CSI Part 2 report.
+  struct entry {
+    /// \brief Part 1 parameters that influence the size of this part 2.
+    /// \remark The total accumulated width of the parameters must not exceed \ref max_nof_entry_bits bits.
+    static_vector<parameter, max_nof_parameters> parameters;
+    /// \brief Maps the concatenation of the parameters to Part 2 size.
+    static_vector<uint16_t, max_size_table> map;
+  };
+
+  /// CSI Part 2 entries.
+  static_vector<entry, max_nof_entries> entries;
+};
+
+} // namespace srsran

include/srsran/srsvec/bit.h

@@ -53,6 +53,16 @@ void bit_unpack(span<uint8_t> unpacked, const bit_buffer& packed);
 /// \remark After execution, \c bits will contain only the unused bits.
 unsigned bit_pack(span<const uint8_t>& bits, unsigned nof_bits);
 
+/// \brief Packs the input bits into an integer value.
+///
+/// The first bit in the sequence corresponds to the bit of index <tt> bits.size() - 1 </tt> of the returned value. The
+/// last value in the sequence corresponds to LSB of the returned value.
+///
+/// \param[in] bits View of unpacked bits.
+/// \return An integer containing the packed bits.
+/// \remark The number of elements must not exceed 32 bits.
+unsigned bit_pack(span<const uint8_t> bits);
+
 /// \brief Packs a number of bits into bytes.
 /// \param[out] packed View of packed bits.
 /// \param[in] unpacked View of unpacked bits.

lib/ran/CMakeLists.txt

@@ -7,9 +7,9 @@
 #
 
 add_library(srsran_ran
+        csi_report/csi_report_config_helpers.cpp
         csi_report/csi_report_unpacking.cpp
         csi_report/csi_report_unpacking_helpers.cpp
-        csi_report/csi_report_config_helpers.cpp
         csi_rs/csi_rs_pattern.cpp
         csi_rs/csi_rs_config_helpers.cpp
         csi_rs/frequency_allocation_type.cpp
@@ -30,6 +30,7 @@ add_library(srsran_ran
         pusch/pusch_mcs.cpp
         pusch/pusch_uci_beta_offset.cpp
         pusch/ulsch_info.cpp
+        uci/uci_part2_size_calculator.cpp
         band_helper.cpp
         resource_allocation/resource_allocation_frequency.cpp
         sch/sch_segmentation.cpp

lib/ran/csi_report/csi_report_wideband_cqi.cpp

@@ -0,0 +1,51 @@
+/*
+ *
+ * Copyright 2021-2023 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#include "srsran/ran/uci/uci_part2_size_calculator.h"
+#include "srsran/srsvec/bit.h"
+
+using namespace srsran;
+
+unsigned srsran::uci_part2_get_size(span<const uint8_t> part1, const uci_part2_size_description& descr)
+{
+  unsigned result = 0;
+
+  // Iterate all entries.
+  for (const uci_part2_size_description::entry& entry : descr.entries) {
+    unsigned index          = 0;
+    unsigned index_bitwidth = 0;
+
+    for (const uci_part2_size_description::parameter& parameter : entry.parameters) {
+      // Extract the value of the parameter.
+      unsigned value = srsvec::bit_pack(part1.subspan(parameter.offset, parameter.width));
+
+      // Combine the parameter value with the current index.
+      index = (index << parameter.width) | value;
+
+      // Accumulate the index bit width.
+      index_bitwidth += parameter.width;
+    }
+
+    // Verify the map size is according to the index bit width.
+    srsran_assert(entry.map.size() == (1U << index_bitwidth),
+                  "Invalid map size (i.e., {}), expected {} entries.",
+                  entry.map.size(),
+                  (1U << index_bitwidth));
+
+    // Verify that the index is within the map size.
+    srsran_assert(
+        index < entry.map.size(), "Index value (i.e., {}) exceeds the map size (i.e., {}).", index, entry.map.size());
+
+    // Add the Part 2 size corresponding to this entry.
+    result += entry.map[index];
+  }
+
+  return result;
+}

lib/ran/uci/uci_part2_size_calculator.cpp

@@ -205,6 +205,19 @@ unsigned srsran::srsvec::bit_pack(span<const uint8_t>& bits, unsigned nof_bits)
   return value;
 }
 
+unsigned srsran::srsvec::bit_pack(span<const uint8_t> bits)
+{
+  srsran_assert(bits.size() <= 32U, "Number of bits ({}) exceeds maximum (32).", bits.size());
+
+  unsigned value = 0;
+
+  for (unsigned i = 0, nof_bits = bits.size(); i != nof_bits; i++) {
+    value |= (unsigned)bits[i] << (nof_bits - i - 1U);
+  }
+
+  return value;
+}
+
 void srsran::srsvec::bit_pack(span<uint8_t> packed, span<const uint8_t> unpacked)
 {
   srsran_assert(divide_ceil(unpacked.size(), 8) == packed.size(), "Inconsistent input sizes.");

lib/srsvec/bit.cpp

@@ -69,6 +69,10 @@ add_executable(resource_allocation_frequency_test resource_allocation/resource_a
 target_link_libraries(resource_allocation_frequency_test srsran_support srsran_ran)
 add_test(resource_allocation_frequency_test resource_allocation_frequency_test)
 
+add_executable(uci_part2_size_calculator_test uci/uci_part2_size_calculator_test.cpp)
+target_link_libraries(uci_part2_size_calculator_test srsran_support srsran_ran srsvec gtest gtest_main)
+add_test(uci_part2_size_calculator_test uci_part2_size_calculator_test)
+
 add_executable(slot_point_test slot_point_test.cpp)
 target_link_libraries(slot_point_test srsran_support)
 add_test(slot_point_test slot_point_test)