LTE中RLC分段、串接、重组及实现

1、1 将RLC SDU组成RLC PDU1.1 功能介绍发送UM RLC实体/AM RLC实体的发送侧将RLC SDU组成UMD PDU时，它们将：- 根据低层通知的特定发送时机以及由低层指示的RLC PDU(s)的总大小，将RLC SDU分段和/或串接成合适的RLC PDU（UMD PDU / AMD PDU）- 在RLC PDU中包含相应的RLC PDU头。Figure 1.1-1: RLC PDU Structure1.2数据结构和宏MIN_PDU_DATA_SIZE宏值， 表示PDU数据域元素的最小长度（>=1）。PDU_Header_Ext表示PDU头扩展部分的结构类型， 包含E

2、和LI位域。PDU表示一个RLC PDU结构的类型，包含的数据成员有：ü PDU头固定部分：UM和AM模式的PDU头不同，不同模式，包含各自的所有的位域；ü PDU头扩展部分：指向PDU_HeaderExt的指针；数据域：每个元素为一个字节的数组。 SDU_context: 表示SDU上下文的结构类型，并包含的数据成员有：BYTE *tbuff：指向存放RLC SDU的缓存器；SDU_leftsize：RLC SDU的长度，初始表示当前顺序从buffer里取出的RLC SDU的长度，每次组建后更新为剩下的RLC SDU的长度； Segment：表示RLC SDU分段的标识，

3、初始为0， 每次顺序取到一个RLC SDU， 如果标识为1，表示是一个RLC SDU分段；否则，表示是一个RLC SDU；PDU_context: 表示PDU上下文的结构类型，并包含的数据成员有：PDU_SN：下一个将要发送的UMD PDU的 SN。PDU_leftsize（PDU剩余大小）：表示组建当前RLC PDU时，该PDU还可以包含的字节数。初始值为此发送时机低层指示的RLC PDU的总大小；ElemNo: 该变量计数RLC PDU数据域元素的个数， 初始为0；每次组建一个RLC PDU结束，ElemNo更新为0。PDU_finish：表示组建一个RLC PDU结束的标识。 值为0，表

4、示正在组建一个RLC PDU； 值为1， 表示组建一个RLC PDU结束，也表示下一次将要组建一个新的RLC PDU。 初始为1，每次组建后，如果正在组建的RLC PDU未结束，更新为0；1.3算法流程1.4详细设计函数原型void Rlc_Pdu_Process(SDU_context &)描述RLC SDU分段或串接成RLC PDU输入SDU上下文：* tbuff 指向存放RLC SDU的缓存器SDU_leftsize RLC SDU的（剩余）长度segment 表示RLC SDU分段的标识输出SDU上下文（记录发送buffer的第一个RLC SDU的信息）1. 在MAC通知的发送

5、时机，初始化PDU上下文；2. 从发送Buffer里顺序取出一个RLC SDU，更新SDU上下文，如果PDU上下文里的PDU_finish1，该SDU将用于组建一个新的RLC PDU，转到3；否则，转到4；3. 创建一个新的RLC PDUØ 首先创建一个初始的RLC PDU；Ø 根据SDU上下文里的SDU分段标识segment确定PDU头固定部分的FI域的第一位：即如果segment为0，该RLC SDU是一个完整的SDU，FI第一位为0；否则，它是一个SDU分段，FI的第一位为1； Ø 并更新PDU_leftsize PDU_leftsize2（PDU头的固定部

6、分大小）。4. 比较PDU_leftsize与SDU_leftsize, 如果：1) PDU_leftsize < SDU_leftsize：SDU需要分段将RLC SDU分段，把长度等于PDU_leftsize的SDU前面分段拷贝到RLC PDU的数据域后面（正好映射到RLC PDU的最后一个数据域元素）；更新SDU上下文：SDU_leftsize = SDU_leftsize - PDU_leftsize； segment = 1；更新PDU上下文：PDU_leftsize = 0； ElemNo +； PDU_finish=1（PDU数据域组建完成）；确定RLC PDU头的固定部分

