* Set GALLIUM_HUD=help for more info.
*/
+#include <signal.h>
#include <stdio.h>
#include "hud/hud_context.h"
#include "util/u_inlines.h"
#include "util/u_memory.h"
#include "util/u_math.h"
+#include "util/u_sampler.h"
#include "util/u_simple_shaders.h"
#include "util/u_string.h"
#include "util/u_upload_mgr.h"
#include "tgsi/tgsi_text.h"
#include "tgsi/tgsi_dump.h"
+/* Control the visibility of all HUD contexts */
+static boolean huds_visible = TRUE;
struct hud_context {
struct pipe_context *pipe;
} text, bg, whitelines;
};
+static void
+signal_visible_handler(int sig, siginfo_t *siginfo, void *context)
+{
+ huds_visible = !huds_visible;
+}
static void
hud_draw_colored_prims(struct hud_context *hud, unsigned prim,
}
static void
-number_to_human_readable(uint64_t num, boolean is_in_bytes, char *out)
+number_to_human_readable(uint64_t num, uint64_t max_value,
+ enum pipe_driver_query_type type, char *out)
{
static const char *byte_units[] =
- {"", " KB", " MB", " GB", " TB", " PB", " EB"};
+ {" B", " KB", " MB", " GB", " TB", " PB", " EB"};
static const char *metric_units[] =
{"", " k", " M", " G", " T", " P", " E"};
- const char **units = is_in_bytes ? byte_units : metric_units;
- double divisor = is_in_bytes ? 1024 : 1000;
- int unit = 0;
+ static const char *time_units[] =
+ {" us", " ms", " s"}; /* based on microseconds */
+ static const char *hz_units[] =
+ {" Hz", " KHz", " MHz", " GHz"};
+ static const char *percent_units[] = {"%"};
+
+ const char **units;
+ unsigned max_unit;
+ double divisor = (type == PIPE_DRIVER_QUERY_TYPE_BYTES) ? 1024 : 1000;
+ unsigned unit = 0;
double d = num;
- while (d > divisor) {
+ switch (type) {
+ case PIPE_DRIVER_QUERY_TYPE_MICROSECONDS:
+ max_unit = ARRAY_SIZE(time_units)-1;
+ units = time_units;
+ break;
+ case PIPE_DRIVER_QUERY_TYPE_PERCENTAGE:
+ max_unit = ARRAY_SIZE(percent_units)-1;
+ units = percent_units;
+ break;
+ case PIPE_DRIVER_QUERY_TYPE_BYTES:
+ max_unit = ARRAY_SIZE(byte_units)-1;
+ units = byte_units;
+ break;
+ case PIPE_DRIVER_QUERY_TYPE_HZ:
+ max_unit = ARRAY_SIZE(hz_units)-1;
+ units = hz_units;
+ break;
+ default:
+ if (max_value == 100) {
+ max_unit = ARRAY_SIZE(percent_units)-1;
+ units = percent_units;
+ } else {
+ max_unit = ARRAY_SIZE(metric_units)-1;
+ units = metric_units;
+ }
+ }
+
+ while (d > divisor && unit < max_unit) {
d /= divisor;
unit++;
}
unsigned y = pane->inner_y1 + pane->inner_height * (5 - i) / 5 -
hud->font.glyph_height / 2;
- number_to_human_readable(pane->max_value * i / 5,
- pane->uses_byte_units, str);
- hud_draw_string(hud, x, y, str);
+ number_to_human_readable(pane->max_value * i / 5, pane->max_value,
+ pane->type, str);
+ hud_draw_string(hud, x, y, "%s", str);
}
/* draw info below the pane */
unsigned x = pane->x1 + 2;
unsigned y = pane->y2 + 2 + i*hud->font.glyph_height;
- number_to_human_readable(gr->current_value,
- pane->uses_byte_units, str);
+ number_to_human_readable(gr->current_value, pane->max_value,
+ pane->type, str);
hud_draw_string(hud, x, y, " %s: %s", gr->name, str);
i++;
}
struct hud_pane *pane;
struct hud_graph *gr;
+ if (!huds_visible)
+ return;
+
hud->fb_width = tex->width0;
hud->fb_height = tex->height0;
hud->constants.two_div_fb_width = 2.0f / hud->fb_width;
cso_save_framebuffer(cso);
cso_save_sample_mask(cso);
+ cso_save_min_samples(cso);
cso_save_blend(cso);
cso_save_depth_stencil_alpha(cso);
cso_save_fragment_shader(cso);
- cso_save_sampler_views(cso, PIPE_SHADER_FRAGMENT);
- cso_save_samplers(cso, PIPE_SHADER_FRAGMENT);
+ cso_save_fragment_sampler_views(cso);
+ cso_save_fragment_samplers(cso);
cso_save_rasterizer(cso);
cso_save_viewport(cso);
cso_save_stream_outputs(cso);
cso_save_geometry_shader(cso);
+ cso_save_tessctrl_shader(cso);
+ cso_save_tesseval_shader(cso);
cso_save_vertex_shader(cso);
cso_save_vertex_elements(cso);
cso_save_aux_vertex_buffer_slot(cso);
viewport.scale[0] = 0.5f * hud->fb_width;
viewport.scale[1] = 0.5f * hud->fb_height;
viewport.scale[2] = 1.0f;
- viewport.scale[3] = 1.0f;
viewport.translate[0] = 0.5f * hud->fb_width;
viewport.translate[1] = 0.5f * hud->fb_height;
viewport.translate[2] = 0.0f;
- viewport.translate[3] = 0.0f;
cso_set_framebuffer(cso, &fb);
cso_set_sample_mask(cso, ~0);
+ cso_set_min_samples(cso, 1);
cso_set_blend(cso, &hud->alpha_blend);
cso_set_depth_stencil_alpha(cso, &hud->dsa);
cso_set_rasterizer(cso, &hud->rasterizer);
cso_set_viewport(cso, &viewport);
cso_set_stream_outputs(cso, 0, NULL, NULL);
+ cso_set_tessctrl_shader_handle(cso, NULL);
+ cso_set_tesseval_shader_handle(cso, NULL);
cso_set_geometry_shader_handle(cso, NULL);
cso_set_vertex_shader_handle(cso, hud->vs);
cso_set_vertex_elements(cso, 2, hud->velems);
/* restore states */
cso_restore_framebuffer(cso);
cso_restore_sample_mask(cso);
+ cso_restore_min_samples(cso);
cso_restore_blend(cso);
cso_restore_depth_stencil_alpha(cso);
cso_restore_fragment_shader(cso);
- cso_restore_sampler_views(cso, PIPE_SHADER_FRAGMENT);
- cso_restore_samplers(cso, PIPE_SHADER_FRAGMENT);
+ cso_restore_fragment_sampler_views(cso);
+ cso_restore_fragment_samplers(cso);
cso_restore_rasterizer(cso);
cso_restore_viewport(cso);
cso_restore_stream_outputs(cso);
+ cso_restore_tessctrl_shader(cso);
+ cso_restore_tesseval_shader(cso);
cso_restore_geometry_shader(cso);
cso_restore_vertex_shader(cso);
cso_restore_vertex_elements(cso);
pane->yscale = -(int)pane->inner_height / (float)pane->max_value;
}
+static void
+hud_pane_update_dyn_ceiling(struct hud_graph *gr, struct hud_pane *pane)
+{
+ unsigned i;
+ float tmp = 0.0f;
+
+ if (pane->dyn_ceil_last_ran != gr->index) {
+ LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
+ for (i = 0; i < gr->num_vertices; ++i) {
+ tmp = gr->vertices[i * 2 + 1] > tmp ?
+ gr->vertices[i * 2 + 1] : tmp;
+ }
+ }
+
+ /* Avoid setting it lower than the initial starting height. */
+ tmp = tmp > pane->initial_max_value ? tmp : pane->initial_max_value;
+ hud_pane_set_max_value(pane, tmp);
+ }
+
+ /*
+ * Mark this adjustment run so we could avoid repeating a full update
+ * again needlessly in case the pane has more than one graph.
+ */
+ pane->dyn_ceil_last_ran = gr->index;
+}
+
static struct hud_pane *
hud_pane_create(unsigned x1, unsigned y1, unsigned x2, unsigned y2,
- unsigned period, uint64_t max_value)
+ unsigned period, uint64_t max_value, uint64_t ceiling,
+ boolean dyn_ceiling)
{
struct hud_pane *pane = CALLOC_STRUCT(hud_pane);
pane->inner_height = pane->inner_y2 - pane->inner_y1;
pane->period = period;
pane->max_num_vertices = (x2 - x1 + 2) / 2;
+ pane->ceiling = ceiling;
+ pane->dyn_ceiling = dyn_ceiling;
+ pane->dyn_ceil_last_ran = 0;
+ pane->initial_max_value = max_value;
hud_pane_set_max_value(pane, max_value);
LIST_INITHEAD(&pane->graph_list);
return pane;
void
hud_graph_add_value(struct hud_graph *gr, uint64_t value)
{
+ gr->current_value = value;
+ value = value > gr->pane->ceiling ? gr->pane->ceiling : value;
+
if (gr->index == gr->pane->max_num_vertices) {
gr->vertices[0] = 0;
gr->vertices[1] = gr->vertices[(gr->index-1)*2+1];
gr->num_vertices++;
}
- gr->current_value = value;
+ if (gr->pane->dyn_ceiling == true) {
+ hud_pane_update_dyn_ceiling(gr, gr->pane);
+ }
if (value > gr->pane->max_value) {
hud_pane_set_max_value(gr->pane, value);
}
return i;
}
+static char *
+read_pane_settings(char *str, unsigned * const x, unsigned * const y,
+ unsigned * const width, unsigned * const height,
+ uint64_t * const ceiling, boolean * const dyn_ceiling)
+{
+ char *ret = str;
+ unsigned tmp;
+
+ while (*str == '.') {
+ ++str;
+ switch (*str) {
+ case 'x':
+ ++str;
+ *x = strtoul(str, &ret, 10);
+ str = ret;
+ break;
+
+ case 'y':
+ ++str;
+ *y = strtoul(str, &ret, 10);
+ str = ret;
+ break;
+
+ case 'w':
+ ++str;
+ tmp = strtoul(str, &ret, 10);
+ *width = tmp > 80 ? tmp : 80; /* 80 is chosen arbitrarily */
+ str = ret;
+ break;
+
+ /*
+ * Prevent setting height to less than 50. If the height is set to less,
+ * the text of the Y axis labels on the graph will start overlapping.
+ */
+ case 'h':
+ ++str;
+ tmp = strtoul(str, &ret, 10);
+ *height = tmp > 50 ? tmp : 50;
+ str = ret;
+ break;
+
+ case 'c':
+ ++str;
+ tmp = strtoul(str, &ret, 10);
+ *ceiling = tmp > 10 ? tmp : 10;
+ str = ret;
+ break;
+
+ case 'd':
+ ++str;
+ ret = str;
+ *dyn_ceiling = true;
+ break;
+
+ default:
+ fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *str);
+ }
+
+ }
+
+ return ret;
+}
+
static boolean
has_occlusion_query(struct pipe_screen *screen)
{
hud_parse_env_var(struct hud_context *hud, const char *env)
{
unsigned num, i;
- char name[256], s[256];
+ char name_a[256], s[256];
+ char *name;
struct hud_pane *pane = NULL;
unsigned x = 10, y = 10;
unsigned width = 251, height = 100;
unsigned period = 500 * 1000; /* default period (1/2 second) */
+ uint64_t ceiling = UINT64_MAX;
+ unsigned column_width = 251;
+ boolean dyn_ceiling = false;
const char *period_env;
/*
}
}
- while ((num = parse_string(env, name)) != 0) {
+ while ((num = parse_string(env, name_a)) != 0) {
env += num;
+ /* check for explicit location, size and etc. settings */
+ name = read_pane_settings(name_a, &x, &y, &width, &height, &ceiling,
+ &dyn_ceiling);
+
+ /*
+ * Keep track of overall column width to avoid pane overlapping in case
+ * later we create a new column while the bottom pane in the current
+ * column is less wide than the rest of the panes in it.
+ */
+ column_width = width > column_width ? width : column_width;
+
if (!pane) {
- pane = hud_pane_create(x, y, x + width, y + height, period, 10);
+ pane = hud_pane_create(x, y, x + width, y + height, period, 10,
+ ceiling, dyn_ceiling);
if (!pane)
return;
}
else if (strcmp(name, "samples-passed") == 0 &&
has_occlusion_query(hud->pipe->screen)) {
hud_pipe_query_install(pane, hud->pipe, "samples-passed",
- PIPE_QUERY_OCCLUSION_COUNTER, 0, 0, FALSE);
+ PIPE_QUERY_OCCLUSION_COUNTER, 0, 0,
+ PIPE_DRIVER_QUERY_TYPE_UINT64,
+ PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE);
}
else if (strcmp(name, "primitives-generated") == 0 &&
has_streamout(hud->pipe->screen)) {
hud_pipe_query_install(pane, hud->pipe, "primitives-generated",
- PIPE_QUERY_PRIMITIVES_GENERATED, 0, 0, FALSE);
+ PIPE_QUERY_PRIMITIVES_GENERATED, 0, 0,
+ PIPE_DRIVER_QUERY_TYPE_UINT64,
+ PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE);
}
else {
boolean processed = FALSE;
if (i < Elements(pipeline_statistics_names)) {
hud_pipe_query_install(pane, hud->pipe, name,
PIPE_QUERY_PIPELINE_STATISTICS, i,
- 0, FALSE);
+ 0, PIPE_DRIVER_QUERY_TYPE_UINT64,
+ PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE);
processed = TRUE;
}
}
if (num && sscanf(s, "%u", &i) == 1) {
hud_pane_set_max_value(pane, i);
+ pane->initial_max_value = i;
}
else {
fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) "
case ',':
env++;
+ if (!pane)
+ break;
+
y += height + hud->font.glyph_height * (pane->num_graphs + 2);
+ height = 100;
if (pane && pane->num_graphs) {
LIST_ADDTAIL(&pane->head, &hud->pane_list);
case ';':
env++;
y = 10;
- x += width + hud->font.glyph_width * 7;
+ x += column_width + hud->font.glyph_width * 7;
+ height = 100;
if (pane && pane->num_graphs) {
LIST_ADDTAIL(&pane->head, &hud->pane_list);
pane = NULL;
}
+
+ /* Starting a new column; reset column width. */
+ column_width = 251;
break;
default:
fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *env);
}
+
+ /* Reset to defaults for the next pane in case these were modified. */
+ width = 251;
+ ceiling = UINT64_MAX;
+ dyn_ceiling = false;
+
}
if (pane) {
puts("");
puts(" Example: GALLIUM_HUD=\"cpu,fps;primitives-generated\"");
puts("");
+ puts(" Additionally, by prepending '.[identifier][value]' modifiers to");
+ puts(" a name, it is possible to explicitly set the location and size");
+ puts(" of a pane, along with limiting overall maximum value of the");
+ puts(" Y axis and activating dynamic readjustment of the Y axis.");
+ puts(" Several modifiers may be applied to the same pane simultaneously.");
+ puts("");
+ puts(" 'x[value]' sets the location of the pane on the x axis relative");
+ puts(" to the upper-left corner of the viewport, in pixels.");
+ puts(" 'y[value]' sets the location of the pane on the y axis relative");
+ puts(" to the upper-left corner of the viewport, in pixels.");
+ puts(" 'w[value]' sets width of the graph pixels.");
+ puts(" 'h[value]' sets height of the graph in pixels.");
+ puts(" 'c[value]' sets the ceiling of the value of the Y axis.");
+ puts(" If the graph needs to draw values higher than");
+ puts(" the ceiling allows, the value is clamped.");
+ puts(" 'd' activates dynamic Y axis readjustment to set the value of");
+ puts(" the Y axis to match the highest value still visible in the graph.");
+ puts("");
+ puts(" If 'c' and 'd' modifiers are used simultaneously, both are in effect:");
+ puts(" the Y axis does not go above the restriction imposed by 'c' while");
+ puts(" still adjusting the value of the Y axis down when appropriate.");
+ puts("");
+ puts(" Example: GALLIUM_HUD=\".w256.h64.x1600.y520.d.c1000fps+cpu,.datom-count\"");
+ puts("");
puts(" Available names:");
puts(" fps");
puts(" cpu");
}
puts("");
+ fflush(stdout);
}
struct hud_context *
struct pipe_sampler_view view_templ;
unsigned i;
const char *env = debug_get_option("GALLIUM_HUD", NULL);
+ unsigned signo = debug_get_num_option("GALLIUM_HUD_TOGGLE_SIGNAL", 0);
+ static boolean sig_handled = FALSE;
+ struct sigaction action = {};
+ huds_visible = debug_get_bool_option("GALLIUM_HUD_VISIBLE", TRUE);
if (!env || !*env)
return NULL;
}
/* sampler view */
- memset(&view_templ, 0, sizeof(view_templ));
- view_templ.format = hud->font.texture->format;
- view_templ.swizzle_r = PIPE_SWIZZLE_RED;
- view_templ.swizzle_g = PIPE_SWIZZLE_GREEN;
- view_templ.swizzle_b = PIPE_SWIZZLE_BLUE;
- view_templ.swizzle_a = PIPE_SWIZZLE_ALPHA;
+ u_sampler_view_default_template(
+ &view_templ, hud->font.texture, hud->font.texture->format);
hud->font_sampler_view = pipe->create_sampler_view(pipe, hud->font.texture,
&view_templ);
LIST_INITHEAD(&hud->pane_list);
+ /* setup sig handler once for all hud contexts */
+ if (!sig_handled && signo != 0) {
+ action.sa_sigaction = &signal_visible_handler;
+ action.sa_flags = SA_SIGINFO;
+
+ if (signo >= NSIG)
+ fprintf(stderr, "gallium_hud: invalid signal %u\n", signo);
+ else if (sigaction(signo, &action, NULL) < 0)
+ fprintf(stderr, "gallium_hud: unable to set handler for signal %u\n", signo);
+ fflush(stderr);
+
+ sig_handled = TRUE;
+ }
+
hud_parse_env_var(hud, env);
return hud;
}
projects / mesa.git / blobdiff