X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=metrics.c;h=eede09b3729886fcdff33780b416b832130e0c51;hb=40729d306204edbc29675e78b5641efe19566dd7;hp=1e2e0184e6592af840c4a69eff7247a004e49c26;hpb=89d08b1a163772b49a52e5a1142363d9d0de7c60;p=fips

diff --git a/metrics.c b/metrics.c
index 1e2e018..eede09b 100644
--- a/metrics.c
+++ b/metrics.c
@@ -58,23 +58,45 @@ typedef struct op_metrics
 	metrics_op_t op;
 	double time_ns;
 
-	double *counters;
-	unsigned num_counters;
+	double **counters;
 } op_metrics_t;
 
-typedef struct counter_group_info
+typedef struct metrics_group_info
 {
 	GLuint id;
-	GLint num_counters;
-	GLint max_active_counters;
-	GLuint *counters;
-} counter_group_info_t;
+	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 num_groups;
-	int max_counters_per_group;
-	counter_group_info_t *groups;
+	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
@@ -101,45 +123,228 @@ 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]);
+
+		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);
+}
+
+/* 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)
 {
-	int i;
+	unsigned i, j;
 	GLuint *group_ids;
-	metrics_info_t *metrics_info = &current_context.metrics_info;
+	metrics_info_t *info = &current_context.metrics_info;
 
-	glGetPerfMonitorGroupsAMD (&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->max_counters_per_group = 0;
+	info->groups = xmalloc (info->num_groups * sizeof (metrics_group_info_t));
 
-	metrics_info->groups = xmalloc (metrics_info->num_groups * sizeof (counter_group_info_t));
+	for (i = 0; i < info->num_groups; i++)
+		metrics_group_info_init (&info->groups[i], group_ids[i]);
 
-	for (i = 0; i < metrics_info->num_groups; i++)
-	{
-		counter_group_info_t *group;
+	free (group_ids);
 
-		group = &metrics_info->groups[i];
+	/* 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);
+			}
+		}
+	}
 
-		group->id = group_ids[i];
+	info->initialized = 1;
+}
 
-		glGetPerfMonitorCountersAMD (group->id, &group->num_counters,
-					     &group->max_active_counters, 0, NULL);
+void
+metrics_info_fini (void)
+{
+	context_t *ctx = &current_context;
+	metrics_info_t *info = &ctx->metrics_info;
+	unsigned i;
+	timer_query_t *timer, *timer_next;
+	monitor_t *monitor, *monitor_next;
 
-		group->counters = xmalloc (group->num_counters * sizeof (GLuint));
+	if (! info->initialized)
+		return;
 
-		glGetPerfMonitorCountersAMD (group->id, NULL, NULL,
-					     group->num_counters,
-					     group->counters);
+	for (timer = ctx->timer_head;
+	     timer;
+	     timer = timer_next)
+	{
+		timer_next = timer->next;
+		free (timer);
+	}
+	ctx->timer_head = NULL;
+	ctx->timer_tail = NULL;
 
-		if (group->num_counters > metrics_info->max_counters_per_group)
-			metrics_info->max_counters_per_group = group->num_counters;
+	for (monitor = ctx->monitor_head;
+	     monitor;
+	     monitor = monitor_next)
+	{
+		monitor_next = monitor->next;
+		free (monitor);
 	}
+	ctx->monitor_head = NULL;
+	ctx->monitor_tail = NULL;
 
-	free (group_ids);
+	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 *
@@ -193,7 +398,7 @@ metrics_counter_start (void)
 	context_t *ctx = &current_context;
 	timer_query_t *timer;
 	monitor_t *monitor;
-	int i;
+	unsigned i;
 
 	/* Create new timer query, add to list */
 	timer = xmalloc (sizeof (timer_query_t));
@@ -230,7 +435,7 @@ metrics_counter_start (void)
 
 	for (i = 0; i < ctx->metrics_info.num_groups; i++)
 	{
-		counter_group_info_t *group;
+		metrics_group_info_t *group;
 		int num_counters;
 
 		group = &ctx->metrics_info.groups[i];
@@ -248,7 +453,7 @@ metrics_counter_start (void)
 		glSelectPerfMonitorCountersAMD(monitor->id,
 					       GL_TRUE, group->id,
 					       num_counters,
-					       group->counters);
+					       group->counter_ids);
 	}
 
 	/* Start the queries */