7、：FI域的后一位 = 1；如果RLC PDU 只有一个数据域元素（即ElemNo1），没有扩展部分， PDU头固定部分的E域 = 0； 否则，有扩展部分，PDU头固定部分的E域=1;确定SN域等于发送状态变量（VT（US）或VT（S）。对AM PDU，确定D/C域 = 1， RF域 = 0， P域（跟轮询机制有关）。确定RLC PDU头扩展部分：（该SDU前面分段在扩展部分没有E和LI；） 如果ElemNo > 1，扩展部分的最后一个E域为0，即扩展部分第(ElemNo-1）个E域=0。（第1到ElemNo个E域已经确定，这里只需确定最后一个E域） 如果ElemNo为奇数，在最后一个LI

8、后加四个填充比特，组建一个RLC PDU结束。实例：以下面的AMD PDU为例，假设这次分段结束后，当前的ElemNo k+1，那么，该SDU前面分段是RLC PDU的最后一个数据域元素，没有E和LI域；固定部分如上所述，其中FI=01或11， E=1； 扩展部分从第1个到第k-1个E = 1；LI1k 为各自数据域元素长度；第K个E = 0。2) PDU_leftsize = = SDU_leftsize：直接映射直接把该RLC SDU映射到RLC PDU的最后一个数据域元素（拷贝）。更新SDU上下文：SDU_leftsize = 0；segment = 0；更新PDU上下文：PDU_lef

9、tsize = 0；PDU_finish=1；ElemNo+。确定RLC PDU头的固定部分：FI域的后一位 = 0；如果RLC PDU 只有一个数据域元素（即ElemNo1），没有扩展部分， PDU头固定部分的E域 = 0； 否则，有扩展部分，PDU头固定部分的E域=1;确定SN域等于发送状态变量（VT（US）或VT（S）。对AM PDU，确定D/C域 = 1， RF域 = 0， P域这里不设置。确定PDU头扩展部分：（该RLC SDU在扩展部分没有E和LI；）如果ElemNo > 1， 扩展部分的最后一个E域为0，即扩展部分第（ElemNo-1）个E域=0。（第1到ElemNo个E域

10、已经确定，这里只需确定最后一个E域）如果ElemNo为奇数，在最后一个LI后加四个填充比特，组建一个RLC PDU结束。实例：以下面的UMD PDU为例，假设这次组建结束后，当前的ElemNo 1，那么， 该SDU是RLC PDU的唯一的一个数据域元素，没有扩展部分；固定部分如上所述，其中FI=00或10， E = 0； 3) PDU_leftsize > SDU_leftsize: SDU串接把该RLC SDU串接到RLC PDU的当前最后的数据域元素的后面。更新PDU上下文： PDU_leftsize PDU_leftsizeSDU_leftsize； Ø 如果 PDU_l

11、eftsize + (k%2)*0.5 1.5 > MIN_PDU_DATA_SIZE，（1.5是PDU头扩展部分一个E和LI域的字节数， 当k= ElemNo是奇数是，0.5是当前补充比特的字节数，MIN_PDU_DATA_SIZE是初始定义的宏) 且Buffer不为空，那么还可以继续串接RLC SDU来组建该RLC PDU，- 更新PDU上下文： ElemNo；PDU_finish = 0；PDU_leftsize PDU_leftsize(1.5* ElemNo(ElemNo2)*0.5) v ElemNo奇数PDU_leftsize PDU_leftsize（1.5* ElemN

