X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=metrics.c;h=22db858d8efc99bf282865adad5f24984c5d150e;hb=076c1c37c1fc8bf3e56a615adfb4c38542cbd4c5;hp=d9dd3a0b3faef6ff600f6a6a487c9f639def47ec;hpb=583e41faf104e7a7ee168761361c8c64aa3c5462;p=fips diff --git a/metrics.c b/metrics.c index d9dd3a0..22db858 100644 --- a/metrics.c +++ b/metrics.c @@ -29,307 +29,14 @@ #include "fips-dispatch-gl.h" #include "metrics.h" +#include "context.h" +#include "metrics-info.h" #include "xmalloc.h" -/* Timer query */ -typedef struct timer_query -{ - unsigned id; - - metrics_op_t op; - struct timer_query *next; -} timer_query_t; - -/* Performance-monitor query */ -typedef struct monitor -{ - unsigned id; - - metrics_op_t op; - struct monitor *next; -} monitor_t; - - -typedef struct op_metrics -{ - /* This happens to also be the index into the - * ctx->op_metrics array currently - */ - metrics_op_t op; - double time_ns; - - double **counters; -} op_metrics_t; - -typedef struct metrics_group_info -{ - GLuint id; - char *name; - - GLuint num_counters; - GLuint max_active_counters; - - GLuint *counter_ids; - char **counter_names; - GLuint *counter_types; - -} metrics_group_info_t; - -typedef struct shader_stage_info -{ - char *name; - - GLuint active_group_index; - GLuint active_counter_index; - - GLuint stall_group_index; - GLuint stall_counter_index; - -} shader_stage_info_t; - -typedef struct metrics_info -{ - int initialized; - - unsigned num_groups; - metrics_group_info_t *groups; - - unsigned num_shader_stages; - shader_stage_info_t *stages; - -} metrics_info_t; - -typedef struct context -{ - metrics_info_t metrics_info; - - metrics_op_t op; - - timer_query_t *timer_head; - timer_query_t *timer_tail; - - monitor_t *monitor_head; - monitor_t *monitor_tail; - - unsigned num_op_metrics; - op_metrics_t *op_metrics; -} context_t; - -/* FIXME: Need a map from integers to context objects and track the - * current context with glXMakeContextCurrent, eglMakeCurrent, etc. */ - -context_t current_context; - int frames; int verbose; -static void -metrics_group_info_init (metrics_group_info_t *group, GLuint id) -{ - GLsizei length; - unsigned i; - - group->id = id; - - /* Get name */ - glGetPerfMonitorGroupStringAMD (id, 0, &length, NULL); - - group->name = xmalloc (length + 1); - - glGetPerfMonitorGroupStringAMD (id, length + 1, NULL, group->name); - - /* Get number of counters */ - group->num_counters = 0; - group->max_active_counters = 0; - glGetPerfMonitorCountersAMD (group->id, - (int *) &group->num_counters, - (int *) &group->max_active_counters, - 0, NULL); - - /* Get counter numbers */ - group->counter_ids = xmalloc (group->num_counters * sizeof (GLuint)); - - glGetPerfMonitorCountersAMD (group->id, NULL, NULL, - group->num_counters, - group->counter_ids); - - /* Get counter names */ - group->counter_names = xmalloc (group->num_counters * sizeof (char *)); - group->counter_types = xmalloc (group->num_counters * sizeof (GLuint)); - - for (i = 0; i < group->num_counters; i++) { - glGetPerfMonitorCounterInfoAMD (group->id, - group->counter_ids[i], - GL_COUNTER_TYPE_AMD, - &group->counter_types[i]); - - /* We assume that all peformance counters are made - * available as uint32 values. The code calling - * CONSUME in accumulate_program_metrics will need to - * be extended to accomodate other counter values. */ - if (group->counter_types[i] != GL_UNSIGNED_INT) { - fprintf (stderr, "fips: Internal error: No support for non-uint counter values\n"); - exit (1); - } - - glGetPerfMonitorCounterStringAMD (group->id, - group->counter_ids[i], - 0, &length, NULL); - - group->counter_names[i] = xmalloc (length + 1); - - glGetPerfMonitorCounterStringAMD (group->id, - group->counter_ids[i], - length + 1, NULL, - group->counter_names[i]); - } -} - -static void -metrics_group_info_fini (metrics_group_info_t *group) -{ - unsigned i; - - for (i = 0; i < group->num_counters; i++) - free (group->counter_names[i]); - - free (group->counter_types); - free (group->counter_names); - free (group->counter_ids); - - free (group->name); -} - -static void -metrics_info_fini (metrics_info_t *info); - -/* A helper function, part of metrics_info_init below. */ - -typedef enum { - SHADER_ACTIVE, - SHADER_STALL -} shader_phase_t; - -static void -_add_shader_stage (metrics_info_t *info, const char *name, - GLuint group_index, GLuint counter_index, - shader_phase_t phase) -{ - shader_stage_info_t *stage; - char *stage_name, *space; - unsigned i; - - stage_name = xstrdup (name); - - /* Terminate the stage name at the first space. - * - * This is valid for counter names such as: - * - * "Vertex Shader Active Time" - * or - * "Vertex Shader Stall Time - Core Stall" - */ - space = strchr (stage_name, ' '); - if (space) - *space = '\0'; - - /* Look for an existing stage of the given name. */ - stage = NULL; - - for (i = 0; i < info->num_shader_stages; i++) { - if (strcmp (info->stages[i].name, stage_name) == 0) { - stage = &info->stages[i]; - break; - } - } - - if (stage == NULL) { - info->num_shader_stages++; - info->stages = xrealloc (info->stages, - info->num_shader_stages * - sizeof (shader_stage_info_t)); - stage = &info->stages[info->num_shader_stages - 1]; - stage->name = xstrdup (stage_name); - stage->active_group_index = 0; - stage->active_counter_index = 0; - stage->stall_group_index = 0; - stage->stall_counter_index = 0; - } - - if (phase == SHADER_ACTIVE) { - stage->active_group_index = group_index; - stage->active_counter_index = counter_index; - } else { - stage->stall_group_index = group_index; - stage->stall_counter_index = counter_index; - } - - free (stage_name); -} - -void -metrics_info_init (void) -{ - unsigned i, j; - GLuint *group_ids; - metrics_info_t *info = ¤t_context.metrics_info; - - if (info->initialized) - metrics_info_fini (info); - - glGetPerfMonitorGroupsAMD ((int *) &info->num_groups, 0, NULL); - - group_ids = xmalloc (info->num_groups * sizeof (GLuint)); - - glGetPerfMonitorGroupsAMD (NULL, info->num_groups, group_ids); - - info->groups = xmalloc (info->num_groups * sizeof (metrics_group_info_t)); - - for (i = 0; i < info->num_groups; i++) - metrics_group_info_init (&info->groups[i], group_ids[i]); - - free (group_ids); - - /* Identify each shader stage (by looking at - * performance-counter names for specific patterns) and - * initialize structures referring to the corresponding - * counter numbers for each stage. */ - info->num_shader_stages = 0; - info->stages = NULL; - - for (i = 0; i < info->num_groups; i++) { - metrics_group_info_t *group = &info->groups[i]; - for (j = 0; j < group->num_counters; j++) { - char *name = group->counter_names[j]; - if (strstr (name, "Shader Active Time")) { - _add_shader_stage (info, name, i, j, - SHADER_ACTIVE); - } - if (strstr (name, "Shader Stall Time")) { - _add_shader_stage (info, name, i, j, - SHADER_STALL); - } - } - } - - info->initialized = 1; -} - -static void -metrics_info_fini (metrics_info_t *info) -{ - unsigned i; - - 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); -} +#define MAX_MONITORS_IN_FLIGHT 1000 static const char * metrics_op_string (metrics_op_t op) @@ -379,43 +86,13 @@ metrics_op_string (metrics_op_t op) void metrics_counter_start (void) { - context_t *ctx = ¤t_context; - timer_query_t *timer; - monitor_t *monitor; + context_t *ctx = context_get_current (); 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++) { @@ -434,35 +111,85 @@ 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 = context_get_current (); + 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 metrics_set_current_op (metrics_op_t op) { - current_context.op = op; + context_t *ctx = context_get_current (); + + ctx->op = op; } metrics_op_t metrics_get_current_op (void) { - return current_context.op; + context_t *ctx = context_get_current (); + + return ctx->op; } static void @@ -515,8 +242,9 @@ accumulate_program_metrics (metrics_op_t op, GLuint *result, GLuint size) (var) = *((typeof(var) *) p); \ p += sizeof(var); - context_t *ctx = ¤t_context; + context_t *ctx = context_get_current (); metrics_info_t *info = &ctx->metrics_info; + op_metrics_t *metrics = ctx_get_op_metrics (ctx, op); unsigned char *p = (unsigned char *) result; while (p < ((unsigned char *) result) + size) @@ -524,12 +252,11 @@ accumulate_program_metrics (metrics_op_t op, GLuint *result, GLuint size) GLuint group_id, group_index; GLuint counter_id, counter_index; metrics_group_info_t *group; - uint32_t value; + double value; unsigned i; CONSUME (group_id); CONSUME (counter_id); - CONSUME (value); for (i = 0; i < info->num_groups; i++) { if (info->groups[i].id == group_id) @@ -546,16 +273,42 @@ accumulate_program_metrics (metrics_op_t op, GLuint *result, GLuint size) counter_index = i; assert (counter_index < group->num_counters); - ctx->op_metrics[op].counters[group_index][counter_index] += value; + switch (group->counter_types[counter_index]) + { + uint uint_value; + uint64_t uint64_value; + float float_value; + case GL_UNSIGNED_INT: + CONSUME (uint_value); + value = uint_value; + break; + case GL_UNSIGNED_INT64_AMD: + CONSUME (uint64_value); + value = uint64_value; + break; + case GL_PERCENTAGE_AMD: + case GL_FLOAT: + CONSUME (float_value); + value = float_value; + break; + default: + fprintf (stderr, "fips: Warning: Unknown counter value type (%d)\n", + group->counter_types[counter_index]); + value = 0.0; + break; + } + + metrics->counters[group_index][counter_index] += value; } } static void accumulate_program_time (metrics_op_t op, unsigned time_ns) { + context_t *ctx = context_get_current (); op_metrics_t *metrics; - metrics = ctx_get_op_metrics (¤t_context, op); + metrics = ctx_get_op_metrics (ctx, op); metrics->time_ns += time_ns; } @@ -621,7 +374,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, @@ -676,7 +433,7 @@ time_compare(const void *in_a, const void *in_b, void *arg unused) static void print_program_metrics (void) { - context_t *ctx = ¤t_context; + context_t *ctx = context_get_current (); metrics_info_t *info = &ctx->metrics_info; unsigned num_shader_stages = info->num_shader_stages; per_stage_metrics_t *sorted, *per_stage; @@ -733,15 +490,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; + } } } @@ -754,36 +526,71 @@ 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 = context_get_current (); + metrics_info_t *info = &ctx->metrics_info; + unsigned i, j; + timer_query_t *timer, *timer_next; + monitor_t *monitor, *monitor_next; + if (verbose) printf ("fips: terminating\n"); - metrics_info_fini (¤t_context.metrics_info); -} + if (! info->initialized) + return; + for (timer = ctx->timer_head; + timer; + timer = timer_next) + { + timer_next = timer->next; + free (timer); + } -void -metrics_end_frame (void) -{ - static int initialized = 0; - static struct timeval tv_start, tv_now; + for (monitor = ctx->monitor_head; + monitor; + monitor = monitor_next) + { + monitor_next = monitor->next; + free (monitor); + } - if (! initialized) { - gettimeofday (&tv_start, NULL); - atexit (metrics_exit); - if (getenv ("FIPS_VERBOSE")) - verbose = 1; - initialized = 1; + for (i = 0; i < info->num_groups; i++) { + metrics_group_info_t *group = &info->groups[i]; + + for (j = 0; j < group->num_counters; i++) + free (group->counter_names[j]); + + free (group->counter_types); + free (group->counter_names); + free (group->counter_ids); + + free (group->name); } - frames++; - gettimeofday (&tv_now, NULL); + 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 = context_get_current (); /* 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; @@ -798,18 +605,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; @@ -838,19 +645,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);