src/gallium/drivers/ilo/ilo_render_dynamic.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 2012-2014 LunarG, Inc.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Chia-I Wu <olv@lunarg.com>
  26  */
  27
  28 #include "core/ilo_builder_3d.h"
  29 #include "core/ilo_builder_media.h"
  30
  31 #include "ilo_common.h"
  32 #include "ilo_blitter.h"
  33 #include "ilo_shader.h"
  34 #include "ilo_state.h"
  35 #include "ilo_render_gen.h"
  36
  37 #define DIRTY(state) (session->pipe_dirty & ILO_DIRTY_ ## state)
  38
  39 static void
  40 gen6_emit_draw_dynamic_viewports(struct ilo_render *r,
  41                                  const struct ilo_state_vector *vec,
  42                                  struct ilo_render_draw_session *session)
  43 {
  44    ILO_DEV_ASSERT(r->dev, 6, 6);
  45
  46    /* CLIP_VIEWPORT, SF_VIEWPORT, and CC_VIEWPORT */
  47    if ((session->vp_delta.dirty & (ILO_STATE_VIEWPORT_SF_CLIP_VIEWPORT |
  48                                    ILO_STATE_VIEWPORT_CC_VIEWPORT)) ||
  49        r->state_bo_changed) {
  50       r->state.CLIP_VIEWPORT = gen6_CLIP_VIEWPORT(r->builder,
  51             &vec->viewport.vp);
  52       r->state.SF_VIEWPORT = gen6_SF_VIEWPORT(r->builder, &vec->viewport.vp);
  53       r->state.CC_VIEWPORT = gen6_CC_VIEWPORT(r->builder, &vec->viewport.vp);
  54
  55       session->viewport_changed = true;
  56    }
  57 }
  58
  59 static void
  60 gen7_emit_draw_dynamic_viewports(struct ilo_render *r,
  61                                  const struct ilo_state_vector *vec,
  62                                  struct ilo_render_draw_session *session)
  63 {
  64    ILO_DEV_ASSERT(r->dev, 7, 8);
  65
  66    /* SF_CLIP_VIEWPORT and CC_VIEWPORT */
  67    if ((session->vp_delta.dirty & (ILO_STATE_VIEWPORT_SF_CLIP_VIEWPORT |
  68                                    ILO_STATE_VIEWPORT_CC_VIEWPORT)) ||
  69        r->state_bo_changed) {
  70       r->state.SF_CLIP_VIEWPORT = gen7_SF_CLIP_VIEWPORT(r->builder,
  71             &vec->viewport.vp);
  72       r->state.CC_VIEWPORT = gen6_CC_VIEWPORT(r->builder, &vec->viewport.vp);
  73
  74       session->viewport_changed = true;
  75    }
  76 }
  77
  78 static void
  79 gen6_emit_draw_dynamic_scissors(struct ilo_render *r,
  80                                 const struct ilo_state_vector *vec,
  81                                 struct ilo_render_draw_session *session)
  82 {
  83    ILO_DEV_ASSERT(r->dev, 6, 8);
  84
  85    /* SCISSOR_RECT */
  86    if ((session->vp_delta.dirty & ILO_STATE_VIEWPORT_SCISSOR_RECT) ||
  87        r->state_bo_changed) {
  88       r->state.SCISSOR_RECT = gen6_SCISSOR_RECT(r->builder,
  89             &vec->viewport.vp);
  90
  91       session->scissor_changed = true;
  92    }
  93 }
  94
  95 static void
  96 gen6_emit_draw_dynamic_cc(struct ilo_render *r,
  97                           const struct ilo_state_vector *vec,
  98                           struct ilo_render_draw_session *session)
  99 {
 100    ILO_DEV_ASSERT(r->dev, 6, 8);
 101
 102    /* BLEND_STATE */
 103    if ((session->cc_delta.dirty & ILO_STATE_CC_BLEND_STATE) ||
 104         r->state_bo_changed) {
 105       if (ilo_dev_gen(r->dev) >= ILO_GEN(8))
 106          r->state.BLEND_STATE = gen8_BLEND_STATE(r->builder, &vec->blend->cc);
 107       else
 108          r->state.BLEND_STATE = gen6_BLEND_STATE(r->builder, &vec->blend->cc);
 109
 110       session->blend_changed = true;
 111    }
 112
 113    /* COLOR_CALC_STATE */
 114    if ((session->cc_delta.dirty & ILO_STATE_CC_COLOR_CALC_STATE) ||
 115        r->state_bo_changed) {
 116       r->state.COLOR_CALC_STATE =
 117          gen6_COLOR_CALC_STATE(r->builder, &vec->blend->cc);
 118       session->cc_changed = true;
 119    }
 120
 121    /* DEPTH_STENCIL_STATE */
 122    if (ilo_dev_gen(r->dev) < ILO_GEN(8) &&
 123        ((session->cc_delta.dirty & ILO_STATE_CC_DEPTH_STENCIL_STATE) ||
 124         r->state_bo_changed)) {
 125       r->state.DEPTH_STENCIL_STATE =
 126          gen6_DEPTH_STENCIL_STATE(r->builder, &vec->blend->cc);
 127       session->dsa_changed = true;
 128    }
 129 }
 130
 131 static void
 132 gen6_emit_draw_dynamic_samplers(struct ilo_render *r,
 133                                 const struct ilo_state_vector *vec,
 134                                 int shader_type,
 135                                 struct ilo_render_draw_session *session)
 136 {
 137    const struct ilo_view_cso * const *views =
 138       (const struct ilo_view_cso **) vec->view[shader_type].states;
 139    struct ilo_state_sampler samplers[ILO_MAX_SAMPLERS];
 140    uint32_t *sampler_state, *border_color_state;
 141    int sampler_count, i;
 142    bool emit_border_color = false;
 143    bool skip = false;
 144
 145    ILO_DEV_ASSERT(r->dev, 6, 8);
 146
 147    /* SAMPLER_BORDER_COLOR_STATE and SAMPLER_STATE */
 148    switch (shader_type) {
 149    case PIPE_SHADER_VERTEX:
 150       if (DIRTY(VS) || DIRTY(SAMPLER_VS) || DIRTY(VIEW_VS)) {
 151          sampler_state = &r->state.vs.SAMPLER_STATE;
 152          border_color_state = r->state.vs.SAMPLER_BORDER_COLOR_STATE;
 153
 154          if (DIRTY(VS) || DIRTY(SAMPLER_VS))
 155             emit_border_color = true;
 156
 157          sampler_count = (vec->vs) ? ilo_shader_get_kernel_param(vec->vs,
 158                ILO_KERNEL_SAMPLER_COUNT) : 0;
 159
 160          session->sampler_vs_changed = true;
 161       } else {
 162          skip = true;
 163       }
 164       break;
 165    case PIPE_SHADER_FRAGMENT:
 166       if (DIRTY(FS) || DIRTY(SAMPLER_FS) || DIRTY(VIEW_FS)) {
 167          sampler_state = &r->state.wm.SAMPLER_STATE;
 168          border_color_state = r->state.wm.SAMPLER_BORDER_COLOR_STATE;
 169
 170          if (DIRTY(VS) || DIRTY(SAMPLER_FS))
 171             emit_border_color = true;
 172
 173          sampler_count = (vec->fs) ? ilo_shader_get_kernel_param(vec->fs,
 174                ILO_KERNEL_SAMPLER_COUNT) : 0;
 175
 176          session->sampler_fs_changed = true;
 177       } else {
 178          skip = true;
 179       }
 180       break;
 181    default:
 182       skip = true;
 183       break;
 184    }
 185
 186    if (skip)
 187       return;
 188
 189    assert(sampler_count <= Elements(vec->view[shader_type].states) &&
 190           sampler_count <= Elements(vec->sampler[shader_type].cso));
 191
 192    if (emit_border_color) {
 193       for (i = 0; i < sampler_count; i++) {
 194          const struct ilo_sampler_cso *cso = vec->sampler[shader_type].cso[i];
 195
 196          border_color_state[i] = (cso) ?
 197             gen6_SAMPLER_BORDER_COLOR_STATE(r->builder, &cso->border) : 0;
 198       }
 199    }
 200
 201    for (i = 0; i < sampler_count; i++) {
 202       const struct ilo_sampler_cso *cso = vec->sampler[shader_type].cso[i];
 203
 204       if (cso && views[i]) {
 205          samplers[i] = cso->sampler;
 206          ilo_state_sampler_set_surface(&samplers[i],
 207                r->dev, &views[i]->surface);
 208       } else {
 209          samplers[i] = vec->disabled_sampler;
 210       }
 211    }
 212
 213    *sampler_state = gen6_SAMPLER_STATE(r->builder, samplers,
 214          border_color_state, sampler_count);
 215 }
 216
 217 static void
 218 gen6_emit_draw_dynamic_pcb(struct ilo_render *r,
 219                            const struct ilo_state_vector *vec,
 220                            struct ilo_render_draw_session *session)
 221 {
 222    ILO_DEV_ASSERT(r->dev, 6, 8);
 223
 224    /* push constant buffer for VS */
 225    if (DIRTY(VS) || DIRTY(CBUF) || DIRTY(CLIP)) {
 226       const int cbuf0_size = (vec->vs) ?
 227             ilo_shader_get_kernel_param(vec->vs,
 228                   ILO_KERNEL_PCB_CBUF0_SIZE) : 0;
 229       const int clip_state_size = (vec->vs) ?
 230             ilo_shader_get_kernel_param(vec->vs,
 231                   ILO_KERNEL_VS_PCB_UCP_SIZE) : 0;
 232       const int total_size = cbuf0_size + clip_state_size;
 233
 234       if (total_size) {
 235          void *pcb;
 236
 237          r->state.vs.PUSH_CONSTANT_BUFFER =
 238             gen6_push_constant_buffer(r->builder, total_size, &pcb);
 239          r->state.vs.PUSH_CONSTANT_BUFFER_size = total_size;
 240
 241          if (cbuf0_size) {
 242             const struct ilo_cbuf_state *cbuf =
 243                &vec->cbuf[PIPE_SHADER_VERTEX];
 244
 245             if (cbuf0_size <= cbuf->cso[0].info.size) {
 246                memcpy(pcb, cbuf->cso[0].user_buffer, cbuf0_size);
 247             } else {
 248                memcpy(pcb, cbuf->cso[0].user_buffer,
 249                      cbuf->cso[0].info.size);
 250                memset(pcb + cbuf->cso[0].info.size, 0,
 251                      cbuf0_size - cbuf->cso[0].info.size);
 252             }
 253
 254             pcb += cbuf0_size;
 255          }
 256
 257          if (clip_state_size)
 258             memcpy(pcb, &vec->clip, clip_state_size);
 259
 260          session->pcb_vs_changed = true;
 261       } else if (r->state.vs.PUSH_CONSTANT_BUFFER_size) {
 262          r->state.vs.PUSH_CONSTANT_BUFFER = 0;
 263          r->state.vs.PUSH_CONSTANT_BUFFER_size = 0;
 264
 265          session->pcb_vs_changed = true;
 266       }
 267    }
 268
 269    /* push constant buffer for FS */
 270    if (DIRTY(FS) || DIRTY(CBUF)) {
 271       const int cbuf0_size = (vec->fs) ?
 272          ilo_shader_get_kernel_param(vec->fs, ILO_KERNEL_PCB_CBUF0_SIZE) : 0;
 273
 274       if (cbuf0_size) {
 275          const struct ilo_cbuf_state *cbuf = &vec->cbuf[PIPE_SHADER_FRAGMENT];
 276          void *pcb;
 277
 278          r->state.wm.PUSH_CONSTANT_BUFFER =
 279             gen6_push_constant_buffer(r->builder, cbuf0_size, &pcb);
 280          r->state.wm.PUSH_CONSTANT_BUFFER_size = cbuf0_size;
 281
 282          if (cbuf0_size <= cbuf->cso[0].info.size) {
 283             memcpy(pcb, cbuf->cso[0].user_buffer, cbuf0_size);
 284          } else {
 285             memcpy(pcb, cbuf->cso[0].user_buffer,
 286                   cbuf->cso[0].info.size);
 287             memset(pcb + cbuf->cso[0].info.size, 0,
 288                   cbuf0_size - cbuf->cso[0].info.size);
 289          }
 290
 291          session->pcb_fs_changed = true;
 292       } else if (r->state.wm.PUSH_CONSTANT_BUFFER_size) {
 293          r->state.wm.PUSH_CONSTANT_BUFFER = 0;
 294          r->state.wm.PUSH_CONSTANT_BUFFER_size = 0;
 295
 296          session->pcb_fs_changed = true;
 297       }
 298    }
 299 }
 300
 301 #undef DIRTY
 302
 303 int
 304 ilo_render_get_draw_dynamic_states_len(const struct ilo_render *render,
 305                                        const struct ilo_state_vector *vec)
 306 {
 307    static int static_len;
 308    int sh_type, len;
 309
 310    ILO_DEV_ASSERT(render->dev, 6, 8);
 311
 312    if (!static_len) {
 313       /* 64 bytes, or 16 dwords */
 314       const int alignment = 64 / 4;
 315
 316       /* pad first */
 317       len = alignment - 1;
 318
 319       /* CC states */
 320       len += align(GEN6_BLEND_STATE__SIZE, alignment);
 321       len += align(GEN6_COLOR_CALC_STATE__SIZE, alignment);
 322       if (ilo_dev_gen(render->dev) < ILO_GEN(8))
 323          len += align(GEN6_DEPTH_STENCIL_STATE__SIZE, alignment);
 324
 325       /* viewport arrays */
 326       if (ilo_dev_gen(render->dev) >= ILO_GEN(7)) {
 327          len += 15 + /* pad first */
 328             align(GEN7_SF_CLIP_VIEWPORT__SIZE, 16) +
 329             align(GEN6_CC_VIEWPORT__SIZE, 8) +
 330             align(GEN6_SCISSOR_RECT__SIZE, 8);
 331       } else {
 332          len += 7 + /* pad first */
 333             align(GEN6_SF_VIEWPORT__SIZE, 8) +
 334             align(GEN6_CLIP_VIEWPORT__SIZE, 8) +
 335             align(GEN6_CC_VIEWPORT__SIZE, 8) +
 336             align(GEN6_SCISSOR_RECT__SIZE, 8);
 337       }
 338
 339       static_len = len;
 340    }
 341
 342    len = static_len;
 343
 344    for (sh_type = 0; sh_type < PIPE_SHADER_TYPES; sh_type++) {
 345       const int alignment = 32 / 4;
 346       int num_samplers = 0, pcb_len = 0;
 347
 348       switch (sh_type) {
 349       case PIPE_SHADER_VERTEX:
 350          if (vec->vs) {
 351             num_samplers = ilo_shader_get_kernel_param(vec->vs,
 352                   ILO_KERNEL_SAMPLER_COUNT);
 353             pcb_len = ilo_shader_get_kernel_param(vec->vs,
 354                   ILO_KERNEL_PCB_CBUF0_SIZE);
 355             pcb_len += ilo_shader_get_kernel_param(vec->vs,
 356                   ILO_KERNEL_VS_PCB_UCP_SIZE);
 357          }
 358          break;
 359       case PIPE_SHADER_GEOMETRY:
 360          break;
 361       case PIPE_SHADER_FRAGMENT:
 362          if (vec->fs) {
 363             num_samplers = ilo_shader_get_kernel_param(vec->fs,
 364                   ILO_KERNEL_SAMPLER_COUNT);
 365             pcb_len = ilo_shader_get_kernel_param(vec->fs,
 366                   ILO_KERNEL_PCB_CBUF0_SIZE);
 367          }
 368          break;
 369       default:
 370          break;
 371       }
 372
 373       /* SAMPLER_STATE array and SAMPLER_BORDER_COLORs */
 374       if (num_samplers) {
 375          /* prefetches are done in multiples of 4 */
 376          num_samplers = align(num_samplers, 4);
 377
 378          len += align(GEN6_SAMPLER_STATE__SIZE * num_samplers, alignment);
 379
 380          if (ilo_dev_gen(render->dev) >= ILO_GEN(8)) {
 381             len += align(GEN6_SAMPLER_BORDER_COLOR_STATE__SIZE, 64 / 4) *
 382                num_samplers;
 383          } else {
 384             len += align(GEN6_SAMPLER_BORDER_COLOR_STATE__SIZE, alignment) *
 385                num_samplers;
 386          }
 387       }
 388
 389       /* PCB */
 390       if (pcb_len)
 391          len += align(pcb_len, alignment);
 392    }
 393
 394    return len;
 395 }
 396
 397 void
 398 ilo_render_emit_draw_dynamic_states(struct ilo_render *render,
 399                                     const struct ilo_state_vector *vec,
 400                                     struct ilo_render_draw_session *session)
 401 {
 402    const unsigned dynamic_used = ilo_builder_dynamic_used(render->builder);
 403
 404    ILO_DEV_ASSERT(render->dev, 6, 8);
 405
 406    if (ilo_dev_gen(render->dev) >= ILO_GEN(7))
 407       gen7_emit_draw_dynamic_viewports(render, vec, session);
 408    else
 409       gen6_emit_draw_dynamic_viewports(render, vec, session);
 410
 411    gen6_emit_draw_dynamic_cc(render, vec, session);
 412    gen6_emit_draw_dynamic_scissors(render, vec, session);
 413    gen6_emit_draw_dynamic_pcb(render, vec, session);
 414
 415    gen6_emit_draw_dynamic_samplers(render, vec,
 416          PIPE_SHADER_VERTEX, session);
 417    gen6_emit_draw_dynamic_samplers(render, vec,
 418          PIPE_SHADER_FRAGMENT, session);
 419
 420    assert(ilo_builder_dynamic_used(render->builder) <= dynamic_used +
 421          ilo_render_get_draw_dynamic_states_len(render, vec));
 422 }
 423
 424 int
 425 ilo_render_get_rectlist_dynamic_states_len(const struct ilo_render *render,
 426                                            const struct ilo_blitter *blitter)
 427 {
 428    ILO_DEV_ASSERT(render->dev, 6, 8);
 429
 430    return (ilo_dev_gen(render->dev) >= ILO_GEN(8)) ? 0 : 96;
 431 }
 432
 433 void
 434 ilo_render_emit_rectlist_dynamic_states(struct ilo_render *render,
 435                                         const struct ilo_blitter *blitter,
 436                                         struct ilo_render_rectlist_session *session)
 437 {
 438    const unsigned dynamic_used = ilo_builder_dynamic_used(render->builder);
 439
 440    ILO_DEV_ASSERT(render->dev, 6, 8);
 441
 442    if (ilo_dev_gen(render->dev) >= ILO_GEN(8))
 443       return;
 444
 445    /* both are inclusive */
 446    session->vb_start = gen6_user_vertex_buffer(render->builder,
 447          sizeof(blitter->vertices), (const void *) blitter->vertices);
 448    session->vb_end = session->vb_start + sizeof(blitter->vertices) - 1;
 449
 450    if (blitter->uses & ILO_BLITTER_USE_DSA) {
 451       render->state.DEPTH_STENCIL_STATE =
 452          gen6_DEPTH_STENCIL_STATE(render->builder, &blitter->cc);
 453    }
 454
 455    if (blitter->uses & ILO_BLITTER_USE_CC) {
 456       render->state.COLOR_CALC_STATE =
 457          gen6_COLOR_CALC_STATE(render->builder, &blitter->cc);
 458    }
 459
 460    if (blitter->uses & ILO_BLITTER_USE_VIEWPORT) {
 461       render->state.CC_VIEWPORT =
 462          gen6_CC_VIEWPORT(render->builder, &blitter->vp);
 463    }
 464
 465    assert(ilo_builder_dynamic_used(render->builder) <= dynamic_used +
 466          ilo_render_get_rectlist_dynamic_states_len(render, blitter));
 467 }
 468
 469 static void
 470 gen6_emit_launch_grid_dynamic_samplers(struct ilo_render *r,
 471                                        const struct ilo_state_vector *vec,
 472                                        struct ilo_render_launch_grid_session *session)
 473 {
 474    const unsigned shader_type = PIPE_SHADER_COMPUTE;
 475    const struct ilo_shader_state *cs = vec->cs;
 476    const struct ilo_view_cso * const *views =
 477       (const struct ilo_view_cso **) vec->view[shader_type].states;
 478    struct ilo_state_sampler samplers[ILO_MAX_SAMPLERS];
 479    int sampler_count, i;
 480
 481    ILO_DEV_ASSERT(r->dev, 7, 7.5);
 482
 483    sampler_count = ilo_shader_get_kernel_param(cs, ILO_KERNEL_SAMPLER_COUNT);
 484
 485    assert(sampler_count <= Elements(vec->view[shader_type].states) &&
 486           sampler_count <= Elements(vec->sampler[shader_type].cso));
 487
 488    for (i = 0; i < sampler_count; i++) {
 489       const struct ilo_sampler_cso *cso = vec->sampler[shader_type].cso[i];
 490
 491       r->state.cs.SAMPLER_BORDER_COLOR_STATE[i] = (cso) ?
 492          gen6_SAMPLER_BORDER_COLOR_STATE(r->builder, &cso->border) : 0;
 493    }
 494
 495    for (i = 0; i < sampler_count; i++) {
 496       const struct ilo_sampler_cso *cso = vec->sampler[shader_type].cso[i];
 497
 498       if (cso && views[i]) {
 499          samplers[i] = cso->sampler;
 500          ilo_state_sampler_set_surface(&samplers[i],
 501                r->dev, &views[i]->surface);
 502       } else {
 503          samplers[i] = vec->disabled_sampler;
 504       }
 505    }
 506
 507    r->state.cs.SAMPLER_STATE = gen6_SAMPLER_STATE(r->builder, samplers,
 508          r->state.cs.SAMPLER_BORDER_COLOR_STATE, sampler_count);
 509 }
 510
 511 static void
 512 gen6_emit_launch_grid_dynamic_pcb(struct ilo_render *r,
 513                                   const struct ilo_state_vector *vec,
 514                                   struct ilo_render_launch_grid_session *session)
 515 {
 516    r->state.cs.PUSH_CONSTANT_BUFFER = 0;
 517    r->state.cs.PUSH_CONSTANT_BUFFER_size = 0;
 518 }
 519
 520 static void
 521 gen6_emit_launch_grid_dynamic_idrt(struct ilo_render *r,
 522                                    const struct ilo_state_vector *vec,
 523                                    struct ilo_render_launch_grid_session *session)
 524 {
 525    const struct ilo_shader_state *cs = vec->cs;
 526    struct ilo_state_compute_interface_info interface;
 527    struct ilo_state_compute_info info;
 528    uint32_t kernel_offset;
 529
 530    ILO_DEV_ASSERT(r->dev, 7, 7.5);
 531
 532    memset(&interface, 0, sizeof(interface));
 533
 534    interface.sampler_count =
 535       ilo_shader_get_kernel_param(cs, ILO_KERNEL_SAMPLER_COUNT);
 536    interface.surface_count =
 537       ilo_shader_get_kernel_param(cs, ILO_KERNEL_SURFACE_TOTAL_COUNT);
 538    interface.thread_group_size = session->thread_group_size;
 539    interface.slm_size =
 540       ilo_shader_get_kernel_param(cs, ILO_KERNEL_CS_LOCAL_SIZE);
 541    interface.curbe_read_length = r->state.cs.PUSH_CONSTANT_BUFFER_size;
 542
 543    memset(&info, 0, sizeof(info));
 544    info.data = session->compute_data;
 545    info.data_size = sizeof(session->compute_data);
 546    info.interfaces = &interface;
 547    info.interface_count = 1;
 548    info.cv_urb_alloc_size = r->dev->urb_size;
 549    info.curbe_alloc_size = r->state.cs.PUSH_CONSTANT_BUFFER_size;
 550
 551    ilo_state_compute_init(&session->compute, r->dev, &info);
 552
 553    kernel_offset = ilo_shader_get_kernel_offset(cs);
 554
 555    session->idrt = gen6_INTERFACE_DESCRIPTOR_DATA(r->builder,
 556          &session->compute, &kernel_offset,
 557          &r->state.cs.SAMPLER_STATE, &r->state.cs.BINDING_TABLE_STATE);
 558
 559    session->idrt_size = 32;
 560 }
 561
 562 int
 563 ilo_render_get_launch_grid_dynamic_states_len(const struct ilo_render *render,
 564                                               const struct ilo_state_vector *vec)
 565 {
 566    const int alignment = 32 / 4;
 567    int num_samplers;
 568    int len = 0;
 569
 570    ILO_DEV_ASSERT(render->dev, 7, 7.5);
 571
 572    num_samplers = ilo_shader_get_kernel_param(vec->cs,
 573          ILO_KERNEL_SAMPLER_COUNT);
 574
 575    /* SAMPLER_STATE array and SAMPLER_BORDER_COLORs */
 576    if (num_samplers) {
 577       /* prefetches are done in multiples of 4 */
 578       num_samplers = align(num_samplers, 4);
 579
 580       len += align(GEN6_SAMPLER_STATE__SIZE * num_samplers, alignment) +
 581              align(GEN6_SAMPLER_BORDER_COLOR_STATE__SIZE, alignment) *
 582              num_samplers;
 583    }
 584
 585    len += GEN6_INTERFACE_DESCRIPTOR_DATA__SIZE;
 586
 587    return len;
 588 }
 589
 590 void
 591 ilo_render_emit_launch_grid_dynamic_states(struct ilo_render *render,
 592                                            const struct ilo_state_vector *vec,
 593                                            struct ilo_render_launch_grid_session *session)
 594 {
 595    const unsigned dynamic_used = ilo_builder_dynamic_used(render->builder);
 596
 597    ILO_DEV_ASSERT(render->dev, 7, 7.5);
 598
 599    gen6_emit_launch_grid_dynamic_samplers(render, vec, session);
 600    gen6_emit_launch_grid_dynamic_pcb(render, vec, session);
 601    gen6_emit_launch_grid_dynamic_idrt(render, vec, session);
 602
 603    assert(ilo_builder_dynamic_used(render->builder) <= dynamic_used +
 604          ilo_render_get_launch_grid_dynamic_states_len(render, vec));
 605 }