@@ -280,16 +485,19 @@ static void
 op_metrics_init (context_t *ctx, op_metrics_t *metrics, metrics_op_t op)
 {
 	metrics_info_t *info = &ctx->metrics_info;
-	unsigned i;
+	unsigned i, j;
 
 	metrics->op = op;
 	metrics->time_ns = 0.0;
 
-	metrics->num_counters = info->num_groups * info->max_counters_per_group;
-	metrics->counters = xmalloc (sizeof(double) * metrics->num_counters);
+	metrics->counters = xmalloc (sizeof(double *) * info->num_groups);
 
-	for (i = 0; i < metrics->num_counters; i++)
-		metrics->counters[i] = 0.0;
+	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 *
@@ -324,46 +532,62 @@ accumulate_program_metrics (metrics_op_t op, GLuint *result, GLuint size)
 	p += sizeof(var);
 
 	context_t *ctx = &current_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, counter_id, counter_type;
-		uint32_t value;
+		GLuint group_id, group_index;
+		GLuint counter_id, counter_index;
+		metrics_group_info_t *group;
+		double value;
 		unsigned i;
 
 		CONSUME (group_id);
 		CONSUME (counter_id);
 
-		glGetPerfMonitorCounterInfoAMD (group_id, counter_id,
-						GL_COUNTER_TYPE_AMD,
-						&counter_type);
-
-		/* We assume that all peformance counters are made
-		 * available as uint32 values. This code can easily be
-		 * extended as needed. */
-		if (counter_type != GL_UNSIGNED_INT) {
-			fprintf (stderr, "Warning: Non-uint counter value. Ignoring remainder of results\n");
-			break;
+		for (i = 0; i < info->num_groups; i++) {
+			if (info->groups[i].id == group_id)
+				break;
 		}
+		group_index = i;
+		assert (group_index < info->num_groups);
+		group = &info->groups[group_index];
 
-		CONSUME (value);
-
-		i = (group_id * ctx->metrics_info.max_counters_per_group +
-		     counter_id);
+		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);
 
-		assert (i < ctx->op_metrics[op].num_counters);
+		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;
+		}
 
-		/* FIXME: While I'm still occasionally getting bogus
-		 * numbers from the performance counters, I'm simply
-		 * going to discard anything larger than half the
-		 * range, (something that looks like a negative signed
-		 * quantity).
-		 */
-		if (((int32_t) value) < 0)
-			fprintf (stderr, ".");
-		else
-			ctx->op_metrics[op].counters[i] += value;
+		metrics->counters[group_index][counter_index] += value;
 	}
 }
 
@@ -377,16 +601,119 @@ 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 (metrics[a].time_ns < metrics[b].time_ns)
+		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;
+		}
+	}
+
+	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 ("    ");
+
+	}
+
+	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->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;
 }
@@ -395,52 +722,96 @@ static void
 print_program_metrics (void)
 {
 	context_t *ctx = &current_context;
-	int *sorted; /* Sorted indices into the ctx->op_metrics */
-	double total = 0;
-	unsigned i, j;
-
-	/* 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];
 		}
-		printf ("\t%7.2f ms (% 2.1f%%)",
-			metric->time_ns / 1e6,
-			metric->time_ns / total * 100);
-		printf ("[");
-		for (j = 0; j < metric->num_counters; j++) {
-			if (metric->counters[j] == 0.0)
-				continue;
-			printf ("%d: %.2f ms ", j, metric->counters[j] / 1e6);
+
+		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;
+
+			if (op_cycles) {
+				per_stage->stage = &info->stages[j];
+				per_stage->time_ns = op->time_ns * (stage_cycles / op_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 {
+				per_stage->active = 0.0;
+			}
 		}
-		printf ("]\n");
 	}
+
+	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 */
@@ -449,12 +820,15 @@ metrics_exit (void)
 {
 	if (verbose)
 		printf ("fips: terminating\n");
+
+	metrics_info_fini ();
 }
 
 
 void
 metrics_end_frame (void)
 {
+	context_t *ctx = &current_context;
 	static int initialized = 0;
 	static struct timeval tv_start, tv_now;
 
@@ -466,14 +840,11 @@ metrics_end_frame (void)
 		initialized = 1;
 	}
 
-	if (verbose)
-		printf ("fips: frame %d complete\n", frames);
-
 	frames++;
 	gettimeofday (&tv_now, NULL);
 
 	/* 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;
@@ -488,18 +859,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;
@@ -526,17 +897,19 @@ metrics_end_frame (void)
 
 		accumulate_program_metrics (monitor->op, result, result_size);
 
-		current_context.monitor_head = monitor->next;
-		if (current_context.monitor_head == NULL)
-			current_context.monitor_tail = NULL;
+		free (result);
+
+		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;
+		monitor = ctx->monitor_head;
 	}
 
-	if (frames % 60 == 0) {
+	if (frames % 15 == 0) {
 		double fps;
 
 		fps = (double) frames / (tv_now.tv_sec - tv_start.tv_sec +