5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
fix-cqi
master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '3a533706bf'
${ noResults }
srsRAN_4G/srsenb/test/mac/sched_dci_test.cc

340 lines
12 KiB
C++
Raw Blame History

/**
* Copyright 2013-2023 Software Radio Systems Limited
*
* This file is part of srsRAN.
*
* srsRAN is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of
* the License, or (at your option) any later version.
*
* srsRAN is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* A copy of the GNU Affero General Public License can be found in
* the LICENSE file in the top-level directory of this distribution
* and at http://www.gnu.org/licenses/.
*
*/
#include "sched_test_utils.h"
#include "srsenb/hdr/stack/mac/sched_lte_common.h"
#include "srsenb/hdr/stack/mac/sched_phy_ch/sched_dci.h"
#include "srsran/common/common_lte.h"
#include "srsran/support/srsran_test.h"
namespace srsenb {
struct tbs_test_args {
bool verbose = false;
bool is_ul = false;
bool use_tbs_index_alt = false;
bool ul64qam_enabled = false;
uint32_t cqi = 5;
uint32_t max_mcs = 28;
uint32_t prb_grant_size = 1;
int req_bytes = std::numeric_limits<int>::max();
tti_point tti_tx_dl{0};
uint32_t get_max_Qm() const
{
if (is_ul) {
return ul64qam_enabled ? 6 : 4;
}
return use_tbs_index_alt ? 8 : 6;
}
float get_max_coderate() const
{
if (is_ul) {
return srsran_cqi_to_coderate(std::min(cqi + 1u, 15u), false);
}
return srsran_cqi_to_coderate(std::min(cqi + 1u, 15u), use_tbs_index_alt);
}
};
bool lower_coderate(tbs_info tb, uint32_t nof_re, const tbs_test_args& args)
{
float max_coderate = srsran_cqi_to_coderate(std::min(args.cqi + 1u, 15u), args.use_tbs_index_alt);
float coderate = srsran_coderate(tb.tbs_bytes * 8, nof_re);
if (coderate > max_coderate) {
return false;
}
srsran_mod_t mod =
(args.is_ul) ? srsran_ra_ul_mod_from_mcs(tb.mcs) : srsran_ra_dl_mod_from_mcs(tb.mcs, args.use_tbs_index_alt);
float Qm = std::min(args.get_max_Qm(), srsran_mod_bits_x_symbol(mod));
return coderate <= 0.932f * Qm;
}
int test_mcs_tbs_dl_helper(const sched_cell_params_t& cell_params, const tbs_test_args& args, tbs_info* result)
{
srsran_dci_dl_t dci;
dci.format = SRSRAN_DCI_FORMAT1;
dci.alloc_type = SRSRAN_RA_ALLOC_TYPE0;
rbgmask_t rbgmask(cell_params.nof_rbgs);
rbgmask.fill(0, cell_params.nof_prbs_to_rbgs(args.prb_grant_size));
dci.type0_alloc.rbg_bitmask = (uint32_t)rbgmask.to_uint64();
uint32_t nof_re = cell_params.get_dl_nof_res(args.tti_tx_dl, dci, 1);
float max_coderate = args.get_max_coderate();
if (srsran_coderate(16, nof_re) > max_coderate) {
// no solution is possible
return SRSRAN_SUCCESS;
}
// Verify MCS, TBS
tbs_info ret = compute_mcs_and_tbs(
args.prb_grant_size, nof_re, args.cqi, args.max_mcs, args.is_ul, args.ul64qam_enabled, args.use_tbs_index_alt);
if (ret.tbs_bytes < 0) {
return SRSRAN_SUCCESS;
}
if (result != nullptr) {
*result = ret;
}
CONDERROR(ret.mcs > (int)args.max_mcs, "Result mcs=%d is higher than stipulated max_mcs=%d", ret.mcs, args.max_mcs);
// Verify TBS is a valid value in TS tables
uint32_t tbs_idx = srsran_ra_tbs_idx_from_mcs(ret.mcs, args.use_tbs_index_alt, args.is_ul);
int expected_tbs = srsran_ra_tbs_from_idx(tbs_idx, args.prb_grant_size);
CONDERROR(expected_tbs != ret.tbs_bytes * 8,
"The tbs=%d is not valid. For {mcs=%d,tbs_idx=%d,nof_re=%d,nof_prb=%d}, it should have been tbs=%d",
ret.tbs_bytes * 8,
ret.mcs,
tbs_idx,
nof_re,
args.prb_grant_size,
expected_tbs);
// Verify coderate doesn't surpass maximum
CONDERROR(not lower_coderate(ret, nof_re, args), "Coderate is higher than maximum");
// Verify there were no better {mcs,tbs} solutions
tbs_info tb2;
for (tb2.mcs = ret.mcs + 1; tb2.mcs <= (int)args.max_mcs; ++tb2.mcs) {
int tbs_idx2 = srsran_ra_tbs_idx_from_mcs(tb2.mcs, args.use_tbs_index_alt, args.is_ul);
tb2.tbs_bytes = srsran_ra_tbs_from_idx(tbs_idx2, args.prb_grant_size) / 8U;
TESTASSERT(not lower_coderate(tb2, nof_re, args) or (args.prb_grant_size == 1 and tb2.mcs == 6));
}
// log results
if (args.verbose) {
printf("input={max_mcs=%d,cqi=%d,nof_prb=%d,nof_re=%d} -> output={mcs=%d, tbs=%d, tbs_index=%d}\n",
args.max_mcs,
args.cqi,
args.prb_grant_size,
nof_re,
ret.mcs,
ret.tbs_bytes * 8,
tbs_idx);
}
return SRSRAN_SUCCESS;
}
int assert_mcs_tbs_result(uint32_t cell_nof_prb,
uint32_t cqi,
uint32_t prb_grant_size,
uint32_t tbs,
uint32_t mcs,
bool alt_cqi_table = false)
{
sched_cell_params_t cell_params = {};
sched_interface::cell_cfg_t cell_cfg = generate_default_cell_cfg(cell_nof_prb);
sched_interface::sched_args_t sched_args = {};
cell_params.set_cfg(0, cell_cfg, sched_args);
tbs_test_args args;
args.verbose = true;
args.cqi = cqi;
args.prb_grant_size = prb_grant_size;
args.use_tbs_index_alt = alt_cqi_table;
if (alt_cqi_table) {
args.max_mcs = std::min(args.max_mcs, 27U); // limited to 27 for 256-QAM
}
tbs_info expected_result;
TESTASSERT(test_mcs_tbs_dl_helper(cell_params, args, &expected_result) == SRSRAN_SUCCESS);
CONDERROR(expected_result != tbs_info(tbs / 8, mcs),
"TBS computation failure. {%d, %d}!={%d, %d}",
expected_result.tbs_bytes * 8,
expected_result.mcs,
tbs,
mcs);
return SRSRAN_SUCCESS;
}
int test_mcs_lookup_specific()
{
/* TEST CASE: DL, no 256-QAM */
// cqi=5,Nprb=1 -> {mcs=3, tbs_idx=3, tbs=40}
TESTASSERT(assert_mcs_tbs_result(6, 5, 1, 40, 3) == SRSRAN_SUCCESS);
TESTASSERT(assert_mcs_tbs_result(6, 5, 4, 256, 4) == SRSRAN_SUCCESS);
TESTASSERT(assert_mcs_tbs_result(100, 9, 1, 712, 28) == SRSRAN_SUCCESS);
TESTASSERT(assert_mcs_tbs_result(100, 10, 10, 5736, 25) == SRSRAN_SUCCESS);
// cqi=15
TESTASSERT(assert_mcs_tbs_result(6, 15, 1, 336, 19) == SRSRAN_SUCCESS); // I_tbs=17
TESTASSERT(assert_mcs_tbs_result(6, 15, 6, 2152, 19) == SRSRAN_SUCCESS); // I_tbs=17
TESTASSERT(assert_mcs_tbs_result(100, 15, 1, 712, 28) == SRSRAN_SUCCESS); // I_tbs=26
TESTASSERT(assert_mcs_tbs_result(100, 15, 2, 1480, 28) == SRSRAN_SUCCESS); // I_tbs=26
TESTASSERT(assert_mcs_tbs_result(100, 15, 10, 7480, 28) == SRSRAN_SUCCESS); // I_tbs=26
TESTASSERT(assert_mcs_tbs_result(100, 15, 1, 968, 27, true) == SRSRAN_SUCCESS);
return SRSRAN_SUCCESS;
}
/// Verify consistency of MCS,TBS computation for different permutations of banwidths, grant sizes, cqi, max_mcs
int test_mcs_tbs_consistency_all()
{
sched_interface::sched_args_t sched_args = {};
for (auto& nof_prb_cell : srsran::lte_cell_nof_prbs) {
sched_interface::cell_cfg_t cell_cfg = generate_default_cell_cfg(nof_prb_cell);
sched_cell_params_t cell_params = {};
cell_params.set_cfg(0, cell_cfg, sched_args);
for (uint32_t prb_grant = 1; prb_grant < nof_prb_cell; ++prb_grant) {
for (uint32_t cqi = 1; cqi < 15; ++cqi) {
for (uint32_t max_mcs = 1; max_mcs <= 28; ++max_mcs) {
tbs_test_args args;
args.tti_tx_dl = tti_point{1};
args.prb_grant_size = prb_grant;
args.cqi = cqi;
args.max_mcs = max_mcs;
TESTASSERT(test_mcs_tbs_dl_helper(cell_params, args, nullptr) == SRSRAN_SUCCESS);
}
}
}
}
return SRSRAN_SUCCESS;
}
/**
* Note: assumes lowest bound for nof of REs
*/
int test_min_mcs_tbs_dl_helper(const sched_cell_params_t& cell_params, const tbs_test_args& args, tbs_info* result)
{
uint32_t nof_re = cell_params.get_dl_lb_nof_re(args.tti_tx_dl, args.prb_grant_size);
*result = compute_min_mcs_and_tbs_from_required_bytes(args.prb_grant_size,
nof_re,
args.cqi,
args.max_mcs,
args.req_bytes,
args.is_ul,
args.ul64qam_enabled,
args.use_tbs_index_alt);
tbs_info tb_max;
TESTASSERT(test_mcs_tbs_dl_helper(cell_params, args, &tb_max) == SRSRAN_SUCCESS);
CONDERROR(tb_max.mcs < result->mcs or tb_max.tbs_bytes < result->tbs_bytes, "Invalid min MCS calculation");
if (args.verbose) {
printf("Min: {tbs=%d, mcs=%d}. Max: {tbs=%d, mcs=%d}. Required tbs was %d\n",
result->tbs_bytes * 8,
result->mcs,
tb_max.tbs_bytes * 8,
tb_max.mcs,
args.req_bytes * 8);
}
return SRSRAN_SUCCESS;
}
/// Test search for minimum MCS/TBS in TS 36.213 table 7.1.7.2.1-1 that fulfills a TBS >= required bytes
int test_min_mcs_tbs_specific()
{
printf("--- Min MCS test ---\n");
sched_cell_params_t cell_params = {};
sched_interface::cell_cfg_t cell_cfg = generate_default_cell_cfg(100);
sched_interface::sched_args_t sched_args = {};
cell_params.set_cfg(0, cell_cfg, sched_args);
tbs_test_args args;
args.verbose = true;
tbs_info result;
args.cqi = 10;
args.prb_grant_size = 5;
args.req_bytes = 10;
TESTASSERT(test_min_mcs_tbs_dl_helper(cell_params, args, &result) == SRSRAN_SUCCESS);
CONDERROR(result.tbs_bytes < (int)args.req_bytes, "Invalid MCS calculation");
CONDERROR(result.tbs_bytes * 8 != 120, "Invalid min TBS calculation");
args.req_bytes = 50;
TESTASSERT_SUCCESS(test_min_mcs_tbs_dl_helper(cell_params, args, &result));
CONDERROR(result.tbs_bytes < (int)args.req_bytes, "Invalid MCS calculation");
CONDERROR(result.tbs_bytes * 8 != 424, "Invalid min TBS calculation");
args.cqi = 15;
args.prb_grant_size = 10;
args.req_bytes = 100;
TESTASSERT(test_min_mcs_tbs_dl_helper(cell_params, args, &result) == SRSRAN_SUCCESS);
CONDERROR(result.tbs_bytes < (int)args.req_bytes, "Invalid MCS calculation");
CONDERROR(result.tbs_bytes * 8 != 872, "Invalid min TBS calculation");
// Check equality case
args.req_bytes = 109;
TESTASSERT_SUCCESS(test_min_mcs_tbs_dl_helper(cell_params, args, &result));
CONDERROR(result.tbs_bytes < (int)args.req_bytes, "Invalid MCS calculation");
CONDERROR(result.tbs_bytes * 8 != 872, "Invalid min TBS calculation");
return SRSRAN_SUCCESS;
}
void test_ul_mcs_tbs_derivation()
{
uint32_t cqi = 15;
uint32_t max_mcs = 28;
sched_cell_params_t cell_params;
prbmask_t prbs;
auto compute_tbs_mcs = [&prbs, &cell_params, &max_mcs, &cqi](uint32_t Nprb, uint32_t prb_grant_size) {
sched_interface::cell_cfg_t cell_cfg = generate_default_cell_cfg(Nprb);
sched_interface::sched_args_t sched_args = {};
cell_params.set_cfg(0, cell_cfg, sched_args);
prbs.resize(Nprb);
prbs.fill(2, prb_grant_size);
uint32_t req_bytes = 1000000;
uint32_t N_srs = 0;
uint32_t nof_symb = 2 * (SRSRAN_CP_NSYMB(cell_params.cfg.cell.cp) - 1) - N_srs;
uint32_t nof_re = nof_symb * prbs.count() * SRSRAN_NRE;
return compute_min_mcs_and_tbs_from_required_bytes(
prbs.count(), nof_re, cqi, max_mcs, req_bytes, true, false, false);
};
cqi = 0;
TESTASSERT_EQ(0, compute_tbs_mcs(25, 25 - 4).mcs);
TESTASSERT_EQ(0, compute_tbs_mcs(50, 50 - 5).mcs);
cqi = 5;
TESTASSERT_EQ(9, compute_tbs_mcs(25, 25 - 4).mcs);
TESTASSERT_EQ(9, compute_tbs_mcs(50, 50 - 5).mcs);
cqi = 15;
TESTASSERT_EQ(23, compute_tbs_mcs(25, 25 - 4).mcs);
TESTASSERT_EQ(23, compute_tbs_mcs(50, 50 - 5).mcs);
TESTASSERT_EQ(24, compute_tbs_mcs(75, 75 - 5).mcs);
TESTASSERT_EQ(23, compute_tbs_mcs(100, 100 - 5).mcs);
}
} // namespace srsenb
int main()
{
auto& mac_log = srslog::fetch_basic_logger("MAC");
mac_log.set_level(srslog::basic_levels::info);
auto& test_log = srslog::fetch_basic_logger("TEST");
test_log.set_level(srslog::basic_levels::info);
// Start the log backend.
srslog::init();
TESTASSERT(srsenb::test_mcs_lookup_specific() == SRSRAN_SUCCESS);
TESTASSERT(srsenb::test_mcs_tbs_consistency_all() == SRSRAN_SUCCESS);
TESTASSERT(srsenb::test_min_mcs_tbs_specific() == SRSRAN_SUCCESS);
srsenb::test_ul_mcs_tbs_derivation();
printf("Success\n");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink