Add T2 LDPC encoding/decoding offload

CMakeLists.txt

@@ -494,6 +494,25 @@ target_link_libraries(shlib_loader PRIVATE CONFIG_LIB)
 
 ##########################################################
 
+# LDPC offload library - AMD T2 Accelerator Card
+##########################################################
+
+add_boolean_option(ENABLE_LDPC_T2 OFF "Build support for LDPC Offload to T2 library" OFF)
+set(ENV{PKG_CONFIG_PATH} "$ENV{PKG_CONFIG_PATH}:/usr/local/lib/x86_64-linux-gnu/pkgconfig")
+if (ENABLE_LDPC_T2)
+  pkg_check_modules(LIBDPDK_T2 REQUIRED libdpdk=20.11.7)
+  find_library(PMD_T2 NAMES rte_baseband_accl_ldpc HINTS "/opt/dpdk-t2/lib/x86_64-linux-gnu/")
+  if (NOT PMD_T2)
+    message(FATAL_ERROR "could not find PMD T2")
+  endif()
+  message(STATUS "T2 build: use ${PMD_T2}")
+  add_library(ldpc_t2 MODULE ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder_offload.c)
+  set_target_properties(ldpc_t2 PROPERTIES COMPILE_FLAGS "-DALLOW_EXPERIMENTAL_API")
+  target_link_libraries(ldpc_t2 ${LIBDPDK_T2_LDFLAGS} ${PMD_T2})
+endif()
+
+##########################################################
+
 include_directories ("${OPENAIR_DIR}/radio/COMMON")
 
 ##############################################################
@@ -801,19 +820,30 @@ set(PHY_LDPC_ORIG_SRC
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder.c
 )
+add_library(ldpc_orig MODULE ${PHY_LDPC_ORIG_SRC} )
+target_link_libraries(ldpc_orig PRIVATE ldpc_gen_HEADERS)
 
 set(PHY_LDPC_OPTIM_SRC
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder_optim.c
-)
+  )
+add_library(ldpc_optim MODULE ${PHY_LDPC_OPTIM_SRC} )
+target_link_libraries(ldpc_optim PRIVATE ldpc_gen_HEADERS)
+
 set(PHY_LDPC_OPTIM8SEG_SRC
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder_optim8seg.c
 )
