X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=metrics.c;h=2ed90d6b33538bd2cb921b47664e4b086c6b3eaf;hb=2c71194f453bb34ff2291c2fa7c73582a3adb05e;hp=09083e639ab966d6e80c36845c8da3c76f447059;hpb=da0ee5e7efab316635f59d212028844f848fa6ce;p=fips

diff --git a/metrics.c b/metrics.c
index 09083e6..2ed90d6 100644
--- a/metrics.c
+++ b/metrics.c
@@ -23,7 +23,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
-
+#include <assert.h>
 #include <sys/time.h>
 
 #include "fips-dispatch-gl.h"
@@ -31,13 +31,24 @@
 #include "metrics.h"
 #include "xmalloc.h"
 
-typedef struct counter
+/* Timer query */
+typedef struct timer_query
 {
 	unsigned id;
 
 	metrics_op_t op;
-	struct counter *next;
-} counter_t;
+	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
 {
@@ -46,14 +57,59 @@ typedef struct op_metrics
 	 */
 	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;
 
-	counter_t *counter_head;
-	counter_t *counter_tail;
+	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;
@@ -67,6 +123,214 @@ 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 = &current_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);
+}
+
 static const char *
 metrics_op_string (metrics_op_t op)
 {
@@ -104,7 +368,7 @@ metrics_op_string (metrics_op_t op)
 	case METRICS_OP_TEX_IMAGE:
 		return "glTexImage*(+)";
 	default:
-		fprintf (stderr, "Internal error: "
+		fprintf (stderr, "fips: Internal error: "
 			 "Unknown metrics op value: %d\n", op);
 		exit (1);
 	}
@@ -115,30 +379,78 @@ metrics_op_string (metrics_op_t op)
 void
 metrics_counter_start (void)
 {
-	counter_t *counter;
+	context_t *ctx = &current_context;
+	timer_query_t *timer;
+	monitor_t *monitor;
+	unsigned i;
 
-	counter = xmalloc (sizeof(counter_t));
+	/* 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;
+	}
 
-	glGenQueries (1, &counter->id);
+	/* Create a new performance-monitor query */
+	monitor = xmalloc (sizeof (monitor_t));
 
-	counter->op = current_context.op;
-	counter->next = NULL;
+	monitor->op = ctx->op;
+	monitor->next = NULL;
 
-	if (current_context.counter_tail) {
-		current_context.counter_tail->next = counter;
-		current_context.counter_tail = counter;
+	if (ctx->monitor_tail) {
+		ctx->monitor_tail->next = monitor;
+		ctx->monitor_tail = monitor;
 	} else {
-		current_context.counter_tail = counter;
-		current_context.counter_head = counter;
+		ctx->monitor_tail = monitor;
+		ctx->monitor_head = monitor;
+	}
+
+	/* Initialize the timer_query and monitor objects */
+	glGenQueries (1, &timer->id);
+
+	glGenPerfMonitorsAMD (1, &monitor->id);
+
+	for (i = 0; i < ctx->metrics_info.num_groups; i++)
+	{
+		metrics_group_info_t *group;
+		int num_counters;
+
+		group = &ctx->metrics_info.groups[i];
+
+		num_counters = group->num_counters;
+		if (group->max_active_counters < group->num_counters)
+		{
+			fprintf (stderr, "Warning: Only monitoring %d/%d counters from group %d\n",
+				 group->max_active_counters,
+				 group->num_counters, i);
+			num_counters = group->max_active_counters;
+
+		}
+
+		glSelectPerfMonitorCountersAMD(monitor->id,
+					       GL_TRUE, group->id,
+					       num_counters,
+					       group->counter_ids);
 	}
 
-	glBeginQuery (GL_TIME_ELAPSED, counter->id);
+	/* Start the queries */
+	glBeginQuery (GL_TIME_ELAPSED, timer->id);
+
+	glBeginPerfMonitorAMD (monitor->id);
 }
 
 void
 metrics_counter_stop (void)
 {
 	glEndQuery (GL_TIME_ELAPSED);
+	glEndPerfMonitorAMD (current_context.monitor_tail->id);
 }
 
 void
@@ -154,35 +466,209 @@ metrics_get_current_op (void)
 }
 
 static void
-accumulate_program_time (metrics_op_t op, unsigned time_ns)
+op_metrics_init (context_t *ctx, op_metrics_t *metrics, metrics_op_t op)
+{
+	metrics_info_t *info = &ctx->metrics_info;
+	unsigned i, j;
+
+	metrics->op = op;
+	metrics->time_ns = 0.0;
+
+	metrics->counters = xmalloc (sizeof(double *) * info->num_groups);
+
+	for (i = 0; i < info->num_groups; i++) {
+		metrics->counters[i] = xmalloc (sizeof (double) *
+						info->groups[i].num_counters);
+		for (j = 0; j < info->groups[i].num_counters; j++)
+			metrics->counters[i][j] = 0.0;
+	}
+}
+
+static op_metrics_t *
+ctx_get_op_metrics (context_t *ctx, metrics_op_t op)
 {
-	context_t *ctx = &current_context;
 	unsigned i;
 
-	if (op >= ctx->num_op_metrics) {
+	if (op >= ctx->num_op_metrics)
+	{
 		ctx->op_metrics = realloc (ctx->op_metrics,
 					   (op + 1) * sizeof (op_metrics_t));
-		for (i = ctx->num_op_metrics; i < op + 1; i++) {
-			ctx->op_metrics[i].op = i;
-			ctx->op_metrics[i].time_ns = 0.0;
-		}
+		for (i = ctx->num_op_metrics; i < op + 1; i++)
+			op_metrics_init (ctx, &ctx->op_metrics[i], i);
 
 		ctx->num_op_metrics = op + 1;
 	}
 
-	ctx->op_metrics[op].time_ns += time_ns;
+	return &ctx->op_metrics[op];
+}
+
+static void
+accumulate_program_metrics (metrics_op_t op, GLuint *result, GLuint size)
+{
+#define CONSUME(var)							\
+	if (p + sizeof(var) > ((unsigned char *) result) + size)	\
+	{								\
+		fprintf (stderr, "Unexpected end-of-buffer while "	\
+			 "parsing results\n");				\
+		break;							\
+	}								\
+	(var) = *((typeof(var) *) p);					\
+	p += sizeof(var);
+
+	context_t *ctx = &current_context;
+	metrics_info_t *info = &ctx->metrics_info;
+	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;
+		unsigned i;
+
+		CONSUME (group_id);
+		CONSUME (counter_id);
+		CONSUME (value);
+
+		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->counter_ids[i] == counter_id)
+				break;
+		}
+		counter_index = i;
+		assert (counter_index < group->num_counters);
+
+		ctx->op_metrics[op].counters[group_index][counter_index] += value;
+	}
+}
+
+static void
+accumulate_program_time (metrics_op_t op, unsigned time_ns)
+{
+	op_metrics_t *metrics;
+
+	metrics = ctx_get_op_metrics (&current_context, op);
+
+	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 0;
+}
+
+static void
+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 group_index, counter;
+	double value;
+
+	/* 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 ("%21s", op_string);
+
+	if (metric->op >= METRICS_OP_SHADER) {
+		printf (" %3d", metric->op - METRICS_OP_SHADER);
+	} else {
+		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);
+
+	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_index = 0; group_index < info->num_groups; group_index++) {
+		group = &info->groups[group_index];
+		for (counter = 0; counter < group->num_counters; 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],
+				value / 1e6);
+		}
+	}
+	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 (metrics[a].time_ns > metrics[b].time_ns)
+	if (a->time_ns > b->time_ns)
 		return 1;
 	return 0;
 }
@@ -191,45 +677,81 @@ static void
 print_program_metrics (void)
 {
 	context_t *ctx = &current_context;
-	unsigned i, j;
-	int *sorted; /* Sorted indices into the ctx->op_metrics */
-	double total = 0;
-
-	/* 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));
-	for (i = 0; i < ctx->num_op_metrics; i++) {
-		sorted[i] = i;
-		total += ctx->op_metrics[i].time_ns;
-	}
-	qsort_r(sorted, ctx->num_op_metrics, sizeof(*sorted),
-		time_compare, ctx->op_metrics);
+	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++) {
-		const char *op_string;
-		op_metrics_t *metric =&ctx->op_metrics[sorted[i]];
-
-		/* Since we sparsely fill the array based on program
-		 * id, many "programs" have no time.
-		 */
-		if (metric->time_ns == 0.0)
-			continue;
-
-		op_string = metrics_op_string (metric->op);
-
-		printf ("%s", op_string);
-		if (metric->op >= METRICS_OP_SHADER) {
-			printf (" %d:", metric->op - METRICS_OP_SHADER);
-		} else {
-			printf (":");
-			for (j = strlen (op_string); j < 20; j++)
-				printf (" ");
+
+		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;
 		}
