5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

sched refactor - removal or cleanup of unused sched methods

Browse Source
master
Francisco 4 years ago committed by Francisco Paisana
parent 137a21d6b2
commit fb48f4484c
5 changed files with 63 additions and 86 deletions
Show Stats Download Patch File Download Diff File

8
lib/include/srslte/adt/bounded_vector.h
Unescape Escape View File

@ -107,13 +107,13 @@ public:
}
T& front() { return (*this)[0]; }
const T& front() const { return (*this)[0]; }
T* data() { return &front(); }
const T* data() const { return &front(); }
T* data() { return reinterpret_cast<T*>(buffer); }
const T* data() const { return reinterpret_cast<const T*>(buffer); }
// Iterators
iterator begin() { return reinterpret_cast<T*>(buffer); }
iterator begin() { return data(); }
iterator end() { return begin() + size_; }
const_iterator begin() const { return reinterpret_cast<const T*>(buffer); }
const_iterator begin() const { return data(); }
const_iterator end() const { return begin() + size_; }
// Capacity

27
srsenb/hdr/stack/mac/sched_grid.h
Unescape Escape View File

@ -19,7 +19,6 @@
#include "srslte/adt/bounded_bitset.h"
#include "srslte/adt/circular_array.h"
#include "srslte/srslog/srslog.h"
#include <deque>
#include <vector>
namespace srsenb {
@ -30,7 +29,7 @@ enum class alloc_result {
sch_collision,
no_cch_space,
no_sch_space,
rnti_inactive,
no_rnti_opportunity,
invalid_grant_params,
invalid_coderate,
no_grant_space,
@ -101,11 +100,6 @@ private:
class sf_grid_t
{
public:
struct dl_ctrl_alloc_t {
alloc_result outcome;
rbg_interval rbg_range;
};
sf_grid_t() : logger(srslog::fetch_basic_logger("MAC")) {}
void init(const sched_cell_params_t& cell_params_);
@ -168,8 +162,6 @@ public:
};
struct bc_alloc_t : public ctrl_alloc_t {
sched_interface::dl_sched_bc_t bc_grant;
bc_alloc_t() = default;
explicit bc_alloc_t(const ctrl_alloc_t& c) : ctrl_alloc_t(c) {}
};
struct dl_alloc_t {
size_t dci_idx;
@ -194,7 +186,6 @@ public:
uint32_t n_prb = 0;
uint32_t mcs = 0;
};
typedef std::pair<alloc_result, const ctrl_alloc_t> ctrl_code_t;
// Control/Configuration Methods
sf_sched();
@ -206,17 +197,16 @@ public:
alloc_result alloc_paging(uint32_t aggr_lvl, uint32_t paging_payload, rbg_interval rbgs);
alloc_result alloc_rar(uint32_t aggr_lvl, const pending_rar_t& rar_grant, rbg_interval rbgs, uint32_t nof_grants);
bool reserve_dl_rbgs(uint32_t rbg_start, uint32_t rbg_end) { return tti_alloc.reserve_dl_rbgs(rbg_start, rbg_end); }
const std::vector<rar_alloc_t>& get_allocated_rars() const { return rar_allocs; }
// UL alloc methods
alloc_result alloc_msg3(sched_ue* user, const sched_interface::dl_sched_rar_grant_t& rargrant);
alloc_result
alloc_ul(sched_ue* user, prb_interval alloc, ul_alloc_t::type_t alloc_type, bool is_msg3 = false, int msg3_mcs = -1);
bool reserve_ul_prbs(const prbmask_t& ulmask, bool strict)
alloc_result reserve_ul_prbs(const prbmask_t& ulmask, bool strict)
{
return tti_alloc.reserve_ul_prbs(ulmask, strict) == alloc_result::success;
return tti_alloc.reserve_ul_prbs(ulmask, strict);
}
bool alloc_phich(sched_ue* user);
alloc_result alloc_phich(sched_ue* user);
// compute DCIs and generate dl_sched_result/ul_sched_result for a given TTI
void generate_sched_results(sched_ue_list& ue_db);
@ -228,6 +218,7 @@ public:
alloc_result alloc_ul_user(sched_ue* user, prb_interval alloc);
const prbmask_t& get_ul_mask() const { return tti_alloc.get_ul_mask(); }
tti_point get_tti_tx_ul() const { return to_tx_ul(tti_rx); }
srslte::const_span<rar_alloc_t> get_allocated_rars() const { return rar_allocs; }
// getters
tti_point get_tti_rx() const { return tti_rx; }
@ -237,10 +228,6 @@ public:
const sched_cell_params_t* get_cc_cfg() const { return cc_cfg; }
private:
void set_bc_sched_result(const sf_cch_allocator::alloc_result_t& dci_result,
sched_interface::dl_sched_res_t* dl_result);
void set_rar_sched_result(const sf_cch_allocator::alloc_result_t& dci_result,
sched_interface::dl_sched_res_t* dl_result);
void set_dl_data_sched_result(const sf_cch_allocator::alloc_result_t& dci_result,
sched_interface::dl_sched_res_t* dl_result,
sched_ue_list& ue_list);
@ -257,8 +244,8 @@ private:
sf_grid_t tti_alloc;
srslte::bounded_vector<bc_alloc_t, sched_interface::MAX_BC_LIST> bc_allocs;
std::vector<rar_alloc_t> rar_allocs;
std::vector<dl_alloc_t> data_allocs;
srslte::bounded_vector<rar_alloc_t, sched_interface::MAX_RAR_LIST> rar_allocs;
srslte::bounded_vector<dl_alloc_t, sched_interface::MAX_DATA_LIST> data_allocs;
srslte::bounded_vector<ul_alloc_t, sched_interface::MAX_DATA_LIST> ul_data_allocs;
uint32_t last_msg3_prb = 0, max_msg3_prb = 0;

7
srsenb/src/stack/mac/sched_carrier.cc
Unescape Escape View File

@ -295,7 +295,7 @@ int ra_sched::dl_rach_info(dl_sched_rar_info_t rar_info)
//! Schedule Msg3 grants in UL based on allocated RARs
void ra_sched::ul_sched(sf_sched* sf_dl_sched, sf_sched* sf_msg3_sched)
{
const std::vector<sf_sched::rar_alloc_t>& alloc_rars = sf_dl_sched->get_allocated_rars();
srslte::const_span<sf_sched::rar_alloc_t> alloc_rars = sf_dl_sched->get_allocated_rars();
for (const auto& rar : alloc_rars) {
for (const auto& msg3grant : rar.rar_grant.msg3_grant) {
@ -334,7 +334,7 @@ sched::carrier_sched::carrier_sched(rrc_interface_mac* rrc_,
sf_dl_mask.resize(1, 0);
}
sched::carrier_sched::~carrier_sched() {}
sched::carrier_sched::~carrier_sched() = default;
void sched::carrier_sched::reset()
{
@ -386,10 +386,9 @@ const cc_sched_result& sched::carrier_sched::generate_tti_result(tti_point tti_r
/* Schedule PHICH */
for (auto& ue_pair : *ue_db) {
if (cc_result->ul_sched_result.phich.size() >= MAX_PHICH_LIST) {
if (tti_sched->alloc_phich(ue_pair.second.get()) == alloc_result::no_grant_space) {
break;
}
tti_sched->alloc_phich(ue_pair.second.get());
}
/* Schedule DL control data */

83
srsenb/src/stack/mac/sched_grid.cc
Unescape Escape View File

@ -29,7 +29,7 @@ const char* to_string(alloc_result result)
return "No space available in PUCCH or PDCCH";
case alloc_result::no_sch_space:
return "Requested number of PRBs not available";
case alloc_result::rnti_inactive:
case alloc_result::no_rnti_opportunity:
return "rnti cannot be allocated (e.g. already allocated, no data, meas gap collision, carrier inactive, etc.)";
case alloc_result::invalid_grant_params:
return "invalid grant arguments (e.g. invalid prb mask)";
@ -55,8 +55,8 @@ void sf_sched_result::new_tti(tti_point tti_rx_)
bool sf_sched_result::is_ul_alloc(uint16_t rnti) const
{
for (const auto& cc : enb_cc_list) {
for (uint32_t j = 0; j < cc.ul_sched_result.pusch.size(); ++j) {
if (cc.ul_sched_result.pusch[j].dci.rnti == rnti) {
for (const auto& pusch : cc.ul_sched_result.pusch) {
if (pusch.dci.rnti == rnti) {
return true;
}
}
@ -66,8 +66,8 @@ bool sf_sched_result::is_ul_alloc(uint16_t rnti) const
bool sf_sched_result::is_dl_alloc(uint16_t rnti) const
{
for (const auto& cc : enb_cc_list) {
for (uint32_t j = 0; j < cc.dl_sched_result.data.size(); ++j) {
if (cc.dl_sched_result.data[j].dci.rnti == rnti) {
for (const auto& data : cc.dl_sched_result.data) {
if (data.dci.rnti == rnti) {
return true;
}
}
@ -259,7 +259,7 @@ void sf_grid_t::rem_last_alloc_dl(rbg_interval rbgs)
alloc_result sf_grid_t::reserve_ul_prbs(prb_interval alloc, bool strict)
{
if (alloc.stop() > ul_mask.size()) {
return alloc_result::no_sch_space;
return alloc_result::invalid_grant_params;
}
prbmask_t newmask(ul_mask.size());
@ -271,11 +271,14 @@ alloc_result sf_grid_t::reserve_ul_prbs(const prbmask_t& prbmask, bool strict)
{
alloc_result ret = alloc_result::success;
if (strict and (ul_mask & prbmask).any()) {
if (logger.info.enabled()) {
fmt::memory_buffer tmp_buffer;
fmt::format_to(tmp_buffer, "There was a collision in the UL. Current mask={:x}, new mask={:x}", ul_mask, prbmask);
logger.error("%s", srslte::to_c_str(tmp_buffer));
fmt::format_to(
tmp_buffer, "There was a collision in the UL. Current mask=0x{:x}, new mask=0x{:x}", ul_mask, prbmask);
logger.info("%s", srslte::to_c_str(tmp_buffer));
ret = alloc_result::sch_collision;
}
}
ul_mask |= prbmask;
return ret;
}
@ -325,7 +328,7 @@ void sf_sched::init(const sched_cell_params_t& cell_params_)
{
cc_cfg = &cell_params_;
tti_alloc.init(*cc_cfg);
max_msg3_prb = std::max(6u, cc_cfg->cfg.cell.nof_prb - tti_alloc.get_pucch_width());
max_msg3_prb = std::max(6U, cc_cfg->cfg.cell.nof_prb - tti_alloc.get_pucch_width());
}
void sf_sched::new_tti(tti_point tti_rx_, sf_sched_result* cc_results_)
@ -361,7 +364,7 @@ bool sf_sched::is_ul_alloc(uint16_t rnti) const
alloc_result sf_sched::alloc_sib(uint32_t aggr_lvl, uint32_t sib_idx, uint32_t sib_ntx, rbg_interval rbgs)
{
if (bc_allocs.size() >= sched_interface::MAX_BC_LIST) {
if (bc_allocs.full()) {
logger.warning("SCHED: Maximum number of Broadcast allocations reached");
return alloc_result::no_grant_space;
}
@ -391,7 +394,7 @@ alloc_result sf_sched::alloc_sib(uint32_t aggr_lvl, uint32_t sib_idx, uint32_t s
alloc_result sf_sched::alloc_paging(uint32_t aggr_lvl, uint32_t paging_payload, rbg_interval rbgs)
{
if (bc_allocs.size() >= sched_interface::MAX_BC_LIST) {
if (bc_allocs.full()) {
logger.warning("SCHED: Maximum number of Broadcast allocations reached");
return alloc_result::no_grant_space;
}
@ -422,7 +425,7 @@ alloc_result sf_sched::alloc_paging(uint32_t aggr_lvl, uint32_t paging_payload,
alloc_result sf_sched::alloc_rar(uint32_t aggr_lvl, const pending_rar_t& rar, rbg_interval rbgs, uint32_t nof_grants)
{
static const uint32_t msg3_nof_prbs = 3;
if (rar_allocs.size() >= sched_interface::MAX_RAR_LIST) {
if (rar_allocs.full()) {
logger.info("SCHED: Maximum number of RAR allocations per TTI reached.");
return alloc_result::no_grant_space;
}
@ -474,22 +477,22 @@ bool is_periodic_cqi_expected(const sched_interface::ue_cfg_t& ue_cfg, tti_point
alloc_result sf_sched::alloc_dl_user(sched_ue* user, const rbgmask_t& user_mask, uint32_t pid)
{
if (data_allocs.size() >= sched_interface::MAX_DATA_LIST) {
if (data_allocs.full()) {
logger.warning("SCHED: Maximum number of DL allocations reached");
return alloc_result::no_grant_space;
}
if (is_dl_alloc(user->get_rnti())) {
logger.warning("SCHED: Attempt to assign multiple harq pids to the same user rnti=0x%x", user->get_rnti());
return alloc_result::rnti_inactive;
return alloc_result::no_rnti_opportunity;
}
auto* cc = user->find_ue_carrier(cc_cfg->enb_cc_idx);
if (cc == nullptr or cc->cc_state() != cc_st::active) {
return alloc_result::rnti_inactive;
return alloc_result::no_rnti_opportunity;
}
if (not user->pdsch_enabled(srslte::tti_point{get_tti_rx()}, cc_cfg->enb_cc_idx)) {
return alloc_result::rnti_inactive;
return alloc_result::no_rnti_opportunity;
}
// Check if allocation would cause segmentation
@ -498,7 +501,7 @@ alloc_result sf_sched::alloc_dl_user(sched_ue* user, const rbgmask_t& user_mask,
// It is newTx
rbg_interval r = user->get_required_dl_rbgs(cc_cfg->enb_cc_idx);
if (r.start() > user_mask.count()) {
logger.warning("SCHED: The number of RBGs allocated to rnti=0x%x will force segmentation", user->get_rnti());
logger.debug("SCHED: The number of RBGs allocated to rnti=0x%x will force segmentation", user->get_rnti());
return alloc_result::invalid_grant_params;
}
}
@ -568,14 +571,14 @@ sf_sched::alloc_ul(sched_ue* user, prb_interval alloc, ul_alloc_t::type_t alloc_
if (is_ul_alloc(user->get_rnti())) {
logger.warning("SCHED: Attempt to assign multiple UL grants to the same user rnti=0x%x", user->get_rnti());
return alloc_result::rnti_inactive;
return alloc_result::no_rnti_opportunity;
}
// Check if there is no collision with measGap
bool needs_pdcch = alloc_type == ul_alloc_t::ADAPT_RETX or (alloc_type == ul_alloc_t::NEWTX and not is_msg3);
if (not user->pusch_enabled(get_tti_rx(), cc_cfg->enb_cc_idx, needs_pdcch)) {
logger.debug("SCHED: PDCCH would collide with rnti=0x%x Measurement Gap", user->get_rnti());
return alloc_result::rnti_inactive;
return alloc_result::no_rnti_opportunity;
}
// Allocate RBGs and DCI space
@ -614,20 +617,20 @@ alloc_result sf_sched::alloc_ul_user(sched_ue* user, prb_interval alloc)
return alloc_ul(user, alloc, alloc_type, h->is_msg3());
}
bool sf_sched::alloc_phich(sched_ue* user)
alloc_result sf_sched::alloc_phich(sched_ue* user)
{
using phich_t = sched_interface::ul_sched_phich_t;
auto* ul_sf_result = &cc_results->get_cc(cc_cfg->enb_cc_idx)->ul_sched_result;
if (ul_sf_result->phich.full()) {
logger.warning("SCHED: Maximum number of PHICH allocations has been reached");
return false;
return alloc_result::no_grant_space;
}
auto p = user->get_active_cell_index(cc_cfg->enb_cc_idx);
if (not p.first) {
// user does not support this carrier
return false;
return alloc_result::no_rnti_opportunity;
}
ul_harq_proc* h = user->get_ul_harq(get_tti_tx_ul(), cc_cfg->enb_cc_idx);
@ -637,29 +640,9 @@ bool sf_sched::alloc_phich(sched_ue* user)
ul_sf_result->phich.emplace_back();
ul_sf_result->phich.back().rnti = user->get_rnti();
ul_sf_result->phich.back().phich = h->pop_pending_phich() ? phich_t::ACK : phich_t::NACK;
return true;
}
return false;
}
void sf_sched::set_bc_sched_result(const sf_cch_allocator::alloc_result_t& dci_result,
sched_interface::dl_sched_res_t* dl_result)
{
for (const auto& bc_alloc : bc_allocs) {
dl_result->bc.emplace_back(bc_alloc.bc_grant);
dl_result->bc.back().dci.location = dci_result[bc_alloc.dci_idx]->dci_pos;
log_broadcast_allocation(dl_result->bc.back(), bc_alloc.rbg_range, *cc_cfg);
}
}
void sf_sched::set_rar_sched_result(const sf_cch_allocator::alloc_result_t& dci_result,
sched_interface::dl_sched_res_t* dl_result)
{
for (const auto& rar_alloc : rar_allocs) {
dl_result->rar.emplace_back(rar_alloc.rar_grant);
dl_result->rar.back().dci.location = dci_result[rar_alloc.alloc_data.dci_idx]->dci_pos;
log_rar_allocation(dl_result->rar.back(), rar_alloc.alloc_data.rbg_range);
return alloc_result::success;
}
return alloc_result::no_rnti_opportunity;
}
void sf_sched::set_dl_data_sched_result(const sf_cch_allocator::alloc_result_t& dci_result,
@ -927,9 +910,17 @@ void sf_sched::generate_sched_results(sched_ue_list& ue_db)
cc_result->dl_sched_result.cfi = tti_alloc.get_pdcch_grid().get_cfi();
/* Generate DCI formats and fill sched_result structs */
set_bc_sched_result(dci_result, &cc_result->dl_sched_result);
for (const auto& bc_alloc : bc_allocs) {
cc_result->dl_sched_result.bc.emplace_back(bc_alloc.bc_grant);
cc_result->dl_sched_result.bc.back().dci.location = dci_result[bc_alloc.dci_idx]->dci_pos;
log_broadcast_allocation(cc_result->dl_sched_result.bc.back(), bc_alloc.rbg_range, *cc_cfg);
}
set_rar_sched_result(dci_result, &cc_result->dl_sched_result);
for (const auto& rar_alloc : rar_allocs) {
cc_result->dl_sched_result.rar.emplace_back(rar_alloc.rar_grant);
cc_result->dl_sched_result.rar.back().dci.location = dci_result[rar_alloc.alloc_data.dci_idx]->dci_pos;
log_rar_allocation(cc_result->dl_sched_result.rar.back(), rar_alloc.alloc_data.rbg_range);
}
set_dl_data_sched_result(dci_result, &cc_result->dl_sched_result, ue_db);

4
srsenb/src/stack/mac/schedulers/sched_base.cc
Unescape Escape View File

@ -146,7 +146,7 @@ alloc_result try_dl_newtx_alloc_greedy(sf_sched& tti_sched, sched_ue& ue, const
// If there is no data to transmit, no need to allocate
rbg_interval req_rbgs = ue.get_required_dl_rbgs(tti_sched.get_enb_cc_idx());
if (req_rbgs.stop() == 0) {
return alloc_result::rnti_inactive;
return alloc_result::no_rnti_opportunity;
}
// Find RBG mask that accommodates pending data
@ -245,7 +245,7 @@ alloc_result try_ul_retx_alloc(sf_sched& tti_sched, sched_ue& ue, const ul_harq_
// Avoid measGaps accounting for PDCCH
if (not ue.pusch_enabled(tti_sched.get_tti_rx(), tti_sched.get_enb_cc_idx(), true)) {
return alloc_result::rnti_inactive;
return alloc_result::no_rnti_opportunity;
}
uint32_t nof_prbs = alloc.length();
alloc = find_contiguous_ul_prbs(nof_prbs, tti_sched.get_ul_mask());

Write Preview
Loading…
Cancel
Save