feat(nrLDPC_coding): Transform segment coding libraries into slot coding...

feat(nrLDPC_coding): Transform segment coding libraries into slot coding libraries by statically linking the adaptation layer and the segment coding libraries

CMakeLists.txt

@@ -777,6 +777,8 @@ set(PHY_NRLDPC_CODINGIF
 
 add_library(dfts MODULE ${OPENAIR1_DIR}/PHY/TOOLS/oai_dfts.c ${OPENAIR1_DIR}/PHY/TOOLS/oai_dfts_neon.c)
 
+add_library(crc_byte OBJECT ${OPENAIR1_DIR}/PHY/CODING/crc_byte.c)
+
 set(PHY_SRC_COMMON
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/dci_tools_common.c
   ${OPENAIR1_DIR}/PHY/LTE_TRANSPORT/lte_mcs.c
@@ -802,7 +804,6 @@ set(PHY_SRC_COMMON
   ${OPENAIR1_DIR}/PHY/CODING/ccoding_byte.c
   ${OPENAIR1_DIR}/PHY/CODING/ccoding_byte_lte.c
   ${OPENAIR1_DIR}/PHY/CODING/3gpplte_sse.c
-  ${OPENAIR1_DIR}/PHY/CODING/crc_byte.c
   ${PHY_TURBOIF}
   ${OPENAIR1_DIR}/PHY/CODING/lte_rate_matching.c
   ${OPENAIR1_DIR}/PHY/CODING/viterbi.c
@@ -1019,9 +1020,11 @@ if (${SMBV})
 endif  (${SMBV})
 
 add_library(PHY_COMMON ${PHY_SRC_COMMON})
-target_link_libraries(PHY_COMMON PRIVATE shlib_loader)
+target_link_libraries(PHY_COMMON
+  PRIVATE shlib_loader asn1_lte_rrc_hdrs crc_byte
+  PUBLIC UTIL
+)
 add_dependencies(PHY_COMMON dfts)
-target_link_libraries(PHY_COMMON PRIVATE asn1_lte_rrc_hdrs PUBLIC UTIL)
 
 add_library(PHY ${PHY_SRC})
 target_link_libraries(PHY PRIVATE asn1_lte_rrc_hdrs asn1_nr_rrc_hdrs)
@@ -1954,12 +1957,17 @@ target_link_libraries(smallblocktest PRIVATE
 
 
 add_executable(ldpctest
-   ${OPENAIR1_DIR}/PHY/CODING/TESTBENCH/ldpctest.c
-   )
+  ${OPENAIR1_DIR}/PHY/CODING/TESTBENCH/ldpctest.c
+  ${OPENAIR1_DIR}/PHY/CODING/nrLDPC_load.c
+)
 target_link_libraries(ldpctest PRIVATE
   -Wl,--start-group UTIL SIMU PHY_COMMON PHY_NR_COMMON -Wl,--end-group
-  m pthread dl shlib_loader ${T_LIB} nr_coding_segment_utils
-  )
+  m pthread dl shlib_loader ${T_LIB}
+  # link 'check_crc' to make it resolved in the LDPC coding libraries
+  # 'check_crc' is not used in ldpctest so it is not linked in the executable by default
+  # --whole-archive links 'check_crc' in the executable even though it is note used, see 'man ld'
+  -Wl,--whole-archive crc_byte -Wl,--no-whole-archive
+)
 
 add_executable(nr_dlschsim
   ${OPENAIR1_DIR}/SIMULATION/NR_PHY/dlschsim.c
@@ -2113,7 +2121,7 @@ if (${T_TRACER})
         PHY_COMMON PHY PHY_UE PHY_NR PHY_NR_COMMON PHY_NR_UE PHY_RU
         L2 L2_LTE L2_NR L2_LTE_NR L2_UE NR_L2_UE L2_UE_LTE_NR MAC_NR_COMMON MAC_UE_NR ngap
         CN_UTILS GTPV1U SCTP_CLIENT MME_APP LIB_NAS_UE NB_IoT SIMU OPENAIR0_LIB
-        dfts config_internals nr_common)
+        dfts config_internals nr_common crc_byte)
     if (TARGET ${i})
       add_dependencies(${i} generate_T)
     endif()

openair1/PHY/CODING/CMakeLists.txt

@@ -13,28 +13,36 @@ add_library(ldpc_orig MODULE
             nrLDPC_encoder/ldpc_encoder.c
 )
 set_target_properties(ldpc_orig PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-target_link_libraries(ldpc_orig PRIVATE ldpc_gen_HEADERS)
+target_link_libraries(ldpc_orig PRIVATE ldpc_segment ldpc_gen_HEADERS)
 
 add_library(ldpc_optim MODULE
             nrLDPC_decoder/nrLDPC_decoder.c
             nrLDPC_encoder/ldpc_encoder_optim.c
 )
 set_target_properties(ldpc_optim PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-target_link_libraries(ldpc_optim PRIVATE ldpc_gen_HEADERS)
+target_link_libraries(ldpc_optim PRIVATE ldpc_segment ldpc_gen_HEADERS)
 
 add_library(ldpc_optim8seg MODULE
             nrLDPC_decoder/nrLDPC_decoder.c
             nrLDPC_encoder/ldpc_encoder_optim8seg.c
 )
 set_target_properties(ldpc_optim8seg PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-target_link_libraries(ldpc_optim8seg PRIVATE ldpc_gen_HEADERS)
+target_link_libraries(ldpc_optim8seg PRIVATE ldpc_segment ldpc_gen_HEADERS)
 
-add_library(ldpc_optim8segmulti MODULE
+add_library(ldpc MODULE
             nrLDPC_decoder/nrLDPC_decoder.c
             nrLDPC_encoder/ldpc_encoder_optim8segmulti.c
 )
-set_target_properties(ldpc_optim8segmulti PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-target_link_libraries(ldpc_optim8segmulti PRIVATE ldpc_gen_HEADERS)
+set_target_properties(ldpc PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+target_link_libraries(ldpc PRIVATE ldpc_segment ldpc_gen_HEADERS)
+
+add_dependencies(ldpctest ldpc ldpc_orig ldpc_optim ldpc_optim8seg)
+add_dependencies(nr-softmodem ldpc ldpc_orig ldpc_optim ldpc_optim8seg)
+add_dependencies(nr-uesoftmodem ldpc ldpc_orig ldpc_optim ldpc_optim8seg)
+add_dependencies(nr_ulsim ldpc ldpc_orig ldpc_optim ldpc_optim8seg)
+add_dependencies(nr_ulschsim ldpc ldpc_orig ldpc_optim ldpc_optim8seg)
+add_dependencies(nr_dlsim ldpc ldpc_orig ldpc_optim ldpc_optim8seg)
+add_dependencies(nr_dlschsim ldpc ldpc_orig ldpc_optim ldpc_optim8seg)
 
 add_custom_target(nrLDPC_decoder_kernels_CL
                   COMMAND gcc nrLDPC_decoder/nrLDPC_decoder_CL.c -dD -DNRLDPC_KERNEL_SOURCE -E -o ${CMAKE_CURRENT_BINARY_DIR}/nrLDPC_decoder_kernels_CL.clc
@@ -46,7 +54,7 @@ add_library(ldpc_cl MODULE
             nrLDPC_encoder/ldpc_encoder_optim8segmulti.c
 )
 set_target_properties(ldpc_cl PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-target_link_libraries(ldpc_cl PRIVATE OpenCL)
+target_link_libraries(ldpc_cl PRIVATE ldpc_segment OpenCL)
 add_dependencies(ldpc_cl nrLDPC_decoder_kernels_CL)
 
 ##############################################
@@ -64,14 +72,24 @@ if (ENABLE_LDPC_CUDA)
   cuda_add_library(ldpc_cuda MODULE
                    nrLDPC_decoder_LYC/nrLDPC_decoder_LYC.cu
                    nrLDPC_encoder/ldpc_encoder_optim8segmulti.c
+                   # The slot coding layer cannot be linked with
+                   # target_link_libraries like above
+                   # because of cuda_add_library
+                   # which already uses target_link_libraries
+                   nrLDPC_coding/nrLDPC_coding_segment/nrLDPC_coding_segment_decoder.c
+                   nrLDPC_coding/nrLDPC_coding_segment/nrLDPC_coding_segment_encoder.c
+                   nrLDPC_coding/nrLDPC_coding_segment/nr_rate_matching.c
   )
   set_target_properties(ldpc_cuda PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
   set_target_properties(ldpc_cuda PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-endif()
 
-add_dependencies(ldpctest ldpc_orig ldpc_optim ldpc_optim8seg ldpc_optim8segmulti)
-if (ENABLE_LDPC_CUDA)
   add_dependencies(ldpctest ldpc_cuda)
+  add_dependencies(nr-softmodem ldpc_cuda)
+  add_dependencies(nr-uesoftmodem ldpc_cuda)
+  add_dependencies(nr_ulsim ldpc_cuda)
+  add_dependencies(nr_ulschsim ldpc_cuda)
+  add_dependencies(nr_dlsim ldpc_cuda)
+  add_dependencies(nr_dlschsim ldpc_cuda)
 endif()
 
 add_subdirectory(nrLDPC_coding)

openair1/PHY/CODING/TESTBENCH/ldpctest.c

@@ -403,7 +403,7 @@ int main(int argc, char *argv[])
 {
   short block_length=8448; // decoder supports length: 1201 -> 1280, 2401 -> 2560
   // default to check output inside ldpc, the NR version checks the outer CRC defined by 3GPP
-  char *ldpc_version = "_optim8segmulti";
+  char *ldpc_version = "";
   /* version of the ldpc decoder library to use (XXX suffix to use when loading libldpc_XXX.so */
   short max_iterations=5;
   int n_segments=1;

openair1/PHY/CODING/nrLDPC_coding/nrLDPC_coding_segment/CMakeLists.txt

-add_library(nr_coding_segment_utils OBJECT
-  nrLDPC_load.c
+add_library(ldpc_segment OBJECT
   nr_rate_matching.c
-)
-
-add_library(nr_coding_segment_decoder OBJECT
   nrLDPC_coding_segment_decoder.c
-)
-
-add_library(nr_coding_segment_encoder OBJECT
   nrLDPC_coding_segment_encoder.c
 )
 
 #ensure that the T header files are generated before targets depending on them
 if (${T_TRACER})
-  add_dependencies(nr_coding_segment_utils generate_T)
-  add_dependencies(nr_coding_segment_decoder generate_T)
-  add_dependencies(nr_coding_segment_encoder generate_T)
+  add_dependencies(ldpc_segment generate_T)
 endif (${T_TRACER})
-
-add_library(ldpc MODULE)
-target_link_libraries(ldpc PRIVATE
-  nr_coding_segment_decoder
-  nr_coding_segment_encoder
-  nr_coding_segment_utils
-)
-set_target_properties(ldpc PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-
-add_dependencies(nr-softmodem ldpc)
-add_dependencies(nr-uesoftmodem ldpc)
-add_dependencies(nr_ulsim ldpc)
-add_dependencies(nr_ulschsim ldpc)
-add_dependencies(nr_dlsim ldpc)
-add_dependencies(nr_dlschsim ldpc)
-
-add_dependencies(ldpc ldpc_orig ldpc_optim ldpc_optim8seg ldpc_optim8segmulti)
-if (ENABLE_LDPC_CUDA)
-  add_dependencies(ldpc ldpc_cuda)
-endif()

openair1/PHY/CODING/nrLDPC_coding/nrLDPC_coding_segment/nrLDPC_coding_segment_decoder.c

@@ -120,9 +120,6 @@ typedef struct nrLDPC_decoding_parameters_s {
   time_stats_t *p_ts_ldpc_decode;
 } nrLDPC_decoding_parameters_t;
 
-// Global var to limit the rework of the dirty legacy code
-ldpc_interface_t ldpc_interface_segment;
-
 static void nr_process_decode_segment(void *arg)
 {
   nrLDPC_decoding_parameters_t *rdata = (nrLDPC_decoding_parameters_t *)arg;
@@ -219,7 +216,7 @@ static void nr_process_decode_segment(void *arg)
 
   ////////////////////////////////// pl =====> llrProcBuf //////////////////////////////////
   int decodeIterations =
-      ldpc_interface_segment.LDPCdecoder(p_decoderParms, 0, 0, 0, l, llrProcBuf, p_procTime, rdata->abort_decode);
+      LDPCdecoder(p_decoderParms, 0, 0, 0, l, llrProcBuf, p_procTime, rdata->abort_decode);
 
   if (decodeIterations <= p_decoderParms->numMaxIter) {
     memcpy(rdata->c, llrProcBuf, K >> 3);
@@ -285,19 +282,11 @@ int nrLDPC_prepare_TB_decoding(nrLDPC_slot_decoding_parameters_t *nrLDPC_slot_de
 
 int32_t nrLDPC_coding_init(void)
 {
-  char *segment_shlibversion = NULL;
-  paramdef_t LoaderParams[] = {
-      {"segment_shlibversion", NULL, 0, .strptr = &segment_shlibversion, .defstrval = "_optim8segmulti", TYPE_STRING, 0, NULL}};
-  config_get(config_get_if(), LoaderParams, sizeofArray(LoaderParams), "nrLDPC_coding_segment");
-  load_LDPClib(segment_shlibversion, &ldpc_interface_segment);
-
   return 0;
 }
 
 int32_t nrLDPC_coding_shutdown(void)
 {
-  free_LDPClib(&ldpc_interface_segment);
-
   return 0;
 }
 

openair1/PHY/CODING/nrLDPC_coding/nrLDPC_coding_segment/nrLDPC_coding_segment_encoder.c

@@ -73,7 +73,7 @@ static void ldpc8blocks_coding_segment(void *p)
   for (int r = 0; r < nrLDPC_TB_encoding_parameters->C; r++)
     c[r] = nrLDPC_TB_encoding_parameters->segments[r].c;
   start_meas(&nrLDPC_TB_encoding_parameters->segments[impp->macro_num * 8].ts_ldpc_encode);
-  ldpc_interface_segment.LDPCencoder(c, d, impp);
+  LDPCencoder(c, d, impp);
   stop_meas(&nrLDPC_TB_encoding_parameters->segments[impp->macro_num * 8].ts_ldpc_encode);
   // Compute where to place in output buffer that is concatenation of all segments
 

openair1/PHY/CODING/nrLDPC_coding/nrLDPC_coding_xdma/CMakeLists.txt

@@ -10,6 +10,9 @@ if (ENABLE_LDPC_XDMA)
   add_library(ldpc_xdma MODULE
               nrLDPC_coding_xdma_offload.c
               nrLDPC_coding_xdma.c
+              ../nrLDPC_coding_segment/nr_rate_matching.c
+              ../nrLDPC_coding_segment/nrLDPC_coding_segment_encoder.c
+              ../../nrLDPC_encoder/ldpc_encoder_optim8segmulti.c
   )
   target_include_directories(ldpc_xdma PRIVATE ../nrLDPC_coding_segment)
 
@@ -18,10 +21,7 @@ if (ENABLE_LDPC_XDMA)
     add_dependencies(ldpc_xdma generate_T)
   endif (${T_TRACER})
 
-  target_link_libraries(ldpc_xdma PRIVATE
-    nr_coding_segment_encoder
-    nr_coding_segment_utils
-  )
+  target_link_libraries(ldpc_xdma PRIVATE ldpc_gen_HEADERS)
   set_target_properties(ldpc_xdma PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 
   add_dependencies(nr-softmodem ldpc_xdma)
@@ -31,9 +31,4 @@ if (ENABLE_LDPC_XDMA)
   add_dependencies(nr_dlsim ldpc_xdma)
   add_dependencies(nr_dlschsim ldpc_xdma)
 
-  add_dependencies(ldpc_xdma ldpc_orig ldpc_optim ldpc_optim8seg ldpc_optim8segmulti)
-  if (ENABLE_LDPC_CUDA)
-    add_dependencies(ldpc_xdma ldpc_cuda)
-  endif()
-
 endif()

openair1/PHY/CODING/nrLDPC_coding/nrLDPC_coding_xdma/nrLDPC_coding_xdma.c

@@ -62,7 +62,6 @@
 #include "PHY/CODING/nrLDPC_coding/nrLDPC_coding_interface.h"
 
 // Global var to limit the rework of the dirty legacy code
-ldpc_interface_t ldpc_interface_segment;
 int num_threads_prepare_max = 0;
 char *user_device = NULL;
 char *enc_read_device = NULL;
@@ -98,10 +97,8 @@ void nr_ulsch_FPGA_decoding_prepare_blocks(void *args);
 
 int32_t nrLDPC_coding_init(void)
 {
-  char *encoder_shlibversion = NULL;
   paramdef_t LoaderParams[] = {
       {"num_threads_prepare", NULL, 0, .iptr = &num_threads_prepare_max, .defintval = 0, TYPE_INT, 0, NULL},
-      {"encoder_shlibversion", NULL, 0, .strptr = &encoder_shlibversion, .defstrval = "_optim8segmulti", TYPE_STRING, 0, NULL},
       {"user_device", NULL, 0, .strptr = &user_device, .defstrval = DEVICE_NAME_DEFAULT_USER, TYPE_STRING, 0, NULL},
       {"enc_read_device", NULL, 0, .strptr = &enc_read_device, .defstrval = DEVICE_NAME_DEFAULT_ENC_READ, TYPE_STRING, 0, NULL},
       {"enc_write_device", NULL, 0, .strptr = &enc_write_device, .defstrval = DEVICE_NAME_DEFAULT_ENC_WRITE, TYPE_STRING, 0, NULL},
@@ -110,13 +107,11 @@ int32_t nrLDPC_coding_init(void)
   config_get(config_get_if(), LoaderParams, sizeofArray(LoaderParams), "nrLDPC_coding_xdma");
   AssertFatal(num_threads_prepare_max != 0, "nrLDPC_coding_xdma.num_threads_prepare was not provided");
 
-  load_LDPClib(encoder_shlibversion, &ldpc_interface_segment);
   return 0;
 }
 
 int32_t nrLDPC_coding_shutdown(void)
 {
-  free_LDPClib(&ldpc_interface_segment);
   return 0;
 }