-		printf ("\t%7.2f ms (% 2.1f%%)\n",
-			metric->time_ns / 1e6,
-			metric->time_ns / total * 100);
 	}
+
+	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);
 }
 
 /* Called at program exit */
@@ -238,6 +760,8 @@ metrics_exit (void)
 {
 	if (verbose)
 		printf ("fips: terminating\n");
+
+	metrics_info_fini (&current_context.metrics_info);
 }
 
 
@@ -255,35 +779,73 @@ metrics_end_frame (void)
 		initialized = 1;
 	}
 
-	if (verbose)
-		printf ("fips: frame %d complete\n", frames);
-
 	frames++;
 	gettimeofday (&tv_now, NULL);
 
-	/* Consume all counters that are ready. */
-	counter_t *counter = current_context.counter_head;
+	/* Consume all timer queries that are ready. */
+	timer_query_t *timer = current_context.timer_head;
 
-	while (counter) {
+	while (timer) {
 		GLuint available, elapsed;
 
-		glGetQueryObjectuiv (counter->id, GL_QUERY_RESULT_AVAILABLE,
-				     &available);
+		glGetQueryObjectuiv (timer->id,
+				     GL_QUERY_RESULT_AVAILABLE, &available);
+		if (! available)
+			break;
+
+		glGetQueryObjectuiv (timer->id,
+				     GL_QUERY_RESULT, &elapsed);
+
+		accumulate_program_time (timer->op, elapsed);
+
+		current_context.timer_head = timer->next;
+		if (current_context.timer_head == NULL)
+			current_context.timer_tail = NULL;
+
+		glDeleteQueries (1, &timer->id);
+
+		free (timer);
+		timer = current_context.timer_head;
+	}
+
+	/* And similarly for all performance monitors that are ready. */
+	monitor_t *monitor = current_context.monitor_head;
+
+	while (monitor) {
+		GLuint available, result_size, *result;
+		GLint bytes_written;
+
+		glGetPerfMonitorCounterDataAMD (monitor->id,
+						GL_PERFMON_RESULT_AVAILABLE_AMD,
+						sizeof (available), &available,
+						NULL);
 		if (! available)
 			break;
 
-		glGetQueryObjectuiv (counter->id, GL_QUERY_RESULT, &elapsed);
+		glGetPerfMonitorCounterDataAMD (monitor->id,
+						GL_PERFMON_RESULT_SIZE_AMD,
+						sizeof (result_size),
+						&result_size, NULL);
+
+		result = xmalloc (result_size);
+
+		glGetPerfMonitorCounterDataAMD (monitor->id,
+						GL_PERFMON_RESULT_AMD,
+						result_size, result,
+						&bytes_written);
+
+		accumulate_program_metrics (monitor->op, result, result_size);
 
-		accumulate_program_time (counter->op, elapsed);
+		free (result);
 
-		current_context.counter_head = counter->next;
-		if (current_context.counter_head == NULL)
-			current_context.counter_tail = NULL;
+		current_context.monitor_head = monitor->next;
+		if (current_context.monitor_head == NULL)
+			current_context.monitor_tail = NULL;
 
-		glDeleteQueries (1, &counter->id);
+		glDeletePerfMonitorsAMD (1, &monitor->id);
 
-		free (counter);
-		counter = current_context.counter_head;
+		free (monitor);
+		monitor = current_context.monitor_head;
 	}
 
 	if (frames % 60 == 0) {