WEBVTT

00:00.210 --> 00:06.420
So we already know that there are two types of memory that we have inside, and so if we utilize any

00:07.650 --> 00:13.640
memory that is far less than distributer memory and if we can use a dedicated memory block available,

00:13.650 --> 00:14.100
perfect.

00:14.100 --> 00:16.020
And if we do it, then they are.

00:17.550 --> 00:24.990
So let us just take an example and understand how difficult things lead to a creation of different types

00:24.990 --> 00:25.470
of memory.

00:25.870 --> 00:31.390
So there are actually two ways in which you can create different types of memory.

00:31.890 --> 00:36.720
So we looked into both the ways to try to understand each and every step in detail.

00:36.810 --> 00:41.230
So we'll see if this is the very first example that we are targeting in a memory.

00:41.550 --> 00:45.480
So I follow an entire procedure right from the beginning.

00:45.900 --> 00:47.760
So we started to create project.

00:56.450 --> 01:01.550
And then we'll probably name it as a memory to Tony.

01:02.700 --> 01:08.410
Click next, since we want to perform an entire process right from the beginning.

01:08.430 --> 01:15.240
That is from the creation of resource bill, implementation will select an active project, click next

01:16.340 --> 01:19.050
to file, see that your target languages are used.

01:19.050 --> 01:27.720
You know, we create the file will name us from memory to tell you and then will select next.

01:27.930 --> 01:30.060
Right now will not be adding any constraint.

01:30.570 --> 01:36.270
Just go ahead and board that will be using for their demonstration purposes.

01:36.270 --> 01:40.340
The next is for DIA, which have an Article seven family.

01:41.220 --> 01:43.140
So we just click finish.

01:43.150 --> 01:47.090
So this will create an workspace where we can start designing.

01:48.280 --> 01:49.600
FPGA systems.

01:53.500 --> 02:01.840
So now, very first thing that we get is the input and usually we have a certain idea related to memory.

02:01.870 --> 02:08.290
So, for example, if you are targeting a single photograph, so you have a single address, but a single

02:08.290 --> 02:14.680
database where he'll be writing a data and one other database very, very devoted, and then there are

02:14.680 --> 02:20.590
some controlled inputs or depending on the architecture or the type of memory that you're targeting,

02:20.710 --> 02:22.180
the number of things may vary.

02:22.840 --> 02:27.580
So usually you do not have an idea of all the votes.

02:28.360 --> 02:30.240
Just add the poor section.

02:30.280 --> 02:32.840
So, for example, will always be there.

02:32.860 --> 02:39.230
It doesn't decide whether Outram will be distributed or block.

02:40.490 --> 02:45.180
And along with this, I know that I'll be targeting one in six to the data.

02:45.190 --> 02:53.560
So I just select the direction as in and four to 16, which will check disperse option and will go from

02:53.560 --> 02:54.010
15.

02:54.580 --> 03:02.500
Similarly, I know that there will be a one bus from where I'll be reading Lolita Directions and then

03:02.650 --> 03:04.210
probably 15 down to zero.

03:04.210 --> 03:04.440
Right.

03:04.480 --> 03:06.610
So those are the boards that I know.

03:07.340 --> 03:11.830
Now let's assume that we are targeting one in block memory.

03:12.160 --> 03:18.580
So a particular style of vision is required to actually to block memory.

03:18.590 --> 03:21.220
I know since we do not know what is at stake.

03:21.580 --> 03:26.800
So a language template option that you have enough to navigate that is a handy option.

03:27.040 --> 03:35.050
So what we'll do is we'll just delete this comment first so that code becomes a bit easier to handle.

03:35.230 --> 03:43.510
OK, and then we'll probably include unsane library, some standard and the school logic underscore

03:43.510 --> 03:44.230
unsigned.

03:46.290 --> 03:48.640
And then will the rest of the cards.

03:49.440 --> 03:59.900
So those are the votes, that block will be a single bit and that action will win and it's 16 right

04:00.150 --> 04:00.420
now.

04:00.420 --> 04:03.930
Let us assume that we will be working on and block traffic.

04:04.110 --> 04:07.580
So we want to implement this kind of memory card.

04:07.620 --> 04:13.610
We want to have a program that is being implemented with the help of but available.

