du: first version of DU SRS resource manager

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

Author: carlo-gal

lib/du/du_high/du_manager/ran_resource_management/CMakeLists.txt

@@ -10,6 +10,7 @@ add_library(du_resource_manager
         du_bearer_resource_manager.cpp
         du_pucch_resource_manager.cpp
         du_ran_resource_manager_impl.cpp
+        du_srs_resource_manager.cpp
         pucch_resource_generator.cpp
         srs_resource_generator.cpp
         ue_capability_manager.cpp)

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

@@ -47,7 +47,8 @@ du_ran_resource_manager_impl::du_ran_resource_manager_impl(span<const du_cell_co
   logger(srslog::fetch_basic_logger("DU-MNG")),
   test_cfg(test_cfg_),
   pucch_res_mng(cell_cfg_list, scheduler_cfg.ue.max_pucchs_per_slot),
-  bearer_res_mng(srb_config, qos_config, logger)
+  bearer_res_mng(srb_config, qos_config, logger),
+  srs_res_mng(std::make_unique<du_srs_policy_max_ul_th>(cell_cfg_list))
 {
 }
 
@@ -164,7 +165,7 @@ 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;
 
     if (not pucch_res_mng.alloc_resources(ue_res.cell_group)) {
-      // Deallocate dedicated Search Spaces.
+      // Deallocate previously allocated SRS + dedicated Search Spaces.
       ue_res.cell_group.cells[0].serv_cell_cfg.init_dl_bwp.pdcch_cfg->search_spaces.clear();
       return make_unexpected(fmt::format("Unable to allocate dedicated PUCCH resources for cell={}", cell_index));
     }

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

@@ -13,6 +13,7 @@
 #include "du_bearer_resource_manager.h"
 #include "du_pucch_resource_manager.h"
 #include "du_ran_resource_manager.h"
+#include "du_srs_resource_manager.h"
 #include "ue_capability_manager.h"
 #include "srsran/ran/qos/five_qi.h"
 
@@ -107,6 +108,8 @@ class du_ran_resource_manager_impl : public du_ran_resource_manager
 
   /// Allocator of UE bearer resources.
   du_bearer_resource_manager bearer_res_mng;
+
+  std::unique_ptr<du_srs_resource_manager> srs_res_mng;
 };
 
 } // namespace srs_du

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

