Lecture 10

IIT Kanpur July 201
20 followers
1 Video View·Jul 26, 2024
[Music]
okay welcome so we'll finish discussing
this transport block segmentation in
this class okay so that's the idea and
we'll cover this whatever is required
for us to like understand this ldpc
encoding and ldpc encoding happens okay
so this is the reference for for this
part okay a standard reference now what
are we trying to do recapture of our
problem okay so this is the transfer
block which has come from the Mac okay
transport block CRC is appended then
this needs to be segmented okay and we
saw
this right okay that b is kcb is greater
than kcb B Das becomes B plus C into L
okay that's the effective payload length
Okay and B is less than kcb then B Das
is B okay right and this is effective
payload length and for our example we
get c equal to four okay right and B Das
is equal to this what is the difference
between this and this is basically extra
96 bits okay right so this is the effect
payload you want to transmit you can
segment it into by4 okay and that's
where we actually digressed right you
want it's not done like this okay we
digressed and we started understanding
how ldpc encoder works right and what
did I tell there what is the crucial
information we need to remember that
notion of base graph correct LIF inside
zc okay and the systematic uh columns KB
okay which is fixed okay
22
now let's see this okay standard
specifies different lifting size to
design this parity check Matrix okay
what is it telling us go and check this
table okay these lifting sizes are
defined I'll introduce this table also
here okay what is it telling us that you
can generate this parity check matrices
only of a certain specific
sizes right okay so if H is of a certain
specific size then input also need to be
of a certain specific size okay because
that's what you need to encode using
this parity check Matrix right so that
puts the constraint and that constraint
we are going to study now in this slide
and that's what will tell us that how
many filler bits we need to append okay
and this is what is these are the set of
lifting sizes which is defined in the
standard so this is coming exactly from
the standard I've copied it from the
standard okay so this is what is here
okay right so look at this only discrete
numbers okay and some of them okay not
all numbers are
here okay so what is it telling these
are the lifting sizes corresponding to
you can generate okay right generate the
par check Matrix okay so the minimum
value of zc so what is how do you like
now you need to basically decide this
parity this lifting size okay then how
much there should be a certain base
graph okay and then how much that base
graph should be lifted okay so that you
can generate this suitable size parity
check Matrix okay so what is and there
is this number systematic columns B okay
that is one dimension of the base graph
Matrix okay so what is happening here so
what will how will you pick the z c
that's so what is this
okay this KB okay this is this number 22
how much is it okay it is the number of
systematic columns which is fixed 22 the
length of this column will differ but
the number of columns remain fixed okay
so basically the base graph Matrix is of
that size right and then you need to
lift it okay how much you should lift it
that's what this formula is okay KB into
this will be the lifting size that
should be equal to K okay which should
be greater than equal to K
Dash Okay what is what is this K Dash
where did this K Dash come from what is
this K Dash you remember this I just
introduced in the last last slide K Dash
is B Das by C okay actually you should
encode K Das bits correct but you cannot
encode K Das number of bits because this
is what there is a constraint on the
lifting size okay so what are we saying
here KB into z c should be equal to K
and that should be equal to greater than
equal to K Das what is they telling us
that this K can be equal to K Das if you
are able to find this lifting
size such that okay this multiplication
is equal to K Das you don't have to
append any filler bits okay such a zc is
defined over here okay because you are
able to find a zc you can create a
suitable parity check Matrix to encode
this k- length input okay that's
otherwise what will happen okay you have
to find a k which is greater than K Dash
right now if K is greater than K Das
what is it telling you that because you
have only how many bits you have you
have only K Das bits okay you need to
append some dummy bits so that you can
encode this input right so let's look at
this for this example what we have so 22
is fixed okay so you have to search
through this all three all of them all
these z c such that you can find a k
minimum K minimum zc such that you can
find a k which is greater than equal to
K Das minimum value of z c not any value
of Z you can have a value greater than z
c also which will satisfy this okay this
particular value of z c you can find a
value greater than this also but what we
are saying here is because you don't
want to append a lot of par bits you
want to append only minimum number of
filler bits okay right so so you find
out a minimum zc which ensures that K is
greater than equal to K Dash okay right
so you do the search you basically like
writing a search operation okay what
will it tell you it tells that z c what
is available here is
352 okay now what is this
7744 which is greater than K Dash which
is 7072
correct okay right and why are we doing
all this because you need to generate
this parity check Matrix okay and why
did we need to learn about this base
graph because parity check Matrix is
generated from this base graph and that
base graph needs to be lifted by a size
of z c so you're able to connect all the
dots right so when segmented transform
block size which is K Dash is not mass
to suable lifting lifting size which is
happening in this case filler bits are
added what are these filler bits they
are dummy bits which you need to encode
because basically cannot encode other
input length Okay so the number of
filler bit denoted by F what is this it
should be K minus K
Das right and that's what this
number right so what is this
segmentation block going to give you is
basically a segmented code block of size
7744 not 70 7
2 right that's the claim I made that it
is segmentation output will not be 7072
it will be
7744 and why because the ldpc encoder is
designed in such a way and why is it
designed in such a way so that there are
practical implementation constraints
okay right and look at this you have so
many like it can ldpc encoder can encode
these many granular sizes okay it cannot
encode any other
arbitrary size and the reason is that
because again you have to generate a
parity check Matrix you cannot generate
any arbitrary parity check Matrix okay
right in theory you can do that in
theory you can encode
this correct then your system will not
be practical okay right so total number
of four code block of size K
77 so it is K not K Dash Okay 7744 K
7744 with filler bits 672 that's the
output of the segmentation
block okay and that's what we promise
that what we'll understand that's how we
have reached here fine okay so that's
how it will look like that's the overall
picture of the segmentation Block B was
28192 there's a transfer block CRC
correct okay so you need you should know
what is coming out of the segmentation
block how many code blocks four of them
1 2 3 and
four right okay so what are
this
748 is your actual message 24
bit
cbcc
672 filler bit same is for all of them
what is other objective is also met
where in all the segmented code blocks
are of the equal
size right okay correct so and if you
look at this so this is and where is the
tbcrc coming where will tbcc come it
will come in the last code
block right
24 right okay so just to understand how
the receiver operation work at this
stage okay right so let's say all this
like decoding has been done at the
receiver you get this because that's
right cbcc will be validated filler bits
will be removed cbcc will be validated
right right if all of them get validated
1 2 3 4 these code blocks you'll have
and then extra tbcrc then tbcrc will be
validated if it passes you pass on 1 2 3
4 back to
Mac correct right that's how it is H so
now this
is like this is a schematics okay so
actual payload we saw it will be 30 9676
but need to be transmitted
okay now how is it actually written in
the standard that's what we are going to
see so we have what we have understood
now okay with all this okay last two two
and a half classes that what are the
principles of
segmentation okay and then how is it
actually done okay right using this
example we have understood now I'm going
to like go through the instructions
which are given in the standard how it
is like how is defined I read those
instructions then prepared this example
now let's go back and read those
instructions and then see how everything
Maps there okay because that's the idea
of this course that you should be able
to read the standard it input bit
sequence to the code block segmentation
is denoted as
this how many bits are going inside this
segmentation Block B right okay correct
because this is the transport Block Plus
CRC which needs to be uncoded that's how
it is defined in the standard B is
greater than zero of course okay right
so this is the bit sequence which is
there in the standard okay again the
notation Remains the Same okay keep this
in mind and bit output from the code
block segmentation are denoted by c c b
is the input C is the output written
like this we are ingenious we don't want
to make notations complicated okay B is
input C is output right okay and you'll
see this B C then it'll Follow by D okay
output on the
subsequence Block will be e that's how
it goes on okay but what is here okay so
what is this this is the r code
block okay and how many such code blocks
will be there Capital C right okay so
where will R run from R will run from 0
to C
minus1 okay correct and what is this
KR what is K coming we decided what is
this this is K right 7744 so what am I
saying here how is this what is this KR
this is the length of this block what
will KR be in this case for all of them
KR will be
7744 right okay you should not suddenly
get surprised where this R coming from I
never calculated that okay I calculated
K I've appended this R because output of
this will be how many different code
blocks and I'm denoting each of this
code block with the subscript R okay
right so R is the code block number and
KR is the number of bits for the code
block number R so I'm given it for you
okay filler bits usually denoted as
minus one are added to the end of each
code block right in order to distinguish
it from the other
bits fine okay let's go on okay
so this is what we have code Block C for
k- is 772 K is 7744 L is 24 fine okay
now I'm going to go through this
segmentation instructions which are
given in the standard okay let's see
this okay so what are this C what is
this crk we just saw cor is output of
the segmentation code segmentation block
right crk how is it calculated okay so
it is actually see this is from this
section of the standard okay now that we
have understood it in detail using that
example okay and the ideas it'll be very
easy to read this okay right so how many
so you have C you have everything you
have calculated this in the in the
segmentation block okay so what is this
r as I said will run from 0 to C minus
one right okay and this is some index
okay K what is this this is a running
index okay K will run from zero to what
is this running index K will run from 0
to k- - lus 1 right what are this why
are leaving what is K Dash 70
72 correct okay right so what is what is
this L minus one why are you leaving L
bits over here they are basically the
CRC bits okay right so what are you
doing here what are what is happening in
this Loop what is the b b is the input
to the code block segmentation block
okay so you now what are you doing here
you're forming these segmented code
blocks correct standard only gives you
this not all those pictures which I've
have shown you right so what are you
doing you taking this first bit look at
this s is zero take this zero write into
this zero code block okay increment this
and how many such bits you are going to
read K
Das right okay K Das minus L right okay
look at this this is the actual payload
without filler bits okay and you are
subtracting l so that you can add the
parity bits to
it correct okay fine this is not done we
are not done yet okay right so continue
this okay now if C is greater than
one then you will do
this right please read get this
carefully if C is greater than one
you'll stop if C is equal to 1 what will
happen you will not go through this Loop
that's what it's saying right NF if C is
this this is NF okay now what are they
saying okay you look at this this is
basically appending these parity bits
okay right if C is equal to 1 what is
your feeling what are these par bits
these are code block par bit CBC these
are CRC bits okay right there are code
block CRC and when will you app that
code block CRC when the number of code
block is greater than
1 right okay if C is equal to one then
you only do
this correct okay there is no code Block
C C
fine now if C is greater than one what
do you do this input this whatever
sequence we just wrote okay that's the
code block sequence you will generate
this par
bits and how many such par bits you are
going to generate L par bits how are you
generating this based on this sequence
which you have written here that's how
you generate this is one code block
generate parity bits okay and then what
are you doing you are taking and how are
you generating see this is exactly
specified here okay this parity bit have
to be generated according to this
generator polinomial GCC 24b which is 24
bit polinomial okay 24 order polinomial
will generate 24 uh CRC bits according
to this sub clause which is there in the
standard we Ood this right there a CRC
generation okay then what are you doing
here you're appending this code block
CRC how are you appending you will now
the index will run from k- minus L to k-
minus
one correct and what are you appending
you're appending this par
bits right to the code
block fine okay get done with this okay
now what is this what is left over here
K Das to K minus one this is the
insertion of filler
bits right okay standard doesn't tell
you in any other way that if the code
block is one you should not append code
block CRC this is the only way you can
figure out there is no separate
instructions okay to tell you that like
cbcc should not be appended then there
is only one code block okay and now we
understand why it should be done we have
spent great amount of time in
understanding this and what is this this
is the insertion of filler bits okay so
even if code block is one you still need
to append the filler bits right because
if K Das is greater than K which happens
okay then you need to append these
filler bits this is for this and then
this is the end for for the
initial yeah okay this is for the
initial for C is equal to this
one okay right so this is actually the
segmentation block
instructions fine okay so by
understanding those these examples and
the understanding this ldpc encoder you
have understood why this is done okay
right so this is basically the end of
the segmentation
block okay that's how it these
instructions are given and you have to
implement it design a system bu based on
this
right okay so ldpc coding in the
standard again we'll finish this also
okay so ldpc encoder input is K bits
right ldpc encoder output length Okay
how much should be the output length
that's what I'm going to uh this is I'm
introducing for the first time okay
right so we done with the segmentation
I'm just summarizing this ldpc encoder
okay we have understood most of it okay
are certain key points so if there is
first base graph what should be the
output length of this n ldpc encoder it
should be 66 into z c it makes sense
I'll give you an example okay if the
base graph is two then n should be 50 z
c okay this is output length input is K
output is n so what should what is the
rate of the code K by
n right okay see this okay so for our
example ldpc encoder output for each
segmented code block what is that right
what was a zc what was zc
352 what is n n will be equal to 66 into
352 this is this number okay what
is and filler bits are replaced with
zeros while encoding and added back
after encoding because you cannot encode
minus one you can only do binary
encoding fine and now look at this if
you look at what is the rate of each
code block input is K which is 7744
output is this what is
this 1x3 a magical
number okay this is called the mother
Cod
rate okay so for the base graph one ldpc
mother code rate is 1x3 which
essentially means that your ldpc encoder
is always going to encode at the rate
1x3
okay how do you generate any other rate
from that that's the next module okay
right so we'll discuss that also so this
is Mother code okay right for the base
graph one and this is coming nicely from
here okay so all these things are neatly
designed okay we did not go into the
ldpc and coder details okay we just like
cover that in 15 minutes you can spend
like half a semester understanding that
okay we're not doing Justice to it but
we are doing we are not here to learn
about uh great detail about ldbc
encoding we are going to understand the
standard okay so how is it written in
the how is this ldpc encoder defined in
the standard you see this what is the
output of segmentation Block C so what
that becomes input to the ldpc
encoder correct okay right so bit input
to the ldpc encoder is c0 to CK minus1
Why this R is removed because ldpc
encoder doesn't care which in which
block you are feeding to so that
subscript r is removed for the ldpc
encoder okay for because for the encoder
all the inputs are same okay while
feeding data to ldpc encoder and this is
precisely the reason look at this lazy
engus bit output from ldpc encoder
decoded D and where does it run from
what will be the output length
n right K is the input n is the output
okay rate is K byn mother code rate is K
byn right okay so we'll summarize this
is what we have understood till now okay
right what is this I'm we'll close this
after this slide okay what is happening
transfer block transer block CRC
segmented into C code blocks appended
code block
CRC okay right we understand reason
behind doing each of the step finally we
are have this filler bits we understand
why they are done each of this code
block
is sent to the ldpc encoder and the
output of ldpc encoder is denoted as
this okay right so we have understood
this part okay so we'll uh stop here and
then we'll continue our discussion on
the subsequent module and which will
tell us like how do you generate any
other code rate from rate 1x3 okay
because all these MCS indexes are not
1x3 they're different rates okay that's
the motivation for understanding the
next block in the trans chain okay so
we'll stop here thank you
[Music]
[Music]
[Music]
