du: fix RAN resource deallocation + add unittest

Signed-off-by: Carlo Galiotto <[email protected]>

Author: carlo-gal

lib/du/du_high/du_manager/ran_resource_management/du_pucch_resource_manager.cpp

@@ -348,6 +348,10 @@ void du_pucch_resource_manager::dealloc_resources(cell_group_config& cell_grp_cf
     srsran_assert(cells[0].pucch_grants_per_slot_cnt[offset] != 0, "Index exceeds the size of the PUCCH grants vector");
     --cells[0].pucch_grants_per_slot_cnt[offset];
   }
+
+  // Disable the PUCCH configuration in this UE. This makes sure the DU will exit this function immediately when it gets
+  // call again for the same UE (upon destructor's call).
+  disable_pucch_cfg(cell_grp_cfg);
 }
 
 std::vector<std::pair<unsigned, unsigned>>::const_iterator

lib/du/du_high/du_manager/ran_resource_management/du_ran_resource_manager_impl.cpp

@@ -38,6 +38,21 @@ du_ue_ran_resource_updater_impl::update(du_cell_index_t                       pc
 
 ///////////////////////////
 
+static void initialize_serv_cell_cfg(serving_cell_config& serv_cell_cfg)
+{
+  srsran_assert(serv_cell_cfg.ul_config.has_value() and
+                    serv_cell_cfg.ul_config.value().init_ul_bwp.pucch_cfg.has_value() and
+                    serv_cell_cfg.ul_config.value().init_ul_bwp.srs_cfg.has_value(),
+                "UL configuration in Serving cell config not configured");
+
+  serv_cell_cfg.ul_config->init_ul_bwp.pucch_cfg.reset();
+  if (serv_cell_cfg.csi_meas_cfg.has_value()) {
+    serv_cell_cfg.csi_meas_cfg.value().csi_report_cfg_list.clear();
+  }
+
+  serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.reset();
+}
+
 du_ran_resource_manager_impl::du_ran_resource_manager_impl(span<const du_cell_config>                cell_cfg_list_,
                                                            const scheduler_expert_config&            scheduler_cfg,
                                                            const std::map<srb_id_t, du_srb_config>&  srb_config,
@@ -64,7 +79,6 @@ du_ran_resource_manager_impl::create_ue_resource_configurator(du_ue_index_t ue_i
   // UE initialized PCell.
   // Note: In case of lack of RAN resource availability, the return will be error type.
   error_type<std::string> err = allocate_cell_resources(ue_index, pcell_index, SERVING_CELL_PCELL_IDX);
-
   return ue_ran_resource_configurator{std::make_unique<du_ue_ran_resource_updater_impl>(&mcg, *this, ue_index),
                                       err.has_value() ? std::string{} : err.error()};
 }
@@ -164,6 +178,10 @@ error_type<std::string> du_ran_resource_manager_impl::allocate_cell_resources(du
     }
     ue_res.cell_group.pcg_cfg.pdsch_harq_codebook = pdsch_harq_ack_codebook::dynamic;
 
+    // Start with removing PUCCH and SRS configurations. This step simplifies the handling of the allocation failure
+    // path.
+    initialize_serv_cell_cfg(ue_res.cell_group.cells[0].serv_cell_cfg);
+
     if (not srs_res_mng->alloc_resources(ue_res.cell_group)) {
       // Deallocate dedicated Search Spaces.
       ue_res.cell_group.cells[0].serv_cell_cfg.init_dl_bwp.pdcch_cfg->search_spaces.clear();

lib/du/du_high/du_manager/ran_resource_management/du_srs_resource_manager.cpp

@@ -158,12 +158,17 @@ du_srs_policy_max_ul_th::du_srs_policy_max_ul_th(span<const du_cell_config> cell
         // Handle TDD and FDD configurations separately, as we treat partially-UL slots differently from
         // fully-UL slots.
         if (cell_cfg_list_[0].tdd_ul_dl_cfg_common.has_value()) {
+          const auto& tdd_cfg = cell_cfg_list_[0].tdd_ul_dl_cfg_common.value();
           // For partially-UL slots, we need to check if the SRS can be placed in the UL symbols of the
           // slot.
           if (is_partually_ul_slot(offset, cell_cfg_list_[0].tdd_ul_dl_cfg_common.value())) {
-            // TODO: Fix check for pattern 2.
-            if (res.symbols.start() < NOF_OFDM_SYM_PER_SLOT_NORMAL_CP -
-                                          cell_cfg_list_[0].tdd_ul_dl_cfg_common.value().pattern1.nof_ul_symbols) {
+            const unsigned slot_index =
+                offset % (NOF_SUBFRAMES_PER_FRAME * get_nof_slots_per_subframe(tdd_cfg.ref_scs));
+            static constexpr unsigned max_srs_symbols = 6U;
+            const unsigned            nof_ul_symbols_for_srs =
+                std::min(srsran::get_active_tdd_ul_symbols(tdd_cfg, slot_index, cyclic_prefix::NORMAL).length(),
+                         max_srs_symbols);
+            if (res.symbols.start() < NOF_OFDM_SYM_PER_SLOT_NORMAL_CP - nof_ul_symbols_for_srs) {
               continue;
             }
           }
@@ -191,13 +196,15 @@ bool du_srs_policy_max_ul_th::alloc_resources(cell_group_config& cell_grp_cfg)
 {
   // TODO: Adapt this to the case of UEs with multiple cells configs.
   srsran_assert(
-      cells[cell_grp_cfg.cells[0].serv_cell_cfg.cell_index].cell_cfg.ue_ded_serv_cell_cfg.ul_config.has_value(),
-      "UE UL config is empty");
+      cells[cell_grp_cfg.cells[0].serv_cell_cfg.cell_index].cell_cfg.ue_ded_serv_cell_cfg.ul_config.has_value() and
+          not cell_grp_cfg.cells[0].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.has_value(),
+      "UE UL config should be non-empty but with an empty SRS config");
+
+  cell_grp_cfg.cells[0].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.emplace(
+      cells[cell_grp_cfg.cells[0].serv_cell_cfg.cell_index].default_srs_cfg);
 
   // If periodic SRS is not enabled, don't allocate anything and exit with success.
-  if (not cells[0].cell_cfg.srs_cfg.srs_period.has_value() or not cells[cell_grp_cfg.cells[0].serv_cell_cfg.cell_index]
-                                                                      .cell_cfg.ue_ded_serv_cell_cfg.ul_config.value()
-                                                                      .init_ul_bwp.srs_cfg.has_value()) {
+  if (not cells[0].cell_cfg.srs_cfg.srs_period.has_value()) {
     return true;
   }
 
@@ -210,19 +217,25 @@ bool du_srs_policy_max_ul_th::alloc_resources(cell_group_config& cell_grp_cfg)
 
   // Verify where there are SRS resources to allocate a new UE.
   if (free_srs_list.empty()) {
+    // If the allocation failed, reset the SRS configuration.
+    cell_grp_cfg.cells[0].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.reset();
     return false;
   }
 
   // Find the best resource ID and offset for this UE.
   auto srs_res_id_offset = cells[0].find_optimal_ue_srs_resource();
 
   if (srs_res_id_offset == free_srs_list.end()) {
+    // If the allocation failed, reset the SRS configuration.
+    cell_grp_cfg.cells[0].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.reset();
     return false;
   }
 
   const auto& du_res_it = cells[0].get_du_srs_res_cfg(srs_res_id_offset->first);
 
   if (du_res_it == cells[0].cell_srs_res_list.end()) {
+    // If the allocation failed, reset the SRS configuration.
+    cell_grp_cfg.cells[0].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.reset();
     return false;
   }
 
@@ -256,6 +269,9 @@ bool du_srs_policy_max_ul_th::alloc_resources(cell_group_config& cell_grp_cfg)
   only_ue_srs_res.freq_domain_shift =
       cells[cell_grp_cfg.cells[0].serv_cell_cfg.cell_index].srs_common_params.freq_shift;
 
+  only_ue_srs_res.periodicity_and_offset.emplace(srs_config::srs_periodicity_and_offset{
+      .period = cells[0].cell_cfg.srs_cfg.srs_period.value(), .offset = static_cast<uint16_t>(srs_offset)});
+
   // Update the SRS resource set with the SRS id.
   ue_srs_cfg.srs_res_set_list.front().srs_res_id_list.front() = only_ue_srs_res.id.ue_res_id;
 
@@ -294,7 +310,8 @@ du_srs_policy_max_ul_th::cell_context::find_optimal_ue_srs_resource()
 
     // Give priority to the last symbols within a slot. This reduces the space used for the SRS in a slot.
     const unsigned symb_weight =
-        (NOF_OFDM_SYM_PER_SLOT_NORMAL_CP - srs_res_cfg_it->symbols.start()) * symbol_weight_base;
+        symbol_weight_base *
+        ((NOF_OFDM_SYM_PER_SLOT_NORMAL_CP - srs_res_cfg_it->symbols.start()) / srs_res_cfg_it->symbols.length());
 
     // We consider a discount if the offset is already used but not full; this way, we give an incentive
     // to the SRS resources not to be allocated on a new slot, to avoid taking PUSCH symbols on a new
@@ -332,4 +349,8 @@ void du_srs_policy_max_ul_th::dealloc_resources(cell_group_config& cell_grp_cfg)
     srsran_assert(cells[0].slot_resource_cnt[offset_to_deallocate].first != 0, "The offset is expected to be non-zero");
     --cells[0].slot_resource_cnt[offset_to_deallocate].first;
   }
+
+  // Reset the SRS configuration in this UE. This makes sure the DU will exit this function immediately when it gets
+  // call again for the same UE (upon destructor's call).
+  cell_grp_cfg.cells[0].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.reset();
 }

lib/du/du_high/du_manager/ran_resource_management/du_srs_resource_manager.h

@@ -36,10 +36,10 @@ class du_srs_resource_manager
   virtual void dealloc_resources(cell_group_config& cell_grp_cfg) = 0;
 };
 
-/// This class implements the MAX UL throughput policy for the SRS allocation. The SRS resources are allocated to
-/// minimize the number of slots that contains the SRS resources; furthermore, within a given slot, the SRS resources
-/// are allocated to minimize the number of symbols that are used for SRS. The drawback of this policy is that it can
-/// increase the inter slot SRS interference among different UEs.
+/// This class implements the MAX UL throughput policy for the SRS allocation. The SRS resources are allocated with the
+/// objective to minimize the number of slots that contains the SRS resources; furthermore, within a given slot, the SRS
+/// resources are allocated to minimize the number of symbols that are used for SRS. The drawback of this policy is that
+/// it can increase the inter slot SRS interference among different UEs.
 class du_srs_policy_max_ul_th : public du_srs_resource_manager
 {
 public:
@@ -58,9 +58,11 @@ class du_srs_policy_max_ul_th : public du_srs_resource_manager
     // Returns the DU SRS resource with the given cell resource ID from the cell list of resources.
     std::vector<du_srs_resource>::const_iterator get_du_srs_res_cfg(unsigned cell_res_id)
     {
-      return std::find_if(cell_srs_res_list.begin(),
-                          cell_srs_res_list.end(),
-                          [cell_res_id](const du_srs_resource& res) { return res.cell_res_id == cell_res_id; });
+      if (cell_res_id >= cell_srs_res_list.size() or cell_srs_res_list[cell_res_id].cell_res_id != cell_res_id) {
+        srsran_assertion_failure("Cell resource ID out of range or invalid");
+        return cell_srs_res_list.end();
+      }
+      return cell_srs_res_list.cbegin() + cell_res_id;
     }
 
     // Returns the best SRS resource ID and offset for this UE, according to the policy defined in this class.
@@ -85,8 +87,6 @@ class du_srs_policy_max_ul_th : public du_srs_resource_manager
     // Maximum number of SRS resources that can be generated in a cell.
     // [Implementation-defined] We assume each UE has one and only one resource.
     static const unsigned max_nof_srs_res = MAX_NOF_DU_UES;
-    // We need to save an object with the cell configuration parameters (not a reference), as this config is a modified
-    // version of the default cell config.
     const du_cell_config& cell_cfg;
     // Default SRS configuration for the cell.
     const srs_config default_srs_cfg;