du: simplify optimization fnc in srs res mng

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

Author: carlo-gal

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

@@ -350,7 +350,7 @@ void du_pucch_resource_manager::dealloc_resources(cell_group_config& cell_grp_cf
   }
 
   // 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).
+  // called again for the same UE (upon destructor's call).
   disable_pucch_cfg(cell_grp_cfg);
 }
 

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

@@ -57,7 +57,8 @@ static std::optional<unsigned> compute_srs_bw_param(unsigned nof_ul_rbs)
 // are placed at the center of the band.
 static unsigned compute_freq_shift(unsigned c_srs, unsigned nof_ul_rbs)
 {
-  // As per Section 6.4.1.4.3, the parameter \f$C_{SRS}\f$ = 0 provides the bandwidth of the SRS resources.
+  // As per Section 6.4.1.4.3, the parameter \f$m_{SRS}\f$ = 0 is an index that, along with \f$C_{SRS}\f$, maps to the
+  // bandwidth of the SRS resources.
   constexpr uint8_t                        b_srs_0    = 0;
   std::optional<srsran::srs_configuration> srs_params = srs_configuration_get(c_srs, b_srs_0);
   srsran_sanity_check(srs_params.has_value() and nof_ul_rbs >= srs_params.value().m_srs,
@@ -137,20 +138,22 @@ du_srs_policy_max_ul_th::du_srs_policy_max_ul_th(span<const du_cell_config> cell
     cell.cell_srs_res_list = generate_cell_srs_list(cell.cell_cfg);
 
     const auto srs_period_slots = static_cast<unsigned>(cell.cell_cfg.srs_cfg.srs_period.value());
-    cell.slot_resource_cnt.reserve(srs_period_slots);
+    // Reserve the size of the vector and set the SRS counter of each offset to 0.
+    cell.slot_resource_cnt.assign(srs_period_slots, 0U);
     cell.srs_res_offset_free_list.reserve(du_srs_policy_max_ul_th::cell_context::max_nof_srs_res);
+    cell.nof_res_per_symb_interval = static_cast<unsigned>(cell.cell_cfg.srs_cfg.tx_comb) *
+                                     static_cast<unsigned>(cell.cell_cfg.srs_cfg.cyclic_shift_reuse_factor) *
+                                     static_cast<unsigned>(cell.cell_cfg.srs_cfg.sequence_id_reuse_factor);
 
     for (unsigned offset = 0; offset != srs_period_slots; ++offset) {
       // We don't generate more than the maximum number of SRS resources per cell.
       if (cell.srs_res_offset_free_list.size() >= du_srs_policy_max_ul_th::cell_context::max_nof_srs_res) {
         break;
       }
 
-      unsigned offset_res_cnt = 0U;
       // Verify whether the offset maps to a partially- or fully-UL slot.
       if (cell_cfg_list_[0].tdd_ul_dl_cfg_common.has_value() and
           not is_ul_slot(offset, cell_cfg_list_[0].tdd_ul_dl_cfg_common.value())) {
-        cell.slot_resource_cnt.emplace_back(0U, offset_res_cnt);
         continue;
       }
 
@@ -164,6 +167,8 @@ du_srs_policy_max_ul_th::du_srs_policy_max_ul_th(span<const du_cell_config> cell
           if (is_partually_ul_slot(offset, cell_cfg_list_[0].tdd_ul_dl_cfg_common.value())) {
             const unsigned slot_index =
                 offset % (NOF_SUBFRAMES_PER_FRAME * get_nof_slots_per_subframe(tdd_cfg.ref_scs));
+            // As per Section 6.4.1.4.1, TS 38.211, the SRS resources can only be placed in the last 6 symbols of the
+            // slot.
             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(),
@@ -185,9 +190,7 @@ du_srs_policy_max_ul_th::du_srs_policy_max_ul_th(span<const du_cell_config> cell
           }
         }
         cell.srs_res_offset_free_list.emplace_back(res.cell_res_id, offset);
-        ++offset_res_cnt;
       }
-      cell.slot_resource_cnt.emplace_back(0U, offset_res_cnt);
     }
   }
 }
@@ -208,8 +211,8 @@ bool du_srs_policy_max_ul_th::alloc_resources(cell_group_config& cell_grp_cfg)
     return true;
   }
 
