So we already know that there are two types of memory that we have inside, and so if we utilize any
memory that is far less than distributer memory and if we can use a dedicated memory block available,
perfect.
And if we do it, then they are.
So let us just take an example and understand how difficult things lead to a creation of different types
of memory.
So there are actually two ways in which you can create different types of memory.
So we looked into both the ways to try to understand each and every step in detail.
So we'll see if this is the very first example that we are targeting in a memory.
So I follow an entire procedure right from the beginning.
So we started to create project.
And then we'll probably name it as a memory to Tony.
Click next, since we want to perform an entire process right from the beginning.
That is from the creation of resource bill, implementation will select an active project, click next
to file, see that your target languages are used.
You know, we create the file will name us from memory to tell you and then will select next.
Right now will not be adding any constraint.
Just go ahead and board that will be using for their demonstration purposes.
The next is for DIA, which have an Article seven family.
So we just click finish.
So this will create an workspace where we can start designing.
FPGA systems.
So now, very first thing that we get is the input and usually we have a certain idea related to memory.
So, for example, if you are targeting a single photograph, so you have a single address, but a single
database where he'll be writing a data and one other database very, very devoted, and then there are
some controlled inputs or depending on the architecture or the type of memory that you're targeting,
the number of things may vary.
So usually you do not have an idea of all the votes.
Just add the poor section.
So, for example, will always be there.
It doesn't decide whether Outram will be distributed or block.
And along with this, I know that I'll be targeting one in six to the data.
So I just select the direction as in and four to 16, which will check disperse option and will go from
15.
Similarly, I know that there will be a one bus from where I'll be reading Lolita Directions and then
probably 15 down to zero.
Right.
So those are the boards that I know.
Now let's assume that we are targeting one in block memory.
So a particular style of vision is required to actually to block memory.
I know since we do not know what is at stake.
So a language template option that you have enough to navigate that is a handy option.
So what we'll do is we'll just delete this comment first so that code becomes a bit easier to handle.
OK, and then we'll probably include unsane library, some standard and the school logic underscore
unsigned.
And then will the rest of the cards.
So those are the votes, that block will be a single bit and that action will win and it's 16 right
now.
Let us assume that we will be working on and block traffic.
So we want to implement this kind of memory card.
We want to have a program that is being implemented with the help of but available.
So I just go through a language right now is be for all the language.
It consists of various types of constructs that will lead to certain kind of districts.
So instead of looking for each and every folder, what will be doing is since we want to implement that,
then with a block memory, I just search for a block.
So I just search for a block, so now it will basically give us a radius wherever it finds a block,
so we will not be targeting one very so just minimize the very long hold.
And then probably in an ideal, you have something called as an designed example.
So if we just go through and then bad options that have been looted after the search, you'll be finding
you have a folder that is named dozen of.
A design example.
So I just flew into a holding example right here.
I have an example followed and then inside this, we want to have a single program, a single program,
and then I can have.
Different kinds of mood.
So they're just looking to single photograph.
Right, so no, for here you can analyze actually a structure how and when your forearm will be considered
as a block.
Right.
So is just looked at in a typical example.
So here you'll be finding you need to make an entire circuit secretion.
So process you have a clock then for each of your clock we can use this kind of a Syntex.
Then if in level eight is one, then if right and there is one then the data has been assigned to a
memory that is being created and else will be reading it.
So this is a typical format that is included here.
So if you don't understand this, what you can do is you can look for other other examples if you have.
So for example, it is just going to a simple developer and inside this, if we just analyze the format.
So now you can look into a typical for so long and this is it, I think a clock so right.
And even if we just choose the right thing and if you make it right.
OK, so whatever address that you specify, whatever it is that you specified, that date will be right
on that specific memory location.
And if you have a dual purpose, they'll be finding you have two different addresses.
And for that reason, if there will be one, you'll be simply reading a data from that specific address
that is mentioned.
OK, so here you can find out that these folks are on Google and Brookside equation is right in there.
And secondly, if you just could do a single program.
A single problem and with the with any one of this option would be finding that are thruppence that
are mandatory, one is right and level and second one is E any rate.
So if we make.
But first, we need to make a nebulas, then only double check whether a right is one.
So if that right is one of will, basically writer data and ELDs will be reading vote.
So this is a typical structure that I'm trying to understand from the language.
Let us just try to add the quotes in our design and try to implement that.
So.
And that is right, and it would have an additional often and size of single district, so this is the
first thing that we have it and there is a mood for that.
So let's just ignore it and enable for the time being.
We know that if the level is high, we can simply put aside that specific memory location ls ls again.
So this is the typical format that we are in.
So it can be considered as a block and let it just ignore it.
And if we perform a synthesis bill, unless actually we get to block them or not.
And if you will then be able to get off of that then we'll look into the language and modify so addressed
business.
So we'll just have to address and let us assume that we want the death of one zero two four.
So standard this code logic in the school sector and then for handling a depth of one zero to four,
we require an infrastructure for declaring that then views and I don't it.
OK, so this completes the remaining force that I've been missing out of an entity for a single.
So we'll just now for the create a memory.
So how you create a memory, it is very similar to how you create.
You start with the type, you give a name to this type.
So let us assume that it is having a user defined normal from when the scrutiny is and that is then
that it is entity and then you define the depth.
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
three.
Down to zero.
Or I can take zero to one zero two three tabooed, the methods are fine of.
And then you specify the size of each element, so the size of each element that are targeting is 16
bit.
So we'll just ignore that.
OK, so this creates an instance.
Now, this instance is not usable by just ignoring a type.
You need to declare a signal, a variable to use this instance.
So we'll just assume it does or in fact, memory the signal and it will have a bit of an understatement.
So this is how you declared a memory.
Now let's just declared an architecture.
So how do we do that?
The first thing we need to make sense to do of so we like to process and say, OK, we'll try to follow
a language template.
So instead of using it, I think in fact that is also possible.
Do the right thing, but will go with if it a clock event and the clock close to one, then.
Right.
So if given and then if, if right then it will equal to one so that indicate that you wish to perform
a writing offered to a specific memory location specified Banneker's.
So now.
And is just so they insist that we created for the memories.
Mmm, mmm, mmm.
And then we need to specify the element, no order or the specific rule on which you will be writing
a.
And that rule will be decided on the basis of an address.
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
twice.
OK, so we're just trying to look twice, you'll be finding choosing at a certain process since no,
this isn't true.
And we want to find out an element or we want to write a value to an element which must be an integer.
And if you just observe either or an interest is having the type of standards for logic and descriptive.
So we need to convert this to an integer.
So we do that so that our function to do that, so do integer, is a function that basically convert
an unsigned to and indeed so to integer.
No, still it isn't either, which is a standard for logic.
So what will add further is.
And unsane, so first will convert a standard and logic on this convicted Lensink and then will convert
that to an actual will be finding the a discount.
And we'll just see, just see.
So this is how you did so this operation basically signify that Baghdad, which is is changing this
whole logic on just going to be converted into a say and then and saying we are going to end it.
Right.
So this completes an operational for writing or else else what we can do.
It is the deal which is going to be simply assigning it to this thing.
Right.
So whatever address we specified, I mean, just try to access a memory from that.
So we'll just see what it is.
So this completes an entire.
So very first thing that will be doing is going to be serving in our committee.
So we'll just keep going until analysis and will observe a schematic.
First, dad will try to understand whether on Christmas and the round block that has been created,
whether they both have a seat.
Right.
And along with that, whether we have an extra lattice in our design, that is the second thing that
we observe.
We'll be finding this is an artillery round block that is being targeted.
So this are all flipflop.
So this doesn't create any problem for timing analysis for an art dealer.
And we'll be finding anybody when I have to have a size of an order drizzles who have to say something.
So the size of dress sizes matching and in fact, so much.
So now we can proceed with an syntheses to actually see whether this style actually convert Arthaud
into a blocked memory.
OK, so here we since we are targeting honor block memory.
So we have forcefully followed a state that can actually create a blocked memory.
Now we will be finding this style will be different for creating a distributed.
OK, so this is one of the we you go to a language template, you search for a specific component that
you are targeting and then you follow a language template.
So if you're exactly matches to a language template, you'll be getting an exact component to this.
So we'll just see whether we actually get to block memory.
So we'll just open our synthesis design.
And we'll just looked into a schematic.
OK, so now if you just go through a synthesis and inside a synthesis, you have a schematic, so we
just go to a schematic and this is a block that has been created.
And I just try to zoom in a bit.
So it is basically RONNEBY.
So this is a block from memory.
So just to confirm this, what you can do is you can go through unfolds and inside a report you have
a utilization report.
So if you just go to an implementation report and the findings say duty as a memory is OK.
So we have not utilized and allowed for the creation of a memory.
So that is why we are getting a zero.
So from this this utilization report itself, you can guess that the memory that we are utilizing is
actually appropriate to be finding Block Grant, which is having a different type.
So and the statistics are not in.
So we are actually using one of it.
So this is a typical coding style that you follow to create a block.
So usually when you are working on a greater amount of depth, you.
Dogged on hand, if you have a smaller debt for data, then you can target on distributed.