maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

adding allocation free function for offload

Browse Source
This commit is contained in:
Hongzhi Wang
2022-03-09 14:39:03 +01:00
committed by Hongzhi Wang
parent 2423996bba
commit 8af206c644
4 changed files with 116 additions and 250 deletions
Download Patch File Download Diff File Expand all files Collapse all files
openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder_offload.c
+89 -243
View File
@@ -582,17 +582,16 @@ static void
testsuite_teardown(void) testsuite_teardown(void)
{ {
uint8_t dev_id; uint8_t dev_id;
printf("testsuite teardown \n");
/* Unconfigure devices */ /* Unconfigure devices */
// RTE_BBDEV_FOREACH(dev_id) RTE_BBDEV_FOREACH(dev_id)
// rte_bbdev_close(dev_id); rte_bbdev_close(dev_id);
/* Clear active devices structs. */ /* Clear active devices structs. */
// memset(active_devs, 0, sizeof(active_devs)); memset(active_devs, 0, sizeof(active_devs));
// nb_active_devs = 0; nb_active_devs = 0;
/* Disable interrupts */ /* Disable interrupts */
// intr_enabled = false; intr_enabled = false;
} }
static int static int
@@ -624,7 +623,7 @@ ut_teardown(void)
/* read stats and print */ /* read stats and print */
rte_bbdev_stats_get(dev_id, &stats); rte_bbdev_stats_get(dev_id, &stats);
/* Stop the device */ /* Stop the device */
//rte_bbdev_stop(dev_id); rte_bbdev_stop(dev_id);
} }
} }
@@ -756,46 +755,6 @@ allocate_buffers_on_socket(struct rte_bbdev_op_data **buffers, const int len,
} }
static void
ldpc_input_llr_scaling(struct rte_bbdev_op_data *input_ops,
const uint16_t n, const int8_t llr_size,
const int8_t llr_decimals)
{
if (input_ops == NULL)
return;
uint16_t i, byte_idx;
int16_t llr_max, llr_min, llr_tmp;
llr_max = (1 << (llr_size - 1)) - 1;
llr_min = -llr_max;
for (i = 0; i < n; ++i) {
struct rte_mbuf *m = input_ops[i].data;
while (m != NULL) {
int8_t *llr = rte_pktmbuf_mtod_offset(m, int8_t *,
input_ops[i].offset);
for (byte_idx = 0; byte_idx < rte_pktmbuf_data_len(m);
++byte_idx) {
llr_tmp = llr[byte_idx];
if (llr_decimals == 4)
llr_tmp *= 8;
else if (llr_decimals == 2)
llr_tmp *= 2;
else if (llr_decimals == 0)
llr_tmp /= 2;
llr_tmp = RTE_MIN(llr_max,
RTE_MAX(llr_min, llr_tmp));
llr[byte_idx] = (int8_t) llr_tmp;
}
m = m->next;
}
}
}
static int static int
fill_queue_buffers(struct test_op_params *op_params,int8_t* p_llr, uint32_t data_len, fill_queue_buffers(struct test_op_params *op_params,int8_t* p_llr, uint32_t data_len,
struct rte_mempool *in_mp, struct rte_mempool *hard_out_mp, struct rte_mempool *in_mp, struct rte_mempool *hard_out_mp,
@@ -808,9 +767,9 @@ fill_queue_buffers(struct test_op_params *op_params,int8_t* p_llr, uint32_t data
int ret; int ret;
enum op_data_type type; enum op_data_type type;
const uint16_t n = op_params->num_to_process; const uint16_t n = op_params->num_to_process;
int ldpc_llr_decimals; //int ldpc_llr_decimals;
int ldpc_llr_size; //int ldpc_llr_size;
uint32_t ldpc_cap_flags; //uint32_t ldpc_cap_flags;
struct rte_mempool *mbuf_pools[DATA_NUM_TYPES] = { struct rte_mempool *mbuf_pools[DATA_NUM_TYPES] = {
in_mp, in_mp,
@@ -1064,7 +1023,7 @@ create_reference_ldpc_dec_op(struct rte_bbdev_dec_op *op, t_nrLDPCoffload_params
static uint32_t /*static uint32_t
calc_ldpc_dec_TB_size(struct rte_bbdev_dec_op *op) calc_ldpc_dec_TB_size(struct rte_bbdev_dec_op *op)
{ {
uint8_t i; uint8_t i;
@@ -1085,7 +1044,7 @@ calc_ldpc_dec_TB_size(struct rte_bbdev_dec_op *op)
} }
return tb_size; return tb_size;
} }
*/
static int static int
init_test_op_params(struct test_op_params *op_params, init_test_op_params(struct test_op_params *op_params,
@@ -1118,124 +1077,12 @@ init_test_op_params(struct test_op_params *op_params,
return 0; return 0;
} }
static int
decod_on_device(uint8_t dev_id,
struct test_op_params *op_params, int8_t* p_llr,
t_nrLDPCoffload_params *p_offloadParams, int8_t* p_out)
{
int t_ret, f_ret, socket_id = SOCKET_ID_ANY;
unsigned int i;
struct active_device *ad;
unsigned int burst_sz = get_burst_sz();
enum rte_bbdev_op_type op_type = RTE_BBDEV_OP_LDPC_DEC;
const struct rte_bbdev_op_cap *capabilities = NULL;
ad = &active_devs[dev_id];
/* Check if device supports op_type */
if (!is_avail_op(ad, op_type))
return TEST_SUCCESS;
struct rte_bbdev_info info;
rte_bbdev_info_get(ad->dev_id, &info);
socket_id = GET_SOCKET(info.socket_id);
f_ret = create_mempools(ad, socket_id, op_type,
get_num_ops(),p_offloadParams);
if (f_ret != TEST_SUCCESS) {
printf("Couldn't create mempools");
goto fail;
}
f_ret = init_test_op_params(op_params, op_type,
0,
0,
ad->ops_mempool,
burst_sz,
get_num_ops(),
get_num_lcores());
if (f_ret != TEST_SUCCESS) {
printf("Couldn't init test op params");
goto fail;
}
/* Find capabilities */
const struct rte_bbdev_op_cap *cap = info.drv.capabilities;
for (i = 0; i < RTE_BBDEV_OP_TYPE_COUNT; i++) {
if (cap->type == op_type) {
capabilities = cap;
break;
}
cap++;
}
TEST_ASSERT_NOT_NULL(capabilities,
"Couldn't find capabilities");
create_reference_ldpc_dec_op(op_params->ref_dec_op, p_offloadParams);
printf("info alig %d queue id %d nb queue %d socket id %d\n", info.drv.min_alignment, ad->queue_ids[i], ad->nb_queues, socket_id);
for (i = 0; i < ad->nb_queues; ++i) {
f_ret = fill_queue_buffers(op_params,
p_llr,
p_offloadParams->E,
ad->in_mbuf_pool,
ad->hard_out_mbuf_pool,
ad->soft_out_mbuf_pool,
ad->harq_in_mbuf_pool,
ad->harq_out_mbuf_pool,
ad->queue_ids[i],
capabilities,
info.drv.min_alignment,
socket_id);
if (f_ret != TEST_SUCCESS) {
printf("Couldn't init queue buffers");
goto fail;
}
}
// t_ret = start_pmd_dec(ad, op_params, p_offloadParams, p_out);
/* Free active device resources and return */
//free_buffers(ad, op_params);
return t_ret;
fail:
free_buffers(ad, op_params);
return TEST_FAILED;
}
/* Run ldpc per active device per supported op type
* per burst size.
*/
static int
ldpc_decod_ut(struct test_op_params *op_params, int8_t* p_llr, t_nrLDPCoffload_params *p_offloadParams, int8_t* p_out)
{
int ret = 0;
uint8_t dev;
/* Alloc op_params */
/*struct test_op_params *op_params = rte_zmalloc(NULL,
sizeof(struct test_op_params), RTE_CACHE_LINE_SIZE);
TEST_ASSERT_NOT_NULL(op_params, "Failed to alloc %zuB for op_params",
RTE_ALIGN(sizeof(struct test_op_params),
RTE_CACHE_LINE_SIZE));
*/
/* For each device run test case function */
for (dev = 0; dev < nb_active_devs; ++dev)
ret |= decod_on_device(dev, op_params, p_llr, p_offloadParams, p_out);
// rte_free(op_params);
return ret;
}
static int static int
pmd_lcore_ldpc_dec(void *arg) pmd_lcore_ldpc_dec(void *arg)
{ {
struct thread_params *tp = arg; struct thread_params *tp = arg;
uint16_t enq, deq; uint16_t enq, deq;
uint64_t total_time = 0, start_time; //uint64_t total_time = 0, start_time;
const uint16_t queue_id = tp->queue_id; const uint16_t queue_id = tp->queue_id;
const uint16_t burst_sz = tp->op_params->burst_sz; const uint16_t burst_sz = tp->op_params->burst_sz;
const uint16_t num_ops = tp->op_params->num_to_process; const uint16_t num_ops = tp->op_params->num_to_process;
@@ -1389,7 +1236,7 @@ start_pmd_dec(struct active_device *ad,
int ret; int ret;
unsigned int lcore_id, used_cores = 0; unsigned int lcore_id, used_cores = 0;
struct thread_params *t_params, *tp; struct thread_params *t_params, *tp;
struct rte_bbdev_info info; //struct rte_bbdev_info info;
uint16_t num_lcores; uint16_t num_lcores;
//rte_bbdev_info_get(ad->dev_id, &info); //rte_bbdev_info_get(ad->dev_id, &info);
@@ -1572,81 +1419,75 @@ int32_t nrLDPC_decod_offload(t_nrLDPC_dec_params* p_decParams, uint8_t C, uint8_
struct active_device *ad; struct active_device *ad;
ad = &active_devs[0]; ad = &active_devs[0];
if (mode==0){ int socket_id;
int i,f_ret;
struct rte_bbdev_info info;
enum rte_bbdev_op_type op_type = RTE_BBDEV_OP_LDPC_DEC;
ret = rte_eal_init(argc_re, argv_re); switch (mode) {
if (ret<0) { case 0:
printf("Could not init EAL, ret %d\n",ret); ret = rte_eal_init(argc_re, argv_re);
return(-1); if (ret<0) {
} printf("Could not init EAL, ret %d\n",ret);
ret = device_setup(); return(-1);
if (ret != TEST_SUCCESS) { }
printf("Couldn't create mempools"); ret = device_setup();
return(-1); if (ret != TEST_SUCCESS) {
} printf("Couldn't setup device");
ret=ut_setup(); return(-1);
if (ret != TEST_SUCCESS) { }
printf("Couldn't create mempools"); ret=ut_setup();
return(-1); if (ret != TEST_SUCCESS) {
} printf("Couldn't setup ut");
return(-1);
}
p_offloadParams->E = E; p_offloadParams->E = E;
p_offloadParams->n_cb = (p_decParams->BG==1)?(66*p_decParams->Z):(50*p_decParams->Z); p_offloadParams->n_cb = (p_decParams->BG==1)?(66*p_decParams->Z):(50*p_decParams->Z);
p_offloadParams->BG = p_decParams->BG; p_offloadParams->BG = p_decParams->BG;
p_offloadParams->Z = p_decParams->Z; p_offloadParams->Z = p_decParams->Z;
p_offloadParams->rv = rv; p_offloadParams->rv = rv;
p_offloadParams->F = F; p_offloadParams->F = F;
p_offloadParams->Qm = Qm; p_offloadParams->Qm = Qm;
//struct test_op_params *op_params = rte_zmalloc(NULL, op_params = rte_zmalloc(NULL,
op_params = rte_zmalloc(NULL,
sizeof(struct test_op_params), RTE_CACHE_LINE_SIZE); sizeof(struct test_op_params), RTE_CACHE_LINE_SIZE);
TEST_ASSERT_NOT_NULL(op_params, "Failed to alloc %zuB for op_params", TEST_ASSERT_NOT_NULL(op_params, "Failed to alloc %zuB for op_params",
RTE_ALIGN(sizeof(struct test_op_params), RTE_ALIGN(sizeof(struct test_op_params),
RTE_CACHE_LINE_SIZE)); RTE_CACHE_LINE_SIZE));
int socket_id;
int f_ret;
struct rte_bbdev_info info;
rte_bbdev_info_get(ad->dev_id, &info);
socket_id = GET_SOCKET(info.socket_id);
enum rte_bbdev_op_type op_type = RTE_BBDEV_OP_LDPC_DEC;
f_ret = create_mempools(ad, socket_id, op_type,
get_num_ops(),p_offloadParams);
if (f_ret != TEST_SUCCESS) {
printf("Couldn't create mempools");
return(-1);
}
f_ret = init_test_op_params(op_params, op_type,
0,
0,
ad->ops_mempool,
1,
get_num_ops(),
get_num_lcores());
if (f_ret != TEST_SUCCESS) {
printf("Couldn't init test op params");
return(-1);
}
}
else{
//printf("offload param E %d BG %d F %d Z %d Qm %d\n", E,p_decParams->BG, F,p_decParams->Z, Qm);
p_offloadParams->E = E;
p_offloadParams->n_cb = (p_decParams->BG==1)?(66*p_decParams->Z):(50*p_decParams->Z);
p_offloadParams->BG = p_decParams->BG;
p_offloadParams->Z = p_decParams->Z;
p_offloadParams->rv = rv;
p_offloadParams->F = F;
p_offloadParams->Qm = Qm;
int socket_id;
int f_ret, i;
const struct rte_bbdev_op_cap *capabilities = NULL;
struct rte_bbdev_info info;
rte_bbdev_info_get(ad->dev_id, &info); rte_bbdev_info_get(ad->dev_id, &info);
socket_id = GET_SOCKET(info.socket_id); socket_id = GET_SOCKET(info.socket_id);
enum rte_bbdev_op_type op_type = RTE_BBDEV_OP_LDPC_DEC; f_ret = create_mempools(ad, socket_id, op_type,
get_num_ops(),p_offloadParams);
if (f_ret != TEST_SUCCESS) {
printf("Couldn't create mempools");
}
f_ret = init_test_op_params(op_params, op_type,
0,
0,
ad->ops_mempool,
1,
get_num_ops(),
get_num_lcores());
if (f_ret != TEST_SUCCESS) {
printf("Couldn't init test op params");
}
break;
case 1:
//printf("offload param E %d BG %d F %d Z %d Qm %d\n", E,p_decParams->BG, F,p_decParams->Z, Qm);
p_offloadParams->E = E;
p_offloadParams->n_cb = (p_decParams->BG==1)?(66*p_decParams->Z):(50*p_decParams->Z);
p_offloadParams->BG = p_decParams->BG;
p_offloadParams->Z = p_decParams->Z;
p_offloadParams->rv = rv;
p_offloadParams->F = F;
p_offloadParams->Qm = Qm;
const struct rte_bbdev_op_cap *capabilities = NULL;
rte_bbdev_info_get(ad->dev_id, &info);
socket_id = GET_SOCKET(info.socket_id);
//enum rte_bbdev_op_type op_type = RTE_BBDEV_OP_LDPC_DEC;
const struct rte_bbdev_op_cap *cap = info.drv.capabilities; const struct rte_bbdev_op_cap *cap = info.drv.capabilities;
for (i = 0; i < RTE_BBDEV_OP_TYPE_COUNT; i++) { for (i = 0; i < RTE_BBDEV_OP_TYPE_COUNT; i++) {
@@ -1677,19 +1518,24 @@ int32_t nrLDPC_decod_offload(t_nrLDPC_dec_params* p_decParams, uint8_t C, uint8_
} }
} }
ret = start_pmd_dec(ad, op_params, p_offloadParams, p_out);
if (ret<0) {
printf("Couldn't start pmd dec");
return(-1);
}
break;
case 2:
ret = start_pmd_dec(ad, op_params, p_offloadParams, p_out); free_buffers(ad, op_params);
if (ret<0) { rte_free(op_params);
printf("Couldn't start pmd dec"); ut_teardown();
return(-1); testsuite_teardown();
break;
default:
printf("Unknown mode: %d\n", mode);
return;
} }
// free_buffers(ad, op_params);
// rte_free(op_params);
}
//ut_teardown();
return numIter; return numIter;
} }
openair1/PHY/CODING/nrLDPC_extern.h
+1
View File
@@ -30,6 +30,7 @@ nrLDPC_dectopfunc_t top_testsuite;
/* functions to load the LDPC shared lib, implemented in openair1/PHY/CODING/nrLDPC_load.c */ /* functions to load the LDPC shared lib, implemented in openair1/PHY/CODING/nrLDPC_load.c */
extern int load_nrLDPClib(char *version) ; extern int load_nrLDPClib(char *version) ;
extern int load_nrLDPClib_offload(void) ; extern int load_nrLDPClib_offload(void) ;
extern int free_nrLDPClib_offload(void) ;
extern int load_nrLDPClib_ref(char *libversion, nrLDPC_encoderfunc_t * nrLDPC_encoder_ptr); // for ldpctest extern int load_nrLDPClib_ref(char *libversion, nrLDPC_encoderfunc_t * nrLDPC_encoder_ptr); // for ldpctest
/* ldpc coder/decoder functions, as loaded by load_nrLDPClib(). */ /* ldpc coder/decoder functions, as loaded by load_nrLDPClib(). */
extern nrLDPC_initcallfunc_t nrLDPC_initcall; extern nrLDPC_initcallfunc_t nrLDPC_initcall;
openair1/PHY/CODING/nrLDPC_load.c
+20
View File
@@ -101,6 +101,26 @@ int load_nrLDPClib_offload(void) {
return 0; return 0;
} }
int free_nrLDPClib_offload(void) {
t_nrLDPC_dec_params decParams;
t_nrLDPC_dec_params* p_decParams = &decParams;
int8_t l[68*384];
int8_t llrProcBuf[22*384];
p_decParams->Z = 384;
p_decParams->BG = 1;
nrLDPC_decoder_offload(p_decParams,
1,
0,
0,
25344,
8,
l,
llrProcBuf, 2);
return 0;
}
int load_nrLDPClib_ref(char *libversion, nrLDPC_encoderfunc_t * nrLDPC_encoder_ptr) { int load_nrLDPClib_ref(char *libversion, nrLDPC_encoderfunc_t * nrLDPC_encoder_ptr) {
loader_shlibfunc_t shlib_encoder_fdesc; loader_shlibfunc_t shlib_encoder_fdesc;
openair1/SIMULATION/NR_PHY/ulsim.c
+1 -2
View File
@@ -647,8 +647,6 @@ int main(int argc, char **argv)
get_softmodem_params()->do_ra = 0; get_softmodem_params()->do_ra = 0;
get_softmodem_params()->usim_test = 1; get_softmodem_params()->usim_test = 1;
//load_nrLDPClib_offload();
if (snr1set == 0) if (snr1set == 0)
snr1 = snr0 + 10; snr1 = snr0 + 10;
double sampling_frequency; double sampling_frequency;
@@ -1544,6 +1542,7 @@ int main(int argc, char **argv)
LOG_MM("ulsimStats.m","EffTP",effTP,snrRun,1,7); LOG_MM("ulsimStats.m","EffTP",effTP,snrRun,1,7);
free(test_input_bit); free(test_input_bit);
free(estimated_output_bit); free(estimated_output_bit);
free_nrLDPClib_offload();
if (output_fd) if (output_fd)
fclose(output_fd); fclose(output_fd);