12、o +0.5）; v ElemNo偶数PDU_leftsize PDU_leftsize1.5* ElemNo；- 确定RLC PDU头的固定部分：确定PDU头固定部分的E为1；确定SN域等于发送状态变量（VT（US）或VT（S）；对AM PDU，确定D/C域 = 1； RF域 = 0； P域与轮询机制有关。- 确定PDU头扩展部分：PDU头的扩展部分包括第ElemNo个PDU_Header_Ext对象， 即一个E和LI k域（kElemNo）；确定LIk SDU_leftsize（或者用偏移量来表示）；确定扩展部分的上一个（第k-1个）的E域为1；- 更新SDU上下文：SDU_leftsiz

13、e = 0；segment = 0；- 循环回到 2， 即继续顺序取出发送Buffer里第一个RLC SDU， 开始继续串接该RLC SDU或一部分来组成RLC PDU；实例：以下面的AMD PDU为例，假设这次串接结束后，当前的ElemNo k1，那么，扩展部分新增的E和LIk+1是当前串接的SDU的E和LI域；固定部分如上所述，其中E=1； 扩展部分第k个E1； 第（K+1）个E = 0；LIk+1 SDU_leftsize ；Ø 否则，如果发送Buffer为空，或者0< PDU_leftsize + (k%2)*0.51.5 < MIN_PDU_DATA_SIZER

14、LC PDU后面不能串接一个RLC SDU，该SDU是RLC PDU的最后一个数据域元素，不需要继续串接，- 更新PDU上下文： PDU_finish = 0；PDU_leftsize 0；- 更新SDU上下文：SDU_leftsize = 0；segment = 0；ElemNo+- 确定RLC PDU头的固定部分：确定FI域的后一位为 0 ；如果RLC PDU 只有一个数据域元素（即ElemNo1），没有扩展部分， PDU头固定部分的E域 = 0； 否则，有扩展部分，PDU头固定部分的E域=1;确定SN域等于发送状态变量（VT（US）或VT（S）。对AM PDU，确定D/C域 = 1， R

15、F域 = 0， P域这里不设置。- 确定PDU头扩展部分：（该RLC SDU在扩展部分没有E和LI域；）如果ElemNo > 1，扩展部分的最后一个E域为0，即扩展部分第ElemNo-1个E域 = 0 ；（第1到ElemNo-2个E域已经确定，这里只需确定最后一个E域，所有的LI域已确定）- 如果ElemNo为奇数，在最后一个LI后加四个填充比特，组建一个RLC PDU结束。以下面的AMD PDU为例，假设这次串接结束后，当前的ElemNo k， 那么，扩展部分没有当前串接的SDU的E和LI域；固定部分如上所述，其中FI00或10；E=0； 扩展部分第k个E1；5. 将组建结束的RLC

16、PDU递交给低层， 同时更新发送状态变量加1，结束。1.5 AMD PDUv 什么时候用到AMD PDU分段？当重传AMD PDU的大小大于本次发送通知中对MAC SDU长度的要求时，可以对AMD PDU进行再分段，形成AMD PDU分段。 v 结构再分段只是对数据域的分段，AMD PDU分段中头的部分除了RF域、新增的LSF域和SO域外都与再分段前的AMD PDU相同。 2 将RLC PDU重组为RLC SDU2.1 接收UM RLC实体SDU重组2.1.1 模块介绍2.1.1.1功能需求在接收UM RLC实体接收UMD PDU后，它：- 将完成重排序的UMD PDU（不考虑已检测到丢失的R

17、LC PDU）重组RLC SDU，并将完成重组的RLC SDU按序递交给高层（先重排序，再重组）- 由于某个RLC SDU的一个UMD PDU在低层丢失，导致收到的UMD PDU不能重组为RLC SDU，则丢弃这些UMD PDU2.1.1.2 算法描述针对当前接收Buffer里已重排序的UMD PDUs按序循环进行重组：（重组是按照SN从小大到的顺序）Ø 从最小的SN的UMD PDU开始， 循环遍历下一个SN（假设SNx）的UMD PDU。 每次循环，顺序遍历UMD PDU的数据域元素，并把该数据域元素和上一次重组保留的RLC SDU分段（如果有的话）一起进行重组（按照SN从小大到的

