1
00:00:00,060 --> 00:00:04,440
Now, we already know less soon have utilized any time left to perform a profile.

2
00:00:04,810 --> 00:00:08,130
Now what are we going to do is to have in high resolution?

3
00:00:08,160 --> 00:00:15,360
Now we know that the timer worked on 32 bit counter, right, but something that is internal to the

4
00:00:15,360 --> 00:00:19,280
arm processing system is a 64 bit global timeout that we already discussed.

5
00:00:19,470 --> 00:00:27,630
So we could also utilize 64 bit global timer, and we could also perform profiling of an application

6
00:00:27,630 --> 00:00:27,840
rate.

7
00:00:27,840 --> 00:00:31,710
And that is what we're going to discuss in this special section right now.

8
00:00:31,740 --> 00:00:36,840
We already knew that for an internal resources of the processing system, we do not need to do anything.

9
00:00:36,840 --> 00:00:42,030
So by default, they are enabled and the fundamental block design that we.

10
00:00:43,250 --> 00:00:51,480
Create utilizing ActionScript could be enough to verify the functionality of the 64 bit timer for the

11
00:00:51,510 --> 00:00:57,020
correct, so we will just be utilizing this fundamental drop data and I've already put it in hardware.

12
00:00:57,090 --> 00:00:57,900
Quite OK.

13
00:00:58,280 --> 00:01:01,130
And here just we are listening to young and tired logic.

14
00:01:01,130 --> 00:01:03,080
How we do quite right.

15
00:01:03,350 --> 00:01:07,820
First thing that you need to do is to include extreme underscore elder age halo.

16
00:01:08,100 --> 00:01:15,350
So let's include all the APIs, as well as macros that could be utilized to compute the time right now.

17
00:01:15,350 --> 00:01:18,590
If you just go to an extent, my desk or l dot h.

18
00:01:18,620 --> 00:01:26,030
OK, so you do see a number of a microsite that are available, and along with that, we have two simple

19
00:01:26,030 --> 00:01:26,490
functions.

20
00:01:26,490 --> 00:01:30,650
So something that will be useful in this specific scenario is day, right?

21
00:01:31,520 --> 00:01:38,990
So this will basically weaken the counter value that we have, and here I have 64bit global timer account

22
00:01:38,990 --> 00:01:39,950
counter operating an up.

23
00:01:40,190 --> 00:01:47,510
So as we see it, the next time we purposefully set the mood to be down more here, by default, it

24
00:01:47,510 --> 00:01:55,100
is up right to the expression that we utilize in the previous case was stuck, mainly saying right when

25
00:01:55,100 --> 00:01:56,710
we are discussing any time.

26
00:01:56,900 --> 00:02:02,450
But here, since our counter is working in an Upwork's, it will be doing and minus stock.

27
00:02:02,530 --> 00:02:03,650
OK, remember this fact?

28
00:02:04,070 --> 00:02:07,610
And then you have macros to calculate count per second.

29
00:02:07,820 --> 00:02:12,800
So global timer always clocked at half of the CPU frequency, right?

30
00:02:13,010 --> 00:02:17,840
So our global timer operate at half off the CPU frequency rate to calculate the period.

31
00:02:17,840 --> 00:02:20,550
We just need to take inverse of it, right?

32
00:02:20,570 --> 00:02:24,560
So it will be to divide by CPU frequency right now.

33
00:02:24,560 --> 00:02:27,380
In the previous case, what we are doing is since we.

34
00:02:28,690 --> 00:02:33,370
Work to work around with this parameter, so we directly considered in this two minus seven.

35
00:02:33,580 --> 00:02:40,030
And then we did a multiplication factor here, but here we do not want to change America, right?

36
00:02:40,030 --> 00:02:42,030
So we'll be keeping this as it is now.

37
00:02:42,040 --> 00:02:44,620
This will be giving us frequency in second rate.

38
00:02:44,650 --> 00:02:48,850
This makes sense because this is in and hearts, whatever value that we have.

39
00:02:48,910 --> 00:02:52,030
So when once we dig an inverse of it, this will be the second.

40
00:02:52,780 --> 00:02:56,590
So to get the nanosecond out of it, we just need to multiply it by.

41
00:02:56,950 --> 00:02:59,520
10 this to my dentist, to my right.

42
00:02:59,540 --> 00:03:00,280
This makes sense.

43
00:03:00,610 --> 00:03:05,710
Similarly, to get the microsecond value, OK, we'll just be multiplying by 10.

44
00:03:05,710 --> 00:03:06,400
This just six.

45
00:03:06,700 --> 00:03:13,030
This that some of the fundamentals that you require to know now this entire driver work on a next time,

