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

clang-format on all the scheduler files

Browse Source
master
Francisco Paisana 5 years ago
parent c1f9d8768c
commit 00d24872d9
9 changed files with 314 additions and 316 deletions
Show Stats Download Patch File Download Diff File

2
srsenb/hdr/stack/mac/scheduler_grid.h
Unescape Escape View File

@ -41,7 +41,7 @@ struct alloc_outcome_t {
alloc_outcome_t(result_enum e) : result(e) {}
operator result_enum() { return result; }
operator bool() { return result == SUCCESS; }
const char* to_string() const;
const char* to_string() const;
};
//! Class responsible for managing a PDCCH CCE grid, namely cce allocs, and avoid collisions.

30
srsenb/hdr/stack/mac/scheduler_harq.h
Unescape Escape View File

@ -52,7 +52,7 @@ struct prb_range_t {
static prb_range_t riv_to_prbs(uint32_t riv, uint32_t nof_prbs, int nof_vrbs = -1);
};
class harq_proc
class harq_proc
{
public:
void config(uint32_t id, uint32_t max_retx, srslte::log* log_h);
@ -68,20 +68,19 @@ public:
uint32_t max_nof_retx() const;
protected:
void new_tx_common(uint32_t tb_idx, uint32_t tti, int mcs, int tbs);
void new_retx_common(uint32_t tb_idx, uint32_t tti, int* mcs, int* tbs);
bool has_pending_retx_common(uint32_t tb_idx) const;
void set_ack_common(uint32_t tb_idx, bool ack);
void reset_pending_data_common();
void new_tx_common(uint32_t tb_idx, uint32_t tti, int mcs, int tbs);
void new_retx_common(uint32_t tb_idx, uint32_t tti, int* mcs, int* tbs);
bool has_pending_retx_common(uint32_t tb_idx) const;
void set_ack_common(uint32_t tb_idx, bool ack);
void reset_pending_data_common();
enum ack_t { NULL_ACK, NACK, ACK };
ack_t ack_state[SRSLTE_MAX_TB];
bool active[SRSLTE_MAX_TB];
bool ndi[SRSLTE_MAX_TB];
uint32_t id;
uint32_t max_retx;
uint32_t id;
uint32_t max_retx;
uint32_t n_rtx[SRSLTE_MAX_TB];
uint32_t tx_cnt[SRSLTE_MAX_TB];
int tti;
@ -114,7 +113,6 @@ private:
class ul_harq_proc : public harq_proc
{
public:
struct ul_alloc_t {
uint32_t RB_start;
uint32_t L;
@ -134,15 +132,15 @@ public:
bool has_pending_retx() const;
bool is_adaptive_retx() const;
void reset_pending_data();
bool has_pending_ack() const;
bool get_pending_ack() const;
uint32_t get_pending_data() const;
void reset_pending_data();
bool has_pending_ack() const;
bool get_pending_ack() const;
uint32_t get_pending_data() const;
private:
ul_alloc_t allocation;
int pending_data;
bool is_adaptive;
int pending_data;
bool is_adaptive;
ack_t pending_ack;
};

157
srsenb/hdr/stack/mac/scheduler_ue.h
Unescape Escape View File

@ -22,9 +22,9 @@
#ifndef SRSENB_SCHEDULER_UE_H
#define SRSENB_SCHEDULER_UE_H
#include <map>
#include "srslte/common/log.h"
#include "srslte/interfaces/sched_interface.h"
#include <map>
#include "scheduler_harq.h"
#include "srslte/asn1/rrc_asn1.h"
@ -32,40 +32,43 @@
namespace srsenb {
/** This class is designed to be thread-safe because it is called from workers through scheduler thread and from
* higher layers and mac threads.
*
* 1 mutex is created for every user and only access to same user variables are mutexed
*/
class sched_ue {
class sched_ue
{
public:
// used by sched_metric to store the pdsch/pusch allocations
bool has_pucch;
typedef struct {
uint32_t cce_start[4][6];
uint32_t nof_loc[4];
uint32_t nof_loc[4];
} sched_dci_cce_t;
/*************************************************************
*
* FAPI-like Interface
*
*
* FAPI-like Interface
*
************************************************************/
sched_ue();
void reset();
void phy_config_enabled(uint32_t tti, bool enabled);
void set_cfg(uint16_t rnti, sched_interface::ue_cfg_t* cfg, sched_interface::cell_cfg_t *cell_cfg,
srslte_regs_t *regs, srslte::log *log_h);
void set_cfg(uint16_t rnti,
sched_interface::ue_cfg_t* cfg,
sched_interface::cell_cfg_t* cell_cfg,
srslte_regs_t* regs,
srslte::log* log_h);
void set_bearer_cfg(uint32_t lc_id, srsenb::sched_interface::ue_bearer_cfg_t* cfg);
void rem_bearer(uint32_t lc_id);
void dl_buffer_state(uint8_t lc_id, uint32_t tx_queue, uint32_t retx_queue);
void ul_buffer_state(uint8_t lc_id, uint32_t bsr, bool set_value = true);
void ul_phr(int phr);
void ul_phr(int phr);
void mac_buffer_state(uint32_t ce_code);
void ul_recv_len(uint32_t lcid, uint32_t len);
void set_dl_ant_info(asn1::rrc::phys_cfg_ded_s::ant_info_c_* dedicated);
@ -76,11 +79,11 @@ public:
int set_ack_info(uint32_t tti, uint32_t tb_idx, bool ack);
void set_ul_crc(uint32_t tti, bool crc_res);
/*******************************************************
* Custom functions
*******************************************************/
/*******************************************************
* Custom functions
*******************************************************/
void tpc_inc();
void tpc_inc();
void tpc_dec();
void set_max_mcs(int mcs_ul, int mcs_dl, int max_aggr_level = -1);
@ -94,19 +97,18 @@ public:
* Functions used by scheduler metric objects
*******************************************************/
uint32_t get_required_prb_dl(uint32_t req_bytes, uint32_t nof_ctrl_symbols);
uint32_t get_required_prb_ul(uint32_t req_bytes);
uint32_t prb_to_rbg(uint32_t nof_prb);
uint32_t rgb_to_prb(uint32_t nof_rbg);
uint32_t get_required_prb_dl(uint32_t req_bytes, uint32_t nof_ctrl_symbols);
uint32_t get_required_prb_ul(uint32_t req_bytes);
uint32_t prb_to_rbg(uint32_t nof_prb);
uint32_t rgb_to_prb(uint32_t nof_rbg);
uint32_t get_pending_dl_new_data(uint32_t tti);
uint32_t get_pending_ul_new_data(uint32_t tti);
uint32_t get_pending_ul_old_data();
uint32_t get_pending_dl_new_data_total(uint32_t tti);
uint32_t get_pending_dl_new_data(uint32_t tti);
uint32_t get_pending_ul_new_data(uint32_t tti);
uint32_t get_pending_ul_old_data();
uint32_t get_pending_dl_new_data_total(uint32_t tti);
void reset_pending_pids(uint32_t tti_rx);
dl_harq_proc *get_pending_dl_harq(uint32_t tti);
dl_harq_proc* get_pending_dl_harq(uint32_t tti);
dl_harq_proc* get_empty_dl_harq();
ul_harq_proc* get_ul_harq(uint32_t tti);
@ -114,8 +116,8 @@ public:
* Functions used by the scheduler object
*******************************************************/
void set_sr();
void unset_sr();
void set_sr();
void unset_sr();
void set_needs_ta_cmd(uint32_t nof_ta_cmd);
@ -133,43 +135,42 @@ public:
int explicit_mcs = -1);
srslte_dci_format_t get_dci_format();
uint32_t get_aggr_level(uint32_t nof_bits);
sched_dci_cce_t *get_locations(uint32_t current_cfi, uint32_t sf_idx);
bool needs_cqi(uint32_t tti, bool will_send = false);
uint32_t get_max_retx();
bool get_pucch_sched(uint32_t current_tti, uint32_t prb_idx[2]);
bool pucch_sr_collision(uint32_t current_tti, uint32_t n_cce);
private:
uint32_t get_aggr_level(uint32_t nof_bits);
sched_dci_cce_t* get_locations(uint32_t current_cfi, uint32_t sf_idx);
bool needs_cqi(uint32_t tti, bool will_send = false);
uint32_t get_max_retx();
bool get_pucch_sched(uint32_t current_tti, uint32_t prb_idx[2]);
bool pucch_sr_collision(uint32_t current_tti, uint32_t n_cce);
private:
typedef struct {
sched_interface::ue_bearer_cfg_t cfg;
int buf_tx;
int buf_retx;
int bsr;
} ue_bearer_t;
bool is_sr_triggered();
int alloc_pdu(int tbs, sched_interface::dl_sched_pdu_t* pdu);
sched_interface::ue_bearer_cfg_t cfg;
int buf_tx;
int buf_retx;
int bsr;
} ue_bearer_t;
bool is_sr_triggered();
int alloc_pdu(int tbs, sched_interface::dl_sched_pdu_t* pdu);
static uint32_t format1_count_prb(uint32_t bitmask, uint32_t cell_nof_prb);
static int cqi_to_tbs(
uint32_t cqi, uint32_t nof_prb, uint32_t nof_re, uint32_t max_mcs, uint32_t max_Qm, bool is_ul, uint32_t* mcs);
int alloc_tbs_dl(uint32_t nof_prb, uint32_t nof_re, uint32_t req_bytes, int *mcs);
int alloc_tbs_ul(uint32_t nof_prb, uint32_t nof_re, uint32_t req_bytes, int *mcs);
int alloc_tbs(uint32_t nof_prb, uint32_t nof_re, uint32_t req_bytes, bool is_ul, int *mcs);
static bool bearer_is_ul(ue_bearer_t *lch);
static bool bearer_is_dl(ue_bearer_t *lch);
int alloc_tbs_dl(uint32_t nof_prb, uint32_t nof_re, uint32_t req_bytes, int* mcs);
int alloc_tbs_ul(uint32_t nof_prb, uint32_t nof_re, uint32_t req_bytes, int* mcs);
int alloc_tbs(uint32_t nof_prb, uint32_t nof_re, uint32_t req_bytes, bool is_ul, int* mcs);
uint32_t get_pending_dl_new_data_unlocked(uint32_t tti);
uint32_t get_pending_ul_old_data_unlocked();
uint32_t get_pending_ul_new_data_unlocked(uint32_t tti);
uint32_t get_pending_dl_new_data_total_unlocked(uint32_t tti);
static bool bearer_is_ul(ue_bearer_t* lch);
static bool bearer_is_dl(ue_bearer_t* lch);
bool needs_cqi_unlocked(uint32_t tti, bool will_send = false);
uint32_t get_pending_dl_new_data_unlocked(uint32_t tti);
uint32_t get_pending_ul_old_data_unlocked();
uint32_t get_pending_ul_new_data_unlocked(uint32_t tti);
uint32_t get_pending_dl_new_data_total_unlocked(uint32_t tti);
bool needs_cqi_unlocked(uint32_t tti, bool will_send = false);
int generate_format2a_unlocked(
dl_harq_proc* h, sched_interface::dl_sched_data_t* data, uint32_t tti, uint32_t cfi, const rbgmask_t& user_mask);
@ -177,33 +178,33 @@ private:
bool is_first_dl_tx();
sched_interface::ue_cfg_t cfg;
srslte_cell_t cell;
srslte::log* log_h;
srslte_cell_t cell;
srslte::log* log_h;
std::mutex mutex;
/* Buffer states */
bool sr;
int buf_mac;
int buf_ul;
bool sr;
int buf_mac;
int buf_ul;
ue_bearer_t lch[sched_interface::MAX_LC];
int power_headroom;
int power_headroom;
uint32_t dl_ri;
uint32_t dl_ri_tti;
uint32_t dl_pmi;
uint32_t dl_pmi_tti;
uint32_t dl_cqi;
uint32_t dl_cqi_tti;
uint32_t cqi_request_tti;
uint32_t ul_cqi;
uint32_t ul_cqi_tti;
uint16_t rnti;
uint32_t dl_cqi_tti;
uint32_t cqi_request_tti;
uint32_t ul_cqi;
uint32_t ul_cqi_tti;
uint16_t rnti;
uint32_t max_mcs_dl;
uint32_t max_aggr_level;
uint32_t max_mcs_ul;
uint32_t max_msg3retx;
int fixed_mcs_ul;
int fixed_mcs_ul;
int fixed_mcs_dl;
uint32_t P;
@ -216,14 +217,12 @@ private:
sched_dci_cce_t dci_locations[3][10];
const static int SCHED_MAX_HARQ_PROC = SRSLTE_FDD_NOF_HARQ;
dl_harq_proc dl_harq[SCHED_MAX_HARQ_PROC];
ul_harq_proc ul_harq[SCHED_MAX_HARQ_PROC];
bool phy_config_dedicated_enabled;
asn1::rrc::phys_cfg_ded_s::ant_info_c_ dl_ant_info;
dl_harq_proc dl_harq[SCHED_MAX_HARQ_PROC];
ul_harq_proc ul_harq[SCHED_MAX_HARQ_PROC];
bool phy_config_dedicated_enabled;
asn1::rrc::phys_cfg_ded_s::ant_info_c_ dl_ant_info;
};
}
} // namespace srsenb
#endif // SRSENB_SCHEDULER_UE_H