04:15.380 --> 04:20.280
So I just go through a language right now is be for all the language.

04:20.280 --> 04:27.810
It consists of various types of constructs that will lead to certain kind of districts.

04:27.840 --> 04:34.720
So instead of looking for each and every folder, what will be doing is since we want to implement that,

04:34.800 --> 04:39.030
then with a block memory, I just search for a block.

04:40.550 --> 04:47.580
So I just search for a block, so now it will basically give us a radius wherever it finds a block,

04:47.630 --> 04:52.170
so we will not be targeting one very so just minimize the very long hold.

04:52.400 --> 04:58.110
And then probably in an ideal, you have something called as an designed example.

04:58.130 --> 05:04.400
So if we just go through and then bad options that have been looted after the search, you'll be finding

05:04.730 --> 05:08.160
you have a folder that is named dozen of.

05:09.060 --> 05:10.560
A design example.

05:12.640 --> 05:16.890
So I just flew into a holding example right here.

05:16.940 --> 05:25.960
I have an example followed and then inside this, we want to have a single program, a single program,

05:25.960 --> 05:27.790
and then I can have.

05:29.100 --> 05:30.280
Different kinds of mood.

05:30.540 --> 05:34.030
So they're just looking to single photograph.

05:34.300 --> 05:43.560
Right, so no, for here you can analyze actually a structure how and when your forearm will be considered

05:43.560 --> 05:44.110
as a block.

05:44.370 --> 05:44.690
Right.

05:44.780 --> 05:47.400
So is just looked at in a typical example.

05:47.790 --> 05:52.560
So here you'll be finding you need to make an entire circuit secretion.

05:52.560 --> 06:00.090
So process you have a clock then for each of your clock we can use this kind of a Syntex.

06:00.540 --> 06:10.800
Then if in level eight is one, then if right and there is one then the data has been assigned to a

06:11.280 --> 06:18.300
memory that is being created and else will be reading it.

06:19.050 --> 06:21.960
So this is a typical format that is included here.

06:22.230 --> 06:27.770
So if you don't understand this, what you can do is you can look for other other examples if you have.

06:27.780 --> 06:36.060
So for example, it is just going to a simple developer and inside this, if we just analyze the format.

06:37.370 --> 06:46.940
So now you can look into a typical for so long and this is it, I think a clock so right.

06:46.940 --> 06:50.750
And even if we just choose the right thing and if you make it right.

06:51.390 --> 06:59.650
OK, so whatever address that you specify, whatever it is that you specified, that date will be right

07:00.350 --> 07:02.230
on that specific memory location.

07:02.630 --> 07:08.300
And if you have a dual purpose, they'll be finding you have two different addresses.

07:08.300 --> 07:15.890
And for that reason, if there will be one, you'll be simply reading a data from that specific address

07:15.890 --> 07:16.480
that is mentioned.

07:16.530 --> 07:25.370
OK, so here you can find out that these folks are on Google and Brookside equation is right in there.

07:25.580 --> 07:29.510
And secondly, if you just could do a single program.

07:33.490 --> 07:41.620
A single problem and with the with any one of this option would be finding that are thruppence that

07:41.620 --> 07:46.970
are mandatory, one is right and level and second one is E any rate.

07:47.320 --> 07:49.510
So if we make.

07:50.530 --> 07:57.550
But first, we need to make a nebulas, then only double check whether a right is one.

07:57.570 --> 08:06.090
So if that right is one of will, basically writer data and ELDs will be reading vote.

08:06.140 --> 08:11.670
So this is a typical structure that I'm trying to understand from the language.

08:12.180 --> 08:16.770
Let us just try to add the quotes in our design and try to implement that.

08:17.220 --> 08:17.520
So.

08:18.640 --> 08:26.140
And that is right, and it would have an additional often and size of single district, so this is the

08:26.140 --> 08:28.900
first thing that we have it and there is a mood for that.

08:30.190 --> 08:34.080
So let's just ignore it and enable for the time being.

08:34.090 --> 08:42.610
We know that if the level is high, we can simply put aside that specific memory location ls ls again.

08:43.570 --> 08:45.870
So this is the typical format that we are in.

08:46.570 --> 08:51.250
So it can be considered as a block and let it just ignore it.