46
00:03:13,030 --> 00:03:15,640
which is an unsigned 64 bit type, right?

47
00:03:16,000 --> 00:03:20,290
There will be delay to boot of the variable over here.

48
00:03:20,560 --> 00:03:23,200
OK, so state stack g.

49
00:03:23,200 --> 00:03:31,120
And so this will be holding the stacking go and then and you will be holding the ankle right now, will

50
00:03:31,120 --> 00:03:36,240
be utilizing the same function that we use, you know, each side timer, OK, so they'll print it,

51
00:03:36,250 --> 00:03:36,820
dimer ET.

52
00:03:37,210 --> 00:03:40,120
And here we are utilizing get MEPA.

53
00:03:40,150 --> 00:03:45,490
And here we need to specify the pointer to the variable where we want this to come right now.

54
00:03:45,490 --> 00:03:49,030
Since does our simple variable will just be specifying an address of great.

55
00:03:49,510 --> 00:03:54,880
Similarly, after we perform an execution of print, it will just be again game calling it type and

56
00:03:54,880 --> 00:03:57,110
here will be mentioning and right.

57
00:03:57,370 --> 00:04:00,700
So now we have both the count available in stagnancy.

58
00:04:00,850 --> 00:04:04,930
Yep, and since our go big Global Times are operating and upward.

59
00:04:05,260 --> 00:04:05,580
OK.

60
00:04:05,860 --> 00:04:13,220
So to display the number of dropping now, remember there's both of them are in unsigned 64bit, right?

61
00:04:13,540 --> 00:04:17,050
So to bring the value of them, we will just be utilizing print.

62
00:04:17,630 --> 00:04:21,010
OK, and here long, long, unsafe.

63
00:04:21,020 --> 00:04:22,030
So L and u.

64
00:04:22,330 --> 00:04:26,110
OK, so I'm saying to you for that long, long Unsane.

65
00:04:26,120 --> 00:04:30,640
And for that, we will be utilizing the format specified LNG rate.

66
00:04:30,880 --> 00:04:31,780
So person zero.

67
00:04:32,500 --> 00:04:34,360
And it will be a g minus start.

68
00:04:34,360 --> 00:04:39,970
You know what, why we are doing this because our counter is operating in an up right now to compute

69
00:04:40,180 --> 00:04:42,520
the value in nanoseconds.

70
00:04:42,550 --> 00:04:50,910
So we just need to have to two then this too nice and divided by the CPU frequency rate.

71
00:04:51,040 --> 00:04:57,370
So we already have a macro for this, which will be, if you remember, it will be two OK, including

72
00:04:57,380 --> 00:04:59,950
this tonight upon CPU frequency rate.

73
00:04:59,950 --> 00:05:03,510
So this will be the same expression that we have added over.

74
00:05:03,730 --> 00:05:07,150
Similarly, when we want time in a microsecond.

75
00:05:07,180 --> 00:05:14,450
OK, here we will just be multiplying two into six divide by the CPU frequency that we have.

76
00:05:14,530 --> 00:05:22,150
Right again, for all of this, we will be utilizing print Mechagodzilla printer is simply not useful

77
00:05:22,150 --> 00:05:23,430
in this scenario, right?

78
00:05:23,620 --> 00:05:26,170
So all the things we have been doing with the rig.

79
00:05:26,380 --> 00:05:30,850
So let's just go ahead and try to file for programming open FPGA.

80
00:05:30,910 --> 00:05:35,140
Now, in the previous case, you already know the value that we are getting is that our two point five

81
00:05:35,140 --> 00:05:41,980
four microseconds right now with 64bit global time, whereas compared to 32 bit, we'll be getting more.

82
00:05:42,940 --> 00:05:48,640
Higher resolution rate, and that is what we are expecting, so they just go ahead and try to.

83
00:05:49,810 --> 00:05:50,560
Panicked when is.

84
00:05:51,250 --> 00:05:55,780
And they will be performing an execution of an application on a highway.

85
00:05:57,100 --> 00:06:04,210
So now here you could clearly see the value that we are getting is the number of clock ticks 861 and

86
00:06:04,210 --> 00:06:06,750
the value in nanoseconds to five eight two.

87
00:06:06,940 --> 00:06:07,260
Right.

88
00:06:07,660 --> 00:06:13,390
And the value in microsecond is around 2.5 rate than the previous case.

89
00:06:13,390 --> 00:06:15,580
It is around 2.5 four.

90
00:06:15,940 --> 00:06:18,900
And here we are, getting 2.5 eight.

91
00:06:19,270 --> 00:06:22,930
We are getting more resolution as compared to the exciting.

92
00:06:23,270 --> 00:06:29,170
So this is how you could utilize the 64 bit global timer to perform filing off your application.