Now, we already know less soon have utilized any time left to perform a profile.
Now what are we going to do is to have in high resolution?
Now we know that the timer worked on 32 bit counter, right, but something that is internal to the
arm processing system is a 64 bit global timeout that we already discussed.
So we could also utilize 64 bit global timer, and we could also perform profiling of an application
rate.
And that is what we're going to discuss in this special section right now.
We already knew that for an internal resources of the processing system, we do not need to do anything.
So by default, they are enabled and the fundamental block design that we.
Create utilizing ActionScript could be enough to verify the functionality of the 64 bit timer for the
correct, so we will just be utilizing this fundamental drop data and I've already put it in hardware.
Quite OK.
And here just we are listening to young and tired logic.
How we do quite right.
First thing that you need to do is to include extreme underscore elder age halo.
So let's include all the APIs, as well as macros that could be utilized to compute the time right now.
If you just go to an extent, my desk or l dot h.
OK, so you do see a number of a microsite that are available, and along with that, we have two simple
functions.
So something that will be useful in this specific scenario is day, right?
So this will basically weaken the counter value that we have, and here I have 64bit global timer account
counter operating an up.
So as we see it, the next time we purposefully set the mood to be down more here, by default, it
is up right to the expression that we utilize in the previous case was stuck, mainly saying right when
we are discussing any time.
But here, since our counter is working in an Upwork's, it will be doing and minus stock.
OK, remember this fact?
And then you have macros to calculate count per second.
So global timer always clocked at half of the CPU frequency, right?
So our global timer operate at half off the CPU frequency rate to calculate the period.
We just need to take inverse of it, right?
So it will be to divide by CPU frequency right now.
In the previous case, what we are doing is since we.
Work to work around with this parameter, so we directly considered in this two minus seven.
And then we did a multiplication factor here, but here we do not want to change America, right?
So we'll be keeping this as it is now.
This will be giving us frequency in second rate.
This makes sense because this is in and hearts, whatever value that we have.
So when once we dig an inverse of it, this will be the second.
So to get the nanosecond out of it, we just need to multiply it by.
10 this to my dentist, to my right.
This makes sense.
Similarly, to get the microsecond value, OK, we'll just be multiplying by 10.
This just six.
This that some of the fundamentals that you require to know now this entire driver work on a next time,
which is an unsigned 64 bit type, right?
There will be delay to boot of the variable over here.
OK, so state stack g.
And so this will be holding the stacking go and then and you will be holding the ankle right now, will
be utilizing the same function that we use, you know, each side timer, OK, so they'll print it,
dimer ET.
And here we are utilizing get MEPA.
And here we need to specify the pointer to the variable where we want this to come right now.
Since does our simple variable will just be specifying an address of great.
Similarly, after we perform an execution of print, it will just be again game calling it type and
here will be mentioning and right.
So now we have both the count available in stagnancy.
Yep, and since our go big Global Times are operating and upward.
OK.
So to display the number of dropping now, remember there's both of them are in unsigned 64bit, right?
So to bring the value of them, we will just be utilizing print.
OK, and here long, long, unsafe.
So L and u.
OK, so I'm saying to you for that long, long Unsane.
And for that, we will be utilizing the format specified LNG rate.
So person zero.
And it will be a g minus start.
You know what, why we are doing this because our counter is operating in an up right now to compute
the value in nanoseconds.
So we just need to have to two then this too nice and divided by the CPU frequency rate.
So we already have a macro for this, which will be, if you remember, it will be two OK, including
this tonight upon CPU frequency rate.
So this will be the same expression that we have added over.
Similarly, when we want time in a microsecond.
OK, here we will just be multiplying two into six divide by the CPU frequency that we have.
Right again, for all of this, we will be utilizing print Mechagodzilla printer is simply not useful
in this scenario, right?
So all the things we have been doing with the rig.
So let's just go ahead and try to file for programming open FPGA.
Now, in the previous case, you already know the value that we are getting is that our two point five
four microseconds right now with 64bit global time, whereas compared to 32 bit, we'll be getting more.
Higher resolution rate, and that is what we are expecting, so they just go ahead and try to.
Panicked when is.
And they will be performing an execution of an application on a highway.
So now here you could clearly see the value that we are getting is the number of clock ticks 861 and
the value in nanoseconds to five eight two.
Right.
And the value in microsecond is around 2.5 rate than the previous case.
It is around 2.5 four.
And here we are, getting 2.5 eight.
We are getting more resolution as compared to the exciting.
So this is how you could utilize the 64 bit global timer to perform filing off your application.