@@ -0,0 +1,245 @@
+/*
+ *
+ * Copyright 2021-2024 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#include "du_srs_resource_manager.h"
+#include "du_ue_resource_config.h"
+#include "srsran/ran/srs/srs_bandwidth_configuration.h"
+
+using namespace srsran;
+using namespace srs_du;
+
+static std::optional<unsigned> compute_srs_bw_param(unsigned nof_ul_rbs)
+{
+  // Iterate over Table 6.4.1.4.3-1, TS 38.211, and find the first \f$C_{SRS}\f$ value that provides the
+  // greatest \f$m_{SRS,0}\f$ such that it is less than or equal to number of UL RBs.
+
+  // As per Table 6.4.1.4.3-1, TS 38.211, the maximum value of \f$C_{SRS}\f$ is 63.
+  constexpr unsigned max_non_valid_c_srs = 64;
+  constexpr uint8_t  b_srs_0             = 0;
+  for (uint8_t c_srs = 0; c_srs != max_non_valid_c_srs; c_srs++) {
+    auto srs_params = srs_configuration_get(c_srs, b_srs_0);
+    srsran_assert(srs_params.has_value(), "The SRS is not valid");
+
+    if (c_srs == 0 and srs_params.value().m_srs > nof_ul_rbs) {
+      srsran_assertion_failure("C_SRS is not compatible with the number of UL RBs");
+      return std::nullopt;
+    }
+    if (srs_params.value().m_srs == nof_ul_rbs) {
+      return c_srs;
+    }
+    if (srs_params.value().m_srs > nof_ul_rbs) {
+      return c_srs - 1;
+    }
+  }
+  return max_non_valid_c_srs - 1;
+}
+
+// Helper that returns the frequency shift value for the SRS; the value is computed in such a way that the SRS resources
+// 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.
+  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,
+                      "The SRS configuration is not valid");
+
+  return (nof_ul_rbs - srs_params.value().m_srs) / 2;
+}
+
+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;
+}
+
+static bool is_partually_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 and
+         srsran::get_active_tdd_dl_symbols(tdd_cfg, slot_index, cyclic_prefix::NORMAL).length() !=
+             NOF_OFDM_SYM_PER_SLOT_NORMAL_CP;
+}
+
+du_srs_policy_max_ul_th::du_srs_policy_max_ul_th(span<const du_cell_config> cell_cfg_list_) :
+  cells(cell_cfg_list_.begin(), cell_cfg_list_.end())
+{
+  for (auto& cell : cells) {
+    std::optional<unsigned> c_srs =
+        compute_srs_bw_param(cell.cell_cfg.ul_cfg_common.init_ul_bwp.generic_params.crbs.length()).value();
+    srsran_assert(c_srs.has_value(), "SRS parameters didn't provide a valid C_SRS value");
+    cell.srs_common_params.c_srs = c_srs.value();
+    std::optional<unsigned> freq_shift =
+        compute_freq_shift(c_srs.value(), cell.cell_cfg.ul_cfg_common.init_ul_bwp.generic_params.crbs.length());
+    srsran_assert(freq_shift.has_value(), "SRS parameters didn't provide a valid freq_shift value");
+    cell.srs_common_params.freq_shift = freq_shift.value();
+
+    cell.cell_srs_res_list = generate_cell_srs_list(cell.cell_cfg);
+
+    const unsigned srs_period_slots = static_cast<unsigned>(cell.cell_cfg.srs_cfg.srs_period.value());
+    cell.slot_resource_cnt.reserve(srs_period_slots);
+
+    for (unsigned offset = 0; offset != srs_period_slots; ++offset) {
+      unsigned offset_res_cnt = 0U;
+      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()) {
+          // Verify whether the offset maps to a partially- or fully-UL slot.
+          if (not is_ul_slot(offset, cell_cfg_list_[0].tdd_ul_dl_cfg_common.value())) {
+            continue;
+          }
+          // 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) {
+              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()) {
+            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;
+          }
+        }
+        cell.srs_res_offset_free_list.push_back({res.cell_res_id, offset});
+        ++offset_res_cnt;
+      }
+      cell.slot_resource_cnt.push_back({0U, offset_res_cnt});
+    }
+  }
+}
+
+bool du_srs_policy_max_ul_th::alloc_resources(cell_group_config& cell_grp_cfg)
+{
+  // Allocation of SR PUCCH offset.
+  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;
+
+  // Verify where there are SRS resources to allocate a new UE.
+  if (free_srs_list.empty()) {
+    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()) {
+    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()) {
+    return false;
+  }
+
+  const auto& du_res = *du_res_it;
+
+  // Update the SRS configuration with the parameters that are specific to this resource and for this UE.
+  auto&          only_ue_srs_res = ue_srs_cfg.srs_res_list.front();
+  const unsigned srs_offset      = srs_res_id_offset->second;
+  // 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);
+  only_ue_srs_res.periodicity_and_offset.value().offset = srs_offset;
+  only_ue_srs_res.tx_comb.tx_comb_offset                = du_res.tx_comb_offset.to_uint();
+  only_ue_srs_res.freq_domain_pos                       = du_res.freq_dom_position;
+  only_ue_srs_res.res_mapping.start_pos                 = NOF_OFDM_SYM_PER_SLOT_NORMAL_CP - du_res.symbols.start() - 1;
+  only_ue_srs_res.res_mapping.nof_symb                  = static_cast<srs_nof_symbols>(du_res.symbols.length());
+  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_domain_shift =
+      cells[cell_grp_cfg.cells[0].serv_cell_cfg.cell_index].srs_common_params.freq_shift;
+
+  // 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;
+
+  // 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;
+
+  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:
+  // - 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).
+  static constexpr unsigned max_weight         = 100U;
+  static constexpr unsigned symbol_weight_base = 10U;
+
+  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())) {
+      return 0U;
+    }
+
+    // SRS res config.
+    const auto srs_res_cfg_it = get_du_srs_res_cfg(srs_res.first);
+
+    if (srs_res_cfg_it == cell_srs_res_list.end()) {
+      return max_weight;
+    }
+
+    // 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;
+
+    // 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;
+
+    return symb_weight - reuse_slot_discount;
+  };
+
+  auto optimal_res_it = std::min_element(
+      srs_res_offset_free_list.begin(),
+      srs_res_offset_free_list.end(),
+      [&weight_function](const std::pair<unsigned, unsigned>& lhs, const std::pair<unsigned, unsigned>& rhs) {
+        return weight_function(lhs) < weight_function(rhs);
+      });
+
+  return optimal_res_it;
+}
+
+void du_srs_policy_max_ul_th::dealloc_resources(cell_group_config& cell_grp_cfg)
+{
+  if (not cell_grp_cfg.cells[0].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;
+
+  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.push_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;
+  }
+}

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

@@ -0,0 +1,103 @@
+/*
+ *
+ * Copyright 2021-2024 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#pragma once
+
+#include "srs_resource_generator.h"
+#include "srsran/adt/optional.h"
+#include "srsran/du/du_cell_config.h"
+#include "srsran/ran/srs/srs_configuration.h"
+
+namespace srsran {
+namespace srs_du {
+
+struct cell_group_config;
+
+/// This abstract class defines the methods that the DU SRS resource manager must implement. The implementation of this
+/// class defines different policies for the SRS allocation.
+class du_srs_resource_manager
+{
+public:
+  virtual ~du_srs_resource_manager() = default;
+
+  /// \brief Allocate SRS resources for a given UE. The resources are stored in the UE's cell group config.
+  /// The function allocates the UE the resources from a common pool.
+  /// \return true if allocation was successful.
+  virtual bool alloc_resources(cell_group_config& cell_grp_cfg) = 0;
+
+  /// \brief Deallocate the SRS resources for a given UE and return the used resource to the common pool.
+  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.
+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_);
+
+  bool alloc_resources(cell_group_config& cell_grp_cfg) override;
+
+  void dealloc_resources(cell_group_config& cell_grp_cfg) override;
+
+private:
+  struct cell_context {
+    cell_context(const du_cell_config& cfg) :
+      cell_cfg(cfg), default_srs_cfg(cfg.ue_ded_serv_cell_cfg.ul_config.value().init_ul_bwp.srs_cfg.value()){};
+
+    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)
+    {
+      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; });
+    }
+
+    // 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
+    {
+      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;
+    }
+
+    // Parameters that are common to all cell SRS resources.
+    struct srs_cell_common {
+      unsigned c_srs;
+      unsigned freq_shift;
+    };
+
+    using pair_cnt_max = std::pair<unsigned, const unsigned>;
+
+    const du_cell_config& cell_cfg;
+    const srs_config      default_srs_cfg;
+    srs_cell_common       srs_common_params;
+    // List of all SRS resources available to the cell; these resources can be allocated over to different UEs over
+    // different offsets.
+    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;
+  };
+
+  // Contains the resources for the different cells of the DU.
+  static_vector<cell_context, MAX_NOF_DU_CELLS> cells;
+};
+
+} // namespace srs_du
+} // namespace srsran