18、顺序）：² 如果重组后的RLC SDU之前没有递交过，将完成重组的RLC SDU按序递交给高层； ² 将由于某个UMD PDU在低层丢失而不能重组为RLC SDU的PDU丢弃（丢失的PDU为SDU的前面部分分段或中间部分分段）； ² 将没有完成重组的RLC SDU分段保留（SDU的后面部分分段没有收到）。2.1.2 数据结构设计PDULeft: 结构类型，表示每次重组之后，没有完成重组的RLC SDU的相关信息 ，用于下一次按序重组，包含下面的成员：SN_Left： 整型变量，记录当前没有完成重组的RLC SDU包含的PDU的最大的SN，初始值为-1； 若某次重组

19、之后，当前被重组的UMD PDU的数据域有剩余，SN_Left更新为该PDU的SN；SDU_Left： 数组，保留重组之后剩余的RLC PDU数据部分（即没有完成重组的RLC SDU分段），也就是0个、1个或多个SDU分段。初始为空数组。注：PDULeft对象设计为静态对象。2.1.3 算法流程2.1.4 详细设计函数原型void Rlc_ Reassemble_UM_Process(PDU_Left &，SN_MIX, SN_MAX)描述将RLC PDU重组成RLC SDU 输入PDU_Left：SN_LeftSDU_LeftSN_MIX: 要重组的最小的SNSN_MAX：要重组的最

20、大的SN输出PDU_Left当前接收Buffer里已重排序的UMD PDU(s)最小的SN = SN_MIX； 循环对SN=x的UMD PDU进行重组，循环直到接收Buffer里已重排序的最后一个SN（SN= SN_MAX）的UMD PDU重组后结束； PDULeft对象保留上一次重组后没有完成重组RLC SDU的信息。看下面的例子： 假设开始重组SN=x的UMD PDU，此时：第1步：判断接受Buffer里SN = x的UMD PDU是否存在，Ø 如果不存在，该UMD PDU 在低层丢失，那么： 丢弃PDULeft对象保留的没有完成重组的RLC SDU，即清空SDU_Left； 更

21、新PDULeft对象的SN成员 = -1； x = x+1;（下一个SN）循环回到第1步；Ø 如果存在， 继续第2步；第2步：检查SN=x的UMD PDU头固定部分FI和E域，如果：- 如果E = = 0，那么该UMD PDU只有一个数据域元素，又Ø 如果FI的第一位为1，那么该UMD PDU的第一个数据域元素是一个SDU的后面分段(前面分段和后面分段根据2个SDU分段在原来的SDU中的相对位置而言)， 判断PDULeft对象的成员SN， ² 如果SN != x1，包含该SDU的前面分段的UMD PDU已经丢失，那么：直接丢弃该UMD PDU；更新PDULeft对

22、象： 如果SN != -1, 丢弃的SDUs成员保留的数据；然后SN = -1；x = x+1;循环回到第1步；² 否则SN = = x1， PDULeft对象的SDUs成员保留了该SDU的前面分段，那么：去掉PDU头， 将这2个SDU分段按序重组（SN升序）为RLC SDU； 这时， l 如果FI的后一位为0， 那么：更新PDULeft对象：SN = -1； SDUs 清空；将完成重组的RLC SDU按序递交给高层；l 否则FI的后一位为1，那么更新PDULeft对象：SN = x； SDUs = 当前重组后没有完成重组的RLC SDU；x = x+1;循环回到第1步；Ø

23、 否则，FI的第一位为0，那么：去掉PDU头，把PDU的数据域直接重组为RLC SDU；这时，² 如果FI的后一位为0，那么：将该完成重组的RLC SDU按序递交给高层；更新PDULeft对象：SN = -1； SDU_Left 清空；² 否则FI的后一位为1，那么：更新PDULeft对象： SN = x； SDUs = 当前重组后没有完成重组的RLC SDU；x = x+1;循环回到第1步；- 否则E1，该UMD PDU有多个数据域元素， 那么：(一) 遍历PDU头扩展部分第一个数据域元素的E和LI域，该数据域元素长度 = LI； Ø 如果FI的第一位为1，该U