08:51.790 --> 08:57.140
And if we perform a synthesis bill, unless actually we get to block them or not.

08:57.430 --> 09:06.510
And if you will then be able to get off of that then we'll look into the language and modify so addressed

09:06.620 --> 09:07.050
business.

09:07.210 --> 09:13.560
So we'll just have to address and let us assume that we want the death of one zero two four.

09:13.650 --> 09:23.640
So standard this code logic in the school sector and then for handling a depth of one zero to four,

09:23.650 --> 09:28.680
we require an infrastructure for declaring that then views and I don't it.

09:29.440 --> 09:35.830
OK, so this completes the remaining force that I've been missing out of an entity for a single.

09:37.030 --> 09:40.280
So we'll just now for the create a memory.

09:40.300 --> 09:44.850
So how you create a memory, it is very similar to how you create.

09:45.550 --> 09:49.680
You start with the type, you give a name to this type.

09:49.690 --> 09:57.240
So let us assume that it is having a user defined normal from when the scrutiny is and that is then

09:57.280 --> 10:01.070
that it is entity and then you define the depth.

10:01.510 --> 10:09.100
I already knew that the depth I want is one four so I can write this is I can write it as one zero two

10:09.100 --> 10:09.430
three.

10:11.490 --> 10:12.360
Down to zero.

10:13.520 --> 10:19.310
Or I can take zero to one zero two three tabooed, the methods are fine of.

10:20.240 --> 10:27.290
And then you specify the size of each element, so the size of each element that are targeting is 16

10:27.290 --> 10:27.510
bit.

10:27.530 --> 10:28.850
So we'll just ignore that.

10:30.170 --> 10:32.160
OK, so this creates an instance.

10:32.190 --> 10:35.870
Now, this instance is not usable by just ignoring a type.

10:35.870 --> 10:41.180
You need to declare a signal, a variable to use this instance.

10:41.690 --> 10:50.510
So we'll just assume it does or in fact, memory the signal and it will have a bit of an understatement.

10:50.540 --> 10:52.970
So this is how you declared a memory.

10:54.050 --> 10:56.900
Now let's just declared an architecture.

10:57.110 --> 10:58.070
So how do we do that?

10:58.350 --> 11:06.440
The first thing we need to make sense to do of so we like to process and say, OK, we'll try to follow

11:06.770 --> 11:07.810
a language template.

11:08.000 --> 11:11.600
So instead of using it, I think in fact that is also possible.

11:11.630 --> 11:22.490
Do the right thing, but will go with if it a clock event and the clock close to one, then.

11:22.910 --> 11:23.240
Right.

11:23.270 --> 11:33.680
So if given and then if, if right then it will equal to one so that indicate that you wish to perform

11:33.950 --> 11:38.890
a writing offered to a specific memory location specified Banneker's.

11:39.590 --> 11:40.790
So now.

11:41.920 --> 11:46.050
And is just so they insist that we created for the memories.

11:46.680 --> 11:50.070
Mmm, mmm, mmm.

11:50.620 --> 11:56.770
And then we need to specify the element, no order or the specific rule on which you will be writing

11:56.770 --> 11:56.830
a.

11:57.670 --> 12:00.850
And that rule will be decided on the basis of an address.

12:01.600 --> 12:10.480
So if we just add an address here and it just if you do like this and if you just end and if you look

12:10.900 --> 12:11.500
twice.

12:13.090 --> 12:21.730
OK, so we're just trying to look twice, you'll be finding choosing at a certain process since no,

12:22.630 --> 12:23.410
this isn't true.

12:24.130 --> 12:30.660
And we want to find out an element or we want to write a value to an element which must be an integer.

12:30.670 --> 12:38.620
And if you just observe either or an interest is having the type of standards for logic and descriptive.

12:38.650 --> 12:41.770
So we need to convert this to an integer.

12:41.800 --> 12:49.090
So we do that so that our function to do that, so do integer, is a function that basically convert

12:50.200 --> 12:53.680
an unsigned to and indeed so to integer.

12:53.680 --> 12:57.550
No, still it isn't either, which is a standard for logic.

12:58.570 --> 13:00.640
So what will add further is.

13:01.860 --> 13:11.220
And unsane, so first will convert a standard and logic on this convicted Lensink and then will convert

13:11.220 --> 13:14.680
that to an actual will be finding the a discount.

