/* A simple benchmark: how long does it take to use libgccjit to compile and run a simple function? */ #include #include #include #include #include "libgccjit.h" #define TEST_ESCHEWS_SET_OPTIONS #define TEST_ESCHEWS_TEST_JIT #define TEST_PROVIDES_MAIN #include "harness.h" void create_code (gcc_jit_context *ctxt, void *user_data) { /* Simple sum-of-squares, to test conditionals and looping int loop_test (int n) { int i; int sum = 0; for (i = 0; i < n ; i ++) { sum += i * i; } return sum; */ gcc_jit_type *the_type = gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT); gcc_jit_type *return_type = the_type; gcc_jit_param *n = gcc_jit_context_new_param (ctxt, NULL, the_type, "n"); gcc_jit_param *params[1] = {n}; gcc_jit_function *func = gcc_jit_context_new_function (ctxt, NULL, GCC_JIT_FUNCTION_EXPORTED, return_type, "loop_test", 1, params, 0); /* Build locals: */ gcc_jit_lvalue *i = gcc_jit_function_new_local (func, NULL, the_type, "i"); gcc_jit_lvalue *sum = gcc_jit_function_new_local (func, NULL, the_type, "sum"); gcc_jit_block *initial = gcc_jit_function_new_block (func, "initial"); gcc_jit_block *loop_cond = gcc_jit_function_new_block (func, "loop_cond"); gcc_jit_block *loop_body = gcc_jit_function_new_block (func, "loop_body"); gcc_jit_block *after_loop = gcc_jit_function_new_block (func, "after_loop"); /* sum = 0; */ gcc_jit_block_add_assignment ( initial, NULL, sum, gcc_jit_context_new_rvalue_from_int (ctxt, the_type, 0)); /* i = 0; */ gcc_jit_block_add_assignment ( initial, NULL, i, gcc_jit_context_new_rvalue_from_int (ctxt, the_type, 0)); gcc_jit_block_end_with_jump (initial, NULL, loop_cond); /* if (i >= n) */ gcc_jit_block_end_with_conditional ( loop_cond, NULL, gcc_jit_context_new_comparison ( ctxt, NULL, GCC_JIT_COMPARISON_GE, gcc_jit_lvalue_as_rvalue (i), gcc_jit_param_as_rvalue (n)), after_loop, loop_body); /* sum += i * i */ gcc_jit_block_add_assignment ( loop_body, NULL, sum, gcc_jit_context_new_binary_op ( ctxt, NULL, GCC_JIT_BINARY_OP_PLUS, the_type, gcc_jit_lvalue_as_rvalue (sum), gcc_jit_context_new_binary_op ( ctxt, NULL, GCC_JIT_BINARY_OP_MULT, the_type, gcc_jit_lvalue_as_rvalue (i), gcc_jit_lvalue_as_rvalue (i)))); /* i++ */ gcc_jit_block_add_assignment ( loop_body, NULL, i, gcc_jit_context_new_binary_op ( ctxt, NULL, GCC_JIT_BINARY_OP_PLUS, the_type, gcc_jit_lvalue_as_rvalue (i), gcc_jit_context_new_rvalue_from_int ( ctxt, the_type, 1))); gcc_jit_block_end_with_jump (loop_body, NULL, loop_cond); /* return sum */ gcc_jit_block_end_with_return ( after_loop, NULL, gcc_jit_lvalue_as_rvalue (sum)); } void verify_code (gcc_jit_context *ctxt, gcc_jit_result *result) { typedef int (*loop_test_fn_type) (int); if (!result) { fail ("%s: %s: !result", test, __func__); return; } loop_test_fn_type loop_test = (loop_test_fn_type)gcc_jit_result_get_code (result, "loop_test"); if (!loop_test) { fail ("%s: %s: !loop_test", test, __func__); return; } int val = loop_test (100); if (val != 328350) fail ("%s: %s: val != 328350", test, __func__); } /* Run one iteration of the test. */ static void test_jit (const char *argv0, int opt_level, gcc_jit_timer *timer) { gcc_jit_context *ctxt; gcc_jit_result *result; gcc_jit_timer_push (timer, "test_jit"); ctxt = gcc_jit_context_acquire (); if (!ctxt) { fail ("gcc_jit_context_acquire failed"); return; } gcc_jit_context_set_timer (ctxt, timer); /* Set up options. */ gcc_jit_context_set_str_option ( ctxt, GCC_JIT_STR_OPTION_PROGNAME, argv0); /* Set up options for benchmarking. */ gcc_jit_context_set_int_option ( ctxt, GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL, opt_level); /* Generating debuginfo takes time; turn it off. */ gcc_jit_context_set_bool_option ( ctxt, GCC_JIT_BOOL_OPTION_DEBUGINFO, 0); /* This option is extremely slow; turn it off. */ gcc_jit_context_set_bool_option ( ctxt, GCC_JIT_BOOL_OPTION_SELFCHECK_GC, 0); /* Turn this on to get detailed timings. */ if (0) gcc_jit_context_set_bool_option ( ctxt, GCC_JIT_BOOL_OPTION_DUMP_SUMMARY, 1); gcc_jit_timer_push (timer, "create_code"); create_code (ctxt, NULL); gcc_jit_timer_pop (timer, "create_code"); gcc_jit_timer_push (timer, "compile"); result = gcc_jit_context_compile (ctxt); gcc_jit_timer_pop (timer, "compile"); gcc_jit_timer_push (timer, "verify_code"); verify_code (ctxt, result); gcc_jit_timer_pop (timer, "verify_code"); gcc_jit_context_release (ctxt); gcc_jit_result_release (result); gcc_jit_timer_pop (timer, "test_jit"); } /* Taken from timevar.c. */ static double ticks_to_msec; #define TICKS_PER_SECOND sysconf (_SC_CLK_TCK) /* POSIX 1003.1-1996 */ #define TICKS_TO_MSEC (1 / (double)TICKS_PER_SECOND) static double get_wallclock_time (void) { struct tms tms; return times (&tms) * ticks_to_msec; } /* Time 100 iterations, at each optimization level (for 400 iterations in all). */ int main (int argc, char **argv) { int opt_level; int num_iterations = 100; double elapsed_time[4]; ticks_to_msec = TICKS_TO_MSEC; for (opt_level = 0; opt_level < 4; opt_level++) { int i; double start_time, end_time; start_time = get_wallclock_time (); gcc_jit_timer *timer = gcc_jit_timer_new (); for (i = 1; i <= num_iterations; i++) { snprintf (test, sizeof (test), "%s iteration %d of %d", extract_progname (argv[0]), i, num_iterations); test_jit (argv[0], opt_level, timer); } end_time = get_wallclock_time (); elapsed_time[opt_level] = end_time - start_time; gcc_jit_timer_print (timer, stderr); gcc_jit_timer_release (timer); pass ("%s: survived %i iterations at optlevel %i", argv[0], num_iterations, opt_level); note (("%s: %i iterations at optlevel %i" " took a total of %.3fs (%.3fs per iteration)"), argv[0], num_iterations, opt_level, elapsed_time[opt_level], elapsed_time[opt_level] / num_iterations); } totals (); /* Print a summary. */ printf ("%s: %i iterations: time taken (lower is better)\n", argv[0], num_iterations); for (opt_level = 0; opt_level < 4; opt_level++) printf ("optlevel %i: %.3fs (%.3fs per iteration)\n", opt_level, elapsed_time[opt_level], elapsed_time[opt_level] / num_iterations); return 0; }