sched: computation of PUCCH multiplexing regions

Author: jonathan-srs

lib/scheduler/pucch_scheduling/pucch_collision_manager.cpp

@@ -15,6 +15,7 @@
 #include "srsran/ran/pucch/pucch_mapping.h"
 #include "srsran/ran/resource_allocation/ofdm_symbol_range.h"
 #include "srsran/ran/resource_allocation/rb_interval.h"
+#include <algorithm>
 
 using namespace srsran;
 
@@ -133,8 +134,44 @@ struct resource_info {
   }
 };
 
+/// \brief Represents a multiplexing region of PUCCH resources.
+/// Contains parameters that all resources in the region have in common.
+struct mux_region {
+  /// Time-frequency grants of the region.
+  time_freq_grants grants;
+  /// PUCCH format of the region.
+  pucch_format format;
+
+  /// Check if a a given resource belongs to this multiplexing region.
+  bool does_resource_belong(const resource_info& res) const { return res.format == format and res.grants == grants; }
+};
+
 } // namespace
 
+/// Collects all PUCCH resources (common + dedicated) from the cell configuration.
+static static_vector<resource_info, pucch_collision_manager::max_nof_cell_resources>
+get_all_resources(const cell_configuration& cell_cfg)
+{
+  // Get the parameter N_bwp_size, which is the Initial UL BWP size in PRBs, as per TS 38.213, Section 9.2.1.
+  const unsigned size_ul_bwp = cell_cfg.ul_cfg_common.init_ul_bwp.generic_params.crbs.length();
+
+  // Get PUCCH common resource config from Table 9.2.1-1, TS 38.213.
+  const pucch_default_resource common_default_res = get_pucch_default_resource(
+      cell_cfg.ul_cfg_common.init_ul_bwp.pucch_cfg_common->pucch_resource_common, size_ul_bwp);
+
+  // Collect all resources (common + dedicated).
+  static_vector<resource_info, pucch_collision_manager::max_nof_cell_resources> all_resources;
+  for (unsigned r_pucch = 0; r_pucch != pucch_collision_manager::nof_common_res; ++r_pucch) {
+    all_resources.push_back(resource_info(common_default_res, r_pucch, size_ul_bwp));
+  }
+  for (const auto& res : cell_cfg.ded_pucch_resources) {
+    all_resources.push_back(resource_info(res));
+  }
+
+  return all_resources;
+}
+
+/// Checks if two PUCCH resources collide.
 static bool do_resources_collide(const resource_info& res1, const resource_info& res2)
 {
   if (not res1.grants.overlaps(res2.grants)) {
@@ -160,6 +197,7 @@ static bool do_resources_collide(const resource_info& res1, const resource_info&
 pucch_collision_manager::pucch_collision_manager(const cell_configuration& cell_cfg_) :
   cell_cfg(cell_cfg_),
   collision_matrix(compute_collisions(cell_cfg)),
+  mux_matrix(compute_mux_regions(cell_cfg)),
   slots_ctx({bounded_bitset<max_nof_cell_resources>(nof_common_res + cell_cfg.ded_pucch_resources.size())})
 {
 }
@@ -272,33 +310,19 @@ void pucch_collision_manager::free_ded(slot_point sl, unsigned cell_res_id)
 pucch_collision_manager::collision_matrix_t
 pucch_collision_manager::compute_collisions(const cell_configuration& cell_cfg)
 {
-  collision_matrix_t matrix(
-      nof_common_res + cell_cfg.ded_pucch_resources.size(),
-      bounded_bitset<max_nof_cell_resources>(nof_common_res + cell_cfg.ded_pucch_resources.size()));
-
-  // Get the parameter N_bwp_size, which is the Initial UL BWP size in PRBs, as per TS 38.213, Section 9.2.1.
-  const unsigned size_ul_bwp = cell_cfg.ul_cfg_common.init_ul_bwp.generic_params.crbs.length();
-
-  // Get PUCCH common resource config from Table 9.2.1-1, TS 38.213.
-  const pucch_default_resource common_default_res = get_pucch_default_resource(
-      cell_cfg.ul_cfg_common.init_ul_bwp.pucch_cfg_common->pucch_resource_common, size_ul_bwp);
+  const unsigned     nof_res = nof_common_res + cell_cfg.ded_pucch_resources.size();
+  collision_matrix_t matrix(nof_res, bounded_bitset<max_nof_cell_resources>(nof_res));
 
   // Collect all resources (common + dedicated).
-  static_vector<resource_info, max_nof_cell_resources> all_resources;
-  for (unsigned r_pucch = 0; r_pucch != nof_common_res; ++r_pucch) {
-    all_resources.push_back(resource_info(common_default_res, r_pucch, size_ul_bwp));
-  }
-  for (const auto& res : cell_cfg.ded_pucch_resources) {
-    all_resources.push_back(resource_info(res));
-  }
+  static_vector<resource_info, max_nof_cell_resources> all_resources = get_all_resources(cell_cfg);
 
   // Precompute the collision matrix.
-  for (size_t i = 0; i != all_resources.size(); ++i) {
+  for (size_t i = 0; i != nof_res; ++i) {
     // A resource always collides with itself.
     matrix[i].set(i);
 
     // Note: The collision matrix is symmetric.
-    for (size_t j = i + 1; j != all_resources.size(); ++j) {
+    for (size_t j = i + 1; j != nof_res; ++j) {
       if (do_resources_collide(all_resources[i], all_resources[j])) {
         matrix[i].set(j);
         matrix[j].set(i);
@@ -308,3 +332,52 @@ pucch_collision_manager::compute_collisions(const cell_configuration& cell_cfg)
 
   return matrix;
 }
+
+pucch_collision_manager::mux_regions_matrix_t
+pucch_collision_manager::compute_mux_regions(const cell_configuration& cell_cfg)
+{
+  unsigned             nof_res = nof_common_res + cell_cfg.ded_pucch_resources.size();
+  mux_regions_matrix_t mux_regions;
+
+  // Collect all resources (common + dedicated).
+  static_vector<resource_info, max_nof_cell_resources> all_resources = get_all_resources(cell_cfg);
+
+  // Helper structure to keep track of multiplexing regions and their members.
+  struct region_record {
+    mux_region                             region;
+    bounded_bitset<max_nof_cell_resources> members;
+  };
+  static_vector<region_record, max_nof_cell_resources> tmp_regions;
+
+  for (size_t i = 0; i != nof_res; ++i) {
+    const auto& res = all_resources[i];
+
+    // Find if the resource belongs to an existing multiplexing region.
+    auto* region_it = std::find_if(tmp_regions.begin(), tmp_regions.end(), [&res](const region_record& record) {
+      return record.region.does_resource_belong(res);
+    });
+
+    if (region_it == tmp_regions.end()) {
+      // If the multiplexing region does not exist yet, create it.
+      region_it = &tmp_regions.emplace_back(region_record{mux_region{
+                                                              .grants = res.grants,
+                                                              .format = res.format,
+                                                          },
+                                                          bounded_bitset<max_nof_cell_resources>(nof_res)});
+    }
+
+    // Add the resource to the multiplexing region.
+    region_it->members.set(i);
+  }
+
+  // Return only multiplexing regions with more than one resource.
+  for (const auto& record : tmp_regions) {
+    if (record.members.count() < 2) {
+      continue;
+    }
+
+    mux_regions.push_back(record.members);
+  }
+
+  return mux_regions;
+}

lib/scheduler/pucch_scheduling/pucch_collision_manager.h

@@ -26,6 +26,11 @@ namespace srsran {
 class pucch_collision_manager
 {
 public:
+  /// Maximum number of common PUCCH resources managed by the collision manager.
+  static constexpr unsigned nof_common_res = pucch_constants::MAX_NOF_CELL_COMMON_PUCCH_RESOURCES;
+  /// Maximum number of PUCCH resources managed by the collision manager (common + dedicated).
+  static constexpr unsigned max_nof_cell_resources = nof_common_res + pucch_constants::MAX_NOF_CELL_PUCCH_RESOURCES;
+
   /// Bounded integer representing a common PUCCH resource index (r_pucch).
   using r_pucch_t = bounded_integer<unsigned, 0, 15>;
 
@@ -40,6 +45,9 @@ class pucch_collision_manager
   /// Checks if a common PUCCH resource collides with a dedicated PUCCH resource.
   bool check_common_to_ded_collision(r_pucch_t r_pucch, unsigned cell_res_id) const;
 
+  /// Returns the number of multiplexing regions defined in the cell configuration.
+  unsigned nof_mux_regions() const { return mux_matrix.size(); }
+
   /// \brief Checks if a common PUCCH resource can be allocated at a given slot.
   /// A resource can be allocated if it is not in use and it does not collide with any other resource already allocated
   /// at the same slot.
@@ -63,20 +71,24 @@ class pucch_collision_manager
   void free_ded(slot_point sl, unsigned cell_res_id);
 
 private:
-  static constexpr unsigned nof_common_res         = pucch_constants::MAX_NOF_CELL_COMMON_PUCCH_RESOURCES;
-  static constexpr unsigned max_nof_cell_resources = nof_common_res + pucch_constants::MAX_NOF_CELL_PUCCH_RESOURCES;
-
-  // Collision matrix indicating which resources collide with each other.
-  // C[i][j] = 1 if resource i collides with resource j, 0 otherwise.
+  /// \brief Collision matrix indicating which resources collide with each other.
+  ///  - C[i][j] = 1 if resource i collides with resource j, 0 otherwise.
   using collision_matrix_t = static_vector<bounded_bitset<max_nof_cell_resources>, max_nof_cell_resources>;
+  /// \brief Matrix of multiplexing regions indicating which resources can be multiplexed together.
+  ///  - Each row represents a multiplexing region.
+  ///  - M[i][j] = 1 if resource j belongs to multiplexing region i, 0 otherwise.
+  /// \remark Multiplexing regions with only one resource (i.e., non-multiplexed resources) are not represented in this
+  ///         matrix. Therefore, we can have a maximum of $max_nof_cell_resources / 2$ rows.
+  using mux_regions_matrix_t = static_vector<bounded_bitset<max_nof_cell_resources>, max_nof_cell_resources / 2>;
 
-  const cell_configuration& cell_cfg;
-  const collision_matrix_t  collision_matrix;
+  const cell_configuration&  cell_cfg;
+  const collision_matrix_t   collision_matrix;
+  const mux_regions_matrix_t mux_matrix;
 
   /// Allocation context for a specific slot.
   struct slot_context {
     /// Bitset representing the current usage state of all PUCCH resources (common and dedicated) in this slot.
-    /// S[i] = 1 if resource i is in use, 0 otherwise.
+    ///  - S[i] = 1 if resource i is in use, 0 otherwise.
     bounded_bitset<max_nof_cell_resources> current_state;
   };
 
@@ -88,6 +100,9 @@ class pucch_collision_manager
 
   /// Computes the collision matrix for all PUCCH resources in the cell configuration.
   static collision_matrix_t compute_collisions(const cell_configuration& cell_cfg);
+
+  /// Computes the multiplexing matrix for all PUCCH resources in the cell configuration.
+  static mux_regions_matrix_t compute_mux_regions(const cell_configuration& cell_cfg);
 };
 
 } // namespace srsran

tests/unittests/scheduler/uci_and_pucch/pucch_collision_manager_test.cpp

@@ -19,11 +19,13 @@
 
 using namespace srsran;
 
-static cell_configuration make_test_cell_configuration(const std::vector<pucch_resource>& ded_res)
+static cell_configuration make_test_cell_configuration(const std::vector<pucch_resource>& ded_res               = {},
+                                                       unsigned                           pucch_resource_common = 11)
 {
   const auto expert_cfg         = config_helpers::make_default_scheduler_expert_config();
   auto       sched_req          = sched_config_helper::make_default_sched_cell_configuration_request();
   sched_req.ded_pucch_resources = ded_res;
+  sched_req.ul_cfg_common.init_ul_bwp.pucch_cfg_common.value().pucch_resource_common = pucch_resource_common;
   return cell_configuration{expert_cfg, sched_req};
 }
 
@@ -50,7 +52,7 @@ static cell_configuration make_test_cell_configuration(const std::vector<pucch_r
 // |---------|--------|----------------|------------------|------------------|
 TEST(pucch_collision_manager_test, common_resources_dont_collide_with_each_other)
 {
-  const auto              cell_cfg = make_test_cell_configuration({});
+  const auto              cell_cfg = make_test_cell_configuration();
   pucch_collision_manager col_manager(cell_cfg);
 
   slot_point sl(cell_cfg.ul_cfg_common.init_ul_bwp.generic_params.scs, 0);
@@ -202,3 +204,76 @@ TEST(pucch_collision_manager_test, f4_multiplexed_resources_dont_collide)
     }
   }
 }
+
+TEST(pucch_collision_manager_test, check_mux_regions_count_for_common_resources)
+{
+  static constexpr std::array<unsigned, 16> nof_expected_mux_regions = {
+      8, // 2 CS
+      6, // 3 CS, resources distributed in regions as 3-3-2-3-3-2
+      6, // 3 CS, resources distributed in regions as 3-3-2-3-3-2
+      8, // 2 CS
+      4, // 4 CS
+      4, // 4 CS
+      4, // 4 CS
+      8, // 2 CS
+      4, // 4 CS
+      4, // 4 CS
+      4, // 4 CS
+      8, // 2 CS
+      4, // 4 CS
+      4, // 4 CS
+      4, // 4 CS
+      4, // 4 CS
+  };
+  for (unsigned pucch_resource_common = 0; pucch_resource_common != 16; ++pucch_resource_common) {
+    const auto              cell_cfg = make_test_cell_configuration({}, pucch_resource_common);
+    pucch_collision_manager col_manager(cell_cfg);
+
+    ASSERT_EQ(nof_expected_mux_regions[pucch_resource_common], col_manager.nof_mux_regions());
+  }
+}
+
+TEST(pucch_collision_manager_test, handles_max_dedicated_resources_with_unique_regions)
+{
+  auto cell_cfg = make_test_cell_configuration();
+
+  std::vector<pucch_resource> ded_res_list;
+  ded_res_list.reserve(pucch_constants::MAX_NOF_CELL_PUCCH_RESOURCES);
+
+  // Generate a list with the maximum number of dedicated PUCCH resources in a way that all resources belongs to a
+  // different multiplexing region.
+  for (unsigned sym = 0, prb = 0; ded_res_list.size() != pucch_constants::MAX_NOF_CELL_PUCCH_RESOURCES;) {
+    const unsigned res_idx = ded_res_list.size();
+    ded_res_list.push_back(pucch_resource{
+        .res_id           = {res_idx, res_idx},
+        .starting_prb     = prb,
+        .second_hop_prb   = std::nullopt,
+        .nof_symbols      = 1,
+        .starting_sym_idx = static_cast<uint8_t>(sym),
+        .format           = pucch_format::FORMAT_2,
+        .format_params    = pucch_format_2_3_cfg{.nof_prbs = 1},
+    });
+
+    // By using different starting symbols and PRBs for each resource, we ensure that all resources have unique
+    // time-frequency allocations, and thus belong to different multiplexing regions.
+    // Using Format 2 ensures they are not multiplexed with the common resources either.
+    ++sym;
+    if (sym == NOF_OFDM_SYM_PER_SLOT_NORMAL_CP) {
+      sym = 0;
+      ++prb;
+      if (prb == cell_cfg.ul_cfg_common.init_ul_bwp.generic_params.crbs.length()) {
+        // No more PRBs available. This should not happen.
+        break;
+      }
+    }
+  }
+  ASSERT_EQ(ded_res_list.size(), pucch_constants::MAX_NOF_CELL_PUCCH_RESOURCES)
+      << "Failed to create the maximum number of dedicated PUCCH resources for the test";
+
+  // Overwrite the cell configuration with the dedicated resources.
+  cell_cfg.ded_pucch_resources = ded_res_list;
+  pucch_collision_manager col_manager(cell_cfg);
+
+  // Only the multiplexing regions of the common resources should be present.
+  EXPECT_EQ(8U, col_manager.nof_mux_regions());
+}