-  // The UE SRS configuration is taken from a base configuration, saved in the GNB. The details that are
-  // UE specific will be added later on in this function.
+  // The UE SRS configuration is taken from a base configuration, saved in the GNB. The UE specific parameters will be
+  // added later on in this function.
   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);
   srs_config& ue_srs_cfg    = cell_grp_cfg.cells[0].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.value();
@@ -222,7 +225,7 @@ bool du_srs_policy_max_ul_th::alloc_resources(cell_group_config& cell_grp_cfg)
     return false;
   }
 
-  // Find the best resource ID and offset for this UE.
+  // Find the best resource ID and offset for this UE, according to the class policy.
   auto srs_res_id_offset = cells[0].find_optimal_ue_srs_resource();
 
   if (srs_res_id_offset == free_srs_list.end()) {
@@ -278,22 +281,23 @@ bool du_srs_policy_max_ul_th::alloc_resources(cell_group_config& cell_grp_cfg)
   // Remove the allocated SRS resource from the free list.
   free_srs_list.erase(srs_res_id_offset);
 
-  // Update the used_not_full slot vector.
-  ++cells[0].slot_resource_cnt[srs_offset].first;
+  // Update the SRS resource per slot counter.
+  ++cells[0].slot_resource_cnt[srs_offset];
 
   return true;
 }
 
 std::vector<std::pair<unsigned, unsigned>>::const_iterator
 du_srs_policy_max_ul_th::cell_context::find_optimal_ue_srs_resource()
 {
-  // The weights assigned here can be set to any value, as long as:
+  // The weights assigned here can be set to arbitrarily value, as long as:
   // - symbol_weight_base is greater than 0;
-  // - reuse_slot_discount less than symbol_weight_base;
-  // - max_weight is > symbol_weight_base * (srs_builder_params::max_nof_symbols /
-  // srs_builder_params::nof_symbols).
+  // - reuse_slot_discount is less than symbol_weight_base;
+  // - max_weight > symbol_weight_base * (srs_builder_params::max_nof_symbols / srs_builder_params::nof_symbols).
   static constexpr unsigned max_weight         = 100U;
   static constexpr unsigned symbol_weight_base = 10U;
+  // We give a discount to the symbol weight if the offset is already used but not full.
+  static const unsigned partial_symb_interval_discount = symbol_weight_base / 2U;
 
   const auto weight_function = [&](const pair_res_id_offset& srs_res) {
     if (cell_cfg.tdd_ul_dl_cfg_common.has_value() and
@@ -308,15 +312,16 @@ du_srs_policy_max_ul_th::cell_context::find_optimal_ue_srs_resource()
       return max_weight;
     }
 
-    // Give priority to the last symbols within a slot. This reduces the space used for the SRS in a slot.
+    // Give priority to the last symbol intervals within a slot. This reduces the space used for the SRS in a slot.
     const unsigned symb_weight =
         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
     // slot.
-    const unsigned reuse_slot_discount = offset_used_not_full(srs_res.second) ? symbol_weight_base / 2U : 0U;
+    const unsigned reuse_slot_discount =
+        offset_interval_used_not_full(srs_res.second) ? partial_symb_interval_discount : 0U;
 
     return symb_weight - reuse_slot_discount;
   };
@@ -346,11 +351,11 @@ void du_srs_policy_max_ul_th::dealloc_resources(cell_group_config& cell_grp_cfg)
     free_srs_list.emplace_back(srs_res.id.cell_res_id, offset_to_deallocate);
 
     // Update the used_not_full slot vector.
-    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;
+    srsran_assert(cells[0].slot_resource_cnt[offset_to_deallocate] != 0, "The offset is expected to be non-zero");
+    --cells[0].slot_resource_cnt[offset_to_deallocate];
   }
 
   // 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).
+  // called 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

