Commit | Line | Data |
---|---|---|
b25a8868 DG |
1 | /* |
2 | * Copyright (C) 2011 - David Goulet <david.goulet@polymtl.ca> | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or | |
5 | * modify it under the terms of the GNU General Public License | |
6 | * as published by the Free Software Foundation; only version 2 | |
7 | * of the License. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, | |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | * GNU General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
15 | * along with this program; if not, write to the Free Software | |
16 | * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
17 | */ | |
18 | ||
19 | #include <stdio.h> | |
20 | #include <string.h> | |
21 | #include <sys/time.h> | |
22 | #include <unistd.h> | |
23 | ||
24 | #include "benchmark.h" | |
25 | ||
3c6bae61 DG |
26 | FILE *fp; |
27 | static double g_freq; | |
b25a8868 | 28 | |
3c6bae61 | 29 | static double calibrate_cpu_freq(void) |
b25a8868 | 30 | { |
b25a8868 | 31 | int i, nb_calib = 10; |
3c6bae61 DG |
32 | double freq; |
33 | ||
34 | printf("CPU frequency calibration, this should take 10 seconds\n"); | |
35 | ||
36 | /* CPU Frequency calibration */ | |
37 | for (i = 0; i < nb_calib; i++) { | |
38 | freq += (double) get_cpu_freq(); | |
39 | } | |
40 | return (freq / (double)nb_calib); | |
41 | } | |
42 | ||
43 | static void close_logs(void) | |
44 | { | |
45 | fclose(fp); | |
46 | } | |
b25a8868 | 47 | |
3c6bae61 DG |
48 | static void open_logs(void) |
49 | { | |
50 | fp = fopen(RESULTS_FILE_NAME, "a"); | |
b25a8868 DG |
51 | if (fp == NULL) { |
52 | perror("fopen benchmark"); | |
b25a8868 | 53 | } |
3c6bae61 | 54 | } |
b25a8868 | 55 | |
3c6bae61 DG |
56 | static double get_bench_time(cycles_t before, cycles_t after) |
57 | { | |
58 | double ret; | |
59 | ||
60 | ret = (((double)(after - before) / (g_freq / 1000.0)) / 1000000000.0); | |
61 | ||
62 | return ret; | |
63 | } | |
64 | ||
65 | void bench_init(void) | |
66 | { | |
67 | open_logs(); | |
68 | if (g_freq == 0) { | |
69 | g_freq = calibrate_cpu_freq(); | |
70 | //fprintf(fp, "CPU frequency %f Ghz\n\n", g_freq); | |
71 | } | |
72 | } | |
73 | ||
74 | void bench_close(void) | |
75 | { | |
76 | close_logs(); | |
77 | printf("Benchmark results in %s\n", RESULTS_FILE_NAME); | |
78 | } | |
79 | ||
80 | double bench_get_create_session(void) | |
81 | { | |
82 | if ((time_create_session_start == 0) && | |
83 | (time_create_session_end == 0)) { | |
84 | fprintf(fp, "NO DATA\n"); | |
85 | return 0; | |
86 | } | |
87 | ||
88 | return get_bench_time(time_create_session_start, time_create_session_end); | |
89 | } | |
90 | ||
91 | double bench_get_destroy_session(void) | |
92 | { | |
93 | if ((time_destroy_session_start == 0) && | |
94 | (time_destroy_session_end == 0)) { | |
95 | fprintf(fp, "NO DATA\n"); | |
96 | return 0; | |
b25a8868 | 97 | } |
b25a8868 | 98 | |
3c6bae61 DG |
99 | return get_bench_time(time_destroy_session_start, time_destroy_session_end); |
100 | } | |
b25a8868 | 101 | |
62d53818 DG |
102 | /* |
103 | * Complete UST notification process time break down in different actions. | |
104 | */ | |
105 | void bench_print_ust_notification(void) | |
106 | { | |
107 | double res, total = 0; | |
108 | ||
109 | fprintf(fp, "--- UST notification time ---\n"); | |
110 | ||
111 | if (time_ust_notify_mmap_start == 0 || time_ust_notify_mmap_stop == 0) { | |
112 | goto no_data; | |
113 | } | |
114 | ||
115 | res = get_bench_time(time_ust_notify_mmap_start, | |
116 | time_ust_notify_mmap_stop); | |
117 | fprintf(fp, "mmap() call time\n"); | |
118 | fprintf(fp, "Time: %.20f sec.\n", res); | |
119 | ||
120 | total += res; | |
121 | ||
122 | if (time_ust_notify_perms_start == 0 || time_ust_notify_perms_stop == 0) { | |
123 | goto no_data; | |
124 | } | |
125 | ||
126 | res = get_bench_time(time_ust_notify_perms_start, | |
127 | time_ust_notify_perms_stop); | |
128 | fprintf(fp, "Setting permissions (chown/chmod)\n"); | |
129 | fprintf(fp, "Time: %.20f sec.\n", res); | |
130 | ||
131 | total += res; | |
132 | ||
133 | if (time_ust_notify_shm_start == 0 || time_ust_notify_shm_stop == 0) { | |
134 | goto no_data; | |
135 | } | |
136 | ||
137 | res = get_bench_time(time_ust_notify_shm_start, | |
138 | time_ust_notify_shm_stop); | |
139 | fprintf(fp, "shm_open/ftruncate/fchmod\n"); | |
140 | fprintf(fp, "Time: %.20f sec.\n", res); | |
141 | ||
142 | total += res; | |
143 | ||
144 | fprintf(fp, "Global UST nonification time\n"); | |
145 | fprintf(fp, "Time: %.20f sec.\n", total); | |
146 | return; | |
147 | ||
148 | no_data: | |
149 | fprintf(fp, "NO DATA\n"); | |
150 | return; | |
151 | } | |
152 | ||
153 | /* | |
154 | * This time value is only coherent is an UST application registered. | |
155 | */ | |
156 | void bench_print_ust_register(void) | |
157 | { | |
158 | double res, total = 0; | |
159 | ||
160 | fprintf(fp, "--- UST registration time ---\n"); | |
161 | ||
162 | if (time_ust_register_start == 0 || time_ust_register_stop == 0) { | |
163 | goto no_data; | |
164 | } | |
165 | ||
166 | res = get_bench_time(time_ust_register_start, time_ust_register_stop); | |
167 | fprintf(fp, "UST registration received and send to dispatch time\n"); | |
168 | fprintf(fp, "Time: %.20f sec.\n", res); | |
169 | ||
170 | total += res; | |
171 | ||
172 | if (time_ust_dispatch_register_start == 0 || | |
173 | time_ust_dispatch_register_stop == 0) { | |
174 | goto no_data; | |
175 | } | |
176 | ||
177 | res = get_bench_time(time_ust_dispatch_register_start, | |
178 | time_ust_dispatch_register_stop); | |
179 | fprintf(fp, "Dispatch UST registration request time\n"); | |
180 | fprintf(fp, "Time: %.20f sec.\n", res); | |
181 | ||
182 | total += res; | |
183 | ||
85c434ee DG |
184 | fprintf(fp, "--> Manage registration breakdown\n"); |
185 | ||
186 | res = get_bench_time(time_ust_register_read_start, | |
187 | time_ust_register_read_stop); | |
188 | fprintf(fp, "read() from pipe time\n"); | |
189 | fprintf(fp, "Time: %.20f sec.\n", res); | |
62d53818 | 190 | |
85c434ee DG |
191 | total += res; |
192 | ||
193 | res = get_bench_time(time_ust_register_add_start, | |
194 | time_ust_register_add_stop); | |
195 | fprintf(fp, "register_traceable_app time\n"); | |
196 | fprintf(fp, "Time: %.20f sec.\n", res); | |
197 | ||
198 | total += res; | |
199 | ||
200 | res = get_bench_time(time_ust_register_done_start, | |
201 | time_ust_register_done_stop); | |
202 | fprintf(fp, "send register done command time\n"); | |
62d53818 DG |
203 | fprintf(fp, "Time: %.20f sec.\n", res); |
204 | ||
205 | total += res; | |
206 | ||
207 | fprintf(fp, "Global time of an UST application registration\n"); | |
208 | fprintf(fp, "Time: %.20f sec.\n", total); | |
209 | return; | |
210 | ||
211 | no_data: | |
212 | fprintf(fp, "NO DATA\n"); | |
213 | return; | |
214 | } | |
215 | ||
216 | ||
3c6bae61 DG |
217 | /* |
218 | * Log results of the sessiond boot process. | |
219 | * | |
220 | * Uses all time_sessiond_* values (see measures.h) | |
221 | */ | |
222 | void bench_print_boot_process(void) | |
223 | { | |
224 | double res; | |
225 | double global_boot_time = 0.0; | |
226 | ||
227 | fprintf(fp, "--- Session daemon boot process ---\n"); | |
b25a8868 | 228 | |
3c6bae61 | 229 | res = get_bench_time(time_sessiond_boot_start, time_sessiond_boot_end); |
b25a8868 | 230 | |
85c434ee DG |
231 | fprintf(fp, "Inside main() from start to first pthread_join" |
232 | "(blocking state)\n"); | |
233 | fprintf(fp, "Time: %.20f sec.\n", res); | |
234 | ||
235 | global_boot_time += res; | |
236 | ||
237 | res = get_bench_time(time_sessiond_th_kern_start, | |
238 | time_sessiond_th_kern_poll); | |
239 | ||
240 | fprintf(fp, "Kernel thread from start to poll() (ready state)\n"); | |
b25a8868 DG |
241 | fprintf(fp, "Time: %.20f sec.\n", res); |
242 | ||
243 | global_boot_time += res; | |
244 | ||
85c434ee DG |
245 | res = get_bench_time(time_sessiond_th_apps_start, |
246 | time_sessiond_th_apps_poll); | |
b25a8868 | 247 | |
85c434ee | 248 | fprintf(fp, "Application thread from start to poll() (ready state)\n"); |
b25a8868 DG |
249 | fprintf(fp, "Time: %.20f sec.\n", res); |
250 | ||
251 | global_boot_time += res; | |
252 | ||
85c434ee DG |
253 | res = get_bench_time(time_sessiond_th_cli_start, |
254 | time_sessiond_th_cli_poll); | |
b25a8868 | 255 | |
85c434ee | 256 | fprintf(fp, "Client thread from start to poll() (ready state)\n"); |
b25a8868 DG |
257 | fprintf(fp, "Time: %.20f sec.\n", res); |
258 | ||
259 | global_boot_time += res; | |
260 | ||
85c434ee DG |
261 | res = get_bench_time(time_sessiond_th_dispatch_start, |
262 | time_sessiond_th_dispatch_block); | |
b25a8868 | 263 | |
85c434ee DG |
264 | fprintf(fp, "Dispatch registration thread from start to poll()" |
265 | "(ready state)\n"); | |
b25a8868 DG |
266 | fprintf(fp, "Time: %.20f sec.\n", res); |
267 | ||
268 | global_boot_time += res; | |
269 | ||
85c434ee DG |
270 | fprintf(fp, "Global Boot Time\n"); |
271 | fprintf(fp, "Time: %0.20f sec.\n", global_boot_time); | |
b25a8868 | 272 | } |