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;
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)
{
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);
free (group->name);
}
-static void
-metrics_info_fini (metrics_info_t *info);
-
/* A helper function, part of metrics_info_init below. */
typedef enum {
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));
info->initialized = 1;
}
-static void
-metrics_info_fini (metrics_info_t *info)
+void
+metrics_info_fini (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 (! info->initialized)
+ return;
+
+ 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);
+ }
+ 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 = ctx->monitor_head;
+ monitor;
+ monitor = monitor_next)
+ {
+ glDeletePerfMonitorsAMD (1, &monitor->id);
+ monitor_next = monitor->next;
+ free (monitor);
+ }
+ 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]);
free (info->groups);
+ info->groups = NULL;
for (i = 0; i < info->num_shader_stages; i++)
free (info->stages[i].name);
free (info->stages);
+ info->stages = NULL;
+
+ info->initialized = 0;
}
static const char *
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++)
{
}
- 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
context_t *ctx = ¤t_context;
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)
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 == i)
+ if (info->groups[i].id == group_id)
break;
}
group_index = i;
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;
}
}
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,
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;
+ }
}
}
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 (¤t_context.metrics_info);
-}
-
+ 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;
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;
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;
}
+}
+
- if (frames % 60 == 0) {
+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;
+ }
+
+ 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);
projects / fips / blobdiff