1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
.. _profiler:
**profiler.h** -- performance profiling
===============================================================================
Most of this module is only usable on certain platforms, while ``timeit``
functions is available on all platforms. The only platforms that can access
the whole module is x86-64 and ARM64 on Unix type systems.
Timer based on clock
--------------------------------------------------------------------------------
.. function:: void timeit_start(timeit_t t)
void timeit_stop(timeit_t t)
void timeit_print(timeit_t t, ulong reps)
Gives wall and user time - useful for parallel programming.
Example usage::
timeit_t t0;
timeit_start(t0);
// do stuff, take some time
timeit_stop(t0);
timeit_print(t0, 1); // only one repetition was done
.. macro:: TIMEIT_REPEAT(timer, reps)
TIMEIT_END_REPEAT(timer, reps)
Repeatedly runs the code between the ``TIMEIT_REPEAT`` and the
``TIMEIT_END_REPEAT`` markers, automatically increasing the number of
repetitions until the elapsed time exceeds the timer resolution. The macro
takes as input a predefined ``timeit_t`` object and an integer variable to
hold the number of repetitions.
.. macro:: TIMEIT_START
TIMEIT_STOP
Repeatedly runs the code between the ``TIMEIT_START`` and the
``TIMEIT_STOP`` markers, automatically increasing the number of repetitions
until the elapsed time exceeds the timer resolution, and then prints the
average elapsed cpu and wall time for a single repetition.
.. macro:: TIMEIT_ONCE_START
TIMEIT_ONCE_STOP
Runs the code between the ``TIMEIT_ONCE_START`` and the
``TIMEIT_ONCE_STOP`` markers exactly once and then prints the elapsed cpu
and wall time. This does not give a precise measurement if the elapsed time
is short compared to the timer resolution.
Timer based on cycle counter
--------------------------------------------------------------------------------
.. function:: void init_clock(int n)
void init_all_clocks(void)
void start_clock(int n)
void stop_clock(int n)
double get_clock(int n)
Gives time based on cycle counter.
First one must ensure the processor speed in cycles per second is set
correctly in ``profiler.h``, in the macro definition ``#define
FLINT_CLOCKSPEED``.
One can access the cycle counter directly by :func:`get_cycle_counter`
which returns the current cycle counter as a ``double``.
A sample usage of clocks is::
init_all_clocks();
start_clock(n);
// do something
stop_clock(n);
flint_printf("Time in seconds is %f.3\n", get_clock(n));
where ``n`` is a clock number (from 0-19 by default). The number of
clocks can be changed by altering ``FLINT_NUM_CLOCKS``. One can also
initialise an individual clock with ``init_clock(n)``.
.. function:: void prof_repeat(double * min, double * max, profile_target_t target, void * arg)
Allows one to automatically time a given function. Here is a sample usage:
Suppose one has a function one wishes to profile::
void myfunc(ulong a, ulong b);
One creates a struct for passing arguments to our function::
typedef struct { ulong a, b; } myfunc_t;
a sample function::
void sample_myfunc(void * arg, ulong count)
{
myfunc_t * params = (myfunc_t *) arg;
ulong a = params->a;
ulong b = params->b;
for (ulong i = 0; i < count; i++)
{
prof_start();
myfunc(a, b);
prof_stop();
}
}
Then we do the profile::
double min, max;
myfunc_t params;
params.a = 3;
params.b = 4;
prof_repeat(&min, &max, sample_myfunc, ¶ms);
flint_printf("Min time is %lf.3s, max time is %lf.3s\n", min, max);
If either of the first two parameters to ``prof_repeat`` is
``NULL``, that value is not stored.
One may set the minimum time in microseconds for a timing run by
adjusting ``DURATION_THRESHOLD`` and one may set a target duration
in microseconds by adjusting ``DURATION_TARGET`` in ``profiler.h``.
Memory usage
--------------------------------------------------------------------------------
.. function:: void fprint_memory_usage(FILE * fs)
void print_memory_usage(void)
Obtains information about the memory usage of the current process.
|
