Update main

# Conflicts:
#	lib/ran/csi_report/csi_report_wideband_cqi.cpp

Author: codebot

CMakeLists.txt

@@ -281,33 +281,23 @@ if (AUTO_DETECT_ISA)
 
     if (HAVE_AVX2)
         add_definitions(-DHAVE_AVX2)
-        if (NOT HAVE_MARCH)
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx2")
-        endif(NOT HAVE_MARCH)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx2")
     endif (HAVE_AVX2)
     if (HAVE_AVX)
         add_definitions(-DHAVE_AVX)
-        if (NOT HAVE_MARCH)
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
-        endif(NOT HAVE_MARCH)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx")
     endif (HAVE_AVX)
     if (HAVE_SSE)
         add_definitions(-DHAVE_SSE)
-        if (NOT HAVE_MARCH)
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.2")
-        endif(NOT HAVE_MARCH)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.1")
     endif (HAVE_SSE)
     if (HAVE_FMA)
         add_definitions(-DHAVE_FMA)
-        if (NOT HAVE_MARCH)
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfma")
-        endif(NOT HAVE_MARCH)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfma")
     endif (HAVE_FMA)
     if (HAVE_AVX512)
         add_definitions(-DHAVE_AVX512)
-        if (NOT HAVE_MARCH)
-            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx512f -mavx512cd -mavx512bw -mavx512dq")
-        endif(NOT HAVE_MARCH)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mavx512f -mavx512cd -mavx512bw -mavx512dq")
     endif (HAVE_AVX512)
 else (AUTO_DETECT_ISA)
     unset(HAVE_SSE CACHE)

apps/gnb/gnb_worker_manager.h

@@ -41,7 +41,7 @@ class affinity_mask_manager
 public:
   /// Creates the tuned affinity mask manager with the given number of threads per core, reserves given amount of CPU
   /// cores for non priority tasks.
-  explicit affinity_mask_manager(unsigned nof_threads_per_core_ = 2U, unsigned nof_cores_for_non_prio_threads_ = 4U) :
+  explicit affinity_mask_manager(unsigned nof_threads_per_core_, unsigned nof_cores_for_non_prio_threads_) :
     nof_threads_per_core(nof_threads_per_core_),
     nof_cores_for_non_prio_threads(nof_cores_for_non_prio_threads_),
     cpu_bitset(compute_host_nof_hardware_threads())
@@ -56,6 +56,15 @@ class affinity_mask_manager
     cpu_bitset.fill(0, nof_cores_for_non_prio_threads, true);
   }
 
+  /// Default constructor.
+  affinity_mask_manager() :
+    nof_threads_per_core(2U),
+    nof_cores_for_non_prio_threads(compute_host_nof_hardware_threads() / 2),
+    cpu_bitset(compute_host_nof_hardware_threads())
+  {
+    cpu_bitset.fill(0, nof_cores_for_non_prio_threads, true);
+  }
+
   /// \brief Returns an affinity mask with assigned CPU indexes.
   ///
   /// \param name Name of the task trying to reserve a CPU core.

include/srsran/phy/upper/channel_processors/ulsch_demultiplex.h

