caiyu/gmio
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

benchmarks: let size of table columns adapts to contents

Browse Source
This commit is contained in:
Hugues Delorme 2015-10-28 14:56:52 +01:00
parent 7a63ad86aa
commit 5d514218ac
2 changed files with 198 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

216
benchmarks/commons/benchmark_tools.c
View File

@ -15,6 +15,7 @@
#include "benchmark_tools.h"
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
@ -26,7 +27,9 @@
# define BENCHMARK_TIMER_LIBC
#endif
typedef struct benchmark_timer
/* Benchmark timers */
struct benchmark_timer
{
#ifdef BENCHMARK_TIMER_WINDOWS
LARGE_INTEGER start_time;
@ -34,7 +37,8 @@ typedef struct benchmark_timer
#elif defined(BENCHMARK_TIMER_LIBC)
clock_t start_tick;
#endif
} benchmark_timer_t;
};
typedef struct benchmark_timer benchmark_timer_t;
static void benchmark_timer_start(benchmark_timer_t* timer)
{
@ -72,6 +76,151 @@ static int64_t benchmark_timer_elapsed_ms(const benchmark_timer_t* timer)
#endif
}
/* Wraps around formatted printing functions */
/*! Wrapp around sprintf() to be used with gprintf_func_exec_time() */
static void sprintf_wrap(void* cookie, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
vsprintf((char*)cookie, fmt, args);
va_end(args);
}
/*! Wrap around printf() to be used with gprintf_func_exec_time() */
static void printf_wrap(void* cookie, const char* fmt, ...)
{
va_list args;
GMIO_UNUSED(cookie);
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
}
/*! Typedef on pointer to printf-wrap functions(eg. sprintf_wrap()) */
typedef void (*func_gprintf_t)(void*, const char*, ...);
/* Utilities */
/*! Calls printf(str) \p n times */
static void print_string_n(const char* str, size_t n)
{
size_t i; /* for-loop index*/
for (i = 0; i < n; ++i)
printf(str);
}
/*! Safe wrapper around strlen() for NULL strings */
GMIO_INLINE size_t safe_strlen(const char* str)
{
return str != NULL ? strlen(str) : 0;
}
/*! Returns the maximum of two size_t values */
GMIO_INLINE size_t size_t_max(size_t lhs, size_t rhs)
{
return lhs > rhs ? lhs : rhs;
}
/*! String representation of the unit used for execution time */
static const char* unit_time_str = "ms";
/*! Generic formatted print of some execution time */
static void gprintf_func_exec_time(
/* Annex data for func_gprintf (ex: char* for sprintf()) */
void* cookie,
/* Function ptr on a printf wrap (ex: sprintf_wrap()) */
func_gprintf_t func_gprintf,
/* Width of the print column, if any (can be == 0) */
size_t width_column,
/* Execution time, in ms */
size_t time_ms,
/* Valid execution time ? */
gmio_bool_t has_time)
{
if (has_time) {
char str_time[128] = {0};
/* TODO: %ull is not accepted by mingw, find a fix(maybe %ul64) */
sprintf(str_time, "%u%s", (unsigned)time_ms, unit_time_str);
if (width_column > 0)
func_gprintf(cookie, "%-*s", width_column, str_time);
else
func_gprintf(cookie, "%s", str_time);
}
else {
const char n_a[] = "N/A";
if (width_column > 0)
func_gprintf(cookie, "%-*s", width_column, n_a);
else
func_gprintf(cookie, "%s", n_a);
}
}
/*! Helper for printf() around gprintf_func_exec_time() */
static void printf_func_exec_time(
size_t width_column,
size_t time_ms,
gmio_bool_t has_time)
{
gprintf_func_exec_time(
NULL, &printf_wrap, width_column, time_ms, has_time);
}
/*! Returns the strlen of the longest tag string */
static size_t find_maxlen_cmp_result_tag(benchmark_cmp_result_array_t res_array)
{
size_t max_len = 0;
size_t i;
for (i = 0; i < res_array.count; ++i) {
const size_t len = safe_strlen(res_array.ptr[i].tag);
max_len = size_t_max(len, max_len);
}
return max_len;
}
/*! Writes in output args the func1 execution informations */
static void select_cmp_result_func1_exec_infos(
const benchmark_cmp_result_t* cmp, size_t* time, gmio_bool_t* has_time)
{
*time = cmp->func1_exec_time_ms;
*has_time = cmp->has_func1_exec_time;
}
/*! Writes in output args the func2 execution informations */
static void select_cmp_result_func2_exec_infos(
const benchmark_cmp_result_t* cmp, size_t* time, gmio_bool_t* has_time)
{
*time = cmp->func2_exec_time_ms;
*has_time = cmp->has_func2_exec_time;
}
/*! Typedef on pointer to functions like select_cmp_result_funcX_exec_infos() */
typedef void (*func_select_cmp_result_func_exec_infos_t)(
const benchmark_cmp_result_t*, size_t*, gmio_bool_t*);
/*! Returns the strlen of the longest execution time string */
static size_t find_maxlen_cmp_result_func_exec_time(
benchmark_cmp_result_array_t res_array,
func_select_cmp_result_func_exec_infos_t func_select_exec_infos)
{
char strbuff[1024] = {0};
size_t max_len = 0;
size_t i;
for (i = 0; i < res_array.count; ++i) {
size_t time = 0;
gmio_bool_t has_time = GMIO_FALSE;
size_t len = 0;
func_select_exec_infos(&res_array.ptr[i], &time, &has_time);
gprintf_func_exec_time(strbuff, &sprintf_wrap, 0, time, has_time);
len = safe_strlen(strbuff);
max_len = size_t_max(len, max_len);
}
return max_len;
}
/* Implementation */
benchmark_cmp_result_t benchmark_cmp(benchmark_cmp_arg_t arg)
{
benchmark_cmp_result_t result = {0};
@ -95,61 +244,56 @@ benchmark_cmp_result_t benchmark_cmp(benchmark_cmp_arg_t arg)
return result;
}
static void printf_string_n(const char* str, size_t n)
{
size_t i; /* for-loop index*/
for (i = 0; i < n; ++i)
printf(str);
}
static const int width_tag_col = 20;
static const int width_func_col = 10;
static const char* unit_time_str = "ms";
static void printf_func_exec_time(
size_t func_exec_time_ms, gmio_bool_t has_func_exec_time)
{
if (has_func_exec_time) {
char str_exec_time[128] = {0};
/* TODO: %ull is not accepted by mingw, find a fix(maybe %ul64) */
sprintf(str_exec_time, "%u%s", func_exec_time_ms, unit_time_str);
printf("%-*s", width_func_col, str_exec_time);
}
else {
printf("%-*s", width_func_col, "N/A");
}
}
void benchmark_print_results(
benchmark_print_format_t format,
benchmark_cmp_result_header_t header,
benchmark_cmp_result_array_t result_array)
{
if (format == BENCHMARK_PRINT_FORMAT_MARKDOWN) {
const char* header_comp1 =
header.component_1 != NULL ? header.component_1 : "";
const char* header_comp2 =
header.component_2 != NULL ? header.component_2 : "";
const size_t width_tag_col =
find_maxlen_cmp_result_tag(result_array);
const size_t width_func1_col =
size_t_max(
find_maxlen_cmp_result_func_exec_time(
result_array, &select_cmp_result_func1_exec_infos),
safe_strlen(header_comp1));
const size_t width_func2_col =
size_t_max(
find_maxlen_cmp_result_func_exec_time(
result_array, &select_cmp_result_func2_exec_infos),
safe_strlen(header_comp2));
size_t i; /* for-loop index*/
/* Print table header */
printf("%*s | ", width_tag_col, "");
printf("%-*s | ", width_func_col, header.component_1);
printf("%-*s\n", width_func_col, header.component_2);
printf("%*s | ", (int)width_tag_col, "");
printf("%-*s | ", (int)width_func1_col, header_comp1);
printf("%-*s\n", (int)width_func2_col, header_comp2);
/* Print separation between header and results */
printf_string_n("-", width_tag_col + 1);
print_string_n("-", width_tag_col + 1);
printf("|");
printf_string_n("-", width_func_col + strlen(unit_time_str));
print_string_n("-", width_func1_col + 2);
printf("|");
printf_string_n("-", width_func_col + strlen(unit_time_str));
print_string_n("-", width_func2_col + 2);
printf("\n");
/* Print benchmark result lines */
for (i = 0; i < result_array.count; ++i) {
const benchmark_cmp_result_t result = result_array.ptr[i];
printf("%-*s | ", width_tag_col, result.tag);
printf("%-*s | ", (int)width_tag_col, result.tag);
printf_func_exec_time(
result.func1_exec_time_ms, result.has_func1_exec_time);
width_func1_col,
result.func1_exec_time_ms,
result.has_func1_exec_time);
printf(" | ");
printf_func_exec_time(
result.func2_exec_time_ms, result.has_func2_exec_time);
width_func2_col,
result.func2_exec_time_ms,
result.has_func2_exec_time);
printf("\n");
}
}

