"Fossies" - the Fresh Open Source Software Archive

Member "mesa-20.1.8/src/gallium/drivers/llvmpipe/lp_rast_debug.c" (16 Sep 2020, 10666 Bytes) of package /linux/misc/mesa-20.1.8.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "lp_rast_debug.c" see the Fossies "Dox" file reference documentation.

    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 }