From d262d152ecfc884e07e0e588ba419c763b57ccaf Mon Sep 17 00:00:00 2001 From: Cedric Roux <cedric.roux@eurecom.fr> Date: Fri, 13 Nov 2020 14:34:01 +0100 Subject: [PATCH] rlc v2: implement SOstart/SOend in NACK reporting The necessity of SOstart/SOend was understood after email exchanges with David Breaux <davidbreaux67@gmail.com>. See openair2/LAYER2/rlc_v2/tests/test46.h for some details. Basically if we NACK without SOstart/SOend then the other end of the RLC channel will consider all the bytes as NACKed and will have to resend them all. If another status is then reported before all the bytes are sent, and because we don't use SOstart/SOend this status will NACK all the bytes again, then all the bytes are to be sent again. And the cycle repeats. It will end with a max retx reached (which triggers RLF, Radio Link Failure). The function put_bit in openair2/LAYER2/rlc_v2/rlc_pdu.c has been changed too, maybe introducing some performance issues. --- openair2/LAYER2/rlc_v2/TODO | 3 - openair2/LAYER2/rlc_v2/rlc_entity_am.c | 156 +++++++++++++++++---- openair2/LAYER2/rlc_v2/rlc_pdu.c | 5 +- openair2/LAYER2/rlc_v2/tests/run_tests.sh | 2 +- openair2/LAYER2/rlc_v2/tests/test11.txt.gz | Bin 430 -> 427 bytes openair2/LAYER2/rlc_v2/tests/test12.txt.gz | Bin 415 -> 411 bytes openair2/LAYER2/rlc_v2/tests/test46.h | 49 +++++++ openair2/LAYER2/rlc_v2/tests/test46.txt.gz | Bin 0 -> 2063 bytes openair2/LAYER2/rlc_v2/tests/test47.h | 27 ++++ openair2/LAYER2/rlc_v2/tests/test47.txt.gz | Bin 0 -> 416 bytes openair2/LAYER2/rlc_v2/tests/test48.h | 29 ++++ openair2/LAYER2/rlc_v2/tests/test48.txt.gz | Bin 0 -> 427 bytes openair2/LAYER2/rlc_v2/tests/test49.h | 27 ++++ openair2/LAYER2/rlc_v2/tests/test49.txt.gz | Bin 0 -> 895 bytes openair2/LAYER2/rlc_v2/tests/test6.h | 3 - openair2/LAYER2/rlc_v2/tests/test6.txt.gz | Bin 777 -> 773 bytes openair2/LAYER2/rlc_v2/tests/test7.h | 3 - openair2/LAYER2/rlc_v2/tests/test7.txt.gz | Bin 796 -> 779 bytes openair2/LAYER2/rlc_v2/tests/test9.h | 3 - openair2/LAYER2/rlc_v2/tests/test9.txt.gz | Bin 327 -> 324 bytes 20 files changed, 261 insertions(+), 46 deletions(-) create mode 100644 openair2/LAYER2/rlc_v2/tests/test46.h create mode 100644 openair2/LAYER2/rlc_v2/tests/test46.txt.gz create mode 100644 openair2/LAYER2/rlc_v2/tests/test47.h create mode 100644 openair2/LAYER2/rlc_v2/tests/test47.txt.gz create mode 100644 openair2/LAYER2/rlc_v2/tests/test48.h create mode 100644 openair2/LAYER2/rlc_v2/tests/test48.txt.gz create mode 100644 openair2/LAYER2/rlc_v2/tests/test49.h create mode 100644 openair2/LAYER2/rlc_v2/tests/test49.txt.gz diff --git a/openair2/LAYER2/rlc_v2/TODO b/openair2/LAYER2/rlc_v2/TODO index 0778d4320b..e93ad7e8b9 100644 --- a/openair2/LAYER2/rlc_v2/TODO +++ b/openair2/LAYER2/rlc_v2/TODO @@ -13,6 +13,3 @@ RLC AM - 36.322 5.1.3.2.3 Actions when a RLC data PDU is placed in the reception buffer [...] and in-sequence byte segments of the AMD PDU with SN = VR(R) [...] - -- use SOstart/SOend in NACK reporting, do not NACK full PDU if - parts of it have been received diff --git a/openair2/LAYER2/rlc_v2/rlc_entity_am.c b/openair2/LAYER2/rlc_v2/rlc_entity_am.c index b4f3d2f47c..710f22855e 100644 --- a/openair2/LAYER2/rlc_v2/rlc_entity_am.c +++ b/openair2/LAYER2/rlc_v2/rlc_entity_am.c @@ -898,6 +898,64 @@ static tx_pdu_size_t compute_new_pdu_size(rlc_entity_am_t *entity, int maxsize) return ret; } +/* return number of missing parts of a sn + * if everything is missing (nothing received), return 0 + */ +static int count_nack_missing_parts(rlc_entity_am_t *entity, int sn) +{ + rlc_rx_pdu_segment_t *l = entity->rx_list; + int last_byte; + int new_last_byte; + int count; + + while (l != NULL) { + if (l->sn == sn) + break; + l = l->next; + } + /* nothing received, everything is missing, return 0 */ + if (l == NULL) + return 0; + + last_byte = -1; + count = 0; + while (l != NULL && l->sn == sn) { + if (l->so > last_byte + 1) + /* missing part detected */ + count++; + if (l->is_last) + /* end of PDU reached - no more missing part to add */ + return count; + new_last_byte = l->so + l->size - l->data_offset - 1; + if (new_last_byte > last_byte) + last_byte = new_last_byte; + l = l->next; + } + /* at this point: end of PDU not received, one more missing part */ + count++; + + return count; +} + +/* return size of nack reporting for sn, in bits */ +static int segment_nack_size(rlc_entity_am_t *entity, int sn) +{ + /* nack + e1 + e2 = 12 bits + * SOstart + SOend = 30 bits + */ + int count; + + count = count_nack_missing_parts(entity, sn); + + /* count_nack_missing_parts returns 0 when everything is missing + * in which case we don't have SOstart/SOend, so only 12 bits + */ + if (count == 0) + return 12; + + return count * (12 + 30); +} + static int status_size(rlc_entity_am_t *entity, int maxsize) { /* let's count bits */ @@ -912,11 +970,16 @@ static int status_size(rlc_entity_am_t *entity, int maxsize) return 0; } - /* each NACK adds 12 bits */ + /* add size of NACKs */ sn = entity->vr_r; - while (bits + 12 <= maxsize && sn_compare_rx(entity, sn, entity->vr_ms) < 0) { - if (!(rlc_am_segment_full(entity, sn))) - bits += 12; + while (sn_compare_rx(entity, sn, entity->vr_ms) < 0) { + if (!(rlc_am_segment_full(entity, sn))) { + int nack_size = segment_nack_size(entity, sn); + /* stop there if not enough room */ + if (bits + nack_size > maxsize) + break; + bits += nack_size; + } sn = (sn + 1) % 1024; } @@ -929,7 +992,8 @@ static int generate_status(rlc_entity_am_t *entity, char *buffer, int size) int bits = 15; /* minimum size is 15 (header+ack_sn+e1) */ int sn; rlc_pdu_encoder_t encoder; - int has_nack = 0; + rlc_pdu_encoder_t encoder_ack; + rlc_pdu_encoder_t previous_e1; int ack; rlc_pdu_encoder_init(&encoder, buffer, size); @@ -947,24 +1011,68 @@ static int generate_status(rlc_entity_am_t *entity, char *buffer, int size) rlc_pdu_encoder_put_bits(&encoder, 0, 3); /* CPT */ /* reserve room for ACK (it will be set after putting the NACKs) */ + encoder_ack = encoder; rlc_pdu_encoder_put_bits(&encoder, 0, 10); + /* put 0 for e1, will be set to 1 later in the code if needed */ + previous_e1 = encoder; + rlc_pdu_encoder_put_bits(&encoder, 0, 1); /* at this point, ACK is VR(R) */ ack = entity->vr_r; - /* each NACK adds 12 bits */ sn = entity->vr_r; - while (bits + 12 <= size && sn_compare_rx(entity, sn, entity->vr_ms) < 0) { + while (sn_compare_rx(entity, sn, entity->vr_ms) < 0) { if (!(rlc_am_segment_full(entity, sn))) { - /* put previous e1 (is 1) */ - rlc_pdu_encoder_put_bits(&encoder, 1, 1); - /* if previous was NACK, put previous e2 (0, we don't do 'so' thing) */ - if (has_nack) - rlc_pdu_encoder_put_bits(&encoder, 0, 1); - /* put NACKed sn */ - rlc_pdu_encoder_put_bits(&encoder, sn, 10); - has_nack = 1; - bits += 12; + rlc_rx_pdu_segment_t *l; + int i; + int count = count_nack_missing_parts(entity, sn); + int nack_bits = count == 0 ? 12 : count * (12 + 30); + int last_byte; + int new_last_byte; + int so_start; + int so_end; + /* if not enough room, stop putting NACKs */ + if (bits + nack_bits > size) + break; + /* set previous e1 to 1 */ + rlc_pdu_encoder_put_bits(&previous_e1, 1, 1); + + if (count == 0) { + /* simply NACK, no SOstart/SOend */ + rlc_pdu_encoder_put_bits(&encoder, sn, 10); /* nack */ + previous_e1 = encoder; + rlc_pdu_encoder_put_bits(&encoder, 0, 2); /* e1, e2 */ + } else { + /* count is not 0, so we have 'count' NACK+e1+e2+SOstart+SOend */ + l = entity->rx_list; + last_byte = -1; + while (l->sn != sn) l = l->next; + for (i = 0; i < count; i++) { + rlc_pdu_encoder_put_bits(&encoder, sn, 10); /* nack */ + previous_e1 = encoder; + /* all NACKs but the last have a following NACK, set e1 for them */ + rlc_pdu_encoder_put_bits(&encoder, i != count - 1, 1); /* e1 */ + rlc_pdu_encoder_put_bits(&encoder, 1, 1); /* e2 */ + /* look for the next segment with missing data before it */ + while (l != NULL && l->sn == sn && !(l->so > last_byte + 1)) { + new_last_byte = l->so + l->size - l->data_offset - 1; + if (new_last_byte > last_byte) + last_byte = new_last_byte; + l = l->next; + } + so_start = last_byte + 1; + if (l == NULL) + so_end = 0x7fff; + else + so_end = l->so - 1; + rlc_pdu_encoder_put_bits(&encoder, so_start, 15); + rlc_pdu_encoder_put_bits(&encoder, so_end, 15); + if (l != NULL) + last_byte = l->so + l->size - l->data_offset - 1; + } + } + + bits += nack_bits; } else { /* this sn is full and we put all NACKs before it, use it for ACK */ ack = (sn + 1) % 1024; @@ -972,24 +1080,10 @@ static int generate_status(rlc_entity_am_t *entity, char *buffer, int size) sn = (sn + 1) % 1024; } - /* go to highest full sn+1 for ACK, VR(MS) is the limit */ - while (sn_compare_rx(entity, sn, entity->vr_ms) < 0 && - rlc_am_segment_full(entity, sn)) { - ack = (sn + 1) % 1024; - sn = (sn + 1) % 1024; - } - - /* at this point, if last put was NACK then put 2 bits else put 1 bit */ - if (has_nack) - rlc_pdu_encoder_put_bits(&encoder, 0, 2); - else - rlc_pdu_encoder_put_bits(&encoder, 0, 1); - rlc_pdu_encoder_align(&encoder); /* let's put the ACK */ - buffer[0] |= ack >> 6; - buffer[1] |= (ack & 0x3f) << 2; + rlc_pdu_encoder_put_bits(&encoder_ack, ack, 10); /* reset the trigger */ entity->status_triggered = 0; diff --git a/openair2/LAYER2/rlc_v2/rlc_pdu.c b/openair2/LAYER2/rlc_v2/rlc_pdu.c index c55e2d9c3c..dc8fc8b094 100644 --- a/openair2/LAYER2/rlc_v2/rlc_pdu.c +++ b/openair2/LAYER2/rlc_v2/rlc_pdu.c @@ -233,9 +233,10 @@ static void put_bit(rlc_pdu_encoder_t *encoder, int bit) exit(1); } - encoder->buffer[encoder->byte] <<= 1; if (bit) - encoder->buffer[encoder->byte] |= 1; + encoder->buffer[encoder->byte] |= 1 << (7 - encoder->bit); + else + encoder->buffer[encoder->byte] &= ~(1 << (7 - encoder->bit)); encoder->bit++; if (encoder->bit == 8) { diff --git a/openair2/LAYER2/rlc_v2/tests/run_tests.sh b/openair2/LAYER2/rlc_v2/tests/run_tests.sh index 72feff0036..f3776157a3 100755 --- a/openair2/LAYER2/rlc_v2/tests/run_tests.sh +++ b/openair2/LAYER2/rlc_v2/tests/run_tests.sh @@ -1,6 +1,6 @@ #!/bin/sh -test_count=45 +test_count=49 for i in `seq $test_count` do diff --git a/openair2/LAYER2/rlc_v2/tests/test11.txt.gz b/openair2/LAYER2/rlc_v2/tests/test11.txt.gz index ea435a666025ab5d90ca2992b91dd94e1551a654..160916bb368ac40216ecf15155677fdbb54f5f84 100644 GIT binary patch literal 427 zcmV;c0aX4UiwFqxWUXHU19W9`bTKh5ba-?CwUo<h!!Qs<_x*~yY&T`bPua_oY)c`@ zsuZKxatWjlEIWOCeJv*{b*ef}Xh6uqXwIFv9?yI_o2QuG-lX6ZmC84nE*e~}3eZ&w zz4}yON^uV&5Q99B4+=mbC<4VG0ZJY&=6{2D4<tcLP!4J}6sT<9gBk3B{Xvk|2XO!n z!4WtH3vdFK;3YT*7yF<`^{gsctL(LCb`(D}6d9P(1VK`l+EAIpxgU{G5IZySx{Orb zWnq`3lauOe3a2J_nuXPD%P>0))YGRXPHJSJCGD&=2K@3MX@!?fS*j}2wX7T6hIY@a zBM|C$d#aQ@bGVOil@xR~QqRVb&6`ASq;HV9urN8+^&~!r>xnqo_4a$^jjmswa5q`} zhhZ+@xf*#f-3q$?9Xq7x=VkVT!7dZdE~9;dLr+*e&+HzVddku)LH*(5hv#Sk_M;Pe zU|Ugpr%>zFMpc+i7IvnN9rA}5W9It-#;8g9%^2#2;J0Z;itr{ibd%>w>#|v|KWrwd VxOPVH(GlKY#1~D&mb-cf008H$$TI){ literal 430 zcmV;f0a5-RiwFp&wB}p_19W9`bTKh5ba-?CwUtY6f<P37_x%-T*>0M9nL&YNquZv5 zx@sCT4nt#NA7Q{getiL*rsx#WXhMJx?sx7z9A>8D$uz<E{w@J0$c<jlZCc`bnSyQ- z*yXnYQ-Vhjffy8k1W1BH&;T?9MWFcUYWhEjcR&iX0BKOAVL(~+9L(SVEIL6!8^jVE zf(PIsI0DCD1zvzPINb$3n^%*o!pz^(a!V0mO;NHQEg~ptTI(9KyZ0j+l0$DtLDP}Z zO&9J^baGQ|&B&|Cjb`dJt1;>`b<ESI#$M{6hGw+2wl-kTgSZl2lv!r-xh+&t+N!j< z&Km-u_;h!<arYeVB77ss#ztz{*fYHGz>gF)Qb!J^`nnzuFX4I|o$Pw`y>w}dw--E& zX6G=>2fS2}XXA~a@85BY6#adfh3rh3^rnn<2_8M^^n$kPX2B6%$<!wq&Em|_WO0#f zvN$E28>_3z)U1|klVdWPxy8Qk?sJIIXX81*=(WWEGP+_a_f4y%2p`JAmRcKYvvRfi Ya-Ep;)?2|xR|K6EKh2#HPZJ0L05dMoSpWb4 diff --git a/openair2/LAYER2/rlc_v2/tests/test12.txt.gz b/openair2/LAYER2/rlc_v2/tests/test12.txt.gz index 988d7ae644c008cef2f34adce448d00a3a7ce4e1..a416cfdd2edc22463ab562588847eb73d27a3848 100644 GIT binary patch literal 411 zcmV;M0c8FkiwFp;WvyQV19W9`bTKk6ba-?CwUkRwgFqC8_x_5r)Q!29;W4l@?bevI zT^Z9*7)+D;NT<~3uXmswQ|dsW+6@ab=iGC?fjb>frU}OPcL_MbT4me0&P!Y`bI?r! zz5G%L5<G$k#2^nOK>pL!v|Y$eVE_t25lDjKPN8RoOtmrvEkGH_gi)ZvyazMb1B*^0 z(KKQo9DqY`1eV|!oPrnN44fYuJ*!u>PB&`)o|k(U5mhd!UqO(BK-Q%QDIH-sD%;&) zKrBCU=JIO5DyvhFO-K85!*exfO6N?jXXbXMX=0upbyRA)#!lB7aA7M{3|tuEpd->D z2HIh0WzcjD`xLFHQH7}|zBsxBzF7VRpJAVsdh_;zhtcex;JG|6^<B=!yMeA>!R{zJ zJj}v(o|g8s#c!f43KWG2+S~^sxWqNG2+zC6T`42Z)oQs_YfMJ7{jP1@(I+&{_1vy8 z7t(VxpYZ6l{eC>UuH664wi-qFNHuhsWlHO!T&+HB5|!UN6+Bqs4OWOw#Wy=C0~C)3 F007+Szx)6I literal 415 zcmV;Q0bu?giwFpK`Quyy19W9`bTKk6ba-?CwUtXx!!Qtp@BE56!UgTxN%J_O_KJ|& zo)D^1$3>OOLv>RGzn(lA)D*`}3c2JEd1hxnt-Z6!bQWWBe;0#eY_-}iOq$_(oq}#+ znDv*2AL9{3AO;DL1bI(avvwgjg+6Em3P2$!atcK)WGa;jXbDoFJd6gd^8a843$Sz= z$)*u|U>`gJ2jCDKffMi&tib81(X)Ql+hnH~?`d{$kwM{-cm;%z;D=>XgoIA8oHXn1 zphqk(u;vmaV6Dm&RHvguy8gMEHA8DnE^DTB&AgNRE6CAO(>1cXmVj4v3k3rkhRAnB zI>ta1hE@hm*HM>73u;tg>WD82hQJqvf5DftSDD$pz2IRy|0j4h&!OgWKB)@Yu0s7r z(eYuHp7pd>pB7C`^#(}Sn5j!iu^eR1SPn91EH9k23VSY2^=7@-TTI9E!!~H$B4;$# z1=6m`8FkzpXFNK+&p#fnq4a*UElLqS5(ASdrHxr-o6TpPM5nh_1@~5n-U{hdd;_Eq JWzaDQ003|)yl4Ob diff --git a/openair2/LAYER2/rlc_v2/tests/test46.h b/openair2/LAYER2/rlc_v2/tests/test46.h new file mode 100644 index 0000000000..b58c9dce64 --- /dev/null +++ b/openair2/LAYER2/rlc_v2/tests/test46.h @@ -0,0 +1,49 @@ +/* + * rlc am test ack/nack reporting with segmented SDUs + * eNB sends SDU in big PDU, not received + * eNB retx with smaller PDUs, not received except a few + * after some time, RX works again, UE should NACK with SOstart/SOend + * + * this test was written because in the past we didn't generate NACKs with + * SOstart/SOend, potentially leading to infinite retransmissions, even with + * good radio conditions (well, there will be max ReTX reached at some point). + * The scenario is as follows: + * the eNB transmits many many PDUs segments and asks for status + * report at some point (but before sending all the segments). The UE then + * generates a (wrong) NACK without SOstart/SOend, and then the eNB has to + * resend everything from start (all bytes of the PDU have been NACKed because + * there is no SOstart/SOend). Then the eNB will again ask for status report + * before sending everything and the process repeats all over again. + */ +TIME, 1, + ENB_AM, 100000, 100000, 35, 0, 45, -1, -1, 4, + UE_AM, 100000, 100000, 35, 0, 45, -1, -1, 4, + UE_RECV_FAILS, 1, + ENB_RECV_FAILS, 1, + ENB_SDU, 0, 300, + ENB_PDU_SIZE, 500, + UE_PDU_SIZE, 1000, +TIME, 2, + ENB_PDU_SIZE, 7, +TIME, 50, + UE_RECV_FAILS, 0, +TIME, 51, + UE_RECV_FAILS, 1, +TIME, 60, + UE_RECV_FAILS, 0, +TIME, 61, + UE_RECV_FAILS, 1, +TIME, 70, + UE_RECV_FAILS, 0, +TIME, 71, + UE_RECV_FAILS, 1, +TIME, 80, + UE_RECV_FAILS, 0, +TIME, 81, + UE_RECV_FAILS, 1, +TIME, 140, + UE_RECV_FAILS, 0, + ENB_RECV_FAILS, 0, +TIME, 150, + ENB_PDU_SIZE, 200, +TIME, -1 diff --git a/openair2/LAYER2/rlc_v2/tests/test46.txt.gz b/openair2/LAYER2/rlc_v2/tests/test46.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..dd633ec0329973242005359584099d8e223de24c GIT binary patch literal 2063 zcmZ9Idpy(oAIH;9%q4C1V8k$TD`oB*A(zv140Y6uLzvu3ncT^>wUJA8(1XZwPQQL# zu=vU4=eFDuwK%RNv;8EOVZs=j`R&{9{2q_<`~CHKKi==>>-l+qK3ch8aBo0$z<y9{ zNKCAS)rr`|*nP`oj=2bHm0Me4<uJ_0AN<c;(BqqRPeu~y6y*75k6#Bmk>1Ffci8jd zM|xaWChZ3m5{Cj6uCb`o+=Pu--gY97B^IqHMy2m?6t7b~Ux~gA>~5>=2}qr(2~^>s zy=pLXibEqQdazIWW#p3NKg%_~)@xE|>_U(ZtenO-Nk>C66J0Z0`u6)E)sHxuU7~8- z-H$;k|G`GIGExNlv^a2qa@tMLRkbv#16y7s8^D=djzEI5uwXDW$dLfGB9rez<H?{( z?Q(GA_#g!Fn|5+{hAI@^tsL!)%T|lVo`lH%D~AA8SE2s+GSOJdt-CJJr#6zHbU!cT z&GkSdf`_rPTi4=CIs6^Vz<dI{>e$%9E1eH&R|toy4sdf`5wA{YSiSyQdms`znRT_N zA;@jQtN}5ZSsiFwdm-}RTcqr-SUFc{gro00tH<P`d-0D!&$J)9DnCQoUUJ;*lfvkj z^c`EHl;1U9E4ZNz{{m~)v0hSa3EY|hZDyywZYNH^G+0s-7VI)EzNAeY+oW`HAR3xj z1~l3jjn_~wAnVRdL~Ees3Siitp|cvdA0-xLD4kO&QVwxGW2hE_#hjJv&-wY>VGpVo zDY;xKth<@*7kv#4W9G%YNn#tLJ<FBDoa3HmEuI5icJV*!J#x^pGIRvNKXv@6!Q~&X zhAX-cp7cGH8!rFpc0;9JeO|-wi0}i;E-%8Df9c!nV700<xgA_Oe^{KdJKMOv9!F@? z9Gfg#_{_bRYF9_cZmQeVMW?L2yOvChqJM1O+y4DS3c2tg4X#l$Zqr$sInLcOXXFO6 zZ|r(t393zgye@Ex^tJI6>(0y!{`(c)78omiu_iBXwUe>XKMJNR-0<_!;N)j=i>INX zN>4I*rCLGyLCLN=7&UhBnG(&aw1(3qlCw8WD<4&eYGdpmtU7U>SuHDV01pr8IEIzX zFV^g)A%Gxq%QlHzN?y=o@xDob_!fZ{PYjS<PBgf5VzAN^&}o_}pj6aLJ)tIv*z|4q zgaVP(;W-*Wg1l&@-vOUg=3xLR;eU(-0Mz(g^LHSSCMCIaVzH(<Is;aSLRbi^Fp{NW z(aY-#U~}2w%!Uv3y6=wQsBC+gJE+2!lWY;%R#Ko44Z>DCfIP)B-_aF`tKaU32r&Y& z{nob5CU<8uAxRLnor1q^6F#lEq}BUsV-@=7PEw+1ncCR0Yvp1+1?rt+{@|BzyB(j0 zf{~`2caEBM;uvuW3*3QyVfyTU@-~XY$fX(Ff|2pZ(9r!gDHj5&PYX&j8s%B^ILRY2 zxZ*MICds5?>eXgGpnwUVqk)YYm$<XQ?y2?k$H49h6YaeP#gt&3_+M^lB~0gpnmw7k z9#CTNK(@4IB6Xl5{A=*}t+n<Co)$23|F1%OhanuZUTR*C;bQJM{OOUk4D9_8_ZG@U zYn%nl^0;9#)^rFrRzEu5)9Wf<Xj$!)tZpW0+-^BqloML_<Zo^~fBgq<A6QwoRh5S8 zU-9K_P{MvIt%@)hxl$<s@SjHY+${<%uhNpGECEs7V)dwtxzBLL3vYkjWeJEG6V?Kz zd|#7Mz%)i`%PEtXK27m=t^p>_xNQdj91k*)GmrrI+&2Gm3Gm*(_zPfC`o~rY?ENM8 zvJV&23StB6p2S5&;Q%ncsx9=P1g!R-T5?IZyOQ46+&1`dzHe|~bie0D=itKg0)ym` z`I*HsgXG}(<l+(7L$L3c%MAuL>2WsqsV7>;Il2hMdU}*M)qbdRP<Wx$vp#Ho{W2Gj zCwTWres1i%T&xL7a*iB{EkzA|xKwSo68Kz8A5>XJKd|S34=4_3Z1Rjq^~fxu8$pup zf$qW2Ksd(PNHg-VHsvj(|0dz6Ga5>4QsCgSk>+GCB;`GXc}vyC*-(wRt-y)QMp}@E zk(43`ld6h$GDH$1WGnNsXZ6TlI+PL!Ge<Sl32j7tD$A+L=IE3E(79g@>CYu(IigL8 zs?wZy*_Eo~pLOpCL;CXxzd9OXh(6MsrR+*I@~|!?4AOt+B=WH43JK)Vr7Zr8z{#q( zS%E_c#*^CRMAO)tq=KH+gHC5u+|b|<p9+-XLq(H$(XBOO{DMh&xT$Y?B`)`ZP=3~? ziWOk^F-UpO>7(L{ZMa8*>S)K=_O3<oEhSC-wh5;7(JuU_Bm%#K#Ozw!!z={x_lo!^ zVfs%gCA$u@c2(kOFP3CrH)ogk-|{cr?_~_DYktq}|GR&Q#js`u!~t`f@?zpj^Hn`h zrd`FF{(XnlBI{aF=HFX$W)Gd5bvI6DW1@%xkY^HXKr6Aoj38!svAWk}{)3iVoBj`K z6h++r6J?gEiWxDi?p2wJRs9Bs)z@tdErGVls*Jq=E&zQ<f_43=bC`3lSeH3Oo0p^U zXQ&Q~1|rdnkjo9FPg|wzF7|W1z1xfFHGWvWQS=7-MvsYu%7%-rsCjxu9Am^6x2K8) X-yH79v{y`bY|GEq`M0Op?A!Nm?NJQf literal 0 HcmV?d00001 diff --git a/openair2/LAYER2/rlc_v2/tests/test47.h b/openair2/LAYER2/rlc_v2/tests/test47.h new file mode 100644 index 0000000000..30cc6498da --- /dev/null +++ b/openair2/LAYER2/rlc_v2/tests/test47.h @@ -0,0 +1,27 @@ +/* + * am: test function segment_nack_size, case "if (count == 0) return 12;" + * The eNB sends 5 PDUs, only first and last received by the UE. Then we + * ask for the UE's buffer status to trigger the case. + */ +TIME, 1, + ENB_AM, 100000, 100000, 35, 0, 45, -1, -1, 4, + UE_AM, 100000, 100000, 35, 0, 45, -1, -1, 4, + ENB_RECV_FAILS, 1, + ENB_PDU_SIZE, 100, + UE_PDU_SIZE, 100, +TIME, 2, + ENB_SDU, 0, 10, +TIME, 3, + UE_RECV_FAILS, 1, + ENB_SDU, 1, 10, +TIME, 4, + ENB_SDU, 2, 10, +TIME, 5, + ENB_SDU, 3, 10, +TIME, 6, + UE_RECV_FAILS, 0, + ENB_RECV_FAILS, 0, + ENB_SDU, 4, 10, +TIME, 42, + UE_BUFFER_STATUS, +TIME, -1 diff --git a/openair2/LAYER2/rlc_v2/tests/test47.txt.gz b/openair2/LAYER2/rlc_v2/tests/test47.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..5404bd79369fff5f25b25c51ca9dd1c3ea236164 GIT binary patch literal 416 zcmV;R0bl+fiwFn~XRcoY19W9`bTl_Eba-?Ct&_V>!$1&4d%oh9(4d*w^&>73X=##F z2w8rtQKSeVKf>edS(_N)B{sI8vA5VcduDWJyWVUgtnY3jNQBa4$GFNHT<&wwRfKB) zZom}b9z-Ap2}pr7$OHMH02G2&4;R}3=+QixGO11coHsp1T1rA4Xbx+)?ohco?2o3z z=62WX%(XcY&d5mLksg>UX9VnwAOWSI3}mNcKt=1qY+C~>7c@BnUcl0hlnkX<gFUbh z4!|LJ1x~;zI0NS{Xi`cRuslafIa2meKnTJRfhdTEcn}{FxS&ZXwSeV2QhF#QA!G$f zASon+*iqUf6i@`kE@)Cp&ttXu^Oxk$UT$Mfcu6W$O_rIeDw@OLt=|HZUw>n3i%FZJ zFlAiTN!?VI-u>h5kpT7U=ZWlGzRnKdj9qZDvq7-mjM`k-$c8kG(^SaA`62H_)aatm z-xK|d&&+&xK6=b&!MgoZv^yVf)aUPr*;yXxs1GyiAN{uv@r*PN3S?=4T3Vnd3qAlU KzFe^s2LJ%53BYIo literal 0 HcmV?d00001 diff --git a/openair2/LAYER2/rlc_v2/tests/test48.h b/openair2/LAYER2/rlc_v2/tests/test48.h new file mode 100644 index 0000000000..46c2c8ad33 --- /dev/null +++ b/openair2/LAYER2/rlc_v2/tests/test48.h @@ -0,0 +1,29 @@ +/* + * am: test case "if (bits + nack_size > maxsize)" in functions status_size + * and generate_status. + * The eNB sends 5 PDUs, only first and last received by the UE. Then we + * ask for the UE's buffer status to trigger the case. UE PDU size is + * limited to 6 to trigger the case. + */ +TIME, 1, + ENB_AM, 100000, 100000, 35, 0, 45, -1, -1, 4, + UE_AM, 100000, 100000, 35, 0, 45, -1, -1, 4, + ENB_RECV_FAILS, 1, + ENB_PDU_SIZE, 100, + UE_PDU_SIZE, 6, +TIME, 2, + ENB_SDU, 0, 10, +TIME, 3, + UE_RECV_FAILS, 1, + ENB_SDU, 1, 10, +TIME, 4, + ENB_SDU, 2, 10, +TIME, 5, + ENB_SDU, 3, 10, +TIME, 6, + UE_RECV_FAILS, 0, + ENB_RECV_FAILS, 0, + ENB_SDU, 4, 10, +TIME, 42, + UE_BUFFER_STATUS, +TIME, -1 diff --git a/openair2/LAYER2/rlc_v2/tests/test48.txt.gz b/openair2/LAYER2/rlc_v2/tests/test48.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..c1797b73bb05906533b665989bdb1f242895c29d GIT binary patch literal 427 zcmV;c0aX4UiwFp4T&`aN19W9`bTl|Fba-?Ct&_V>!$1&4d%oh9(4d*wwd1%%q@_tx zA!PZnMv)?f{0NV)XV=6CFNtM~H1-yrvuCbnHmmg}#_HiNhQz2$en{$~#r3WL-NdMO zp9V}Z9zg_Rkbo3Og91<pT7V+Z^66?b06m)*Q>BebUW>M;h@+&`fu^vws}5C|{qA5Y ztnatI&QzNt;e?Fz9qEC&@*-d_f)td2a*$2OfJ*1WY+C~>A2b>P&tPd!N`_Lb!2vh~ zFTfFa2~NQoI0qL#XjDpOumVp?c~bUJLI}bTfhdTE1dtH2@Ij+eY6dIxr1VfqBFGYw zLNZ7Wu~FJdD4__7ebA_sp2l+X7tWbK`>`8y!dqISZu8vKb=mIsAN>}X;`SF?TTIrL zrKys-Nt?E|^zNN>mjr0uzfWXy`8j)l6Lvvw7rJL|=aPnlG&bJR^zrT#)Y%oEz9AQy z?9NA@^O=P>p`(wfT7nHIqCYLT>v+Pi9~8*sf(vb0*I{rrr2iu(uhyB4`rYE;Zn>}B VMQTo9u0W3#d;x&&PX$2-002Em%`^Z2 literal 0 HcmV?d00001 diff --git a/openair2/LAYER2/rlc_v2/tests/test49.h b/openair2/LAYER2/rlc_v2/tests/test49.h new file mode 100644 index 0000000000..edeec27403 --- /dev/null +++ b/openair2/LAYER2/rlc_v2/tests/test49.h @@ -0,0 +1,27 @@ +/* + * rlc am test ack/nack reporting with segmented SDUs + * + * 5 SDUs put into 6 PDUs, all PDUs received expect the 3rd. Then + * retransmission happens with smaller PDU size. + */ +TIME, 1, + ENB_AM, 100000, 100000, 35, 0, 45, -1, -1, 4, + UE_AM, 100000, 100000, 35, 0, 45, -1, -1, 4, + ENB_SDU, 0, 60, + ENB_SDU, 1, 160, + ENB_SDU, 2, 130, + ENB_SDU, 3, 120, + ENB_SDU, 4, 100, + ENB_PDU_SIZE, 100, + UE_PDU_SIZE, 1000, +TIME, 3, + UE_RECV_FAILS, 1, +TIME, 4, + UE_RECV_FAILS, 0, +TIME, 7, + ENB_PDU_SIZE, 40, +TIME, 42, + UE_RECV_FAILS, 1, +TIME, 80, + UE_RECV_FAILS, 0, +TIME, -1 diff --git a/openair2/LAYER2/rlc_v2/tests/test49.txt.gz b/openair2/LAYER2/rlc_v2/tests/test49.txt.gz new file mode 100644 index 0000000000000000000000000000000000000000..752a1aedd51defe7b9225848e6ff5bf45c7d1a7f GIT binary patch literal 895 zcmV-_1AzP=iwFo60m)wi19W9`bTm0Gba-?C?U>7MTtyIu_dLb7gbnJhzRwcHTQ+f4 z2t|EGmMj!`a1cB_=Nx-1jy*m}5R8*B574cuud4pKTwc7s+;Q>a4?FaZn_l0)-M3r5 zy=tiMcI>bI?0B`~CzL{Il%NdCq8!Sj0xF^sDx(UjqNax(HP8yJ(SkN;i*{&_4(NzZ z=!`Dtif-tR9*9CTB8WjO;t-DnBq9mPNI@#nkd6$D!f1?O48~#{#$y5|ViG1}%Fo|i zKJT7BxTo*@GZoV?9W$^BtFeMLSc`R7j}6#}P1uYr*otk~jvY9K(>TEyoW(hu#|2!( zC0xc8T*Wn9$Bl_7UgHIC@D}gz9v|=#pYR!9@D<<i6aGO^1WgcvAy|SVctRjVLLy{B zAyh&mbiyDiq9zK_5G~OWJuwg?F%dJd5G%0}J8_T{Nt1+RNS5SCo)k!tlt`IWNR`w` zoixabtjR()WJ`8rPY&crPUK83<VtSjP979R(G;N=ilsP;rvyr*Bub_fN~JVPrwpp1 zYN}8T)lwbRQv)?p6E#x{wNe|kQwL4aG)-uRW@(P*X@M4LiI!>GxgZa@V3u5HmDXsT zHt343=|VSjOLufn5A;Y+^h_`GN^kT|9}LCN3}G0CWjKas1V&^eMrIU7Wi&=-j4!dS zPE#wJ5i<`FlO<y3x;jZ+ZN|ht#6;ay(c>CC*VS`%^_c4~{nvhzf9r4Gwc9n+DZOUT z%pA+JbZoZS1JpMc3)9xGuip0?UcY*Cm}|a*u|~F%Wzw0+xw9&MgetC}noX#6Nf$la z^{<X7U!Od#pxO^XHTSai#R|@8Ds2VTeF*9j+R5+pGO$@`E2#b`)U+_2te=3M$ClOD zGI!YH(ByDBh>r=+ZCLSp-m|~0weR=i_WJsdLznLD`@j8d)zQ!G{pXXHGc&c8o8x1Y zJuG-L;=>4aDkWbVC|d@`djqFPoiNST1|DyNcPsK(44edMQqcdTXUuUA;iv_16?d7l zYZi(z3*^d!5I=LoA-yExyKO_<2Bh(_ke1Q?83UhW!35%H7HIJ=oydy`PZkipY#`^u z<NxCDxRC}%oo|kx*UfPwSfbA7##5ggH^QOR`O^4LNA~9$<6&sm@o68O$?K08+t)AT VlV6xmeqlFX`~{-o;B)C5002XNs$u{D literal 0 HcmV?d00001 diff --git a/openair2/LAYER2/rlc_v2/tests/test6.h b/openair2/LAYER2/rlc_v2/tests/test6.h index 2115c8a328..f778749729 100644 --- a/openair2/LAYER2/rlc_v2/tests/test6.h +++ b/openair2/LAYER2/rlc_v2/tests/test6.h @@ -5,9 +5,6 @@ * [1..600] is received but ACK/NACK not * eNB retx with still smaller PDUs [1..400] [401..600] [601..900] * all is received, ACKs/NACKs go through - * - * this test will fail if NACK mechanism uses SOstart/SOend - * (not implemented for the moment) */ TIME, 1, ENB_AM, 100000, 100000, 35, 0, 45, -1, -1, 4, diff --git a/openair2/LAYER2/rlc_v2/tests/test6.txt.gz b/openair2/LAYER2/rlc_v2/tests/test6.txt.gz index 54870821a619725938e1ea529ff533d748d9c7db..345c149eec772a1057e77089963bac98bd8bc13f 100644 GIT binary patch literal 773 zcmV+g1N!_QiwFpqQ>|YD19W9`bT%$@cys{mnoExzH4ugO`4!(1HmLlz?-DUvHkqst ziu@>}kwys3WrE<>bDJ<xM%*Aah>0kv)hpWz*LO~xZu|D;_3eq9Z@)g_PCV#*_x8LV z`QmONU!FMM{iZaL6W<|%IK(3XiAX{+Qjm%?q$2~F$YrJ?8z(r2^SFSExP;5Nf~&ZO z>$riNxP?>P#tYuzJwD(gKH)RI;48l2JAU9Ne&H3r2|{oLPY8raNQ6u%gi2_HP8ftq zSOg_(q7WU?69X|46EPDDu@W1x69;h;7g33uBqT@jq(F+KM9QQ>s-#Bhq(PdbMN-lx z3)zu9Iglecku$lFE4h(7d5|Z0k(InDLU9yN36w}lluRj<N@<i%8I(y`6s2scP#x7% z12s|;HB$?<QX92X2X#^xRjK<@HkzY(TA)Q*qGej4Ra&EU+MrF^qFrjd=|XpOPY?7+ zPxMSL^h$5^P9OA1Uv#B!hA<q%GXf(r5+gGTqcR$!GX`Ta7DE}EDNM)o%)pGy#LUdX ztjxyj%)y+@#Z=~I3CpoOE3hIfu`;W$Dyy+NYp^D3v6Qt@K^^MRfJQW-87*i<8`{x< zPIRG)Znm%;+p_~ZvJ*SA3%jx#yR!#-vKL#~+xR#Bjeq0c_&5HI|NoZ%?_b?M%dJ1? zkNVJm*0(>c#}A>^AEEUEwTP9@tjny+_&5HIf8*cyH~x+P7ZF`!xtd+``yZ~C>Wh5z zSOv|&%)yL*<KOuIAMyXxG2h&LvSIqC^GSK$UhCD-LFzGn|It-1NFVw#iJ8Q##k{nT zd`P~At0JyXlK02^vbPuhFPpHBb)K0(i&y7I%h;AN%mB>*KP&z}HpWjF+dntPbUjN+ zJXTosPaY1%ndnS(|6Z_vPh+;MZmKcWeAZe05b@IcyLbA)>u=tCxIS#Rht09fv5bG? z-}pEFjeq0c_<uQx_3sXp;$J>ek6bJK($Ab9=hX9gKi=Q}`V@P0ef8>h5<a4YR5t(s D5E6rk literal 777 zcmV+k1NQtMiwFo(!roj019W9`bT%$@cys{mo4altM-WAGeZ>i_#HfCEZ)k|A6H$?2 z2>qxw2oQ$BHD%ae?_JRpBzVQlFbNef;Y?KLp1RY6xxRXPec<ZH9}c(!cRD}3KdyVe zyIIKV1IL@clqPcECqxj3cqAYZNk~QtQjvyqWFQkcJ*mjX3C`g>F5n_A;WDn^Dz4!= zZr~<v;S{&=f_He25BP{r_>3?3if{OiANYx1c*Spm5FEi10wEF-ArlIr5*ncs24NBw zK?$2EL`U?*K#ash%)~;h#76AIL7c=zRN^KH$&oxMkRmCOGO3U%sgXKqkS1x7l(fl0 zc4SWu<Va5BOfKX~ZsblL<Vjv+C2xvQ9K}-tB~lV4QwpV08l_VPWl|PJDVr)(NA=V| zjnqWV)IzP)M(xx=ozz8D>OPH)=4hT4Xpxp^nO10()@YqJXp^>Rrx|a$&>h{=13l6c zJ<|)l(i^?g2Yu2PUFn-449D<{z=({*$c)0MjK=7U!I+H2P{w8o(=k0WFe5WDGqW%& zvoSk!Feh^{mAP5MaxBjZtjJ2N%qpzPYOKy0tjSs|Wo=YYhk7)i5lv`D3tG{Jc66W< zU8tg)Eo{g3?7)uf#Ln!(uI$F{?7^Pw#a8w<{*8a*-}pEFjeq0+|K<PZSJz+k)?f5j zz3ad0``_06r_$=rrS$~0h>gzFW$H5ijeq0c_&5HIf8+mIRM%K8cGvuH;Ch<A$Y+;L z&<th<GyaW#<Nq7t|8Zl!yZY+F^pD>s<;(S2FWw!bp6}lux9SP$bG|HM7BO2f&#fe% zBVWVC5XZ;J`wPKu@$xg)tF2d<^h|m$ivQ1L_%*RTDZ})X45!J^WN0!p8NMtTKA0_E zejAjJK3w&mfu18{sj<}jcSjQsG!{E;u+&&;Ui4|hImAnEZ$9W9Z{NK8^aF(b|6s;4 zV;TR(zwvMU8~?_?@&9}p>r<b^<G)@~&%IXoqaQim&#A}bzQ4Ww^Rf2o`u^45*|Zby H7CZm|ELM+i diff --git a/openair2/LAYER2/rlc_v2/tests/test7.h b/openair2/LAYER2/rlc_v2/tests/test7.h index 081227a400..83e9083b10 100644 --- a/openair2/LAYER2/rlc_v2/tests/test7.h +++ b/openair2/LAYER2/rlc_v2/tests/test7.h @@ -6,9 +6,6 @@ * eNB retx with still smaller PDUs [1..400] [401..600] [601..900] * [401..600] received, ACK goes through * link clean, all goes through - * - * this test will fail if NACK mechanism uses SOstart/SOend - * (not implemented for the moment) */ TIME, 1, ENB_AM, 100000, 100000, 35, 0, 45, -1, -1, 4, diff --git a/openair2/LAYER2/rlc_v2/tests/test7.txt.gz b/openair2/LAYER2/rlc_v2/tests/test7.txt.gz index 9976a6050779805882bbefb2dab98fa27fd789bc..48148755dc87b70df54d4a863a5727283ae42afb 100644 GIT binary patch literal 779 zcmV+m1N8hKiwFpcU#(vP19W9`bT=+^cys{mn>}lsM-)bT|B6$_O}O(tv!$`xG?uFn z%zWH20uh2Xa)^JucjHJ{WL<{H@r7lpcdL7z=bl;Sy}o*Lec<Y+R|njIJDnfi9oIcS z+$`kff#c0brHLH)84<)G9tlW95|WXERHPvt8OTIVzf@%71m|!b7jO}ma2Z!{71wYb zH*gcTaEjY_!8^Ri2YkdQe8v}i#W#G%5B$V0yy7=O2#(+hfe;CakO_rQ360PRgD?q; zpoC2nq9b}@AVy*$W?~^$Vk36qAWq^UDshv9<Vc<rNRgCCnN&!X)JUB)NRzZkO4?*0 zJF+JSawI2mCKqxgH*zNr@+2>^k~c*tj^ZhS5-Ew2DTPugjnXNDGAWCqluZ??qk3wf zMrxvFYN1wYqju_`PU@m6b)UvYb2Lv2v`9;|Oe?fXYqU-qv`JgE(~LJ==#K8`fgb6J zp6P{N>5bm$gFfktuJp|ihGTd}U_?e@WJY0BMq_lwU`)nhC}T5)>6o4wn30*7nOT^X z*_fR<n3K7f%G@krIhJPyR%9hsW))UtHCAU0)?_V~vNkHHLp>VMh$b|n1+8d9J37#b zE>zLY7Pe!1c3?+#VrO<?S9W7}_Fzx;Vk>(a|Hi-ZZ~Pno#=r6Z-}3*<i|Z%e`d)w4 zyZ*br`)%DnN~=Fh>j`QR8=X~`RhRK^{2TwqzwvMU8~@KjU1PcEuKDvHuBYjXeDSdf zT7y}G8UMz=@&6t1|8!&4iyJdYJ#WnY*P=X8dX9{x#!_Qj<5_xdix*QI&3kR{TZ37H zeN+5DZMJl=*}TMav#t8~K+ln})L3f%Wm|69Y}ry{srhDY`R&zLL+l^!<jR*1yKwnB zM16SLpTGTsTb~%M^7J-E@aE>`=GK?im;WO-|6GlyW?OoD^Fi-;^ZM=M%MJE!gH@ST znelJ@8~?_?@o)Sa|Ig#-|Fy&T<Jmv{^Xz^$Tj7s><aj@)9*_I}_V&*Q@zwR?i%$(s JzlHQW005kxiuM2i literal 796 zcmV+%1LOQ3iwFp0#NJ#219W9`bT=+^cys{mn>}ltM-YX3|B9!Kn=t#md&^+8X)ISE znEjXy0uh34<dFRO+#5y0BG>6cBs}nz`&RRuGl#?O_0{|916SXFcfcLE)A{M+aozLH z%|hNDINtoBG?4>8Ac8o=BLRs>LNZd2iZrAn1DVL_PenFPa1Q5j0T*!zmvIGGaShjT z12=ICr?`z5yu*8Zz(;(-XMDj|e8YGAz)$?bD}ED%;0T@&2$7HonNSFo&<LF{2$Qe~ zO4vjpI-(~AVk9PFCKh5PHex3Z;v_Dj5;sXmj^s&!6iJDcNrhBNjnqklG)ar3q)isG zBYScnM{*)(av@i8BX{y3Px2xwc~gYqD4r51k&-BxQYe+uD4jAWld>pE*;JuAs;35O zq$X;n7HXw7YNrnBq%Nvb_i1c2NAt8mi?l?`v_h-2M(eaeo3uqc&3My=?&zK#=#if2 znO^9X-sqh^=##$aO5Y4&IEH5gMr0&LW)wzcG)89(#$+spGB#6~j_H|!8JUThnT1)I zjoF!lIhl*8%*_&(V|i9!MOI>ER$*0EV|CVGP1a&5YomfX)T057XhJhu(26#+qXV7j zLKWR?VLP^G2X<s9c4ilLWjA(b5B6j)wz9YJZ~Pno#=r4z{2TxOFaJNjxqg;gf6|}z zuK%hZe_8iWq1B&5>j`QR8=YB~S(ou|{2TwqzwvMU8~-mNy2f%byXJ?&^)!8v&pw-= zIhZ+^@o)Sa|6dXR&o^ehxG{s&^TynNEy@$6XUUjqOf|MOUS#fV@uG^O<zCzS=3wSv zuZsWY&Xz7Zo0oWYwpITg=vgwR8dJ@GoR(X*v}~#|)x6rY{Nd`0BKD7Wa^>^GE?mA2 z5g$+c=l?w1pa}lo^7ynoZh721(me8Y<?#nQJUQFa+nY~%$NP65o*p#Vdj_*Ivohn~ z_&5HIf8*cyH~wGBdxj9KLpFK5ln&X2XeF}A#$@xVOXM%9_^CyX{}lbXFA;w0M~?S% a>hZYmZ*PBptW$J-`{qygK1W|ZLI40jfsNb% diff --git a/openair2/LAYER2/rlc_v2/tests/test9.h b/openair2/LAYER2/rlc_v2/tests/test9.h index 88e23d94e9..2da9732012 100644 --- a/openair2/LAYER2/rlc_v2/tests/test9.h +++ b/openair2/LAYER2/rlc_v2/tests/test9.h @@ -11,9 +11,6 @@ * In the current RLC implementation, this is impossible. If we send [12..21] * it means [1..21] has been split and so we won't sent it later on. * Maybe with HARQ retransmissions in PHY/MAC in bad radio conditions? - * - * this test will fail if NACK mechanism uses SOstart/SOend - * (not implemented for the moment) */ TIME, 1, ENB_AM, 100000, 100000, 35, 0, 45, -1, -1, 4, diff --git a/openair2/LAYER2/rlc_v2/tests/test9.txt.gz b/openair2/LAYER2/rlc_v2/tests/test9.txt.gz index cc6d934e708e1ddad7286e7c3eec33cd23c91f94..d3803062aa9de8a7e8fa319d58248e6b06c89e99 100644 GIT binary patch literal 324 zcmV-K0lWSmiwFomVXa>R19W9`bU7|`cys{0luJ*;Fc5_A{S|YB3!2S4Iilu@klLOQ zs?yj&k-|f9Qv|=BIFL#a7NR2b;?sKOo87h7`D&dZzq!sJ8CqQ)wnlZhs1<mb!PM^> zJ~P~b1O@a!9}K_{jKCO7z!WUN9aw_>MGaOELImPLd`JKZArT~oB#;zRKz5K4qV5;# z3B-eb(rvNV+ZWZ11fC@*I6$0*BZ!?KUT8sdGJ^aSXX=?aJ;k@4)nJuy2=KcMY2em7 zIm1*nbgKqdRUK7#Cj?KUd4mi4jV(K~e}2U6ax(*=P#lW?wGEs6%h9!g<6GpU+ILSS z8LK^edbC7wg{tZsIt}R0H-k^0UQg+!KIj&!<!1az&he2P{eNm-@IAi8Bwh;x)0L$* Wrs|sJZA_un)#3v@!SqEg1pok{29+29 literal 327 zcmV-N0l5AjiwFpB!rxp119W9`bU7|`cys{0lub*+Kp2GY{S|Z6i_DwN_fgub2u)8S zCE49dp?;8UD*EefQd0;l#cJ$*-<fB2XWwErFLKQ8ZgWVE+UniXnFd#D177EF>rV^C z91kEt0RvEhAsB%%n1CsmfhAah8r%<Ba0MYmAOS={LP!LOAqgafWRMb4K{UiXPKp7< zlYOyuxwXqT)AR&EOHi_dxClp>ctL`w1+i%l@>iUpXX^D7)q1WvtCU@UpJm8Gzuwsy zhN_WYHEdPQQMEcFcovTvT)1znZrt|u8TZr02!ulMDE?O)7PD_hUjzHU$iZplf0eL5 z9Smm<p;UaLAo{lj5tWSI5K-g(jl+HI^^D!DceciSy66|(CHCCW|J3Vx;<uQ@d+FdB Zt*vvbX0!R|Q&@8|`2vfGRlm&z0062KoVWl0 -- 2.26.2