src/gallium/drivers/llvmpipe/lp_rast_debug.c

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