1 #include "util/u_math.h" 2 #include "lp_rast_priv.h" 3 #include "lp_state_fs.h" 4 5 struct tile { 6 int coverage; 7 int overdraw; 8 const struct lp_rast_state *state; 9 char data[TILE_SIZE][TILE_SIZE]; 10 }; 11 12 static char get_label( int i ) 13 { 14 static const char *cmd_labels = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; 15 unsigned max_label = (2*26+10); 16 17 if (i < max_label) 18 return cmd_labels[i]; 19 else 20 return '?'; 21 } 22 23 24 25 static const char *cmd_names[LP_RAST_OP_MAX] = 26 { 27 "clear_color", 28 "clear_zstencil", 29 "triangle_1", 30 "triangle_2", 31 "triangle_3", 32 "triangle_4", 33 "triangle_5", 34 "triangle_6", 35 "triangle_7", 36 "triangle_8", 37 "triangle_3_4", 38 "triangle_3_16", 39 "triangle_4_16", 40 "shade_tile", 41 "shade_tile_opaque", 42 "begin_query", 43 "end_query", 44 "set_state", 45 }; 46 47 static const char *cmd_name(unsigned cmd) 48 { 49 assert(Elements(cmd_names) > cmd); 50 return cmd_names[cmd]; 51 } 52 53 static const struct lp_fragment_shader_variant * 54 get_variant( const struct lp_rast_state *state, 55 const struct cmd_block *block, 56 int k ) 57 { 58 if (!state) 59 return NULL; 60 61 if (block->cmd[k] == LP_RAST_OP_SHADE_TILE || 62 block->cmd[k] == LP_RAST_OP_SHADE_TILE_OPAQUE || 63 block->cmd[k] == LP_RAST_OP_TRIANGLE_1 || 64 block->cmd[k] == LP_RAST_OP_TRIANGLE_2 || 65 block->cmd[k] == LP_RAST_OP_TRIANGLE_3 || 66 block->cmd[k] == LP_RAST_OP_TRIANGLE_4 || 67 block->cmd[k] == LP_RAST_OP_TRIANGLE_5 || 68 block->cmd[k] == LP_RAST_OP_TRIANGLE_6 || 69 block->cmd[k] == LP_RAST_OP_TRIANGLE_7) 70 return state->variant; 71 72 return NULL; 73 } 74 75 76 static boolean 77 is_blend( const struct lp_rast_state *state, 78 const struct cmd_block *block, 79 int k ) 80 { 81 const struct lp_fragment_shader_variant *variant = get_variant(state, block, k); 82 83 if (variant) 84 return variant->key.blend.rt[0].blend_enable; 85 86 return FALSE; 87 } 88 89 90 91 static void 92 debug_bin( const struct cmd_bin *bin ) 93 { 94 const struct lp_rast_state *state = NULL; 95 const struct cmd_block *head = bin->head; 96 int i, j = 0; 97 98 debug_printf("bin %d,%d:\n", bin->x, bin->y); 99 100 while (head) { 101 for (i = 0; i < head->count; i++, j++) { 102 if (head->cmd[i] == LP_RAST_OP_SET_STATE) 103 state = head->arg[i].state; 104 105 debug_printf("%d: %s %s\n", j, 106 cmd_name(head->cmd[i]), 107 is_blend(state, head, i) ? "blended" : ""); 108 } 109 head = head->next; 110 } 111 } 112 113 114 static void plot(struct tile *tile, 115 int x, int y, 116 char val, 117 boolean blend) 118 { 119 if (tile->data[x][y] == ' ') 120 tile->coverage++; 121 else 122 tile->overdraw++; 123 124 tile->data[x][y] = val; 125 } 126 127 128 129 130 131 132 static int 133 debug_shade_tile(int x, int y, 134 const union lp_rast_cmd_arg arg, 135 struct tile *tile, 136 char val) 137 { 138 const struct lp_rast_shader_inputs *inputs = arg.shade_tile; 139 boolean blend; 140 unsigned i,j; 141 142 if (!tile->state) 143 return 0; 144 145 blend = tile->state->variant->key.blend.rt[0].blend_enable; 146 147 if (inputs->disable) 148 return 0; 149 150 for (i = 0; i < TILE_SIZE; i++) 151 for (j = 0; j < TILE_SIZE; j++) 152 plot(tile, i, j, val, blend); 153 154 return TILE_SIZE * TILE_SIZE; 155 } 156 157 static int 158 debug_clear_tile(int x, int y, 159 const union lp_rast_cmd_arg arg, 160 struct tile *tile, 161 char val) 162 { 163 unsigned i,j; 164 165 for (i = 0; i < TILE_SIZE; i++) 166 for (j = 0; j < TILE_SIZE; j++) 167 plot(tile, i, j, val, FALSE); 168 169 return TILE_SIZE * TILE_SIZE; 170 171 } 172 173 174 static int 175 debug_triangle(int tilex, int tiley, 176 const union lp_rast_cmd_arg arg, 177 struct tile *tile, 178 char val) 179 { 180 const struct lp_rast_triangle *tri = arg.triangle.tri; 181 unsigned plane_mask = arg.triangle.plane_mask; 182 const struct lp_rast_plane *tri_plane = GET_PLANES(tri); 183 struct lp_rast_plane plane[8]; 184 int x, y; 185 int count = 0; 186 unsigned i, nr_planes = 0; 187 boolean blend = tile->state->variant->key.blend.rt[0].blend_enable; 188 189 if (tri->inputs.disable) { 190 /* This triangle was partially binned and has been disabled */ 191 return 0; 192 } 193 194 while (plane_mask) { 195 plane[nr_planes] = tri_plane[u_bit_scan(&plane_mask)]; 196 plane[nr_planes].c = (plane[nr_planes].c + 197 plane[nr_planes].dcdy * tiley - 198 plane[nr_planes].dcdx * tilex); 199 nr_planes++; 200 } 201 202 for(y = 0; y < TILE_SIZE; y++) 203 { 204 for(x = 0; x < TILE_SIZE; x++) 205 { 206 for (i = 0; i < nr_planes; i++) 207 if (plane[i].c <= 0) 208 goto out; 209 210 plot(tile, x, y, val, blend); 211 count++; 212 213 out: 214 for (i = 0; i < nr_planes; i++) 215 plane[i].c -= plane[i].dcdx; 216 } 217 218 for (i = 0; i < nr_planes; i++) { 219 plane[i].c += plane[i].dcdx * TILE_SIZE; 220 plane[i].c += plane[i].dcdy; 221 } 222 } 223 return count; 224 } 225 226 227 228 229 230 static void 231 do_debug_bin( struct tile *tile, 232 const struct cmd_bin *bin, 233 boolean print_cmds) 234 { 235 unsigned k, j = 0; 236 const struct cmd_block *block; 237 238 int tx = bin->x * TILE_SIZE; 239 int ty = bin->y * TILE_SIZE; 240 241 memset(tile->data, ' ', sizeof tile->data); 242 tile->coverage = 0; 243 tile->overdraw = 0; 244 tile->state = NULL; 245 246 for (block = bin->head; block; block = block->next) { 247 for (k = 0; k < block->count; k++, j++) { 248 boolean blend = is_blend(tile->state, block, k); 249 char val = get_label(j); 250 int count = 0; 251 252 if (print_cmds) 253 debug_printf("%c: %15s", val, cmd_name(block->cmd[k])); 254 255 if (block->cmd[k] == LP_RAST_OP_SET_STATE) 256 tile->state = block->arg[k].state; 257 258 if (block->cmd[k] == LP_RAST_OP_CLEAR_COLOR || 259 block->cmd[k] == LP_RAST_OP_CLEAR_ZSTENCIL) 260 count = debug_clear_tile(tx, ty, block->arg[k], tile, val); 261 262 if (block->cmd[k] == LP_RAST_OP_SHADE_TILE || 263 block->cmd[k] == LP_RAST_OP_SHADE_TILE_OPAQUE) 264 count = debug_shade_tile(tx, ty, block->arg[k], tile, val); 265 266 if (block->cmd[k] == LP_RAST_OP_TRIANGLE_1 || 267 block->cmd[k] == LP_RAST_OP_TRIANGLE_2 || 268 block->cmd[k] == LP_RAST_OP_TRIANGLE_3 || 269 block->cmd[k] == LP_RAST_OP_TRIANGLE_4 || 270 block->cmd[k] == LP_RAST_OP_TRIANGLE_5 || 271 block->cmd[k] == LP_RAST_OP_TRIANGLE_6 || 272 block->cmd[k] == LP_RAST_OP_TRIANGLE_7) 273 count = debug_triangle(tx, ty, block->arg[k], tile, val); 274 275 if (print_cmds) { 276 debug_printf(" % 5d", count); 277 278 if (blend) 279 debug_printf(" blended"); 280 281 debug_printf("\n"); 282 } 283 } 284 } 285 } 286 287 void 288 lp_debug_bin( const struct cmd_bin *bin) 289 { 290 struct tile tile; 291 int x,y; 292 293 if (bin->head) { 294 do_debug_bin(&tile, bin, TRUE); 295 296 debug_printf("------------------------------------------------------------------\n"); 297 for (y = 0; y < TILE_SIZE; y++) { 298 for (x = 0; x < TILE_SIZE; x++) { 299 debug_printf("%c", tile.data[y][x]); 300 } 301 debug_printf("|\n"); 302 } 303 debug_printf("------------------------------------------------------------------\n"); 304 305 debug_printf("each pixel drawn avg %f times\n", 306 ((float)tile.overdraw + tile.coverage)/(float)tile.coverage); 307 } 308 } 309 310 311 312 313 314 315 /** Return number of bytes used for a single bin */ 316 static unsigned 317 lp_scene_bin_size( const struct lp_scene *scene, unsigned x, unsigned y ) 318 { 319 struct cmd_bin *bin = lp_scene_get_bin((struct lp_scene *) scene, x, y); 320 const struct cmd_block *cmd; 321 unsigned size = 0; 322 for (cmd = bin->head; cmd; cmd = cmd->next) { 323 size += (cmd->count * 324 (sizeof(uint8_t) + sizeof(union lp_rast_cmd_arg))); 325 } 326 return size; 327 } 328 329 330 331 void 332 lp_debug_draw_bins_by_coverage( struct lp_scene *scene ) 333 { 334 unsigned x, y; 335 unsigned total = 0; 336 unsigned possible = 0; 337 static unsigned long long _total; 338 static unsigned long long _possible; 339 340 for (x = 0; x < scene->tiles_x; x++) 341 debug_printf("-"); 342 debug_printf("\n"); 343 344 for (y = 0; y < scene->tiles_y; y++) { 345 for (x = 0; x < scene->tiles_x; x++) { 346 struct cmd_bin *bin = lp_scene_get_bin(scene, x, y); 347 const char *bits = "0123456789"; 348 struct tile tile; 349 350 if (bin->head) { 351 //lp_debug_bin(bin); 352 353 do_debug_bin(&tile, bin, FALSE); 354 355 total += tile.coverage; 356 possible += 64*64; 357 358 if (tile.coverage == 64*64) 359 debug_printf("*"); 360 else if (tile.coverage) { 361 int bit = tile.coverage/(64.0*64.0)*10; 362 debug_printf("%c", bits[MIN2(bit,10)]); 363 } 364 else 365 debug_printf("?"); 366 } 367 else { 368 debug_printf(" "); 369 } 370 } 371 debug_printf("|\n"); 372 } 373 374 for (x = 0; x < scene->tiles_x; x++) 375 debug_printf("-"); 376 debug_printf("\n"); 377 378 debug_printf("this tile total: %u possible %u: percentage: %f\n", 379 total, 380 possible, 381 total * 100.0 / (float)possible); 382 383 _total += total; 384 _possible += possible; 385 386 debug_printf("overall total: %llu possible %llu: percentage: %f\n", 387 _total, 388 _possible, 389 _total * 100.0 / (double)_possible); 390 } 391 392 393 void 394 lp_debug_draw_bins_by_cmd_length( struct lp_scene *scene ) 395 { 396 unsigned x, y; 397 398 for (y = 0; y < scene->tiles_y; y++) { 399 for (x = 0; x < scene->tiles_x; x++) { 400 const char *bits = " ...,-~:;=o+xaw*#XAWWWWWWWWWWWWWWWW"; 401 unsigned sz = lp_scene_bin_size(scene, x, y); 402 unsigned sz2 = util_logbase2(sz); 403 debug_printf("%c", bits[MIN2(sz2,32)]); 404 } 405 debug_printf("\n"); 406 } 407 } 408 409 410 void 411 lp_debug_bins( struct lp_scene *scene ) 412 { 413 unsigned x, y; 414 415 for (y = 0; y < scene->tiles_y; y++) { 416 for (x = 0; x < scene->tiles_x; x++) { 417 struct cmd_bin *bin = lp_scene_get_bin(scene, x, y); 418 if (bin->head) { 419 debug_bin(bin); 420 } 421 } 422 } 423 } 424
