Laurent THOMAS
1292cd68b7
saves about 600MB of memory allocation Move the definition of PRACH items and the PRACH list to the defs_nr_commons.h file. Do not re-write the entire structure in nr_schedule_rx_prach(), as it is quite large now.
169 lines
7.5 KiB
C
169 lines
7.5 KiB
C
/*
|
|
* Licensed to the OpenAirInterface (OAI) Software Alliance under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The OpenAirInterface Software Alliance licenses this file to You under
|
|
* the OAI Public License, Version 1.1 (the "License"); you may not use this file
|
|
* except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.openairinterface.org/?page_id=698
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*-------------------------------------------------------------------------------
|
|
* For more information about the OpenAirInterface (OAI) Software Alliance:
|
|
* contact@openairinterface.org
|
|
*/
|
|
|
|
#include "phy_init.h"
|
|
#include "PHY/phy_extern.h"
|
|
#include "SCHED/sched_common.h"
|
|
#include "common/utils/LOG/vcd_signal_dumper.h"
|
|
#include "assertions.h"
|
|
#include <math.h>
|
|
#include "openair1/PHY/defs_RU.h"
|
|
|
|
void nr_phy_init_RU(RU_t *ru)
|
|
{
|
|
NR_DL_FRAME_PARMS *fp = ru->nr_frame_parms;
|
|
|
|
LOG_D(PHY, "Initializing RU signal buffers (if_south %s) nb_tx %d, nb_rx %d\n", ru_if_types[ru->if_south], ru->nb_tx, ru->nb_rx);
|
|
|
|
nfapi_nr_config_request_scf_t *cfg = &ru->config;
|
|
ru->nb_log_antennas = 0;
|
|
for (int n = 0; n < ru->num_gNB; n++) {
|
|
if (cfg->carrier_config.num_tx_ant.value > ru->nb_log_antennas)
|
|
ru->nb_log_antennas = cfg->carrier_config.num_tx_ant.value;
|
|
}
|
|
|
|
// copy configuration from gNB[0] in to RU, assume that all gNB instances sharing RU use the same configuration
|
|
// (at least the parts that are needed by the RU, numerology and PRACH)
|
|
|
|
AssertFatal(ru->nb_log_antennas > 0 && ru->nb_log_antennas < 13, "ru->nb_log_antennas %d ! \n",ru->nb_log_antennas);
|
|
|
|
nfapi_nr_analog_beamforming_ve_t *analog_config = &cfg->analog_beamforming_ve;
|
|
ru->num_beams_period = analog_config->analog_bf_vendor_ext.value ? analog_config->num_beams_period_vendor_ext.value : 1;
|
|
int nb_tx_streams = ru->nb_tx * ru->num_beams_period;
|
|
int nb_rx_streams = ru->nb_rx * ru->num_beams_period;
|
|
LOG_I(NR_PHY, "nb_tx_streams %d, nb_rx_streams %d, num_Beams_period %d\n", nb_tx_streams, nb_rx_streams, ru->num_beams_period);
|
|
ru->common.beam_id = malloc16_clear(ru->num_beams_period * sizeof(int*));
|
|
for(int i = 0; i < ru->num_beams_period; i++) {
|
|
ru->common.beam_id[i] = malloc16(fp->symbols_per_slot * fp->slots_per_frame * sizeof(int));
|
|
memset(ru->common.beam_id[i], -1, fp->symbols_per_slot * fp->slots_per_frame * sizeof(int));
|
|
}
|
|
|
|
if (ru->if_south <= REMOTE_IF5) { // this means REMOTE_IF5 or LOCAL_RF, so allocate memory for time-domain signals
|
|
// Time-domain signals
|
|
ru->common.txdata = (int32_t**)malloc16(nb_tx_streams * sizeof(int32_t*));
|
|
ru->common.rxdata = (int32_t**)malloc16(nb_rx_streams * sizeof(int32_t*));
|
|
|
|
for (int i = 0; i < nb_tx_streams; i++) {
|
|
// Allocate 10 subframes of I/Q TX signal data (time) if not
|
|
ru->common.txdata[i] = (int32_t*)malloc16_clear((ru->sf_extension + fp->samples_per_frame) * sizeof(int32_t));
|
|
LOG_D(PHY,
|
|
"[INIT] common.txdata[%d] = %p (%lu bytes,sf_extension %d)\n",
|
|
i,
|
|
ru->common.txdata[i],
|
|
(ru->sf_extension + fp->samples_per_frame) * sizeof(int32_t),
|
|
ru->sf_extension);
|
|
ru->common.txdata[i] = &ru->common.txdata[i][ru->sf_extension];
|
|
|
|
LOG_D(PHY, "[INIT] common.txdata[%d] = %p \n", i, ru->common.txdata[i]);
|
|
}
|
|
for (int i = 0; i < nb_rx_streams; i++) {
|
|
ru->common.rxdata[i] = (int32_t*)malloc16_clear(fp->samples_per_frame * sizeof(int32_t));
|
|
}
|
|
} // IF5 or local RF
|
|
else {
|
|
ru->common.txdata = (int32_t**)NULL;
|
|
ru->common.rxdata = (int32_t**)NULL;
|
|
}
|
|
if (ru->function != NGFI_RRU_IF5) { // we need to do RX/TX RU processing
|
|
LOG_D(PHY, "nb_tx %d\n", ru->nb_tx);
|
|
ru->common.rxdata_7_5kHz = (int32_t**)malloc16(ru->nb_rx*sizeof(int32_t*) );
|
|
for (int i = 0; i < ru->nb_rx; i++) {
|
|
ru->common.rxdata_7_5kHz[i] = (int32_t*)malloc16_clear( 2*fp->samples_per_subframe*2*sizeof(int32_t) );
|
|
LOG_D(PHY, "rxdata_7_5kHz[%d] %p for RU %d\n", i, ru->common.rxdata_7_5kHz[i], ru->idx);
|
|
}
|
|
|
|
// allocate precoding input buffers (TX)
|
|
ru->common.txdataF = (int32_t **)malloc16(ru->nb_tx*sizeof(int32_t*));
|
|
// [hna] samples_per_frame without CP
|
|
for(int i = 0; i < ru->nb_tx; ++i)
|
|
ru->common.txdataF[i] = (int32_t*)malloc16_clear(fp->samples_per_frame_wCP * sizeof(int32_t));
|
|
|
|
// allocate IFFT input buffers (TX)
|
|
ru->common.txdataF_BF = (int32_t **)malloc16(nb_tx_streams * sizeof(int32_t*));
|
|
LOG_D(PHY, "[INIT] common.txdata_BF= %p (%lu bytes)\n", ru->common.txdataF_BF, nb_tx_streams * sizeof(int32_t *));
|
|
for (int i = 0; i < nb_tx_streams; i++) {
|
|
ru->common.txdataF_BF[i] = (int32_t*)malloc16_clear(fp->samples_per_subframe_wCP * sizeof(int32_t));
|
|
LOG_D(PHY, "txdataF_BF[%d] %p for RU %d\n", i, ru->common.txdataF_BF[i], ru->idx);
|
|
}
|
|
// allocate FFT output buffers (RX)
|
|
ru->common.rxdataF = (int32_t**)malloc16(nb_rx_streams * sizeof(int32_t*));
|
|
for (int i = 0; i < nb_rx_streams; i++) {
|
|
// allocate 4 slots of I/Q signal data (frequency)
|
|
int size = RU_RX_SLOT_DEPTH * fp->symbols_per_slot * fp->ofdm_symbol_size;
|
|
ru->common.rxdataF[i] = (int32_t*)malloc16_clear(sizeof(**ru->common.rxdataF) * size);
|
|
LOG_D(PHY, "rxdataF[%d] %p for RU %d\n", i, ru->common.rxdataF[i], ru->idx);
|
|
}
|
|
|
|
AssertFatal(ru->num_gNB <= NUMBER_OF_gNB_MAX, "gNB instances %d > %d\n", ru->num_gNB,NUMBER_OF_gNB_MAX);
|
|
|
|
LOG_D(PHY, "[INIT] %s() ru->num_gNB:%d \n", __FUNCTION__, ru->num_gNB);
|
|
} // !=IF5
|
|
}
|
|
|
|
void nr_phy_free_RU(RU_t *ru)
|
|
{
|
|
LOG_D(PHY, "Freeing RU signal buffers (if_south %s) nb_tx %d\n", ru_if_types[ru->if_south], ru->nb_tx);
|
|
int nb_tx_streams = ru->nb_tx * ru->num_beams_period;
|
|
int nb_rx_streams = ru->nb_rx * ru->num_beams_period;
|
|
|
|
if (ru->if_south <= REMOTE_IF5) { // this means REMOTE_IF5 or LOCAL_RF, so free memory for time-domain signals
|
|
// Hack: undo what is done at allocation
|
|
for (int i = 0; i < nb_tx_streams; i++) {
|
|
int32_t *p = &ru->common.txdata[i][-ru->sf_extension];
|
|
free_and_zero(p);
|
|
}
|
|
free_and_zero(ru->common.txdata);
|
|
|
|
for (int i = 0; i < nb_rx_streams; i++)
|
|
free_and_zero(ru->common.rxdata[i]);
|
|
free_and_zero(ru->common.rxdata);
|
|
} // else: IF5 or local RF -> nothing to free()
|
|
|
|
if (ru->function != NGFI_RRU_IF5) { // we need to do RX/TX RU processing
|
|
for (int i = 0; i < ru->nb_rx; i++)
|
|
free_and_zero(ru->common.rxdata_7_5kHz[i]);
|
|
free_and_zero(ru->common.rxdata_7_5kHz);
|
|
|
|
// free beamforming input buffers (TX)
|
|
for (int i = 0; i < ru->nb_tx; i++)
|
|
free_and_zero(ru->common.txdataF[i]);
|
|
free_and_zero(ru->common.txdataF);
|
|
|
|
// free IFFT input buffers (TX)
|
|
for (int i = 0; i < nb_tx_streams; i++)
|
|
free_and_zero(ru->common.txdataF_BF[i]);
|
|
free_and_zero(ru->common.txdataF_BF);
|
|
|
|
// free FFT output buffers (RX)
|
|
for (int i = 0; i < nb_rx_streams; i++)
|
|
free_and_zero(ru->common.rxdataF[i]);
|
|
free_and_zero(ru->common.rxdataF);
|
|
|
|
for(int i = 0; i < ru->num_beams_period; ++i)
|
|
free_and_zero(ru->common.beam_id[i]);
|
|
free_and_zero(ru->common.beam_id);
|
|
}
|
|
|
|
PHY_VARS_gNB *gNB0 = ru->gNB_list[0];
|
|
gNB0->num_RU--;
|
|
DevAssert(gNB0->num_RU >= 0);
|
|
}
|