benchmark/benchmark.c

   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
  26 FILE *fp;
  27 static double g_freq;
  28
  29 static double calibrate_cpu_freq(void)
  30 {
  31         int i, nb_calib = 10;
  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 }
  47
  48 static void open_logs(void)
  49 {
  50         fp = fopen(RESULTS_FILE_NAME, "a");
  51         if (fp == NULL) {
  52                 perror("fopen benchmark");
  53         }
  54 }
  55
  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;
  97         }
  98
  99         return get_bench_time(time_destroy_session_start, time_destroy_session_end);
 100 }
 101
 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
 184         if (time_ust_manage_register_start == 0 ||
 185                         time_ust_manage_register_stop == 0) {
 186                 goto no_data;
 187         }
 188
 189         res = get_bench_time(time_ust_manage_register_start,
 190                         time_ust_manage_register_stop);
 191         fprintf(fp, "Manage UST registration time\n");
 192         fprintf(fp, "Time: %.20f sec.\n", res);
 193
 194         total += res;
 195
 196         fprintf(fp, "Global time of an UST application registration\n");
 197         fprintf(fp, "Time: %.20f sec.\n", total);
 198         return;
 199
 200 no_data:
 201         fprintf(fp, "NO DATA\n");
 202         return;
 203 }
 204
 205
 206 /*
 207  * Log results of the sessiond boot process.
 208  *
 209  * Uses all time_sessiond_* values (see measures.h)
 210  */
 211 void bench_print_boot_process(void)
 212 {
 213         double res;
 214         double global_boot_time = 0.0;
 215
 216         fprintf(fp, "--- Session daemon boot process ---\n");
 217
 218         res = get_bench_time(time_sessiond_boot_start, time_sessiond_boot_end);
 219
 220         fprintf(fp, "Boot time inside main() from start to first pthread_join (blocking state)\n");
 221         fprintf(fp, "Time: %.20f sec.\n", res);
 222
 223         global_boot_time += res;
 224
 225         res = get_bench_time(time_sessiond_th_kern_start, time_sessiond_th_kern_poll);
 226
 227         fprintf(fp, "Boot time of the kernel thread from start to poll() (ready state)\n");
 228         fprintf(fp, "Time: %.20f sec.\n", res);
 229
 230         global_boot_time += res;
 231
 232         res = get_bench_time(time_sessiond_th_apps_start, time_sessiond_th_apps_poll);
 233
 234         fprintf(fp, "Boot time of the application thread from start to poll() (ready state)\n");
 235         fprintf(fp, "Time: %.20f sec.\n", res);
 236
 237         global_boot_time += res;
 238
 239         res = get_bench_time(time_sessiond_th_cli_start, time_sessiond_th_cli_poll);
 240
 241         fprintf(fp, "Boot time of the client thread from start to poll() (ready state)\n");
 242         fprintf(fp, "Time: %.20f sec.\n", res);
 243
 244         global_boot_time += res;
 245
 246         fprintf(fp, "Global Boot Time of ltt-sessiond: %0.20f sec.\n", global_boot_time);
 247 }