diff options
| -rw-r--r-- | src/gallium/drivers/radeonsi/si_descriptors.c | 346 | ||||
| -rw-r--r-- | src/gallium/drivers/radeonsi/si_pipe.c | 12 | ||||
| -rw-r--r-- | src/gallium/drivers/radeonsi/si_pipe.h | 23 | ||||
| -rw-r--r-- | src/gallium/drivers/radeonsi/si_shader_tgsi_mem.c | 35 |
4 files changed, 187 insertions, 229 deletions
diff --git a/src/gallium/drivers/radeonsi/si_descriptors.c b/src/gallium/drivers/radeonsi/si_descriptors.c index 13a9a08ea58..c161fd1200e 100644 --- a/src/gallium/drivers/radeonsi/si_descriptors.c +++ b/src/gallium/drivers/radeonsi/si_descriptors.c @@ -1875,16 +1875,20 @@ static void si_rebind_buffer(struct pipe_context *ctx, struct pipe_resource *buf /* Bindless texture handles */ if (rbuffer->texture_handle_allocated) { + struct si_descriptors *descs = &sctx->bindless_descriptors; + util_dynarray_foreach(&sctx->resident_tex_handles, struct si_texture_handle *, tex_handle) { struct pipe_sampler_view *view = (*tex_handle)->view; - struct si_bindless_descriptor *desc = (*tex_handle)->desc; + unsigned desc_slot = (*tex_handle)->desc_slot; if (view->texture == buf) { si_set_buf_desc_address(rbuffer, view->u.buf.offset, - &desc->desc_list[4]); - desc->dirty = true; + descs->list + + desc_slot * 16 + 4); + + (*tex_handle)->desc_dirty = true; sctx->bindless_descriptors_dirty = true; radeon_add_to_buffer_list_check_mem( @@ -1897,10 +1901,12 @@ static void si_rebind_buffer(struct pipe_context *ctx, struct pipe_resource *buf /* Bindless image handles */ if (rbuffer->image_handle_allocated) { + struct si_descriptors *descs = &sctx->bindless_descriptors; + util_dynarray_foreach(&sctx->resident_img_handles, struct si_image_handle *, img_handle) { struct pipe_image_view *view = &(*img_handle)->view; - struct si_bindless_descriptor *desc = (*img_handle)->desc; + unsigned desc_slot = (*img_handle)->desc_slot; if (view->resource == buf) { if (view->access & PIPE_IMAGE_ACCESS_WRITE) @@ -1908,8 +1914,10 @@ static void si_rebind_buffer(struct pipe_context *ctx, struct pipe_resource *buf si_set_buf_desc_address(rbuffer, view->u.buf.offset, - &desc->desc_list[4]); - desc->dirty = true; + descs->list + + desc_slot * 16 + 4); + + (*img_handle)->desc_dirty = true; sctx->bindless_descriptors_dirty = true; radeon_add_to_buffer_list_check_mem( @@ -1941,11 +1949,19 @@ static void si_invalidate_buffer(struct pipe_context *ctx, struct pipe_resource } static void si_upload_bindless_descriptor(struct si_context *sctx, - struct si_bindless_descriptor *desc) + unsigned desc_slot, + unsigned num_dwords) { + struct si_descriptors *desc = &sctx->bindless_descriptors; struct radeon_winsys_cs *cs = sctx->b.gfx.cs; - uint64_t va = desc->buffer->gpu_address + desc->offset; - unsigned num_dwords = sizeof(desc->desc_list) / 4; + unsigned desc_slot_offset = desc_slot * 16; + uint32_t *data; + uint64_t va; + + data = desc->list + desc_slot_offset; + + va = desc->buffer->gpu_address + desc->buffer_offset + + desc_slot_offset * 4; radeon_emit(cs, PKT3(PKT3_WRITE_DATA, 2 + num_dwords, 0)); radeon_emit(cs, S_370_DST_SEL(V_370_TC_L2) | @@ -1953,7 +1969,7 @@ static void si_upload_bindless_descriptor(struct si_context *sctx, S_370_ENGINE_SEL(V_370_ME)); radeon_emit(cs, va); radeon_emit(cs, va >> 32); - radeon_emit_array(cs, desc->desc_list, num_dwords); + radeon_emit_array(cs, data, num_dwords); } static void si_upload_bindless_descriptors(struct si_context *sctx) @@ -1970,24 +1986,24 @@ static void si_upload_bindless_descriptors(struct si_context *sctx) util_dynarray_foreach(&sctx->resident_tex_handles, struct si_texture_handle *, tex_handle) { - struct si_bindless_descriptor *desc = (*tex_handle)->desc; + unsigned desc_slot = (*tex_handle)->desc_slot; - if (!desc->dirty) + if (!(*tex_handle)->desc_dirty) continue; - si_upload_bindless_descriptor(sctx, desc); - desc->dirty = false; + si_upload_bindless_descriptor(sctx, desc_slot, 16); + (*tex_handle)->desc_dirty = false; } util_dynarray_foreach(&sctx->resident_img_handles, struct si_image_handle *, img_handle) { - struct si_bindless_descriptor *desc = (*img_handle)->desc; + unsigned desc_slot = (*img_handle)->desc_slot; - if (!desc->dirty) + if (!(*img_handle)->desc_dirty) continue; - si_upload_bindless_descriptor(sctx, desc); - desc->dirty = false; + si_upload_bindless_descriptor(sctx, desc_slot, 8); + (*img_handle)->desc_dirty = false; } /* Invalidate L1 because it doesn't know that L2 changed. */ @@ -2002,18 +2018,20 @@ static void si_update_resident_texture_descriptor(struct si_context *sctx, struct si_texture_handle *tex_handle) { struct si_sampler_view *sview = (struct si_sampler_view *)tex_handle->view; - struct si_bindless_descriptor *desc = tex_handle->desc; + struct si_descriptors *desc = &sctx->bindless_descriptors; + unsigned desc_slot_offset = tex_handle->desc_slot * 16; uint32_t desc_list[16]; if (sview->base.texture->target == PIPE_BUFFER) return; - memcpy(desc_list, desc->desc_list, sizeof(desc_list)); + memcpy(desc_list, desc->list + desc_slot_offset, sizeof(desc_list)); si_set_sampler_view_desc(sctx, sview, &tex_handle->sstate, - &desc->desc_list[0]); + desc->list + desc_slot_offset); - if (memcmp(desc_list, desc->desc_list, sizeof(desc_list))) { - desc->dirty = true; + if (memcmp(desc_list, desc->list + desc_slot_offset, + sizeof(desc_list))) { + tex_handle->desc_dirty = true; sctx->bindless_descriptors_dirty = true; } } @@ -2021,18 +2039,22 @@ static void si_update_resident_texture_descriptor(struct si_context *sctx, static void si_update_resident_image_descriptor(struct si_context *sctx, struct si_image_handle *img_handle) { - struct si_bindless_descriptor *desc = img_handle->desc; + struct si_descriptors *desc = &sctx->bindless_descriptors; + unsigned desc_slot_offset = img_handle->desc_slot * 16; struct pipe_image_view *view = &img_handle->view; - uint32_t desc_list[16]; + uint32_t desc_list[8]; if (view->resource->target == PIPE_BUFFER) return; - memcpy(desc_list, desc->desc_list, sizeof(desc_list)); - si_set_shader_image_desc(sctx, view, true, &desc->desc_list[0]); + memcpy(desc_list, desc->list + desc_slot_offset, + sizeof(desc_list)); + si_set_shader_image_desc(sctx, view, true, + desc->list + desc_slot_offset); - if (memcmp(desc_list, desc->desc_list, sizeof(desc_list))) { - desc->dirty = true; + if (memcmp(desc_list, desc->list + desc_slot_offset, + sizeof(desc_list))) { + img_handle->desc_dirty = true; sctx->bindless_descriptors_dirty = true; } } @@ -2116,6 +2138,8 @@ static void si_shader_pointers_begin_new_cs(struct si_context *sctx) sctx->shader_pointers_dirty = u_bit_consecutive(0, SI_NUM_DESCS); sctx->vertex_buffer_pointer_dirty = sctx->vertex_buffers.buffer != NULL; si_mark_atom_dirty(sctx, &sctx->shader_pointers.atom); + sctx->graphics_bindless_pointer_dirty = sctx->bindless_descriptors.buffer != NULL; + sctx->compute_bindless_pointer_dirty = sctx->bindless_descriptors.buffer != NULL; } /* Set a base register address for user data constants in the given shader. @@ -2204,14 +2228,25 @@ static void si_emit_global_shader_pointers(struct si_context *sctx, R_00B130_SPI_SHADER_USER_DATA_VS_0); if (sctx->b.chip_class >= GFX9) { - /* GFX9 merged LS-HS and ES-GS. - * Set RW_BUFFERS in the special registers, so that - * it's preloaded into s[0:1] instead of s[8:9]. - */ - si_emit_shader_pointer(sctx, descs, - R_00B208_SPI_SHADER_USER_DATA_ADDR_LO_GS); - si_emit_shader_pointer(sctx, descs, - R_00B408_SPI_SHADER_USER_DATA_ADDR_LO_HS); + /* GFX9 merged LS-HS and ES-GS. */ + if (descs == &sctx->descriptors[SI_DESCS_RW_BUFFERS]) { + /* Set RW_BUFFERS in the special registers, so that + * it's preloaded into s[0:1] instead of s[8:9]. + */ + si_emit_shader_pointer(sctx, descs, + R_00B208_SPI_SHADER_USER_DATA_ADDR_LO_GS); + si_emit_shader_pointer(sctx, descs, + R_00B408_SPI_SHADER_USER_DATA_ADDR_LO_HS); + } else { + /* Set BINDLESS_SAMPLERS_AND_IMAGES into s[10:11], + * s[8:9] remains unused for now. + */ + assert(descs == &sctx->bindless_descriptors); + si_emit_shader_pointer(sctx, descs, + R_00B330_SPI_SHADER_USER_DATA_ES_0); + si_emit_shader_pointer(sctx, descs, + R_00B430_SPI_SHADER_USER_DATA_LS_0); + } } else { si_emit_shader_pointer(sctx, descs, R_00B230_SPI_SHADER_USER_DATA_GS_0); @@ -2256,6 +2291,12 @@ void si_emit_graphics_shader_pointers(struct si_context *sctx, sh_base[PIPE_SHADER_VERTEX]); sctx->vertex_buffer_pointer_dirty = false; } + + if (sctx->graphics_bindless_pointer_dirty) { + si_emit_global_shader_pointers(sctx, + &sctx->bindless_descriptors); + sctx->graphics_bindless_pointer_dirty = false; + } } void si_emit_compute_shader_pointers(struct si_context *sctx) @@ -2272,135 +2313,87 @@ void si_emit_compute_shader_pointers(struct si_context *sctx) si_emit_shader_pointer(sctx, descs + i, base); } sctx->shader_pointers_dirty &= ~compute_mask; + + if (sctx->compute_bindless_pointer_dirty) { + si_emit_shader_pointer(sctx, &sctx->bindless_descriptors, base); + sctx->compute_bindless_pointer_dirty = false; + } } /* BINDLESS */ -struct si_bindless_descriptor_slab +static void si_init_bindless_descriptors(struct si_context *sctx, + struct si_descriptors *desc, + unsigned shader_userdata_index, + unsigned num_elements) { - struct pb_slab base; - struct r600_resource *buffer; - struct si_bindless_descriptor *entries; -}; + si_init_descriptors(sctx, desc, shader_userdata_index, 16, num_elements, + 0, 0, NULL); + sctx->bindless_descriptors.num_active_slots = num_elements; -bool si_bindless_descriptor_can_reclaim_slab(void *priv, - struct pb_slab_entry *entry) -{ - /* Do not allow to reclaim any bindless descriptors for now because the - * GPU might be using them. This should be improved later on. + /* The first bindless descriptor is stored at slot 1, because 0 is not + * considered to be a valid handle. */ - return false; + sctx->num_bindless_descriptors = 1; } -struct pb_slab *si_bindless_descriptor_slab_alloc(void *priv, unsigned heap, - unsigned entry_size, - unsigned group_index) +static void si_release_bindless_descriptors(struct si_context *sctx) { - struct si_context *sctx = priv; - struct si_screen *sscreen = sctx->screen; - struct si_bindless_descriptor_slab *slab; - - slab = CALLOC_STRUCT(si_bindless_descriptor_slab); - if (!slab) - return NULL; - - /* Create a buffer in VRAM for 1024 bindless descriptors. */ - slab->buffer = (struct r600_resource *) - pipe_buffer_create(&sscreen->b.b, 0, - PIPE_USAGE_DEFAULT, 64 * 1024); - if (!slab->buffer) - goto fail; - - slab->base.num_entries = slab->buffer->bo_size / entry_size; - slab->base.num_free = slab->base.num_entries; - slab->entries = CALLOC(slab->base.num_entries, sizeof(*slab->entries)); - if (!slab->entries) - goto fail_buffer; - - LIST_INITHEAD(&slab->base.free); - - for (unsigned i = 0; i < slab->base.num_entries; ++i) { - struct si_bindless_descriptor *desc = &slab->entries[i]; - - desc->entry.slab = &slab->base; - desc->entry.group_index = group_index; - desc->buffer = slab->buffer; - desc->offset = i * entry_size; - - LIST_ADDTAIL(&desc->entry.head, &slab->base.free); - } - - /* Add the descriptor to the per-context list. */ - util_dynarray_append(&sctx->bindless_descriptors, - struct r600_resource *, slab->buffer); - - return &slab->base; - -fail_buffer: - r600_resource_reference(&slab->buffer, NULL); -fail: - FREE(slab); - return NULL; + si_release_descriptors(&sctx->bindless_descriptors); } -void si_bindless_descriptor_slab_free(void *priv, struct pb_slab *pslab) +static unsigned +si_create_bindless_descriptor(struct si_context *sctx, uint32_t *desc_list, + unsigned size) { - struct si_context *sctx = priv; - struct si_bindless_descriptor_slab *slab = - (struct si_bindless_descriptor_slab *)pslab; + struct si_descriptors *desc = &sctx->bindless_descriptors; + unsigned desc_slot, desc_slot_offset; - /* Remove the descriptor from the per-context list. */ - util_dynarray_delete_unordered(&sctx->bindless_descriptors, - struct r600_resource *, slab->buffer); + /* Reserve a new slot for this bindless descriptor. */ + desc_slot = sctx->num_bindless_descriptors++; - r600_resource_reference(&slab->buffer, NULL); - FREE(slab->entries); - FREE(slab); -} + if (desc_slot >= desc->num_elements) { + /* The array of bindless descriptors is full, resize it. */ + unsigned slot_size = desc->element_dw_size * 4; + unsigned new_num_elements = desc->num_elements * 2; -static struct si_bindless_descriptor * -si_create_bindless_descriptor(struct si_context *sctx, uint32_t *desc_list, - unsigned size) -{ - struct si_screen *sscreen = sctx->screen; - struct si_bindless_descriptor *desc; - struct pb_slab_entry *entry; - void *ptr; + desc->list = REALLOC(desc->list, desc->num_elements * slot_size, + new_num_elements * slot_size); + desc->num_elements = new_num_elements; + desc->num_active_slots = new_num_elements; + } - /* Sub-allocate the bindless descriptor from a slab to avoid dealing - * with a ton of buffers and for reducing the winsys overhead. + /* For simplicity, sampler and image bindless descriptors use fixed + * 16-dword slots for now. Image descriptors only need 8-dword but this + * doesn't really matter because no real apps use image handles. */ - entry = pb_slab_alloc(&sctx->bindless_descriptor_slabs, 64, 0); - if (!entry) - return NULL; + desc_slot_offset = desc_slot * 16; - desc = NULL; - desc = container_of(entry, desc, entry); + /* Copy the descriptor into the array. */ + memcpy(desc->list + desc_slot_offset, desc_list, size); - /* Upload the descriptor directly in VRAM. Because the slabs are - * currently never reclaimed, we don't need to synchronize the - * operation. + /* Re-upload the whole array of bindless descriptors into a new buffer. */ - ptr = sscreen->b.ws->buffer_map(desc->buffer->buf, NULL, - PIPE_TRANSFER_WRITE | - PIPE_TRANSFER_UNSYNCHRONIZED); - util_memcpy_cpu_to_le32(ptr + desc->offset, desc_list, size); + if (!si_upload_descriptors(sctx, desc, &sctx->shader_pointers.atom)) + return 0; - /* Keep track of the initial descriptor especially for buffers - * invalidation because we might need to know the previous address. - */ - memcpy(desc->desc_list, desc_list, sizeof(desc->desc_list)); + /* Make sure to re-emit the shader pointers for all stages. */ + sctx->graphics_bindless_pointer_dirty = true; + sctx->compute_bindless_pointer_dirty = true; - return desc; + return desc_slot; } static void si_invalidate_bindless_buf_desc(struct si_context *sctx, - struct si_bindless_descriptor *desc, + unsigned desc_slot, struct pipe_resource *resource, - uint64_t offset) + uint64_t offset, + bool *desc_dirty) { + struct si_descriptors *desc = &sctx->bindless_descriptors; struct r600_resource *buf = r600_resource(resource); - uint32_t *desc_list = desc->desc_list + 4; + unsigned desc_slot_offset = desc_slot * 16; + uint32_t *desc_list = desc->list + desc_slot_offset + 4; uint64_t old_desc_va; assert(resource->target == PIPE_BUFFER); @@ -2415,7 +2408,7 @@ static void si_invalidate_bindless_buf_desc(struct si_context *sctx, */ si_set_buf_desc_address(buf, offset, &desc_list[0]); - desc->dirty = true; + *desc_dirty = true; sctx->bindless_descriptors_dirty = true; } } @@ -2448,20 +2441,17 @@ static uint64_t si_create_texture_handle(struct pipe_context *ctx, memcpy(&tex_handle->sstate, sstate, sizeof(*sstate)); ctx->delete_sampler_state(ctx, sstate); - tex_handle->desc = si_create_bindless_descriptor(sctx, desc_list, - sizeof(desc_list)); - if (!tex_handle->desc) { + tex_handle->desc_slot = si_create_bindless_descriptor(sctx, desc_list, + sizeof(desc_list)); + if (!tex_handle->desc_slot) { FREE(tex_handle); return 0; } - handle = tex_handle->desc->buffer->gpu_address + - tex_handle->desc->offset; + handle = tex_handle->desc_slot; if (!_mesa_hash_table_insert(sctx->tex_handles, (void *)handle, tex_handle)) { - pb_slab_free(&sctx->bindless_descriptor_slabs, - &tex_handle->desc->entry); FREE(tex_handle); return 0; } @@ -2487,8 +2477,6 @@ static void si_delete_texture_handle(struct pipe_context *ctx, uint64_t handle) pipe_sampler_view_reference(&tex_handle->view, NULL); _mesa_hash_table_remove(sctx->tex_handles, entry); - pb_slab_free(&sctx->bindless_descriptor_slabs, - &tex_handle->desc->entry); FREE(tex_handle); } @@ -2534,12 +2522,14 @@ static void si_make_texture_handle_resident(struct pipe_context *ctx, * while it wasn't resident. */ si_update_resident_texture_descriptor(sctx, tex_handle); - if (tex_handle->desc->dirty) + if (tex_handle->desc_dirty) sctx->bindless_descriptors_dirty = true; } else { - si_invalidate_bindless_buf_desc(sctx, tex_handle->desc, + si_invalidate_bindless_buf_desc(sctx, + tex_handle->desc_slot, sview->base.texture, - sview->base.u.buf.offset); + sview->base.u.buf.offset, + &tex_handle->desc_dirty); } /* Add the texture handle to the per-context list. */ @@ -2549,11 +2539,6 @@ static void si_make_texture_handle_resident(struct pipe_context *ctx, /* Add the buffers to the current CS in case si_begin_new_cs() * is not going to be called. */ - radeon_add_to_buffer_list(&sctx->b, &sctx->b.gfx, - tex_handle->desc->buffer, - RADEON_USAGE_READWRITE, - RADEON_PRIO_DESCRIPTORS); - si_sampler_view_add_buffer(sctx, sview->base.texture, RADEON_USAGE_READ, sview->is_stencil_sampler, false); @@ -2580,7 +2565,7 @@ static uint64_t si_create_image_handle(struct pipe_context *ctx, { struct si_context *sctx = (struct si_context *)ctx; struct si_image_handle *img_handle; - uint32_t desc_list[16]; + uint32_t desc_list[8]; uint64_t handle; if (!view || !view->resource) @@ -2595,20 +2580,17 @@ static uint64_t si_create_image_handle(struct pipe_context *ctx, si_set_shader_image_desc(sctx, view, false, &desc_list[0]); - img_handle->desc = si_create_bindless_descriptor(sctx, desc_list, - sizeof(desc_list)); - if (!img_handle->desc) { + img_handle->desc_slot = si_create_bindless_descriptor(sctx, desc_list, + sizeof(desc_list)); + if (!img_handle->desc_slot) { FREE(img_handle); return 0; } - handle = img_handle->desc->buffer->gpu_address + - img_handle->desc->offset; + handle = img_handle->desc_slot; if (!_mesa_hash_table_insert(sctx->img_handles, (void *)handle, img_handle)) { - pb_slab_free(&sctx->bindless_descriptor_slabs, - &img_handle->desc->entry); FREE(img_handle); return 0; } @@ -2634,8 +2616,6 @@ static void si_delete_image_handle(struct pipe_context *ctx, uint64_t handle) util_copy_image_view(&img_handle->view, NULL); _mesa_hash_table_remove(sctx->img_handles, entry); - pb_slab_free(&sctx->bindless_descriptor_slabs, - &img_handle->desc->entry); FREE(img_handle); } @@ -2677,13 +2657,15 @@ static void si_make_image_handle_resident(struct pipe_context *ctx, * while it wasn't resident. */ si_update_resident_image_descriptor(sctx, img_handle); - if (img_handle->desc->dirty) + if (img_handle->desc_dirty) sctx->bindless_descriptors_dirty = true; } else { - si_invalidate_bindless_buf_desc(sctx, img_handle->desc, + si_invalidate_bindless_buf_desc(sctx, + img_handle->desc_slot, view->resource, - view->u.buf.offset); + view->u.buf.offset, + &img_handle->desc_dirty); } /* Add the image handle to the per-context list. */ @@ -2693,11 +2675,6 @@ static void si_make_image_handle_resident(struct pipe_context *ctx, /* Add the buffers to the current CS in case si_begin_new_cs() * is not going to be called. */ - radeon_add_to_buffer_list(&sctx->b, &sctx->b.gfx, - img_handle->desc->buffer, - RADEON_USAGE_READWRITE, - RADEON_PRIO_DESCRIPTORS); - si_sampler_view_add_buffer(sctx, view->resource, (access & PIPE_IMAGE_ACCESS_WRITE) ? RADEON_USAGE_READWRITE : @@ -2727,20 +2704,6 @@ void si_all_resident_buffers_begin_new_cs(struct si_context *sctx) num_resident_img_handles = sctx->resident_img_handles.size / sizeof(struct si_image_handle *); - /* Skip adding the bindless descriptors when no handles are resident. - */ - if (!num_resident_tex_handles && !num_resident_img_handles) - return; - - /* Add all bindless descriptors. */ - util_dynarray_foreach(&sctx->bindless_descriptors, - struct r600_resource *, desc) { - - radeon_add_to_buffer_list(&sctx->b, &sctx->b.gfx, *desc, - RADEON_USAGE_READWRITE, - RADEON_PRIO_DESCRIPTORS); - } - /* Add all resident texture handles. */ util_dynarray_foreach(&sctx->resident_tex_handles, struct si_texture_handle *, tex_handle) { @@ -2891,6 +2854,13 @@ void si_init_all_descriptors(struct si_context *sctx) FREE(sctx->vertex_buffers.list); /* not used */ sctx->vertex_buffers.list = NULL; + /* Initialize an array of 1024 bindless descriptors, when the limit is + * reached, just make it larger and re-upload the whole array. + */ + si_init_bindless_descriptors(sctx, &sctx->bindless_descriptors, + SI_SGPR_BINDLESS_SAMPLERS_AND_IMAGES, + 1024); + sctx->descriptors_dirty = u_bit_consecutive(0, SI_NUM_DESCS); sctx->total_ce_ram_allocated = ce_offset; @@ -2992,6 +2962,7 @@ void si_release_all_descriptors(struct si_context *sctx) sctx->vertex_buffers.list = NULL; /* points into a mapped buffer */ si_release_descriptors(&sctx->vertex_buffers); + si_release_bindless_descriptors(sctx); } void si_all_descriptors_begin_new_cs(struct si_context *sctx) @@ -3008,6 +2979,7 @@ void si_all_descriptors_begin_new_cs(struct si_context *sctx) for (i = 0; i < SI_NUM_DESCS; ++i) si_descriptors_begin_new_cs(sctx, &sctx->descriptors[i]); + si_descriptors_begin_new_cs(sctx, &sctx->bindless_descriptors); si_shader_pointers_begin_new_cs(sctx); } diff --git a/src/gallium/drivers/radeonsi/si_pipe.c b/src/gallium/drivers/radeonsi/si_pipe.c index a2b37cbab0c..1523eaed941 100644 --- a/src/gallium/drivers/radeonsi/si_pipe.c +++ b/src/gallium/drivers/radeonsi/si_pipe.c @@ -98,9 +98,6 @@ static void si_destroy_context(struct pipe_context *context) si_saved_cs_reference(&sctx->current_saved_cs, NULL); - pb_slabs_deinit(&sctx->bindless_descriptor_slabs); - util_dynarray_fini(&sctx->bindless_descriptors); - _mesa_hash_table_destroy(sctx->tex_handles, NULL); _mesa_hash_table_destroy(sctx->img_handles, NULL); @@ -371,15 +368,6 @@ static struct pipe_context *si_create_context(struct pipe_screen *screen, sctx->tm = si_create_llvm_target_machine(sscreen); - /* Create a slab allocator for all bindless descriptors. */ - if (!pb_slabs_init(&sctx->bindless_descriptor_slabs, 6, 6, 1, sctx, - si_bindless_descriptor_can_reclaim_slab, - si_bindless_descriptor_slab_alloc, - si_bindless_descriptor_slab_free)) - goto fail; - - util_dynarray_init(&sctx->bindless_descriptors, NULL); - /* Bindless handles. */ sctx->tex_handles = _mesa_hash_table_create(NULL, _mesa_hash_pointer, _mesa_key_pointer_equal); diff --git a/src/gallium/drivers/radeonsi/si_pipe.h b/src/gallium/drivers/radeonsi/si_pipe.h index 2dca72d7f3c..7df02967ab7 100644 --- a/src/gallium/drivers/radeonsi/si_pipe.h +++ b/src/gallium/drivers/radeonsi/si_pipe.h @@ -246,25 +246,18 @@ union si_vgt_param_key { uint32_t index; }; -struct si_bindless_descriptor -{ - struct pb_slab_entry entry; - struct r600_resource *buffer; - unsigned offset; - uint32_t desc_list[16]; - bool dirty; -}; - struct si_texture_handle { - struct si_bindless_descriptor *desc; + unsigned desc_slot; + bool desc_dirty; struct pipe_sampler_view *view; struct si_sampler_state sstate; }; struct si_image_handle { - struct si_bindless_descriptor *desc; + unsigned desc_slot; + bool desc_dirty; struct pipe_image_view view; }; @@ -444,12 +437,12 @@ struct si_context { union si_vgt_param_key ia_multi_vgt_param_key; unsigned ia_multi_vgt_param[SI_NUM_VGT_PARAM_STATES]; - /* Slab allocator for bindless descriptors. */ - struct pb_slabs bindless_descriptor_slabs; - /* Bindless descriptors. */ - struct util_dynarray bindless_descriptors; + struct si_descriptors bindless_descriptors; + unsigned num_bindless_descriptors; bool bindless_descriptors_dirty; + bool graphics_bindless_pointer_dirty; + bool compute_bindless_pointer_dirty; /* Allocated bindless handles */ struct hash_table *tex_handles; diff --git a/src/gallium/drivers/radeonsi/si_shader_tgsi_mem.c b/src/gallium/drivers/radeonsi/si_shader_tgsi_mem.c index f8c99ff7e77..1e44b68b860 100644 --- a/src/gallium/drivers/radeonsi/si_shader_tgsi_mem.c +++ b/src/gallium/drivers/radeonsi/si_shader_tgsi_mem.c @@ -205,15 +205,22 @@ image_fetch_rsrc( } if (image->Register.File != TGSI_FILE_IMAGE) { + /* Bindless descriptors are accessible from a different pair of + * user SGPR indices. + */ struct gallivm_state *gallivm = &ctx->gallivm; LLVMBuilderRef builder = gallivm->builder; - LLVMValueRef ptr = - lp_build_emit_fetch_src(bld_base, image, - TGSI_TYPE_UNSIGNED64, 0); - rsrc_ptr = LLVMBuildIntToPtr(builder, ptr, - si_const_array(ctx->v8i32, 0), ""); - index = LLVMConstInt(ctx->i32, 0, 0); + rsrc_ptr = LLVMGetParam(ctx->main_fn, + ctx->param_bindless_samplers_and_images); + index = lp_build_emit_fetch_src(bld_base, image, + TGSI_TYPE_UNSIGNED, 0); + + /* For simplicity, bindless image descriptors use fixed + * 16-dword slots for now. + */ + index = LLVMBuildMul(builder, index, + LLVMConstInt(ctx->i32, 2, 0), ""); } *rsrc = si_load_image_desc(ctx, rsrc_ptr, index, @@ -1213,15 +1220,13 @@ static void tex_fetch_ptrs( } if (reg->Register.File != TGSI_FILE_SAMPLER) { - struct gallivm_state *gallivm = &ctx->gallivm; - LLVMBuilderRef builder = gallivm->builder; - - LLVMValueRef ptr = - lp_build_emit_fetch_src(bld_base, reg, - TGSI_TYPE_UNSIGNED64, 0); - list = LLVMBuildIntToPtr(builder, ptr, - si_const_array(ctx->v8i32, 0), ""); - index = LLVMConstInt(ctx->i32, 0, 0); + /* Bindless descriptors are accessible from a different pair of + * user SGPR indices. + */ + list = LLVMGetParam(ctx->main_fn, + ctx->param_bindless_samplers_and_images); + index = lp_build_emit_fetch_src(bld_base, reg, + TGSI_TYPE_UNSIGNED, 0); } if (target == TGSI_TEXTURE_BUFFER) |