radeonsi: use slot indexes for bindless handles

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 <samuel.pitoiset@gmail.com>
Reviewed-by: Marek Olšák <marek.olsak@amd.com>

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)
-{
-	struct si_context *sctx = priv;
-	struct si_bindless_descriptor_slab *slab =
-		(struct si_bindless_descriptor_slab *)pslab;
-
-	/* Remove the descriptor from the per-context list. */
-	util_dynarray_delete_unordered(&sctx->bindless_descriptors,
-				       struct r600_resource *, slab->buffer);
-
-	r600_resource_reference(&slab->buffer, NULL);
-	FREE(slab->entries);
-	FREE(slab);
-}
-
-static struct si_bindless_descriptor *
+static unsigned
 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;
+	struct si_descriptors *desc = &sctx->bindless_descriptors;
+	unsigned desc_slot, desc_slot_offset;
 
-	/* Sub-allocate the bindless descriptor from a slab to avoid dealing
-	 * with a ton of buffers and for reducing the winsys overhead.
+	/* Reserve a new slot for this bindless descriptor. */
+	desc_slot = sctx->num_bindless_descriptors++;
+
+	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;
+
+		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;
+	}
+
+	/* 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);
 }

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);

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;

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)