X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=metrics.c;h=ad73fe6e26202ae2d1785548fbe8ea1fe730997d;hb=refs%2Fheads%2Freset-metrics;hp=9f66ded156bc997e8572fce88c258aa60f3f7313;hpb=3b579d69622d53b95c6259daf0ecb4f5d2b1798b;p=fips diff --git a/metrics.c b/metrics.c index 9f66ded..ad73fe6 100644 --- a/metrics.c +++ b/metrics.c @@ -105,12 +105,26 @@ typedef struct context metrics_op_t op; + /* GL_TIME_ELAPSED query for which glEndQuery has not yet + * been called. */ + unsigned timer_begun_id; + + /* GL_TIME_ELAPSED queries for which glEndQuery has been + * called, (but results have not yet been queried). */ timer_query_t *timer_head; timer_query_t *timer_tail; + /* Performance monitor for which glEndPerfMonitorAMD has not + * yet been called. */ + unsigned monitor_begun_id; + + /* Performance monitors for which glEndPerfMonitorAMD has + * been called, (but results have not yet been queried). */ monitor_t *monitor_head; monitor_t *monitor_tail; + int monitors_in_flight; + unsigned num_op_metrics; op_metrics_t *op_metrics; } context_t; @@ -123,6 +137,11 @@ context_t current_context; int frames; int verbose; +#define MAX_MONITORS_IN_FLIGHT 1000 + +void +metrics_collect_available (void); + static void metrics_group_info_init (metrics_group_info_t *group, GLuint id) { @@ -303,7 +322,8 @@ metrics_info_init (void) void metrics_info_fini (void) { - metrics_info_t *info = ¤t_context.metrics_info; + context_t *ctx = ¤t_context; + metrics_info_t *info = &ctx->metrics_info; unsigned i; timer_query_t *timer, *timer_next; monitor_t *monitor, *monitor_next; @@ -311,25 +331,43 @@ metrics_info_fini (void) if (! info->initialized) return; - for (timer = current_context.timer_head; + metrics_collect_available (); + + if (ctx->timer_begun_id) { + glEndQuery (GL_TIME_ELAPSED); + glDeleteQueries (1, &ctx->timer_begun_id); + ctx->timer_begun_id = 0; + } + + for (timer = ctx->timer_head; timer; timer = timer_next) { + glDeleteQueries (1, &timer->id); timer_next = timer->next; free (timer); } - current_context.timer_head = NULL; - current_context.timer_tail = NULL; + ctx->timer_head = NULL; + ctx->timer_tail = NULL; + + if (ctx->monitor_begun_id) { + glEndPerfMonitorAMD (ctx->monitor_begun_id); + glDeletePerfMonitorsAMD (1, &ctx->monitor_begun_id); + ctx->monitor_begun_id = 0; + } - for (monitor = current_context.monitor_head; + for (monitor = ctx->monitor_head; monitor; monitor = monitor_next) { + glDeletePerfMonitorsAMD (1, &monitor->id); monitor_next = monitor->next; free (monitor); } - current_context.monitor_head = NULL; - current_context.monitor_tail = NULL; + ctx->monitor_head = NULL; + ctx->monitor_tail = NULL; + + current_context.monitors_in_flight = 0; for (i = 0; i < info->num_groups; i++) metrics_group_info_fini (&info->groups[i]); @@ -395,42 +433,12 @@ void metrics_counter_start (void) { context_t *ctx = ¤t_context; - timer_query_t *timer; - monitor_t *monitor; unsigned i; - /* Create new timer query, add to list */ - timer = xmalloc (sizeof (timer_query_t)); - - timer->op = ctx->op; - timer->next = NULL; - - if (ctx->timer_tail) { - ctx->timer_tail->next = timer; - ctx->timer_tail = timer; - } else { - ctx->timer_tail = timer; - ctx->timer_head = timer; - } - - /* Create a new performance-monitor query */ - monitor = xmalloc (sizeof (monitor_t)); - - monitor->op = ctx->op; - monitor->next = NULL; - - if (ctx->monitor_tail) { - ctx->monitor_tail->next = monitor; - ctx->monitor_tail = monitor; - } else { - ctx->monitor_tail = monitor; - ctx->monitor_head = monitor; - } - /* Initialize the timer_query and monitor objects */ - glGenQueries (1, &timer->id); + glGenQueries (1, &ctx->timer_begun_id); - glGenPerfMonitorsAMD (1, &monitor->id); + glGenPerfMonitorsAMD (1, &ctx->monitor_begun_id); for (i = 0; i < ctx->metrics_info.num_groups; i++) { @@ -449,23 +457,69 @@ metrics_counter_start (void) } - glSelectPerfMonitorCountersAMD(monitor->id, + glSelectPerfMonitorCountersAMD(ctx->monitor_begun_id, GL_TRUE, group->id, num_counters, group->counter_ids); } /* Start the queries */ - glBeginQuery (GL_TIME_ELAPSED, timer->id); + glBeginQuery (GL_TIME_ELAPSED, ctx->timer_begun_id); - glBeginPerfMonitorAMD (monitor->id); + glBeginPerfMonitorAMD (ctx->monitor_begun_id); } void metrics_counter_stop (void) { + context_t *ctx = ¤t_context; + timer_query_t *timer; + monitor_t *monitor; + + /* Stop the current timer and monitor. */ glEndQuery (GL_TIME_ELAPSED); - glEndPerfMonitorAMD (current_context.monitor_tail->id); + glEndPerfMonitorAMD (ctx->monitor_begun_id); + + /* Add these IDs to our lists of outstanding queries and + * monitors so the results can be collected later. */ + timer = xmalloc (sizeof (timer_query_t)); + + timer->op = ctx->op; + timer->id = ctx->timer_begun_id; + timer->next = NULL; + + if (ctx->timer_tail) { + ctx->timer_tail->next = timer; + ctx->timer_tail = timer; + } else { + ctx->timer_tail = timer; + ctx->timer_head = timer; + } + + /* Create a new performance-monitor query */ + monitor = xmalloc (sizeof (monitor_t)); + + monitor->op = ctx->op; + monitor->id = ctx->monitor_begun_id; + monitor->next = NULL; + + if (ctx->monitor_tail) { + ctx->monitor_tail->next = monitor; + ctx->monitor_tail = monitor; + } else { + ctx->monitor_tail = monitor; + ctx->monitor_head = monitor; + } + + ctx->monitors_in_flight++; + + /* Avoid being a resource hog and collect outstanding results + * once we have sent off a large number of + * queries. (Presumably, many of the outstanding queries are + * available by now.) + */ + if (ctx->monitors_in_flight > MAX_MONITORS_IN_FLIGHT) + metrics_collect_available (); } void @@ -661,7 +715,11 @@ print_per_stage_metrics (context_t *ctx, printf (" "); } - printf (" %cS:", per_stage->stage->name[0]); + + if (per_stage->stage) + printf (" %cS:", per_stage->stage->name[0]); + else + printf (" :"); printf ("\t%7.2f ms (%4.1f%%)", per_stage->time_ns / 1e6, @@ -713,6 +771,38 @@ time_compare(const void *in_a, const void *in_b, void *arg unused) return 0; } +static void +op_metrics_reset (op_metrics_t *op) +{ + context_t *ctx = ¤t_context; + metrics_info_t *info = &ctx->metrics_info; + unsigned group_index, counter; + metrics_group_info_t *group; + + op->time_ns = 0.0; + + for (group_index = 0; group_index < info->num_groups; group_index++) { + group = &info->groups[group_index]; + for (counter = 0; counter < group->num_counters; counter++) + { + op->counters[group_index][counter] = 0.0; + } + } +} + +static void +reset_metrics (void) +{ + context_t *ctx = ¤t_context; + unsigned i; + + for (i = 0; i < ctx->num_op_metrics; i++) { + + op_metrics_reset (&ctx->op_metrics[i]); + + } +} + static void print_program_metrics (void) { @@ -773,15 +863,30 @@ print_program_metrics (void) per_stage = &sorted[i * num_shader_stages + j]; per_stage->metrics = op; - per_stage->stage = &info->stages[j]; - if (op_cycles) + + if (op_cycles) { + per_stage->stage = &info->stages[j]; per_stage->time_ns = op->time_ns * (stage_cycles / op_cycles); - else - per_stage->time_ns = 0.0; - if (stage_cycles) + } else { + /* If we don't have any per-stage cycle counts + * for this operation, then use the first + * stage as a placeholder for all the time, + * but NULL-ify the stage info so that the + * report doesn't lie about this time being + * from any particular stage. */ + per_stage->stage = NULL; + if (j == 0) { + per_stage->time_ns = op->time_ns; + } else { + per_stage->time_ns = 0.0; + } + } + + if (stage_cycles) { per_stage->active = active_cycles / stage_cycles; - else + } else { per_stage->active = 0.0; + } } } @@ -794,36 +899,61 @@ print_program_metrics (void) free (sorted); } -/* Called at program exit */ +/* Called at program exit. + * + * This is similar to metrics_info_fini, but only frees any used + * memory. Notably, it does not call any OpenGL functions, (since the + * OpenGL context no longer exists at program exit). + */ static void metrics_exit (void) { + context_t *ctx = ¤t_context; + metrics_info_t *info = &ctx->metrics_info; + unsigned i; + timer_query_t *timer, *timer_next; + monitor_t *monitor, *monitor_next; + if (verbose) printf ("fips: terminating\n"); - metrics_info_fini (); -} - + if (! info->initialized) + return; -void -metrics_end_frame (void) -{ - static int initialized = 0; - static struct timeval tv_start, tv_now; + for (timer = ctx->timer_head; + timer; + timer = timer_next) + { + timer_next = timer->next; + free (timer); + } - if (! initialized) { - gettimeofday (&tv_start, NULL); - atexit (metrics_exit); - if (getenv ("FIPS_VERBOSE")) - verbose = 1; - initialized = 1; + for (monitor = ctx->monitor_head; + monitor; + monitor = monitor_next) + { + monitor_next = monitor->next; + free (monitor); } - frames++; - gettimeofday (&tv_now, NULL); + for (i = 0; i < info->num_groups; i++) + metrics_group_info_fini (&info->groups[i]); + + free (info->groups); + + for (i = 0; i < info->num_shader_stages; i++) + free (info->stages[i].name); + + free (info->stages); +} + +void +metrics_collect_available (void) +{ + context_t *ctx = ¤t_context; /* Consume all timer queries that are ready. */ - timer_query_t *timer = current_context.timer_head; + timer_query_t *timer = ctx->timer_head; while (timer) { GLuint available, elapsed; @@ -838,18 +968,18 @@ metrics_end_frame (void) accumulate_program_time (timer->op, elapsed); - current_context.timer_head = timer->next; - if (current_context.timer_head == NULL) - current_context.timer_tail = NULL; + ctx->timer_head = timer->next; + if (ctx->timer_head == NULL) + ctx->timer_tail = NULL; glDeleteQueries (1, &timer->id); free (timer); - timer = current_context.timer_head; + timer = ctx->timer_head; } /* And similarly for all performance monitors that are ready. */ - monitor_t *monitor = current_context.monitor_head; + monitor_t *monitor = ctx->monitor_head; while (monitor) { GLuint available, result_size, *result; @@ -878,19 +1008,44 @@ metrics_end_frame (void) free (result); - current_context.monitor_head = monitor->next; - if (current_context.monitor_head == NULL) - current_context.monitor_tail = NULL; + ctx->monitor_head = monitor->next; + if (ctx->monitor_head == NULL) + ctx->monitor_tail = NULL; glDeletePerfMonitorsAMD (1, &monitor->id); free (monitor); - monitor = current_context.monitor_head; + + ctx->monitors_in_flight--; + + monitor = ctx->monitor_head; + } +} + + +void +metrics_end_frame (void) +{ + static int initialized = 0; + static struct timeval tv_start, tv_now; + + if (! initialized) { + gettimeofday (&tv_start, NULL); + atexit (metrics_exit); + if (getenv ("FIPS_VERBOSE")) + verbose = 1; + initialized = 1; } - if (frames % 60 == 0) { + frames++; + + metrics_collect_available (); + + if (frames % 15 == 0) { double fps; + gettimeofday (&tv_now, NULL); + fps = (double) frames / (tv_now.tv_sec - tv_start.tv_sec + (tv_now.tv_usec - tv_start.tv_usec) / 1.0e6); @@ -898,4 +1053,7 @@ metrics_end_frame (void) print_program_metrics (); } + + if (frames == 208) + reset_metrics (); }