sched: fix uninited var + remove unused function

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

Author: carlo-gal

lib/scheduler/ue_scheduling/harq_process.h

@@ -270,7 +270,7 @@ class dl_harq_process : public detail::harq_process<true>
     std::array<optional<tb_params>, base_type::MAX_NOF_TBS> tb;
     cqi_value                                               cqi;
     unsigned                                                nof_layers;
-    bool                                                    is_fallback;
+    bool                                                    is_fallback{false};
   };
 
   struct dl_ack_info_result {

lib/scheduler/ue_scheduling/ue_event_manager.cpp

@@ -80,7 +80,7 @@ class ue_event_manager::ue_dl_buffer_occupancy_manager final : public scheduler_
       u.handle_dl_buffer_state_indication(dl_bo);
       if (dl_bo.lcid == LCID_SRB0 or (u.get_pcell().is_in_fallback_mode() and dl_bo.lcid == LCID_SRB1)) {
         // Signal SRB fallback scheduler with the new SRB0/SRB1 buffer state.
-        parent.du_cells[u.get_pcell().cell_index].srb0_sched->handle_dl_buffer_state_indication_srb(
+        parent.du_cells[u.get_pcell().cell_index].fallback_sched->handle_dl_buffer_state_indication_srb(
             dl_bo.ue_index, dl_bo.lcid == LCID_SRB0);
       }
 
@@ -632,16 +632,16 @@ void ue_event_manager::run(slot_point sl, du_cell_index_t cell_index)
 }
 
 void ue_event_manager::add_cell(cell_resource_allocator& cell_res_grid,
-                                ue_fallback_scheduler&   srb0_sched,
+                                ue_fallback_scheduler&   fallback_sched,
                                 uci_scheduler_impl&      uci_sched)
 {
   const du_cell_index_t cell_index = cell_res_grid.cell_index();
   srsran_assert(not cell_exists(cell_index), "Overwriting cell configurations not supported");
 
-  du_cells[cell_index].cfg        = &cell_res_grid.cfg;
-  du_cells[cell_index].res_grid   = &cell_res_grid;
-  du_cells[cell_index].srb0_sched = &srb0_sched;
-  du_cells[cell_index].uci_sched  = &uci_sched;
+  du_cells[cell_index].cfg            = &cell_res_grid.cfg;
+  du_cells[cell_index].res_grid       = &cell_res_grid;
+  du_cells[cell_index].fallback_sched = &fallback_sched;
+  du_cells[cell_index].uci_sched      = &uci_sched;
 }
 
 bool ue_event_manager::cell_exists(du_cell_index_t cell_index) const

lib/scheduler/ue_scheduling/ue_event_manager.h

@@ -36,8 +36,9 @@ class ue_event_manager final : public sched_ue_configuration_handler,
   ue_event_manager(ue_repository& ue_db, scheduler_metrics_handler& metrics_handler, scheduler_event_logger& ev_logger);
   ~ue_event_manager();
 
-  void
-  add_cell(cell_resource_allocator& cell_res_grid, ue_fallback_scheduler& srb0_sched, uci_scheduler_impl& uci_sched);
+  void add_cell(cell_resource_allocator& cell_res_grid,
+                ue_fallback_scheduler&   fallback_sched,
+                uci_scheduler_impl&      uci_sched);
 
   /// UE Add/Mod/Remove interface.
   void handle_ue_creation(ue_config_update_event ev) override;
@@ -113,8 +114,8 @@ class ue_event_manager final : public sched_ue_configuration_handler,
 
     cell_resource_allocator* res_grid = nullptr;
 
-    // Reference to SRB0 and other bearers scheduler
-    ue_fallback_scheduler* srb0_sched = nullptr;
+    // Reference to fallback scheduler.
+    ue_fallback_scheduler* fallback_sched = nullptr;
 
     // Reference to the CSI and SR UCI scheduler.
     uci_scheduler_impl* uci_sched = nullptr;

lib/scheduler/ue_scheduling/ue_fallback_scheduler.cpp

@@ -337,7 +337,7 @@ dl_harq_process* ue_fallback_scheduler::schedule_srb0(ue&                      u
 
     if (mcs_idx > expert_cfg.max_msg4_mcs) {
       logger.debug("rnti={}: Postponing SRB0 PDU allocation. Cause: MCS index chosen ({}) for SRB0 exceeds maximum"
-                   "allowed MCS index ({})",
+                   " allowed MCS index ({})",
                    u.crnti,
                    mcs_idx,
                    expert_cfg.max_msg4_mcs);
@@ -567,68 +567,6 @@ dl_harq_process* ue_fallback_scheduler::schedule_srb1(ue&                      u
   return h_dl;
 }
 
-void ue_fallback_scheduler::fill_srb0_grant(ue&                        u,
-                                            slot_point                 pdsch_slot,
-                                            dl_harq_process&           h_dl,
-                                            pdcch_dl_information&      pdcch,
-                                            dl_msg_alloc&              msg,
-                                            unsigned                   pucch_res_indicator,
-                                            unsigned                   pdsch_time_res,
-                                            unsigned                   k1,
-                                            sch_mcs_index              mcs_idx,
-                                            const crb_interval&        ue_grant_crbs,
-                                            const pdsch_config_params& pdsch_params,
-                                            unsigned                   tbs_bytes,
-                                            bool                       is_retx)
-{
-  // Allocate DL HARQ.
-  // NOTE: We do not multiplex the SRBO PUCCH with existing PUCCH HARQs, thus both DAI and HARQ-ACK bit index are 0.
-  if (not is_retx) {
-    const bool               is_fallback = true;
-    static constexpr uint8_t srb0_dai    = 0;
-    h_dl.new_tx(pdsch_slot,
-                k1,
-                expert_cfg.max_nof_harq_retxs,
-                srb0_dai,
-                u.get_pcell().channel_state_manager().get_wideband_cqi(),
-                u.get_pcell().channel_state_manager().get_nof_dl_layers(),
-                is_fallback);
-  } else {
-    const unsigned harq_bit_idx = 0U;
-    h_dl.new_retx(pdsch_slot, k1, harq_bit_idx);
-  }
-
-  // Fill DL PDCCH DCI.
-  static const uint8_t msg4_rv = 0;
-  build_dci_f1_0_tc_rnti(pdcch.dci,
-                         cell_cfg.dl_cfg_common.init_dl_bwp,
-                         ue_grant_crbs,
-                         pdsch_time_res,
-                         k1,
-                         pucch_res_indicator,
-                         mcs_idx,
-                         msg4_rv,
-                         h_dl);
-
-  // Fill PDSCH PDU.
-  msg.context.ue_index    = u.ue_index;
-  msg.context.k1          = k1;
-  msg.context.ss_id       = pdcch.ctx.context.ss_id;
-  msg.context.nof_retxs   = h_dl.tb(0).nof_retxs;
-  msg.context.olla_offset = 0;
-  build_pdsch_f1_0_tc_rnti(
-      msg.pdsch_cfg, pdsch_params, tbs_bytes, u.crnti, cell_cfg, pdcch.dci.tc_rnti_f1_0, ue_grant_crbs, not is_retx);
-
-  if (not is_retx) {
-    // Set MAC logical channels to schedule in this PDU.
-    u.build_dl_fallback_transport_block_info(
-        msg.tb_list.emplace_back(), msg.pdsch_cfg.codewords[0].tb_size_bytes, true);
-  }
-
-  // Save in HARQ the parameters set for this PDCCH and PDSCH PDUs.
-  h_dl.save_alloc_params(pdcch.dci.type, msg.pdsch_cfg);
-}
-
 void ue_fallback_scheduler::fill_srb_grant(ue&                        u,
                                            slot_point                 pdsch_slot,
                                            dl_harq_process&           h_dl,

lib/scheduler/ue_scheduling/ue_fallback_scheduler.h

@@ -71,20 +71,6 @@ class ue_fallback_scheduler
                                  slot_point               most_recent_ack_slot,
                                  dl_harq_process*         h_dl_retx = nullptr);
 
-  void fill_srb0_grant(ue&                        u,
-                       slot_point                 pdsch_slot,
-                       dl_harq_process&           h_dl,
-                       pdcch_dl_information&      pdcch,
-                       dl_msg_alloc&              msg,
-                       unsigned                   pucch_res_indicator,
-                       unsigned                   pdsch_time_res,
-                       unsigned                   k1,
-                       sch_mcs_index              mcs_idx,
-                       const crb_interval&        ue_grant_crbs,
-                       const pdsch_config_params& pdsch_params,
-                       unsigned                   tbs_bytes,
-                       bool                       is_retx);
-
   void fill_srb_grant(ue&                        u,
                       slot_point                 pdsch_slot,
                       dl_harq_process&           h_dl,

lib/scheduler/ue_scheduling/ue_pdsch_param_candidate_searcher.h

@@ -137,7 +137,7 @@ class ue_pdsch_param_candidate_searcher
       // Create list of DL HARQ processes with pending retx, sorted from oldest to newest.
       for (unsigned i = 0; i != ue_cc.harqs.nof_dl_harqs(); ++i) {
         const dl_harq_process& h = ue_cc.harqs.dl_harq(i);
-        if ((not h.last_alloc_params().is_fallback) and h.has_pending_retx()) {
+        if (h.has_pending_retx() and (not h.last_alloc_params().is_fallback)) {
           dl_harq_candidates.push_back(&h);
         }
       }

lib/scheduler/ue_scheduling/ue_scheduler_impl.cpp

@@ -30,7 +30,8 @@ void ue_scheduler_impl::add_cell(const ue_scheduler_cell_params& params)
 {
   ue_res_grid_view.add_cell(*params.cell_res_alloc);
   cells[params.cell_index] = std::make_unique<cell>(expert_cfg, params, ue_db);
-  event_mng.add_cell(*params.cell_res_alloc, cells[params.cell_index]->srb0_sched, cells[params.cell_index]->uci_sched);
+  event_mng.add_cell(
+      *params.cell_res_alloc, cells[params.cell_index]->fallback_sched, cells[params.cell_index]->uci_sched);
   ue_alloc.add_cell(params.cell_index, *params.pdcch_sched, *params.uci_alloc, *params.cell_res_alloc);
 }
 
@@ -155,7 +156,7 @@ void ue_scheduler_impl::run_slot(slot_point slot_tx, du_cell_index_t cell_index)
   cells[cell_index]->uci_sched.run_slot(*cells[cell_index]->cell_res_alloc);
 
   // Run cell-specific SRB0 scheduler.
-  cells[cell_index]->srb0_sched.run_slot(*cells[cell_index]->cell_res_alloc);
+  cells[cell_index]->fallback_sched.run_slot(*cells[cell_index]->cell_res_alloc);
 
   // Synchronize all carriers. Last thread to reach this synchronization point, runs UE scheduling strategy.
   sync_point.wait(

lib/scheduler/ue_scheduling/ue_scheduler_impl.h

@@ -68,13 +68,13 @@ class ue_scheduler_impl final : public ue_scheduler
     /// PUCCH scheduler.
     uci_scheduler_impl uci_sched;
 
-    /// SRB0 scheduler.
-    ue_fallback_scheduler srb0_sched;
+    /// Fallback scheduler.
+    ue_fallback_scheduler fallback_sched;
 
     cell(const scheduler_ue_expert_config& expert_cfg, const ue_scheduler_cell_params& params, ue_repository& ues) :
       cell_res_alloc(params.cell_res_alloc),
       uci_sched(params.cell_res_alloc->cfg, *params.uci_alloc, ues),
-      srb0_sched(expert_cfg, params.cell_res_alloc->cfg, *params.pdcch_sched, *params.pucch_alloc, ues)
+      fallback_sched(expert_cfg, params.cell_res_alloc->cfg, *params.pdcch_sched, *params.pucch_alloc, ues)
     {
     }
   };

tests/unittests/scheduler/ue_scheduling/fallback_scheduler_test.cpp

@@ -935,13 +935,13 @@ class fallback_scheduler_srb1_segmentation : public base_fallback_tester,
                         test_rgen::uniform_int(20U, 40U)};
     }
 
-    const cell_configuration&         cell_cfg;
-    ue&                               test_ue;
-    slot_point                        slot_update_srb_traffic;
-    unsigned                          nof_packet_to_tx;
+    const cell_configuration&             cell_cfg;
+    ue&                                   test_ue;
+    slot_point                            slot_update_srb_traffic;
+    unsigned                              nof_packet_to_tx;
     fallback_scheduler_srb1_segmentation* parent;
-    srslog::basic_logger&             test_logger  = srslog::fetch_basic_logger("TEST");
-    unsigned                          missing_retx = 0;
+    srslog::basic_logger&                 test_logger  = srslog::fetch_basic_logger("TEST");
+    unsigned                              missing_retx = 0;
 
     using h_state = srsran::dl_harq_process::harq_process::transport_block::state_t;
     std::vector<h_state> latest_harq_states;