37
srsenb/src/stack/mac/scheduler.cc
Unescape Escape View File

@ -27,10 +27,10 @@
#include "srslte/common/pdu.h"
#include "srslte/srslte.h"
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__)
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) log_h->warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__)
namespace srsenb {
@ -118,9 +118,9 @@ sched::tti_sched_result_t::alloc_dl_ctrl(uint32_t aggr_lvl, uint32_t tbs_bytes,
alloc_outcome_t sched::tti_sched_result_t::alloc_bc(uint32_t aggr_lvl, uint32_t sib_idx, uint32_t sib_ntx)
{
uint32_t sib_len = sibs_cfg[sib_idx].len;
uint32_t rv = get_rvidx(sib_ntx);
ctrl_code_t ret = alloc_dl_ctrl(aggr_lvl, sib_len, SRSLTE_SIRNTI);
uint32_t sib_len = sibs_cfg[sib_idx].len;
uint32_t rv = get_rvidx(sib_ntx);
ctrl_code_t ret = alloc_dl_ctrl(aggr_lvl, sib_len, SRSLTE_SIRNTI);
if (not ret.first) {
Warning("SCHED: Could not allocate SIB=%d, L=%d, len=%d, cause=%s\n",
sib_idx + 1,
@ -132,7 +132,7 @@ alloc_outcome_t sched::tti_sched_result_t::alloc_bc(uint32_t aggr_lvl, uint32_t
// BC allocation successful
bc_alloc_t bc_alloc(ret.second);
bc_alloc.rv = rv;
bc_alloc.rv = rv;
bc_alloc.sib_idx = sib_idx;
bc_allocs.push_back(bc_alloc);
@ -222,11 +222,11 @@ alloc_outcome_t sched::tti_sched_result_t::alloc_ul(sched_ue*
}
ul_alloc_t ul_alloc = {};
ul_alloc.type = alloc_type;
ul_alloc.dci_idx = tti_alloc.get_pdcch_grid().nof_allocs() - 1;
ul_alloc.user_ptr = user;
ul_alloc.alloc = alloc;
ul_alloc.mcs = mcs;
ul_alloc.type = alloc_type;
ul_alloc.dci_idx = tti_alloc.get_pdcch_grid().nof_allocs() - 1;
ul_alloc.user_ptr = user;
ul_alloc.alloc = alloc;
ul_alloc.mcs = mcs;
ul_data_allocs.push_back(ul_alloc);
return alloc_outcome_t::SUCCESS;
@ -388,7 +388,7 @@ void sched::tti_sched_result_t::set_dl_data_sched_result(const pdcch_grid_t::all
srslte_dci_format_t dci_format = user->get_dci_format();
bool is_newtx = h->is_empty();
int tbs = 0;
int tbs = 0;
switch (dci_format) {
case SRSLTE_DCI_FORMAT1:
tbs = user->generate_format1(h, data, get_tti_tx_dl(), get_cfi(), data_alloc.user_mask);
@ -437,7 +437,7 @@ void sched::tti_sched_result_t::set_ul_sched_result(const pdcch_grid_t::alloc_re
for (const auto& ul_alloc : ul_data_allocs) {
sched_interface::ul_sched_data_t* pusch = &ul_sched_result.pusch[ul_sched_result.nof_dci_elems];
sched_ue* user = ul_alloc.user_ptr;
sched_ue* user = ul_alloc.user_ptr;
srslte_dci_location_t cce_range = {0, 0};
if (ul_alloc.needs_pdcch()) {
@ -712,11 +712,10 @@ int sched::cell_cfg(sched_interface::cell_cfg_t* cell_cfg)
return 0;
}
/*******************************************************
*
*
* FAPI-like main sched interface. Wrappers to UE object
*
*
*******************************************************/
int sched::ue_cfg(uint16_t rnti, sched_interface::ue_cfg_t* ue_cfg)
@ -984,8 +983,8 @@ void sched::generate_phich(tti_sched_result_t* tti_sched)
int sched::generate_ul_sched(tti_sched_result_t* tti_sched)
{
/* Initialize variables */
current_tti = tti_sched->get_tti_tx_ul();
prbmask_t& ul_mask = tti_sched->get_ul_mask();
current_tti = tti_sched->get_tti_tx_ul();
prbmask_t& ul_mask = tti_sched->get_ul_mask();
// reserve PRBs for PRACH
if (srslte_prach_tti_opportunity_config_fdd(cfg.prach_config, tti_sched->get_tti_tx_ul(), -1)) {

2
srsenb/src/stack/mac/scheduler_grid.cc
Unescape Escape View File

@ -131,7 +131,7 @@ void pdcch_grid_t::update_alloc_tree(int parent_nod
const sched_ue::sched_dci_cce_t* dci_locs)
{
alloc_t alloc;
alloc.rnti = (user != nullptr) ? user->get_rnti() : (uint16_t)0u;
alloc.rnti = (user != nullptr) ? user->get_rnti() : (uint16_t)0u;
alloc.dci_pos.L = aggr_idx;
// get cumulative pdcch mask

49
srsenb/src/stack/mac/scheduler_harq.cc
Unescape Escape View File

@ -25,10 +25,10 @@
#include "srslte/common/pdu.h"
#include "srslte/srslte.h"
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__)
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) log_h->warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__)
namespace srsenb {
@ -50,18 +50,18 @@ prb_range_t prb_range_t::riv_to_prbs(uint32_t riv, uint32_t nof_prbs, int nof_vr
return p;
}
/******************************************************
*
* These classes manage the HARQ Processes.
/******************************************************
*
* These classes manage the HARQ Processes.
* There is a common class and two child classes for UL and DL.
*
*
******************************************************/
void harq_proc::config(uint32_t id_, uint32_t max_retx_, srslte::log* log_h_)
{
log_h = log_h_;
id = id_;
max_retx = max_retx_;
log_h = log_h_;
id = id_;
max_retx = max_retx_;
for (int i = 0; i < SRSLTE_MAX_TB; i++) {
ndi[i] = false;
}
@ -70,12 +70,12 @@ void harq_proc::config(uint32_t id_, uint32_t max_retx_, srslte::log* log_h_)
void harq_proc::reset(uint32_t tb_idx)
{
ack_state[tb_idx] = NULL_ACK;
active[tb_idx] = false;
n_rtx[tb_idx] = 0;
tti = 0;
last_mcs[tb_idx] = -1;
last_tbs[tb_idx] = -1;
tx_cnt[tb_idx] = 0;
active[tb_idx] = false;
n_rtx[tb_idx] = 0;
tti = 0;
last_mcs[tb_idx] = -1;
last_tbs[tb_idx] = -1;
tx_cnt[tb_idx] = 0;
}
uint32_t harq_proc::get_id() const
@ -105,7 +105,7 @@ bool harq_proc::has_pending_retx_common(uint32_t tb_idx) const
uint32_t harq_proc::get_tti() const
{
return (uint32_t) tti;
return (uint32_t)tti;
}
void harq_proc::set_ack_common(uint32_t tb_idx, bool ack_)
@ -113,7 +113,8 @@ void harq_proc::set_ack_common(uint32_t tb_idx, bool ack_)
ack_state[tb_idx] = ack_ ? ACK : NACK;
log_h->debug("ACK=%d received pid=%d, tb_idx=%d, n_rtx=%d, max_retx=%d\n", ack_, id, tb_idx, n_rtx[tb_idx], max_retx);
if (!ack_ && (n_rtx[tb_idx] + 1 >= max_retx)) {
Warning("SCHED: discarting TB %d pid=%d, tti=%d, maximum number of retx exceeded (%d)\n", tb_idx, id, tti, max_retx);
Warning(
"SCHED: discarting TB %d pid=%d, tti=%d, maximum number of retx exceeded (%d)\n", tb_idx, id, tti, max_retx);
active[tb_idx] = false;
} else if (ack_) {
active[tb_idx] = false;
@ -121,10 +122,10 @@ void harq_proc::set_ack_common(uint32_t tb_idx, bool ack_)
}
void harq_proc::new_tx_common(uint32_t tb_idx, uint32_t tti_, int mcs, int tbs)
{
{
reset(tb_idx);
ndi[tb_idx] = !ndi[tb_idx];
tti = tti_;
tti = tti_;
tx_cnt[tb_idx]++;
last_mcs[tb_idx] = mcs;
last_tbs[tb_idx] = tbs;
@ -206,7 +207,7 @@ void dl_harq_proc::set_ack(uint32_t tb_idx, bool ack)
uint32_t dl_harq_proc::get_n_cce() const
{
return n_cce;
return n_cce;
}
rbgmask_t dl_harq_proc::get_rbgmask() const
@ -231,7 +232,7 @@ void dl_harq_proc::reset_pending_data()
reset_pending_data_common();
}
/******************************************************
/******************************************************
* UE::UL HARQ class *
******************************************************/
@ -296,7 +297,7 @@ void ul_harq_proc::reset_pending_data()
uint32_t ul_harq_proc::get_pending_data() const
{
return (uint32_t) pending_data;
return (uint32_t)pending_data;
}
}
} // namespace srsenb

43
srsenb/src/stack/mac/scheduler_metric.cc
Unescape Escape View File

@ -23,10 +23,10 @@
#include "srsenb/hdr/stack/mac/scheduler_harq.h"
#include <string.h>
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__)
#define Error(fmt, ...) log_h->error(fmt, ##__VA_ARGS__)
#define Warning(fmt, ...) log_h->warning(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__)
#define Info(fmt, ...) log_h->info(fmt, ##__VA_ARGS__)
#define Debug(fmt, ...) log_h->debug(fmt, ##__VA_ARGS__)
namespace srsenb {
@ -54,8 +54,8 @@ void dl_metric_rr::sched_users(std::map<uint16_t, sched_ue>& ue_db, dl_tti_sched
uint32_t priority_idx = tti_alloc->get_tti_tx_dl() % (uint32_t)ue_db.size();
it_t iter = ue_db.begin();
std::advance(iter, priority_idx);
for(uint32_t ue_count = 0 ; ue_count < ue_db.size() ; ++iter, ++ue_count) {
if(iter==ue_db.end()) {
for (uint32_t ue_count = 0; ue_count < ue_db.size(); ++iter, ++ue_count) {
if (iter == ue_db.end()) {
iter = ue_db.begin(); // wrap around
}
sched_ue* user = &iter->second;
@ -122,7 +122,7 @@ dl_harq_proc* dl_metric_rr::allocate_user(sched_ue* user)
h = user->get_empty_dl_harq();
if (h) {
#else
if (h && h->is_empty()) {
if (h && h->is_empty()) {
#endif
// Allocate resources based on pending data
if (req_bytes) {
@ -159,17 +159,18 @@ void ul_metric_rr::sched_users(std::map<uint16_t, sched_ue>& ue_db, ul_tti_sched
tti_alloc = tti_sched;
current_tti = tti_alloc->get_tti_tx_ul();
if(ue_db.size()==0)
return;
if (ue_db.size() == 0)
return;
// give priority in a time-domain RR basis
uint32_t priority_idx = (current_tti+(uint32_t)ue_db.size()/2) % (uint32_t)ue_db.size(); // make DL and UL interleaved
uint32_t priority_idx =
(current_tti + (uint32_t)ue_db.size() / 2) % (uint32_t)ue_db.size(); // make DL and UL interleaved
// allocate reTxs first
it_t iter = ue_db.begin();
std::advance(iter, priority_idx);
for(uint32_t ue_count = 0 ; ue_count < ue_db.size() ; ++iter, ++ue_count) {
if(iter==ue_db.end()) {
for (uint32_t ue_count = 0; ue_count < ue_db.size(); ++iter, ++ue_count) {
if (iter == ue_db.end()) {
iter = ue_db.begin(); // wrap around
}
sched_ue* user = &iter->second;
@ -178,9 +179,9 @@ void ul_metric_rr::sched_users(std::map<uint16_t, sched_ue>& ue_db, ul_tti_sched
// give priority in a time-domain RR basis
iter = ue_db.begin();
std::advance(iter,priority_idx);
for(uint32_t ue_count = 0 ; ue_count < ue_db.size() ; ++iter, ++ue_count) {
if(iter==ue_db.end()) {
std::advance(iter, priority_idx);
for (uint32_t ue_count = 0; ue_count < ue_db.size(); ++iter, ++ue_count) {
if (iter == ue_db.end()) {
iter = ue_db.begin(); // wrap around
}
sched_ue* user = &iter->second;
@ -200,12 +201,12 @@ bool ul_metric_rr::find_allocation(uint32_t L, ul_harq_proc::ul_alloc_t* alloc)
bzero(alloc, sizeof(ul_harq_proc::ul_alloc_t));
for (uint32_t n = 0; n < used_rb->size() && alloc->L < L; n++) {
if (not used_rb->test(n) && alloc->L == 0) {
alloc->RB_start = n;
alloc->RB_start = n;
}
if (not used_rb->test(n)) {
alloc->L++;
alloc->L++;
} else if (alloc->L > 0) {
// avoid edges
// avoid edges
if (n < 3) {
alloc->RB_start = 0;
alloc->L = 0;
@ -214,15 +215,15 @@ bool ul_metric_rr::find_allocation(uint32_t L, ul_harq_proc::ul_alloc_t* alloc)
}
}
}
if (alloc->L==0) {
if (alloc->L == 0) {
return false;
}
// Make sure L is allowed by SC-FDMA modulation
// Make sure L is allowed by SC-FDMA modulation
while (!srslte_dft_precoding_valid_prb(alloc->L)) {
alloc->L--;
}
return alloc->L == L;
return alloc->L == L;
}
ul_harq_proc* ul_metric_rr::allocate_user_retx_prbs(sched_ue* user)

302
srsenb/src/stack/mac/scheduler_ue.cc
Unescape Escape View File

@ -34,17 +34,16 @@
#define MCS_FIRST_DL 4
#define MIN_DATA_TBS 4
/******************************************************
/******************************************************
* UE class *
******************************************************/
namespace srsenb {
/*******************************************************
*
* Initialization and configuration functions
*
*
* Initialization and configuration functions
*
*******************************************************/
sched_ue::sched_ue() :
@ -110,10 +109,9 @@ void sched_ue::set_cfg(uint16_t rnti_,
}
}
for (int i=0;i<sched_interface::MAX_LC;i++) {
for (int i = 0; i < sched_interface::MAX_LC; i++) {
set_bearer_cfg(i, &cfg.ue_bearers[i]);
}
}
void sched_ue::reset()
@ -144,12 +142,13 @@ void sched_ue::reset()
}
}
for (int i=0;i<sched_interface::MAX_LC; i++) {
for (int i = 0; i < sched_interface::MAX_LC; i++) {
rem_bearer(i);
}
}
void sched_ue::set_fixed_mcs(int mcs_ul, int mcs_dl) {
void sched_ue::set_fixed_mcs(int mcs_ul, int mcs_dl)
{
std::lock_guard<std::mutex> lock(mutex);
fixed_mcs_ul = mcs_ul;
fixed_mcs_dl = mcs_dl;
@ -158,14 +157,14 @@ void sched_ue::set_fixed_mcs(int mcs_ul, int mcs_dl) {
void sched_ue::set_max_mcs(int mcs_ul, int mcs_dl, int max_aggr_level_) {
std::lock_guard<std::mutex> lock(mutex);
if (mcs_ul < 0) {
max_mcs_ul = 28;
max_mcs_ul = 28;
} else {
max_mcs_ul = mcs_ul;
max_mcs_ul = mcs_ul;
}
if (mcs_dl < 0) {
max_mcs_dl = 28;
max_mcs_dl = 28;
} else {
max_mcs_dl = mcs_dl;
max_mcs_dl = mcs_dl;
}
if (max_aggr_level_ < 0) {
max_aggr_level = 3;
@ -174,11 +173,10 @@ void sched_ue::set_max_mcs(int mcs_ul, int mcs_dl, int max_aggr_level_) {
}
}
/*******************************************************
*
* FAPI-like main scheduler interface.
*
*
* FAPI-like main scheduler interface.
*
*******************************************************/
void sched_ue::set_bearer_cfg(uint32_t lc_id, sched_interface::ue_bearer_cfg_t* cfg)
@ -186,10 +184,10 @@ void sched_ue::set_bearer_cfg(uint32_t lc_id, sched_interface::ue_bearer_cfg_t*
std::lock_guard<std::mutex> lock(mutex);
if (lc_id < sched_interface::MAX_LC) {
memcpy(&lch[lc_id].cfg, cfg, sizeof(sched_interface::ue_bearer_cfg_t));
lch[lc_id].buf_tx = 0;
lch[lc_id].buf_retx = 0;
lch[lc_id].buf_tx = 0;
lch[lc_id].buf_retx = 0;
if (lch[lc_id].cfg.direction != sched_interface::ue_bearer_cfg_t::IDLE) {
Info("SCHED: Set bearer config lc_id=%d, direction=%d\n", lc_id, (int) lch[lc_id].cfg.direction);
Info("SCHED: Set bearer config lc_id=%d, direction=%d\n", lc_id, (int)lch[lc_id].cfg.direction);
}
}
}
@ -204,8 +202,8 @@ void sched_ue::rem_bearer(uint32_t lc_id)
void sched_ue::phy_config_enabled(uint32_t tti, bool enabled)
{
dl_cqi_tti = tti;
phy_config_dedicated_enabled = enabled;
dl_cqi_tti = tti;
phy_config_dedicated_enabled = enabled;
}
void sched_ue::ul_buffer_state(uint8_t lc_id, uint32_t bsr, bool set_value)
@ -218,12 +216,11 @@ void sched_ue::ul_buffer_state(uint8_t lc_id, uint32_t bsr, bool set_value)
lch[lc_id].bsr += bsr;
}
}
Debug("SCHED: bsr=%d, lcid=%d, bsr={%d,%d,%d,%d}\n", bsr, lc_id,
lch[0].bsr, lch[1].bsr, lch[2].bsr, lch[3].bsr);
Debug("SCHED: bsr=%d, lcid=%d, bsr={%d,%d,%d,%d}\n", bsr, lc_id, lch[0].bsr, lch[1].bsr, lch[2].bsr, lch[3].bsr);
}
void sched_ue::ul_phr(int phr)
{
{
power_headroom = phr;
}
@ -245,12 +242,12 @@ void sched_ue::mac_buffer_state(uint32_t ce_code)
void sched_ue::set_sr()
{
sr = true;
sr = true;
}
void sched_ue::unset_sr()
{
sr = false;
sr = false;
}
void sched_ue::set_needs_ta_cmd(uint32_t nof_ta_cmd_) {
@ -292,7 +289,7 @@ bool sched_ue::get_pucch_sched(uint32_t current_tti, uint32_t prb_idx[2])
if (TTI_TX(dl_harq[i].get_tti()) == current_tti) {
cfg.pucch_cfg.uci_cfg.ack[0].ncce[0] = dl_harq[i].get_n_cce();
cfg.pucch_cfg.uci_cfg.ack[0].nof_acks = 1;
ret = true;
ret = true;
}
}
// Periodic CQI
@ -322,8 +319,8 @@ bool sched_ue::get_pucch_sched(uint32_t current_tti, uint32_t prb_idx[2])
int sched_ue::set_ack_info(uint32_t tti, uint32_t tb_idx, bool ack)
{
std::lock_guard<std::mutex> lock(mutex);
int ret = -1;
for (int i=0;i<SCHED_MAX_HARQ_PROC;i++) {
int ret = -1;
for (int i = 0; i < SCHED_MAX_HARQ_PROC; i++) {
if (TTI_TX(dl_harq[i].get_tti()) == tti) {
Debug("SCHED: Set ACK=%d for rnti=0x%x, pid=%d, tb=%d, tti=%d\n", ack, rnti, i, tb_idx, tti);
dl_harq[i].set_ack(tb_idx, ack);
@ -345,19 +342,18 @@ void sched_ue::ul_recv_len(uint32_t lcid, uint32_t len)
// Remove PDCP header??
if (len > 4) {
len -= 4;
len -= 4;
}
if (lcid < sched_interface::MAX_LC) {
if (bearer_is_ul(&lch[lcid])) {
if (lch[lcid].bsr > (int) len) {
if (lch[lcid].bsr > (int)len) {
lch[lcid].bsr -= len;
} else {
lch[lcid].bsr = 0;
}
}
}
Debug("SCHED: recv_len=%d, lcid=%d, bsr={%d,%d,%d,%d}\n", len, lcid,
lch[0].bsr, lch[1].bsr, lch[2].bsr, lch[3].bsr);
Debug("SCHED: recv_len=%d, lcid=%d, bsr={%d,%d,%d,%d}\n", len, lcid, lch[0].bsr, lch[1].bsr, lch[2].bsr, lch[3].bsr);
}
void sched_ue::set_ul_crc(uint32_t tti, bool crc_res)
@ -400,16 +396,18 @@ void sched_ue::set_ul_cqi(uint32_t tti, uint32_t cqi, uint32_t ul_ch_code)
ul_cqi_tti = tti;
}
void sched_ue::tpc_inc() {
void sched_ue::tpc_inc()
{
std::lock_guard<std::mutex> lock(mutex);
if (power_headroom > 0) {
next_tpc_pusch = 3;
next_tpc_pucch = 3;
next_tpc_pucch = 3;
}
log_h->info("SCHED: Set TCP=%d for rnti=0x%x\n", next_tpc_pucch, rnti);
}
void sched_ue::tpc_dec() {
void sched_ue::tpc_dec()
{
std::lock_guard<std::mutex> lock(mutex);
next_tpc_pusch = 0;
next_tpc_pucch = 0;
@ -417,9 +415,9 @@ void sched_ue::tpc_dec() {
}
/*******************************************************
*
* Functions used to generate DCI grants
*
*
* Functions used to generate DCI grants
*
*******************************************************/
// Generates a Format1 dci
@ -531,7 +529,7 @@ int sched_ue::generate_format2a(
dl_harq_proc* h, sched_interface::dl_sched_data_t* data, uint32_t tti, uint32_t cfi, const rbgmask_t& user_mask)
{
std::lock_guard<std::mutex> lock(mutex);
int ret = generate_format2a_unlocked(h, data, tti, cfi, user_mask);
int ret = generate_format2a_unlocked(h, data, tti, cfi, user_mask);
return ret;
}
@ -571,7 +569,7 @@ int sched_ue::generate_format2a_unlocked(
for (uint32_t tb = 0; tb < SRSLTE_MAX_TB; tb++) {
if (!h->is_empty(tb)) {
tb_en[tb] = true;
no_retx = false;
no_retx = false;
}
}
/* Two layers, no retransmissions... */
@ -583,8 +581,8 @@ int sched_ue::generate_format2a_unlocked(
for (uint32_t tb = 0; tb < SRSLTE_MAX_TB; tb++) {
uint32_t req_bytes = get_pending_dl_new_data_total_unlocked(tti);
int mcs = 0;
int tbs = 0;
int mcs = 0;
int tbs = 0;
if (!h->is_empty(tb)) {
h->new_retx(user_mask, tb, tti, &mcs, &tbs, data->dci.location.ncce);
@ -631,7 +629,7 @@ int sched_ue::generate_format2a_unlocked(
dci->format = SRSLTE_DCI_FORMAT2A;
dci->rnti = rnti;
dci->pid = h->get_id();
dci->tpc_pucch = (uint8_t) next_tpc_pucch;
dci->tpc_pucch = (uint8_t)next_tpc_pucch;
next_tpc_pucch = 1;
int ret = data->tbs[0] + data->tbs[1];
@ -651,9 +649,9 @@ int sched_ue::generate_format2(
/* Compute precoding information */
data->dci.format = SRSLTE_DCI_FORMAT2;
if ((SRSLTE_DCI_IS_TB_EN(data->dci.tb[0]) + SRSLTE_DCI_IS_TB_EN(data->dci.tb[1])) == 1) {
data->dci.pinfo = (uint8_t) (dl_pmi + 1) % (uint8_t) 5;
data->dci.pinfo = (uint8_t)(dl_pmi + 1) % (uint8_t)5;
} else {
data->dci.pinfo = (uint8_t) (dl_pmi & 1);
data->dci.pinfo = (uint8_t)(dl_pmi & 1);
}
return ret;
@ -701,7 +699,7 @@ int sched_ue::generate_format0(sched_interface::ul_sched_data_t* data,
} else {
// retx
h->new_retx(0, tti, &mcs, NULL, alloc);
tbs = srslte_ra_tbs_from_idx(srslte_ra_tbs_idx_from_mcs(mcs, true), alloc.L) / 8;
tbs = srslte_ra_tbs_from_idx(srslte_ra_tbs_idx_from_mcs(mcs, true), alloc.L) / 8;
}
data->tbs = tbs;
@ -719,45 +717,50 @@ int sched_ue::generate_format0(sched_interface::ul_sched_data_t* data,
dci->tb.ndi = h->get_ndi(0);
dci->cqi_request = cqi_request;
dci->freq_hop_fl = srslte_dci_ul_t::SRSLTE_RA_PUSCH_HOP_DISABLED;
dci->tpc_pusch = next_tpc_pusch;
next_tpc_pusch = 1;
dci->tpc_pusch = next_tpc_pusch;
next_tpc_pusch = 1;
}
return tbs;
}
/*******************************************************
*
*
* Functions used by scheduler or scheduler metric objects
*
*
*******************************************************/
bool sched_ue::bearer_is_ul(ue_bearer_t *lch) {
return lch->cfg.direction == sched_interface::ue_bearer_cfg_t::UL || lch->cfg.direction == sched_interface::ue_bearer_cfg_t::BOTH;
bool sched_ue::bearer_is_ul(ue_bearer_t* lch)
{
return lch->cfg.direction == sched_interface::ue_bearer_cfg_t::UL ||
lch->cfg.direction == sched_interface::ue_bearer_cfg_t::BOTH;
}
bool sched_ue::bearer_is_dl(ue_bearer_t *lch) {
return lch->cfg.direction == sched_interface::ue_bearer_cfg_t::DL || lch->cfg.direction == sched_interface::ue_bearer_cfg_t::BOTH;
bool sched_ue::bearer_is_dl(ue_bearer_t* lch)
{
return lch->cfg.direction == sched_interface::ue_bearer_cfg_t::DL ||
lch->cfg.direction == sched_interface::ue_bearer_cfg_t::BOTH;
}
uint32_t sched_ue::get_max_retx() {
return cfg.maxharq_tx;
uint32_t sched_ue::get_max_retx()
{
return cfg.maxharq_tx;
}
bool sched_ue::is_first_dl_tx()
{
for (int i=0;i<SCHED_MAX_HARQ_PROC;i++) {
for (int i = 0; i < SCHED_MAX_HARQ_PROC; i++) {
if (dl_harq[i].nof_tx(0) > 0) {
return false;
return false;
}
}
return true;
return true;
}
bool sched_ue::needs_cqi(uint32_t tti, bool will_be_sent)
{
std::lock_guard<std::mutex> lock(mutex);
bool ret = needs_cqi_unlocked(tti, will_be_sent);
bool ret = needs_cqi_unlocked(tti, will_be_sent);
return ret;
}
@ -765,12 +768,9 @@ bool sched_ue::needs_cqi(uint32_t tti, bool will_be_sent)
bool sched_ue::needs_cqi_unlocked(uint32_t tti, bool will_be_sent)
{
bool ret = false;
if (phy_config_dedicated_enabled &&
cfg.aperiodic_cqi_period &&
get_pending_dl_new_data_unlocked(tti) > 0)
{
if (phy_config_dedicated_enabled && cfg.aperiodic_cqi_period && get_pending_dl_new_data_unlocked(tti) > 0) {
uint32_t interval = srslte_tti_interval(tti, dl_cqi_tti);
bool needscqi = interval >= cfg.aperiodic_cqi_period;
bool needscqi = interval >= cfg.aperiodic_cqi_period;
if (needscqi) {
uint32_t interval_sent = srslte_tti_interval(tti, cqi_request_tti);
if (interval_sent >= 16) {
@ -788,7 +788,7 @@ bool sched_ue::needs_cqi_unlocked(uint32_t tti, bool will_be_sent)
uint32_t sched_ue::get_pending_dl_new_data(uint32_t tti)
{
std::lock_guard<std::mutex> lock(mutex);
uint32_t pending_data = get_pending_dl_new_data_unlocked(tti);
uint32_t pending_data = get_pending_dl_new_data_unlocked(tti);
return pending_data;
}
@ -799,16 +799,16 @@ uint32_t sched_ue::get_pending_dl_new_data(uint32_t tti)
uint32_t sched_ue::get_pending_dl_new_data_total(uint32_t tti)
{
std::lock_guard<std::mutex> lock(mutex);
uint32_t req_bytes = get_pending_dl_new_data_total_unlocked(tti);
uint32_t req_bytes = get_pending_dl_new_data_total_unlocked(tti);
return req_bytes;
}
uint32_t sched_ue::get_pending_dl_new_data_total_unlocked(uint32_t tti)
{
uint32_t req_bytes = get_pending_dl_new_data_unlocked(tti);
if(req_bytes>0) {
if (req_bytes > 0) {
req_bytes += (req_bytes < 128) ? 2 : 3; // consider the header
if(is_first_dl_tx()) {
if (is_first_dl_tx()) {
req_bytes += 6; // count for RAR
}
}
@ -819,7 +819,7 @@ uint32_t sched_ue::get_pending_dl_new_data_total_unlocked(uint32_t tti)
uint32_t sched_ue::get_pending_dl_new_data_unlocked(uint32_t tti)
{
uint32_t pending_data = 0;
for (int i=0;i<sched_interface::MAX_LC;i++) {
for (int i = 0; i < sched_interface::MAX_LC; i++) {
if (bearer_is_dl(&lch[i])) {
pending_data += lch[i].buf_retx + lch[i].buf_tx;
}
@ -833,14 +833,14 @@ uint32_t sched_ue::get_pending_dl_new_data_unlocked(uint32_t tti)
uint32_t sched_ue::get_pending_ul_new_data(uint32_t tti)
{
std::lock_guard<std::mutex> lock(mutex);
uint32_t pending_data = get_pending_ul_new_data_unlocked(tti);
uint32_t pending_data = get_pending_ul_new_data_unlocked(tti);
return pending_data;
}
uint32_t sched_ue::get_pending_ul_old_data()
{
std::lock_guard<std::mutex> lock(mutex);
uint32_t pending_data = get_pending_ul_old_data_unlocked();
uint32_t pending_data = get_pending_ul_old_data_unlocked();
return pending_data;
}
@ -848,7 +848,7 @@ uint32_t sched_ue::get_pending_ul_old_data()
uint32_t sched_ue::get_pending_ul_new_data_unlocked(uint32_t tti)
{
uint32_t pending_data = 0;
for (int i=0;i<sched_interface::MAX_LC;i++) {
for (int i = 0; i < sched_interface::MAX_LC; i++) {
if (bearer_is_ul(&lch[i])) {
pending_data += lch[i].bsr;
}
@ -866,8 +866,13 @@ uint32_t sched_ue::get_pending_ul_new_data_unlocked(uint32_t tti)
pending_data = 0;
}
if (pending_data) {
Debug("SCHED: pending_data=%d, pending_ul_data=%d, bsr={%d,%d,%d,%d}\n", pending_data,pending_ul_data,
lch[0].bsr, lch[1].bsr, lch[2].bsr, lch[3].bsr);
Debug("SCHED: pending_data=%d, pending_ul_data=%d, bsr={%d,%d,%d,%d}\n",
pending_data,
pending_ul_data,
lch[0].bsr,
lch[1].bsr,
lch[2].bsr,
lch[3].bsr);
}
return pending_data;
}
@ -876,7 +881,7 @@ uint32_t sched_ue::get_pending_ul_new_data_unlocked(uint32_t tti)
uint32_t sched_ue::get_pending_ul_old_data_unlocked()
{
uint32_t pending_data = 0;
for (int i=0;i<SCHED_MAX_HARQ_PROC;i++) {
for (int i = 0; i < SCHED_MAX_HARQ_PROC; i++) {
pending_data += ul_harq[i].get_pending_data();
}
return pending_data;
@ -884,12 +889,12 @@ uint32_t sched_ue::get_pending_ul_old_data_unlocked()
uint32_t sched_ue::prb_to_rbg(uint32_t nof_prb)
{
return (uint32_t) ceil((float) nof_prb / P);
return (uint32_t)ceil((float)nof_prb / P);
}
uint32_t sched_ue::rgb_to_prb(uint32_t nof_rbg)
{
return P*nof_rbg;
return P * nof_rbg;
}
uint32_t sched_ue::get_required_prb_dl(uint32_t req_bytes, uint32_t nof_ctrl_symbols)
@ -903,10 +908,10 @@ uint32_t sched_ue::get_required_prb_dl(uint32_t req_bytes, uint32_t nof_ctrl_sym
uint32_t nbytes = 0;
uint32_t n;
int mcs0 = (is_first_dl_tx() and cell.nof_prb == 6) ? MCS_FIRST_DL : fixed_mcs_dl;
for (n=0; n < cell.nof_prb && nbytes < req_bytes; ++n) {
for (n = 0; n < cell.nof_prb && nbytes < req_bytes; ++n) {
nof_re = srslte_ra_dl_approx_nof_re(&cell, n + 1, nof_ctrl_symbols);
if (mcs0 < 0) {
tbs = alloc_tbs_dl(n+1, nof_re, 0, &mcs);
tbs = alloc_tbs_dl(n + 1, nof_re, 0, &mcs);
} else {
tbs = srslte_ra_tbs_from_idx(srslte_ra_tbs_idx_from_mcs(mcs0, false), n + 1) / 8;
}
@ -920,33 +925,33 @@ uint32_t sched_ue::get_required_prb_dl(uint32_t req_bytes, uint32_t nof_ctrl_sym
return n;
}
uint32_t sched_ue::get_required_prb_ul(uint32_t req_bytes)
uint32_t sched_ue::get_required_prb_ul(uint32_t req_bytes)
{
int mcs = 0;
uint32_t nbytes = 0;
uint32_t N_srs = 0;
uint32_t N_srs = 0;
uint32_t n = 0;
if (req_bytes == 0) {
return 0;
return 0;
}
std::lock_guard<std::mutex> lock(mutex);
for (n = 1; n < cell.nof_prb && nbytes < req_bytes + 4; n++) {
uint32_t nof_re = (2*(SRSLTE_CP_NSYMB(cell.cp)-1) - N_srs)*n*SRSLTE_NRE;
int tbs = 0;
uint32_t nof_re = (2 * (SRSLTE_CP_NSYMB(cell.cp) - 1) - N_srs) * n * SRSLTE_NRE;
int tbs = 0;
if (fixed_mcs_ul < 0) {
tbs = alloc_tbs_ul(n, nof_re, 0, &mcs);
} else {
tbs = srslte_ra_tbs_from_idx(srslte_ra_tbs_idx_from_mcs(fixed_mcs_ul, true), n) / 8;
}
if (tbs > 0) {
nbytes = tbs;
nbytes = tbs;
}
}
while (!srslte_dft_precoding_valid_prb(n) && n<=cell.nof_prb) {
while (!srslte_dft_precoding_valid_prb(n) && n <= cell.nof_prb) {
n++;
}
@ -955,7 +960,7 @@ uint32_t sched_ue::get_required_prb_ul(uint32_t req_bytes)
bool sched_ue::is_sr_triggered()
{
return sr;
return sr;
}
void sched_ue::reset_pending_pids(uint32_t tti_rx)
@ -966,7 +971,7 @@ void sched_ue::reset_pending_pids(uint32_t tti_rx)
get_ul_harq(tti_tx_ul)->reset_pending_data();
// DL harqs
for (int i=0;i<SCHED_MAX_HARQ_PROC;i++) {
for (int i = 0; i < SCHED_MAX_HARQ_PROC; i++) {
dl_harq[i].reset_pending_data();
if (not dl_harq[i].is_empty()) {
uint32_t tti_diff = srslte_tti_interval(tti_tx_dl, dl_harq[i].get_tti());
@ -986,18 +991,18 @@ dl_harq_proc* sched_ue::get_pending_dl_harq(uint32_t tti)
std::lock_guard<std::mutex> lock(mutex);
int oldest_idx=-1;
uint32_t oldest_tti = 0;
for (int i=0;i<SCHED_MAX_HARQ_PROC;i++) {
int oldest_idx = -1;
uint32_t oldest_tti = 0;
for (int i = 0; i < SCHED_MAX_HARQ_PROC; i++) {
if (dl_harq[i].has_pending_retx(0, tti) || dl_harq[i].has_pending_retx(1, tti)) {
uint32_t x = srslte_tti_interval(tti, dl_harq[i].get_tti());
if (x > oldest_tti) {
oldest_idx = i;
oldest_tti = x;
oldest_idx = i;
oldest_tti = x;
}
}
}
dl_harq_proc *h = NULL;
dl_harq_proc* h = NULL;
if (oldest_idx >= 0) {
h = &dl_harq[oldest_idx];
}
@ -1005,7 +1010,7 @@ dl_harq_proc* sched_ue::get_pending_dl_harq(uint32_t tti)
return h;
#else
return &dl_harq[tti%SCHED_MAX_HARQ_PROC];
return &dl_harq[tti % SCHED_MAX_HARQ_PROC];
#endif
}
@ -1013,8 +1018,8 @@ dl_harq_proc* sched_ue::get_empty_dl_harq()
{
std::lock_guard<std::mutex> lock(mutex);
dl_harq_proc *h = NULL;
for (int i=0;i<SCHED_MAX_HARQ_PROC && !h;i++) {
dl_harq_proc* h = NULL;
for (int i = 0; i < SCHED_MAX_HARQ_PROC && !h; i++) {
if (dl_harq[i].is_empty(0) && dl_harq[i].is_empty(1)) {
h = &dl_harq[i];
}
@ -1042,7 +1047,8 @@ dl_harq_proc* sched_ue::get_dl_harq(uint32_t idx)
return &dl_harq[idx];
}
srslte_dci_format_t sched_ue::get_dci_format() {
srslte_dci_format_t sched_ue::get_dci_format()
{
srslte_dci_format_t ret = SRSLTE_DCI_FORMAT1;
if (phy_config_dedicated_enabled) {
@ -1072,16 +1078,15 @@ srslte_dci_format_t sched_ue::get_dci_format() {
return ret;
}
/* Find lowest DCI aggregation level supported by the UE spectral efficiency */
uint32_t sched_ue::get_aggr_level(uint32_t nof_bits)
{
std::lock_guard<std::mutex> lock(mutex);
uint32_t l=0;
float max_coderate = srslte_cqi_to_coderate(dl_cqi);
float coderate = 99;
float factor=1.5;
uint32_t l_max = 3;
uint32_t l = 0;
float max_coderate = srslte_cqi_to_coderate(dl_cqi);
float coderate = 99;
float factor = 1.5;
uint32_t l_max = 3;
if (cell.nof_prb == 6) {
factor = 1.0;
l_max = 2;
@ -1090,53 +1095,59 @@ uint32_t sched_ue::get_aggr_level(uint32_t nof_bits)
do {
coderate = srslte_pdcch_coderate(nof_bits, l);
l++;
} while(l<l_max && factor*coderate > max_coderate);
Debug("SCHED: CQI=%d, l=%d, nof_bits=%d, coderate=%.2f, max_coderate=%.2f\n", dl_cqi, l, nof_bits, coderate, max_coderate);
} while (l < l_max && factor * coderate > max_coderate);
Debug("SCHED: CQI=%d, l=%d, nof_bits=%d, coderate=%.2f, max_coderate=%.2f\n",
dl_cqi,
l,
nof_bits,
coderate,
max_coderate);
return l;
}
sched_ue::sched_dci_cce_t* sched_ue::get_locations(uint32_t cfi, uint32_t sf_idx)
{
if (cfi > 0 && cfi <= 3) {
return &dci_locations[cfi-1][sf_idx];
return &dci_locations[cfi - 1][sf_idx];
} else {
Error("SCHED: Invalid CFI=%d\n", cfi);
return &dci_locations[0][sf_idx];
}
return &dci_locations[0][sf_idx];
}
}
/* Allocates first available RLC PDU */
int sched_ue::alloc_pdu(int tbs_bytes, sched_interface::dl_sched_pdu_t* pdu)
{
// TODO: Implement lcid priority (now lowest index is lowest priority)
int x = 0;
int i = 0;
for (i=0;i<sched_interface::MAX_LC && !x;i++) {
int x = 0;
int i = 0;
for (i = 0; i < sched_interface::MAX_LC && !x; i++) {
if (lch[i].buf_retx) {
x = SRSLTE_MIN(lch[i].buf_retx, tbs_bytes);
lch[i].buf_retx -= x;
lch[i].buf_retx -= x;
} else if (lch[i].buf_tx) {
x = SRSLTE_MIN(lch[i].buf_tx, tbs_bytes);
lch[i].buf_tx -= x;
lch[i].buf_tx -= x;
}
}
if (x) {
pdu->lcid = i-1;
pdu->nbytes = x;
pdu->lcid = i - 1;
pdu->nbytes = x;
Debug("SCHED: Allocated lcid=%d, nbytes=%d, tbs_bytes=%d\n", pdu->lcid, pdu->nbytes, tbs_bytes);
}
return x;
}
uint32_t sched_ue::format1_count_prb(uint32_t bitmask, uint32_t cell_nof_prb) {
uint32_t P = srslte_ra_type0_P(cell_nof_prb);
uint32_t nb = (int) ceilf((float) cell_nof_prb / P);
uint32_t nof_prb = 0;
uint32_t sched_ue::format1_count_prb(uint32_t bitmask, uint32_t cell_nof_prb)
{
uint32_t P = srslte_ra_type0_P(cell_nof_prb);
uint32_t nb = (int)ceilf((float)cell_nof_prb / P);
uint32_t nof_prb = 0;
for (uint32_t i = 0; i < nb; i++) {
if (bitmask & (1 << (nb - i - 1))) {
for (uint32_t j = 0; j < P; j++) {
if (i*P+j < cell_nof_prb) {
if (i * P + j < cell_nof_prb) {
nof_prb++;
}
}
@ -1145,12 +1156,12 @@ uint32_t sched_ue::format1_count_prb(uint32_t bitmask, uint32_t cell_nof_prb) {
return nof_prb;
}
int sched_ue::cqi_to_tbs(uint32_t cqi, uint32_t nof_prb, uint32_t nof_re, uint32_t max_mcs, uint32_t max_Qm, bool is_ul,
uint32_t* mcs)
int sched_ue::cqi_to_tbs(
uint32_t cqi, uint32_t nof_prb, uint32_t nof_re, uint32_t max_mcs, uint32_t max_Qm, bool is_ul, uint32_t* mcs)
{
float max_coderate = srslte_cqi_to_coderate(cqi);
float max_coderate = srslte_cqi_to_coderate(cqi);
int sel_mcs = max_mcs + 1;
float coderate = 99;
float coderate = 99;
float eff_coderate = 99;
uint32_t Qm = 1;
int tbs = 0;
@ -1162,43 +1173,33 @@ int sched_ue::cqi_to_tbs(uint32_t cqi, uint32_t nof_prb, uint32_t nof_re, uint32
coderate = srslte_coderate(tbs, nof_re);
srslte_mod_t mod = (is_ul) ? srslte_ra_ul_mod_from_mcs(sel_mcs) : srslte_ra_dl_mod_from_mcs(sel_mcs);
Qm = SRSLTE_MIN(max_Qm, srslte_mod_bits_x_symbol(mod));
eff_coderate = coderate/Qm;
} while((sel_mcs > 0 && coderate > max_coderate) || eff_coderate > 0.930);
eff_coderate = coderate / Qm;
} while ((sel_mcs > 0 && coderate > max_coderate) || eff_coderate > 0.930);
if (mcs) {
*mcs = (uint32_t)sel_mcs;
}
return tbs;
}
int sched_ue::alloc_tbs_dl(uint32_t nof_prb,
uint32_t nof_re,
uint32_t req_bytes,
int *mcs)
int sched_ue::alloc_tbs_dl(uint32_t nof_prb, uint32_t nof_re, uint32_t req_bytes, int* mcs)
{
return alloc_tbs(nof_prb, nof_re, req_bytes, false, mcs);
}
int sched_ue::alloc_tbs_ul(uint32_t nof_prb,
uint32_t nof_re,
uint32_t req_bytes,
int *mcs)
int sched_ue::alloc_tbs_ul(uint32_t nof_prb, uint32_t nof_re, uint32_t req_bytes, int* mcs)
{
return alloc_tbs(nof_prb, nof_re, req_bytes, true, mcs);
}
/* In this scheduler we tend to use all the available bandwidth and select the MCS
* that approximates the minimum between the capacity and the requested rate
/* In this scheduler we tend to use all the available bandwidth and select the MCS
* that approximates the minimum between the capacity and the requested rate
*/
int sched_ue::alloc_tbs(uint32_t nof_prb,
uint32_t nof_re,
uint32_t req_bytes,
bool is_ul,
int *mcs)
int sched_ue::alloc_tbs(uint32_t nof_prb, uint32_t nof_re, uint32_t req_bytes, bool is_ul, int* mcs)
{
uint32_t sel_mcs = 0;
uint32_t cqi = is_ul?ul_cqi:dl_cqi;
uint32_t max_mcs = is_ul?max_mcs_ul:max_mcs_dl;
uint32_t cqi = is_ul ? ul_cqi : dl_cqi;
uint32_t max_mcs = is_ul ? max_mcs_ul : max_mcs_dl;
uint32_t max_Qm = is_ul ? 4 : 6; // Allow 16-QAM in PUSCH Only
// TODO: Compute real spectral efficiency based on PUSCH-UCI configuration
@ -1222,11 +1223,10 @@ int sched_ue::alloc_tbs(uint32_t nof_prb,
}
if (mcs && tbs_bytes >= 0) {
*mcs = (int) sel_mcs;
*mcs = (int)sel_mcs;
}
return tbs_bytes;
}
}
} // namespace srsenb

8
srsenb/test/mac/scheduler_test_rand.cc
Unescape Escape View File

@ -181,10 +181,10 @@ struct sched_tester : public srsenb::sched {
ra_sched_t::pending_msg3_t ul_pending_msg3;
srslte::bounded_bitset<128, true> used_cce;
// std::vector<bool> used_cce;
std::map<uint16_t, tester_user_results> ue_data; ///< stores buffer state of each user
tester_user_results total_ues; ///< stores combined UL/DL buffer state
srsenb::sched_interface::ul_sched_res_t sched_result_ul;
srsenb::sched_interface::dl_sched_res_t sched_result_dl;
std::map<uint16_t, tester_user_results> ue_data; ///< stores buffer state of each user
tester_user_results total_ues; ///< stores combined UL/DL buffer state
srsenb::sched_interface::ul_sched_res_t sched_result_ul;
srsenb::sched_interface::dl_sched_res_t sched_result_dl;
};
struct ue_info {
int prach_tti = -1, rar_tti = -1, msg3_tti = -1;

Write Preview
Loading…
Cancel
Save