24、MD PDU的第一个数据域元素是一个SDU的后面分段，那么：判断PDULeft对象的成员SN：² 如果SN ！= x-1，包含该SDU的部分前面分段的UMD PDU已经丢失，那么：直接丢弃该UMD PDU的第一个数据域元素；更新PDULeft对象： 如果SN != -1, 丢弃SDUs成员保留的数据；然后SN = -1；² 否则SN = =x-1， PDULeft对象的SDUs成员保留了该SDU的前面分段，那么：将这2个SDU分段按序重组为RLC SDU；将完成重组的RLC SDU按序递交给高层；更新PDULeft对象：SN = -1； SDUs 清空； 此时，上面的例子的

25、变化：Ø 否则FI的第一位为0，那么：把第一个数据域元素直接重组为RLC SDU；将完成重组的RLC SDU按序递交给高层；(二) 检查当前遍历的E域， 循环执行下面的操作：Ø 如果E= =0，该UMD PDU只剩下的最后一个数据域元素，那么：去掉PDU头，把PDU的最后一个数据域元素直接重组为RLC SDU；² 如果FI的后一位为0，那么：将该完成重组的RLC SDU按序递交给高层；更新PDULeft对象：SN = -1； SDUs 清空；² 否则FI的后一位为1，那么：更新PDULeft对象： SN = x； SDUs = 当前重组后没有完成重组的R

26、LC SDU； x = x+1;循环回到第1步；最后，关于上面的例子：RLC SDU 1、RLC SDU 2、RLC SDU 3 提交给高层；Ø 否则E= =1，该UMD PDU还剩下多个数据域元素，那么： 按序遍历PDU头的扩展部分下一个数据域元素的E和LI域， 下一个数据域元素长度 = LI；直接把下一个数据域元素重组为一个完整的RLC SDU；更新PDULeft对象：SN = -1； SDUs 清空；将该完成重组的RLC SDU按序递交给高层；循环回到（二）。第3步，循环结束，返回。2.2 AM RLC实体接收侧SDU重组2.2.1 模块介绍2.2.1.1功能需求AM RLC实

27、体的接收侧收到RLC数据PDU后， 它：- 将完成重排序的RLC数据PDU（完整的PDU）重组成RLC SDU，并将完成重组的RLC SDU按序递交给高层2.2.1.2 算法描述将落在接收窗外的SN所对应的AMD PDU的任何字节分段和SN = VR(R)的AMD PDU的连续字节分段进行重组：从最小SN的AMD PDU或AMD PDU分段开始， 循环遍历下一个SN的AMD PDU或AMD PDU分段。每次循环，有下面2种情况：Ø 对AMD PDU：根据E域和LI域，顺序遍历AMD PDU的数据域元素，把该PDU的数据域进行重组，重组时去掉RLC头：² 如果重组后的RLC

28、SDU之前没有递交过，将完成重组的RLC SDU按序递交给高层； ² 将没有完成重组的RLC SDU保留， 等到下一次继续重组。Ø 对AMD PDU分段：首先根据LSF域和SO域将AMD PDU分段重组为AMD PDU，然后再根据同上把AMD PDU重组为RLC SDU。Ø 按当前遍历的 相同SN的AMD PDU分段在原AMD PDU中的顺序， 把该AMD PDU的可以被重组的连续的字节分段进行重组，重组时去掉RLC头。2.2.2 数据结构设计PDULeft: 结构类型，表示每次重组之后，没有完成重组的RLC SDU的相关信息 ，用于下一次按序重组，包含下面的成员

