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

diff --git a/metrics.c b/metrics.c
index 2ed90d6..6e81fae 100644
--- a/metrics.c
+++ b/metrics.c
@@ -105,12 +105,26 @@ typedef struct context
 
 	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;
@@ -123,6 +137,11 @@ context_t current_context;
 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)
 {
@@ -163,15 +182,6 @@ 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);
@@ -200,9 +210,6 @@ metrics_group_info_fini (metrics_group_info_t *group)
 	free (group->name);
 }
 
-static void
-metrics_info_fini (metrics_info_t *info);
-
 /* A helper function, part of metrics_info_init below. */
 
 typedef enum {
@@ -274,9 +281,6 @@ metrics_info_init (void)
 	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));
@@ -315,20 +319,69 @@ metrics_info_init (void)
 	info->initialized = 1;
 }
 
-static void
-metrics_info_fini (metrics_info_t *info)
+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;
+
+	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 *
@@ -380,42 +433,12 @@ void
 metrics_counter_start (void)
 {
 	context_t *ctx = &current_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++)
 	{
@@ -434,23 +457,69 @@ 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 = &current_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
@@ -517,6 +586,7 @@ accumulate_program_metrics (metrics_op_t op, GLuint *result, GLuint size)
 
 	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)
@@ -524,15 +594,14 @@ 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 == i)
+			if (info->groups[i].id == group_id)
 				break;
 		}
 		group_index = i;
@@ -546,7 +615,32 @@ 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;
 	}
 }
 
@@ -621,7 +715,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,
@@ -733,15 +831,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 +867,61 @@ 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 = &current_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 (&current_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 = &current_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;
@@ -798,18 +936,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 +976,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;
 	}
+}
+
 
-	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);