X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=metrics.c;h=2ed90d6b33538bd2cb921b47664e4b086c6b3eaf;hb=2c71194f453bb34ff2291c2fa7c73582a3adb05e;hp=38e9e954a6fc7dc941ce4bb608d76d1e886a4a32;hpb=cff9de18eebbbbc9b88e51483f5e471afbafaac1;p=fips diff --git a/metrics.c b/metrics.c index 38e9e95..2ed90d6 100644 --- a/metrics.c +++ b/metrics.c @@ -69,16 +69,34 @@ typedef struct metrics_group_info GLuint num_counters; GLuint max_active_counters; - GLuint *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 @@ -129,11 +147,11 @@ metrics_group_info_init (metrics_group_info_t *group, GLuint id) 0, NULL); /* Get counter numbers */ - group->counters = xmalloc (group->num_counters * sizeof (GLuint)); + group->counter_ids = xmalloc (group->num_counters * sizeof (GLuint)); glGetPerfMonitorCountersAMD (group->id, NULL, NULL, group->num_counters, - group->counters); + group->counter_ids); /* Get counter names */ group->counter_names = xmalloc (group->num_counters * sizeof (char *)); @@ -141,7 +159,7 @@ metrics_group_info_init (metrics_group_info_t *group, GLuint id) for (i = 0; i < group->num_counters; i++) { glGetPerfMonitorCounterInfoAMD (group->id, - group->counters[i], + group->counter_ids[i], GL_COUNTER_TYPE_AMD, &group->counter_types[i]); @@ -155,37 +173,162 @@ metrics_group_info_init (metrics_group_info_t *group, GLuint id) } glGetPerfMonitorCounterStringAMD (group->id, - group->counters[i], + group->counter_ids[i], 0, &length, NULL); group->counter_names[i] = xmalloc (length + 1); glGetPerfMonitorCounterStringAMD (group->id, - group->counters[i], + 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; + unsigned i, j; GLuint *group_ids; - metrics_info_t *metrics_info = ¤t_context.metrics_info; + metrics_info_t *info = ¤t_context.metrics_info; + + if (info->initialized) + metrics_info_fini (info); - glGetPerfMonitorGroupsAMD ((int *) &metrics_info->num_groups, 0, NULL); + glGetPerfMonitorGroupsAMD ((int *) &info->num_groups, 0, NULL); - group_ids = xmalloc (metrics_info->num_groups * sizeof (GLuint)); + group_ids = xmalloc (info->num_groups * sizeof (GLuint)); - glGetPerfMonitorGroupsAMD (NULL, metrics_info->num_groups, group_ids); + glGetPerfMonitorGroupsAMD (NULL, info->num_groups, group_ids); - metrics_info->groups = xmalloc (metrics_info->num_groups * sizeof (metrics_group_info_t)); + info->groups = xmalloc (info->num_groups * sizeof (metrics_group_info_t)); - for (i = 0; i < metrics_info->num_groups; i++) - metrics_group_info_init (&metrics_info->groups[i], i); + 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); } static const char * @@ -294,7 +437,7 @@ metrics_counter_start (void) glSelectPerfMonitorCountersAMD(monitor->id, GL_TRUE, group->id, num_counters, - group->counters); + group->counter_ids); } /* Start the queries */ @@ -373,11 +516,13 @@ accumulate_program_metrics (metrics_op_t op, GLuint *result, GLuint size) p += sizeof(var); context_t *ctx = ¤t_context; + metrics_info_t *info = &ctx->metrics_info; unsigned char *p = (unsigned char *) result; while (p < ((unsigned char *) result) + size) { - GLuint group_id, counter_id, counter_index; + GLuint group_id, group_index; + GLuint counter_id, counter_index; metrics_group_info_t *group; uint32_t value; unsigned i; @@ -386,17 +531,22 @@ accumulate_program_metrics (metrics_op_t op, GLuint *result, GLuint size) CONSUME (counter_id); CONSUME (value); - assert (group_id < ctx->metrics_info.num_groups); - group = &ctx->metrics_info.groups[group_id]; + for (i = 0; i < info->num_groups; i++) { + if (info->groups[i].id == i) + break; + } + group_index = i; + assert (group_index < info->num_groups); + group = &info->groups[group_index]; for (i = 0; i < group->num_counters; i++) { - if (group->counters[i] == counter_id) + if (group->counter_ids[i] == counter_id) break; } counter_index = i; assert (counter_index < group->num_counters); - ctx->op_metrics[op].counters[group_id][counter_index] += value; + ctx->op_metrics[op].counters[group_index][counter_index] += value; } } @@ -410,55 +560,96 @@ accumulate_program_time (metrics_op_t op, unsigned time_ns) metrics->time_ns += time_ns; } +typedef struct per_stage_metrics +{ + op_metrics_t *metrics; + shader_stage_info_t *stage; + double time_ns; + double active; +} per_stage_metrics_t; + static int -time_compare(const void *in_a, const void *in_b, void *arg) +_is_shader_stage_counter (metrics_info_t *info, + unsigned group_index, + unsigned counter_index) { - int a = *(const int *)in_a; - int b = *(const int *)in_b; - struct op_metrics *metrics = arg; + shader_stage_info_t *stage; + unsigned i; + + for (i = 0; i < info->num_shader_stages; i++) { + stage = &info->stages[i]; + + if (stage->active_group_index == group_index && + stage->active_counter_index == counter_index) + { + return 1; + } + + if (stage->stall_group_index == group_index && + stage->stall_counter_index == counter_index) + { + return 1; + } + } - if (metrics[a].time_ns < metrics[b].time_ns) - return -1; - if (metrics[a].time_ns > metrics[b].time_ns) - return 1; return 0; } static void -print_op_metrics (context_t *ctx, op_metrics_t *metric, double total) +print_per_stage_metrics (context_t *ctx, + per_stage_metrics_t *per_stage, + double total) { metrics_info_t *info = &ctx->metrics_info; + op_metrics_t *metric = per_stage->metrics; metrics_group_info_t *group; const char *op_string; - unsigned i, group_id, counter; + unsigned group_index, counter; double value; - /* Since we sparsely fill the array based on program - * id, many "programs" have no time. - */ - if (metric->time_ns == 0.0) + /* Don't print anything for stages with no alloted time. */ + if (per_stage->time_ns == 0.0) return; op_string = metrics_op_string (metric->op); - printf ("%s", op_string); + printf ("%21s", op_string); + if (metric->op >= METRICS_OP_SHADER) { - printf (" %d:", metric->op - METRICS_OP_SHADER); + printf (" %3d", metric->op - METRICS_OP_SHADER); } else { - printf (":"); - for (i = strlen (op_string); i < 20; i++) - printf (" "); + printf (" "); + } + printf (" %cS:", per_stage->stage->name[0]); + + printf ("\t%7.2f ms (%4.1f%%)", + per_stage->time_ns / 1e6, + per_stage->time_ns / total * 100); - printf ("\t%7.2f ms (% 2.1f%%)", - metric->time_ns / 1e6, - metric->time_ns / total * 100); + if (per_stage->active) + printf (", %4.1f%% active", per_stage->active * 100); + + printf ("\n"); + + /* I'm not seeing a lot of value printing the rest of these + * performance counters by default yet. Use --verbose to get + * them for now. */ + if (! verbose) + return; printf ("["); - for (group_id = 0; group_id < info->num_groups; group_id++) { - group = &info->groups[group_id]; + for (group_index = 0; group_index < info->num_groups; group_index++) { + group = &info->groups[group_index]; for (counter = 0; counter < group->num_counters; counter++) { - value = metric->counters[group_id][counter]; + + /* Don't print this counter value if it's a + * per-stage cycle counter, (which we have + * already accounted for). */ + if (_is_shader_stage_counter (info, group_index, counter)) + continue; + + value = metric->counters[group_index][counter]; if (value == 0.0) continue; printf ("%s: %.2f ", group->counter_names[counter], @@ -468,27 +659,97 @@ print_op_metrics (context_t *ctx, op_metrics_t *metric, double total) printf ("]\n"); } +static int +time_compare(const void *in_a, const void *in_b, void *arg unused) +{ + const per_stage_metrics_t *a = in_a; + const per_stage_metrics_t *b = in_b; + + + if (a->time_ns < b->time_ns) + return -1; + if (a->time_ns > b->time_ns) + return 1; + return 0; +} + static void print_program_metrics (void) { context_t *ctx = ¤t_context; - int *sorted; /* Sorted indices into the ctx->op_metrics */ - double total = 0; - unsigned i; - - /* Make a sorted list of the operations by time used, and figure - * out the total so we can print percentages. + metrics_info_t *info = &ctx->metrics_info; + unsigned num_shader_stages = info->num_shader_stages; + per_stage_metrics_t *sorted, *per_stage; + double total_time, op_cycles; + op_metrics_t *op; + unsigned group_index, counter_index; + unsigned i, j, num_sorted; + + /* Make a sorted list of the per-stage operations by time + * used, and figure out the total so we can print percentages. */ - sorted = calloc(ctx->num_op_metrics, sizeof(*sorted)); + num_sorted = ctx->num_op_metrics * num_shader_stages; + + sorted = xmalloc (sizeof (*sorted) * num_sorted); + + total_time = 0.0; + for (i = 0; i < ctx->num_op_metrics; i++) { - sorted[i] = i; - total += ctx->op_metrics[i].time_ns; + + op = &ctx->op_metrics[i]; + + /* Accumulate total time across all ops. */ + total_time += op->time_ns; + + /* Also, find total cycles in all stages of this op. */ + op_cycles = 0.0; + + for (j = 0; j < num_shader_stages; j++) { + /* Active cycles */ + group_index = info->stages[j].active_group_index; + counter_index = info->stages[j].active_counter_index; + op_cycles += op->counters[group_index][counter_index]; + + /* Stall cycles */ + group_index = info->stages[j].stall_group_index; + counter_index = info->stages[j].stall_counter_index; + op_cycles += op->counters[group_index][counter_index]; + } + + for (j = 0; j < num_shader_stages; j++) { + double active_cycles, stall_cycles, stage_cycles; + + /* Active cycles */ + group_index = info->stages[j].active_group_index; + counter_index = info->stages[j].active_counter_index; + active_cycles = op->counters[group_index][counter_index]; + + /* Stall cycles */ + group_index = info->stages[j].stall_group_index; + counter_index = info->stages[j].stall_counter_index; + stall_cycles = op->counters[group_index][counter_index]; + + stage_cycles = active_cycles + stall_cycles; + + per_stage = &sorted[i * num_shader_stages + j]; + per_stage->metrics = op; + per_stage->stage = &info->stages[j]; + if (op_cycles) + per_stage->time_ns = op->time_ns * (stage_cycles / op_cycles); + else + per_stage->time_ns = 0.0; + if (stage_cycles) + per_stage->active = active_cycles / stage_cycles; + else + per_stage->active = 0.0; + } } - qsort_r(sorted, ctx->num_op_metrics, sizeof(*sorted), - time_compare, ctx->op_metrics); - for (i = 0; i < ctx->num_op_metrics; i++) - print_op_metrics (ctx, &ctx->op_metrics[sorted[i]], total); + qsort_r (sorted, num_sorted, sizeof (*sorted), + time_compare, ctx->op_metrics); + + for (i = 0; i < num_sorted; i++) + print_per_stage_metrics (ctx, &sorted[i], total_time); free (sorted); } @@ -499,6 +760,8 @@ metrics_exit (void) { if (verbose) printf ("fips: terminating\n"); + + metrics_info_fini (¤t_context.metrics_info); } @@ -516,9 +779,6 @@ metrics_end_frame (void) initialized = 1; } - if (verbose) - printf ("fips: frame %d complete\n", frames); - frames++; gettimeofday (&tv_now, NULL);