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

moving more init functions to device initialization

Browse Source
This commit is contained in:
Hongzhi Wang
2022-03-09 14:37:27 +01:00
committed by Hongzhi Wang
parent 6532db1233
commit 7b88c36ba6
4 changed files with 136 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files
openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder_offload.c
+124 -255
View File
@@ -28,7 +28,6 @@
* \warning
*/
#include <stdint.h>
#include <immintrin.h>
#include "nrLDPCdecoder_defs.h"
@@ -73,7 +72,7 @@
#define GET_SOCKET(socket_id) (((socket_id) == SOCKET_ID_ANY) ? 0 : (socket_id))
#define MAX_QUEUES RTE_MAX_LCORE
#define TEST_REPETITIONS 1
#define TEST_REPETITIONS 1
#ifdef RTE_LIBRTE_PMD_BBDEV_FPGA_LTE_FEC
#include <fpga_lte_fec.h>
@@ -114,19 +113,11 @@
/* Headroom for filler LLRs insertion in HARQ buffer */
#define FILLER_HEADROOM 1024
struct test_bbdev_vector test_vector;
struct test_bbdev_vector test_vector_dec;
/* Switch between PMD and Interrupt for throughput TC */
static bool intr_enabled;
/* LLR arithmetic representation for numerical conversion */
static int ldpc_llr_decimals;
static int ldpc_llr_size;
/* Keep track of the LDPC decoder device capability flag */
static uint32_t ldpc_cap_flags;
/* Represents tested active devices */
static struct active_device {
struct active_device {
const char *driver_name;
uint8_t dev_id;
uint16_t supported_ops;
@@ -286,7 +277,6 @@ create_mbuf_pool(uint32_t length, uint8_t dev_id,
int socket_id, unsigned int mbuf_pool_size,
const char *op_type_str)
{
unsigned int i;
uint32_t max_seg_sz = 0;
char pool_name[RTE_MEMPOOL_NAMESIZE];
@@ -358,7 +348,6 @@ create_mempools(struct active_device *ad, int socket_id,
socket_id);
ad->in_mbuf_pool = mp;
}
/* Hard outputs */
if (nb_segments > 0) {
mbuf_pool_size = optimal_mempool_size(ops_pool_size *
@@ -765,45 +754,6 @@ allocate_buffers_on_socket(struct rte_bbdev_op_data **buffers, const int len,
}
/*
* We may have to insert filler bits
* when they are required by the HARQ assumption
*/
static void
ldpc_add_filler(struct rte_bbdev_op_data *input_ops,
const uint16_t n, struct test_op_params *op_params)
{
struct rte_bbdev_op_ldpc_dec dec = op_params->ref_dec_op->ldpc_dec;
if (input_ops == NULL)
return;
/* No need to add filler if not required by device */
if (!(ldpc_cap_flags &
RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_FILLERS))
return;
/* No need to add filler for loopback operation */
if (dec.op_flags & RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK)
return;
uint16_t i, j, parity_offset;
for (i = 0; i < n; ++i) {
struct rte_mbuf *m = input_ops[i].data;
int8_t *llr = rte_pktmbuf_mtod_offset(m, int8_t *,
input_ops[i].offset);
parity_offset = (dec.basegraph == 1 ? 20 : 8)
* dec.z_c - dec.n_filler;
uint16_t new_hin_size = input_ops[i].length + dec.n_filler;
m->data_len = new_hin_size;
input_ops[i].length = new_hin_size;
for (j = new_hin_size - 1; j >= parity_offset + dec.n_filler;
j--)
llr[j] = llr[j - dec.n_filler];
uint16_t llr_max_pre_scaling = (1 << (ldpc_llr_size - 1)) - 1;
for (j = 0; j < dec.n_filler; j++)
llr[parity_offset + j] = llr_max_pre_scaling;
}
}
static void
ldpc_input_llr_scaling(struct rte_bbdev_op_data *input_ops,
const uint16_t n, const int8_t llr_size,
@@ -856,6 +806,9 @@ fill_queue_buffers(struct test_op_params *op_params,int8_t* p_llr, uint32_t data
int ret;
enum op_data_type type;
const uint16_t n = op_params->num_to_process;
int ldpc_llr_decimals;
int ldpc_llr_size;
uint32_t ldpc_cap_flags;
struct rte_mempool *mbuf_pools[DATA_NUM_TYPES] = {
in_mp,
@@ -885,29 +838,19 @@ fill_queue_buffers(struct test_op_params *op_params,int8_t* p_llr, uint32_t data
mbuf_pools[type], n, type, min_alignment);
TEST_ASSERT_SUCCESS(ret,
"Couldn't init rte_bbdev_op_data structs");
}
// if (test_vector.op_type == RTE_BBDEV_OP_LDPC_DEC) {
bool loopback = op_params->ref_dec_op->ldpc_dec.op_flags &
RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK;
bool llr_comp = op_params->ref_dec_op->ldpc_dec.op_flags &
RTE_BBDEV_LDPC_LLR_COMPRESSION;
bool harq_comp = op_params->ref_dec_op->ldpc_dec.op_flags &
RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION;
ldpc_llr_decimals = capabilities->cap.ldpc_dec.llr_decimals;
ldpc_llr_size = capabilities->cap.ldpc_dec.llr_size;
ldpc_cap_flags = capabilities->cap.ldpc_dec.capability_flags;
if (!loopback && !llr_comp)
ldpc_input_llr_scaling(*queue_ops[DATA_INPUT], n,
ldpc_llr_size, ldpc_llr_decimals);
if (!loopback && !harq_comp)
ldpc_input_llr_scaling(*queue_ops[DATA_HARQ_INPUT], n,
ldpc_llr_size, ldpc_llr_decimals);
if (!loopback)
ldpc_add_filler(*queue_ops[DATA_HARQ_INPUT], n,
op_params);
// }
return 0;
}
@@ -946,7 +889,7 @@ maxstar(double A, double B)
}
static void
copy_reference_ldpc_dec_op(struct rte_bbdev_dec_op **ops, unsigned int n,
set_ldpc_dec_op(struct rte_bbdev_dec_op **ops, unsigned int n,
unsigned int start_idx,
struct rte_bbdev_op_data *inputs,
struct rte_bbdev_op_data *hard_outputs,
@@ -957,7 +900,7 @@ copy_reference_ldpc_dec_op(struct rte_bbdev_dec_op **ops, unsigned int n,
t_nrLDPCoffload_params *p_offloadParams)
{
unsigned int i;
struct rte_bbdev_op_ldpc_dec *ldpc_dec = &ref_op->ldpc_dec;
//struct rte_bbdev_op_ldpc_dec *ldpc_dec = &ref_op->ldpc_dec;
for (i = 0; i < n; ++i) {
/* if (ldpc_dec->code_block_mode == 0) {
ops[i]->ldpc_dec.tb_params.ea =
@@ -1007,12 +950,11 @@ copy_reference_ldpc_dec_op(struct rte_bbdev_dec_op **ops, unsigned int n,
static int
/*static int
check_dec_status_and_ordering(struct rte_bbdev_dec_op *op,
unsigned int order_idx, const int expected_status)
{
int status = op->status;
/* ignore parity mismatch false alarms for long iterations */
if (get_iter_max() >= 10) {
if (!(expected_status & (1 << RTE_BBDEV_SYNDROME_ERROR)) &&
(status & (1 << RTE_BBDEV_SYNDROME_ERROR))) {
@@ -1037,7 +979,7 @@ check_dec_status_and_ordering(struct rte_bbdev_dec_op *op,
return TEST_SUCCESS;
}
/*static int
static int
check_enc_status_and_ordering(struct rte_bbdev_enc_op *op,
unsigned int order_idx, const int expected_status)
{
@@ -1060,13 +1002,10 @@ validate_ldpc_dec_op(struct rte_bbdev_dec_op **ops, const uint16_t n,
int8_t* p_out)
{
unsigned int i;
int ret;
struct op_data_entries *hard_data_orig ;
//int ret;
struct rte_bbdev_op_ldpc_dec *ops_td;
struct rte_bbdev_op_data *hard_output;
struct rte_bbdev_op_data *harq_output;
struct rte_bbdev_op_data *soft_output;
struct rte_bbdev_op_ldpc_dec *ref_td = &ref_op->ldpc_dec;
//struct rte_bbdev_op_ldpc_dec *ref_td = &ref_op->ldpc_dec;
struct rte_mbuf *m;
char *data;
@@ -1081,7 +1020,7 @@ validate_ldpc_dec_op(struct rte_bbdev_dec_op **ops, const uint16_t n,
TEST_ASSERT(ops_td->iter_count <= ref_td->iter_count,
"Returned iter_count (%d) > expected iter_count (%d)",
ops_td->iter_count, ref_td->iter_count);
*/
*/
uint16_t offset = hard_output->offset;
uint16_t data_len = rte_pktmbuf_data_len(m) - offset;
@@ -1122,20 +1061,13 @@ static void
create_reference_ldpc_dec_op(struct rte_bbdev_dec_op *op, t_nrLDPCoffload_params *p_offloadParams)
{
// unsigned int i;
// struct op_data_entries *entry;
// op->ldpc_dec = test_vector.ldpc_dec;
// entry = &test_vector.entries[DATA_INPUT];
//for (i = 0; i < entry->nb_segments; ++i)
op->ldpc_dec.input.length = p_offloadParams->E;
// entry->segments[i].length;
/*if (test_vector.ldpc_dec.op_flags &
RTE_BBDEV_LDPC_HQ_COMBINE_IN_ENABLE) {
entry = &test_vector.entries[DATA_HARQ_INPUT];
for (i = 0; i < entry->nb_segments; ++i)
op->ldpc_dec.harq_combined_input.length +=
entry->segments[i].length;
}*/
op->ldpc_dec.basegraph = p_offloadParams->BG;
op->ldpc_dec.z_c = p_offloadParams->Z;
op->ldpc_dec.n_filler = p_offloadParams->F;
op->ldpc_dec.code_block_mode = 1;
}
@@ -1150,6 +1082,8 @@ calc_ldpc_dec_TB_size(struct rte_bbdev_dec_op *op)
if (op->ldpc_dec.code_block_mode) {
tb_size = sys_cols * op->ldpc_dec.z_c - op->ldpc_dec.n_filler;
//printf("calc tb sys cols %d tb_size %d\n",sys_cols,tb_size);
} else {
c = op->ldpc_dec.tb_params.c;
r = op->ldpc_dec.tb_params.r;
@@ -1248,7 +1182,7 @@ decod_on_device(uint8_t dev_id,
"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,
@@ -1268,10 +1202,10 @@ decod_on_device(uint8_t dev_id,
}
}
t_ret = start_pmd_dec(ad, op_params, p_offloadParams, p_out);
// t_ret = start_pmd_dec(ad, op_params, p_offloadParams, p_out);
/* Free active device resources and return */
free_buffers(ad, op_params);
//free_buffers(ad, op_params);
return t_ret;
fail:
@@ -1283,126 +1217,28 @@ fail:
* per burst size.
*/
static int
ldpc_decod_ut(int8_t* p_llr, t_nrLDPCoffload_params *p_offloadParams, int8_t* p_out)
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,
/*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);
// rte_free(op_params);
return ret;
}
/* Push back the HARQ output from DDR to host */
static void
retrieve_harq_ddr(uint16_t dev_id, uint16_t queue_id,
struct rte_bbdev_dec_op **ops,
const uint16_t n)
{
uint16_t j;
int save_status, ret;
uint32_t harq_offset = (uint32_t) queue_id * HARQ_INCR * 1024;
struct rte_bbdev_dec_op *ops_deq[MAX_BURST];
uint32_t flags = ops[0]->ldpc_dec.op_flags;
bool loopback = flags & RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK;
bool mem_out = flags & RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE;
bool hc_out = flags & RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE;
bool h_comp = flags & RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION;
for (j = 0; j < n; ++j) {
if ((loopback && mem_out) || hc_out) {
save_status = ops[j]->status;
ops[j]->ldpc_dec.op_flags =
RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK +
RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_IN_ENABLE;
if (h_comp)
ops[j]->ldpc_dec.op_flags +=
RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION;
ops[j]->ldpc_dec.harq_combined_input.offset =
harq_offset;
ops[j]->ldpc_dec.harq_combined_output.offset = 0;
harq_offset += HARQ_INCR;
if (!loopback)
ops[j]->ldpc_dec.harq_combined_input.length =
ops[j]->ldpc_dec.harq_combined_output.length;
rte_bbdev_enqueue_ldpc_dec_ops(dev_id, queue_id,
&ops[j], 1);
ret = 0;
while (ret == 0)
ret = rte_bbdev_dequeue_ldpc_dec_ops(
dev_id, queue_id,
&ops_deq[j], 1);
ops[j]->ldpc_dec.op_flags = flags;
ops[j]->status = save_status;
}
}
}
/*
* Push back the HARQ output from HW DDR to Host
* Preload HARQ memory input and adjust HARQ offset
*/
static void
preload_harq_ddr(uint16_t dev_id, uint16_t queue_id,
struct rte_bbdev_dec_op **ops, const uint16_t n,
bool preload)
{
uint16_t j;
int ret;
uint32_t harq_offset = (uint32_t) queue_id * HARQ_INCR * 1024;
struct rte_bbdev_op_data save_hc_in, save_hc_out;
struct rte_bbdev_dec_op *ops_deq[MAX_BURST];
uint32_t flags = ops[0]->ldpc_dec.op_flags;
bool mem_in = flags & RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_IN_ENABLE;
bool hc_in = flags & RTE_BBDEV_LDPC_HQ_COMBINE_IN_ENABLE;
bool mem_out = flags & RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE;
bool hc_out = flags & RTE_BBDEV_LDPC_HQ_COMBINE_OUT_ENABLE;
bool h_comp = flags & RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION;
for (j = 0; j < n; ++j) {
if ((mem_in || hc_in) && preload) {
save_hc_in = ops[j]->ldpc_dec.harq_combined_input;
save_hc_out = ops[j]->ldpc_dec.harq_combined_output;
ops[j]->ldpc_dec.op_flags =
RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK +
RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE;
if (h_comp)
ops[j]->ldpc_dec.op_flags +=
RTE_BBDEV_LDPC_HARQ_6BIT_COMPRESSION;
ops[j]->ldpc_dec.harq_combined_output.offset =
harq_offset;
ops[j]->ldpc_dec.harq_combined_input.offset = 0;
rte_bbdev_enqueue_ldpc_dec_ops(dev_id, queue_id,
&ops[j], 1);
ret = 0;
while (ret == 0)
ret = rte_bbdev_dequeue_ldpc_dec_ops(
dev_id, queue_id, &ops_deq[j], 1);
ops[j]->ldpc_dec.op_flags = flags;
ops[j]->ldpc_dec.harq_combined_input = save_hc_in;
ops[j]->ldpc_dec.harq_combined_output = save_hc_out;
}
/* Adjust HARQ offset when we reach external DDR */
if (mem_in || hc_in)
ops[j]->ldpc_dec.harq_combined_input.offset
= harq_offset;
if (mem_out || hc_out)
ops[j]->ldpc_dec.harq_combined_output.offset
= harq_offset;
harq_offset += HARQ_INCR;
}
}
static int
pmd_lcore_ldpc_dec(void *arg, t_nrLDPCoffload_params *p_offloadParams, int8_t* p_out)
{
@@ -1420,11 +1256,10 @@ pmd_lcore_ldpc_dec(void *arg, t_nrLDPCoffload_params *p_offloadParams, int8_t* p
struct rte_bbdev_info info;
uint16_t num_to_enq;
struct rte_bbdev_op_data *hard_output;
struct rte_bbdev_op_ldpc_dec *ops_td;
//struct rte_bbdev_op_data *hard_output;
bool extDdr = check_bit(ldpc_cap_flags,
RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE);
//bool extDdr = check_bit(ldpc_cap_flags,
// RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_OUT_ENABLE);
bool loopback = check_bit(ref_op->ldpc_dec.op_flags,
RTE_BBDEV_LDPC_INTERNAL_HARQ_MEMORY_LOOPBACK);
bool hc_out = check_bit(ref_op->ldpc_dec.op_flags,
@@ -1455,8 +1290,7 @@ pmd_lcore_ldpc_dec(void *arg, t_nrLDPCoffload_params *p_offloadParams, int8_t* p
ref_op->ldpc_dec.iter_max = get_iter_max();
ref_op->ldpc_dec.iter_count = ref_op->ldpc_dec.iter_max;
//if (test_vector.op_type != RTE_BBDEV_OP_NONE)
copy_reference_ldpc_dec_op(ops_enq, num_ops, 0, bufs->inputs,
set_ldpc_dec_op(ops_enq, num_ops, 0, bufs->inputs,
bufs->hard_outputs, bufs->soft_outputs,
bufs->harq_inputs, bufs->harq_outputs, ref_op, p_offloadParams);
@@ -1473,11 +1307,6 @@ pmd_lcore_ldpc_dec(void *arg, t_nrLDPCoffload_params *p_offloadParams, int8_t* p
mbuf_reset(
ops_enq[j]->ldpc_dec.harq_combined_output.data);
}
if (extDdr) {
bool preload = i == (TEST_REPETITIONS - 1);
preload_harq_ddr(tp->dev_id, queue_id, ops_enq,
num_ops, preload);
}
start_time = rte_rdtsc_precise();
for (enq = 0, deq = 0; enq < num_ops;) {
@@ -1509,16 +1338,10 @@ pmd_lcore_ldpc_dec(void *arg, t_nrLDPCoffload_params *p_offloadParams, int8_t* p
tp->iter_count = RTE_MAX(ops_enq[i]->ldpc_dec.iter_count,
tp->iter_count);
}
if (extDdr) {
/* Read loopback is not thread safe */
retrieve_harq_ddr(tp->dev_id, queue_id, ops_enq, num_ops);
}
//if (test_vector.op_type != RTE_BBDEV_OP_NONE) {
ret = validate_ldpc_dec_op(ops_deq, num_ops, ref_op,
tp->op_params->vector_mask, p_out);
TEST_ASSERT_SUCCESS(ret, "Validation failed!");
//}
rte_bbdev_dec_op_free_bulk(ops_enq, num_ops);
@@ -1534,25 +1357,6 @@ pmd_lcore_ldpc_dec(void *arg, t_nrLDPCoffload_params *p_offloadParams, int8_t* p
}
static void
print_enc_throughput(struct thread_params *t_params, unsigned int used_cores)
{
unsigned int iter = 0;
double total_mops = 0, total_mbps = 0;
for (iter = 0; iter < used_cores; iter++) {
printf(
"Throughput for core (%u): %.8lg Ops/s, %.8lg Mbps\n",
t_params[iter].lcore_id, t_params[iter].ops_per_sec,
t_params[iter].mbps);
total_mops += t_params[iter].ops_per_sec;
total_mbps += t_params[iter].mbps;
}
printf(
"\nTotal throughput for %u cores: %.8lg MOPS, %.8lg Mbps\n",
used_cores, total_mops, total_mbps);
}
/* Aggregate the performance results over the number of cores used */
static void
print_dec_throughput(struct thread_params *t_params, unsigned int used_cores)
@@ -1594,22 +1398,16 @@ start_pmd_dec(struct active_device *ad,
struct thread_params *t_params, *tp;
struct rte_bbdev_info info;
uint16_t num_lcores;
const char *op_type_str;
rte_bbdev_info_get(ad->dev_id, &info);
op_type_str = rte_bbdev_op_type_str(test_vector.op_type);
TEST_ASSERT_NOT_NULL(op_type_str, "Invalid op type: %u",
test_vector.op_type);
printf("+ ------------------------------------------------------- +\n");
printf("== start pmd dec\ndev: %s, nb_queues: %u, burst size: %u, num ops: %u, num_lcores: %u, op type: %s, itr mode: %s, GHz: %lg\n",
/*printf("+ ------------------------------------------------------- +\n");
printf("== start pmd dec\ndev: %s, nb_queues: %u, burst size: %u, num ops: %u, num_lcores: %u, itr mode: %s, GHz: %lg\n",
info.dev_name, ad->nb_queues, op_params->burst_sz,
op_params->num_to_process, op_params->num_lcores,
op_type_str,
intr_enabled ? "Interrupt mode" : "PMD mode",
(double)rte_get_tsc_hz() / 1000000000.0);
*/
/* Set number of lcores */
num_lcores = (ad->nb_queues < (op_params->num_lcores))
? ad->nb_queues
@@ -1640,7 +1438,6 @@ start_pmd_dec(struct active_device *ad,
t_params[used_cores].op_params = op_params;
t_params[used_cores].queue_id = ad->queue_ids[used_cores];
t_params[used_cores].iter_count = 0;
rte_eal_remote_launch(pmd_lcore_ldpc_dec,
&t_params[used_cores++], lcore_id);
}
@@ -1660,11 +1457,7 @@ start_pmd_dec(struct active_device *ad,
/* Print throughput if interrupts are disabled and test passed */
if (!intr_enabled) {
if (test_vector.op_type == RTE_BBDEV_OP_TURBO_DEC ||
test_vector.op_type == RTE_BBDEV_OP_LDPC_DEC)
print_dec_throughput(t_params, num_lcores);
else
print_enc_throughput(t_params, num_lcores);
//print_dec_throughput(t_params, num_lcores);
rte_free(t_params);
return ret;
}
@@ -1702,12 +1495,7 @@ start_pmd_dec(struct active_device *ad,
/* Print throughput if test passed */
if (!ret) {
if (test_vector.op_type == RTE_BBDEV_OP_TURBO_DEC ||
test_vector.op_type == RTE_BBDEV_OP_LDPC_DEC)
print_dec_throughput(t_params, num_lcores);
else if (test_vector.op_type == RTE_BBDEV_OP_TURBO_ENC ||
test_vector.op_type == RTE_BBDEV_OP_LDPC_ENC)
print_enc_throughput(t_params, num_lcores);
}
rte_free(t_params);
@@ -1728,11 +1516,6 @@ static struct test_params {
bool init_device;
} test_params;
const char *
get_vector_filename(void)
{
return test_params.test_vector_filename;
}
unsigned int
get_num_ops(void)
{
@@ -1769,8 +1552,11 @@ get_init_device(void)
return test_params.init_device;
}
struct test_op_params op_params_e;
struct test_op_params *op_params = &op_params_e;
int32_t nrLDPC_decod_offload(t_nrLDPC_dec_params* p_decParams, uint8_t C, uint8_t rv, uint16_t F,
uint32_t E, uint8_t Qm, int8_t* p_llr, int8_t* p_out, uint8_t mode)
uint32_t E, uint8_t Qm, int8_t* p_llr, int8_t* p_out, uint8_t mode)
{
t_nrLDPCoffload_params offloadParams;
t_nrLDPCoffload_params* p_offloadParams = &offloadParams;
@@ -1787,15 +1573,55 @@ int32_t nrLDPC_decod_offload(t_nrLDPC_dec_params* p_decParams, uint8_t C, uint8_
test_params.burst_sz=1;
test_params.num_lcores=1;
test_params.num_tests = 1;
struct active_device *ad;
ad = &active_devs[0];
if (mode==0){
printf("offload mode %d\n", mode);
ret = rte_eal_init(argc_re, argv_re);
device_setup();
ut_setup();
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;
//struct test_op_params *op_params = rte_zmalloc(NULL,
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));
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");
}
f_ret = init_test_op_params(op_params, op_type,
0,
0,
ad->ops_mempool,
1,
1,
1);
if (f_ret != TEST_SUCCESS) {
printf("Couldn't init test op params");
}
}
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);
@@ -1804,7 +1630,50 @@ int32_t nrLDPC_decod_offload(t_nrLDPC_dec_params* p_decParams, uint8_t C, uint8_
p_offloadParams->rv = rv;
p_offloadParams->F = F;
p_offloadParams->Qm = Qm;
ldpc_decod_ut(p_llr, p_offloadParams, p_out);
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);
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;
for (i = 0; i < RTE_BBDEV_OP_TYPE_COUNT; i++) {
if (cap->type == op_type) {
capabilities = cap;
break;
}
cap++;
}
create_reference_ldpc_dec_op(op_params->ref_dec_op, p_offloadParams);
ad->nb_queues =1;
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");
}
}
start_pmd_dec(ad, op_params, p_offloadParams, p_out);
// free_buffers(ad, op_params);
// rte_free(op_params);
}
//ut_teardown();
openair1/PHY/CODING/nrLDPC_defs.h
+2 -2
View File
@@ -24,6 +24,7 @@
#define __NRLDPC_DEFS__H__
#include <openair1/PHY/defs_nr_common.h>
#include "openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h"
/**
\brief LDPC encoder
\param 1 input
@@ -73,8 +74,7 @@ typedef int(*nrLDPC_encoderfunc_t)(unsigned char **,unsigned char **,int,int,sho
*/
typedef int32_t(*nrLDPC_decoderfunc_t)(t_nrLDPC_dec_params* , int8_t*, int8_t* , t_nrLDPC_procBuf* , t_nrLDPC_time_stats* );
//typedef int32_t(*nrLDPC_decoffloadfunc_t)(t_nrLDPC_dec_params* , int8_t*, int8_t* , t_nrLDPC_procBuf* , t_nrLDPC_time_stats* );
typedef int32_t(*nrLDPC_decoffloadfunc_t)(t_nrLDPC_dec_params* , uint8_t , uint8_t, uint16_t, uint32_t, uint8_t, int8_t*, int8_t* ,uint8_t );
typedef int32_t(*nrLDPC_decoffloadfunc_t)(t_nrLDPC_dec_params* , uint8_t , uint8_t, uint16_t, uint32_t, uint8_t, int8_t*, int8_t* ,uint8_t);
typedef int32_t(*nrLDPC_dectopfunc_t)(void);
#endif
openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c
+4 -4
View File
@@ -602,17 +602,17 @@ uint32_t nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
{
pl_ol128[j] = _mm_packs_epi16(pv_ol128[i],pv_ol128[i+1]);
}
ret = nrLDPC_decoder_offload(p_decParams,
1, //harq_process->C,
1,
pusch_pdu->pusch_data.rv_index,
harq_process->F,
E,
Qm,
(int8_t*)&pl_ol128[0],
llrProcBuf, 1);
for (int m=0; m < Kr>>3; m ++) {
for (int m=0; m < Kr>>3; m ++) {
harq_process->c[r][m]= (uint8_t) llrProcBuf[m];
}
openair1/SIMULATION/NR_PHY/ulsim.c
+6 -4
View File
@@ -648,17 +648,19 @@ int main(int argc, char **argv)
int8_t l_ol [68*384];
__m128i *pl_ol128 = (__m128i*)&l_ol;
int8_t llrProcBuf[22*384];
p_decParams->Z = 384;
p_decParams->BG = 1;
nrLDPC_decoder_offload(p_decParams,
1,
0,
0,
0,
2,
25344,
8,
(int8_t*)&pl_ol128[0],
llrProcBuf, 0);
if (snr1set == 0)
snr1 = snr0 + 10;
double sampling_frequency;