From c2dfa9b1114db660547eca8bcdf32374313b6a04 Mon Sep 17 00:00:00 2001 From: Samuel Pitoiset Date: Mon, 3 Jul 2017 16:06:44 +0200 Subject: [PATCH] radeonsi: use slot indexes for bindless handles MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Using VRAM address as bindless handles is not a good idea because we have to use LLVMIntToPTr and the LLVM CSE pass can't optimize because it has no information about the pointer. Instead, use slots indexes like the existing descriptors. Note that we use fixed 16-dword slots for both samplers and images. This doesn't really matter because no real apps use image handles. This improves performance with DOW3 by +7%. Signed-off-by: Samuel Pitoiset Reviewed-by: Marek Olšák --- src/gallium/drivers/radeonsi/si_descriptors.c | 346 ++++++++---------- src/gallium/drivers/radeonsi/si_pipe.c | 12 - src/gallium/drivers/radeonsi/si_pipe.h | 23 +- .../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) -- 2.30.2