29、：SN_Left： 整型变量，记录当前没有完成重组的RLC SDU包含的PDU的最大的SN，初始值为-1； 若某次重组之后，当前被重组的UMD PDU的数据域有剩余，SN_Left更新为该PDU的SN；SDU_Left： 数组，保留重组之后剩余的RLC PDU数据部分（即没有完成重组的RLC SDU分段），也就是0个、1个或多个SDU分段。初始为空数组。注：PDULeft对象设计为静态对象。AMD_SegContext: 表示AMD PDU分段上下文， 包含下面的变量：SN： AMD PDU分段的SN， 初始为-1；SO： 没有被全部重组的AMD PDU分段在原AMD PDU中的偏移量；初始为

30、0， 每次重组之后更新；CSO（字节分段偏移）： 没有被重组的第一个字节分段在原AMD PDU中的偏移，初始为0；LISN： 没有被重组的连续字节分段的所有的LI中，顺序最小的LI的序号； 初始为1； LISN= 0表示这些连续字节分段是AMD PDU最后一个数据域元素； LISN = k（正整数）， 表示这些连续字节分段对应的顺序最小的LI的序号。注：AMD_SegContext对象设计为静态对象。2.2.3 算法流程2.2.4 详细设计落在接收窗外的最小的SN = x， 循环开始对SN=x的 RLC PDU进行重组，循环结束条件： SN= =VR(R); PDULeft对象初始化，以后保留

31、上一次重组后没有完成重组RLC SDU的信息；AMD_SegContext 对象初始化，以后记录上一次重组后AMD PDU分段的上下文信息。第1步： 对SN x的RLC PDU（s），执行：1. 如果RLC PDU头RF域1，表示该RLC PDUs是一些AMD PDU分段，那么：l （1）执行循环，循环结束条件为LSF = 1，LSF初始为0， 每次循环，循环体里执行：n （按SO升序）得到对应的AMD PDU分段；n （按序）把当前AMD PDU分段的数据域串接，组成AMD PDU的数据域；n LSF = 当前AMD PDU分段头的LSF域；n 循环回到（1）；l 加上该AMD PDU的头，

32、RF域修改为0， 接着转到第2步对该AMD PDU进行重组。附注：下面红色的部分是上面“1“的另一种方法：（按照AMD PDU分段重组）1. 如果RLC PDU头RF域1，表示这些RLC PDUs是一些AMD PDU分段， 那么：检查AMD PDU分段头E域：Ø 如果E=0， 即SNVR(R)的原AMD PDU只有一个数据域元素，那么：l 执行循环，循环结束条件为LSF = 1，LSF初始为0， 每次循环，循环体里执行： （按SO升序）得到对应的AMD PDU分段；（按序）把当前AMD PDU分段的数据域串接，重组为RLC SDU； LSF = 当前AMD PDU分段头的LSF域；l

33、 接着，检查分段头FI域：² 如果FI的第一位为1，那么重组后的RLC SDU是一个SDU的后面分段， 显然PDULeft对象的SDUs成员保留了该SDU的前面分段，那么：将这2个SDU分段按序重组为一个RLC SDU； 这时， l 如果FI的后一位为0， 那么：更新PDULeft对象：SN = -1； SDUs 清空；将完成重组的RLC SDU按序递交给高层；l 否则FI的后一位为1，那么：更新PDULeft对象：SN = x； SDUs = 当前重组后没有完成重组的RLC SDU；² 否则，FI的第一位为0，且l 如果FI的后一位为0，那么：将该完成重组的RLC SDU

34、按序递交给高层；更新PDULeft对象：SN = -1； SDUs 清空；l 否则FI的后一位为1，那么：更新PDULeft对象： SN = x； SDUs = 当前重组后没有完成重组的RLC SDU；l 更新AMD_SegContext对象：（初始值）² CSO = 0；² SN = -1；² LISN = 1；² SO= 0；l x = x+1;l 循环回到第1步；Ø 否则E域=1，即该SN的AMD PDU有多个数据域元素，那么：n 检查AMD_SegContext对象的SN是否指示接收窗外最小的SN：² 如果SN = = x，

