Lecture 08

IIT Kanpur July 201
20 followers
Jul 26, 2024
[Music]
okay so we learned about CRC and then
what we are going to see another
important block of this physical aay
Crossing okay which is the transport
block seg mentation what is it we are
going to understand and that's what this
lecture is about and this is this part
section of this of the standard okay go
back and read the standard that's my
advice in each class
okay recapturing just to get back on
track okay Ma has sent one transfer
block then I forgot to tell you in the
last class that whatever processing we
discuss for transport block one is the
same processing is applicable for the
second transport block also nothing
changes okay exactly the same processing
then uh now what is the job of physical
layer physical layer has a transfer
block which it needs to like transmit on
air okay so this these are the tasks
which physical L needs to perform and we
learned about the first task which it
did that was CRC calculation and
attachment okay so it calculated the CRC
right now according to this chain what I
showed you and I'm writing this as a
rudimentary okay because there are lot
of other blocks which will get added to
this transceiver chain okay but this is
the heart of the physical 5G physical
processing additional modules to support
this processing will get added okay and
why are these additional modules coming
because of the Practical implementation
constraints mostly so we'll see that
according to this chain once you have
attached the CRC do the ldpc encoding
doesn't happen so there is one
additional block which comes in between
and we are going to study that in this
class that is called transport block
segmentation block now what is this
segmentation why is it required how is
it done this class and the next class
now the maximum input code block size
which 5G ldpc encoder can process is
8448 another flavor also in the standard
which can process only of 3840 so for
this class we assume that this the
maximum input block which ldpc can
process is
8448 and the standard denotes that this
number as kcb that's how you have now
keep this in mind 8448 of course it can
process data lesser than that the size
can be of lesser than that okay but it
it's not that it can process any size
lesser than this it cannot process 8447
size okay there are certain sizes which
are defined in the standard which this
ldpc encoder can process okay but the
maximum is this have I made myself clear
now we saw that the transport block size
can be much larger than the ldpc code
block size I'll again break back those
numbers suppose a user is allocated this
MCS 26 and 275 prbs 320,000 bits what is
the maximum 8448 so what did you do got
the transport block physically appended
the CRC so you cannot straight away feed
this plus CRC to the ldpc encoder but
because ldpc encoder is not designed to
process such huge transport blocks and
we'll understand why okay why they done
like that now how do you handle this
situation okay which you're going to hit
upon very often basically to segment it
segment the transfer block basically
slice the transfer block into smaller
sizes okay and when we do that okay when
the transfer block length plus 24 bit
CRC which you have appended which is
denoted as B in the standard okay these
are I'm not introducing these notations
I'm taking these notations from the
standard so this is this alphabet which
is defined okay if this is greater than
kcb you should segment it then the
obvious question comes okay why not
limit the maximum input code block size
of ldpc encoder to the largest transfer
block size what am I saying here what is
this bullet saying here that why not
make this as this plus 24 right it
should be able to you can design ldpc
encoder so that it can process this
then you don't have to basically do this
segmentation I can design why limit
myself to 8448 I can have 319 874 plus
24 ldpc encoder can be designed to
process that also okay now that's where
these like practical implementation
constraints come into picture and
they're very obvious also okay if you're
an engineer who's implementing this kind
of system you'll see that okay first
fact which I not clearly articulated or
LLY told is basically the decoding
complexity increases with increase in
code block length right so if you
increase if your code block is of say
this size your ldpc decoder which you
will Design will require enormous amount
of implementation complexity you might
not be able to implement in real time in
a device also in fpg that's the first
constraint so that your system actually
works second one if you segmented like
this okay so what can you do okay you
have if you want to basically you have
segmented you need to like basically
decode each one of this segmented code
block at the receiver now you can have
this multiple ldpc decoders running in
parallel to decode each one of this
encoded code block at the deceiver if
you don't do this what will happen you
cannot do this okay that you'll have to
design an extremely complex ldpc decoder
which you cannot run in parall there
will be only one decoder here depending
on how many segmented code blocks you
get okay if there is a time constraint
you can basically run these decoders in
parall get done with the decoding reduce
the delay and these factors actually
like help in designing Ur LC compliant
systems also okay that you can decode
this data in parall and reduce the
decoding delay so that's the primary
reason now I will so if you see this
I'll explain this picture completely now
what happens here is that you gotten
this transfer block plus you have
calculated this
CRC right okay then there will be this
if B plus the B is greater than the kcb
right it has to be segmented let's
assume that that is happening otherwise
you don't have to segment you don't have
to study this so now what happens here
is that this transfer Block Plus CRC
gets segmented into multiple code block
this is basically each one of this
segmented transport block is called a
code block okay because this going
inside the encoder that's the
name so how many such code blocks are
there we denote it by C that's again you
see this the C is the total number of
segmented code block again this standard
notation okay I'm not going to repeat it
from now all these notations are defined
in the standard okay we will of course
like introduce them as and when they are
required now what happens is okay what
does this mean if C is equal to 1 what
is the meaning of c is equal to one then
there's no segmentation correct because
if code block is only one code block
after you're getting after segmenting it
what does that mean that b is less than
kcb otherwise so if C is equal to 1 okay
there the transport block doesn't get
segmented there is only this CRC why I'm
writing this it'll become clear
immediately if C is greater than one
what am I saying here that if the
transport block gets segmented then one
additional what are this cbcc they
called code block CRC of length again 24
is attached to each of this code block
that's how standard right it if you'll
see I'll give you the flowchart also as
it is given in the standard okay but we
are first like decoding it and writing
it in plain English okay so if you're
not segmenting the code block then you
will not append any additional CRC if
you're not segmenting the transport
block let then you will not append any
additional
CRC if you are segmenting the transport
block and generating these code blocks
okay then you will append this
additional CRC to each of this code
block you see this CRC CRC and
CRC right
okay then there is something called this
filler bit they are also added I will
not explain it now okay you'll have to
wait for the next class to come then
I'll be able to explain why these filler
bits are added okay we will revisit this
but for segmentation okay that's what is
happening you have segmented the
transport block into multiple code
blocks then then you are adding this
extra 24 bit cc to each one of them now
obvious questions okay that there is a
CRC already a CRC why are appending
additional CRC okay we are going to
discuss that and we going to discuss how
this code block transport block is
segmented also the reasons for appending
CRC to the segmented code block okay so
as we just said CRC is computed for each
segmented code block along with the
transfer block right so there is now how
how are we distinguishing there is this
CRC this is called
tbcc transfer block CRC okay because it
is appended to the transfer block this
is called cbcc because it is appended to
the code block that's how I wrote it
cbcc tbcr okay the name tells everything
okay so you don't have to remember it it
comes automatically
okay now so why are we the first
question is okay that why are we
appending this CRC to each of the
segmented code block right so what does
it allow it allows error detection at
the segmented code Block Level what is
what is this telling you you can check
each of the segmented code
block right and then then come to know
that whether this code block is an error
or not so what could happen that only
few of these segmented code code blocks
are in
error right so physical layer will ask
for retransmission of only those code
blocks why should it ask for the
retransmission of other code blocks or
the whole transfer block so that's why
this
additional cbcc is appended to each code
block okay because every extra
retransmission is going to cause use of
bandwidth which can be allocated for
another user or which can be allocated
for fresh transmission of data okay
right so you don't want to do that
that's why the cbcc is appended okay now
then you could ask this
question that why do you need tbcc when
there is a cbsc RC correct okay now if
you know that like each transport each
code block is error free right what are
you going to do so how will this what
will happen finally at the receiver so
you have segmented the transfer block at
the receiver you're going to check each
one of this CRC of each of this code
block and then you you'll remove this
CRC and then put them
together correct if all of them are
correct then you're going to put all
these C code blocks together and the at
the end there'll be this CRC
tbcc right okay then the transport tbcrc
also needs to be
validated
okay correct okay right now if cbcc can
guarantee you that like all of them are
without error that's when you will put
them together correct why do you need
this transer block CRC can ask this
question right additional 24 bits but it
has its use okay and what are the use is
this duplication of effort
because according to the question we
just asked like this is looks like it is
like additional 24 bit CRC which might
not be required okay not like that okay
so what happens
is that different polinomial are used
for transer Block CRC and the code block
CRC they're not the same
polinomial okay so if cbcc is not able
to to catch some errors there's a
probability that tbcrc will be able to
catch those
errors right it is not that these
crc's cannot make mistakes you're just
trying to make sure that this mistakes
get caught at some level and just to
tell you even this is the physical layer
level okay even the Mac layer does his
own like arq okay is sits on top of
hybrid arq okay okay so ma layer is
going to do its own checking so now this
is basically so that's you're seeing
that there like two levels of checks
being done to make sure that there are
no errors right and how is it being made
sure we are using two different
polinomial okay for
tbcc and the code block segmented code
block CRC right okay so we understand
why two different levels of CRC but if
there is only one code block then there
is only one CRC so this allows detection
of residual errors so it is not
duplication of efforts standards are
kind of optimized okay now before we see
how do you actually uh segment a
transport block correctly okay I'll tell
you how it is not segmented okay what is
the wrong way of segmenting a transfer
block just to make us understand that
the logic behind segmenting and the
transfer block The Way It Is defined in
the standard so we are going to use this
uh system configuration throughout
today's class okay so what are we saying
user is allocated 70 resource blocks
prbs okay you can write a physical
resource block or resource block this is
used interchangeably okay over a slot of
14 symbols okay now and it is given 16
quam MCS 16 okay if look at the table
which is defined it is 16 quam and that
is the code rate of 642 right so based
on this the transfer block size can be
calculated okay which we'll do that in
this class but as of now I'm giving you
this number okay so based on this
configuration right the transfer block
will be of size 28168 bits now what
happens is as soon as it comes transform
block CRC is appended which is 24 bit so
what is this B what is be this plus this
right there's a number which is this
plus this of course we know that it has
to segmented so then this what does it
include B includes
288 168 database and 24bit transform
block
CRC okay now what happens here okay so
what do we remember here that the
maximum code block size which the ldpc
encoder can encode is 8448 bits then how
do you a simple way of segmenting this
uh trans lock is to do it like this now
you can divide
28192 by 8448 3 will be the quotient and
this will be the remainder so what are
we saying here that you can have three
code blocks of size
8448 and the last code block of size
2848 looks like a feasible way of doing
it because what are you guaranteed okay
you guaranteed that maximum code block
is of size
8448 right and there's another code
block of size 2848 you can encode it but
as the title says there's a wrong way of
doing it okay why is it wrong way what
happens here is you look at this three
code blocks are of size 8448 and one is
of a much lesser size than this 8448
okay let me tell it explicitly that
larger the code block size okay better
will be the performance of ldpc decoder
which essentially means that this is
called like the coding gain okay where
in code block is of larger size okay you
will be able to decode it at a lower SNR
relatively lower SNR and so the SNR
required to decode this will be slightly
higher than the SNR required to decode
this so what is happening here if you
decode it like this you are penalizing
this fellow okay because this SNR is
required is higher okay and it is like
if this syst stuck transport block is
stuck at the physical layer if stuck
means if you're not able to decode this
okay right transport block decoding is
not complete okay right so what how do
you want to how would you like to like
segment it then okay so that like you're
not the segmentation is not unfair to
any of these segmented code block
obvious common sense is that you would
like to make sure that transport block
is divided into equal size blocks so
this is what we are going to learn in
not in today's class but in the next
class that how do you actually segmented
so that it gets segmented into equal
size code blocks and the reason here is
that the BL performance is limited by
the smallest transport block size okay
now you have to make sure that all of
them pass the CRC all of them are like
detected error free we need to to
segment them into equal sizes so what we
have learned till now is basically these
two lectures where we have like
understood the some bit of the physical
air processing is that there is this the
two transport blocks which come to the
physical layer maximum of two whatever
processing we do for One Transport layer
it is applicable to the second transport
layer also okay now as soon as the
physical layer gets the transfer block
the first step is append the transfer
block CRC right okay and then if this
transport Block Plus CRC is greater than
kcb which is the maximum length which
this ldpc encoder can process you need
to segment it okay and the segmentation
is defined in the standard in such a way
that all these segmented code blocks
have more or less than the equal size
okay and this is the reason okay now
once these code blocks are segmented
then what do you do you append code
block CRC right to each of this
segmented code block and what we
understood was that this segmentation
also this addition of this CRC is not a
duplication of effort and what is
happening here is that the code block
CRC has a different Pol nomial then the
transport block CRC so if the code block
CRC is not able to cast some errors
there is a hope that this transport
block CRC will be able to catch the
residual errors and you will be you'll
your transport block will be error free
okay so that's what is the content of
this class so we'll continue it in the
next class thank you
[Music]
[Music]
[Music]
