du: some simplification in the DU SRS res mng

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

Author: carlo-gal

include/srsran/ran/tdd/tdd_ul_dl_config.h

@@ -71,6 +71,9 @@ bool is_tdd_full_dl_slot(const tdd_ul_dl_config_common& cfg, unsigned slot_index
 /// \brief Checks if all symbols in the current slot index are active for UL.
 bool is_tdd_full_ul_slot(const tdd_ul_dl_config_common& cfg, unsigned slot_index);
 
+/// \brief Checks if some symbols in the current slot index, but not all of them, are active for UL.
+bool is_tdd_partial_ul_slot(const tdd_ul_dl_config_common& cfg, unsigned slot_index);
+
 /// \brief Calculates the number of active DL symbols in the current slot_index.
 ofdm_symbol_range get_active_tdd_dl_symbols(const tdd_ul_dl_config_common& cfg, unsigned slot_index, cyclic_prefix cp);
 

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

@@ -59,8 +59,8 @@ static unsigned compute_freq_shift(unsigned c_srs, unsigned nof_ul_rbs)
 {
   // 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);
+  constexpr uint8_t                b_srs_0    = 0;
+  std::optional<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,
                       "The SRS configuration is not valid");
 
@@ -70,14 +70,13 @@ static unsigned compute_freq_shift(unsigned c_srs, unsigned nof_ul_rbs)
 static bool is_ul_slot(unsigned offset, const tdd_ul_dl_config_common& tdd_cfg)
 {
   const unsigned slot_index = offset % (NOF_SUBFRAMES_PER_FRAME * get_nof_slots_per_subframe(tdd_cfg.ref_scs));
-  return srsran::get_active_tdd_ul_symbols(tdd_cfg, slot_index, cyclic_prefix::NORMAL).length() != 0;
+  return has_active_tdd_ul_symbols(tdd_cfg, slot_index);
 }
 
-static bool is_partually_ul_slot(unsigned offset, const tdd_ul_dl_config_common& tdd_cfg)
+static bool is_partially_ul_slot(unsigned offset, const tdd_ul_dl_config_common& tdd_cfg)
 {
-  const unsigned slot_index  = offset % (NOF_SUBFRAMES_PER_FRAME * get_nof_slots_per_subframe(tdd_cfg.ref_scs));
-  const unsigned nof_symbols = srsran::get_active_tdd_ul_symbols(tdd_cfg, slot_index, cyclic_prefix::NORMAL).length();
-  return nof_symbols != 0 and nof_symbols != NOF_OFDM_SYM_PER_SLOT_NORMAL_CP;
+  const unsigned slot_index = offset % (NOF_SUBFRAMES_PER_FRAME * get_nof_slots_per_subframe(tdd_cfg.ref_scs));
+  return is_tdd_partial_ul_slot(tdd_cfg, slot_index);
 }
 
 // Helper that updates the starting SRS config with user-defined parameters.
@@ -120,6 +119,8 @@ du_srs_policy_max_ul_rate::cell_context::cell_context(const du_cell_config& cfg)
 du_srs_policy_max_ul_rate::du_srs_policy_max_ul_rate(span<const du_cell_config> cell_cfg_list_) :
   cells(cell_cfg_list_.begin(), cell_cfg_list_.end())
 {
+  static constexpr unsigned primary_cell_index = 0U;
+
   for (auto& cell : cells) {
     if (not cell.cell_cfg.srs_cfg.srs_period.has_value()) {
       continue;
@@ -139,6 +140,7 @@ du_srs_policy_max_ul_rate::du_srs_policy_max_ul_rate(span<const du_cell_config>
 
     const auto srs_period_slots = static_cast<unsigned>(cell.cell_cfg.srs_cfg.srs_period.value());
     // Reserve the size of the vector and set the SRS counter of each offset to 0.
+    cell.slot_resource_cnt.reserve(srs_period_slots);
     cell.slot_resource_cnt.assign(srs_period_slots, 0U);
     cell.srs_res_offset_free_list.reserve(du_srs_policy_max_ul_rate::cell_context::max_nof_srs_res);
     cell.nof_res_per_symb_interval = static_cast<unsigned>(cell.cell_cfg.srs_cfg.tx_comb) *
@@ -152,42 +154,33 @@ du_srs_policy_max_ul_rate::du_srs_policy_max_ul_rate(span<const du_cell_config>
       }
 
       // 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())) {
+      if (cell_cfg_list_[primary_cell_index].tdd_ul_dl_cfg_common.has_value() and
+          not is_ul_slot(offset, cell_cfg_list_[primary_cell_index].tdd_ul_dl_cfg_common.value())) {
         continue;
       }
 
       for (auto& res : cell.cell_srs_res_list) {
         // 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
+        if (cell_cfg_list_[primary_cell_index].tdd_ul_dl_cfg_common.has_value() and
+            is_partially_ul_slot(offset, cell_cfg_list_[primary_cell_index].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.
+          const auto&    tdd_cfg    = cell_cfg_list_[primary_cell_index].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.
-          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(),
-                         max_srs_symbols);
-            if (res.symbols.start() < NOF_OFDM_SYM_PER_SLOT_NORMAL_CP - nof_ul_symbols_for_srs) {
-              continue;
-            }
-          }
-          // This is the fully-UL slot case: check if the SRS can be placed in the UL symbols of the slot.
-          else if (res.symbols.start() <
-                   NOF_OFDM_SYM_PER_SLOT_NORMAL_CP - cell.cell_cfg.srs_cfg.max_nof_symbols.to_uint()) {
+          static constexpr unsigned max_srs_symbols = 6U;
+          const unsigned            nof_ul_symbols_for_srs =
+              std::min(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;
           }
         }
-        // FDD case.
-        else {
-          if (res.symbols.start() < NOF_OFDM_SYM_PER_SLOT_NORMAL_CP - cell.cell_cfg.srs_cfg.max_nof_symbols.to_uint()) {
-            continue;
-          }
+        // NOTE: for TDD, the offset that are not UL slots are skipped above.
+        // FDD case and TDD case for fully-UL slot.
+        else if (res.symbols.start() <
+                 NOF_OFDM_SYM_PER_SLOT_NORMAL_CP - cell.cell_cfg.srs_cfg.max_nof_symbols.to_uint()) {
+          continue;
         }
         cell.srs_res_offset_free_list.emplace_back(res.cell_res_id, offset);
       }
@@ -197,48 +190,50 @@ du_srs_policy_max_ul_rate::du_srs_policy_max_ul_rate(span<const du_cell_config>
 
 bool du_srs_policy_max_ul_rate::alloc_resources(cell_group_config& cell_grp_cfg)
 {
+  static constexpr unsigned primary_cell_index = 0U;
+
   // 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() 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");
+  srsran_assert(cells[cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.cell_index]
+                        .cell_cfg.ue_ded_serv_cell_cfg.ul_config.has_value() and
+                    not cell_grp_cfg.cells[primary_cell_index].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);
+  cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.emplace(
+      cells[cell_grp_cfg.cells[primary_cell_index].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()) {
+  if (not cells[primary_cell_index].cell_cfg.srs_cfg.srs_period.has_value()) {
     return true;
   }
 
   // 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();
-  auto&       free_srs_list = cells[cell_grp_cfg.cells[0].serv_cell_cfg.cell_index].srs_res_offset_free_list;
+  cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.emplace(
+      cells[cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.cell_index].default_srs_cfg);
+  srs_config& ue_srs_cfg = cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.value();
+  auto& free_srs_list = cells[cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.cell_index].srs_res_offset_free_list;
 
   // 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();
+    cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.reset();
     return false;
   }
 
   // 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();
+  auto srs_res_id_offset = cells[primary_cell_index].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();
+    cell_grp_cfg.cells[primary_cell_index].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);
+  const auto& du_res_it = cells[primary_cell_index].get_du_srs_res_cfg(srs_res_id_offset->first);
 
-  if (du_res_it == cells[0].cell_srs_res_list.end()) {
+  if (du_res_it == cells[primary_cell_index].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();
+    cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.reset();
     return false;
   }
 
@@ -250,12 +245,13 @@ bool du_srs_policy_max_ul_rate::alloc_resources(cell_group_config& cell_grp_cfg)
   // NOTE: given that there is only 1 SRS resource per UE, we can assume that the SRS resource ID is 0.
   only_ue_srs_res.id.cell_res_id = du_res.cell_res_id;
   only_ue_srs_res.id.ue_res_id   = static_cast<srs_config::srs_res_id>(0U);
-  srsran_assert(cells[0].cell_cfg.ul_carrier.nof_ant == 1 or cells[0].cell_cfg.ul_carrier.nof_ant == 2 or
-                    cells[0].cell_cfg.ul_carrier.nof_ant == 4,
+  srsran_assert(cells[primary_cell_index].cell_cfg.ul_carrier.nof_ant == 1 or
+                    cells[primary_cell_index].cell_cfg.ul_carrier.nof_ant == 2 or
+                    cells[primary_cell_index].cell_cfg.ul_carrier.nof_ant == 4,
                 "The number of UL antenna ports is not valid");
   only_ue_srs_res.nof_ports =
-      static_cast<srs_config::srs_resource::nof_srs_ports>(cells[0].cell_cfg.ul_carrier.nof_ant);
-  only_ue_srs_res.tx_comb.size                 = cells[0].cell_cfg.srs_cfg.tx_comb;
+      static_cast<srs_config::srs_resource::nof_srs_ports>(cells[primary_cell_index].cell_cfg.ul_carrier.nof_ant);
+  only_ue_srs_res.tx_comb.size                 = cells[primary_cell_index].cell_cfg.srs_cfg.tx_comb;
   only_ue_srs_res.tx_comb.tx_comb_offset       = du_res.tx_comb_offset.to_uint();
   only_ue_srs_res.tx_comb.tx_comb_cyclic_shift = du_res.cs;
   only_ue_srs_res.freq_domain_pos              = du_res.freq_dom_position;
@@ -264,16 +260,18 @@ bool du_srs_policy_max_ul_rate::alloc_resources(cell_group_config& cell_grp_cfg)
   only_ue_srs_res.sequence_id                  = du_res.sequence_id;
 
   // Update the SRS configuration with the parameters that are common to the cell.
-  only_ue_srs_res.freq_hop.c_srs = cells[cell_grp_cfg.cells[0].serv_cell_cfg.cell_index].srs_common_params.c_srs;
+  only_ue_srs_res.freq_hop.c_srs =
+      cells[cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.cell_index].srs_common_params.c_srs;
   // We assume that the frequency hopping is disabled and that the SRS occupies all possible RBs within the BWP. Refer
   // to Section 6.4.1.4.3, TS 38.211.
   only_ue_srs_res.freq_hop.b_srs = 0U;
   only_ue_srs_res.freq_hop.b_hop = 0U;
   only_ue_srs_res.freq_domain_shift =
-      cells[cell_grp_cfg.cells[0].serv_cell_cfg.cell_index].srs_common_params.freq_shift;
+      cells[cell_grp_cfg.cells[primary_cell_index].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)});
+  only_ue_srs_res.periodicity_and_offset.emplace(
+      srs_config::srs_periodicity_and_offset{.period = cells[primary_cell_index].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;
@@ -282,12 +280,12 @@ bool du_srs_policy_max_ul_rate::alloc_resources(cell_group_config& cell_grp_cfg)
   free_srs_list.erase(srs_res_id_offset);
 
   // Update the SRS resource per slot counter.
-  ++cells[0].slot_resource_cnt[srs_offset];
+  ++cells[primary_cell_index].slot_resource_cnt[srs_offset];
 
   return true;
 }
 
-std::vector<std::pair<unsigned, unsigned>>::const_iterator
+std::vector<du_srs_policy_max_ul_rate::cell_context::pair_res_id_offset>::const_iterator
 du_srs_policy_max_ul_rate::cell_context::find_optimal_ue_srs_resource()
 {
   // The weights assigned here can be set to arbitrarily value, as long as:
@@ -301,7 +299,7 @@ du_srs_policy_max_ul_rate::cell_context::find_optimal_ue_srs_resource()
 
   const auto weight_function = [&](const pair_res_id_offset& srs_res) {
     if (cell_cfg.tdd_ul_dl_cfg_common.has_value() and
-        is_partually_ul_slot(srs_res.second, cell_cfg.tdd_ul_dl_cfg_common.value())) {
+        is_partially_ul_slot(srs_res.second, cell_cfg.tdd_ul_dl_cfg_common.value())) {
       return 0U;
     }
 
@@ -338,24 +336,27 @@ du_srs_policy_max_ul_rate::cell_context::find_optimal_ue_srs_resource()
 
 void du_srs_policy_max_ul_rate::dealloc_resources(cell_group_config& cell_grp_cfg)
 {
-  if (not cells[0].cell_cfg.srs_cfg.srs_period.has_value() or
-      not cell_grp_cfg.cells[0].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.has_value()) {
+  static constexpr unsigned primary_cell_index = 0U;
+
+  if (not cells[primary_cell_index].cell_cfg.srs_cfg.srs_period.has_value() or
+      not cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.has_value()) {
     return;
   }
 
-  const auto& ue_srs_cfg    = cell_grp_cfg.cells[0].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.value();
-  auto&       free_srs_list = cells[cell_grp_cfg.cells[0].serv_cell_cfg.cell_index].srs_res_offset_free_list;
+  const auto& ue_srs_cfg = cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.value();
+  auto& free_srs_list = cells[cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.cell_index].srs_res_offset_free_list;
 
   for (const auto& srs_res : ue_srs_cfg.srs_res_list) {
     const unsigned offset_to_deallocate = srs_res.periodicity_and_offset.value().offset;
     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] != 0, "The offset is expected to be non-zero");
-    --cells[0].slot_resource_cnt[offset_to_deallocate];
+    srsran_assert(cells[primary_cell_index].slot_resource_cnt[offset_to_deallocate] != 0,
+                  "The offset is expected to be non-zero");
+    --cells[primary_cell_index].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
   // 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();
+  cell_grp_cfg.cells[primary_cell_index].serv_cell_cfg.ul_config->init_ul_bwp.srs_cfg.reset();
 }

lib/ran/tdd_ul_dl_config.cpp

@@ -68,6 +68,12 @@ bool srsran::is_tdd_full_ul_slot(const tdd_ul_dl_config_common& cfg, unsigned sl
   return nof_active_symbols(cfg, slot_index, cyclic_prefix::NORMAL, false) == NOF_OFDM_SYM_PER_SLOT_NORMAL_CP;
 }
 
+bool srsran::is_tdd_partial_ul_slot(const tdd_ul_dl_config_common& cfg, unsigned slot_index)
+{
+  const unsigned nof_symbols = nof_active_symbols(cfg, slot_index, cyclic_prefix::NORMAL, false);
+  return nof_symbols != 0U and nof_symbols != NOF_OFDM_SYM_PER_SLOT_NORMAL_CP;
+}
+
 ofdm_symbol_range
 srsran::get_active_tdd_dl_symbols(const tdd_ul_dl_config_common& cfg, unsigned slot_index, cyclic_prefix cp)
 {

lib/scheduler/config/serving_cell_config_factory.cpp

@@ -498,8 +498,7 @@ srs_config srsran::config_helpers::make_default_srs_config(const cell_config_bui
   res.freq_hop.b_hop = 0;
   res.grp_or_seq_hop = srs_group_or_sequence_hopping::neither;
   res.res_type       = srs_resource_type::aperiodic;
-
-  res.sequence_id = params.pci;
+  res.sequence_id    = params.pci;
 
   cfg.srs_res_set_list.emplace_back();
   // TODO: Verify correctness of the config based on what we support.