So let us start building our application rate, so if you go to a boot support package, the recommended
driver for any time HDMI CD, right?
So that is the first driver file that giggling in our mean application, right?
So I should include Dan Hicks tmr CD, right?
Right.
Then all the hardware login information will be in the experimental stage.
OK, so this is the second driver file that the required rate, then we proceed to perform an initialization.
So if you just explore the driver we have.
Initialize function present in our code, right, so we will just be declaring the instant structure.
OK, so let me just.
Declare an instance structure will be naming this esteemed, right, then we declare the function which
could be used to perform an initialization of a time or two.
You just need this SDMI in it and then we proceed to call TMI initially today.
So there's just requiring an instant structure and the device A.D. so we go ahead and return the state
as wishes of indicating.
Stewardess saying this would be close to.
Initially, the first argument is an instance structure, right?
So it will be.
And then the second argument that we need to add is the device at any rate.
So we need to explore the experimental fight and there we will be finding dmaa.
Right.
This will lead us to an instance where we have all the information related to the exciting work.
So we'll just be copying this device.
We go ahead and we add it to what you write.
So this completes the process of initialization.
Now we will be verifying whether initial edition is successful or not.
No.
In fact, our miniaturization will be to provide our application rate to.
In that case, you could skip the process of verifying whether initial edition is successful.
So let me just skip the process of checking whether initial is successful or not.
And we will be proceeding to do a configuration of our time, right?
So.
Our first thing that we do with the timer is to forcefully stop it great, so we'll call a stop phone
should this required an instant structure idea.
Yeah, no.
So in the case, when we are utilizing only a single timer there, that Yamashita number will be close
to zero rate.
So we'll be calling pmrc to stop with.
The first argument will be the instance structure and second, when will be the EMI CTA number, which
is seal, right?
Then we will be performing.
Then we will be setting up the mode right.
So let's assume that we want to operate our timer in adult mode.
OK, so first we'll be reading an existing option.
So we have the function referred to as a gate option that will retain the existing option that we have
in for any excitement.
Again, this requires you that you do.
So really just be calling this.
OK, you really do.
Let it just got a name, though, very well as option.
OK, call this function.
This required first argument as an instance structure and the TMI CGI number two.
Once we have an existing option, we'll give, we'll be updating the option with an option that we want
the same great option or with.
Now, if you go ahead and look for the different options that we have over here, so we want to just
operate the.
Timer in and down, right, so we'll just be copying this don't count option, OK?
And we'll be adding your door here.
Right.
So this will allow us to use our timer downward.
So once we update our option variable.
Now we call the second option function that help us to set the specific the user's specific option into
the timer.
So let's just call this.
So this arbitrary argument first one is an instant structure of my CTA number and adoption that user
want to say great.
So first argument is an instant structure, which is Steber.
The second argument is that the MCP a number and the last argument will be the option that we want the
same right?
So once we.
Correctly set up with the option, we need to load our timer such that be able to calculate the timer
function is consuming, and we will be assuming here that the delay that our function, which we are
profiling will always consume the time less than 15 seconds.
So this you need to make sure whenever you load your timer with the specific count that you load it
with the value.
So set it exceed the specific delay that you are expecting out of an application rate or a function
that you are profiling.
So here we have a set reset value function.
OK, so this allows us to load our counter register to provide this specific right.
So we go ahead and first declared a new 32 variable rate.
So the way you do because this.
Except the value in a utility to format, right, so we already know that we configure our timer to
operate at 100 meters away.
So if clock frequency that we have used is 100 meters, so you 32 count.
OK, so first we need to add and then we got to adhere so to zero one two three one two three.
So this is a hundred megahertz.
Then to achieve a delay of 15 seconds, we just need to multiply by the factor of 50.
Right.
So we call the set reset value function, though it is required for us to document SDMI.
The second document is still EMR, CTA number and the account value that we want to load.
So this should be covered.
So this will allow us to chinda a delay of 15 seconds until we already configured our timer to operate
on then down.
Great.
Then we proceed.
And let me just call this reset function.
All right.
So we go ahead and call reset.
So this complete the process of configuration.
So what?
What are all things that we did over here so we forcefully stop our timer?
We choose this specific option.
So here we do not want interrupt or not only learn more.
We simply want our time to operate in a normal OK, so we read an existing option that you have for
any timer and then we update an option, right?
We calculated or delay, depending on the time that we are targeting for an application that we are
profiling, right?
So here we are assuming that our function would be taking more than 15 seconds.
So we loaded our timer so that the able to calculate the delay of at least 15 seconds, right?
Then we load that well into the counter and then we are revisiting our time.
So these are the series of steps that you need to perform while initializing your time.
Right now, let's assume that the application that we are profiling is a simple, deliberate death rate.
And this is sending a strong profile on to a council race, so this is what we wish to prove.
Great.
So here we have an application which you want to provide, so just about an application, what we going
with?
OK.
We will be going ahead and we'll be starting our crime.
So.
We call the start function, this required two arguments.
First one is the team, which is against the structure and diversity and no right?
So once you start your timer first, you sample the value at that instant, so let it just call the
gate value.
This return the current value of our time.
So this return you that you do.
So we declared what variable utility this will be storing the clock tick that we have at the start of
our application rate.
So we call get value.
This again required two arguments.
The first one is that here my second one is the DMA number, right?
Then we allow an application to complete.
OK, and then we declared one more variable, which we refer to as an end.
OK.
And that will be sampling the value of.
The counters that we have after we finish the execution of our application right now, you know, that
I counter is going in a downward election rate the stock will have at higher value.
Let's back to it right now.
Let me just try to bring the number of clock ticks that we are consuming data with.
Each clock they are counted will be discriminated by one, right?
This makes sense.
This is how our founder works.
OK, so if we compute the difference between starting in, that basically gives us.
The number of topics that we are consuming to execute this application, right, and that we will be
utilizing to compute the delay rate so the number of OK clock ticks that we are consuming.
OK, let me just bring this in and potentially duty and the value that we want printed.
Start my nursing, right?
If you upgrade your account setting it up well, then in that case then will have an higher value ask
about the stock, right?
So there you need to perform and minus stock, right?
Once you have the number of clock ticks that you are consuming now will do some calculation, right?
So we know that Tariq sativa operates at 100 megahertz, right?
So this basically is equal to 10 industry week.
If you take an inverse of it's a single clocked, it cost us around in this two minus trade.
So if you want to get an equal value in a microsecond, right, so if you just separate, then there's
two minus six and then this minus two, which we did over here.
So then this two minus six will result in two microsecond antennas.
Two minus two will give 0.2 to one, right.
So as soon as we have a number of blocked, it's OK.
If you want to get the value in a microsecond, you just need to multiply by.
The factor of zero point zero zero point zero one is a floating point number.
So we need to proceed.
With the printing function, right, that allow us to print the flirting going, no, it so.
Dying in.
Microsecond rate, or you could just be mentioning like this person 0f this is the format specified
that we use when we want to pay the plotting by number.
OK.
And what we need to do is we just need to perform start mining, saying OK.
And the multiplication factor that we need to add is 0.08, right?
So this is how we will be getting.
The value.
In my view, a second rate, so this is the time our application consuming OK in a microsecond if you
want to bring the value system in a nanosecond rate.
So for a nanosecond, we just need to multiply by 10, and that will basically give us a decision as
to mine so it will be converted into this two minus nine rate.
And this basically signifies that Dennis two minus nine, will give us a nanosecond and the 10 will
be as it is over here, right?
So whenever you want to get the value in nanosecond, you just need to multiply by the factor of 10.
Right now, this is not a floating point number.
So we could proceed with the XL print rate, so let it just go ahead.
And add to bring the.
OK.
And here we will be spending time in.
In a nanosecond rate here, students are no, it's not flirting going, no.
It is a fixed point number, so we could just use percieved zero.
OK.
And here the value that we're going to apprentice start minus st.
OK, and this should be multiplied by the factor of 10.
So this is how we profile our application.
So first, we are calculating the number of clicks.
OK, that should be a start minus it in a case of our download.
OK, and then to calculate the value in an microsecond, we just need to multiply by the factor of 0.01
when you calculate the value in in a nanosecond.
We just need to multiply by the factor of that, right?
So this completes our application.
Let it just proceed to be our application project.
So once our buildings finished, we will be selecting our application project Debug as launch on hardware,
right?
So this will automatically programmers.
So let us try to connect and why this terminal to conflict where we have our hook in the border that
which we would be operating is one one five.
Right?
Only thing that we need to do is to click on resume, but right.
So here we are just calling an inexplicable.
We haven't called the function that perform initialization of a timer and hence we are not seeing any
value for it.
So let me just go ahead and call Primary Nic after we perform the initial addition for and you are very
fit and let's just again rebuild our application and then we need to start afresh DBA configuration
right to select our DBA configuration and click on relaunch.
So now we proceed and click on resume button, right?
So you could clearly see the number of clock ticks that we are consuming is around two.
Forty six.
OK.
And the time that we are getting in a microsecond is two point forty six, whereas time that we are
getting in a nanosecond is two four six zero.
Right.
So this is how we perform a profiling of an application utilizing any set time where it.