/* * Copyright (c) 2009 * Tama Communications Corporation * * This file is part of GNU GLOBAL. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #if HAVE_CONFIG_H #include #endif #if TIME_WITH_SYS_TIME #include #include #elif HAVE_SYS_TIME_H #include #else #include #endif #if HAVE_SYS_RESOURCE_H #include #endif #include #include #include #include #include #include #include "checkalloc.h" #include "die.h" #include "queue.h" #include "statistics.h" #include "strbuf.h" #if !defined(timeradd) #define timeradd(a, b, r) do { \ (r)->tv_sec = (a)->tv_sec + (b)->tv_sec; \ (r)->tv_usec = (a)->tv_usec + (b)->tv_usec; \ if ((r)->tv_usec >= 1000000) { \ (r)->tv_sec++; \ (r)->tv_usec -= 1000000; \ } \ } while (0) #endif #if !defined(timersub) #define timersub(a, b, r) do { \ (r)->tv_sec = (a)->tv_sec - (b)->tv_sec; \ (r)->tv_usec = (a)->tv_usec - (b)->tv_usec; \ if ((r)->tv_usec < 0) { \ (r)->tv_sec--; \ (r)->tv_usec += 1000000; \ } \ } while (0) #endif #if HAVE_GETTIMEOFDAY typedef struct timeval ELAPSED_TIME_TYPE; #define GET_ELAPSED_TIME(p) gettimeofday(p, NULL) #define SUB_ELAPSED_TIME(a, b, r) do { \ struct timeval diff; \ timersub(a, b, &diff); \ *(r) = diff.tv_sec + diff.tv_usec * 1e-6; \ } while (0) #if HAVE_GETRUSAGE typedef struct timeval CPU_TIME_TYPE; #define GET_CPU_TIME(pu, ps) do { \ struct rusage self, children; \ getrusage(RUSAGE_SELF, &self); \ getrusage(RUSAGE_CHILDREN, &children); \ timeradd(&self.ru_utime, &children.ru_utime, pu); \ timeradd(&self.ru_stime, &children.ru_stime, ps); \ } while (0) #define SUB_CPU_TIME SUB_ELAPSED_TIME #define CPU_TIME_AVAILABLE 1 #else #define CPU_TIME_AVAILABLE 0 #endif #else typedef time_t ELAPSED_TIME_TYPE; #define GET_ELAPSED_TIME(p) time(p) #define SUB_ELAPSED_TIME(a, b, r) (*(r) = *(a) - *(b)) #define CPU_TIME_AVAILABLE 0 #endif struct statistics_time { STAILQ_ENTRY(statistics_time) next; ELAPSED_TIME_TYPE elapsed_start; double elapsed; /**< Elapsed time in seconds. */ #if CPU_TIME_AVAILABLE CPU_TIME_TYPE user_start; CPU_TIME_TYPE system_start; double user; /**< User time in seconds. */ double system; /**< System time in seconds. */ double percent; /**< (user + system) * 100 / elapsed */ /**< percent may be NaN or infinity. */ #endif int name_len; char name[1]; }; static STRBUF *sb; static STATISTICS_TIME *T_all; static STAILQ_HEAD(statistics_time_list, statistics_time) statistics_time_list = STAILQ_HEAD_INITIALIZER(statistics_time_list); void init_statistics(void) { assert(sb == NULL); sb = strbuf_open(0); T_all = statistics_time_start("The entire time"); } STATISTICS_TIME * statistics_time_start(const char *fmt, ...) { STATISTICS_TIME *t; va_list ap; strbuf_reset(sb); va_start(ap, fmt); strbuf_vsprintf(sb, fmt, ap); va_end(ap); t = check_malloc(offsetof(STATISTICS_TIME, name) + strbuf_getlen(sb) + 1); t->name_len = strbuf_getlen(sb); strcpy(t->name, strbuf_value(sb)); GET_ELAPSED_TIME(&t->elapsed_start); #if CPU_TIME_AVAILABLE GET_CPU_TIME(&t->user_start, &t->system_start); #endif return t; } void statistics_time_end(STATISTICS_TIME *t) { ELAPSED_TIME_TYPE elapsed_end; #if CPU_TIME_AVAILABLE CPU_TIME_TYPE user_end; CPU_TIME_TYPE system_end; #endif GET_ELAPSED_TIME(&elapsed_end); SUB_ELAPSED_TIME(&elapsed_end, &t->elapsed_start, &t->elapsed); #if CPU_TIME_AVAILABLE GET_CPU_TIME(&user_end, &system_end); SUB_CPU_TIME(&user_end, &t->user_start, &t->user); SUB_CPU_TIME(&system_end, &t->system_start, &t->system); t->percent = (t->elapsed == 0) ? ( #if defined(NAN) (t->user + t->system == 0) ? NAN : #endif #if defined(INFINITY) INFINITY #else HUGE_VAL #endif ) : ((t->user + t->system) / t->elapsed * 100); #endif STAILQ_INSERT_TAIL(&statistics_time_list, t, next); } struct printing_width { int name; int elapsed; #if CPU_TIME_AVAILABLE int user; int system; int percent; #endif }; static int decimal_width(unsigned long num) { int width = 1; while (num >= 10) { num /= 10; width++; } return width; } #define ELAPSED_PRECISION 3 #define USER_PRECISION 3 #define SYSTEM_PRECISION 3 #define PERCENT_PRECISION 1 #define STR(x) #x #define XSTR(x) STR(x) #define PRECISION_STRING(x) XSTR(x##_PRECISION) static void get_max_width(struct printing_width *max_width) { const STATISTICS_TIME *t; int w; #if CPU_TIME_AVAILABLE char buf[64]; #endif STAILQ_FOREACH(t, &statistics_time_list, next) { if (t->name_len > max_width->name) max_width->name = t->name_len; w = decimal_width(t->elapsed) + ELAPSED_PRECISION + 1; if (w > max_width->elapsed) max_width->elapsed = w; #if CPU_TIME_AVAILABLE w = decimal_width(t->user) + USER_PRECISION + 1; if (w > max_width->user ) max_width->user = w; w = decimal_width(t->system) + SYSTEM_PRECISION + 1; if (w > max_width->system) max_width->system = w; /* * Printing style of NaN and infinity is implementation-defined. * Therefore, it is impossible to know printing width without calling snprintf. */ w = snprintf(buf, sizeof(buf), "%." PRECISION_STRING(PERCENT) "f", t->percent); if (w > max_width->percent) max_width->percent = w; #endif } } #define MIN_DOTS_LEN 3 static void print_header_list(void **ppriv) { struct printing_width max_width; char *dots; memset(&max_width, 0, sizeof(max_width)); get_max_width(&max_width); *ppriv = dots = check_malloc(sizeof(max_width) + max_width.name + MIN_DOTS_LEN + 1); memcpy(dots, &max_width, sizeof(max_width)); dots += sizeof(max_width); memset(dots, '.', max_width.name + MIN_DOTS_LEN); dots[max_width.name + MIN_DOTS_LEN] = '\0'; setverbose(); } static void print_time_list(const STATISTICS_TIME *t, void *priv) { const struct printing_width *max_width = priv; const char *dots = (const char *)&max_width[1]; #if CPU_TIME_AVAILABLE message("- %s %s" " user %*." PRECISION_STRING(USER) "fs" " system %*." PRECISION_STRING(SYSTEM) "fs" " elapsed %*." PRECISION_STRING(ELAPSED) "fs" " %*." PRECISION_STRING(PERCENT) "f%%", t->name, dots + t->name_len, max_width->user, t->user, max_width->system, t->system, max_width->elapsed, t->elapsed, max_width->percent, t->percent); #else message("- %s %s" " elapsed %*." PRECISION_STRING(ELAPSED) "fs", t->name, dots + t->name_len, max_width->elapsed, t->elapsed); #endif } static const char name_heading_string[] = "period"; static const char elapsed_heading_string[] = "elapsed[sec]"; #if CPU_TIME_AVAILABLE static const char user_heading_string[] = "user[sec]"; static const char system_heading_string[] = "system[sec]"; static const char percent_heading_string[] = "%CPU"; #endif static void print_header_table(void **ppriv) { struct printing_width max_width; char *bar; int bar_len; max_width.name = sizeof(name_heading_string) - 1; max_width.elapsed = sizeof(elapsed_heading_string) - 1; #if CPU_TIME_AVAILABLE max_width.user = sizeof(user_heading_string) - 1; max_width.system = sizeof(system_heading_string) - 1; max_width.percent = sizeof(percent_heading_string) - 1; #endif get_max_width(&max_width); bar_len = (max_width.name > max_width.elapsed) ? max_width.name : max_width.elapsed; #if CPU_TIME_AVAILABLE if (max_width.user > bar_len) bar_len = max_width.user; if (max_width.system > bar_len) bar_len = max_width.system; if (max_width.percent > bar_len) bar_len = max_width.percent; #endif *ppriv = bar = check_malloc(sizeof(max_width) + bar_len + 1); memcpy(bar, &max_width, sizeof(max_width)); bar += sizeof(max_width); memset(bar, '-', bar_len); bar[bar_len] = '\0'; setverbose(); #if CPU_TIME_AVAILABLE message("%-*s %*s %*s %*s %*s", max_width.name, name_heading_string, max_width.user, user_heading_string, max_width.system, system_heading_string, max_width.elapsed, elapsed_heading_string, max_width.percent, percent_heading_string); message("%.*s %.*s %.*s %.*s %.*s", max_width.name, bar, max_width.user, bar, max_width.system, bar, max_width.elapsed, bar, max_width.percent, bar); #else message("%-*s %*s", max_width.name, name_heading_string, max_width.elapsed, elapsed_heading_string); message("%.*s %.*s", max_width.name, bar, max_width.elapsed, bar); #endif } static void print_time_table(const STATISTICS_TIME *t, void *priv) { const struct printing_width *max_width = priv; const char *bar = (const char *)&max_width[1]; if (t == T_all) { #if CPU_TIME_AVAILABLE message("%.*s %.*s %.*s %.*s %.*s", max_width->name, bar, max_width->user, bar, max_width->system, bar, max_width->elapsed, bar, max_width->percent, bar); #else message("%.*s %.*s", max_width->name, bar, max_width->elapsed, bar); #endif } #if CPU_TIME_AVAILABLE message("%-*s" " %*." PRECISION_STRING(USER) "f" " %*." PRECISION_STRING(SYSTEM) "f" " %*." PRECISION_STRING(ELAPSED) "f" " %*." PRECISION_STRING(PERCENT) "f", max_width->name, t->name, max_width->user, t->user, max_width->system, t->system, max_width->elapsed, t->elapsed, max_width->percent, t->percent); #else message("%-*s" " %*." PRECISION_STRING(ELAPSED) "f", max_width->name, t->name, max_width->elapsed, t->elapsed); #endif } static void print_footer_common(void *priv) { free(priv); } struct printng_style { void (*print_header)(void **); void (*print_time)(const STATISTICS_TIME *, void *); void (*print_footer)(void *); }; static const struct printng_style printing_styles[] = { /* STATISTICS_STYLE_NONE */ { NULL, NULL, NULL }, /* STATISTICS_STYLE_LIST */ { print_header_list, print_time_list, print_footer_common }, /* STATISTICS_STYLE_TABLE */ { print_header_table, print_time_table, print_footer_common }, }; #if !defined(ARRAY_SIZE) #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) #endif void print_statistics(int style_no) { const struct printng_style *style; STATISTICS_TIME *t; void *priv; assert(T_all != NULL); statistics_time_end(T_all); assert(style_no >= 0 && style_no < ARRAY_SIZE(printing_styles)); style = &printing_styles[style_no]; if (style->print_header != NULL) style->print_header(&priv); while (!STAILQ_EMPTY(&statistics_time_list)) { t = STAILQ_FIRST(&statistics_time_list); if (style->print_time != NULL) style->print_time(t, priv); STAILQ_REMOVE_HEAD(&statistics_time_list, next); free(t); } if (style->print_footer != NULL) style->print_footer(priv); strbuf_close(sb); T_all = NULL; sb = NULL; }