cu_cp: improve initial ue creation

Author: FabianEckermann

lib/cu_cp/du_processor/du_processor_impl.cpp

@@ -159,50 +159,47 @@ bool du_processor_impl::create_rrc_ue(cu_cp_ue&                              ue,
 ue_rrc_context_creation_outcome
 du_processor_impl::handle_ue_rrc_context_creation_request(const ue_rrc_context_creation_request& req)
 {
-  srsran_assert(req.c_rnti != rnti_t::INVALID_RNTI, "ue={}: Invalid C-RNTI", req.ue_index);
+  srsran_assert(req.c_rnti != rnti_t::INVALID_RNTI, "ue={} c-rnti={}: Invalid C-RNTI", req.ue_index, req.c_rnti);
+
+  // Check that creation message is valid
+  const du_cell_configuration* pcell = cfg.du_cfg_hdlr->get_context().find_cell(req.cgi);
+  if (pcell == nullptr) {
+    logger.warning("ue={} c-rnti={}: Could not find cell with NCI={}", req.ue_index, req.c_rnti, req.cgi.nci);
+    // Return the RRCReject container
+    return make_unexpected(rrc_du_adapter.on_rrc_reject_required());
+  }
+  const pci_t pci = pcell->pci;
 
   ue_index_t ue_index = req.ue_index;
+  cu_cp_ue*  ue       = nullptr;
 
   if (ue_index == ue_index_t::invalid) {
     // Add new CU-CP UE
-    ue_index = ue_mng.add_ue(cfg.du_index);
+    ue_index = ue_mng.add_ue(cfg.du_index, cfg.du_cfg_hdlr->get_context().id, pci, req.c_rnti, pcell->cell_index);
     if (ue_index == ue_index_t::invalid) {
       logger.warning("CU-CP UE creation failed");
       return make_unexpected(rrc_du_adapter.on_rrc_reject_required());
     }
+    ue = ue_mng.find_ue(ue_index);
 
     /// NOTE: From this point on the UE exists in the UE manager and must be removed if any error occurs.
-  }
-
-  // Lambda, that removes the UE from the UE manager and returns a RRCReject container.
-  auto return_failure = [this](ue_index_t ue_id) {
-    // Remove the UE from the UE manager
-    ue_mng.remove_ue(ue_id);
-    // Return the RRCReject container
-    return make_unexpected(rrc_du_adapter.on_rrc_reject_required());
-  };
 
-  // Check that creation message is valid
-  const du_cell_configuration* pcell = cfg.du_cfg_hdlr->get_context().find_cell(req.cgi);
-  if (pcell == nullptr) {
-    logger.warning("ue={}: Could not find cell with NCI={}", ue_index, req.cgi.nci);
-    return return_failure(ue_index);
-  }
-  const pci_t pci = pcell->pci;
-
-  // Create new UE RRC context
-  cu_cp_ue* ue = ue_mng.set_ue_du_context(ue_index, cfg.du_cfg_hdlr->get_context().id, pci, req.c_rnti);
-  if (ue == nullptr) {
-    logger.warning("ue={}: Could not create UE context", ue_index);
-    // A UE with the same PCI and RNTI already exists, so we don't remove it and only reject the new UE.
-    return make_unexpected(rrc_du_adapter.on_rrc_reject_required());
+  } else {
+    ue = ue_mng.set_ue_du_context(ue_index, cfg.du_cfg_hdlr->get_context().id, pci, req.c_rnti, pcell->cell_index);
+    if (ue == nullptr) {
+      logger.warning("ue={}: Could not create UE context", ue_index);
+      // A UE with the same PCI and RNTI already exists, so we don't remove it and only reject the new UE.
+      return make_unexpected(rrc_du_adapter.on_rrc_reject_required());
+    }
   }
-  ue->set_pcell_index(pcell->cell_index);
 
   // Create RRC UE. If the DU-to-CU-RRC-Container is empty, the UE will be rejected.
   if (not create_rrc_ue(*ue, req.c_rnti, req.cgi, req.du_to_cu_rrc_container.copy(), std::move(req.prev_context))) {
     logger.warning("ue={}: Could not create RRC UE object", ue_index);
-    return return_failure(ue_index);
+    // Remove the UE from the UE manager
+    ue_mng.remove_ue(ue_index);
+    // Return the RRCReject container
+    return make_unexpected(rrc_du_adapter.on_rrc_reject_required());
   }
   rrc_ue_interface* rrc_ue       = rrc->find_ue(ue_index);
   f1ap_rrc_ue_adapters[ue_index] = {};

lib/cu_cp/ue_manager/cu_cp_ue_impl.cpp

@@ -18,20 +18,30 @@ cu_cp_ue::cu_cp_ue(ue_index_t                     ue_index_,
                    const up_resource_manager_cfg& up_cfg,
                    const security_manager_config& sec_cfg,
                    ue_task_scheduler_impl         task_sched_,
-                   pci_t                          pci_,
-                   rnti_t                         c_rnti_) :
+                   std::optional<gnb_du_id_t>     du_id_,
+                   std::optional<pci_t>           pci_,
+                   std::optional<rnti_t>          c_rnti_,
+                   std::optional<du_cell_index_t> pcell_index_) :
   ue_index(ue_index_),
   task_sched(std::move(task_sched_)),
   up_mng(up_cfg),
   sec_mng(sec_cfg),
   rrc_ue_cu_cp_ev_notifier(ue_index)
 {
-  if (pci_ != INVALID_PCI) {
-    pci = pci_;
+  if (du_id_.has_value() && du_id_.value() != gnb_du_id_t::invalid) {
+    ue_ctxt.du_id = du_id_.value();
   }
 
-  if (c_rnti_ != rnti_t::INVALID_RNTI) {
-    ue_ctxt.crnti = c_rnti_;
+  if (pci_.has_value() && pci_.value() != INVALID_PCI) {
+    pci = pci_.value();
+  }
+
+  if (c_rnti_.has_value() && c_rnti_.value() != rnti_t::INVALID_RNTI) {
+    ue_ctxt.crnti = c_rnti_.value();
+  }
+
+  if (pcell_index_.has_value() && pcell_index_.value() != du_cell_index_t::invalid) {
+    pcell_index = pcell_index_.value();
   }
 
   ue_ctxt.du_idx = du_index_;
@@ -41,7 +51,7 @@ cu_cp_ue::cu_cp_ue(ue_index_t                     ue_index_,
 }
 
 /// \brief Update a UE with PCI and/or C-RNTI.
-void cu_cp_ue::update_du_ue(gnb_du_id_t du_id_, pci_t pci_, rnti_t c_rnti_)
+void cu_cp_ue::update_du_ue(gnb_du_id_t du_id_, pci_t pci_, rnti_t c_rnti_, du_cell_index_t pcell_index_)
 {
   if (du_id_ != gnb_du_id_t::invalid) {
     ue_ctxt.du_id = du_id_;
@@ -54,6 +64,10 @@ void cu_cp_ue::update_du_ue(gnb_du_id_t du_id_, pci_t pci_, rnti_t c_rnti_)
   if (c_rnti_ != rnti_t::INVALID_RNTI) {
     ue_ctxt.crnti = c_rnti_;
   }
+
+  if (pcell_index_ != du_cell_index_t::invalid) {
+    pcell_index = pcell_index_;
+  }
 }
 
 /// \brief Set/update the measurement context of the UE.

lib/cu_cp/ue_manager/cu_cp_ue_impl.h

@@ -18,6 +18,7 @@
 #include "../up_resource_manager/up_resource_manager_impl.h"
 #include "cu_cp_ue_impl_interface.h"
 #include "ue_task_scheduler_impl.h"
+#include <optional>
 #include <unordered_map>
 
 namespace srsran {
@@ -43,8 +44,10 @@ class cu_cp_ue : public cu_cp_ue_impl_interface
            const up_resource_manager_cfg& up_cfg,
            const security_manager_config& sec_cfg,
            ue_task_scheduler_impl         task_sched_,
-           pci_t                          pci_    = INVALID_PCI,
-           rnti_t                         c_rnti_ = rnti_t::INVALID_RNTI);
+           std::optional<gnb_du_id_t>     du_id_       = std::nullopt,
+           std::optional<pci_t>           pci_         = std::nullopt,
+           std::optional<rnti_t>          c_rnti_      = std::nullopt,
+           std::optional<du_cell_index_t> pcell_index_ = std::nullopt);
 
   /// \brief Cancel all pending UE tasks.
   void stop();
@@ -82,9 +85,10 @@ class cu_cp_ue : public cu_cp_ue_impl_interface
   cell_meas_manager_ue_context& get_meas_context() { return meas_context; }
 
   /// \brief Update a UE with PCI and/or C-RNTI.
-  void update_du_ue(gnb_du_id_t du_id_  = gnb_du_id_t::invalid,
-                    pci_t       pci_    = INVALID_PCI,
-                    rnti_t      c_rnti_ = rnti_t::INVALID_RNTI);
+  void update_du_ue(gnb_du_id_t     du_id_       = gnb_du_id_t::invalid,
+                    pci_t           pci_         = INVALID_PCI,
+                    rnti_t          c_rnti_      = rnti_t::INVALID_RNTI,
+                    du_cell_index_t pcell_index_ = du_cell_index_t::invalid);
 
   /// \brief Set/update the measurement context of the UE.
   void update_meas_context(cell_meas_manager_ue_context meas_ctxt);

lib/cu_cp/ue_manager/ue_manager_impl.cpp

@@ -33,8 +33,37 @@ void ue_manager::stop()
   ue_task_scheds.stop();
 }
 
-ue_index_t ue_manager::add_ue(du_index_t du_index)
+ue_index_t ue_manager::add_ue(du_index_t                     du_index,
+                              std::optional<gnb_du_id_t>     du_id,
+                              std::optional<pci_t>           pci,
+                              std::optional<rnti_t>          rnti,
+                              std::optional<du_cell_index_t> pcell_index)
 {
+  if (du_index == du_index_t::invalid) {
+    logger.warning("CU-CP UE creation Failed. Cause: Invalid DU index={}", du_index);
+    return ue_index_t::invalid;
+  }
+
+  if (du_id.has_value() && du_id.value() == gnb_du_id_t::invalid) {
+    logger.warning("CU-CP UE creation Failed. Cause: Invalid gNB-DU ID={}", du_id.value());
+    return ue_index_t::invalid;
+  }
+
+  if (pci.has_value() && pci.value() == INVALID_PCI) {
+    logger.warning("CU-CP UE creation Failed. Cause: Invalid pci={}", pci.value());
+    return ue_index_t::invalid;
+  }
+
+  if (rnti.has_value() && rnti.value() == rnti_t::INVALID_RNTI) {
+    logger.warning("CU-CP UE creation Failed. Cause: Invalid rnti={}", rnti.value());
+    return ue_index_t::invalid;
+  }
+
+  if (pcell_index.has_value() && pcell_index.value() == du_cell_index_t::invalid) {
+    logger.warning("CU-CP UE creation Failed. Cause: Invalid pcell_index={}", pcell_index.value());
+    return ue_index_t::invalid;
+  }
+
   if (ues.size() == ue_config.max_nof_supported_ues) {
     logger.warning("CU-CP UE creation Failed. Cause: Maximum number of UEs {} supported by the CU-CP has been reached",
                    ue_config.max_nof_supported_ues);
@@ -53,9 +82,20 @@ ue_index_t ue_manager::add_ue(du_index_t du_index)
   // Create UE object
   ues.emplace(std::piecewise_construct,
               std::forward_as_tuple(new_ue_index),
-              std::forward_as_tuple(new_ue_index, du_index, up_config, sec_config, std::move(ue_sched)));
+              std::forward_as_tuple(
+                  new_ue_index, du_index, up_config, sec_config, std::move(ue_sched), du_id, pci, rnti, pcell_index));
+
+  // Add PCI and RNTI to lookup.
+  if (pci.has_value() && rnti.has_value()) {
+    pci_rnti_to_ue_index.emplace(std::make_tuple(pci.value(), rnti.value()), new_ue_index);
+  }
 
-  logger.info("ue={}: Created new CU-CP UE", new_ue_index);
+  logger.info("ue={}{}{}{}{}: Created new CU-CP UE",
+              new_ue_index,
+              du_id.has_value() ? fmt::format(" gnb_du_id={}", du_id.value()) : "",
+              pci.has_value() ? fmt::format(" pci={}", pci.value()) : "",
+              rnti.has_value() ? fmt::format(" rnti={}", rnti.value()) : "",
+              pcell_index.has_value() ? fmt::format(" pcell_index={}", pcell_index.value()) : "");
 
   return new_ue_index;
 }
@@ -120,11 +160,16 @@ ue_task_scheduler* ue_manager::find_ue_task_scheduler(ue_index_t ue_index)
 
 // du processor
 
-cu_cp_ue* ue_manager::set_ue_du_context(ue_index_t ue_index, gnb_du_id_t du_id, pci_t pci, rnti_t rnti)
+cu_cp_ue* ue_manager::set_ue_du_context(ue_index_t      ue_index,
+                                        gnb_du_id_t     du_id,
+                                        pci_t           pci,
+                                        rnti_t          rnti,
+                                        du_cell_index_t pcell_index)
 {
   srsran_assert(ue_index != ue_index_t::invalid, "Invalid ue_index={}", ue_index);
   srsran_assert(pci != INVALID_PCI, "Invalid pci={}", pci);
   srsran_assert(rnti != rnti_t::INVALID_RNTI, "Invalid rnti={}", rnti);
+  srsran_assert(pcell_index != du_cell_index_t::invalid, "Invalid pcell_index={}", pcell_index);
 
   // check if ue_index is in db
   if (ues.find(ue_index) == ues.end()) {
@@ -139,12 +184,13 @@ cu_cp_ue* ue_manager::set_ue_du_context(ue_index_t ue_index, gnb_du_id_t du_id,
   }
 
   auto& ue = ues.at(ue_index);
-  ue.update_du_ue(du_id, pci, rnti);
+  ue.update_du_ue(du_id, pci, rnti, pcell_index);
 
   // Add PCI and RNTI to lookup.
   pci_rnti_to_ue_index.emplace(std::make_tuple(pci, rnti), ue_index);
 
-  logger.debug("ue={}: Updated UE with pci={} and rnti={}", ue_index, pci, rnti);
+  logger.debug(
+      "ue={}: Updated UE with gnb_du_id={} pci={} rnti={} pcell_index={}", ue_index, du_id, pci, rnti, pcell_index);
 
   return &ue;
 }

lib/cu_cp/ue_manager/ue_manager_impl.h

@@ -19,6 +19,7 @@
 #include "ue_task_scheduler_impl.h"
 #include "srsran/cu_cp/security_manager_config.h"
 #include "srsran/cu_cp/ue_configuration.h"
+#include <optional>
 #include <unordered_map>
 
 namespace srsran {
@@ -70,11 +71,26 @@ class ue_manager : public ue_metrics_handler
 
   /// \brief Allocate resources for the UE in the CU-CP.
   /// \param[in] du_index Index of the DU the UE is connected to.
+  /// \param[in] du_id The gNB-DU ID of the DU the UE is connected to.
+  /// \param[in] pci The PCI of the cell the UE is connected to.
+  /// \param[in] rnti The RNTI of the UE.
+  /// \param[in] pcell_index The index of the PCell the UE is connected to.
   /// \return ue_index of the created UE or ue_index_t::invalid in case of failure.
-  ue_index_t add_ue(du_index_t du_index);
+  ue_index_t add_ue(du_index_t                     du_index,
+                    std::optional<gnb_du_id_t>     du_id       = std::nullopt,
+                    std::optional<pci_t>           pci         = std::nullopt,
+                    std::optional<rnti_t>          rnti        = std::nullopt,
+                    std::optional<du_cell_index_t> pcell_index = std::nullopt);
 
   /// \brief Set the DU context of the UE.
-  cu_cp_ue* set_ue_du_context(ue_index_t ue_index, gnb_du_id_t du_id, pci_t pci, rnti_t rnti);
+  /// \param[in] ue_index Index of the UE.
+  /// \param[in] du_id The gNB-DU ID of the DU the UE is connected to.
+  /// \param[in] pci The PCI of the cell the UE is connected to.
+  /// \param[in] rnti The RNTI of the UE.
+  /// \param[in] pcell_index The index of the PCell the UE is connected to.
+  /// \return Pointer to the DU UE if found, nullptr otherwise.
+  cu_cp_ue*
+  set_ue_du_context(ue_index_t ue_index, gnb_du_id_t du_id, pci_t pci, rnti_t rnti, du_cell_index_t pcell_index);
 
   /// \brief Find the UE with the given UE index, thats DU context is set up.
   /// \param[in] ue_index Index of the UE to be found.

tests/unittests/cu_cp/mobility/handover_reconfiguration_routine_test.cpp

@@ -25,14 +25,16 @@ class handover_reconfiguration_routine_test : public mobility_test
 
   void create_ues(bool procedure_outcome, unsigned transaction_id_)
   {
-    ue_index_t source_ue_index = get_ue_manager()->add_ue(source_du_index);
-    source_ue = get_ue_manager()->set_ue_du_context(source_ue_index, int_to_gnb_du_id(0), source_pci, source_rnti);
+    ue_index_t source_ue_index =
+        get_ue_manager()->add_ue(source_du_index, int_to_gnb_du_id(0), source_pci, source_rnti, du_cell_index_t::min);
+    source_ue = get_ue_manager()->find_ue(source_ue_index);
     ASSERT_NE(source_ue, nullptr);
     source_rrc_ue_notifier.set_transaction_id(transaction_id_);
     source_ue->set_rrc_ue_notifier(source_rrc_ue_notifier);
 
-    ue_index_t target_ue_index = get_ue_manager()->add_ue(target_du_index);
-    target_ue = get_ue_manager()->set_ue_du_context(target_ue_index, int_to_gnb_du_id(0), target_pci, target_rnti);
+    ue_index_t target_ue_index =
+        get_ue_manager()->add_ue(target_du_index, int_to_gnb_du_id(0), target_pci, target_rnti, du_cell_index_t::min);
+    target_ue = get_ue_manager()->find_ue(target_ue_index);
     ASSERT_NE(target_ue, nullptr);
     cu_cp_handler.set_rrc_reconfiguration_outcome(procedure_outcome);
     target_ue->set_rrc_ue_notifier(target_rrc_ue_notifier);
@@ -61,15 +63,15 @@ class handover_reconfiguration_routine_test : public mobility_test
 private:
   // source UE parameters.
   du_index_t                                         source_du_index = uint_to_du_index(0);
-  unsigned                                           source_pci      = 1;
+  pci_t                                              source_pci      = 1;
   rnti_t                                             source_rnti     = to_rnti(0x4601);
   dummy_du_processor_rrc_ue_control_message_notifier source_rrc_ue_notifier;
   dummy_f1ap_ue_context_manager                      source_f1ap_ue_ctxt_mng;
   cu_cp_ue*                                          source_ue = nullptr;
 
   // target UE parameters.
   du_index_t                                         target_du_index = uint_to_du_index(1);
-  unsigned                                           target_pci      = 2;
+  pci_t                                              target_pci      = 2;
   rnti_t                                             target_rnti     = to_rnti(0x4601);
   dummy_du_processor_rrc_ue_control_message_notifier target_rrc_ue_notifier;
   cu_cp_ue*                                          target_ue = nullptr;

tests/unittests/cu_cp/routines/ue_context_release_routine_test.cpp

@@ -33,10 +33,9 @@ class ue_context_release_test : public cu_cp_routine_manager_test
 
   ue_index_t add_ue(pci_t pci, rnti_t c_rnti)
   {
-    ue_index_t ue_index = ue_mng.add_ue(du_index_t::min);
-    cu_cp_ue*  ue       = ue_mng.set_ue_du_context(ue_index, int_to_gnb_du_id(0), pci, c_rnti);
+    ue_index_t ue_index = ue_mng.add_ue(du_index_t::min, int_to_gnb_du_id(0), pci, c_rnti, du_cell_index_t::min);
+    cu_cp_ue*  ue       = ue_mng.find_ue(ue_index);
     // Set parameters from creation message
-    ue->set_pcell_index(du_cell_index_t::min);
     ue->set_rrc_ue_notifier(rrc_ue_ctrl_notifier);
     ue->set_rrc_ue_srb_notifier(rrc_ue_srb_ctrl_notifier);