35、即在上次重组过程中，该RLC PDUs的一部分连续的字节分段已经被重组为RLC SDU，那么：l 如果LISN = 0，即剩下的RLC PDUs对应于原AMD PDU的最后的数据域元素，那么：设置循环变量E=0；（转到（1）² 否则， SN=x的RLC PDUs不是最小SN的AMD PDU分段。n （1）执行循环：循环结束条件为 E = = 0，（循环变量E初始为1），在循环体里，执行：l 根据AMD_SegContext对象的LISN，找到AMD PDU分段头扩展部分的第LISN个E和LI域；l 更新循环变量E = 第LISN个E域；l 计算得到长度为LI的连续字节分段，返回当前的

36、AMD PDU分段的SO；（计算时， 用到SO和AMD PDU分段长）l 检查CSO， 判断这些连续的字节分段是否从第一个字节分段开始的，即：² 如果CSO = =0 且分段头FI的第一位为1， 即这些第一个连续字节分段是一个SDU的后面分段， 显然PDULeft对象的SDUs成员保留了该SDU的前面分段，那么：将这2个SDU分段按序重组为RLC SDU；将该完成重组的RLC SDU按序递交给高层；² 否则，CSO != 0 或FI的第一位为0，那么：把这些连续字节分段重组为RLC SDU；将该完成重组的RLC SDU按序递交给高层；l 更新PDULeft对象：SN = -

37、1； SDUs 清空；l 更新AMD_SegContext对象： u CSO = CSO +LI；u 如果E=1， LISN +；否则LISN = 0；u 如果LI = = length CSO，SO=当前AMD PDU分段的SO+分段长度；否则（LI < length CSO）SO=当前AMD PDU分段的SO；l 循环回到（1）；n 循环结束后，即循环变量E = 0，那么剩下的RLC PDUs正好对应于原AMD PDU的最后的数据域元素， 那么：l 执行循环，循环结束条件为LSF = 1，LSF初始为0， 每次循环，循环体里执行： （按SO升序）得到对应的AMD PDU分段； （按序

38、）把当前AMD PDU分段的数据域串接，从而重组为RLC SDU； LSF = 当前AMD PDU分段头的LSF域；l 继续检查分段头FI域² 如果FI的后一位为0，那么：将该完成重组的RLC SDU按序递交给高层；更新PDULeft对象：SN = -1； SDUs 清空；² 否则FI的后一位为1，那么：更新PDULeft对象： SN = x； SDUs = 当前重组后没有完成重组的RLC SDU；l 更新AMD_SegContext对象：（初始值）² CSO = 0；² SN = -1；² LISN = 1；² SO= 0；l x

39、= x+1;l 循环回到第1步；2. 如果RLC PDU头RF域=0，检查SN=x（x<VR(R)）的AMD PDU头FI和E域， 即：Ø 如果E = = 0，该AMD PDU只有一个数据域元素，又² 如果FI的第一位为1，那么该AMD PDU的第一个数据域元素是一个SDU的后面分段， 显然PDULeft对象的SDUs成员保留了该SDU的前面分段，那么：去掉PDU头， 将这2个SDU分段按序重组（SN升序）为RLC SDU； 这时， l 如果FI的后一位为0， 那么：更新PDULeft对象：SN = -1； SDUs 清空；将完成重组的RLC SDU按序递交给高层；l

40、 否则FI的后一位为1，那么更新PDULeft对象：SN = x； SDUs = 当前重组后没有完成重组的RLC SDU；² 否则，FI的第一位为0，那么：去掉PDU头，把PDU的数据域直接重组为RLC SDU；这时，l 如果FI的后一位为0，那么：将该完成重组的RLC SDU按序递交给高层；更新PDULeft对象：SN = -1； SDUs 清空；l 否则FI的后一位为1，那么：更新PDULeft对象： SN = x； SDUs = 当前重组后没有完成重组的RLC SDU；x = x+1;循环回到第1步；Ø 否则E1，该UMD PDU有多个数据域元素， 那么：(一) 遍历

