yigid/openairinterface5g
1
0
Fork 0
mirror of https://gitlab.eurecom.fr/oai/openairinterface5g.git synced 2026-07-13 04:30:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

change datamodel in nr-ue-ru.c to implement the current status: a ru has 0 or 1 cell, a cell has 0 or 1 UE

Browse Source 
Signed-off-by: Laurent THOMAS <laurent.thomas@open-cells.com>
This commit is contained in:
Laurent THOMAS
2026-06-01 17:46:43 +02:00
parent a0526fc1d0
commit 2987a87a52
4 changed files with 70 additions and 156 deletions
Download Patch File Download Diff File Expand all files Collapse all files

118
executables/nr-ue-ru.c
View File

@@ -81,12 +81,6 @@
}
// clang-format on
static struct {
int count;
nrUE_cell_params_t *cfg;
NR_DL_FRAME_PARMS *fp;
} nrue_cells = {};
static struct {
int count;
nrUE_RU_params_t *cfg;
@@ -95,33 +89,9 @@ static struct {
// We keep openair0_cfg_g outside for legacy code
openair0_config_t openair0_cfg_g[MAX_CARDS] = {};
int nrue_get_cell_count(void)
{
return nrue_cells.count;
}
int nrue_get_band(const PHY_VARS_NR_UE *UE)
{
int cell_id = nrue_rus.cfg[UE->rf_map.card].used_by_cell;
return nrue_cells.cfg[cell_id].band;
}
const nrUE_cell_params_t *nrue_get_cell(int cell_id)
{
AssertFatal(cell_id >= 0 && cell_id < nrue_cells.count, "Invalid cell ID %d! Cell count = %d\n", cell_id, nrue_cells.count);
return &nrue_cells.cfg[cell_id];
}
NR_DL_FRAME_PARMS *nrue_get_cell_fp(int cell_id)
{
AssertFatal(cell_id >= 0 && cell_id < nrue_cells.count, "Invalid cell ID %d! Cell count = %d\n", cell_id, nrue_cells.count);
return &nrue_cells.fp[cell_id];
}
void nrue_set_cell(int cell_id, const nrUE_cell_params_t *cell)
{
AssertFatal(cell_id >= 0 && cell_id < nrue_cells.count, "Invalid cell ID %d! Cell count = %d\n", cell_id, nrue_cells.count);
nrue_cells.cfg[cell_id] = *cell;
return nrue_rus.cfg[UE->rf_map.card].cell.band;
}
void nrue_set_cell_params(configmodule_interface_t *cfg)
@@ -131,43 +101,35 @@ void nrue_set_cell_params(configmodule_interface_t *cfg)
config_getlist(cfg, &cellParamList, cellParams, sizeofArray(cellParams), NULL);
if (cellParamList.numelt <= 0) {
nrue_cells.count = 1;
nrue_cells.fp = calloc_or_fail(nrue_cells.count, sizeof(*nrue_cells.fp));
nrue_cells.cfg = calloc_or_fail(nrue_cells.count, sizeof(*nrue_cells.cfg));
nrue_cells.cfg[0] = (nrUE_cell_params_t){.ru_id = 0,
.band = get_softmodem_params()->band,
.rf_frequency = downlink_frequency[0][0],
.rf_freq_offset = uplink_frequency_offset[0][0],
.numerology = get_softmodem_params()->numerology,
.N_RB_DL = get_nrUE_params()->N_RB_DL,
.ssb_start = get_nrUE_params()->ssb_start_subcarrier,
.used_by_ue = -1};
nrue_rus.cfg[0].cell = (nrUE_cell_params_t){.active = true,
.band = get_softmodem_params()->band,
.rf_frequency = downlink_frequency[0][0],
.rf_freq_offset = uplink_frequency_offset[0][0],
.numerology = get_softmodem_params()->numerology,
.N_RB_DL = get_nrUE_params()->N_RB_DL,
.ssb_start = get_nrUE_params()->ssb_start_subcarrier,
.fp = calloc_or_fail(1, sizeof(*nrue_rus.cfg[0].cell.fp))};
return;
}
nrue_cells.count = cellParamList.numelt;
nrue_cells.fp = calloc_or_fail(nrue_cells.count, sizeof(*nrue_cells.fp));
nrue_cells.cfg = calloc_or_fail(nrue_cells.count, sizeof(*nrue_cells.cfg));
LOG_W(NR_PHY, "Ignoring command line cell parameters, using the following instead:\n");
for (int cell_id = 0; cell_id < nrue_cells.count; cell_id++) {
for (int cell_id = 0; cell_id < cellParamList.numelt; cell_id++) {
paramdef_t *param = cellParamList.paramarray[cell_id];
const int sz = sizeofArray(cellParams);
nrUE_cell_params_t *cell = nrue_cells.cfg + cell_id;
*cell = (nrUE_cell_params_t){.ru_id = *gpd(param, sz, NRUE_CELL_RU_ID)->iptr,
nrUE_cell_params_t *cell = &nrue_rus.cfg[*gpd(param, sz, NRUE_CELL_RU_ID)->iptr].cell;
*cell = (nrUE_cell_params_t){.active = true,
.band = *gpd(param, sz, NRUE_CELL_BAND)->iptr,
.rf_frequency = *gpd(param, sz, NRUE_CELL_RF_FREQUENCY)->u64ptr,
.rf_freq_offset = *gpd(param, sz, NRUE_CELL_RF_FREQ_OFFSET)->i64ptr,
.numerology = *gpd(param, sz, NRUE_CELL_NUMEROLOGY)->iptr,
.N_RB_DL = *gpd(param, sz, NRUE_CELL_N_RB_DL)->iptr,
.ssb_start = *gpd(param, sz, NRUE_CELL_SSB_START)->iptr,
.used_by_ue = -1};
.fp = calloc_or_fail(1, sizeof(*nrue_rus.cfg[0].cell.fp))};
LOG_I(NR_PHY,
"cell %d: ru_id %d, band %d, DL freq %lu, UL freq_offset %ld, numerology %d, N_RB_DL %d, ssb_start %d\n",
"cell %d: band %d, DL freq %lu, UL freq_offset %ld, numerology %d, N_RB_DL %d, ssb_start %d\n",
cell_id,
cell->ru_id,
cell->band,
cell->rf_frequency,
cell->rf_freq_offset,
@@ -182,19 +144,12 @@ int nrue_get_ru_count(void)
return nrue_rus.count;
}
const nrUE_RU_params_t *nrue_get_ru(int ru_id)
nrUE_RU_params_t *nrue_get_ru(int ru_id)
{
AssertFatal(ru_id >= 0 && ru_id < nrue_rus.count, "Invalid RU ID %d! RU count = %d\n", ru_id, nrue_rus.count);
return &nrue_rus.cfg[ru_id];
}
void nrue_set_ru_cell_id(int ru_id, int cell_id)
{
AssertFatal(ru_id >= 0 && ru_id < nrue_rus.count, "Invalid RU ID %d! RU count = %d\n", ru_id, nrue_rus.count);
AssertFatal(cell_id >= 0 && cell_id < nrue_cells.count, "Invalid cell ID %d! Cell count = %d\n", cell_id, nrue_cells.count);
nrue_rus.cfg[ru_id].used_by_cell = cell_id;
}
void nrue_set_ru_params(configmodule_interface_t *cfg)
{
paramdef_t RUParams[] = NRUE_RU_PARAMS_DESC;
@@ -217,8 +172,7 @@ void nrue_set_ru_params(configmodule_interface_t *cfg)
.time_source = get_softmodem_params()->timing_source,
.tune_offset = get_softmodem_params()->tune_offset,
.if_frequency = get_nrUE_params()->if_freq,
.if_freq_offset = get_nrUE_params()->if_freq_off,
.used_by_cell = -1};
.if_freq_offset = get_nrUE_params()->if_freq_off};
return;
}
@@ -280,14 +234,13 @@ void nrue_init_openair0(void)
for (int ru_id = 0; ru_id < nrue_rus.count; ru_id++) {
nrUE_RU_params_t *ru = nrue_rus.cfg + ru_id;
int cell_id = ru->used_by_cell;
if (cell_id < 0) {
if (!ru->cell.active) {
LOG_W(PHY, "Skipping initialization of RU %d because it is not used by any cell!\n", ru_id);
continue;
}
NR_DL_FRAME_PARMS *frame_parms = nrue_cells.fp + cell_id;
NR_DL_FRAME_PARMS *frame_parms = ru->cell.fp;
if (is_sidelink) {
int UE_id = nrue_cells.cfg[cell_id].used_by_ue;
int UE_id = ru->cell.used_by_ue;
if (UE_id < 0) {
LOG_W(PHY, "Skipping initialization of RU %d because it is not used by any UE!\n", ru_id);
continue;
@@ -376,8 +329,8 @@ void nrue_ru_end(void)
void nrue_ru_set_freq(PHY_VARS_NR_UE *UE, uint64_t ul_carrier, uint64_t dl_carrier, int freq_offset)
{
int current_cell_id = nrue_rus.cfg[UE->rf_map.card].used_by_cell;
NR_DL_FRAME_PARMS *fp0 = nrue_cells.fp + current_cell_id;
nrUE_RU_params_t *ru = nrue_rus.cfg + UE->rf_map.card;
NR_DL_FRAME_PARMS *fp0 = ru->cell.fp;
uint64_t dl_carrier_distance =
fp0->dl_CarrierFreq > dl_carrier ? fp0->dl_CarrierFreq - dl_carrier : dl_carrier - fp0->dl_CarrierFreq;
uint64_t ul_carrier_distance =
@@ -385,28 +338,25 @@ void nrue_ru_set_freq(PHY_VARS_NR_UE *UE, uint64_t ul_carrier, uint64_t dl_carri
uint64_t carrier_distance = dl_carrier_distance + ul_carrier_distance;
for (int ru_id = 0; carrier_distance != 0 && ru_id < nrue_rus.count; ru_id++) {
int cell_id = nrue_rus.cfg[ru_id].used_by_cell;
if (cell_id < 0) // skip RUs that have no cell definition
nrUE_RU_params_t *ru_loop = nrue_rus.cfg + ru_id;
if (!ru_loop->cell.active) // skip RUs that have no cell definition
continue;
if (nrue_cells.cfg[cell_id].used_by_ue >= 0) // skip cells that are already used by an UE
if (ru_loop->cell.used_by_ue >= 0) // skip cells that are already used by an UE
continue;
fp0 = nrue_cells.fp + cell_id;
fp0 = ru_loop->cell.fp;
uint64_t this_dl_carrier_distance =
fp0->dl_CarrierFreq > dl_carrier ? fp0->dl_CarrierFreq - dl_carrier : dl_carrier - fp0->dl_CarrierFreq;
uint64_t this_ul_carrier_distance =
fp0->ul_CarrierFreq > ul_carrier ? fp0->ul_CarrierFreq - ul_carrier : ul_carrier - fp0->ul_CarrierFreq;
uint64_t this_carrier_distance = this_dl_carrier_distance + this_ul_carrier_distance;
if (this_carrier_distance < carrier_distance) {
UE->rf_map.card = ru_id;
UE->rf_map.card = ru_id; // ???? fixme
carrier_distance = this_carrier_distance;
}
}
nrue_cells.cfg[current_cell_id].used_by_ue = -1;
current_cell_id = nrue_rus.cfg[UE->rf_map.card].used_by_cell;
nrue_cells.cfg[current_cell_id].used_by_ue = UE->Mod_id;
ru->cell.used_by_ue = UE->Mod_id;
openair0_config_t *cfg = &openair0_cfg_g[UE->rf_map.card];
openair0_device_t *dev = &nrue_rus.openair0_dev[UE->rf_map.card];
nr_rf_card_config_freq(cfg, ul_carrier, dl_carrier, freq_offset);
@@ -458,13 +408,10 @@ int nrue_ru_read(PHY_VARS_NR_UE *UE, openair0_timestamp_t *ptimestamp, void **bu
tmp_buf[ant] = tmp_samples;
for (int ru_id = 0; ru_id < nrue_rus.count; ru_id++) {
int cell_id = nrue_rus.cfg[ru_id].used_by_cell;
if (cell_id < 0) // skip RUs that have no cell definition
if (!nrue_rus.cfg[ru_id].cell.active) // skip RUs that have no cell definition
continue;
int ue_id = nrue_cells.cfg[cell_id].used_by_ue;
if (ue_id >= 0) // skip cells that are already used by an UE
if (nrue_rus.cfg[ru_id].cell.used_by_ue >= 0) // skip cells that are already used by an UE
continue;
dev = &nrue_rus.openair0_dev[ru_id];
dev->trx_read_func(dev, &tmp_timestamp, tmp_buf, nsamps, num_antennas);
if (!dev->firstTS_initialized) {
@@ -493,13 +440,10 @@ int nrue_ru_write(PHY_VARS_NR_UE *UE, openair0_timestamp_t timestamp, void **buf
tmp_buf[ant] = tmp_samples;
for (int ru_id = 0; ru_id < nrue_rus.count; ru_id++) {
int cell_id = nrue_rus.cfg[ru_id].used_by_cell;
if (cell_id < 0) // skip RUs that have no cell definition
if (!nrue_rus.cfg[ru_id].cell.active) // skip RUs that have no cell definition
continue;
int ue_id = nrue_cells.cfg[cell_id].used_by_ue;
if (ue_id >= 0) // skip cells that are already used by an UE
if (nrue_rus.cfg[ru_id].cell.used_by_ue >= 0) // skip cells that are already used by an UE
continue;
dev = &nrue_rus.openair0_dev[ru_id];
dev->trx_write_func(dev, timestamp + dev->firstTS, tmp_buf, nsamps, num_antennas, flags);
}

7
executables/nr-ue-ru.h
View File

@@ -8,15 +8,10 @@
#include "PHY/defs_nr_UE.h"
#include "radio/COMMON/common_lib.h"
int nrue_get_cell_count(void);
const nrUE_cell_params_t *nrue_get_cell(int cell_id);
NR_DL_FRAME_PARMS *nrue_get_cell_fp(int cell_id);
void nrue_set_cell(int cell_id, const nrUE_cell_params_t *cell);
void nrue_set_cell_params(configmodule_interface_t *cfg);
int nrue_get_band(const PHY_VARS_NR_UE *UE);
int nrue_get_ru_count(void);
const nrUE_RU_params_t *nrue_get_ru(int ru_id);
void nrue_set_ru_cell_id(int ru_id, int cell_id);
nrUE_RU_params_t *nrue_get_ru(int ru_id);
void nrue_set_ru_params(configmodule_interface_t *cfg);
void nrue_init_openair0(void);

76
executables/nr-uesoftmodem.c
View File

@@ -168,11 +168,10 @@ static void set_UE_options(int CC_id, PHY_VARS_NR_UE *UE, int ru_id)
UE->UE_fo_compensation, UE->UE_scan_carrier, UE->no_timing_correction, UE->chest_freq, UE->chest_time);
}
static void set_fp_options(int cell_id, int ru_id)
static void set_fp_options(int ru_id)
{
NR_DL_FRAME_PARMS *fp = nrue_get_cell_fp(cell_id);
const nrUE_RU_params_t *RU = nrue_get_ru(ru_id);
NR_DL_FRAME_PARMS *fp = RU->cell.fp;
// Set FP variables
fp->nb_antennas_rx = RU->nb_rx;
fp->nb_antennas_tx = RU->nb_tx;
@@ -285,7 +284,7 @@ int main(int argc, char **argv)
get_nrUE_params()->uecap_file,
get_nrUE_params()->reconfig_file,
get_nrUE_params()->rbconfig_file,
nrue_get_cell(0)->numerology);
nrue_get_ru(0)->cell.numerology);
// start time manager with some reasonable default for the running mode
// (may be overwritten in configuration file or command line)
@@ -303,50 +302,26 @@ int main(int argc, char **argv)
: TIME_SOURCE_REALTIME);
// initialize per-cell frame parameters
for (int cell_id = 0; cell_id < nrue_get_cell_count(); cell_id++) {
int ru_id = nrue_get_cell(cell_id)->ru_id;
AssertFatal(ru_id >= 0 && ru_id < nrue_get_ru_count(),
"Invalid ru_id (%d) for cell %d. Should be >= 0 and < %d\n",
ru_id,
cell_id,
nrue_get_ru_count());
AssertFatal(nrue_get_ru(ru_id)->used_by_cell == -1,
"RU %d is already used by cell %d and therefore cannot also be used by cell %d\n",
ru_id,
nrue_get_ru(ru_id)->used_by_cell,
cell_id);
nrue_set_ru_cell_id(ru_id, cell_id);
set_fp_options(cell_id, ru_id);
for (int ru_id = 0; ru_id < nrue_get_ru_count(); ru_id++) {
nrUE_RU_params_t *ru = nrue_get_ru(ru_id);
if (!ru->cell.active) // skip RUs that have no cell definition
continue;
set_fp_options(ru_id);
if (IS_SA_MODE(get_softmodem_params()) || get_softmodem_params()->sl_mode)
nr_init_frame_parms_ue_sa(nrue_get_cell_fp(cell_id), nrue_get_cell(cell_id));
nr_init_frame_parms_ue_sa(ru->cell.fp, &ru->cell);
}
int cell_id = 0;
int ru_id = 0;
for (int inst = 0; inst < NB_UE_INST; inst++) {
NR_UE_MAC_INST_t *mac = get_mac_inst(inst);
for (int CC_id = 0; CC_id < MAX_NUM_CCs; CC_id++) {
PHY_VARS_NR_UE *UE_CC = nrPHY_vars_UE_g[inst][CC_id];
AssertFatal(cell_id >= 0 && cell_id < nrue_get_cell_count(),
"There are not enough cell definitions for all UEs! NB_UE_INST = %d, MAX_NUM_CCs = %d, nrue_cell_count = %d\n",
NB_UE_INST,
MAX_NUM_CCs,
nrue_get_cell_count());
nrUE_cell_params_t cell = *nrue_get_cell(cell_id);
AssertFatal(cell.used_by_ue == -1,
"Cell %d is already used by UE %d and cannot also be used by UE %d as cells map 1:1 to RUs and RU sharing is not implemented\n",
cell_id,
cell.used_by_ue,
inst);
cell.used_by_ue = inst;
set_UE_options(CC_id, UE_CC, cell.ru_id);
// fixme: it seems implicit mapping
AssertFatal(ru_id < nrue_get_ru_count(), " more UEs than ru+cell definitions in the config file\n");
set_UE_options(CC_id, UE_CC, ru_id);
init_nr_ue_phy_cpu_stats(&UE_CC->phy_cpu_stats);
NR_DL_FRAME_PARMS *fp = nrue_get_cell_fp(cell_id);
nrUE_RU_params_t *ru = nrue_get_ru(ru_id);
NR_DL_FRAME_PARMS *fp = ru->cell.fp;
if (!IS_SA_MODE(get_softmodem_params()) && !get_softmodem_params()->sl_mode) {
do {
notifiedFIFO_elt_t *elt = pollNotifiedFIFO(&mac->input_nf);
@@ -359,19 +334,18 @@ int main(int argc, char **argv)
fapi_nr_config_request_t *nrUE_config = &UE_CC->nrUE_config;
nr_init_frame_parms_ue(fp, nrUE_config, mac->nr_band);
cell.band = mac->nr_band;
cell.rf_frequency = fp->dl_CarrierFreq;
cell.rf_freq_offset = fp->ul_CarrierFreq - fp->dl_CarrierFreq;
cell.numerology = fp->numerology_index;
cell.N_RB_DL = fp->N_RB_DL;
cell.ssb_start = fp->ssb_start_subcarrier;
ru->cell.band = mac->nr_band;
ru->cell.rf_frequency = fp->dl_CarrierFreq;
ru->cell.rf_freq_offset = fp->ul_CarrierFreq - fp->dl_CarrierFreq;
ru->cell.numerology = fp->numerology_index;
ru->cell.N_RB_DL = fp->N_RB_DL;
ru->cell.ssb_start = fp->ssb_start_subcarrier;
}
nrue_set_cell(cell_id, &cell);
UE_CC->frame_parms = *fp;
mac->nr_band = cell.band;
mac->ssb_start_subcarrier = cell.ssb_start;
mac->dl_frequency = cell.rf_frequency;
mac->nr_band = ru->cell.band;
mac->ssb_start_subcarrier = ru->cell.ssb_start;
mac->dl_frequency = ru->cell.rf_frequency;
UE_CC->sl_mode = get_softmodem_params()->sl_mode;
init_actor(&UE_CC->sync_actor, "SYNC_", -1);
@@ -404,7 +378,7 @@ int main(int argc, char **argv)
sl_ue_phy_init(UE_CC);
}
cell_id++; // initially connect each UE and carrier to its own cell
ru_id++; // initially connect each UE and carrier to its own cell
}
}

25
openair1/PHY/defs_nr_UE.h
View File

@@ -239,6 +239,18 @@ typedef struct UE_NR_SCAN_INFO_s {
int32_t freq_offset_Hz[3][10];
} UE_NR_SCAN_INFO_t;
typedef struct {
bool active;
int band;
uint64_t rf_frequency;
int64_t rf_freq_offset;
int numerology;
int N_RB_DL;
int ssb_start;
int used_by_ue;
NR_DL_FRAME_PARMS *fp;
} nrUE_cell_params_t;
typedef struct {
unsigned int nb_tx;
unsigned int nb_rx;
@@ -253,20 +265,9 @@ typedef struct {
double tune_offset;
uint64_t if_frequency;
int if_freq_offset;
int used_by_cell;
nrUE_cell_params_t cell;
} nrUE_RU_params_t;
typedef struct {
int ru_id;
int band;
uint64_t rf_frequency;
int64_t rf_freq_offset;
int numerology;
int N_RB_DL;
int ssb_start;
int used_by_ue;
} nrUE_cell_params_t;
/// Top-level PHY Data Structure for UE
typedef struct PHY_VARS_NR_UE_s {
/// \brief Module ID indicator for this instance