From 85e478d8ad5060f3e0a947e3a698c713d2609994 Mon Sep 17 00:00:00 2001 From: Andre Puschmann Date: Wed, 27 Oct 2021 15:49:29 +0200 Subject: [PATCH] rlc_um_nr_test: add TC to reproduce reassembly issue * add TC to reproduce reassembly issue that causes low TCP throughput * fix PCAP writing * fix other testcase to wait for t_reassembly to expire --- lib/test/rlc/CMakeLists.txt | 2 +- lib/test/rlc/rlc_um_nr_test.cc | 100 ++++++++++++++++++++++++++++----- 2 files changed, 86 insertions(+), 16 deletions(-) diff --git a/lib/test/rlc/CMakeLists.txt b/lib/test/rlc/CMakeLists.txt index 50cfab6c3..6b0f6bf45 100644 --- a/lib/test/rlc/CMakeLists.txt +++ b/lib/test/rlc/CMakeLists.txt @@ -50,7 +50,7 @@ target_link_libraries(rlc_um_nr_pdu_test srsran_rlc srsran_mac srsran_phy) add_nr_test(rlc_um_nr_pdu_test rlc_um_nr_pdu_test) add_executable(rlc_um_nr_test rlc_um_nr_test.cc) -target_link_libraries(rlc_um_nr_test srsran_rlc srsran_phy) +target_link_libraries(rlc_um_nr_test srsran_rlc srsran_phy srsran_mac srsran_common) add_nr_test(rlc_um_nr_test rlc_um_nr_test) ######################################################################## diff --git a/lib/test/rlc/rlc_um_nr_test.cc b/lib/test/rlc/rlc_um_nr_test.cc index 82a58f341..9f1052a1a 100644 --- a/lib/test/rlc/rlc_um_nr_test.cc +++ b/lib/test/rlc/rlc_um_nr_test.cc @@ -11,6 +11,7 @@ */ #include "rlc_test_common.h" +#include "srsran/common/test_common.h" #include "srsran/config.h" #include "srsran/interfaces/ue_pdcp_interfaces.h" #include "srsran/rlc/rlc.h" @@ -20,14 +21,6 @@ #include #include -#define TESTASSERT(cond) \ - { \ - if (!(cond)) { \ - std::cout << "[" << __FUNCTION__ << "][Line " << __LINE__ << "]: FAIL at " << (#cond) << std::endl; \ - return -1; \ - } \ - } - #define PCAP 0 #define PCAP_CRNTI (0x1001) #define PCAP_TTI (666) @@ -35,9 +28,9 @@ using namespace srsran; #if PCAP -#include "srsran/common/mac_nr_pcap.h" -#include "srsran/mac/mac_nr_pdu.h" -static std::unique_ptr pcap_handle = nullptr; +#include "srsran/common/mac_pcap.h" +#include "srsran/mac/mac_sch_pdu_nr.h" +static std::unique_ptr pcap_handle = nullptr; #endif int write_pdu_to_pcap(const uint32_t lcid, const uint8_t* payload, const uint32_t len) @@ -45,11 +38,11 @@ int write_pdu_to_pcap(const uint32_t lcid, const uint8_t* payload, const uint32_ #if PCAP if (pcap_handle) { byte_buffer_t tx_buffer; - srsran::mac_nr_sch_pdu tx_pdu; + srsran::mac_sch_pdu_nr tx_pdu; tx_pdu.init_tx(&tx_buffer, len + 10); tx_pdu.add_sdu(lcid, payload, len); tx_pdu.pack(); - pcap_handle->write_dl_crnti(tx_buffer.msg, tx_buffer.N_bytes, PCAP_CRNTI, true, PCAP_TTI); + pcap_handle->write_dl_crnti_nr(tx_buffer.msg, tx_buffer.N_bytes, PCAP_CRNTI, true, PCAP_TTI); return SRSRAN_SUCCESS; } #endif @@ -84,7 +77,7 @@ public: logger2.set_hex_dump_max_size(-1); // configure RLC entities - rlc_config_t cnfg = rlc_config_t::default_rlc_um_nr_config(6); + rlc_config_t cnfg = rlc_config_t::default_rlc_um_nr_config(12); if (rlc1.configure(cnfg) != true) { fprintf(stderr, "Couldn't configure RLC1 object\n"); } @@ -479,6 +472,11 @@ int rlc_um_nr_test7() TESTASSERT(ctxt.tester.sdus.at(i)->N_bytes == sdu_size); } + // let t-reassembly expire + while (ctxt.timers.nof_running_timers() != 0) { + ctxt.timers.step_all(); + } + rlc_bearer_metrics_t rlc2_metrics = ctxt.rlc2.get_metrics(); TESTASSERT(rlc2_metrics.num_lost_pdus == 1); @@ -554,10 +552,73 @@ int rlc_um_nr_test8() return SRSRAN_SUCCESS; } +// Similar to rlc_um_nr_test9() but out-of-order PDUs have SNs (from multiple SDUs) +int rlc_um_nr_test9() +{ + rlc_um_nr_test_context1 ctxt; + + const uint32_t num_sdus = 2; + const uint32_t sdu_size = 20; + + ctxt.tester.set_expected_sdu_len(sdu_size); + + // Push SDUs into RLC1 + byte_buffer_pool* pool = byte_buffer_pool::get_instance(); + unique_byte_buffer_t sdu_bufs[num_sdus]; + for (uint32_t i = 0; i < num_sdus; i++) { + sdu_bufs[i] = srsran::make_byte_buffer(); + // Write the index into the buffer + for (uint32_t k = 0; k < sdu_size; ++k) { + sdu_bufs[i]->msg[k] = i; + } + sdu_bufs[i]->N_bytes = sdu_size; + ctxt.rlc1.write_sdu(std::move(sdu_bufs[i])); + } + + // Read PDUs from RLC1 with grant smaller than SDU size + const uint32_t max_num_pdus = 10; + uint32_t num_pdus = 0; + unique_byte_buffer_t pdu_bufs[max_num_pdus]; + + while (ctxt.rlc1.get_buffer_state() != 0 && num_pdus < max_num_pdus) { + pdu_bufs[num_pdus] = srsran::make_byte_buffer(); + int len = ctxt.rlc1.read_pdu(pdu_bufs[num_pdus]->msg, 10); // 3 bytes for header + payload + pdu_bufs[num_pdus]->N_bytes = len; + + // write PCAP + write_pdu_to_pcap(4, pdu_bufs[num_pdus]->msg, pdu_bufs[num_pdus]->N_bytes); + + num_pdus++; + } + + TESTASSERT(num_pdus == 6); + + // Write all PDUs such that the middle section of SN=0 is received after the start section of SN=1 + ctxt.rlc2.write_pdu(pdu_bufs[0]->msg, pdu_bufs[0]->N_bytes); + // skip 2nd PDU which is the middle section of SN=0 + ctxt.rlc2.write_pdu(pdu_bufs[2]->msg, pdu_bufs[2]->N_bytes); + ctxt.rlc2.write_pdu(pdu_bufs[3]->msg, pdu_bufs[3]->N_bytes); + + // now feed the middle part of SN=0 + ctxt.rlc2.write_pdu(pdu_bufs[1]->msg, pdu_bufs[1]->N_bytes); + + // and the rest of SN=1 + ctxt.rlc2.write_pdu(pdu_bufs[4]->msg, pdu_bufs[4]->N_bytes); + ctxt.rlc2.write_pdu(pdu_bufs[5]->msg, pdu_bufs[5]->N_bytes); + + TESTASSERT(num_sdus == ctxt.tester.get_num_sdus()); + for (uint32_t i = 0; i < ctxt.tester.sdus.size(); i++) { + TESTASSERT(ctxt.tester.sdus.at(i)->N_bytes == sdu_size); + TESTASSERT(*(ctxt.tester.sdus[i]->msg) == i); + } + + return SRSRAN_SUCCESS; +} + int main(int argc, char** argv) { #if PCAP - pcap_handle = std::unique_ptr(new srsran::mac_nr_pcap()); + pcap_handle = std::unique_ptr(new srsran::mac_pcap()); pcap_handle->open("rlc_um_nr_test.pcap"); #endif @@ -606,5 +667,14 @@ int main(int argc, char** argv) return SRSRAN_ERROR; } + if (rlc_um_nr_test9()) { + fprintf(stderr, "rlc_um_nr_test9() failed.\n"); + return SRSRAN_ERROR; + } + +#if PCAP + pcap_handle->close(); +#endif + return SRSRAN_SUCCESS; }