mirror of https://github.com/pvnis/srsRAN_4G.git
move scheduler rbg/prb/cce mask and interval types and associated helper functions to a separate file
Francisco
4 years ago
committed by
Francisco Paisana
parent
7c0649bc24
commit
0e0835a805
@ -0,0 +1,174 @@
|
|||||||
|
/**
|
||||||
|
*
|
||||||
|
* \section COPYRIGHT
|
||||||
|
*
|
||||||
|
* Copyright 2013-2021 Software Radio Systems Limited
|
||||||
|
*
|
||||||
|
* By using this file, you agree to the terms and conditions set
|
||||||
|
* forth in the LICENSE file which can be found at the top level of
|
||||||
|
* the distribution.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
#ifndef SRSRAN_SCHED_PHY_RESOURCE_H
|
||||||
|
#define SRSRAN_SCHED_PHY_RESOURCE_H
|
||||||
|
|
||||||
|
#include "srsran/adt/bounded_bitset.h"
|
||||||
|
#include "srsran/adt/interval.h"
|
||||||
|
#include "srsran/common/srsran_assert.h"
|
||||||
|
extern "C" {
|
||||||
|
#include "srsran/phy/phch/ra.h"
|
||||||
|
}
|
||||||
|
|
||||||
|
// Description: This file defines the types associated with representing the allocation masks/intervals for RBGs, PRBs
|
||||||
|
// and PDCCH CCEs, and provides some function helpers and algorithms to handle these types.
|
||||||
|
|
||||||
|
constexpr uint32_t MAX_NOF_RBGS = 25;
|
||||||
|
constexpr uint32_t MAX_NOF_PRBS = 100;
|
||||||
|
constexpr uint32_t MAX_NOF_CCES = 128;
|
||||||
|
|
||||||
|
namespace srsenb {
|
||||||
|
|
||||||
|
/// convert cell nof PRBs to nof RBGs
|
||||||
|
inline uint32_t cell_nof_prb_to_rbg(uint32_t nof_prbs)
|
||||||
|
{
|
||||||
|
switch (nof_prbs) {
|
||||||
|
case 6:
|
||||||
|
return 6;
|
||||||
|
case 15:
|
||||||
|
return 8;
|
||||||
|
case 25:
|
||||||
|
return 13;
|
||||||
|
case 50:
|
||||||
|
return 17;
|
||||||
|
case 75:
|
||||||
|
return 19;
|
||||||
|
case 100:
|
||||||
|
return 25;
|
||||||
|
default:
|
||||||
|
srsran_terminate("Provided nof PRBs not valid");
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// convert cell nof RBGs to nof PRBs
|
||||||
|
inline uint32_t cell_nof_rbg_to_prb(uint32_t nof_rbgs)
|
||||||
|
{
|
||||||
|
switch (nof_rbgs) {
|
||||||
|
case 6:
|
||||||
|
return 6;
|
||||||
|
case 8:
|
||||||
|
return 15;
|
||||||
|
case 13:
|
||||||
|
return 25;
|
||||||
|
case 17:
|
||||||
|
return 50;
|
||||||
|
case 19:
|
||||||
|
return 75;
|
||||||
|
case 25:
|
||||||
|
return 100;
|
||||||
|
default:
|
||||||
|
srsran_terminate("Provided nof PRBs not valid");
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Bitmask used for CCE allocations
|
||||||
|
using pdcch_mask_t = srsran::bounded_bitset<MAX_NOF_CCES, true>;
|
||||||
|
|
||||||
|
/// Bitmask that stores the allocared DL RBGs
|
||||||
|
using rbgmask_t = srsran::bounded_bitset<MAX_NOF_RBGS, true>;
|
||||||
|
|
||||||
|
/// Bitmask that stores the allocated UL PRBs
|
||||||
|
using prbmask_t = srsran::bounded_bitset<MAX_NOF_PRBS, true>;
|
||||||
|
|
||||||
|
/// Struct to express a {min,...,max} range of RBGs
|
||||||
|
struct prb_interval;
|
||||||
|
struct rbg_interval : public srsran::interval<uint32_t> {
|
||||||
|
using interval::interval;
|
||||||
|
static rbg_interval find_first_interval(const rbgmask_t& mask);
|
||||||
|
static rbg_interval prbs_to_rbgs(const prb_interval& prbs, uint32_t cell_nof_prb);
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Struct to express a {min,...,max} range of PRBs
|
||||||
|
struct prb_interval : public srsran::interval<uint32_t> {
|
||||||
|
using interval::interval;
|
||||||
|
static prb_interval rbgs_to_prbs(const rbg_interval& rbgs, uint32_t cell_nof_prb)
|
||||||
|
{
|
||||||
|
uint32_t P = srsran_ra_type0_P(cell_nof_prb);
|
||||||
|
return prb_interval{rbgs.start() * P, std::min(rbgs.stop() * P, cell_nof_prb)};
|
||||||
|
}
|
||||||
|
static prb_interval riv_to_prbs(uint32_t riv, uint32_t nof_prbs, int nof_vrbs = -1);
|
||||||
|
};
|
||||||
|
|
||||||
|
inline rbg_interval rbg_interval::prbs_to_rbgs(const prb_interval& prbs, uint32_t cell_nof_prb)
|
||||||
|
{
|
||||||
|
uint32_t P = srsran_ra_type0_P(cell_nof_prb);
|
||||||
|
return rbg_interval{prbs.start() / P, srsran::ceil_div(prbs.stop(), P)};
|
||||||
|
}
|
||||||
|
|
||||||
|
/*******************************************************
|
||||||
|
* helper functions
|
||||||
|
*******************************************************/
|
||||||
|
|
||||||
|
/// If the RBG mask one bits are all contiguous
|
||||||
|
inline bool is_contiguous(const rbgmask_t& mask)
|
||||||
|
{
|
||||||
|
return rbg_interval::find_first_interval(mask).length() == mask.count();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Count number of PRBs present in a DL RBG mask
|
||||||
|
inline uint32_t count_prb_per_tb(const rbgmask_t& bitmask)
|
||||||
|
{
|
||||||
|
uint32_t Nprb = cell_nof_rbg_to_prb(bitmask.size());
|
||||||
|
uint32_t P = srsran_ra_type0_P(Nprb);
|
||||||
|
uint32_t nof_prb = P * bitmask.count();
|
||||||
|
if (bitmask.test(bitmask.size() - 1)) {
|
||||||
|
nof_prb -= bitmask.size() * P - Nprb;
|
||||||
|
}
|
||||||
|
return nof_prb;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Estimate of number of PRBs in DL grant given Nof RBGs
|
||||||
|
inline uint32_t count_prb_per_tb_approx(uint32_t nof_rbgs, uint32_t cell_nof_prb)
|
||||||
|
{
|
||||||
|
uint32_t P = srsran_ra_type0_P(cell_nof_prb);
|
||||||
|
return std::min(nof_rbgs * P, cell_nof_prb);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Finds a contiguous interval of "zeroed"/available RBG resources
|
||||||
|
* @param max_nof_rbgs maximum number of RBGs
|
||||||
|
* @param current_mask bitmask of occupied RBGs, used to search for available RBGs
|
||||||
|
* @return interval with found RBGs. If a valid interval wasn't found, interval.length() == 0
|
||||||
|
*/
|
||||||
|
rbg_interval find_empty_rbg_interval(uint32_t max_nof_rbgs, const rbgmask_t& current_mask);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Finds a bitmask of "zeroed"/available RBG resources
|
||||||
|
* @param max_nof_rbgs maximum number of RBGs
|
||||||
|
* @param current_mask bitmask of occupied RBGs, used to search for available RBGs
|
||||||
|
* @return bitmask of found RBGs. If a valid mask wasn't found, bitmask::size() == 0
|
||||||
|
*/
|
||||||
|
rbgmask_t find_available_rbgmask(uint32_t max_nof_rbgs, bool is_contiguous, const rbgmask_t& current_mask);
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Finds a range of L contiguous PRBs that are empty
|
||||||
|
* @param L Max length of the requested UL PRBs
|
||||||
|
* @param current_mask input PRB mask where to search for available PRBs
|
||||||
|
* @return found interval of PRBs
|
||||||
|
*/
|
||||||
|
prb_interval find_contiguous_ul_prbs(uint32_t L, const prbmask_t& current_mask);
|
||||||
|
|
||||||
|
} // namespace srsenb
|
||||||
|
|
||||||
|
namespace fmt {
|
||||||
|
|
||||||
|
template <>
|
||||||
|
struct formatter<srsenb::rbg_interval> : public formatter<srsran::interval<uint32_t> > {};
|
||||||
|
template <>
|
||||||
|
struct formatter<srsenb::prb_interval> : public formatter<srsran::interval<uint32_t> > {};
|
||||||
|
|
||||||
|
} // namespace fmt
|
||||||
|
|
||||||
|
#endif // SRSRAN_SCHED_PHY_RESOURCE_H
|
||||||
@ -0,0 +1,139 @@
|
|||||||
|
/**
|
||||||
|
*
|
||||||
|
* \section COPYRIGHT
|
||||||
|
*
|
||||||
|
* Copyright 2013-2021 Software Radio Systems Limited
|
||||||
|
*
|
||||||
|
* By using this file, you agree to the terms and conditions set
|
||||||
|
* forth in the LICENSE file which can be found at the top level of
|
||||||
|
* the distribution.
|
||||||
|
*
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include "srsenb/hdr/stack/mac/sched_phy_ch/sched_phy_resource.h"
|
||||||
|
extern "C" {
|
||||||
|
#include "lib/include/srsran/phy/dft/dft_precoding.h"
|
||||||
|
}
|
||||||
|
|
||||||
|
namespace srsenb {
|
||||||
|
|
||||||
|
rbg_interval rbg_interval::find_first_interval(const rbgmask_t& mask)
|
||||||
|
{
|
||||||
|
int rb_start = -1;
|
||||||
|
for (uint32_t i = 0; i < mask.size(); i++) {
|
||||||
|
if (rb_start == -1) {
|
||||||
|
if (mask.test(i)) {
|
||||||
|
rb_start = i;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if (!mask.test(i)) {
|
||||||
|
return rbg_interval(rb_start, i);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (rb_start != -1) {
|
||||||
|
return rbg_interval(rb_start, mask.size());
|
||||||
|
}
|
||||||
|
return rbg_interval();
|
||||||
|
}
|
||||||
|
|
||||||
|
prb_interval prb_interval::riv_to_prbs(uint32_t riv, uint32_t nof_prbs, int nof_vrbs)
|
||||||
|
{
|
||||||
|
if (nof_vrbs < 0) {
|
||||||
|
nof_vrbs = nof_prbs;
|
||||||
|
}
|
||||||
|
uint32_t rb_start, l_crb;
|
||||||
|
srsran_ra_type2_from_riv(riv, &l_crb, &rb_start, nof_prbs, (uint32_t)nof_vrbs);
|
||||||
|
return {rb_start, rb_start + l_crb};
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename RBMask,
|
||||||
|
typename RBInterval =
|
||||||
|
typename std::conditional<std::is_same<RBMask, prbmask_t>::value, prb_interval, rbg_interval>::type>
|
||||||
|
RBInterval find_contiguous_interval(const RBMask& in_mask, uint32_t max_size)
|
||||||
|
{
|
||||||
|
RBInterval max_interv;
|
||||||
|
|
||||||
|
for (size_t n = 0; n < in_mask.size();) {
|
||||||
|
int pos = in_mask.find_lowest(n, in_mask.size(), false);
|
||||||
|
if (pos < 0) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t max_pos = std::min(in_mask.size(), (size_t)pos + max_size);
|
||||||
|
int pos2 = in_mask.find_lowest(pos, max_pos, true);
|
||||||
|
RBInterval interv(pos, pos2 < 0 ? max_pos : pos2);
|
||||||
|
if (interv.length() >= max_size) {
|
||||||
|
return interv;
|
||||||
|
}
|
||||||
|
if (interv.length() > max_interv.length()) {
|
||||||
|
max_interv = interv;
|
||||||
|
}
|
||||||
|
n = interv.stop();
|
||||||
|
}
|
||||||
|
return max_interv;
|
||||||
|
}
|
||||||
|
|
||||||
|
rbgmask_t find_available_rbgmask(const rbgmask_t& in_mask, uint32_t max_size)
|
||||||
|
{
|
||||||
|
// 1's for free RBs
|
||||||
|
rbgmask_t localmask = ~(in_mask);
|
||||||
|
|
||||||
|
if (max_size >= localmask.size() or max_size >= localmask.count()) {
|
||||||
|
// shortcut in case rbg count < max_size
|
||||||
|
return localmask;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t i = 0, nof_alloc = 0;
|
||||||
|
for (; i < localmask.size() and nof_alloc < max_size; ++i) {
|
||||||
|
if (localmask.test(i)) {
|
||||||
|
nof_alloc++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
localmask.fill(i, localmask.size(), false);
|
||||||
|
return localmask;
|
||||||
|
}
|
||||||
|
|
||||||
|
rbg_interval find_empty_rbg_interval(uint32_t max_nof_rbgs, const rbgmask_t& current_mask)
|
||||||
|
{
|
||||||
|
return find_contiguous_interval(current_mask, max_nof_rbgs);
|
||||||
|
}
|
||||||
|
|
||||||
|
rbgmask_t find_available_rbgmask(uint32_t max_nof_rbgs, bool is_contiguous, const rbgmask_t& current_mask)
|
||||||
|
{
|
||||||
|
// Allocate enough RBs that accommodate pending data
|
||||||
|
rbgmask_t newtx_mask(current_mask.size());
|
||||||
|
if (is_contiguous) {
|
||||||
|
rbg_interval interv = find_contiguous_interval(current_mask, max_nof_rbgs);
|
||||||
|
newtx_mask.fill(interv.start(), interv.stop());
|
||||||
|
} else {
|
||||||
|
newtx_mask = find_available_rbgmask(current_mask, max_nof_rbgs);
|
||||||
|
}
|
||||||
|
return newtx_mask;
|
||||||
|
}
|
||||||
|
|
||||||
|
prb_interval find_contiguous_ul_prbs(uint32_t L, const prbmask_t& current_mask)
|
||||||
|
{
|
||||||
|
prb_interval prb_interv = find_contiguous_interval(current_mask, L);
|
||||||
|
if (prb_interv.empty()) {
|
||||||
|
return prb_interv;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Make sure L is allowed by SC-FDMA modulation
|
||||||
|
prb_interval prb_interv2 = prb_interv;
|
||||||
|
while (not srsran_dft_precoding_valid_prb(prb_interv.length()) and prb_interv.stop() < current_mask.size() and
|
||||||
|
not current_mask.test(prb_interv.stop())) {
|
||||||
|
prb_interv.resize_by(1);
|
||||||
|
}
|
||||||
|
if (not srsran_dft_precoding_valid_prb(prb_interv.length())) {
|
||||||
|
// if length increase failed, try to decrease
|
||||||
|
prb_interv = prb_interv2;
|
||||||
|
prb_interv.resize_by(-1);
|
||||||
|
while (not srsran_dft_precoding_valid_prb(prb_interv.length()) and not prb_interv.empty()) {
|
||||||
|
prb_interv.resize_by(-1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return prb_interv;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace srsenb
|
||||||
Loading…
Reference in New Issue