41、PDU头扩展部分第一个数据域元素的E和LI域，该数据域元素长度 = LI； 然后判断：² 如果FI的第一位为1，该UMD PDU的第一个数据域元素是一个SDU的后面分段， 显然PDULeft对象的SDUs成员保留了该SDU的前面分段，那么：将这2个SDU分段按序重组为RLC SDU；将完成重组的RLC SDU按序递交给高层；更新PDULeft对象：SN = -1； SDUs 清空；² 否则FI的第一位为0，那么：把第一个数据域元素直接重组为RLC SDU；将完成重组的RLC SDU按序递交给高层；(二) 检查当前遍历的E域， 循环执行下面的操作：Ø 如果E=0，该

42、AMD PDU只剩下的最后一个数据域元素，那么： 把PDU的最后一个数据域元素直接重组为RLC SDU；² 如果FI的后一位为0，那么：将该完成重组的RLC SDU按序递交给高层；更新PDULeft对象：SN = -1； SDUs 清空；² 否则FI的后一位为1，那么：更新PDULeft对象： SN = x； SDUs = 当前重组后没有完成重组的RLC SDU； x = x+1;循环回到第1步；Ø 否则E=1，该UMD PDU还剩下多个数据域元素，那么： 按序遍历PDU头的扩展部分下一个数据域元素的E和LI域， 下一个数据域元素长度 = LI；直接把下一个数据域

43、元素重组为一个完整的RLC SDU；将该完成重组的RLC SDU按序递交给高层；更新PDULeft对象：SN = -1； SDUs 清空；循环回到（二）。第2步： 尝试对SN = VR(R)的未完整接收的AMD PDU的连续字节分段进行重组：有下面的例子：对SN = VR(R)的未完整接收的AMD PDU的连续字节分段进行重组， 第3个分段还没有接收到。- 如果没有接收到SNVR（R）的AMD PDU任何字节分段， RLC SDU重组结束，返回。- 否则， 尝试对 从AMD PDU第一个字节分段开始的连续的字节分段进行重组，第一个不连续的字节分段之后的所有字节分段不进行重组，那么：检查所有的A

44、MD PDU分段头的SO： Ø 如果最小的SO > 0，不对该AMD PDU的任何字节分段进行重组， RLC SDU重组结束，返回。Ø 如果最小的SO = = 0，那么：检查AMD PDU分段头E域：² 如果E=0， 即SNVR(R)的 AMD PDU只有一个数据域元素， 显然这些字节分段不能被重组，那么：RLC SDU重组结束，返回。² 否则E=1，即SNVR(R)的 AMD PDU有多个数据域元素，那么：l 计算未被重组的连续AMD PDU分段的总长度（设为length）；l （1）执行结束条件为E=0的循环（表示遍历到AMD PDU的最后的未

45、完整接收的数据域元素），在循环体里，执行：n 得到AMD PDU分段头扩展部分的第LISN个E和LI域；n 更新循环条件的E=当前E域；n 比较LI 和 length CSO，即：Ø 如果LI =< length - CSO, 从CSO开始长度为LI的连续字节分段可以被重组， 那么： 计算得到长度为LI的连续字节分段，以及当前的AMD PDU分段的SO² 如果CSO = =0 且分段头FI的第一位为1， 即这些第一个连续字节分段是一个SDU的后面分段， 显然PDULeft对象的SDUs成员保留了该SDU的前面分段，那么：将这2个SDU分段按序重组为RLC SDU；将该完成重组的RLC SDU按序递交给高层；² 否则，CSO != 0 或FI的第一位为0，那么：把这些连续字节分段重组为RLC SDU；将该完成重组的RLC SDU按序递交给高层；n 更新PDULeft对象：SN = -1； SDUs 清空；n 更新length：length = length LI；n 更新AM