13:21.370 --> 13:23.480
And we'll just see, just see.

13:24.160 --> 13:31.430
So this is how you did so this operation basically signify that Baghdad, which is is changing this

13:31.440 --> 13:37.350
whole logic on just going to be converted into a say and then and saying we are going to end it.

13:37.870 --> 13:38.210
Right.

13:38.440 --> 13:44.170
So this completes an operational for writing or else else what we can do.

13:44.170 --> 13:51.790
It is the deal which is going to be simply assigning it to this thing.

13:51.790 --> 13:52.040
Right.

13:52.270 --> 13:57.480
So whatever address we specified, I mean, just try to access a memory from that.

13:58.180 --> 13:59.490
So we'll just see what it is.

14:01.030 --> 14:02.580
So this completes an entire.

14:03.820 --> 14:08.570
So very first thing that will be doing is going to be serving in our committee.

14:08.980 --> 14:13.180
So we'll just keep going until analysis and will observe a schematic.

14:13.180 --> 14:20.500
First, dad will try to understand whether on Christmas and the round block that has been created,

14:20.500 --> 14:22.120
whether they both have a seat.

14:22.930 --> 14:23.190
Right.

14:23.590 --> 14:29.020
And along with that, whether we have an extra lattice in our design, that is the second thing that

14:29.020 --> 14:29.810
we observe.

14:35.640 --> 14:39.780
We'll be finding this is an artillery round block that is being targeted.

14:39.930 --> 14:41.660
So this are all flipflop.

14:41.680 --> 14:46.710
So this doesn't create any problem for timing analysis for an art dealer.

14:46.710 --> 14:52.660
And we'll be finding anybody when I have to have a size of an order drizzles who have to say something.

14:53.070 --> 14:57.080
So the size of dress sizes matching and in fact, so much.

14:57.240 --> 15:04.730
So now we can proceed with an syntheses to actually see whether this style actually convert Arthaud

15:04.740 --> 15:06.200
into a blocked memory.

15:06.690 --> 15:10.410
OK, so here we since we are targeting honor block memory.

15:10.410 --> 15:15.110
So we have forcefully followed a state that can actually create a blocked memory.

15:15.980 --> 15:23.050
Now we will be finding this style will be different for creating a distributed.

15:23.390 --> 15:29.130
OK, so this is one of the we you go to a language template, you search for a specific component that

15:29.130 --> 15:31.800
you are targeting and then you follow a language template.

15:31.830 --> 15:37.700
So if you're exactly matches to a language template, you'll be getting an exact component to this.

15:38.080 --> 15:41.780
So we'll just see whether we actually get to block memory.

15:42.150 --> 15:44.190
So we'll just open our synthesis design.

15:45.670 --> 15:47.650
And we'll just looked into a schematic.

15:51.880 --> 15:57.700
OK, so now if you just go through a synthesis and inside a synthesis, you have a schematic, so we

15:57.700 --> 16:01.600
just go to a schematic and this is a block that has been created.

16:01.600 --> 16:03.660
And I just try to zoom in a bit.

16:03.670 --> 16:06.110
So it is basically RONNEBY.

16:07.000 --> 16:09.460
So this is a block from memory.

16:09.720 --> 16:15.430
So just to confirm this, what you can do is you can go through unfolds and inside a report you have

16:15.430 --> 16:17.130
a utilization report.

16:17.150 --> 16:23.200
So if you just go to an implementation report and the findings say duty as a memory is OK.

16:23.230 --> 16:27.040
So we have not utilized and allowed for the creation of a memory.

16:27.050 --> 16:29.260
So that is why we are getting a zero.

16:30.010 --> 16:36.340
So from this this utilization report itself, you can guess that the memory that we are utilizing is

16:36.340 --> 16:42.600
actually appropriate to be finding Block Grant, which is having a different type.

16:42.680 --> 16:44.960
So and the statistics are not in.

16:45.790 --> 16:48.280
So we are actually using one of it.

16:49.000 --> 16:54.170
So this is a typical coding style that you follow to create a block.

16:55.120 --> 17:00.130
So usually when you are working on a greater amount of depth, you.

17:01.070 --> 17:07.040
Dogged on hand, if you have a smaller debt for data, then you can target on distributed.