@@ -37,14 +37,20 @@ class du_srs_resource_manager
 };
 
 /// 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.
+/// objective to minimize the number of slots and symbols that contain the SRS resources, to reduce as much as possible
+/// the slots and symbols resources taken from the PUSCH. 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:
   explicit du_srs_policy_max_ul_th(span<const du_cell_config> cell_cfg_list_);
 
+  /// The SRS resources are allocate according to the following policy:
+  /// - Give priority to resources that are placed on partially-UL slots, first.
+  /// - Then, give priority to SRS resources that is placed on the symbol interval (i.e, the symbols interval used by an
+  /// SRS resource) closest to the end of the slot.
+  /// - If a symbol interval on a particular slot is already used and not completely full, then give priority to this
+  /// symbol interval over any other symbol intervals on the same or on different slots.
   bool alloc_resources(cell_group_config& cell_grp_cfg) override;
 
   void dealloc_resources(cell_group_config& cell_grp_cfg) override;
@@ -53,8 +59,6 @@ class du_srs_policy_max_ul_th : public du_srs_resource_manager
   struct cell_context {
     cell_context(const du_cell_config& cfg);
 
-    using pair_res_id_offset = std::pair<unsigned, unsigned>;
-
     // 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)
     {
@@ -65,15 +69,22 @@ class du_srs_policy_max_ul_th : public du_srs_resource_manager
       return cell_srs_res_list.cbegin() + cell_res_id;
     }
 
+    using pair_res_id_offset = std::pair<unsigned, unsigned>;
+
     // Returns the best SRS resource ID and offset for this UE, according to the policy defined in this class.
     std::vector<pair_res_id_offset>::const_iterator find_optimal_ue_srs_resource();
 
-    // Check if this SRS offset has already some SRS resources allocated, but can still host more.
-    bool offset_used_not_full(unsigned offset) const
+    // Check if this SRS offset has already some SRS resources allocated at a given symbol interval, but can still host
+    // more.
+    bool offset_interval_used_not_full(unsigned offset) const
     {
+      // The counter of SRS resources counts how many resources have been allocated in the current slot (offset).
+      // If the counter is 0, then the offset is free.
+      // If the counter is a non-zero multiple (i.e, N) of nof_res_per_symb_interval, then the symbol interval of index
+      // N-1 has been filled completely and the next symbol interval of index N is free. In any other case, the symbol
+      // interval N-1 is partially filled.
       srsran_assert(offset < slot_resource_cnt.size(), "Offset out of range");
-      return slot_resource_cnt[offset].first != 0 and
-             slot_resource_cnt[offset].first < slot_resource_cnt[offset].second;
+      return slot_resource_cnt[offset] % nof_res_per_symb_interval != 0U;
     }
 
     // Parameters that are common to all cell SRS resources.
@@ -82,8 +93,6 @@ class du_srs_policy_max_ul_th : public du_srs_resource_manager
       unsigned freq_shift;
     };
 
-    using pair_cnt_max = std::pair<unsigned, const unsigned>;
-
     // 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;
@@ -96,8 +105,9 @@ class du_srs_policy_max_ul_th : public du_srs_resource_manager
     std::vector<du_srs_resource> cell_srs_res_list;
     // List of SRS resource ID and offset that can be allocated to the cell's UEs.
     std::vector<pair_res_id_offset> srs_res_offset_free_list;
-    // Counter of how many SRS resources (current counter, max_counter) that can be allocated in the same slot (offset).
-    std::vector<pair_cnt_max> slot_resource_cnt;
+    unsigned                        nof_res_per_symb_interval = 0;
+    // Counter of how many SRS resources that are allocated per slot (offset).
+    std::vector<unsigned> slot_resource_cnt;
   };
 
   // Contains the resources for the different cells of the DU.

tests/unittests/du_manager/du_ran_resource_manager_test.cpp

