WEBVTT

00:00.210 --> 00:06.380
OK, so now us try to implement a distributed memory of what we'll be doing is we'll be sticking to

00:06.380 --> 00:13.650
the same conclusion that is that one day it'll be four, which is very, very green, which is very,

00:13.650 --> 00:16.020
very high if you consider so far.

00:17.400 --> 00:22.550
So we've been industrial application of the use of memory and such scenarios.

00:23.490 --> 00:31.380
But then let us just try to replicate the same scenario and discuss how our holding cells actually decide

00:31.380 --> 00:33.670
what should be implemented in this state.

00:33.690 --> 00:36.430
So we'll just create a new source must.

00:38.340 --> 00:40.770
OK, and I just need does.

00:42.670 --> 00:44.530
Distributed to nearly.

00:47.410 --> 00:48.970
Mine to just click finish.

00:49.400 --> 00:54.700
OK, so we'll just copy in and diet and from our previous example.

00:54.970 --> 01:02.310
OK, so Bill will begin, will be copying everything and we'll just be sitting that insider.

01:03.390 --> 01:06.180
The nucleated model, that is just a bitter memory.

01:08.770 --> 01:11.620
And we'll just end our architecture like.

01:15.240 --> 01:18.580
The very first thing that they'll be doing here is.

01:19.520 --> 01:25.080
So we just see our design and the first thing that we always do is whenever we create a new one.

01:26.480 --> 01:31.120
We usually want to perform an entire feature designed to on a newly created money.

01:31.700 --> 01:34.770
So we'll set it as a tough one right here.

01:34.790 --> 01:45.380
You'll be finding the new money will be needed to get that distributed memory and just this entire thing.

01:46.100 --> 01:49.290
We're just be to do it here and here.

01:49.400 --> 01:49.690
Right.

01:51.050 --> 01:53.630
So this will create a new source.

01:54.110 --> 01:55.460
We'll be having with.

01:56.890 --> 01:59.740
And then they'll be setting this sauce as a.

02:01.640 --> 02:07.040
So this is the first thing that you always do when you create a new source and then will again follow

02:07.060 --> 02:07.320
along.

02:07.940 --> 02:15.570
So we just go to a language template and know instead of will search for a distributed memory.

02:16.700 --> 02:21.470
Now, again, you'll be finding a whole lot of options, individuals who will simply first minimize

02:21.470 --> 02:28.730
their vision and insight, a visual we will target of shooting examples instead of shooting example,

02:28.730 --> 02:31.800
you have a distributed Rampolla religious group.

02:31.860 --> 02:34.810
And so if you could just see or hear.

02:35.750 --> 02:37.710
So this remains seen for the.

02:38.690 --> 02:47.590
So if you are right and is one, then you, Rita, you and your entire block would hit you and your

02:47.610 --> 02:54.440
process and then finally us saying to Aram, depending on the address that you specify.

02:54.490 --> 03:00.860
OK, so this is the difference, if you remember, in a blocked memory, if writing is one, we used

03:00.860 --> 03:03.950
to write the data as we used to read it.

03:04.250 --> 03:11.750
But if you want to have a distributor memory, you'll need to force the process and and you'll be simply

03:11.900 --> 03:15.220
reading the data from a memory location.

03:15.550 --> 03:21.030
So just lose language and no recourse for the creation of a distributed memory.

03:21.050 --> 03:23.300
So we started the process again.

03:23.300 --> 03:26.060
It is a sequential process block.

03:26.840 --> 03:42.270
And so if a clock event to document and block equals two and then then if right and level is high.

03:42.930 --> 03:43.260
Right.

03:43.280 --> 03:50.560
And then then will be simply rewriting the data for the address specified by it.

03:50.990 --> 03:57.680
So the ramp and memories are a memory that is being created.

03:57.820 --> 03:58.550
And then.

03:59.880 --> 04:08.550
Will simply be to simply be writing a little bit on the basis of interest and we need to do an intermediate

04:08.550 --> 04:09.170
conclusion.

