fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-06-13 15:58:18 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

zink/bo: use pb_buffer_lean to save a little mem

Browse source 
vtbl is not used

Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/41936>
This commit is contained in:
Mike Blumenkrantz 2026-06-01 10:38:58 -04:00 • committed by Marge Bot
parent 47142da666
commit cf1ca02bd0
4 changed files with 49 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

82
src/gallium/drivers/zink/zink_bo.c
View file

@ -131,7 +131,7 @@ bo_destroy(struct zink_screen *screen, struct zink_bo *bo)
}
static bool
bo_can_reclaim(struct zink_screen *screen, struct pb_buffer *pbuf)
bo_can_reclaim(struct zink_screen *screen, struct pb_buffer_lean *pbuf)
{
struct zink_bo *bo = zink_bo(pbuf);
@ -150,7 +150,7 @@ static void
bo_slab_free(struct zink_screen *screen, struct pb_slab *pslab)
{
struct zink_slab *slab = zink_slab(pslab);
ASSERTED unsigned slab_size = slab->buffer->base.base.size;
ASSERTED unsigned slab_size = slab->buffer->base.size;
assert(slab->base.num_entries * slab->base.entry_size <= slab_size);
FREE(slab->entries);
@ -273,7 +273,7 @@ bo_create_internal(struct zink_screen *screen,
if (init_pb_cache) {
bo->u.real.use_reusable_pool = true;
pb_cache_init_entry(&screen->pb.bo_cache, bo->cache_entry, &bo->base.base, mem_type_idx);
pb_cache_init_entry(&screen->pb.bo_cache, bo->cache_entry, &bo->base, mem_type_idx);
} else {
#ifdef ZINK_USE_DMABUF
list_inithead(&bo->u.real.exports);
@ -283,12 +283,12 @@ bo_create_internal(struct zink_screen *screen,
simple_mtx_init(&bo->lock, mtx_plain);
pipe_reference_init(&bo->base.base.reference, 1);
bo->base.base.alignment_log2 = util_logbase2(alignment);
bo->base.base.size = mai.allocationSize;
pipe_reference_init(&bo->base.reference, 1);
bo->base.alignment_log2 = util_logbase2(alignment);
bo->base.size = mai.allocationSize;
bo->type = ZINK_BO_REAL;
bo->base.base.placement = mem_type_idx;
bo->base.base.usage = flags;
bo->base.placement = mem_type_idx;
bo->base.usage = flags;
bo->unique_id = p_atomic_inc_return(&screen->pb.next_bo_unique_id);
return bo;
@ -330,7 +330,7 @@ sparse_backing_alloc(struct zink_screen *screen, struct zink_bo *bo,
/* Allocate a new backing buffer if necessary. */
if (!best_backing) {
struct pb_buffer *buf;
struct pb_buffer_lean *buf;
uint64_t size;
uint32_t pages;
@ -346,11 +346,11 @@ sparse_backing_alloc(struct zink_screen *screen, struct zink_bo *bo,
return NULL;
}
assert(bo->u.sparse.num_backing_pages < DIV_ROUND_UP(bo->base.base.size, ZINK_SPARSE_BUFFER_PAGE_SIZE));
assert(bo->u.sparse.num_backing_pages < DIV_ROUND_UP(bo->base.size, ZINK_SPARSE_BUFFER_PAGE_SIZE));
size = MIN3(bo->base.base.size / 16,
size = MIN3(bo->base.size / 16,
8 * 1024 * 1024,
bo->base.base.size - (uint64_t)bo->u.sparse.num_backing_pages * ZINK_SPARSE_BUFFER_PAGE_SIZE);
bo->base.size - (uint64_t)bo->u.sparse.num_backing_pages * ZINK_SPARSE_BUFFER_PAGE_SIZE);
size = MAX2(size, ZINK_SPARSE_BUFFER_PAGE_SIZE);
buf = zink_bo_create(screen, size, ZINK_SPARSE_BUFFER_PAGE_SIZE,
@ -362,7 +362,7 @@ sparse_backing_alloc(struct zink_screen *screen, struct zink_bo *bo,
}
/* We might have gotten a bigger buffer than requested via caching. */
pages = buf->base.size / ZINK_SPARSE_BUFFER_PAGE_SIZE;
pages = buf->size / ZINK_SPARSE_BUFFER_PAGE_SIZE;
best_backing->bo = zink_bo(buf);
best_backing->num_chunks = 1;
@ -393,7 +393,7 @@ static void
sparse_free_backing_buffer(struct zink_screen *screen, struct zink_bo *bo,
struct zink_sparse_backing *backing)
{
bo->u.sparse.num_backing_pages -= backing->bo->base.base.size / ZINK_SPARSE_BUFFER_PAGE_SIZE;
bo->u.sparse.num_backing_pages -= backing->bo->base.size / ZINK_SPARSE_BUFFER_PAGE_SIZE;
list_del(&backing->list);
zink_bo_unref(screen, backing->bo);
@ -460,7 +460,7 @@ sparse_backing_free(struct zink_screen *screen, struct zink_bo *bo,
}
if (backing->num_chunks == 1 && backing->chunks[0].begin == 0 &&
backing->chunks[0].end == backing->bo->base.base.size / ZINK_SPARSE_BUFFER_PAGE_SIZE)
backing->chunks[0].end == backing->bo->base.size / ZINK_SPARSE_BUFFER_PAGE_SIZE)
sparse_free_backing_buffer(screen, bo, backing);
return true;
@ -469,7 +469,7 @@ sparse_backing_free(struct zink_screen *screen, struct zink_bo *bo,
static void
bo_sparse_destroy(struct zink_screen *screen, struct zink_bo *bo)
{
assert(!bo->mem && bo->base.base.usage & ZINK_ALLOC_SPARSE);
assert(!bo->mem && bo->base.usage & ZINK_ALLOC_SPARSE);
while (!list_is_empty(&bo->u.sparse.backing)) {
sparse_free_backing_buffer(screen, bo,
@ -482,7 +482,7 @@ bo_sparse_destroy(struct zink_screen *screen, struct zink_bo *bo)
FREE(bo);
}
static struct pb_buffer *
static struct pb_buffer_lean *
bo_sparse_create(struct zink_screen *screen, uint64_t size)
{
struct zink_bo *bo;
@ -499,15 +499,15 @@ bo_sparse_create(struct zink_screen *screen, uint64_t size)
return NULL;
simple_mtx_init(&bo->lock, mtx_plain);
pipe_reference_init(&bo->base.base.reference, 1);
bo->base.base.alignment_log2 = util_logbase2(ZINK_SPARSE_BUFFER_PAGE_SIZE);
bo->base.base.size = size;
pipe_reference_init(&bo->base.reference, 1);
bo->base.alignment_log2 = util_logbase2(ZINK_SPARSE_BUFFER_PAGE_SIZE);
bo->base.size = size;
bo->type = ZINK_BO_SPARSE;
unsigned placement = zink_mem_type_idx_from_types(screen, ZINK_HEAP_DEVICE_LOCAL_SPARSE, UINT32_MAX);
assert(placement != UINT32_MAX);
bo->base.base.placement = placement;
bo->base.placement = placement;
bo->unique_id = p_atomic_inc_return(&screen->pb.next_bo_unique_id);
bo->base.base.usage = ZINK_ALLOC_SPARSE;
bo->base.usage = ZINK_ALLOC_SPARSE;
bo->u.sparse.num_va_pages = DIV_ROUND_UP(size, ZINK_SPARSE_BUFFER_PAGE_SIZE);
bo->u.sparse.commitments = CALLOC(bo->u.sparse.num_va_pages,
@ -525,7 +525,7 @@ error_alloc_commitments:
return NULL;
}
struct pb_buffer *
struct pb_buffer_lean *
zink_bo_create(struct zink_screen *screen, uint64_t size, unsigned alignment, enum zink_heap heap, enum zink_alloc_flag flags, unsigned mem_type_idx, const void *pNext)
{
struct zink_bo *bo;
@ -586,13 +586,13 @@ zink_bo_create(struct zink_screen *screen, uint64_t size, unsigned alignment, en
return NULL;
bo = container_of(entry, struct zink_bo, u.slab.entry);
assert(bo->base.base.placement == mem_type_idx);
pipe_reference_init(&bo->base.base.reference, 1);
bo->base.base.size = size;
assert(bo->base.placement == mem_type_idx);
pipe_reference_init(&bo->base.reference, 1);
bo->base.size = size;
memset(&bo->reads, 0, sizeof(bo->reads));
memset(&bo->writes, 0, sizeof(bo->writes));
bo->unique_id = p_atomic_inc_return(&screen->pb.next_bo_unique_id);
assert(alignment <= 1 << bo->base.base.alignment_log2);
assert(alignment <= 1 << bo->base.alignment_log2);
return &bo->base;
}
@ -619,7 +619,7 @@ no_slab:
/* Get a buffer from the cache. */
bo = (struct zink_bo*)
pb_cache_reclaim_buffer(&screen->pb.bo_cache, size, alignment, 0, mem_type_idx);
assert(!bo || bo->base.base.placement == mem_type_idx);
assert(!bo || bo->base.placement == mem_type_idx);
if (bo) {
memset(&bo->reads, 0, sizeof(bo->reads));
memset(&bo->writes, 0, sizeof(bo->writes));
@ -636,7 +636,7 @@ no_slab:
if (!bo)
return NULL;
}
assert(bo->base.base.placement == mem_type_idx);
assert(bo->base.placement == mem_type_idx);
return &bo->base;
}
@ -663,7 +663,7 @@ zink_bo_map(struct zink_screen *screen, struct zink_bo *bo)
* be atomic thanks to the lock. */
cpu = real->u.real.cpu_ptr;
if (!cpu) {
VkResult result = VKSCR(MapMemory)(screen->dev, real->mem, 0, real->base.base.size, 0, &cpu);
VkResult result = VKSCR(MapMemory)(screen->dev, real->mem, 0, real->base.size, 0, &cpu);
if (result != VK_SUCCESS) {
mesa_loge("ZINK: vkMapMemory failed (%s)", vk_Result_to_str(result));
simple_mtx_unlock(&real->lock);
@ -671,8 +671,8 @@ zink_bo_map(struct zink_screen *screen, struct zink_bo *bo)
return NULL;
}
if (unlikely(zink_debug & ZINK_DEBUG_MAP)) {
p_atomic_add(&screen->mapped_vram, real->base.base.size);
mesa_loge("NEW MAP(%"PRIu64") TOTAL(%"PRIu64")", real->base.base.size, screen->mapped_vram);
p_atomic_add(&screen->mapped_vram, real->base.size);
mesa_loge("NEW MAP(%"PRIu64") TOTAL(%"PRIu64")", real->base.size, screen->mapped_vram);
}
p_atomic_set(&real->u.real.cpu_ptr, cpu);
}
@ -695,8 +695,8 @@ zink_bo_unmap(struct zink_screen *screen, struct zink_bo *bo)
if (!p_atomic_read(&real->u.real.map_count)) {
p_atomic_set(&real->u.real.cpu_ptr, NULL);
if (unlikely(zink_debug & ZINK_DEBUG_MAP)) {
p_atomic_add(&screen->mapped_vram, -real->base.base.size);
mesa_loge("UNMAP(%"PRIu64") TOTAL(%"PRIu64")", real->base.base.size, screen->mapped_vram);
p_atomic_add(&screen->mapped_vram, -real->base.size);
mesa_loge("UNMAP(%"PRIu64") TOTAL(%"PRIu64")", real->base.size, screen->mapped_vram);
}
VKSCR(UnmapMemory)(screen->dev, real->mem);
}
@ -708,7 +708,7 @@ zink_bo_unmap(struct zink_screen *screen, struct zink_bo *bo)
static void
track_freed_sparse_bo(struct zink_context *ctx, struct zink_sparse_backing *backing)
{
pipe_reference(NULL, &backing->bo->base.base.reference);
pipe_reference(NULL, &backing->bo->base.reference);
util_dynarray_append(&ctx->bs->freed_sparse_backing_bos, backing->bo);
}
@ -788,8 +788,8 @@ buffer_bo_commit(struct zink_context *ctx, struct zink_resource *res, uint32_t o
struct zink_screen *screen = zink_screen(ctx->base.screen);
struct zink_bo *bo = res->obj->bo;
assert(offset % ZINK_SPARSE_BUFFER_PAGE_SIZE == 0);
assert(offset <= bo->base.base.size);
assert(size <= bo->base.base.size - offset);
assert(offset <= bo->base.size);
assert(size <= bo->base.size - offset);
assert(size % ZINK_SPARSE_BUFFER_PAGE_SIZE == 0 || offset + size == res->obj->size);
struct zink_sparse_commitment *comm = bo->u.sparse.commitments;
@ -1284,7 +1284,7 @@ bo_slab_alloc(void *priv, unsigned mem_type_idx, unsigned entry_size, unsigned g
if (!slab->buffer)
goto fail;
slab_size = slab->buffer->base.base.size;
slab_size = slab->buffer->base.size;
slab->base.num_entries = slab_size / entry_size;
slab->base.num_free = slab->base.num_entries;
@ -1300,8 +1300,8 @@ bo_slab_alloc(void *priv, unsigned mem_type_idx, unsigned entry_size, unsigned g
struct zink_bo *bo = &slab->entries[i];
simple_mtx_init(&bo->lock, mtx_plain);
bo->base.base.alignment_log2 = util_logbase2(get_slab_entry_alignment(screen, entry_size));
bo->base.base.size = entry_size;
bo->base.alignment_log2 = util_logbase2(get_slab_entry_alignment(screen, entry_size));
bo->base.size = entry_size;
bo->type = ZINK_BO_SLAB;
bo->offset = slab->buffer->offset + i * entry_size;
bo->u.slab.entry.slab = &slab->base;
@ -1314,7 +1314,7 @@ bo_slab_alloc(void *priv, unsigned mem_type_idx, unsigned entry_size, unsigned g
bo->u.slab.real = slab->buffer->u.slab.real;
assert(bo->u.slab.real->mem);
}
bo->base.base.placement = bo->u.slab.real->base.base.placement;
bo->base.placement = bo->u.slab.real->base.placement;
list_addtail(&bo->u.slab.entry.head, &slab->base.free);
}

6
src/gallium/drivers/zink/zink_bo.h
View file

@ -110,7 +110,7 @@ zink_bo_init(struct zink_screen *screen);
void
zink_bo_deinit(struct zink_screen *screen);
struct pb_buffer *
struct pb_buffer_lean *
zink_bo_create(struct zink_screen *screen, uint64_t size, unsigned alignment, enum zink_heap heap, enum zink_alloc_flag flags, unsigned mem_type_idx, const void *pNext);
void
@ -134,7 +134,7 @@ zink_bo_get_mem(const struct zink_bo *bo)
static ALWAYS_INLINE VkDeviceSize
zink_bo_get_size(const struct zink_bo *bo)
{
return bo->mem ? bo->base.base.size : bo->u.slab.real->base.base.size;
return bo->mem ? bo->base.size : bo->u.slab.real->base.size;
}
void *
@ -241,7 +241,7 @@ zink_bo_usage_unset(struct zink_bo *bo, struct zink_batch_state *bs)
static ALWAYS_INLINE void
zink_bo_unref(struct zink_screen *screen, struct zink_bo *bo)
{
if (pipe_reference(&bo->base.base.reference, NULL))
if (pipe_reference(&bo->base.reference, NULL))
zink_bo_destroy(screen, bo);
}

6
src/gallium/drivers/zink/zink_resource.c
View file

@ -1217,9 +1217,9 @@ update_obj_info(struct zink_screen *screen, struct zink_resource_object *obj,
obj->size = zink_bo_get_size(obj->bo);
}
obj->coherent = screen->info.mem_props.memoryTypes[obj->bo->base.base.placement].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
obj->coherent = screen->info.mem_props.memoryTypes[obj->bo->base.placement].propertyFlags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
if (!(templ->flags & PIPE_RESOURCE_FLAG_SPARSE)) {
obj->host_visible = screen->info.mem_props.memoryTypes[obj->bo->base.base.placement].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
obj->host_visible = screen->info.mem_props.memoryTypes[obj->bo->base.placement].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT;
}
}
@ -2678,7 +2678,7 @@ zink_buffer_map(struct pipe_context *pctx,
unsigned map_offset = box->x;
/* ideally never ever read or write to non-cached mem */
bool is_cached_mem = (screen->info.mem_props.memoryTypes[res->obj->bo->base.base.placement].propertyFlags & VK_STAGING_RAM) == VK_STAGING_RAM;
bool is_cached_mem = (screen->info.mem_props.memoryTypes[res->obj->bo->base.placement].propertyFlags & VK_STAGING_RAM) == VK_STAGING_RAM;
/* but this is only viable with a certain amount of vram since it may fully duplicate lots of large buffers */
bool host_mem_type_check = res->obj->host_visible;
if (screen->always_cached_upload)

4
src/gallium/drivers/zink/zink_types.h
View file

@ -708,7 +708,7 @@ enum zink_bo_type {
};
struct zink_bo {
struct pb_buffer base;
struct pb_buffer_lean base;
enum zink_bo_type type;
union {
@ -756,7 +756,7 @@ struct zink_bo {
};
static inline struct zink_bo *
zink_bo(struct pb_buffer *pbuf)
zink_bo(struct pb_buffer_lean *pbuf)
{
return (struct zink_bo*)pbuf;
}