OK, so now us try to implement a distributed memory of what we'll be doing is we'll be sticking to
the same conclusion that is that one day it'll be four, which is very, very green, which is very,
very high if you consider so far.
So we've been industrial application of the use of memory and such scenarios.
But then let us just try to replicate the same scenario and discuss how our holding cells actually decide
what should be implemented in this state.
So we'll just create a new source must.
OK, and I just need does.
Distributed to nearly.
Mine to just click finish.
OK, so we'll just copy in and diet and from our previous example.
OK, so Bill will begin, will be copying everything and we'll just be sitting that insider.
The nucleated model, that is just a bitter memory.
And we'll just end our architecture like.
The very first thing that they'll be doing here is.
So we just see our design and the first thing that we always do is whenever we create a new one.
We usually want to perform an entire feature designed to on a newly created money.
So we'll set it as a tough one right here.
You'll be finding the new money will be needed to get that distributed memory and just this entire thing.
We're just be to do it here and here.
Right.
So this will create a new source.
We'll be having with.
And then they'll be setting this sauce as a.
So this is the first thing that you always do when you create a new source and then will again follow
along.
So we just go to a language template and know instead of will search for a distributed memory.
Now, again, you'll be finding a whole lot of options, individuals who will simply first minimize
their vision and insight, a visual we will target of shooting examples instead of shooting example,
you have a distributed Rampolla religious group.
And so if you could just see or hear.
So this remains seen for the.
So if you are right and is one, then you, Rita, you and your entire block would hit you and your
process and then finally us saying to Aram, depending on the address that you specify.
OK, so this is the difference, if you remember, in a blocked memory, if writing is one, we used
to write the data as we used to read it.
But if you want to have a distributor memory, you'll need to force the process and and you'll be simply
reading the data from a memory location.
So just lose language and no recourse for the creation of a distributed memory.
So we started the process again.
It is a sequential process block.
And so if a clock event to document and block equals two and then then if right and level is high.
Right.
And then then will be simply rewriting the data for the address specified by it.
So the ramp and memories are a memory that is being created.
And then.
Will simply be to simply be writing a little bit on the basis of interest and we need to do an intermediate
conclusion.
So to India, Indonesia and then and unsigned.
And finally, this competition, we just need to add two more into this.
And then this completes a process of writing a letter to memory to just look counterbalances the finding.
The everything looks fine and we need to immediately end this, if not great.
So we'll just add and and will also end this clock and a process.
So and after the president, we can write it will be for our doctorate.
So we'll just add will be equal to a question.
This is the data will be actually.
OK, so now we'll just see what it is and just try to see whether we haven't committed any error rate.
So just to see a warning.
So DOD is having the same size and then.
I don't we specified all the exact.
OK, so we one the parents to decide that, but, you know, we'll be finding that compiler do not compete.
Right now we'll just go to an schematic to see whether the address piece is matching through the autism
that has been created.
So we'll just go to an actual analysis.
And we looked into schematics of schematic.
Give us an idea that all the typical components and the typical size of each and every photo will be
finding nine zero nine zero nine addresses.
Also having the same sense that, as detailed and detailed, is also having to say so.
16 bitrate.
So that looks fine.
And then we can proceed with then performing the synthesis is so I just click on Run Synthesis.
Now, this will take some finite amount of time to perform synthesis, so as soon as synthesis is complete,
we'll just looked into a typical cell that has been doing off to the synthesis.
So this is one of the we value for language template.
And then you get a dedicated component.
But whenever you are.
I'm not sure about a specific language conflict, the good or an easy way is to proceed with the knife.
So we looked into it and that we also when we actually discuss.
Right.
So we just clicked on an open synthesis design.
And we'll simply go to a schematic where we can actually visualize what the typical cells that are being
created.
So we'll be finding the circuit as complicated as compared to what we have in the previous case.
So, you know, if we just see this is a component that is RAM 256, cross one.
So this is basically our cells for distributed memory.
So just to confirm this, what we can do is we can go to a report, we can open utilization.
We both know if you can see the slice and duties which are being used and then there is 256.
Right.
So it'll be finding it by utilizing for us day.
So we are utilizing a duty as a memory and which is basically distributed data to finding distributors.
I'm calling this group of Dessaix, which is a very, very high infection rate.
So and if we can just go to a program that will not be finding anything.
So this is how you use the specific style of by by referring to a language template and you can get
an equivalent of cell type while performing a generation of necklaced or conversion of glued to the
same.