Page 1260 - 5G Basics - Core Network Aspects
P. 1260

2                                                 Transport aspects


            For the case cm is not an integer, Cm(t) will vary between:

                                      f client  B server  8 /               f client  B server  8 /  
                                                         
                                     
                       C m  t) (   floor               and C m  t) (   ceiling                (D-14)
                                                                               f
                                       f
                                      server     M                          server     M     
            The remainder of cn and Cm(t) is:
                                                           8 M         
                                               c nD   c n  –    C m (t     )                       (D-15)
                                                             n          

            As only an integer number of cnD n-bit data entities can be signalled per server frame or multiframe, the
            integer value CnD(t) of cnD has to be used.


                                                                           
                                                
                              C nD (t )   int(c n )   8 M  C m (t    )   C n (t )    8 M  C m (t      )  (D-16)
                                                   n                       n           
                                        8  M      8 M
            CnD(t) is a number between  1      and        1 .
                                           n          n

            16M-byte granularity mapping
            Clause 20.5 specifies that the mapping of ODUk bits into the payload of an ODUCn.ts is performed with 128
             M-bit (16M-byte) granularity.
            The insertion of ODUk data into the payload area of the ODTUCn.ts multiframe at the mapper is performed
            in 16M-byte (or m-bit, m = 128  M) data entities, denoted as Cm(t). The remaining CnD(t) data entities are
            signalled in the justification overhead as additional timing/phase information.
                              cn     f      B        f       B         f      B    / 128 
                        c m     n       client    server         client    server      client    server       (D-20)
                                       
                                                                          
                                                                             
                              m        f server  m      f server  128 M      f server  M  
            As only an integer number of m-bit data entities can be transported per server frame or multiframe, the
            integer value Cm(t) of cm has to be used. Since it is required that no information is lost, the rounding process
            to  the  integer  value  has  to  take  care  of  the  truncated  part,  e.g.,  a  cm  with  a  value  of  10.25  has  to  be
            represented by the integer sequence 10,10,10,11.
                                                             f      B     / 128 
                                                            
                                         C m  t) (   int( c )  int   client    server            (D-21)
                                                     m
                                                              f server  M     
            For the case cm is not an integer, Cm(t) will vary between:
                                       f     B     / 128                   f      B     / 128 
                        C m  t) (   floor    client    server   and C m  t) (   ceiling     client    server       (D-22)
                                                         
                                        f server  M                         f server  M      
            The remainder of cn and Cm(t) is:
                                                             
                                                         128 M          
                                               c nD   c n  –    C m (t     )                       (D-23)
                                                            n           
            As only an integer number of cnD n-bit data entities can be signalled per server frame or multiframe, the
            integer value CnD(t) of cnD has to be used.
                                                   
                                                                               
                                              128 M                     128 M          
                              C nD (t )   int(c n )    C m (t   )   C n (t )    C m (t     )  (D-24)
                                                  n                        n           
                                        128  M       128M
            CnD(t) is a number between  1        and            .  1
                                            n            n




            1250
   1255   1256   1257   1258   1259   1260   1261   1262   1263   1264   1265