du: support cell slice reconfiguration request

Author: jonathan-srs

include/srsran/mac/mac_cell_manager.h

@@ -72,6 +72,8 @@ struct mac_cell_reconfig_request {
   std::optional<mac_cell_positioning_measurement_request> positioning;
   /// If not empty, contains the new SI PDU to be updated.
   std::optional<mac_cell_sys_info_pdu_update> new_si_pdu_info;
+  /// If not empty, contains the updates to be applied to the RRM policies.
+  std::optional<du_cell_slice_reconfig_request> slice_reconf_req;
 };
 
 struct mac_cell_reconfig_response {

include/srsran/ran/rrm.h

@@ -10,13 +10,13 @@
 
 #pragma once
 
+#include "srsran/ran/du_types.h"
 #include "srsran/ran/plmn_identity.h"
 #include "srsran/ran/s_nssai.h"
 
 namespace srsran {
 
 /// Identifier of a RRM Policy Member.
-/// \remark See O-RAN.WG3.E2SM-RC-R003-v3.00 Section 8.4.3.6
 struct rrm_policy_member {
   plmn_identity plmn_id = plmn_identity::test_value();
   /// Single Network Slice Selection Assistance Information (S-NSSAI).
@@ -29,7 +29,7 @@ struct rrm_policy_member {
 };
 
 struct rrm_policy_ratio_group {
-  /// The resource type of interest for an RRM Policy
+  /// The resource type of interest for an RRM Policy.
   /// \remark See 3GPP TS 28.541, Section 4.4.1 Attribute properties.
   enum class resource_type_t { prb, prb_ul, prb_dl };
   resource_type_t resource_type = resource_type_t::prb;
@@ -43,4 +43,40 @@ struct rrm_policy_ratio_group {
   std::optional<unsigned> ded_prb_policy_ratio;
 };
 
+constexpr unsigned MAX_SLICE_RECONF_POLICIES = 16;
+
+/// Request to reconfigure slicing policies for a given DU cell.
+struct du_cell_slice_reconfig_request {
+  du_cell_index_t cell_index;
+  struct rrm_policy_config {
+    rrm_policy_member rrc_member;
+    unsigned          min_prb;
+    unsigned          max_prb;
+  };
+  static_vector<rrm_policy_config, MAX_SLICE_RECONF_POLICIES> rrm_policies;
+};
+
 } // namespace srsran
+
+namespace fmt {
+
+template <>
+struct formatter<srsran::rrm_policy_member> {
+  template <typename ParseContext>
+  auto parse(ParseContext& ctx)
+  {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const srsran::rrm_policy_member& member, FormatContext& ctx) const
+  {
+    return format_to(ctx.out(),
+                     "{{PLMN={}, SST={}, SD={}}}",
+                     member.plmn_id.to_string(),
+                     member.s_nssai.sst.value(),
+                     member.s_nssai.sd.value());
+  }
+};
+
+} // namespace fmt

include/srsran/scheduler/scheduler_configurator.h

@@ -109,6 +109,11 @@ struct sched_cell_configuration_request_message {
   metrics_config metrics;
 };
 
+/// Cell Reconfiguration Request.
+struct sched_cell_reconfiguration_request_message {
+  std::optional<du_cell_slice_reconfig_request> slice_reconf_req;
+};
+
 /// Parameters provided to the scheduler to configure the resource allocation of a specific UE.
 struct sched_ue_resource_alloc_config {
   /// Minimum and maximum PDSCH grant sizes for the given UE.
@@ -215,6 +220,9 @@ class scheduler_configurator
   /// \brief Deactivate a configured cell. This method has no effect if the cell is already deactivated.
   /// \remark This method needs to be called after the last slot_indication() call.
   virtual void handle_cell_deactivation_request(du_cell_index_t cell_index) = 0;
+
+  /// \brief Handle slice reconfiguration request of a cell.
+  virtual void handle_slice_reconfiguration_request(const du_cell_slice_reconfig_request& msg) = 0;
 };
 
 class scheduler_ue_configurator

lib/du/du_high/du_manager/du_cell_manager.cpp

@@ -13,6 +13,7 @@
 #include "converters/scheduler_configuration_helpers.h"
 #include "srsran/du/du_cell_config_validation.h"
 #include "srsran/du/du_high/du_manager/du_configurator.h"
+#include "srsran/ran/band_helper.h"
 #include "srsran/srslog/srslog.h"
 
 using namespace srsran;
@@ -95,6 +96,68 @@ expected<du_cell_reconfig_result> du_cell_manager::handle_cell_reconf_request(co
     si_updated                       = true;
   }
 
+  const unsigned nof_prbs =
+      band_helper::get_n_rbs_from_bw(MHz_to_bs_channel_bandwidth(cell_cfg.dl_carrier.carrier_bw_mhz),
+                                     cell_cfg.scs_common,
+                                     band_helper::get_freq_range(cell_cfg.dl_carrier.band));
+
+  du_cell_reconfig_result result;
+  result.slice_reconf_req.emplace();
+  for (const auto& rrm_policy_ratio : req.rrm_policy_ratio_list) {
+    if (not(rrm_policy_ratio.min_prb_policy_ratio.has_value() or rrm_policy_ratio.max_prb_policy_ratio.has_value())) {
+      continue;
+    }
+
+    for (const auto& policy_member : rrm_policy_ratio.policy_members_list) {
+      bool found = false;
+      for (auto& policy_cfg : cell_cfg.rrm_policy_members) {
+        if (policy_cfg.rrc_member == policy_member) {
+          found = true;
+          // Update the policy member configuration.
+          unsigned min_prb_ratio =
+              rrm_policy_ratio.min_prb_policy_ratio.has_value() ? rrm_policy_ratio.min_prb_policy_ratio.value() : 0;
+          unsigned max_prb_ratio =
+              rrm_policy_ratio.max_prb_policy_ratio.has_value() ? rrm_policy_ratio.max_prb_policy_ratio.value() : 100;
+
+          min_prb_ratio = std::clamp(min_prb_ratio, static_cast<unsigned>(0), static_cast<unsigned>(100));
+          max_prb_ratio = std::clamp(max_prb_ratio, static_cast<unsigned>(0), static_cast<unsigned>(100));
+
+          const unsigned min_prb = static_cast<int>((1.0 * min_prb_ratio / 100) * nof_prbs);
+          const unsigned max_prb = static_cast<int>((1.0 * max_prb_ratio / 100) * nof_prbs);
+
+          if (min_prb > max_prb) {
+            logger.warning(
+                "Invalid min/max PRB policy ratio for {} in cell {}: min_prb={} > max_prb={}. Skipping update.",
+                policy_member,
+                fmt::underlying(cell_index),
+                min_prb,
+                max_prb);
+            break;
+          }
+
+          if ((policy_cfg.min_prb != min_prb) or (policy_cfg.max_prb != max_prb)) {
+            // Policy configuration has been updated.
+            result.slice_reconf_req->rrm_policies.push_back(
+                du_cell_slice_reconfig_request::rrm_policy_config{policy_member, min_prb, max_prb});
+          }
+
+          policy_cfg.min_prb = min_prb;
+          policy_cfg.max_prb = max_prb;
+          break;
+        }
+      }
+      if (not found) {
+        logger.warning("No RRM policy member found for {} in cell {}", policy_member, fmt::underlying(cell_index));
+      }
+
+      if (result.slice_reconf_req->rrm_policies.full()) {
+        logger.warning("RRM policy update list is full. Discarding further updates for cell {}",
+                       fmt::underlying(cell_index));
+        break;
+      }
+    }
+  }
+
   if (si_updated) {
     // Need to re-pack SIB1.
     cell.si_cfg.sib1 = asn1_packer::pack_sib1(cell_cfg);
@@ -104,7 +167,14 @@ expected<du_cell_reconfig_result> du_cell_manager::handle_cell_reconf_request(co
     cell.si_cfg.si_sched_cfg.version++;
   }
 
-  return du_cell_reconfig_result{cell_index, si_updated, si_updated};
+  result.cell_index           = cell_index;
+  result.cu_notif_required    = si_updated;
+  result.sched_notif_required = si_updated;
+  if (result.slice_reconf_req->rrm_policies.empty()) {
+    // No RRM policy changes.
+    result.slice_reconf_req.reset();
+  }
+  return result;
 }
 
 async_task<bool> du_cell_manager::start(du_cell_index_t cell_index)

lib/du/du_high/du_manager/du_cell_manager.h

@@ -39,6 +39,8 @@ struct du_cell_reconfig_result {
   bool cu_notif_required;
   /// Whether the Scheduler needs to be notified about an update in the SI scheduling.
   bool sched_notif_required;
+  /// Request for the MAC to change the slice configuration of the cell.
+  std::optional<du_cell_slice_reconfig_request> slice_reconf_req;
 };
 
 class du_cell_manager

lib/du/du_high/du_manager/du_manager_impl.cpp

@@ -240,7 +240,7 @@ du_param_config_response du_manager_impl::handle_operator_config_request(const d
       // Launch config procedure.
       CORO_AWAIT_VALUE(auto resp, launch_async<du_param_config_procedure>(req, params, cell_mng));
 
-      // signal back to caller.
+      // Signal back to caller.
       p.set_value(resp);
 
       CORO_RETURN();

lib/du/du_high/du_manager/procedures/du_param_config_procedure.cpp

@@ -37,13 +37,13 @@ void du_param_config_procedure::operator()(coro_context<async_task<du_param_conf
   for (; next_cell_idx != changed_cells.size(); ++next_cell_idx) {
     // Reconfigure cell in the MAC.
     CORO_AWAIT_VALUE(mac_cell_reconfig_response macresp, handle_mac_cell_update(changed_cells[next_cell_idx]));
-    if (not macresp.si_updated) {
+    if (changed_cells[next_cell_idx].sched_notif_required and not macresp.si_updated) {
       resp.success = false;
       CORO_EARLY_RETURN(resp);
     }
   }
 
-  // Initiate F1AP gNB-DU Configuration Update
+  // Initiate F1AP gNB-DU Configuration Update.
   CORO_AWAIT_VALUE(gnbdu_config_update_response f1resp, handle_f1_gnbdu_config_update());
 
   resp.success = f1resp.result;
@@ -69,31 +69,40 @@ async_task<gnbdu_config_update_response> du_param_config_procedure::handle_f1_gn
 {
   gnbdu_config_update_request f1_req{};
 
-  f1_req.cells_to_mod.resize(changed_cells.size());
-  for (unsigned i = 0, e = changed_cells.size(); i != e; ++i) {
-    if (changed_cells[i].cu_notif_required) {
-      const du_cell_config& cell_cfg = du_cells.get_cell_cfg(changed_cells[i].cell_index);
-
-      f1_req.cells_to_mod[i].cell_info   = make_f1ap_du_cell_info(cell_cfg);
-      f1_req.cells_to_mod[i].du_sys_info = make_f1ap_du_sys_info(cell_cfg);
+  f1_req.cells_to_mod.reserve(changed_cells.size());
+  for (const auto& changed_cell : changed_cells) {
+    if (changed_cell.cu_notif_required) {
+      const du_cell_config& cell_cfg = du_cells.get_cell_cfg(changed_cell.cell_index);
+      auto&                 cell     = f1_req.cells_to_mod.emplace_back();
+      cell.cell_info                 = make_f1ap_du_cell_info(cell_cfg);
+      cell.du_sys_info               = make_f1ap_du_sys_info(cell_cfg);
     }
   }
 
+  if (f1_req.cells_to_mod.empty()) {
+    return launch_no_op_task(gnbdu_config_update_response{true});
+  }
+
   return du_params.f1ap.conn_mng.handle_du_config_update(f1_req);
 }
 
 async_task<mac_cell_reconfig_response>
 du_param_config_procedure::handle_mac_cell_update(const du_cell_reconfig_result& changed_cell)
 {
-  if (not changed_cell.sched_notif_required) {
-    // TODO: Support changes that do not require SI scheduling config update.
+  if (not changed_cell.sched_notif_required and not changed_cell.slice_reconf_req.has_value()) {
     return launch_no_op_task(mac_cell_reconfig_response{});
   }
 
   mac_cell_reconfig_request req;
 
-  // Update SIB1 and SI message content.
-  req.new_sys_info = du_cells.get_sys_info(changed_cell.cell_index);
+  if (changed_cell.sched_notif_required) {
+    // Update SIB1 and SI message content.
+    req.new_sys_info = du_cells.get_sys_info(changed_cell.cell_index);
+  }
+
+  if (changed_cell.slice_reconf_req.has_value()) {
+    req.slice_reconf_req.emplace(changed_cell.slice_reconf_req.value());
+  }
 
   return du_params.mac.cell_mng.get_cell_controller(changed_cell.cell_index).reconfigure(req);
 }

lib/e2/e2sm/e2sm_ccc/e2sm_ccc_control_action_du_executor.cpp

@@ -294,15 +294,11 @@ e2sm_ccc_control_o_rrm_policy_ratio_executor::execute_ric_control_action(const e
   // Log received control request.
   log_du_config_request(logger, du_ctrl_config_req);
 
-  return launch_async(
-      [&req, ctrl_config = std::move(du_ctrl_config_req)](coro_context<async_task<e2sm_ric_control_response>>& ctx) {
-        CORO_BEGIN(ctx);
-        srs_du::du_param_config_response ctrl_response;
-        // TODO: remove success = true, add this to the capture list above, and uncomment when RRM Policy
-        // reconfiguration handling is implemented in DU.
-        ctrl_response.success = true;
-        // ctrl_response                     = du_param_configurator.handle_operator_config_request(ctrl_config);
-        e2sm_ric_control_response e2_resp = convert_to_e2sm_response(req, ctrl_config, ctrl_response);
-        CORO_RETURN(e2_resp);
-      });
+  return launch_async([this, &req, ctrl_config = std::move(du_ctrl_config_req)](
+                          coro_context<async_task<e2sm_ric_control_response>>& ctx) {
+    CORO_BEGIN(ctx);
+    srs_du::du_param_config_response ctrl_response = du_param_configurator.handle_operator_config_request(ctrl_config);
+    e2sm_ric_control_response        e2_resp       = convert_to_e2sm_response(req, ctrl_config, ctrl_response);
+    CORO_RETURN(e2_resp);
+  });
 }

lib/mac/mac_dl/mac_cell_processor.cpp

@@ -179,6 +179,19 @@ async_task<mac_cell_reconfig_response> mac_cell_processor::reconfigure(const mac
       resp.si_pdus_enqueued = true;
     }
 
+    if (request.slice_reconf_req.has_value()) {
+      // Change to respective DL cell executor context.
+      CORO_AWAIT(execute_on_blocking(cell_exec, timers));
+
+      {
+        SRSRAN_RTSAN_SCOPED_ENABLER;
+        sched.handle_slice_reconfiguration_request(request.slice_reconf_req.value());
+      }
+
+      // Change back to CTRL executor context.
+      CORO_AWAIT(execute_on_blocking(ctrl_exec, timers));
+    }
+
     CORO_RETURN(resp);
   });
 }

lib/mac/mac_dl/mac_scheduler_cell_info_handler.h

@@ -58,6 +58,11 @@ class mac_scheduler_cell_info_handler : public mac_ue_control_information_handle
   virtual async_task<mac_cell_positioning_measurement_response>
   handle_positioning_measurement_request(du_cell_index_t                                 cell_index,
                                          const mac_cell_positioning_measurement_request& req) = 0;
+
+  /// \brief Handle request to update the slice configuration of a cell.
+  /// \param[in] cell_index Index of the cell for which the measurement is directed.
+  /// \param[in] req Request to update the RRM policies.
+  virtual void handle_slice_reconfiguration_request(const du_cell_slice_reconfig_request& req) = 0;
 };
 
 } // namespace srsran