5g-team
/
srsRAN_4G
mirror of https://github.com/pvnis/srsRAN_4G.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

lib,rlc_am_nr_test: add retx test with trimmed status PDU

Browse Source
master
Robert Falkenberg 3 years ago
parent a2332d10f2
commit 85c95d94b2
1 changed files with 214 additions and 0 deletions
Show Stats Download Patch File Download Diff File

214
lib/test/rlc/rlc_am_nr_test.cc
Unescape Escape View File

@ -652,6 +652,219 @@ int lost_pdu_duplicated_nack_test(rlc_am_nr_sn_size_t sn_size)
return SRSRAN_SUCCESS; return SRSRAN_SUCCESS;
} }
/*
* Test the loss of multiple PDUs.
* NACKs for all missing PDUs should be visible in buffer state -- but we enforce
* a trimmed status PDU by providing little space for the whole status PDU.
* Retx after NACK should be present too.
* Further status report shall contain the trimmed NACK.
* Another Retx after NACK should be present.
* No further status reports shall be issued.
*/
int lost_pdus_trimmed_nack_test(rlc_am_nr_sn_size_t sn_size)
{
rlc_am_tester tester;
timer_handler timers(8);
byte_buffer_t pdu_bufs[NBUFS];
auto& test_logger = srslog::fetch_basic_logger("TESTER ");
rlc_am rlc1(srsran_rat_t::nr, srslog::fetch_basic_logger("RLC_AM_1"), 1, &tester, &tester, &timers);
rlc_am rlc2(srsran_rat_t::nr, srslog::fetch_basic_logger("RLC_AM_2"), 1, &tester, &tester, &timers);
test_delimit_logger delimiter("lost PDUs and trimmed NACKs ({} bit SN)", to_number(sn_size));
constexpr uint32_t payload_size = 1;
uint32_t header_size = sn_size == rlc_am_nr_sn_size_t::size12bits ? 2 : 3;
uint32_t data_pdu_size = header_size + payload_size;
uint32_t expect_buffer_state = NBUFS * data_pdu_size;
if (not rlc1.configure(rlc_config_t::default_rlc_am_nr_config(to_number(sn_size)))) {
return -1;
}
rlc_config_t rlc2_config = rlc_config_t::default_rlc_am_nr_config(to_number(sn_size));
if (not rlc2.configure(rlc2_config)) {
return -1;
}
// after configuring entity
TESTASSERT(0 == rlc1.get_buffer_state());
basic_test_tx(&rlc1, pdu_bufs, sn_size);
// Write 5 PDUs into RLC2
for (int i = 0; i < NBUFS; i++) {
if (i != 1 && i != 3) {
rlc2.write_pdu(pdu_bufs[i].msg, pdu_bufs[i].N_bytes); // Don't write RLC_SN=1 and 3.
}
}
// Only after t-reassembly has expired, will the status report include NACKs.
TESTASSERT_EQ(3, rlc2.get_buffer_state());
{
// Read status PDU from RLC2
byte_buffer_t status_buf;
int len = rlc2.read_pdu(status_buf.msg, 5);
status_buf.N_bytes = len;
TESTASSERT(0 == rlc2.get_buffer_state());
// Assert status is correct
rlc_am_nr_status_pdu_t status_check(sn_size);
rlc_am_nr_read_status_pdu(&status_buf, sn_size, &status_check);
TESTASSERT_EQ(1, status_check.ack_sn); // 1 is the next expected SN (i.e. the first lost packet.)
// Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
}
// Step timers until reassambly timeout expires
for (int cnt = 0; cnt < 35; cnt++) {
timers.step_all();
}
// Step timers until reassambly timeout expires
for (int cnt = 0; cnt < 35; cnt++) {
timers.step_all();
}
// t-reassembly has expired. There should be two NACKs in the status report.
constexpr uint32_t status_pdu_ack_size = 3;
uint32_t status_pdu_nack_size = sn_size == rlc_am_nr_sn_size_t::size12bits ? 2 : 3;
uint32_t expected_size = status_pdu_ack_size + 2 * status_pdu_nack_size;
TESTASSERT_EQ(expected_size, rlc2.get_buffer_state());
{
// Read status PDU from RLC2, enforce to trimming by providing little space (expected_size - 1)
// to drop the second NACK.
byte_buffer_t status_buf;
uint32_t len = rlc2.read_pdu(status_buf.msg, expected_size - 1);
status_buf.N_bytes = len;
expected_size = status_pdu_ack_size + 1 * status_pdu_nack_size; // only one NACK left
TESTASSERT_EQ(len, expected_size);
// Assert status is correct
rlc_am_nr_status_pdu_t status_check(sn_size);
rlc_am_nr_read_status_pdu(&status_buf, sn_size, &status_check);
TESTASSERT_EQ(3, status_check.ack_sn); // 3 is the next expected SN (after trimming)
TESTASSERT_EQ(1, status_check.nacks.size()); // Expect only one NACK left
TESTASSERT_EQ(1, status_check.nacks[0].nack_sn); // The NACK'ed SN is 1.
// Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
// Check there is an Retx of SN=1
TESTASSERT_EQ(data_pdu_size, rlc1.get_buffer_state());
}
{
// Check correct re-transmission
byte_buffer_t retx_buf;
uint32_t len = rlc1.read_pdu(retx_buf.msg, data_pdu_size);
retx_buf.N_bytes = len;
TESTASSERT_EQ(data_pdu_size, len);
rlc2.write_pdu(retx_buf.msg, retx_buf.N_bytes);
expected_size = status_pdu_ack_size + 1 * status_pdu_nack_size;
TESTASSERT_EQ(expected_size, rlc2.get_buffer_state()); // Status report should now include the chopped NACK
}
{
// Double check status report
byte_buffer_t status_buf;
uint32_t len = rlc2.read_pdu(status_buf.msg, expected_size);
status_buf.N_bytes = len;
expected_size = status_pdu_ack_size + 1 * status_pdu_nack_size; // the remaining NACK
TESTASSERT_EQ(len, expected_size);
// Nothing else pending
TESTASSERT_EQ(0, rlc2.get_buffer_state());
// Assert status is correct
rlc_am_nr_status_pdu_t status_check(sn_size);
rlc_am_nr_read_status_pdu(&status_buf, sn_size, &status_check);
TESTASSERT_EQ(5, status_check.ack_sn); // 5 is the next expected SN.
TESTASSERT_EQ(1, status_check.nacks.size()); // Expect only the second NACK
TESTASSERT_EQ(3, status_check.nacks[0].nack_sn); // The NACK'ed SN is 3.
// Write status PDU to RLC1
rlc1.write_pdu(status_buf.msg, status_buf.N_bytes);
// Check there is an Retx of SN=3
TESTASSERT_EQ(data_pdu_size, rlc1.get_buffer_state());
}
{
// Check correct re-transmission
byte_buffer_t retx_buf;
uint32_t len = rlc1.read_pdu(retx_buf.msg, data_pdu_size);
retx_buf.N_bytes = len;
TESTASSERT_EQ(data_pdu_size, len);
rlc2.write_pdu(retx_buf.msg, retx_buf.N_bytes);
expected_size = status_pdu_ack_size;
TESTASSERT_EQ(expected_size, rlc2.get_buffer_state()); // Status report should have no NACKs
}
{
// Double check status report
byte_buffer_t status_buf;
int len = rlc2.read_pdu(status_buf.msg, expected_size);
status_buf.N_bytes = len;
TESTASSERT_EQ(0, rlc2.get_buffer_state());
// Assert status is correct
rlc_am_nr_status_pdu_t status_check(sn_size);
rlc_am_nr_read_status_pdu(&status_buf, sn_size, &status_check);
TESTASSERT_EQ(5, status_check.ack_sn); // 5 is the next expected SN.
TESTASSERT_EQ(0, status_check.nacks.size()); // All PDUs are acked now
}
{
// rlc2 should not issue further status PDUs as time passes (even after expiry of t_status_prohibit)
int32_t checktime = 2 * rlc2_config.am_nr.t_status_prohibit;
for (int cnt = 0; cnt < checktime; cnt++) {
timers.step_all();
TESTASSERT_EQ(0, rlc2.get_buffer_state());
}
}
// Check statistics
rlc_bearer_metrics_t metrics1 = rlc1.get_metrics();
rlc_bearer_metrics_t metrics2 = rlc2.get_metrics();
uint32_t total_tx_pdu_bytes1 = (NBUFS + 2) * data_pdu_size; // (NBUFS + 2 RETX) * PDU size
uint32_t total_rx_pdu_bytes1 = 3 * status_pdu_ack_size + 2 * status_pdu_nack_size; // 3 status PDUs (2 with one NACK)
uint32_t total_tx_pdu_bytes2 =
4 * status_pdu_ack_size + 2 * status_pdu_nack_size; // 4 status PDUs (2 with one NACK, two without)
uint32_t total_rx_pdu_bytes2 = (NBUFS)*data_pdu_size; // (NBUFS - 2 Lost + 2 RETX) * PDU size
// SDU metrics
TESTASSERT_EQ(5, metrics1.num_tx_sdus);
TESTASSERT_EQ(0, metrics1.num_rx_sdus);
TESTASSERT_EQ(5, metrics1.num_tx_sdu_bytes);
TESTASSERT_EQ(0, metrics1.num_rx_sdu_bytes);
TESTASSERT_EQ(0, metrics1.num_lost_sdus);
// PDU metrics
TESTASSERT_EQ(5 + 2, metrics1.num_tx_pdus); // One re-transmission
TESTASSERT_EQ(3, metrics1.num_rx_pdus); // 3 status PDUs
TESTASSERT_EQ(total_tx_pdu_bytes1, metrics1.num_tx_pdu_bytes); // (NBUFS + 2 RETX) * PDU size
TESTASSERT_EQ(total_rx_pdu_bytes1, metrics1.num_rx_pdu_bytes); // Two status PDU (one with a NACK)
TESTASSERT_EQ(0, metrics1.num_lost_sdus); // No lost SDUs
// PDU metrics
TESTASSERT_EQ(0, metrics2.num_tx_sdus);
TESTASSERT_EQ(5, metrics2.num_rx_sdus);
TESTASSERT_EQ(0, metrics2.num_tx_sdu_bytes);
TESTASSERT_EQ(5, metrics2.num_rx_sdu_bytes);
TESTASSERT_EQ(0, metrics2.num_lost_sdus);
// SDU metrics
TESTASSERT_EQ(4, metrics2.num_tx_pdus); // 4 status PDUs
TESTASSERT_EQ(5, metrics2.num_rx_pdus); // 5 PDUs (7 tx'ed, but 2 were lost)
TESTASSERT_EQ(total_tx_pdu_bytes2, metrics2.num_tx_pdu_bytes); // Three status PDU (one with a NACK, two without)
TESTASSERT_EQ(total_rx_pdu_bytes2, metrics2.num_rx_pdu_bytes); // (NBUFS - 2 Lost + 2 RETX) * PDU size
TESTASSERT_EQ(0, metrics2.num_lost_sdus); // No lost SDUs
return SRSRAN_SUCCESS;
}
/* /*
* Test the basic segmentation of a single SDU. * Test the basic segmentation of a single SDU.
* A single SDU of 3 bytes is segmented into 3 PDUs * A single SDU of 3 bytes is segmented into 3 PDUs
@ -2063,6 +2276,7 @@ int main()
TESTASSERT(basic_test(sn_size) == SRSRAN_SUCCESS); TESTASSERT(basic_test(sn_size) == SRSRAN_SUCCESS);
TESTASSERT(lost_pdu_test(sn_size) == SRSRAN_SUCCESS); TESTASSERT(lost_pdu_test(sn_size) == SRSRAN_SUCCESS);
TESTASSERT(lost_pdu_duplicated_nack_test(sn_size) == SRSRAN_SUCCESS); TESTASSERT(lost_pdu_duplicated_nack_test(sn_size) == SRSRAN_SUCCESS);
TESTASSERT(lost_pdus_trimmed_nack_test(sn_size) == SRSRAN_SUCCESS);
TESTASSERT(basic_segmentation_test(sn_size) == SRSRAN_SUCCESS); TESTASSERT(basic_segmentation_test(sn_size) == SRSRAN_SUCCESS);
TESTASSERT(segment_retx_test(sn_size) == SRSRAN_SUCCESS); TESTASSERT(segment_retx_test(sn_size) == SRSRAN_SUCCESS);
TESTASSERT(segment_retx_and_loose_segments_test(sn_size) == SRSRAN_SUCCESS); TESTASSERT(segment_retx_and_loose_segments_test(sn_size) == SRSRAN_SUCCESS);

Write Preview
Loading…
Cancel
Save