Try to understand, Matika, OK, where do we want to have a specific component?
OK, so the good idea is you go to a language template, OK, and then you search for let's assume everyone
will just search for the two of you.
And then you have.
A specific family, so we have an Arctic seven, seven, seven and so on and so forth.
So we have on the basis of the.
Our family, we can choose the specific company, OK, or in general will be finding that there are
some it will construct also.
OK, so we're going to specifically choose which kind of memory that you want to implement, independent
of whether it's Vertex seven family or depending on the family.
OK, so if you just go to the synthesis construct, OK, there you have the right to.
So you have an event to steal.
OK, so here you have a good example.
So we'll go ahead and take that and then we have a block crime and distribute to that.
We want to have a distributor.
So we just go and search for an example, right.
And then you'll be finding an entire crew exist with the right, so.
What we'll do is we'll just copy the entire code.
OK, we'll just use the language template and we'll be straight over here, right.
So this is how you implement distributed.
Memory insight.
But right now, what we'll do is we'll just try to understand some of the things which have been mentioned.
So we have a detailed, detailed each of size 16.
But OK, then we have an address of site Six Feet three.
And then here you have declared a memory clock event.
Right.
And that bill is one.
In that case, we are writing a letter and we are really good idea.
Right.
So what we'll do is now we'll just use this to various as you one to two, three and four.
This will require an address size of 10 to nine down to zero.
And we'll just see what you and see whether still be able to invoke a distributor.
So we have used a language template and then we have modified our code so that we are able to get the
elements of one zero.
So let me just move ahead and perform a synthesis.
So our synthesis is complete, we'll just open our synthesis to say we'll go ahead and will observe
the schematic rate, so we'll just go ahead and observe a schematic and see what is in component that
is invoked by we do not rate since we have included a language template, will be finding that the component
that has been invoked will be distributed.
Right.
So we'll just go ahead and say the schematic and then we'll just try to obliterate and that will choose
a company.
OK, so you'll be finding that we want to invoke our distributor, OK, even though we have increased
our debt size to one zero to four.
Now, let's give one more try.
That is in the previous case.
OK, then we are not working with a template.
We have chosen the data size to be 32.
OK, so let us see now what we are doing.
So OK, so this is exactly the same size that we are choosing.
Then we would automatically choose and block memory for us.
Right now we have utilized a template for a distributed memory and we have to do the same, say so.
So this will give us an idea whether the language template really gives us the specific element or whether
we are still able to invoke or block memory.
We will just go ahead and perform a synthesis.
OK, now what we'll do is we'll just open our eyes, and this is Tuesday, let's see whether we are
still able to invoke our distributor, remember?
LP, so we'll just go to a schematic.
OK, and then we'll try to zoom in a bit.
Now we'll be finding still be able to invoke the student memory and this is the biggest advantage that
we get it.
And if we compare with an bedrocks of some time in a very low, the template might not work correctly
to be what might lead to some different component, but with what?
That just work.
So once you follow a language template will be finding you go on increasing the size of it.
Have that much resources on your FPGA.
We will always choose the component that you have specified.
Right now, this is one where we have forcefully suggested that we should be working with the distributed
memory, even though we have a greater depth and a greater say.
Let us go ahead and try to invoke the block memory for a lower say so that we have a good understanding.
Right.
Let's go ahead and use the language template again.
We have already looked for a distributor memory.
Now what we'll do is we'll just look for a blocker and we'll use a simple single program.
Right.
So we'll just go ahead.
And then we have a various.
Templates available, so we'll choose right for small, right?
And Dan.
OK, so we just see.
OK, so here you'll be finding no, we do not get an example, but we have certain template printing
with a straight through process, Clocky, Bloche, and then this is how we define the functional functionality.
OK, so we will just copy this thing.
And Will.
Just go ahead to our design, OK, and then here will be posting it to after.
We will be just visiting, right?
So for us and this is how you declared that, right?
So let's just stick to a process, so here we need to specify a clock right here.
Also, we need to work around the clock because we have used that name for our clock child clock over
here, then enabled pen is not present inside our design.
So just add and enable pen here.
OK, so in everything we have added because the template required it.
Right.
So once we know that complete required, we need to add it right.
So here we just adding a right and it will then Romney for us is here if we can see it.
Is that right?
So we just had a Ramlal here and then address for us is a date.
So we just update this with.
He.
Be for us is just go ahead and then we'll die they.
And family ties are football coach here, d o should be close to you, should be close to the right.
This is what the structure which is required to invoke the.
So do you then for us, the memory name is right.
This makes sense.
And then finally, we have an address for an address we have about New Jersey.
So this complete in.
And conflict that is required to invoke.
The blog.
To hear now what will be choosing is will be reducing the address to five down to zero to 60 for element
and size of.
Here also, once we reduce the size, we now can focus on sixty three elements.
OK, and each of size seven.
So if you remember, when we fit this requirement, we would automatically have chosen the.
Distributive memory for implementation.
Right now, we have utilized the language template and we have modified the language to to follow up.
Right now, let's see whether the design that is being invoked is a distributed memory will just go
or block memory.
So it should be blocked.
So we'll just go ahead.
I will perform synthesis.
Let's see whether we are able to correctly invoke our.
So let's just open our synthesis design and let's see for this low depth as well as LURVE, it better
be able to.
Invoke distributed Mimi.
OK, so still, we weren't able to get a distributor, we weren't able to get a blocked memory.
Still, it is distributor.
So now we'll again go to a language similar to this we already follow.
OK, so something that we have not.
Added is.
OK, so we have already added this thing.
Then.
Guess with this process, we have not I don't think so.
There are two process.
One is for this one defining out, OK, and then we have.
This process, right, so where else we are sensing the kind of beating the doctor so that we have not
added, we just copied this process also.
And we'll go ahead and take our call.
OK, and then we'll just be.
So this is the second process that is mandated.
So we'll just add Glocke or here will be replacing this with also.
OK, here we have a reset, so if reset is one, OK, so here we need to add one more thing that is
reset now, right?
So just go ahead and now will reset.
So now here we are in the template they have in place are temporary, registered.
Right.
That is touring a resort and then finally, which has been updated entirely.
Right.
So, in fact, this is also will be naming as Ramita.
OK, and then here will be naming it as data, right then this crime data has been updated into the
outbreak.
OK.
And finally, the disease outbreak is updating our deal tonight.
So here it should be deal.
This is how the coldest winter.
So this is one more thing that we need to add.
OK, Rexy.
So here, we'll just get a break, see if, in fact, we can ignore some of the stuff.
OK, so what we can do is instead of Rexy, what we'll do is we'll just add ELDs or else then the outbreak
will be updated with Rahmati, OK?
So let me just declare Dautrich.
So here, we'll just go signal.
We require the Altec and one more thing that we require is remedied, and that should have exactly the
same size water element sizes.
So we'll just declare this over here, OK?
And then we'll proceed to we'll be finding no Ramey's memory, OK?
And that is updated with Dean.
That makes sense.
OK, then we have a ramita, we just have to do Arabel where we have a die, OK, and then this is exactly
what Templated consists of, the Ultragaz working around over here.
And then finally, we are updating deal with the.
All right.
So this completes the process.
And finally, we need to end.
OK, so now no, I guess we have four learning tech language that has been given for memory now Lloris
performance.
And this is again and see whether this works fine.