1 /**************************************************************************
2 *
3 * Copyright 2013 Marek Olšák <maraeo@gmail.com>
4 * All Rights Reserved.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL THE AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 *
26 **************************************************************************/
27
28 /* This head-up display module can draw transparent graphs on top of what
29 * the app is rendering, visualizing various data like framerate, cpu load,
30 * performance counters, etc. It can be hook up into any state tracker.
31 *
32 * The HUD is controlled with the GALLIUM_HUD environment variable.
33 * Set GALLIUM_HUD=help for more info.
34 */
35
36 #include <inttypes.h>
37 #include <signal.h>
38 #include <stdio.h>
39
40 #include "hud/hud_context.h"
41 #include "hud/hud_private.h"
42 #include "hud/font.h"
43
44 #include "cso_cache/cso_context.h"
45 #include "util/u_draw_quad.h"
46 #include "util/u_format.h"
47 #include "util/u_inlines.h"
48 #include "util/u_memory.h"
49 #include "util/u_math.h"
50 #include "util/u_sampler.h"
51 #include "util/u_simple_shaders.h"
52 #include "util/u_string.h"
53 #include "util/u_upload_mgr.h"
54 #include "tgsi/tgsi_text.h"
55 #include "tgsi/tgsi_dump.h"
56
57 /* Control the visibility of all HUD contexts */
58 static boolean huds_visible = TRUE;
59
60 struct hud_context {
61 struct pipe_context *pipe;
62 struct cso_context *cso;
63 struct u_upload_mgr *uploader;
64
65 struct hud_batch_query_context *batch_query;
66 struct list_head pane_list;
67
68 /* states */
69 struct pipe_blend_state no_blend, alpha_blend;
70 struct pipe_depth_stencil_alpha_state dsa;
71 void *fs_color, *fs_text;
72 struct pipe_rasterizer_state rasterizer, rasterizer_aa_lines;
73 void *vs;
74 struct pipe_vertex_element velems[2];
75
76 /* font */
77 struct util_font font;
78 struct pipe_sampler_view *font_sampler_view;
79 struct pipe_sampler_state font_sampler_state;
80
81 /* VS constant buffer */
82 struct {
83 float color[4];
84 float two_div_fb_width;
85 float two_div_fb_height;
86 float translate[2];
87 float scale[2];
88 float padding[2];
89 } constants;
90 struct pipe_constant_buffer constbuf;
91
92 unsigned fb_width, fb_height;
93
94 /* vertices for text and background drawing are accumulated here and then
95 * drawn all at once */
96 struct vertex_queue {
97 float *vertices;
98 struct pipe_vertex_buffer vbuf;
99 unsigned max_num_vertices;
100 unsigned num_vertices;
101 } text, bg, whitelines;
102
103 bool has_srgb;
104 };
105
106 #ifdef PIPE_OS_UNIX
107 static void
signal_visible_handler(int sig,siginfo_t * siginfo,void * context)108 signal_visible_handler(int sig, siginfo_t *siginfo, void *context)
109 {
110 huds_visible = !huds_visible;
111 }
112 #endif
113
114 static void
hud_draw_colored_prims(struct hud_context * hud,unsigned prim,float * buffer,unsigned num_vertices,float r,float g,float b,float a,int xoffset,int yoffset,float yscale)115 hud_draw_colored_prims(struct hud_context *hud, unsigned prim,
116 float *buffer, unsigned num_vertices,
117 float r, float g, float b, float a,
118 int xoffset, int yoffset, float yscale)
119 {
120 struct cso_context *cso = hud->cso;
121 struct pipe_vertex_buffer vbuffer = {0};
122
123 hud->constants.color[0] = r;
124 hud->constants.color[1] = g;
125 hud->constants.color[2] = b;
126 hud->constants.color[3] = a;
127 hud->constants.translate[0] = (float) xoffset;
128 hud->constants.translate[1] = (float) yoffset;
129 hud->constants.scale[0] = 1;
130 hud->constants.scale[1] = yscale;
131 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
132
133 vbuffer.user_buffer = buffer;
134 vbuffer.stride = 2 * sizeof(float);
135
136 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso),
137 1, &vbuffer);
138 cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
139 cso_draw_arrays(cso, prim, 0, num_vertices);
140 }
141
142 static void
hud_draw_colored_quad(struct hud_context * hud,unsigned prim,unsigned x1,unsigned y1,unsigned x2,unsigned y2,float r,float g,float b,float a)143 hud_draw_colored_quad(struct hud_context *hud, unsigned prim,
144 unsigned x1, unsigned y1, unsigned x2, unsigned y2,
145 float r, float g, float b, float a)
146 {
147 float buffer[] = {
148 (float) x1, (float) y1,
149 (float) x1, (float) y2,
150 (float) x2, (float) y2,
151 (float) x2, (float) y1,
152 };
153
154 hud_draw_colored_prims(hud, prim, buffer, 4, r, g, b, a, 0, 0, 1);
155 }
156
157 static void
hud_draw_background_quad(struct hud_context * hud,unsigned x1,unsigned y1,unsigned x2,unsigned y2)158 hud_draw_background_quad(struct hud_context *hud,
159 unsigned x1, unsigned y1, unsigned x2, unsigned y2)
160 {
161 float *vertices = hud->bg.vertices + hud->bg.num_vertices*2;
162 unsigned num = 0;
163
164 assert(hud->bg.num_vertices + 4 <= hud->bg.max_num_vertices);
165
166 vertices[num++] = (float) x1;
167 vertices[num++] = (float) y1;
168
169 vertices[num++] = (float) x1;
170 vertices[num++] = (float) y2;
171
172 vertices[num++] = (float) x2;
173 vertices[num++] = (float) y2;
174
175 vertices[num++] = (float) x2;
176 vertices[num++] = (float) y1;
177
178 hud->bg.num_vertices += num/2;
179 }
180
181 static void
hud_draw_string(struct hud_context * hud,unsigned x,unsigned y,const char * str,...)182 hud_draw_string(struct hud_context *hud, unsigned x, unsigned y,
183 const char *str, ...)
184 {
185 char buf[256];
186 char *s = buf;
187 float *vertices = hud->text.vertices + hud->text.num_vertices*4;
188 unsigned num = 0;
189
190 va_list ap;
191 va_start(ap, str);
192 util_vsnprintf(buf, sizeof(buf), str, ap);
193 va_end(ap);
194
195 if (!*s)
196 return;
197
198 hud_draw_background_quad(hud,
199 x, y,
200 x + strlen(buf)*hud->font.glyph_width,
201 y + hud->font.glyph_height);
202
203 while (*s) {
204 unsigned x1 = x;
205 unsigned y1 = y;
206 unsigned x2 = x + hud->font.glyph_width;
207 unsigned y2 = y + hud->font.glyph_height;
208 unsigned tx1 = (*s % 16) * hud->font.glyph_width;
209 unsigned ty1 = (*s / 16) * hud->font.glyph_height;
210 unsigned tx2 = tx1 + hud->font.glyph_width;
211 unsigned ty2 = ty1 + hud->font.glyph_height;
212
213 if (*s == ' ') {
214 x += hud->font.glyph_width;
215 s++;
216 continue;
217 }
218
219 assert(hud->text.num_vertices + num/4 + 4 <= hud->text.max_num_vertices);
220
221 vertices[num++] = (float) x1;
222 vertices[num++] = (float) y1;
223 vertices[num++] = (float) tx1;
224 vertices[num++] = (float) ty1;
225
226 vertices[num++] = (float) x1;
227 vertices[num++] = (float) y2;
228 vertices[num++] = (float) tx1;
229 vertices[num++] = (float) ty2;
230
231 vertices[num++] = (float) x2;
232 vertices[num++] = (float) y2;
233 vertices[num++] = (float) tx2;
234 vertices[num++] = (float) ty2;
235
236 vertices[num++] = (float) x2;
237 vertices[num++] = (float) y1;
238 vertices[num++] = (float) tx2;
239 vertices[num++] = (float) ty1;
240
241 x += hud->font.glyph_width;
242 s++;
243 }
244
245 hud->text.num_vertices += num/4;
246 }
247
248 static void
number_to_human_readable(uint64_t num,enum pipe_driver_query_type type,char * out)249 number_to_human_readable(uint64_t num, enum pipe_driver_query_type type,
250 char *out)
251 {
252 static const char *byte_units[] =
253 {" B", " KB", " MB", " GB", " TB", " PB", " EB"};
254 static const char *metric_units[] =
255 {"", " k", " M", " G", " T", " P", " E"};
256 static const char *time_units[] =
257 {" us", " ms", " s"}; /* based on microseconds */
258 static const char *hz_units[] =
259 {" Hz", " KHz", " MHz", " GHz"};
260 static const char *percent_units[] = {"%"};
261 static const char *dbm_units[] = {" (-dBm)"};
262 static const char *temperature_units[] = {" C"};
263 static const char *volt_units[] = {" mV", " V"};
264 static const char *amp_units[] = {" mA", " A"};
265 static const char *watt_units[] = {" mW", " W"};
266
267 const char **units;
268 unsigned max_unit;
269 double divisor = (type == PIPE_DRIVER_QUERY_TYPE_BYTES) ? 1024 : 1000;
270 unsigned unit = 0;
271 double d = num;
272
273 switch (type) {
274 case PIPE_DRIVER_QUERY_TYPE_MICROSECONDS:
275 max_unit = ARRAY_SIZE(time_units)-1;
276 units = time_units;
277 break;
278 case PIPE_DRIVER_QUERY_TYPE_VOLTS:
279 max_unit = ARRAY_SIZE(volt_units)-1;
280 units = volt_units;
281 break;
282 case PIPE_DRIVER_QUERY_TYPE_AMPS:
283 max_unit = ARRAY_SIZE(amp_units)-1;
284 units = amp_units;
285 break;
286 case PIPE_DRIVER_QUERY_TYPE_DBM:
287 max_unit = ARRAY_SIZE(dbm_units)-1;
288 units = dbm_units;
289 break;
290 case PIPE_DRIVER_QUERY_TYPE_TEMPERATURE:
291 max_unit = ARRAY_SIZE(temperature_units)-1;
292 units = temperature_units;
293 break;
294 case PIPE_DRIVER_QUERY_TYPE_PERCENTAGE:
295 max_unit = ARRAY_SIZE(percent_units)-1;
296 units = percent_units;
297 break;
298 case PIPE_DRIVER_QUERY_TYPE_BYTES:
299 max_unit = ARRAY_SIZE(byte_units)-1;
300 units = byte_units;
301 break;
302 case PIPE_DRIVER_QUERY_TYPE_HZ:
303 max_unit = ARRAY_SIZE(hz_units)-1;
304 units = hz_units;
305 break;
306 case PIPE_DRIVER_QUERY_TYPE_WATTS:
307 max_unit = ARRAY_SIZE(watt_units)-1;
308 units = watt_units;
309 break;
310 default:
311 max_unit = ARRAY_SIZE(metric_units)-1;
312 units = metric_units;
313 }
314
315 while (d > divisor && unit < max_unit) {
316 d /= divisor;
317 unit++;
318 }
319
320 /* Round to 3 decimal places so as not to print trailing zeros. */
321 if (d*1000 != (int)(d*1000))
322 d = round(d * 1000) / 1000;
323
324 /* Show at least 4 digits with at most 3 decimal places, but not zeros. */
325 if (d >= 1000 || d == (int)d)
326 sprintf(out, "%.0f%s", d, units[unit]);
327 else if (d >= 100 || d*10 == (int)(d*10))
328 sprintf(out, "%.1f%s", d, units[unit]);
329 else if (d >= 10 || d*100 == (int)(d*100))
330 sprintf(out, "%.2f%s", d, units[unit]);
331 else
332 sprintf(out, "%.3f%s", d, units[unit]);
333 }
334
335 static void
hud_draw_graph_line_strip(struct hud_context * hud,const struct hud_graph * gr,unsigned xoffset,unsigned yoffset,float yscale)336 hud_draw_graph_line_strip(struct hud_context *hud, const struct hud_graph *gr,
337 unsigned xoffset, unsigned yoffset, float yscale)
338 {
339 if (gr->num_vertices <= 1)
340 return;
341
342 assert(gr->index <= gr->num_vertices);
343
344 hud_draw_colored_prims(hud, PIPE_PRIM_LINE_STRIP,
345 gr->vertices, gr->index,
346 gr->color[0], gr->color[1], gr->color[2], 1,
347 xoffset + (gr->pane->max_num_vertices - gr->index - 1) * 2 - 1,
348 yoffset, yscale);
349
350 if (gr->num_vertices <= gr->index)
351 return;
352
353 hud_draw_colored_prims(hud, PIPE_PRIM_LINE_STRIP,
354 gr->vertices + gr->index*2,
355 gr->num_vertices - gr->index,
356 gr->color[0], gr->color[1], gr->color[2], 1,
357 xoffset - gr->index*2 - 1, yoffset, yscale);
358 }
359
360 static void
hud_pane_accumulate_vertices(struct hud_context * hud,const struct hud_pane * pane)361 hud_pane_accumulate_vertices(struct hud_context *hud,
362 const struct hud_pane *pane)
363 {
364 struct hud_graph *gr;
365 float *line_verts = hud->whitelines.vertices + hud->whitelines.num_vertices*2;
366 unsigned i, num = 0;
367 char str[32];
368 const unsigned last_line = pane->last_line;
369
370 /* draw background */
371 hud_draw_background_quad(hud,
372 pane->x1, pane->y1,
373 pane->x2, pane->y2);
374
375 /* draw numbers on the right-hand side */
376 for (i = 0; i <= last_line; i++) {
377 unsigned x = pane->x2 + 2;
378 unsigned y = pane->inner_y1 +
379 pane->inner_height * (last_line - i) / last_line -
380 hud->font.glyph_height / 2;
381
382 number_to_human_readable(pane->max_value * i / last_line,
383 pane->type, str);
384 hud_draw_string(hud, x, y, "%s", str);
385 }
386
387 /* draw info below the pane */
388 i = 0;
389 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
390 unsigned x = pane->x1 + 2;
391 unsigned y = pane->y2 + 2 + i*hud->font.glyph_height;
392
393 number_to_human_readable(gr->current_value, pane->type, str);
394 hud_draw_string(hud, x, y, " %s: %s", gr->name, str);
395 i++;
396 }
397
398 /* draw border */
399 assert(hud->whitelines.num_vertices + num/2 + 8 <= hud->whitelines.max_num_vertices);
400 line_verts[num++] = (float) pane->x1;
401 line_verts[num++] = (float) pane->y1;
402 line_verts[num++] = (float) pane->x2;
403 line_verts[num++] = (float) pane->y1;
404
405 line_verts[num++] = (float) pane->x2;
406 line_verts[num++] = (float) pane->y1;
407 line_verts[num++] = (float) pane->x2;
408 line_verts[num++] = (float) pane->y2;
409
410 line_verts[num++] = (float) pane->x1;
411 line_verts[num++] = (float) pane->y2;
412 line_verts[num++] = (float) pane->x2;
413 line_verts[num++] = (float) pane->y2;
414
415 line_verts[num++] = (float) pane->x1;
416 line_verts[num++] = (float) pane->y1;
417 line_verts[num++] = (float) pane->x1;
418 line_verts[num++] = (float) pane->y2;
419
420 /* draw horizontal lines inside the graph */
421 for (i = 0; i <= last_line; i++) {
422 float y = round((pane->max_value * i / (double)last_line) *
423 pane->yscale + pane->inner_y2);
424
425 assert(hud->whitelines.num_vertices + num/2 + 2 <= hud->whitelines.max_num_vertices);
426 line_verts[num++] = pane->x1;
427 line_verts[num++] = y;
428 line_verts[num++] = pane->x2;
429 line_verts[num++] = y;
430 }
431
432 hud->whitelines.num_vertices += num/2;
433 }
434
435 static void
hud_pane_draw_colored_objects(struct hud_context * hud,const struct hud_pane * pane)436 hud_pane_draw_colored_objects(struct hud_context *hud,
437 const struct hud_pane *pane)
438 {
439 struct hud_graph *gr;
440 unsigned i;
441
442 /* draw colored quads below the pane */
443 i = 0;
444 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
445 unsigned x = pane->x1 + 2;
446 unsigned y = pane->y2 + 2 + i*hud->font.glyph_height;
447
448 hud_draw_colored_quad(hud, PIPE_PRIM_QUADS, x + 1, y + 1, x + 12, y + 13,
449 gr->color[0], gr->color[1], gr->color[2], 1);
450 i++;
451 }
452
453 /* draw the line strips */
454 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
455 hud_draw_graph_line_strip(hud, gr, pane->inner_x1, pane->inner_y2, pane->yscale);
456 }
457 }
458
459 static void
hud_alloc_vertices(struct hud_context * hud,struct vertex_queue * v,unsigned num_vertices,unsigned stride)460 hud_alloc_vertices(struct hud_context *hud, struct vertex_queue *v,
461 unsigned num_vertices, unsigned stride)
462 {
463 v->num_vertices = 0;
464 v->max_num_vertices = num_vertices;
465 v->vbuf.stride = stride;
466 u_upload_alloc(hud->uploader, 0, v->vbuf.stride * v->max_num_vertices,
467 16, &v->vbuf.buffer_offset, &v->vbuf.buffer,
468 (void**)&v->vertices);
469 }
470
471 /**
472 * Draw the HUD to the texture \p tex.
473 * The texture is usually the back buffer being displayed.
474 */
475 void
hud_draw(struct hud_context * hud,struct pipe_resource * tex)476 hud_draw(struct hud_context *hud, struct pipe_resource *tex)
477 {
478 struct cso_context *cso = hud->cso;
479 struct pipe_context *pipe = hud->pipe;
480 struct pipe_framebuffer_state fb;
481 struct pipe_surface surf_templ, *surf;
482 struct pipe_viewport_state viewport;
483 const struct pipe_sampler_state *sampler_states[] =
484 { &hud->font_sampler_state };
485 struct hud_pane *pane;
486 struct hud_graph *gr, *next;
487
488 if (!huds_visible)
489 return;
490
491 hud->fb_width = tex->width0;
492 hud->fb_height = tex->height0;
493 hud->constants.two_div_fb_width = 2.0f / hud->fb_width;
494 hud->constants.two_div_fb_height = 2.0f / hud->fb_height;
495
496 cso_save_state(cso, (CSO_BIT_FRAMEBUFFER |
497 CSO_BIT_SAMPLE_MASK |
498 CSO_BIT_MIN_SAMPLES |
499 CSO_BIT_BLEND |
500 CSO_BIT_DEPTH_STENCIL_ALPHA |
501 CSO_BIT_FRAGMENT_SHADER |
502 CSO_BIT_FRAGMENT_SAMPLER_VIEWS |
503 CSO_BIT_FRAGMENT_SAMPLERS |
504 CSO_BIT_RASTERIZER |
505 CSO_BIT_VIEWPORT |
506 CSO_BIT_STREAM_OUTPUTS |
507 CSO_BIT_GEOMETRY_SHADER |
508 CSO_BIT_TESSCTRL_SHADER |
509 CSO_BIT_TESSEVAL_SHADER |
510 CSO_BIT_VERTEX_SHADER |
511 CSO_BIT_VERTEX_ELEMENTS |
512 CSO_BIT_AUX_VERTEX_BUFFER_SLOT |
513 CSO_BIT_PAUSE_QUERIES |
514 CSO_BIT_RENDER_CONDITION));
515 cso_save_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX);
516
517 /* set states */
518 memset(&surf_templ, 0, sizeof(surf_templ));
519 surf_templ.format = tex->format;
520
521 /* Without this, AA lines look thinner if they are between 2 pixels
522 * because the alpha is 0.5 on both pixels. (it's ugly)
523 *
524 * sRGB makes the width of all AA lines look the same.
525 */
526 if (hud->has_srgb) {
527 enum pipe_format srgb_format = util_format_srgb(tex->format);
528
529 if (srgb_format != PIPE_FORMAT_NONE)
530 surf_templ.format = srgb_format;
531 }
532 surf = pipe->create_surface(pipe, tex, &surf_templ);
533
534 memset(&fb, 0, sizeof(fb));
535 fb.nr_cbufs = 1;
536 fb.cbufs[0] = surf;
537 fb.zsbuf = NULL;
538 fb.width = hud->fb_width;
539 fb.height = hud->fb_height;
540
541 viewport.scale[0] = 0.5f * hud->fb_width;
542 viewport.scale[1] = 0.5f * hud->fb_height;
543 viewport.scale[2] = 1.0f;
544 viewport.translate[0] = 0.5f * hud->fb_width;
545 viewport.translate[1] = 0.5f * hud->fb_height;
546 viewport.translate[2] = 0.0f;
547
548 cso_set_framebuffer(cso, &fb);
549 cso_set_sample_mask(cso, ~0);
550 cso_set_min_samples(cso, 1);
551 cso_set_depth_stencil_alpha(cso, &hud->dsa);
552 cso_set_rasterizer(cso, &hud->rasterizer);
553 cso_set_viewport(cso, &viewport);
554 cso_set_stream_outputs(cso, 0, NULL, NULL);
555 cso_set_tessctrl_shader_handle(cso, NULL);
556 cso_set_tesseval_shader_handle(cso, NULL);
557 cso_set_geometry_shader_handle(cso, NULL);
558 cso_set_vertex_shader_handle(cso, hud->vs);
559 cso_set_vertex_elements(cso, 2, hud->velems);
560 cso_set_render_condition(cso, NULL, FALSE, 0);
561 cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1,
562 &hud->font_sampler_view);
563 cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, sampler_states);
564 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
565
566 /* prepare vertex buffers */
567 hud_alloc_vertices(hud, &hud->bg, 16 * 256, 2 * sizeof(float));
568 hud_alloc_vertices(hud, &hud->whitelines, 4 * 256, 2 * sizeof(float));
569 hud_alloc_vertices(hud, &hud->text, 16 * 1024, 4 * sizeof(float));
570
571 /* prepare all graphs */
572 hud_batch_query_update(hud->batch_query);
573
574 LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) {
575 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
576 gr->query_new_value(gr);
577 }
578
579 if (pane->sort_items) {
580 LIST_FOR_EACH_ENTRY_SAFE(gr, next, &pane->graph_list, head) {
581 /* ignore the last one */
582 if (&gr->head == pane->graph_list.prev)
583 continue;
584
585 /* This is an incremental bubble sort, because we only do one pass
586 * per frame. It will eventually reach an equilibrium.
587 */
588 if (gr->current_value <
589 LIST_ENTRY(struct hud_graph, next, head)->current_value) {
590 LIST_DEL(&gr->head);
591 LIST_ADD(&gr->head, &next->head);
592 }
593 }
594 }
595
596 hud_pane_accumulate_vertices(hud, pane);
597 }
598
599 /* unmap the uploader's vertex buffer before drawing */
600 u_upload_unmap(hud->uploader);
601
602 /* draw accumulated vertices for background quads */
603 cso_set_blend(cso, &hud->alpha_blend);
604 cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
605
606 if (hud->bg.num_vertices) {
607 hud->constants.color[0] = 0;
608 hud->constants.color[1] = 0;
609 hud->constants.color[2] = 0;
610 hud->constants.color[3] = 0.666f;
611 hud->constants.translate[0] = 0;
612 hud->constants.translate[1] = 0;
613 hud->constants.scale[0] = 1;
614 hud->constants.scale[1] = 1;
615
616 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
617 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
618 &hud->bg.vbuf);
619 cso_draw_arrays(cso, PIPE_PRIM_QUADS, 0, hud->bg.num_vertices);
620 }
621 pipe_resource_reference(&hud->bg.vbuf.buffer, NULL);
622
623 /* draw accumulated vertices for white lines */
624 cso_set_blend(cso, &hud->no_blend);
625
626 hud->constants.color[0] = 1;
627 hud->constants.color[1] = 1;
628 hud->constants.color[2] = 1;
629 hud->constants.color[3] = 1;
630 hud->constants.translate[0] = 0;
631 hud->constants.translate[1] = 0;
632 hud->constants.scale[0] = 1;
633 hud->constants.scale[1] = 1;
634 cso_set_constant_buffer(cso, PIPE_SHADER_VERTEX, 0, &hud->constbuf);
635
636 if (hud->whitelines.num_vertices) {
637 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
638 &hud->whitelines.vbuf);
639 cso_set_fragment_shader_handle(hud->cso, hud->fs_color);
640 cso_draw_arrays(cso, PIPE_PRIM_LINES, 0, hud->whitelines.num_vertices);
641 }
642 pipe_resource_reference(&hud->whitelines.vbuf.buffer, NULL);
643
644 /* draw accumulated vertices for text */
645 cso_set_blend(cso, &hud->alpha_blend);
646 if (hud->text.num_vertices) {
647 cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1,
648 &hud->text.vbuf);
649 cso_set_fragment_shader_handle(hud->cso, hud->fs_text);
650 cso_draw_arrays(cso, PIPE_PRIM_QUADS, 0, hud->text.num_vertices);
651 }
652 pipe_resource_reference(&hud->text.vbuf.buffer, NULL);
653
654 /* draw the rest */
655 cso_set_rasterizer(cso, &hud->rasterizer_aa_lines);
656 LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) {
657 if (pane)
658 hud_pane_draw_colored_objects(hud, pane);
659 }
660
661 cso_restore_state(cso);
662 cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_VERTEX);
663
664 pipe_surface_reference(&surf, NULL);
665
666 /* Start queries. */
667 hud_batch_query_begin(hud->batch_query);
668
669 LIST_FOR_EACH_ENTRY(pane, &hud->pane_list, head) {
670 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
671 if (gr->begin_query)
672 gr->begin_query(gr);
673 }
674 }
675 }
676
677 static void
fixup_bytes(enum pipe_driver_query_type type,int position,uint64_t * exp10)678 fixup_bytes(enum pipe_driver_query_type type, int position, uint64_t *exp10)
679 {
680 if (type == PIPE_DRIVER_QUERY_TYPE_BYTES && position % 3 == 0)
681 *exp10 = (*exp10 / 1000) * 1024;
682 }
683
684 /**
685 * Set the maximum value for the Y axis of the graph.
686 * This scales the graph accordingly.
687 */
688 void
hud_pane_set_max_value(struct hud_pane * pane,uint64_t value)689 hud_pane_set_max_value(struct hud_pane *pane, uint64_t value)
690 {
691 double leftmost_digit;
692 uint64_t exp10;
693 int i;
694
695 /* The following code determines the max_value in the graph as well as
696 * how many describing lines are drawn. The max_value is rounded up,
697 * so that all drawn numbers are rounded for readability.
698 * We want to print multiples of a simple number instead of multiples of
699 * hard-to-read numbers like 1.753.
700 */
701
702 /* Find the left-most digit. */
703 exp10 = 1;
704 for (i = 0; value > 9 * exp10; i++) {
705 exp10 *= 10;
706 fixup_bytes(pane->type, i + 1, &exp10);
707 }
708
709 leftmost_digit = DIV_ROUND_UP(value, exp10);
710
711 /* Round 9 to 10. */
712 if (leftmost_digit == 9) {
713 leftmost_digit = 1;
714 exp10 *= 10;
715 fixup_bytes(pane->type, i + 1, &exp10);
716 }
717
718 switch ((unsigned)leftmost_digit) {
719 case 1:
720 pane->last_line = 5; /* lines in +1/5 increments */
721 break;
722 case 2:
723 pane->last_line = 8; /* lines in +1/4 increments. */
724 break;
725 case 3:
726 case 4:
727 pane->last_line = leftmost_digit * 2; /* lines in +1/2 increments */
728 break;
729 case 5:
730 case 6:
731 case 7:
732 case 8:
733 pane->last_line = leftmost_digit; /* lines in +1 increments */
734 break;
735 default:
736 assert(0);
737 }
738
739 /* Truncate {3,4} to {2.5, 3.5} if possible. */
740 for (i = 3; i <= 4; i++) {
741 if (leftmost_digit == i && value <= (i - 0.5) * exp10) {
742 leftmost_digit = i - 0.5;
743 pane->last_line = leftmost_digit * 2; /* lines in +1/2 increments. */
744 }
745 }
746
747 /* Truncate 2 to a multiple of 0.2 in (1, 1.6] if possible. */
748 if (leftmost_digit == 2) {
749 for (i = 1; i <= 3; i++) {
750 if (value <= (1 + i*0.2) * exp10) {
751 leftmost_digit = 1 + i*0.2;
752 pane->last_line = 5 + i; /* lines in +1/5 increments. */
753 break;
754 }
755 }
756 }
757
758 pane->max_value = leftmost_digit * exp10;
759 pane->yscale = -(int)pane->inner_height / (float)pane->max_value;
760 }
761
762 static void
hud_pane_update_dyn_ceiling(struct hud_graph * gr,struct hud_pane * pane)763 hud_pane_update_dyn_ceiling(struct hud_graph *gr, struct hud_pane *pane)
764 {
765 unsigned i;
766 float tmp = 0.0f;
767
768 if (pane->dyn_ceil_last_ran != gr->index) {
769 LIST_FOR_EACH_ENTRY(gr, &pane->graph_list, head) {
770 for (i = 0; i < gr->num_vertices; ++i) {
771 tmp = gr->vertices[i * 2 + 1] > tmp ?
772 gr->vertices[i * 2 + 1] : tmp;
773 }
774 }
775
776 /* Avoid setting it lower than the initial starting height. */
777 tmp = tmp > pane->initial_max_value ? tmp : pane->initial_max_value;
778 hud_pane_set_max_value(pane, tmp);
779 }
780
781 /*
782 * Mark this adjustment run so we could avoid repeating a full update
783 * again needlessly in case the pane has more than one graph.
784 */
785 pane->dyn_ceil_last_ran = gr->index;
786 }
787
788 static struct hud_pane *
hud_pane_create(unsigned x1,unsigned y1,unsigned x2,unsigned y2,unsigned period,uint64_t max_value,uint64_t ceiling,boolean dyn_ceiling,boolean sort_items)789 hud_pane_create(unsigned x1, unsigned y1, unsigned x2, unsigned y2,
790 unsigned period, uint64_t max_value, uint64_t ceiling,
791 boolean dyn_ceiling, boolean sort_items)
792 {
793 struct hud_pane *pane = CALLOC_STRUCT(hud_pane);
794
795 if (!pane)
796 return NULL;
797
798 pane->x1 = x1;
799 pane->y1 = y1;
800 pane->x2 = x2;
801 pane->y2 = y2;
802 pane->inner_x1 = x1 + 1;
803 pane->inner_x2 = x2 - 1;
804 pane->inner_y1 = y1 + 1;
805 pane->inner_y2 = y2 - 1;
806 pane->inner_width = pane->inner_x2 - pane->inner_x1;
807 pane->inner_height = pane->inner_y2 - pane->inner_y1;
808 pane->period = period;
809 pane->max_num_vertices = (x2 - x1 + 2) / 2;
810 pane->ceiling = ceiling;
811 pane->dyn_ceiling = dyn_ceiling;
812 pane->dyn_ceil_last_ran = 0;
813 pane->sort_items = sort_items;
814 pane->initial_max_value = max_value;
815 hud_pane_set_max_value(pane, max_value);
816 LIST_INITHEAD(&pane->graph_list);
817 return pane;
818 }
819
820 /* replace '-' with a space */
821 static void
strip_hyphens(char * s)822 strip_hyphens(char *s)
823 {
824 while (*s) {
825 if (*s == '-')
826 *s = ' ';
827 s++;
828 }
829 }
830
831 /**
832 * Add a graph to an existing pane.
833 * One pane can contain multiple graphs over each other.
834 */
835 void
hud_pane_add_graph(struct hud_pane * pane,struct hud_graph * gr)836 hud_pane_add_graph(struct hud_pane *pane, struct hud_graph *gr)
837 {
838 static const float colors[][3] = {
839 {0, 1, 0},
840 {1, 0, 0},
841 {0, 1, 1},
842 {1, 0, 1},
843 {1, 1, 0},
844 {0.5, 1, 0.5},
845 {1, 0.5, 0.5},
846 {0.5, 1, 1},
847 {1, 0.5, 1},
848 {1, 1, 0.5},
849 {0, 0.5, 0},
850 {0.5, 0, 0},
851 {0, 0.5, 0.5},
852 {0.5, 0, 0.5},
853 {0.5, 0.5, 0},
854 };
855 unsigned color = pane->next_color % ARRAY_SIZE(colors);
856
857 strip_hyphens(gr->name);
858
859 gr->vertices = MALLOC(pane->max_num_vertices * sizeof(float) * 2);
860 gr->color[0] = colors[color][0];
861 gr->color[1] = colors[color][1];
862 gr->color[2] = colors[color][2];
863 gr->pane = pane;
864 LIST_ADDTAIL(&gr->head, &pane->graph_list);
865 pane->num_graphs++;
866 pane->next_color++;
867 }
868
869 void
hud_graph_add_value(struct hud_graph * gr,uint64_t value)870 hud_graph_add_value(struct hud_graph *gr, uint64_t value)
871 {
872 gr->current_value = value;
873 value = value > gr->pane->ceiling ? gr->pane->ceiling : value;
874
875 if (gr->fd)
876 fprintf(gr->fd, "%" PRIu64 "\n", value);
877
878 if (gr->index == gr->pane->max_num_vertices) {
879 gr->vertices[0] = 0;
880 gr->vertices[1] = gr->vertices[(gr->index-1)*2+1];
881 gr->index = 1;
882 }
883 gr->vertices[(gr->index)*2+0] = (float) (gr->index * 2);
884 gr->vertices[(gr->index)*2+1] = (float) value;
885 gr->index++;
886
887 if (gr->num_vertices < gr->pane->max_num_vertices) {
888 gr->num_vertices++;
889 }
890
891 if (gr->pane->dyn_ceiling == true) {
892 hud_pane_update_dyn_ceiling(gr, gr->pane);
893 }
894 if (value > gr->pane->max_value) {
895 hud_pane_set_max_value(gr->pane, value);
896 }
897 }
898
899 static void
hud_graph_destroy(struct hud_graph * graph)900 hud_graph_destroy(struct hud_graph *graph)
901 {
902 FREE(graph->vertices);
903 if (graph->free_query_data)
904 graph->free_query_data(graph->query_data);
905 if (graph->fd)
906 fclose(graph->fd);
907 FREE(graph);
908 }
909
910 void
hud_graph_set_dump_file(struct hud_graph * gr)911 hud_graph_set_dump_file(struct hud_graph *gr)
912 {
913 #ifndef PIPE_OS_WINDOWS
914 const char *hud_dump_dir = getenv("GALLIUM_HUD_DUMP_DIR");
915 char *dump_file;
916
917 if (hud_dump_dir && access(hud_dump_dir, W_OK) == 0) {
918 dump_file = malloc(strlen(hud_dump_dir) + sizeof("/") + sizeof(gr->name));
919 if (dump_file) {
920 strcpy(dump_file, hud_dump_dir);
921 strcat(dump_file, "/");
922 strcat(dump_file, gr->name);
923 gr->fd = fopen(dump_file, "w+");
924 free(dump_file);
925 }
926 }
927 #endif
928 }
929
930 /**
931 * Read a string from the environment variable.
932 * The separators "+", ",", ":", and ";" terminate the string.
933 * Return the number of read characters.
934 */
935 static int
parse_string(const char * s,char * out)936 parse_string(const char *s, char *out)
937 {
938 int i;
939
940 for (i = 0; *s && *s != '+' && *s != ',' && *s != ':' && *s != ';' && *s != '=';
941 s++, out++, i++)
942 *out = *s;
943
944 *out = 0;
945
946 if (*s && !i) {
947 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) while "
948 "parsing a string\n", *s, *s);
949 fflush(stderr);
950 }
951
952 return i;
953 }
954
955 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,boolean * reset_colors,boolean * sort_items)956 read_pane_settings(char *str, unsigned * const x, unsigned * const y,
957 unsigned * const width, unsigned * const height,
958 uint64_t * const ceiling, boolean * const dyn_ceiling,
959 boolean *reset_colors, boolean *sort_items)
960 {
961 char *ret = str;
962 unsigned tmp;
963
964 while (*str == '.') {
965 ++str;
966 switch (*str) {
967 case 'x':
968 ++str;
969 *x = strtoul(str, &ret, 10);
970 str = ret;
971 break;
972
973 case 'y':
974 ++str;
975 *y = strtoul(str, &ret, 10);
976 str = ret;
977 break;
978
979 case 'w':
980 ++str;
981 tmp = strtoul(str, &ret, 10);
982 *width = tmp > 80 ? tmp : 80; /* 80 is chosen arbitrarily */
983 str = ret;
984 break;
985
986 /*
987 * Prevent setting height to less than 50. If the height is set to less,
988 * the text of the Y axis labels on the graph will start overlapping.
989 */
990 case 'h':
991 ++str;
992 tmp = strtoul(str, &ret, 10);
993 *height = tmp > 50 ? tmp : 50;
994 str = ret;
995 break;
996
997 case 'c':
998 ++str;
999 tmp = strtoul(str, &ret, 10);
1000 *ceiling = tmp > 10 ? tmp : 10;
1001 str = ret;
1002 break;
1003
1004 case 'd':
1005 ++str;
1006 ret = str;
1007 *dyn_ceiling = true;
1008 break;
1009
1010 case 'r':
1011 ++str;
1012 ret = str;
1013 *reset_colors = true;
1014 break;
1015
1016 case 's':
1017 ++str;
1018 ret = str;
1019 *sort_items = true;
1020 break;
1021
1022 default:
1023 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *str);
1024 fflush(stderr);
1025 }
1026
1027 }
1028
1029 return ret;
1030 }
1031
1032 static boolean
has_occlusion_query(struct pipe_screen * screen)1033 has_occlusion_query(struct pipe_screen *screen)
1034 {
1035 return screen->get_param(screen, PIPE_CAP_OCCLUSION_QUERY) != 0;
1036 }
1037
1038 static boolean
has_streamout(struct pipe_screen * screen)1039 has_streamout(struct pipe_screen *screen)
1040 {
1041 return screen->get_param(screen, PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS) != 0;
1042 }
1043
1044 static boolean
has_pipeline_stats_query(struct pipe_screen * screen)1045 has_pipeline_stats_query(struct pipe_screen *screen)
1046 {
1047 return screen->get_param(screen, PIPE_CAP_QUERY_PIPELINE_STATISTICS) != 0;
1048 }
1049
1050 static void
hud_parse_env_var(struct hud_context * hud,const char * env)1051 hud_parse_env_var(struct hud_context *hud, const char *env)
1052 {
1053 unsigned num, i;
1054 char name_a[256], s[256];
1055 char *name;
1056 struct hud_pane *pane = NULL;
1057 unsigned x = 10, y = 10;
1058 unsigned width = 251, height = 100;
1059 unsigned period = 500 * 1000; /* default period (1/2 second) */
1060 uint64_t ceiling = UINT64_MAX;
1061 unsigned column_width = 251;
1062 boolean dyn_ceiling = false;
1063 boolean reset_colors = false;
1064 boolean sort_items = false;
1065 const char *period_env;
1066
1067 /*
1068 * The GALLIUM_HUD_PERIOD env var sets the graph update rate.
1069 * The env var is in seconds (a float).
1070 * Zero means update after every frame.
1071 */
1072 period_env = getenv("GALLIUM_HUD_PERIOD");
1073 if (period_env) {
1074 float p = (float) atof(period_env);
1075 if (p >= 0.0f) {
1076 period = (unsigned) (p * 1000 * 1000);
1077 }
1078 }
1079
1080 while ((num = parse_string(env, name_a)) != 0) {
1081 env += num;
1082
1083 /* check for explicit location, size and etc. settings */
1084 name = read_pane_settings(name_a, &x, &y, &width, &height, &ceiling,
1085 &dyn_ceiling, &reset_colors, &sort_items);
1086
1087 /*
1088 * Keep track of overall column width to avoid pane overlapping in case
1089 * later we create a new column while the bottom pane in the current
1090 * column is less wide than the rest of the panes in it.
1091 */
1092 column_width = width > column_width ? width : column_width;
1093
1094 if (!pane) {
1095 pane = hud_pane_create(x, y, x + width, y + height, period, 10,
1096 ceiling, dyn_ceiling, sort_items);
1097 if (!pane)
1098 return;
1099 }
1100
1101 if (reset_colors) {
1102 pane->next_color = 0;
1103 reset_colors = false;
1104 }
1105
1106 /* Add a graph. */
1107 #if HAVE_GALLIUM_EXTRA_HUD || HAVE_LIBSENSORS
1108 char arg_name[64];
1109 #endif
1110 /* IF YOU CHANGE THIS, UPDATE print_help! */
1111 if (strcmp(name, "fps") == 0) {
1112 hud_fps_graph_install(pane);
1113 }
1114 else if (strcmp(name, "cpu") == 0) {
1115 hud_cpu_graph_install(pane, ALL_CPUS);
1116 }
1117 else if (sscanf(name, "cpu%u%s", &i, s) == 1) {
1118 hud_cpu_graph_install(pane, i);
1119 }
1120 #if HAVE_GALLIUM_EXTRA_HUD
1121 else if (sscanf(name, "nic-rx-%s", arg_name) == 1) {
1122 hud_nic_graph_install(pane, arg_name, NIC_DIRECTION_RX);
1123 }
1124 else if (sscanf(name, "nic-tx-%s", arg_name) == 1) {
1125 hud_nic_graph_install(pane, arg_name, NIC_DIRECTION_TX);
1126 }
1127 else if (sscanf(name, "nic-rssi-%s", arg_name) == 1) {
1128 hud_nic_graph_install(pane, arg_name, NIC_RSSI_DBM);
1129 pane->type = PIPE_DRIVER_QUERY_TYPE_DBM;
1130 }
1131 else if (sscanf(name, "diskstat-rd-%s", arg_name) == 1) {
1132 hud_diskstat_graph_install(pane, arg_name, DISKSTAT_RD);
1133 pane->type = PIPE_DRIVER_QUERY_TYPE_BYTES;
1134 }
1135 else if (sscanf(name, "diskstat-wr-%s", arg_name) == 1) {
1136 hud_diskstat_graph_install(pane, arg_name, DISKSTAT_WR);
1137 pane->type = PIPE_DRIVER_QUERY_TYPE_BYTES;
1138 }
1139 else if (sscanf(name, "cpufreq-min-cpu%u", &i) == 1) {
1140 hud_cpufreq_graph_install(pane, i, CPUFREQ_MINIMUM);
1141 pane->type = PIPE_DRIVER_QUERY_TYPE_HZ;
1142 }
1143 else if (sscanf(name, "cpufreq-cur-cpu%u", &i) == 1) {
1144 hud_cpufreq_graph_install(pane, i, CPUFREQ_CURRENT);
1145 pane->type = PIPE_DRIVER_QUERY_TYPE_HZ;
1146 }
1147 else if (sscanf(name, "cpufreq-max-cpu%u", &i) == 1) {
1148 hud_cpufreq_graph_install(pane, i, CPUFREQ_MAXIMUM);
1149 pane->type = PIPE_DRIVER_QUERY_TYPE_HZ;
1150 }
1151 #endif
1152 #if HAVE_LIBSENSORS
1153 else if (sscanf(name, "sensors_temp_cu-%s", arg_name) == 1) {
1154 hud_sensors_temp_graph_install(pane, arg_name,
1155 SENSORS_TEMP_CURRENT);
1156 pane->type = PIPE_DRIVER_QUERY_TYPE_TEMPERATURE;
1157 }
1158 else if (sscanf(name, "sensors_temp_cr-%s", arg_name) == 1) {
1159 hud_sensors_temp_graph_install(pane, arg_name,
1160 SENSORS_TEMP_CRITICAL);
1161 pane->type = PIPE_DRIVER_QUERY_TYPE_TEMPERATURE;
1162 }
1163 else if (sscanf(name, "sensors_volt_cu-%s", arg_name) == 1) {
1164 hud_sensors_temp_graph_install(pane, arg_name,
1165 SENSORS_VOLTAGE_CURRENT);
1166 pane->type = PIPE_DRIVER_QUERY_TYPE_VOLTS;
1167 }
1168 else if (sscanf(name, "sensors_curr_cu-%s", arg_name) == 1) {
1169 hud_sensors_temp_graph_install(pane, arg_name,
1170 SENSORS_CURRENT_CURRENT);
1171 pane->type = PIPE_DRIVER_QUERY_TYPE_AMPS;
1172 }
1173 else if (sscanf(name, "sensors_pow_cu-%s", arg_name) == 1) {
1174 hud_sensors_temp_graph_install(pane, arg_name,
1175 SENSORS_POWER_CURRENT);
1176 pane->type = PIPE_DRIVER_QUERY_TYPE_WATTS;
1177 }
1178 #endif
1179 else if (strcmp(name, "samples-passed") == 0 &&
1180 has_occlusion_query(hud->pipe->screen)) {
1181 hud_pipe_query_install(&hud->batch_query, pane, hud->pipe,
1182 "samples-passed",
1183 PIPE_QUERY_OCCLUSION_COUNTER, 0, 0,
1184 PIPE_DRIVER_QUERY_TYPE_UINT64,
1185 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
1186 0);
1187 }
1188 else if (strcmp(name, "primitives-generated") == 0 &&
1189 has_streamout(hud->pipe->screen)) {
1190 hud_pipe_query_install(&hud->batch_query, pane, hud->pipe,
1191 "primitives-generated",
1192 PIPE_QUERY_PRIMITIVES_GENERATED, 0, 0,
1193 PIPE_DRIVER_QUERY_TYPE_UINT64,
1194 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
1195 0);
1196 }
1197 else {
1198 boolean processed = FALSE;
1199
1200 /* pipeline statistics queries */
1201 if (has_pipeline_stats_query(hud->pipe->screen)) {
1202 static const char *pipeline_statistics_names[] =
1203 {
1204 "ia-vertices",
1205 "ia-primitives",
1206 "vs-invocations",
1207 "gs-invocations",
1208 "gs-primitives",
1209 "clipper-invocations",
1210 "clipper-primitives-generated",
1211 "ps-invocations",
1212 "hs-invocations",
1213 "ds-invocations",
1214 "cs-invocations"
1215 };
1216 for (i = 0; i < ARRAY_SIZE(pipeline_statistics_names); ++i)
1217 if (strcmp(name, pipeline_statistics_names[i]) == 0)
1218 break;
1219 if (i < ARRAY_SIZE(pipeline_statistics_names)) {
1220 hud_pipe_query_install(&hud->batch_query, pane, hud->pipe, name,
1221 PIPE_QUERY_PIPELINE_STATISTICS, i,
1222 0, PIPE_DRIVER_QUERY_TYPE_UINT64,
1223 PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE,
1224 0);
1225 processed = TRUE;
1226 }
1227 }
1228
1229 /* driver queries */
1230 if (!processed) {
1231 if (!hud_driver_query_install(&hud->batch_query, pane, hud->pipe,
1232 name)) {
1233 fprintf(stderr, "gallium_hud: unknown driver query '%s'\n", name);
1234 fflush(stderr);
1235 }
1236 }
1237 }
1238
1239 if (*env == ':') {
1240 env++;
1241
1242 if (!pane) {
1243 fprintf(stderr, "gallium_hud: syntax error: unexpected ':', "
1244 "expected a name\n");
1245 fflush(stderr);
1246 break;
1247 }
1248
1249 num = parse_string(env, s);
1250 env += num;
1251
1252 if (num && sscanf(s, "%u", &i) == 1) {
1253 hud_pane_set_max_value(pane, i);
1254 pane->initial_max_value = i;
1255 }
1256 else {
1257 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c' (%i) "
1258 "after ':'\n", *env, *env);
1259 fflush(stderr);
1260 }
1261 }
1262
1263 if (*env == '=') {
1264 env++;
1265
1266 if (!pane) {
1267 fprintf(stderr, "gallium_hud: syntax error: unexpected '=', "
1268 "expected a name\n");
1269 fflush(stderr);
1270 break;
1271 }
1272
1273 num = parse_string(env, s);
1274 env += num;
1275
1276 strip_hyphens(s);
1277 if (!LIST_IS_EMPTY(&pane->graph_list)) {
1278 struct hud_graph *graph;
1279 graph = LIST_ENTRY(struct hud_graph, pane->graph_list.prev, head);
1280 strncpy(graph->name, s, sizeof(graph->name)-1);
1281 graph->name[sizeof(graph->name)-1] = 0;
1282 }
1283 }
1284
1285 if (*env == 0)
1286 break;
1287
1288 /* parse a separator */
1289 switch (*env) {
1290 case '+':
1291 env++;
1292 break;
1293
1294 case ',':
1295 env++;
1296 if (!pane)
1297 break;
1298
1299 y += height + hud->font.glyph_height * (pane->num_graphs + 2);
1300 height = 100;
1301
1302 if (pane && pane->num_graphs) {
1303 LIST_ADDTAIL(&pane->head, &hud->pane_list);
1304 pane = NULL;
1305 }
1306 break;
1307
1308 case ';':
1309 env++;
1310 y = 10;
1311 x += column_width + hud->font.glyph_width * 9;
1312 height = 100;
1313
1314 if (pane && pane->num_graphs) {
1315 LIST_ADDTAIL(&pane->head, &hud->pane_list);
1316 pane = NULL;
1317 }
1318
1319 /* Starting a new column; reset column width. */
1320 column_width = 251;
1321 break;
1322
1323 default:
1324 fprintf(stderr, "gallium_hud: syntax error: unexpected '%c'\n", *env);
1325 fflush(stderr);
1326 }
1327
1328 /* Reset to defaults for the next pane in case these were modified. */
1329 width = 251;
1330 ceiling = UINT64_MAX;
1331 dyn_ceiling = false;
1332 sort_items = false;
1333
1334 }
1335
1336 if (pane) {
1337 if (pane->num_graphs) {
1338 LIST_ADDTAIL(&pane->head, &hud->pane_list);
1339 }
1340 else {
1341 FREE(pane);
1342 }
1343 }
1344 }
1345
1346 static void
print_help(struct pipe_screen * screen)1347 print_help(struct pipe_screen *screen)
1348 {
1349 int i, num_queries, num_cpus = hud_get_num_cpus();
1350
1351 puts("Syntax: GALLIUM_HUD=name1[+name2][...][:value1][,nameI...][;nameJ...]");
1352 puts("");
1353 puts(" Names are identifiers of data sources which will be drawn as graphs");
1354 puts(" in panes. Multiple graphs can be drawn in the same pane.");
1355 puts(" There can be multiple panes placed in rows and columns.");
1356 puts("");
1357 puts(" '+' separates names which will share a pane.");
1358 puts(" ':[value]' specifies the initial maximum value of the Y axis");
1359 puts(" for the given pane.");
1360 puts(" ',' creates a new pane below the last one.");
1361 puts(" ';' creates a new pane at the top of the next column.");
1362 puts(" '=' followed by a string, changes the name of the last data source");
1363 puts(" to that string");
1364 puts("");
1365 puts(" Example: GALLIUM_HUD=\"cpu,fps;primitives-generated\"");
1366 puts("");
1367 puts(" Additionally, by prepending '.[identifier][value]' modifiers to");
1368 puts(" a name, it is possible to explicitly set the location and size");
1369 puts(" of a pane, along with limiting overall maximum value of the");
1370 puts(" Y axis and activating dynamic readjustment of the Y axis.");
1371 puts(" Several modifiers may be applied to the same pane simultaneously.");
1372 puts("");
1373 puts(" 'x[value]' sets the location of the pane on the x axis relative");
1374 puts(" to the upper-left corner of the viewport, in pixels.");
1375 puts(" 'y[value]' sets the location of the pane on the y axis relative");
1376 puts(" to the upper-left corner of the viewport, in pixels.");
1377 puts(" 'w[value]' sets width of the graph pixels.");
1378 puts(" 'h[value]' sets height of the graph in pixels.");
1379 puts(" 'c[value]' sets the ceiling of the value of the Y axis.");
1380 puts(" If the graph needs to draw values higher than");
1381 puts(" the ceiling allows, the value is clamped.");
1382 puts(" 'd' activates dynamic Y axis readjustment to set the value of");
1383 puts(" the Y axis to match the highest value still visible in the graph.");
1384 puts(" 'r' resets the color counter (the next color will be green)");
1385 puts(" 's' sort items below graphs in descending order");
1386 puts("");
1387 puts(" If 'c' and 'd' modifiers are used simultaneously, both are in effect:");
1388 puts(" the Y axis does not go above the restriction imposed by 'c' while");
1389 puts(" still adjusting the value of the Y axis down when appropriate.");
1390 puts("");
1391 puts(" Example: GALLIUM_HUD=\".w256.h64.x1600.y520.d.c1000fps+cpu,.datom-count\"");
1392 puts("");
1393 puts(" Available names:");
1394 puts(" fps");
1395 puts(" cpu");
1396
1397 for (i = 0; i < num_cpus; i++)
1398 printf(" cpu%i\n", i);
1399
1400 if (has_occlusion_query(screen))
1401 puts(" samples-passed");
1402 if (has_streamout(screen))
1403 puts(" primitives-generated");
1404
1405 if (has_pipeline_stats_query(screen)) {
1406 puts(" ia-vertices");
1407 puts(" ia-primitives");
1408 puts(" vs-invocations");
1409 puts(" gs-invocations");
1410 puts(" gs-primitives");
1411 puts(" clipper-invocations");
1412 puts(" clipper-primitives-generated");
1413 puts(" ps-invocations");
1414 puts(" hs-invocations");
1415 puts(" ds-invocations");
1416 puts(" cs-invocations");
1417 }
1418
1419 #if HAVE_GALLIUM_EXTRA_HUD
1420 hud_get_num_disks(1);
1421 hud_get_num_nics(1);
1422 hud_get_num_cpufreq(1);
1423 #endif
1424 #if HAVE_LIBSENSORS
1425 hud_get_num_sensors(1);
1426 #endif
1427
1428 if (screen->get_driver_query_info){
1429 boolean skipping = false;
1430 struct pipe_driver_query_info info;
1431 num_queries = screen->get_driver_query_info(screen, 0, NULL);
1432
1433 for (i = 0; i < num_queries; i++){
1434 screen->get_driver_query_info(screen, i, &info);
1435 if (info.flags & PIPE_DRIVER_QUERY_FLAG_DONT_LIST) {
1436 if (!skipping)
1437 puts(" ...");
1438 skipping = true;
1439 } else {
1440 printf(" %s\n", info.name);
1441 skipping = false;
1442 }
1443 }
1444 }
1445
1446 puts("");
1447 fflush(stdout);
1448 }
1449
1450 struct hud_context *
hud_create(struct pipe_context * pipe,struct cso_context * cso)1451 hud_create(struct pipe_context *pipe, struct cso_context *cso)
1452 {
1453 struct pipe_screen *screen = pipe->screen;
1454 struct hud_context *hud;
1455 struct pipe_sampler_view view_templ;
1456 unsigned i;
1457 const char *env = debug_get_option("GALLIUM_HUD", NULL);
1458 #ifdef PIPE_OS_UNIX
1459 unsigned signo = debug_get_num_option("GALLIUM_HUD_TOGGLE_SIGNAL", 0);
1460 static boolean sig_handled = FALSE;
1461 struct sigaction action = {};
1462 #endif
1463 huds_visible = debug_get_bool_option("GALLIUM_HUD_VISIBLE", TRUE);
1464
1465 if (!env || !*env)
1466 return NULL;
1467
1468 if (strcmp(env, "help") == 0) {
1469 print_help(pipe->screen);
1470 return NULL;
1471 }
1472
1473 hud = CALLOC_STRUCT(hud_context);
1474 if (!hud)
1475 return NULL;
1476
1477 hud->pipe = pipe;
1478 hud->cso = cso;
1479 hud->uploader = u_upload_create(pipe, 256 * 1024,
1480 PIPE_BIND_VERTEX_BUFFER, PIPE_USAGE_STREAM);
1481
1482 /* font */
1483 if (!util_font_create(pipe, UTIL_FONT_FIXED_8X13, &hud->font)) {
1484 u_upload_destroy(hud->uploader);
1485 FREE(hud);
1486 return NULL;
1487 }
1488
1489 hud->has_srgb = screen->is_format_supported(screen,
1490 PIPE_FORMAT_B8G8R8A8_SRGB,
1491 PIPE_TEXTURE_2D, 0,
1492 PIPE_BIND_RENDER_TARGET) != 0;
1493
1494 /* blend state */
1495 hud->no_blend.rt[0].colormask = PIPE_MASK_RGBA;
1496
1497 hud->alpha_blend.rt[0].colormask = PIPE_MASK_RGBA;
1498 hud->alpha_blend.rt[0].blend_enable = 1;
1499 hud->alpha_blend.rt[0].rgb_func = PIPE_BLEND_ADD;
1500 hud->alpha_blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_SRC_ALPHA;
1501 hud->alpha_blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_INV_SRC_ALPHA;
1502 hud->alpha_blend.rt[0].alpha_func = PIPE_BLEND_ADD;
1503 hud->alpha_blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ZERO;
1504 hud->alpha_blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
1505
1506 /* fragment shader */
1507 hud->fs_color =
1508 util_make_fragment_passthrough_shader(pipe,
1509 TGSI_SEMANTIC_COLOR,
1510 TGSI_INTERPOLATE_CONSTANT,
1511 TRUE);
1512
1513 {
1514 /* Read a texture and do .xxxx swizzling. */
1515 static const char *fragment_shader_text = {
1516 "FRAG\n"
1517 "DCL IN[0], GENERIC[0], LINEAR\n"
1518 "DCL SAMP[0]\n"
1519 "DCL SVIEW[0], RECT, FLOAT\n"
1520 "DCL OUT[0], COLOR[0]\n"
1521 "DCL TEMP[0]\n"
1522
1523 "TEX TEMP[0], IN[0], SAMP[0], RECT\n"
1524 "MOV OUT[0], TEMP[0].xxxx\n"
1525 "END\n"
1526 };
1527
1528 struct tgsi_token tokens[1000];
1529 struct pipe_shader_state state;
1530
1531 if (!tgsi_text_translate(fragment_shader_text, tokens, ARRAY_SIZE(tokens))) {
1532 assert(0);
1533 pipe_resource_reference(&hud->font.texture, NULL);
1534 u_upload_destroy(hud->uploader);
1535 FREE(hud);
1536 return NULL;
1537 }
1538 pipe_shader_state_from_tgsi(&state, tokens);
1539 hud->fs_text = pipe->create_fs_state(pipe, &state);
1540 }
1541
1542 /* rasterizer */
1543 hud->rasterizer.half_pixel_center = 1;
1544 hud->rasterizer.bottom_edge_rule = 1;
1545 hud->rasterizer.depth_clip = 1;
1546 hud->rasterizer.line_width = 1;
1547 hud->rasterizer.line_last_pixel = 1;
1548
1549 hud->rasterizer_aa_lines = hud->rasterizer;
1550 hud->rasterizer_aa_lines.line_smooth = 1;
1551
1552 /* vertex shader */
1553 {
1554 static const char *vertex_shader_text = {
1555 "VERT\n"
1556 "DCL IN[0..1]\n"
1557 "DCL OUT[0], POSITION\n"
1558 "DCL OUT[1], COLOR[0]\n" /* color */
1559 "DCL OUT[2], GENERIC[0]\n" /* texcoord */
1560 /* [0] = color,
1561 * [1] = (2/fb_width, 2/fb_height, xoffset, yoffset)
1562 * [2] = (xscale, yscale, 0, 0) */
1563 "DCL CONST[0..2]\n"
1564 "DCL TEMP[0]\n"
1565 "IMM[0] FLT32 { -1, 0, 0, 1 }\n"
1566
1567 /* v = in * (xscale, yscale) + (xoffset, yoffset) */
1568 "MAD TEMP[0].xy, IN[0], CONST[2].xyyy, CONST[1].zwww\n"
1569 /* pos = v * (2 / fb_width, 2 / fb_height) - (1, 1) */
1570 "MAD OUT[0].xy, TEMP[0], CONST[1].xyyy, IMM[0].xxxx\n"
1571 "MOV OUT[0].zw, IMM[0]\n"
1572
1573 "MOV OUT[1], CONST[0]\n"
1574 "MOV OUT[2], IN[1]\n"
1575 "END\n"
1576 };
1577
1578 struct tgsi_token tokens[1000];
1579 struct pipe_shader_state state;
1580 if (!tgsi_text_translate(vertex_shader_text, tokens, ARRAY_SIZE(tokens))) {
1581 assert(0);
1582 pipe_resource_reference(&hud->font.texture, NULL);
1583 u_upload_destroy(hud->uploader);
1584 FREE(hud);
1585 return NULL;
1586 }
1587 pipe_shader_state_from_tgsi(&state, tokens);
1588 hud->vs = pipe->create_vs_state(pipe, &state);
1589 }
1590
1591 /* vertex elements */
1592 for (i = 0; i < 2; i++) {
1593 hud->velems[i].src_offset = i * 2 * sizeof(float);
1594 hud->velems[i].src_format = PIPE_FORMAT_R32G32_FLOAT;
1595 hud->velems[i].vertex_buffer_index = cso_get_aux_vertex_buffer_slot(cso);
1596 }
1597
1598 /* sampler view */
1599 u_sampler_view_default_template(
1600 &view_templ, hud->font.texture, hud->font.texture->format);
1601 hud->font_sampler_view = pipe->create_sampler_view(pipe, hud->font.texture,
1602 &view_templ);
1603
1604 /* sampler state (for font drawing) */
1605 hud->font_sampler_state.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
1606 hud->font_sampler_state.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
1607 hud->font_sampler_state.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
1608 hud->font_sampler_state.normalized_coords = 0;
1609
1610 /* constants */
1611 hud->constbuf.buffer_size = sizeof(hud->constants);
1612 hud->constbuf.user_buffer = &hud->constants;
1613
1614 LIST_INITHEAD(&hud->pane_list);
1615
1616 /* setup sig handler once for all hud contexts */
1617 #ifdef PIPE_OS_UNIX
1618 if (!sig_handled && signo != 0) {
1619 action.sa_sigaction = &signal_visible_handler;
1620 action.sa_flags = SA_SIGINFO;
1621
1622 if (signo >= NSIG)
1623 fprintf(stderr, "gallium_hud: invalid signal %u\n", signo);
1624 else if (sigaction(signo, &action, NULL) < 0)
1625 fprintf(stderr, "gallium_hud: unable to set handler for signal %u\n", signo);
1626 fflush(stderr);
1627
1628 sig_handled = TRUE;
1629 }
1630 #endif
1631
1632 hud_parse_env_var(hud, env);
1633 return hud;
1634 }
1635
1636 void
hud_destroy(struct hud_context * hud)1637 hud_destroy(struct hud_context *hud)
1638 {
1639 struct pipe_context *pipe = hud->pipe;
1640 struct hud_pane *pane, *pane_tmp;
1641 struct hud_graph *graph, *graph_tmp;
1642
1643 LIST_FOR_EACH_ENTRY_SAFE(pane, pane_tmp, &hud->pane_list, head) {
1644 LIST_FOR_EACH_ENTRY_SAFE(graph, graph_tmp, &pane->graph_list, head) {
1645 LIST_DEL(&graph->head);
1646 hud_graph_destroy(graph);
1647 }
1648 LIST_DEL(&pane->head);
1649 FREE(pane);
1650 }
1651
1652 hud_batch_query_cleanup(&hud->batch_query);
1653 pipe->delete_fs_state(pipe, hud->fs_color);
1654 pipe->delete_fs_state(pipe, hud->fs_text);
1655 pipe->delete_vs_state(pipe, hud->vs);
1656 pipe_sampler_view_reference(&hud->font_sampler_view, NULL);
1657 pipe_resource_reference(&hud->font.texture, NULL);
1658 u_upload_destroy(hud->uploader);
1659 FREE(hud);
1660 }
1661