18
benchmarks/commons/benchmark_tools.h
View File

@ -21,32 +21,47 @@
GMIO_C_LINKAGE_BEGIN
/*! Typedef on pointer to function to be benchmarked(execution time) */
typedef void (*benchmark_file_func_t)(const char*);
/* benchmark_cmp */
/*! Describes a comparison benchmark between two functions */
struct benchmark_cmp_arg
{
/*! Brief description of the comparison(eg. "Write to file") */
const char* tag;
/*! Pointer to the 1st function */
benchmark_file_func_t func1;
/*! Argument passed to the 1st function on exec */
const char* func1_filepath;
/*! Pointer to the 2nd function */
benchmark_file_func_t func2;
/*! Argument passed to the 2nd function on exec */
const char* func2_filepath;
};
typedef struct benchmark_cmp_arg benchmark_cmp_arg_t;
/*! Holds the result of the exec time comparison between two functions */
struct benchmark_cmp_result
{
/*! Identifies the comparison */
const char* tag;
/*! Execution time(in ms) of the 1st function */
size_t func1_exec_time_ms;
/*! Is exec time of the 1st function valid ? */
gmio_bool_t has_func1_exec_time;
/*! Execution time(in ms) of the 2nd function */
size_t func2_exec_time_ms;
/*! Is exec time of the 2nd function valid ? */
gmio_bool_t has_func2_exec_time;
};
typedef struct benchmark_cmp_result benchmark_cmp_result_t;
/*! Runs func1 then func2 and measures the respective execution time */
benchmark_cmp_result_t benchmark_cmp(benchmark_cmp_arg_t arg);
/*! Runs a batch(array) of comparison benchmarks */
void benchmark_cmp_batch(
size_t run_count,
const benchmark_cmp_arg_t* arg_array,
@ -63,6 +78,7 @@ enum benchmark_print_format
};
typedef enum benchmark_print_format benchmark_print_format_t;
/*! Array of benchmark_cmp_result */
struct benchmark_cmp_result_array
{
const benchmark_cmp_result_t* ptr;
@ -70,6 +86,7 @@ struct benchmark_cmp_result_array
};
typedef struct benchmark_cmp_result_array benchmark_cmp_result_array_t;
/*! Horizontal header labels for benchmark results(by column) */
struct benchmark_cmp_result_header
{
const char* component_1;
@ -77,6 +94,7 @@ struct benchmark_cmp_result_header
};
typedef struct benchmark_cmp_result_header benchmark_cmp_result_header_t;
/*! Prints formatted benchmark results */
void benchmark_print_results(
benchmark_print_format_t format,
benchmark_cmp_result_header_t header,