04:09.180 --> 04:14.820
So to India, Indonesia and then and unsigned.

04:15.780 --> 04:21.600
And finally, this competition, we just need to add two more into this.

04:21.600 --> 04:31.190
And then this completes a process of writing a letter to memory to just look counterbalances the finding.

04:31.680 --> 04:37.760
The everything looks fine and we need to immediately end this, if not great.

04:37.770 --> 04:44.770
So we'll just add and and will also end this clock and a process.

04:44.790 --> 04:50.330
So and after the president, we can write it will be for our doctorate.

04:50.730 --> 04:55.000
So we'll just add will be equal to a question.

04:55.410 --> 04:57.670
This is the data will be actually.

05:00.980 --> 05:09.060
OK, so now we'll just see what it is and just try to see whether we haven't committed any error rate.

05:09.500 --> 05:12.050
So just to see a warning.

05:16.020 --> 05:19.020
So DOD is having the same size and then.

05:20.480 --> 05:22.870
I don't we specified all the exact.

05:26.950 --> 05:37.250
OK, so we one the parents to decide that, but, you know, we'll be finding that compiler do not compete.

05:37.270 --> 05:45.130
Right now we'll just go to an schematic to see whether the address piece is matching through the autism

05:45.190 --> 05:46.220
that has been created.

05:46.240 --> 05:48.400
So we'll just go to an actual analysis.

05:48.640 --> 05:50.980
And we looked into schematics of schematic.

05:51.160 --> 05:57.910
Give us an idea that all the typical components and the typical size of each and every photo will be

05:57.940 --> 06:01.750
finding nine zero nine zero nine addresses.

06:01.750 --> 06:06.050
Also having the same sense that, as detailed and detailed, is also having to say so.

06:06.700 --> 06:07.640
16 bitrate.

06:07.960 --> 06:08.970
So that looks fine.

06:11.140 --> 06:16.810
And then we can proceed with then performing the synthesis is so I just click on Run Synthesis.

06:18.010 --> 06:24.970
Now, this will take some finite amount of time to perform synthesis, so as soon as synthesis is complete,

06:25.660 --> 06:31.580
we'll just looked into a typical cell that has been doing off to the synthesis.

06:31.810 --> 06:35.140
So this is one of the we value for language template.

06:35.170 --> 06:37.530
And then you get a dedicated component.

06:37.870 --> 06:39.400
But whenever you are.

06:40.510 --> 06:47.280
I'm not sure about a specific language conflict, the good or an easy way is to proceed with the knife.

06:47.430 --> 06:52.240
So we looked into it and that we also when we actually discuss.

06:53.000 --> 06:53.220
Right.

06:53.700 --> 06:57.120
So we just clicked on an open synthesis design.

06:58.910 --> 07:05.870
And we'll simply go to a schematic where we can actually visualize what the typical cells that are being

07:05.870 --> 07:06.270
created.

07:06.290 --> 07:13.460
So we'll be finding the circuit as complicated as compared to what we have in the previous case.

07:14.210 --> 07:21.290
So, you know, if we just see this is a component that is RAM 256, cross one.

07:22.430 --> 07:26.380
So this is basically our cells for distributed memory.

07:26.390 --> 07:32.750
So just to confirm this, what we can do is we can go to a report, we can open utilization.

07:32.750 --> 07:40.280
We both know if you can see the slice and duties which are being used and then there is 256.

07:40.550 --> 07:40.720
Right.

07:41.210 --> 07:46.340
So it'll be finding it by utilizing for us day.

07:46.490 --> 07:53.620
So we are utilizing a duty as a memory and which is basically distributed data to finding distributors.

07:53.630 --> 07:57.500
I'm calling this group of Dessaix, which is a very, very high infection rate.

07:57.770 --> 08:02.590
So and if we can just go to a program that will not be finding anything.

08:03.230 --> 08:10.430
So this is how you use the specific style of by by referring to a language template and you can get

08:10.430 --> 08:20.450
an equivalent of cell type while performing a generation of necklaced or conversion of glued to the

08:20.960 --> 08:21.500
same.