@@ -830,14 +830,13 @@ static cell_config_builder_params make_cell_cfg_params(const srs_params& params)
 
 static du_cell_config make_srs_base_du_cell_config(const cell_config_builder_params& params)
 {
-  // This function generates a configuration which would potentially allow for very large number of SRS resources.
+  // This function generates a configuration which would potentially allow for a very large number of SRS resources.
   du_cell_config du_cfg  = config_helpers::make_default_du_cell_config(params);
   auto&          srs_cfg = du_cfg.srs_cfg;
 
   // Generates a random SRS configuration.
-  srs_cfg.tx_comb         = test_rgen::bernoulli(0.5) ? tx_comb_size::n2 : tx_comb_size::n4;
-  srs_cfg.max_nof_symbols = test_rgen::uniform_int<unsigned>(1U, 6U);
-  // The number of SRS symbols cannot exceed the number of
+  srs_cfg.tx_comb                                = test_rgen::bernoulli(0.5) ? tx_comb_size::n2 : tx_comb_size::n4;
+  srs_cfg.max_nof_symbols                        = test_rgen::uniform_int<unsigned>(1U, 6U);
   std::array<srs_nof_symbols, 3> nof_symb_values = {srs_nof_symbols::n1, srs_nof_symbols::n2, srs_nof_symbols::n4};
   srs_cfg.nof_symbols = nof_symb_values[test_rgen::uniform_int<unsigned>(0, nof_symb_values.size() - 1)];
   while (srs_cfg.nof_symbols > srs_cfg.max_nof_symbols) {
@@ -896,7 +895,7 @@ static du_cell_config make_srs_du_cell_config(const cell_config_builder_params&
 {
   auto du_cfg = make_srs_base_du_cell_config(params);
 
-  // For the optimality test, we to have a configuration that doesn't allow more than 1024 SRS resources.
+  // For the optimality test, we to have a configuration that doesn't allow for more than 1024 SRS resources.
   if (not limit_srs_res) {
     return du_cfg;
   }
@@ -906,14 +905,14 @@ static du_cell_config make_srs_du_cell_config(const cell_config_builder_params&
   auto tot_num_srs_res = [&du_cfg]() {
     auto& tdd_cfg = du_cfg.tdd_ul_dl_cfg_common;
     auto& srs_cfg = du_cfg.srs_cfg;
-    // This is the number of SRS resources per symbol interval.
+    // This is the number of SRS resources per symbol interval. A symbol interval is an interval where the SRS resource
+    // can be placed within a slot and its width (or length) is given by the corresponding SRS parameter \c nof_symb in
+    // the SRS configuration.
     const unsigned nof_res_per_symb_interval = srs_cfg.sequence_id_reuse_factor *
                                                static_cast<unsigned>(srs_cfg.cyclic_shift_reuse_factor) *
                                                static_cast<unsigned>(srs_cfg.tx_comb);
 
-    // A symbol interval is an interval where the SRS resource can be placed within a slot and its width (or length) is
-    // given by the corresponding SRS parameter \c nof_symb in the SRS configuration. This "number of symbols intervals"
-    // counts all the symbols intervals within the SRS period.
+    // This "number of symbols intervals" counts all the symbols intervals within the SRS period.
     unsigned nof_symb_intervals = 0;
 
     // The number of symbols interval per slot depends on whether it's FDD or TDD.
@@ -937,6 +936,7 @@ static du_cell_config make_srs_du_cell_config(const cell_config_builder_params&
       }
     }
 
+    // Return the total number of SRS resources.
     return nof_symb_intervals * nof_res_per_symb_interval;
   };
 
@@ -1046,7 +1046,7 @@ class du_srs_resource_manager_tester : public ::testing::TestWithParam<srs_param
   // Helper that computes the Frequency Shift parameter (see Section 6.4.1.4.3, TS 38.211).
   unsigned compute_freq_shift() const
   {
-    // The function computes the frequency shift so that the SRS resources are placed in the center of the bandwidth.
+    // The function computes the frequency shift so that the SRS resources are placed in the center of the band.
     unsigned   c_srs         = compute_c_srs();
     unsigned   ul_bw_nof_rbs = cell_cfg_list[0].ul_cfg_common.init_ul_bwp.generic_params.crbs.length();
     const auto srs_cfg       = srs_configuration_get(c_srs, 0U);