Lily, to understand how we do profiling with any set time.
All right.
So what we're going to do is in a fundamental block design, we'll just be adding any second.
So we are here utilizing only single time.
So this second option should be A. Right?
And the most important parameter for us is to understand the field clock frequency because when we are
calculating the amount of time that our function to execute, we must know what is the frequency at
which time is tell.
So if you just reconfigure same processing system and go to clock configuration, there you have a fabric
clock specification, right?
So we are creating, I feel, fabric lock 50 Maycock.
So this is an operating frequency for our excitement, right?
So this is an important parameter.
Now we remember when we are getting the counter value, so we basically know how many clock ticks are
left straight because each clock are counted, value will increment or decrement depending on the mood
that we have set, right?
So something that could be getting old when we call gate counter value function is the number of clock
ticks that have been elapsed.
So just your fundamental triangulation since APL fabric is operating at 50 MIGA, so inverse of it will
be zero point two into 10 to minus seven.
Right?
So to get the delay in microsecond, we just need to shift one digit left to zero point zero two into
tennis to minus six.
So whenever you want to calculate the delay in microsecond, you just need to find out the number of
clock ticks that are left standing.
You just need to multiply them with the zero point zero.
Now remember, here we are multiplying within our starting point number, so we will be printing the
value in the starting point for my right.
When we consider lettuces, you mean one delay in a nanosecond rate.
So if we just do the inverse of 50 into the industry, six, that will be getting 0.2 intuitiveness
to minus seven.
OK.
So if you just multiply by 100 here, we could add in this to minus two, right?
So it was zero point two and two hundred and two.
Then this two minus nine.
Right.
And if you just multiply this two, we will be getting twenty nine.
Great.
So whenever you want to calculate the delay in a nanosecond, you just need to multiply whatever the
clock ticks that you are getting when you subtract, start dining counterbalance and then you'll be
multiplying it with that 20, right?
So with this calculation, we'll just be setting five.
Now this is a goal which we also discussed in a pool, right?
So we first initialize our timer.
OK, specifying the device addy and then the instant structuring config structure, performing the self-test.
And then we are just checking whether initialization of time very successful or not great.
And here we are, just setting up an option.
So.
Had the option that we set is down more, so our counter will be counting in, OK, and that basically
mean related, you may declare to where you will do it right.
So this is the function which we want to.
Used for our profile, so we'll just be calculating the time elapsed for this function, right?
So we have two variable stock variable and variable rate and both of them Spiral EU-Turkey like right
now get value will basically return the current value of our counter right hand.
Here we are utilizing the single timer.
So here we specified see right and EMI as the timer instant.
So here we will be getting some value.
And since our counter is operating in a normal so and value will be less than stock than it was when
we reach over here are accountable.
Reduce its value depending on the to collapse, right?
So when we consider the down option, the value that we calculate will be stock minus the egg because
our stock value of a counter will be more as compared to hey, right now, this will represent the number
of laps we'll get for a valuation of this.
Specific function that we considered here, it is sobering now to calculate the time elapsed in nanosecond
as this because we just need to multiply by 20.
OK, so what are you up to that we receive would just be multiplying them with a 20 and will be getting
the DV in nanoseconds, right?
And that is what we are doing here.
So this is an integer we are utilizing.
But since the start line isn't like the play by play.
Now when we consider that we want to have a value in a microsecond, OK, so we need to multiply by
zero point zero.
So here we already discussed we need to multiply by 0.02 to get microsecond.
And since this is a floating point number, we utilize brain death.
OK.
This will be timeless in microseconds and here puts into your graph stack minus it multiplied by zero
point zero.
So this is how we will be displaying the values on a.
Right?
So first, we are getting the number of plotted, and that will be very simple.
We just need to calculate the difference between these two variable to get the values in a nanosecond.
We've just been multiplying by 10.
And to get the values in.
And to get the values in a microsecond, we just need to multiply it by zero point zero rate.
So this complete, then it will let it just proceed for execution of a court that gets be clicking on
program FPGA first and then right click run as launch on.
Right.
So here you are an illusion as 10 minutes the time you need to successfully and.
Here you could see that this is the string that is sending on a console and it is used for competition
rates, the number of clock ticks.
127.
Time elapsed in nanoseconds two five four zero.
OK and time elapsed.
Microsecond is two point five four zero, right?
So this is how you could utilize any side timer to profile the functions or any other construct that
you want your new application.