@@ -31,9 +31,16 @@
 
 namespace srsran {
 
-/// \brief Uplink Shared Channel demultiplexer interface.
+/// \brief User interface of the Uplink Shared Channel (UL-SCH) demultiplexer.
 ///
-/// User interface of the Uplink Shared Channel (UL-SCH) demultiplexer.
+/// Note that, for calculating the CSI Part 2 report size, it is necessary to decode the CSI Part 1. Consequently, the
+/// CSI Part 1 report soft bits can be demultiplexed with a dedicated method (see \ref
+/// ulsch_demultiplex::demultiplex_csi_part1). After decoding the CSI Part 1 report, all the remaining UL-SCH fields can
+/// be demultiplexed at once (see \ref ulsch_demultiplex::demultiplex_sch_harq_ack_and_csi_part2).
+
+///
+/// All fields can be demultiplexed simultaneously if CSI Part 2 is not present (see \ref
+/// ulsch_demultiplex::demultiplex).
 class ulsch_demultiplex
 {
 public:
@@ -78,14 +85,41 @@ class ulsch_demultiplex
   /// Default destructor.
   virtual ~ulsch_demultiplex() = default;
 
+  /// \brief Demultiplexes the CSI Part 1 report from the UL-SCH transmission.
+  /// \param[out] csi_part1             CSI Part 1 report soft bits.
+  /// \param[in]  input                 Input soft bits to demultiplex.
+  /// \param[in]  nof_enc_harq_ack_bits Number of HARQ-ACK information bits multiplexed in the PUSCH message. Parameter
+  ///                                   \f$O_\textup{HARQ-ACK}\f$.
+  /// \param[in]  config                UL-SCH demultiplexing parameters.
+  virtual void demultiplex_csi_part1(span<log_likelihood_ratio>       csi_part1,
+                                     span<const log_likelihood_ratio> input,
+                                     unsigned                         nof_enc_harq_ack_bits,
+                                     const configuration&             config) = 0;
+
+  /// \brief Demultiplexes the Shared Channel (SCH) data, the HARQ-ACK information bits and the CSI Part 2 report from
+  ///        the UL-SCH transmission.
+  /// \param[out] sch_data               Shared channel data soft bits.
+  /// \param[out] harq_ack               HARQ-ACK information soft bits.
+  /// \param[out] csi_part2              CSI Part 2 report soft bits.
+  /// \param[in]  input                  Input soft bits to demultiplex.
+  /// \param[in]  nof_enc_csi_part1_bits Number of HARQ-ACK information bits multiplexed in the PUSCH message. Parameter
+  ///                                    \f$O_\textup{CSI-1}\f$.
+  /// \param[in]  config                 UL-SCH demultiplexing parameters.
+  virtual void demultiplex_sch_harq_ack_and_csi_part2(span<log_likelihood_ratio>       sch_data,
+                                                      span<log_likelihood_ratio>       harq_ack,
+                                                      span<log_likelihood_ratio>       csi_part2,
+                                                      span<const log_likelihood_ratio> input,
+                                                      unsigned                         nof_enc_csi_part1_bits,
+                                                      const configuration&             config) = 0;
+
   /// \brief Demultiplexes Uplink Shared Channel (UL-SCH).
   ///
   /// Demultiplexes the different information fields from the UL-SCH transmission.
   ///
-  /// \param[out] sch_data   Destination of the resultant shared channel data soft bits.
-  /// \param[out] harq_ack   Destination of HARQ-ACK information soft bits.
-  /// \param[out] csi_part1  Destination CSI Part 1 report soft bits.
-  /// \param[out] csi_part2  Destination CSI Part 2 report soft bits.
+  /// \param[out] sch_data   Shared channel data soft bits.
+  /// \param[out] harq_ack   HARQ-ACK information soft bits.
+  /// \param[out] csi_part1  CSI Part 1 report soft bits.
+  /// \param[out] csi_part2  CSI Part 2 report soft bits.
   /// \param[in] input       Input soft bits to demultiplex.
   /// \param[in] config      UL-SCH demultiplexing parameters.
   virtual void demultiplex(span<log_likelihood_ratio>       sch_data,

include/srsran/ran/csi_report/csi_report_configuration.h

@@ -91,13 +91,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,35 @@
+/*
+ *
+ * Copyright 2021-2023 Software Radio Systems Limited
+ *
+ * This file is part of srsRAN.
+ *
+ * srsRAN is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * srsRAN is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * A copy of the GNU Affero General Public License can be found in
+ * the LICENSE file in the top-level directory of this distribution
+ * and at http://www.gnu.org/licenses/.
+ *
+ */
+
+#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,60 @@
+/*
+ *
+ * Copyright 2021-2023 Software Radio Systems Limited
+ *
+ * This file is part of srsRAN.
+ *
+ * srsRAN is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of
+ * the License, or (at your option) any later version.
+ *
+ * srsRAN is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * A copy of the GNU Affero General Public License can be found in
+ * the LICENSE file in the top-level directory of this distribution
+ * and at http://www.gnu.org/licenses/.
+ *
+ */
+
+#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

@@ -65,6 +65,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/phy/upper/channel_processors/pusch_processor_impl.cpp

@@ -246,24 +246,23 @@ void pusch_processor_impl::process(span<uint8_t>                    data,
 
   // Prepare buffers.
   span<log_likelihood_ratio> sch_llr = span<log_likelihood_ratio>(temp_sch_llr).first(info.nof_ul_sch_bits.value());
-  span<log_likelihood_ratio> harq_ack_llr =
-      span<log_likelihood_ratio>(temp_harq_ack_llr).first(info.nof_harq_ack_bits.value());
-  span<log_likelihood_ratio> csi_part1_llr =
-      span<log_likelihood_ratio>(temp_csi_part1_llr).first(info.nof_csi_part1_bits.value());
-  span<log_likelihood_ratio> csi_part2_llr =
-      span<log_likelihood_ratio>(temp_csi_part2_llr).first(info.nof_csi_part2_bits.value());
-
-  // Demultiplex UL-SCH if any of UCI field is present.
-  if ((pdu.uci.nof_harq_ack > 0) || (pdu.uci.nof_csi_part1 > 0) || (pdu.uci.nof_csi_part2 > 0)) {
-    // Demultiplexes UL-SCH codeword.
-    demultiplex->demultiplex(sch_llr, harq_ack_llr, csi_part1_llr, csi_part2_llr, codeword_llr, demux_config);
-  } else {
-    // Overwrite the view of the codeword.
-    sch_llr = codeword_llr;
-  }
 
-  // Process UCI.
-  if (pdu.uci.nof_harq_ack || pdu.uci.nof_csi_part1 || pdu.uci.nof_csi_part2) {
+  // Process UCI if HARQ-ACK or CSI reports are present.
+  if ((pdu.uci.nof_harq_ack > 0) || (pdu.uci.nof_csi_part1 > 0)) {
+    span<log_likelihood_ratio> harq_ack_llr =
+        span<log_likelihood_ratio>(temp_harq_ack_llr).first(info.nof_harq_ack_bits.value());
+    span<log_likelihood_ratio> csi_part1_llr =
+        span<log_likelihood_ratio>(temp_csi_part1_llr).first(info.nof_csi_part1_bits.value());
+
+    // Depending on CSI Part 2 report.
+    if (pdu.uci.nof_csi_part2 > 0) {
+      // Demultiplex HARQ-ACK and CSI Part 1.
+      demultiplex->demultiplex_csi_part1(csi_part1_llr, codeword_llr, info.nof_harq_ack_bits.value(), demux_config);
+    } else {
+      // Demultiplex SCH data, HARQ-ACK and CSI Part 1.
+      demultiplex->demultiplex(sch_llr, harq_ack_llr, csi_part1_llr, {}, codeword_llr, demux_config);
+    }
+
     // Prepare UCI decoder configuration.
     uci_decoder::configuration uci_dec_config;
     uci_dec_config.modulation = pdu.mcs_descr.modulation;
@@ -278,11 +277,35 @@ void pusch_processor_impl::process(span<uint8_t>                    data,
     // Decode CSI Part 1.
     result_uci.csi_part1 = decode_uci_field(csi_part1_llr, pdu.uci.nof_csi_part1, uci_dec_config);
 
-    // Decode HARQ-ACK.
-    result_uci.csi_part2 = decode_uci_field(csi_part2_llr, pdu.uci.nof_csi_part2, uci_dec_config);
+    // If CSI Part 2 is enabled.
+    if (pdu.uci.nof_csi_part2 > 0) {
+      // Calculate the number of CSI Part 2 payload bits.
+      unsigned nof_csi_part2 = pdu.uci.nof_csi_part2;
+
+      // Calculate the number of CSI Part 2 encoded bits.
+      unsigned nof_enc_csi_part2 = info.nof_csi_part2_bits.value();
+
+      // Prepare view of CSI Part 2 report LLRs.
+      span<log_likelihood_ratio> csi_part2_llr =
+          span<log_likelihood_ratio>(temp_csi_part2_llr).first(nof_enc_csi_part2);
+
+      // Demultiplex SCH data and CSI Part 2 bits.
+      demultiplex->demultiplex_sch_harq_ack_and_csi_part2(
+          sch_llr, harq_ack_llr, csi_part2_llr, codeword_llr, csi_part1_llr.size(), demux_config);
+
+      // Decode CSI Part 2.
+      result_uci.csi_part2 = decode_uci_field(csi_part2_llr, nof_csi_part2, uci_dec_config);
+    } else {
+      // Otherwise, clear CSI Part 2 result.
+      result_uci.csi_part2.status = uci_status::unknown;
+      result_uci.csi_part2.payload.clear();
+    }
 
     // Report UCI if at least one field is present.
     notifier.on_uci(result_uci);
+  } else {
+    // Overwrite the view of the codeword to avoid copying SCH data.
+    sch_llr = codeword_llr;
   }
 
   // Decode codeword if present.