* Set GALLIUM_HUD=help for more info.
*/
+#include <signal.h>
#include <stdio.h>
#include "hud/hud_context.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;
struct cso_context *cso;
struct u_upload_mgr *uploader;
+ struct hud_batch_query_context *batch_query;
struct list_head pane_list;
/* states */
} text, bg, whitelines;
};
+#ifdef PIPE_OS_UNIX
+static void
+signal_visible_handler(int sig, siginfo_t *siginfo, void *context)
+{
+ huds_visible = !huds_visible;
+}
+#endif
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_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);
hud_alloc_vertices(hud, &hud->text, 4 * 512, 4 * sizeof(float));
/* prepare all graphs */
+ hud_batch_query_update(hud->batch_query);
+
LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) {
LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
gr->query_new_value(gr);
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);
}
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);
+ hud_pipe_query_install(&hud->batch_query, pane, hud->pipe,
+ "samples-passed",
+ PIPE_QUERY_OCCLUSION_COUNTER, 0, 0,
+ PIPE_DRIVER_QUERY_TYPE_UINT64,
+ PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
+ 0);
}
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);
+ hud_pipe_query_install(&hud->batch_query, pane, hud->pipe,
+ "primitives-generated",
+ PIPE_QUERY_PRIMITIVES_GENERATED, 0, 0,
+ PIPE_DRIVER_QUERY_TYPE_UINT64,
+ PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
+ 0);
}
else {
boolean processed = FALSE;
if (strcmp(name, pipeline_statistics_names[i]) == 0)
break;
if (i < Elements(pipeline_statistics_names)) {
- hud_pipe_query_install(pane, hud->pipe, name,
+ hud_pipe_query_install(&hud->batch_query, pane, hud->pipe, name,
PIPE_QUERY_PIPELINE_STATISTICS, i,
- 0, FALSE);
+ 0, PIPE_DRIVER_QUERY_TYPE_UINT64,
+ PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
+ 0);
processed = TRUE;
}
}
/* driver queries */
if (!processed) {
- if (!hud_driver_query_install(pane, hud->pipe, name)){
+ if (!hud_driver_query_install(&hud->batch_query, pane, hud->pipe,
+ name)) {
fprintf(stderr, "gallium_hud: unknown driver query '%s'\n", name);
}
}
case ',':
env++;
+ if (!pane)
+ break;
+
y += height + hud->font.glyph_height * (pane->num_graphs + 2);
height = 100;
}
if (screen->get_driver_query_info){
+ boolean skipping = false;
struct pipe_driver_query_info info;
num_queries = screen->get_driver_query_info(screen, 0, NULL);
for (i = 0; i < num_queries; i++){
screen->get_driver_query_info(screen, i, &info);
- printf(" %s\n", info.name);
+ if (info.flags & PIPE_DRIVER_QUERY_FLAG_DONT_LIST) {
+ if (!skipping)
+ puts(" ...");
+ skipping = true;
+ } else {
+ printf(" %s\n", info.name);
+ skipping = false;
+ }
}
}
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);
+#ifdef PIPE_OS_UNIX
+ static boolean sig_handled = FALSE;
+ struct sigaction action = {};
+#endif
+ huds_visible = debug_get_bool_option("GALLIUM_HUD_VISIBLE", TRUE);
if (!env || !*env)
return NULL;
LIST_INITHEAD(&hud->pane_list);
+ /* setup sig handler once for all hud contexts */
+#ifdef PIPE_OS_UNIX
+ 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;
+ }
+#endif
+
hud_parse_env_var(hud, env);
return hud;
}
FREE(pane);
}
+ hud_batch_query_cleanup(&hud->batch_query);
pipe->delete_fs_state(pipe, hud->fs_color);
pipe->delete_fs_state(pipe, hud->fs_text);
pipe->delete_vs_state(pipe, hud->vs);
projects / mesa.git / blobdiff