+add_library(ldpc_optim8seg MODULE ${PHY_LDPC_OPTIM8SEG_SRC} )
+target_link_libraries(ldpc_optim8seg PRIVATE ldpc_gen_HEADERS)
+
 set(PHY_LDPC_OPTIM8SEGMULTI_SRC
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder/nrLDPC_decoder.c
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder_optim8segmulti.c
-)
+  )
+add_library(ldpc MODULE ${PHY_LDPC_OPTIM8SEGMULTI_SRC} )
+target_link_libraries(ldpc PRIVATE ldpc_gen_HEADERS)
+
 set(PHY_LDPC_CUDA_SRC
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_decoder_LYC/nrLDPC_decoder_LYC.cu
   ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_encoder/ldpc_encoder_optim8segmulti.c
@@ -2057,6 +2087,10 @@ endif()
 
 add_dependencies(nr-softmodem ldpc_orig ldpc_optim ldpc_optim8seg ldpc)
 
+if (ENABLE_LDPC_T2)
+  add_dependencies(nr-softmodem ldpc_t2)
+endif()
+
 # force the generation of ASN.1 so that we don't need to wait during the build
 target_link_libraries(nr-softmodem PRIVATE
   asn1_lte_rrc asn1_nr_rrc asn1_s1ap asn1_ngap asn1_m2ap asn1_m3ap asn1_x2ap asn1_f1ap asn1_lpp)
@@ -2270,6 +2304,10 @@ add_executable(nr_ulsim
   ${PHY_INTERFACE_DIR}/queue_t.c
   )
 
+if (ENABLE_LDPC_T2)
+  add_dependencies(nr_ulsim ldpc_t2)
+endif()
+
 target_link_libraries(nr_ulsim PRIVATE
   -Wl,--start-group UTIL SIMU SIMU_ETH PHY_COMMON PHY_NR_COMMON PHY_NR PHY_NR_UE SCHED_NR_LIB SCHED_NR_UE_LIB MAC_UE_NR MAC_NR_COMMON nr_rrc CONFIG_LIB L2_NR HASHTABLE x2ap SECURITY ngap -lz -Wl,--end-group
   m pthread ${T_LIB} ITTI dl shlib_loader

cmake_targets/build_oai

@@ -46,7 +46,7 @@ BUILD_DOXYGEN=0
 DISABLE_HARDWARE_DEPENDENCY="False"
 CMAKE_BUILD_TYPE="RelWithDebInfo"
 CMAKE_CMD="$CMAKE"
-OPTIONAL_LIBRARIES="telnetsrv enbscope uescope nrscope nrqtscope ldpc_cuda websrv oai_iqplayer"
+OPTIONAL_LIBRARIES="telnetsrv enbscope uescope nrscope nrqtscope ldpc_cuda ldpc_t2 websrv oai_iqplayer"
 TARGET_LIST=""
 
 function print_help() {

doc/LDPC_T2_OFFLOAD_SETUP.md

+<table style="border-collapse: collapse; border: none;">
+  <tr style="border-collapse: collapse; border: none;">
+    <td style="border-collapse: collapse; border: none;">
+      <a href="http://www.openairinterface.org/">
+         <img src="./images/oai_final_logo.png" alt="" border=3 height=50 width=150>
+         </img>
+      </a>
+    </td>
+    <td style="border-collapse: collapse; border: none; vertical-align: center;">
+      <b><font size = "5">OAI T1/T2 LDPC offload</font></b>
+    </td>
+  </tr>
+</table>
+
+**Table of Contents**
+
+[[_TOC_]]
+
+This documentation aims to provide a tutorial for AMD Xilinx T2 Telco card integration into OAI and its usage.
+## Prerequisites
+Offload of the channel decoding was tested with the T2 card in following setup:
+
+**AMD Xilinx T2 card**
+ - bitstream image and PMD driver provided by AccelerComm
+ - DPDK 20.11.3 with patch from Accelercomm (also tested with DPDK 20.11.7
+   version)
+ - tested on RHEL7.9, RHEL9.2, Ubuntu 20.04, Ubuntu 22.04
+
+## DPDK setup
+ - check the presence of the card on the host
+	 - `lspci | grep "Xilinx"`
+ - binding of the device with igb_uio driver
+	 - `./dpdk-devbind.py -b igb_uio <address of the PCI of the card>`
+ - hugepages setup (10 x 1GB hugepages)
+	 - `./dpdk-hugepages.py -p 1G --setup 10G`
+
+*Note: Commands to run from dpdk/usertool folder*
+
+## Compilation
+Deployment of the OAI is precisely described in the following tutorials.
+ - [BUILD](https://gitlab.eurecom.fr/oai/openairinterface5g/-/blob/develop/doc/BUILD.md)
+ - [NR_SA_CN5G_gNB_USRP_COTS_UE_Tutorial](https://gitlab.eurecom.fr/oai/openairinterface5g/-/blob/develop/doc/NR_SA_Tutorial_COTS_UE.md)
+
+Shared object file *libldpc_t2.so* is created  during the compilation. This object is conditionally compiled. Selection of the library to compile is done using *--build-lib ldpc_t2*. Example command to build OAI with support for LDPC offload to T2 card is:
+
+`./build_oai -P --gNB -w USRP --build-lib "ldpc_t2" --ninja`
+
+*Required poll mode driver has to be present on the host machine and required DPDK version has to be installed on the host, prior to the build of OAI*
+
+## nr_ulsim test
+Offload of the channel decoding to the AMD Xilinx T2 card is in nr_ulsim specified by *-o* option. Example command for running nr_ulsim with LDPC decoding offload to the T2 card:
+
+`sudo ./nr_ulsim -n100 -s20 -m20 -r273 -o`
+
+## nr_dlsim test
+Offload of the channel encoding to the AMD Xilinx T2 card is in nr_dlsim specified by *-c* option. Example command for running nr_dlsim with LDPC encoding offload to the T2 card:
+
+`sudo ./nr_dlsim -n300 -s30 -R 106 -e 27 -c`
+
+## OTA and RFSIM test
+Offload of the channel encoding and decoding to the AMD Xilinx T2 card is enabled by *--ldpc-offload-enable 1* option. Example command for running nr-softmodem with LDPC processing on the T2 card:
+
+`./nr-softmodem -O config_file.conf --sa --ldpc-offload-enable 1`
+
+### LDPC encoding/decoding with CPU/GPU
+Available LDPC implementations and loading particular libraries is well described in *openair1/PHY/CODING/DOC/LDPCImplementation.md*. Default library for LDPC processing is called `libldpc.so`. Sample command for running nr-softmodem with selected library (in this case we want to replace `libldpc.so` by `libldpc_optim.so` library):
+`./nr-softmodem -O config_file.conf --sa --loader.ldpc.shlibversion _optim`
+
+Available options:
+- --loader.ldpc.shlibversion _optim8seg
+- --loader.ldpc.shlibversion _optim
+- --loader.ldpc.shlibversion _orig
+- --loader.ldpc.shlibversion _cuda
+- --loader.ldpc.shlibversion _cl
+
+## Limitations
+### AMD Xilinx T1 card
+ - offload of the LDPC decoding implemented only for MCS > 9, decoding of the smaller TBs on the T1 card leads to blocking of the card
+ - HARQ is not functional with LDPC decoding offload to the T1 card (restricted in the code to avoid blocking of the card)
+ - LDPC encoding offload not implemented for the T1 card
+ - not supported in current develop branch, please checkout to *2023.w43*
+### AMD Xilinx T2 card
+ - offload of the LDPC encoding implemented for MCS > 2
+ - occasional blocking of the card in decoder function - issue is investigated

executables/nr-gnb.c

@@ -593,6 +593,7 @@ void init_eNB_afterRU(void) {
     LOG_I(PHY,"RC.nb_nr_CC[inst:%d]:%p\n", inst, RC.gNB[inst]);
 
     gNB = RC.gNB[inst];
+    gNB->ldpc_offload_flag = ldpc_offload_flag;
     gNB->reorder_thread_disable = get_softmodem_params()->reorder_thread_disable;
 
     phy_init_nr_gNB(gNB);

executables/nr-softmodem-common.h

@@ -98,6 +98,7 @@
 #define CONFIG_HLP_WORKER_CMD    "two option for worker 'WORKER_DISABLE' or 'WORKER_ENABLE'\n"
 #define CONFIG_HLP_USRP_THREAD   "having extra thead for usrp tx\n"
 #define CONFIG_HLP_DISABLNBIOT   "disable nb-iot, even if defined in config\n"
+#define CONFIG_HLP_LDPC_OFFLOAD  "enable LDPC offload to AMD Xilinx T2 card\n"
 #define CONFIG_HLP_USRP_ARGS     "set the arguments to identify USRP (same syntax as in UHD)\n"
 #define CONFIG_HLP_TX_SUBDEV     "set the arguments to select tx_subdev (same syntax as in UHD)\n"
 #define CONFIG_HLP_RX_SUBDEV     "set the arguments to select rx_subdev (same syntax as in UHD)\n"

executables/nr-softmodem.h

@@ -29,6 +29,7 @@
   {"D" ,                    CONFIG_HLP_DLBM_PHYTEST,   0,                .u64ptr=&dlsch_slot_bitmap,          .defintval=0,                     TYPE_UINT64, 0},        \
   {"U" ,                    CONFIG_HLP_ULBM_PHYTEST,   0,                .u64ptr=&ulsch_slot_bitmap,          .defintval=0,                     TYPE_UINT64, 0},        \
   {"usrp-tx-thread-config", CONFIG_HLP_USRP_THREAD,    0,                .iptr=&usrp_tx_thread,               .defstrval=0,                     TYPE_INT,    0},        \
+  {"ldpc-offload-enable",   CONFIG_HLP_LDPC_OFFLOAD,   0,                .iptr=&ldpc_offload_flag,            .defstrval=0,                     TYPE_INT,    0},        \
   {"uecap_file",            CONFIG_HLP_UECAP_FILE,     0,                .strptr=&uecap_file,                 .defstrval="./uecap_ports1.xml",  TYPE_STRING, 0},        \
   {"s" ,                    CONFIG_HLP_SNR,            0,                .dblptr=&snr_dB,                     .defdblval=25,                    TYPE_DOUBLE, 0},        \
 }
@@ -43,6 +44,7 @@ extern uint32_t target_ul_bw;
 extern uint64_t dlsch_slot_bitmap;
 extern uint64_t ulsch_slot_bitmap;
 extern char *uecap_file;
+extern int ldpc_offload_flag;
 
 // In nr-gnb.c
 extern void init_gNB(int single_thread_flag,int wait_for_sync);

executables/nr-uesoftmodem.c

@@ -429,7 +429,7 @@ int NB_UE_INST = 1;
 configmodule_interface_t *uniqCfg = NULL;
 
 // A global var to reduce the changes size
-ldpc_interface_t ldpc_interface = {0};
+ldpc_interface_t ldpc_interface = {0}, ldpc_interface_offload = {0};
 
 int main( int argc, char **argv ) {
   int set_exe_prio = 1;

executables/softmodem-common.c

@@ -47,6 +47,7 @@ char *parallel_config=NULL;
 char *worker_config=NULL;
 int usrp_tx_thread = 0;
 char *nfapi_str=NULL;
+int ldpc_offload_flag=0;
 uint8_t nfapi_mode=0;
 
 static mapping softmodem_funcs[] = MAPPING_SOFTMODEM_FUNCTIONS;

executables/softmodem-common.h

@@ -368,6 +368,7 @@ extern int32_t uplink_frequency_offset[MAX_NUM_CCs][4];
 extern int usrp_tx_thread;
 extern uint16_t sl_ahead;
 extern uint16_t sf_ahead;
+extern int ldpc_offload_flag;
 extern int oai_exit;
 
 void tx_func(void *param);

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_offload.h

+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2017 Intel Corporation
+ */
+
+#ifndef _MAIN_H_
+#define _MAIN_H_
+
+#include <stddef.h>
+#include <sys/queue.h>
+
+#include <rte_common.h>
+#include <rte_hexdump.h>
+#include <rte_log.h>
+
+#define TEST_SUCCESS    0
+#define TEST_FAILED     -1
+#define TEST_SKIPPED    1
+
+#define MAX_BURST 512U
+#define DEFAULT_BURST 32U
+#define DEFAULT_OPS 64U
+#define DEFAULT_ITER 6U
+
+enum op_data_type {
+  DATA_INPUT = 0,
+  DATA_SOFT_OUTPUT,
+  DATA_HARD_OUTPUT,
+  DATA_HARQ_INPUT,
+  DATA_HARQ_OUTPUT,
+  DATA_NUM_TYPES,
+};
+
+#define TEST_ASSERT(cond, msg, ...) do {  \
+		if (!(cond)) {  \
+			printf("TestCase %s() line %d failed: " \
+				msg "\n", __func__, __LINE__, ##__VA_ARGS__); \
+			return TEST_FAILED;  \
+		} \
+} while (0)
+
+/* Compare two buffers (length in bytes) */
+#define TEST_ASSERT_BUFFERS_ARE_EQUAL(a, b, len, msg, ...) do { \
+	if (memcmp((a), (b), len)) { \
+		printf("TestCase %s() line %d failed: " \
+			msg "\n", __func__, __LINE__, ##__VA_ARGS__); \
+		rte_memdump(stdout, "Buffer A", (a), len); \
+		rte_memdump(stdout, "Buffer B", (b), len); \
+		return TEST_FAILED; \
+	} \
+} while (0)
+
+#define TEST_ASSERT_SUCCESS(val, msg, ...) do { \
+		typeof(val) _val = (val); \
+		if (!(_val == 0)) { \
+			printf("TestCase %s() line %d failed (err %d): " \
+				msg "\n", __func__, __LINE__, _val, \
+				##__VA_ARGS__); \
+			return TEST_FAILED; \
+		} \
+} while (0)
+
+#define TEST_ASSERT_FAIL(val, msg, ...) \
+	TEST_ASSERT_SUCCESS(!(val), msg, ##__VA_ARGS__)
+
+#define TEST_ASSERT_NOT_NULL(val, msg, ...) do { \
+		if ((val) == NULL) { \
+			printf("TestCase %s() line %d failed (null): " \
+				msg "\n", __func__, __LINE__, ##__VA_ARGS__); \
+			return TEST_FAILED;  \
+		} \
+} while (0)
+
+struct unit_test_case {
+	int (*setup)(void);
+	void (*teardown)(void);
+	int (*testcase)(void);
+	const char *name;
+};
+
+#define TEST_CASE(testcase) {NULL, NULL, testcase, #testcase}
+
+#define TEST_CASE_ST(setup, teardown, testcase) \
+		{setup, teardown, testcase, #testcase}
+
+#define TEST_CASES_END() {NULL, NULL, NULL, NULL}
+
+struct unit_test_suite {
+	const char *suite_name;
+	int (*setup)(void);
+	void (*teardown)(void);
+	struct unit_test_case unit_test_cases[];
+};
+
+int unit_test_suite_runner(struct unit_test_suite *suite);
+
+typedef int (test_callback)(void);
+TAILQ_HEAD(test_commands_list, test_command);
+struct test_command {
+	TAILQ_ENTRY(test_command) next;
+	const char *command;
+	test_callback *callback;
+};
+
+void add_test_command(struct test_command *t);
+
+/* Register a test function */
+#define REGISTER_TEST_COMMAND(name, testsuite) \
+	static int test_func_##name(void) \
+	{ \
+		return unit_test_suite_runner(&testsuite); \
+	} \
+	static struct test_command test_struct_##name = { \
+		.command = RTE_STR(name), \
+		.callback = test_func_##name, \
+	}; \
+	RTE_INIT(test_register_##name) \
+	{ \
+		add_test_command(&test_struct_##name); \
+	}
+
+const char *get_vector_filename(void);
+
+unsigned int get_num_ops(void);
+
+unsigned int get_burst_sz(void);
+
+unsigned int get_num_lcores(void);
+
+double get_snr(void);
+
+unsigned int get_iter_max(void);
+
+bool get_init_device(void);
+
+#endif

openair1/PHY/CODING/nrLDPC_decoder/nrLDPC_types.h

@@ -96,6 +96,17 @@ typedef struct nrLDPC_dec_params {
     int (*check_crc)(uint8_t* decoded_bytes, uint32_t n, uint8_t crc_type);
 } t_nrLDPC_dec_params;
 
+typedef struct nrLDPCoffload_params {
+    uint8_t BG; /**< Base graph */
+    uint16_t Z;
+    uint16_t Kr;
+    uint8_t rv;
+    uint32_t E;
+    uint16_t n_cb;
+    uint16_t F; /**< Filler bits */
+    uint8_t Qm; /**< Modulation */
+} t_nrLDPCoffload_params;
+
 /**
    Structure containing LDPC decoder processing time statistics.
  */

openair1/PHY/CODING/nrLDPC_extern.h

@@ -31,7 +31,7 @@ typedef struct ldpc_interface_s {
 } ldpc_interface_t;
 
 // Global var to limit the rework of the dirty legacy code
-extern ldpc_interface_t ldpc_interface;
+extern ldpc_interface_t ldpc_interface, ldpc_interface_offload;
 
 /* functions to load the LDPC shared lib, implemented in openair1/PHY/CODING/nrLDPC_load.c */
 int load_LDPClib(char *version, ldpc_interface_t *);

openair1/PHY/INIT/nr_init.c

@@ -502,7 +502,7 @@ int init_codebook_gNB(PHY_VARS_gNB *gNB) {
 }
 
 // A global var to reduce the changes size
-ldpc_interface_t ldpc_interface = {0};
+ldpc_interface_t ldpc_interface = {0}, ldpc_interface_offload = {0};
 
 int phy_init_nr_gNB(PHY_VARS_gNB *gNB)
 {
@@ -533,6 +533,8 @@ int phy_init_nr_gNB(PHY_VARS_gNB *gNB)
 
   load_LDPClib(NULL, &ldpc_interface);
 
+  if (gNB->ldpc_offload_flag)
+    load_LDPClib("_t2", &ldpc_interface_offload);
   gNB->max_nb_pdsch = MAX_MOBILES_PER_GNB;
 
   init_codebook_gNB(gNB);

openair1/PHY/NR_TRANSPORT/nr_dlsch_coding.c

@@ -380,25 +380,60 @@ int nr_dlsch_encoding(PHY_VARS_gNB *gNB,
   impp.tparity = tparity;
   impp.toutput = toutput;
   impp.harq = harq;
-  notifiedFIFO_t nf;
-  initNotifiedFIFO(&nf);
-  int nbJobs = 0;
-  for (int j = 0; j < (impp.n_segments / 8 + ((impp.n_segments & 7) == 0 ? 0 : 1)); j++) {
-    notifiedFIFO_elt_t *req = newNotifiedFIFO_elt(sizeof(impp), j, &nf, ldpc8blocks);
-    encoder_implemparams_t *perJobImpp = (encoder_implemparams_t *)NotifiedFifoData(req);
-    *perJobImpp = impp;
-    perJobImpp->macro_num = j;
-    pushTpool(&gNB->threadPool, req);
-    nbJobs++;
-  }
-  while (nbJobs) {
-    notifiedFIFO_elt_t *req = pullTpool(&nf, &gNB->threadPool);
-    if (req == NULL)
-      break; // Tpool has been stopped
-    delNotifiedFIFO_elt(req);
-    nbJobs--;
+  if (gNB->ldpc_offload_flag && *rel15->mcsIndex > 2) {
+    impp.Qm = rel15->qamModOrder[0];
+    impp.rv = rel15->rvIndex[0];
+    int nb_re_dmrs =
+        (rel15->dmrsConfigType == NFAPI_NR_DMRS_TYPE1) ? (6 * rel15->numDmrsCdmGrpsNoData) : (4 * rel15->numDmrsCdmGrpsNoData);
+    impp.G = nr_get_G(rel15->rbSize,
+                      rel15->NrOfSymbols,
+                      nb_re_dmrs,
+                      get_num_dmrs(rel15->dlDmrsSymbPos),
+                      harq->unav_res,
+                      rel15->qamModOrder[0],
+                      rel15->nrOfLayers);
+    uint8_t tmp[68 * 384] __attribute__((aligned(32)));
+    uint8_t *d = tmp;
+    int r_offset = 0;
+    for (int r = 0; r < impp.n_segments; r++) {
+      impp.E = nr_get_E(impp.G, impp.n_segments, impp.Qm, rel15->nrOfLayers, r);
+      impp.Kr = impp.K;
+      ldpc_interface_offload.LDPCencoder(&harq->c[r], &d, &impp);
+      uint8_t e[impp.E];
+      bzero(e, impp.E);
+      nr_rate_matching_ldpc(rel15->maintenance_parms_v3.tbSizeLbrmBytes,
+                            impp.BG,
+                            impp.Zc,
+                            tmp,
+                            e,
+                            impp.n_segments,
+                            impp.F,
+                            impp.K - impp.F - 2 * impp.Zc,
+                            impp.rv,
+                            impp.E);
+      nr_interleaving_ldpc(impp.E, impp.Qm, e, impp.output + r_offset);
+      r_offset += impp.E;
+    }
+  } else {
+    notifiedFIFO_t nf;
+    initNotifiedFIFO(&nf);
+    int nbJobs = 0;
+    for (int j = 0; j < (impp.n_segments / 8 + ((impp.n_segments & 7) == 0 ? 0 : 1)); j++) {
+      notifiedFIFO_elt_t *req = newNotifiedFIFO_elt(sizeof(impp), j, &nf, ldpc8blocks);
+      encoder_implemparams_t *perJobImpp = (encoder_implemparams_t *)NotifiedFifoData(req);
+      *perJobImpp = impp;
+      perJobImpp->macro_num = j;
+      pushTpool(&gNB->threadPool, req);
+      nbJobs++;
+    }
+    while (nbJobs) {
+      notifiedFIFO_elt_t *req = pullTpool(&nf, &gNB->threadPool);
+      if (req == NULL)
+        break; // Tpool has been stopped
+      delNotifiedFIFO_elt(req);
+      nbJobs--;
+    }
   }
-
   VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_gNB_DLSCH_ENCODING, VCD_FUNCTION_OUT);
   return 0;
 }

openair1/PHY/NR_TRANSPORT/nr_ulsch_decoding.c

@@ -222,6 +222,101 @@ static void nr_processULSegment(void *arg)
     memcpy(ulsch_harq->c[r],llrProcBuf,  Kr>>3);
 }
 
+int decode_offload(PHY_VARS_gNB *phy_vars_gNB,
+                   uint8_t ULSCH_id,
+                   short *ulsch_llr,
+                   nfapi_nr_pusch_pdu_t *pusch_pdu,
+                   t_nrLDPC_dec_params *decParams,
+                   uint8_t harq_pid,
+                   uint32_t G)
+{
+  NR_gNB_ULSCH_t *ulsch = &phy_vars_gNB->ulsch[ULSCH_id];
+  NR_UL_gNB_HARQ_t *harq_process = ulsch->harq_process;
+  int16_t z_ol[68 * 384 + 16] __attribute__((aligned(16)));
+  int8_t l_ol[68 * 384 + 16] __attribute__((aligned(16)));
+  uint8_t Qm = pusch_pdu->qam_mod_order;
+  uint8_t n_layers = pusch_pdu->nrOfLayers;
+  const int Kr = harq_process->K;
+  const int Kr_bytes = Kr >> 3;
+  uint32_t A = (harq_process->TBS) << 3;
+  const int kc = decParams->BG == 2 ? 52 : 68;
+  ulsch->max_ldpc_iterations = 20;
+  int decodeIterations = 2;
+  int r_offset = 0, offset = 0;
+  for (int r = 0; r < harq_process->C; r++) {
+    int E = nr_get_E(G, harq_process->C, Qm, n_layers, r);
+    memset(harq_process->c[r], 0, Kr_bytes);
+    decParams->R = nr_get_R_ldpc_decoder(pusch_pdu->pusch_data.rv_index,
+                                         E,
+                                         decParams->BG,
+                                         decParams->Z,
+                                         &harq_process->llrLen,
+                                         harq_process->round);
+
+    memcpy(z_ol, ulsch_llr + r_offset, E * sizeof(short));
+    simde__m128i *pv_ol128 = (simde__m128i *)&z_ol;
+    simde__m128i *pl_ol128 = (simde__m128i *)&l_ol;
+    for (int i = 0, j = 0; j < ((kc * harq_process->Z) >> 4) + 1; i += 2, j++) {
+      pl_ol128[j] = simde_mm_packs_epi16(pv_ol128[i], pv_ol128[i + 1]);
+    }
+    decParams->E = E;
+    decParams->rv = pusch_pdu->pusch_data.rv_index;
+    decParams->F = harq_process->F;
+    decParams->Qm = Qm;
+    decodeIterations =
+        ldpc_interface_offload
+            .LDPCdecoder(decParams, harq_pid, ULSCH_id, r, (int8_t *)&pl_ol128[0], (int8_t *)harq_process->c[r], NULL, NULL);
+    if (decodeIterations < 0) {
+      LOG_E(PHY, "ulsch_decoding.c: Problem in LDPC decoder offload\n");
+      return -1;
+    }
+    bool decodeSuccess = check_crc((uint8_t *)harq_process->c[r], lenWithCrc(harq_process->C, A), crcType(harq_process->C, A));
+    if (decodeSuccess) {
+      memcpy(harq_process->b + offset, harq_process->c[r], Kr_bytes - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
+      offset += (Kr_bytes - (harq_process->F >> 3) - ((harq_process->C > 1) ? 3 : 0));
+      harq_process->processedSegments++;
+    } else {
+      LOG_D(PHY, "uplink segment error %d/%d\n", r, harq_process->C);
+      LOG_D(PHY, "ULSCH %d in error\n", ULSCH_id);
+    }
+    r_offset += E;
+  }
+  bool crc_valid = false;
+  if (harq_process->processedSegments == harq_process->C) {
+    // When the number of code blocks is 1 (C = 1) and ulsch_harq->processedSegments = 1, we can assume a good TB because of the
+    // CRC check made by the LDPC for early termination, so, no need to perform CRC check twice for a single code block
+    crc_valid = true;
+    if (harq_process->C > 1) {
+      crc_valid = check_crc(harq_process->b, lenWithCrc(1, A), crcType(1, A));
+    }
+  }
+  if (crc_valid) {
+    LOG_D(PHY, "ULSCH: Setting ACK for slot %d TBS %d\n", ulsch->slot, harq_process->TBS);
+    ulsch->active = false;
+    harq_process->round = 0;
+    LOG_D(PHY, "ULSCH received ok \n");
+    nr_fill_indication(phy_vars_gNB, ulsch->frame, ulsch->slot, ULSCH_id, harq_pid, 0, 0);
+  } else {
+    LOG_D(PHY,
+        "[gNB %d] ULSCH: Setting NAK for SFN/SF %d/%d (pid %d, status %d, round %d, TBS %d)\n",
+        phy_vars_gNB->Mod_id,
+        ulsch->frame,
+        ulsch->slot,
+        harq_pid,
+        ulsch->active,
+        harq_process->round,
+        harq_process->TBS);
+    ulsch->handled = 1;
+    decodeIterations = ulsch->max_ldpc_iterations + 1;
+    LOG_D(PHY, "ULSCH %d in error\n", ULSCH_id);
+    nr_fill_indication(phy_vars_gNB, ulsch->frame, ulsch->slot, ULSCH_id, harq_pid, 1, 0);
+  }
+
+  ulsch->last_iteration_cnt = decodeIterations;
+  VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_PHY_gNB_ULSCH_DECODING,0);
+  return 0;
+}
+
 int nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
                       uint8_t ULSCH_id,
                       short *ulsch_llr,
@@ -332,6 +427,9 @@ int nr_ulsch_decoding(PHY_VARS_gNB *phy_vars_gNB,
     harq_process->harq_to_be_cleared = false;
   }
 
+  if (phy_vars_gNB->ldpc_offload_flag)
+    return decode_offload(phy_vars_gNB, ULSCH_id, ulsch_llr, pusch_pdu, &decParams, harq_pid, G);
+
   uint32_t offset = 0, r_offset = 0;
   set_abort(&harq_process->abort_decode, false);
   for (int r = 0; r < harq_process->C; r++) {

openair1/PHY/NR_UE_TRANSPORT/nr_ulsch_coding.c

@@ -202,12 +202,20 @@ int nr_ulsch_encoding(PHY_VARS_NR_UE *ue,
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_LDPC_ENCODER_OPTIM, VCD_FUNCTION_IN);
 
     start_meas(&ue->ulsch_ldpc_encoding_stats);
-    for (int j = 0; j < (harq_process->C / 8 + 1); j++) {
-      impp.macro_num = j;
-      impp.E = nr_get_E(G, harq_process->C, mod_order, ulsch->pusch_pdu.nrOfLayers, j);
-      impp.Kr = Kr;
-      ldpc_interface.LDPCencoder(harq_process->c, harq_process->d, &impp);
-    }
+    if (ldpc_interface_offload.LDPCencoder)
+      for (int j = 0; j < harq_process->C; j++) {
+        impp.macro_num = j;
+        impp.E = nr_get_E(G, harq_process->C, mod_order, ulsch->pusch_pdu.nrOfLayers, j);
+        impp.Kr = Kr;
+        ldpc_interface_offload.LDPCencoder(&harq_process->c[j], &harq_process->d[j], &impp);
+      }
+    else
+      for (int j = 0; j < (harq_process->C / 8 + 1); j++) {
+        impp.macro_num = j;
+        impp.E = nr_get_E(G, harq_process->C, mod_order, ulsch->pusch_pdu.nrOfLayers, j);
+        impp.Kr = Kr;
+        ldpc_interface.LDPCencoder(harq_process->c, harq_process->d, &impp);
+      }
     VCD_SIGNAL_DUMPER_DUMP_FUNCTION_BY_NAME(VCD_SIGNAL_DUMPER_FUNCTIONS_LDPC_ENCODER_OPTIM, VCD_FUNCTION_OUT);
 
     //stop_meas(te_stats);

openair1/PHY/defs_gNB.h

@@ -642,6 +642,8 @@ typedef struct PHY_VARS_gNB_s {
   /// OFDM symbol offset divisor for UL
   uint32_t ofdm_offset_divisor;
 
+  int ldpc_offload_flag;
+
   int reorder_thread_disable;
 
   int max_ldpc_iterations;

openair1/SIMULATION/NR_PHY/dlsim.c

@@ -291,6 +291,7 @@ int main(int argc, char **argv)
   uint8_t n_tx=1,n_rx=1;
   uint8_t round;
   uint8_t num_rounds = 4;
+  int ldpc_offload_flag = 0;
   char gNBthreads[128]="n";
 
   channel_desc_t *gNB2UE;
@@ -398,6 +399,10 @@ int main(int argc, char **argv)
       n_trials = atoi(optarg);
       break;
 
+    case 'c':
+      ldpc_offload_flag = 1;
+      break;
+
     case 's':
       snr0 = atof(optarg);
       printf("Setting SNR0 to %f\n",snr0);
@@ -562,6 +567,7 @@ int main(int argc, char **argv)
       //printf("-j Relative strength of second intefering gNB (in dB) - cell_id mod 3 = 2\n");
       printf("-R N_RB_DL\n");
       printf("-O oversampling factor (1,2,4,8,16)\n");
+      printf("-c ldpc offload flag\n");
       printf("-A Interpolation_filname Run with Abstraction to generate Scatter plot using interpolation polynomial in file\n");
       //printf("-C Generate Calibration information for Abstraction (effective SNR adjustment to remove Pe bias w.r.t. AWGN)\n");
       printf("-f raw file containing RRC configuration (generated by gNB)\n");
@@ -620,6 +626,7 @@ int main(int argc, char **argv)
 
   gNB = RC.gNB[0];
   gNB->ofdm_offset_divisor = UINT_MAX;
+  gNB->ldpc_offload_flag = ldpc_offload_flag;
   frame_parms = &gNB->frame_parms; //to be initialized I suppose (maybe not necessary for PBCH)
   frame_parms->nb_antennas_tx = n_tx;
   frame_parms->nb_antennas_rx = n_rx;
@@ -1325,6 +1332,9 @@ int main(int argc, char **argv)
   free(UE->phy_sim_pdsch_dl_ch_estimates_ext);
   free(UE->phy_sim_dlsch_b);
 
+  if (gNB->ldpc_offload_flag)
+    free_LDPClib(&ldpc_interface_offload);
+
   if (output_fd)
     fclose(output_fd);
 

openair1/SIMULATION/NR_PHY/ulsim.c

@@ -186,6 +186,7 @@ int main(int argc, char *argv[])
   double effRate;
   double effTP;
   float eff_tp_check = 100;
+  int ldpc_offload_flag = 0;
   uint8_t max_rounds = 4;
   int chest_type[2] = {0};
   int enable_ptrs = 0;
@@ -329,6 +330,10 @@ int main(int argc, char *argv[])
       n_trials = atoi(optarg);
       break;
 
+    case 'o':
+      ldpc_offload_flag = 1;
+      break;
+
     case 'p':
       extended_prefix_flag = 1;
       break;
@@ -488,6 +493,7 @@ int main(int argc, char *argv[])
       printf("-k 3/4 sampling\n");
       printf("-m MCS value\n");
       printf("-n Number of trials to simulate\n");
+      printf("-o ldpc offload flag\n");
       printf("-p Use extended prefix mode\n");
       printf("-q MCS table\n");
       printf("-r Number of allocated resource blocks for PUSCH\n");
@@ -623,6 +629,7 @@ int main(int argc, char *argv[])
   cfg->carrier_config.num_rx_ant.value = n_rx;
 
 //  nr_phy_config_request_sim(gNB,N_RB_DL,N_RB_DL,mu,0,0x01);
+  gNB->ldpc_offload_flag = ldpc_offload_flag;
   gNB->chest_freq = chest_type[0];
   gNB->chest_time = chest_type[1];
 
@@ -1604,6 +1611,8 @@ int main(int argc, char *argv[])
           num_dmrs_cdm_grps_no_data);
 
   free_MIB_NR(mib);
+  if (gNB->ldpc_offload_flag)
+    free_LDPClib(&ldpc_interface_offload);
 
   if (output_fd)
     fclose(output_fd);