From 271a1d8dd9edd39345947674222cfb8c391bc230 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Marek=20Ol=C5=A1=C3=A1k?= Date: Mon, 11 Aug 2025 01:01:59 -0400 Subject: [PATCH] util/hash_table: don't allocate hash_table_u64::table, declare it statically We can use _mesa_hash_table_init instead of _mesa_hash_table_create. It doesn't have to be allocated. Reviewed-by: Gert Wollny Acked-by: Pierre-Eric Pelloux-Prayer Part-of: --- src/amd/vulkan/radv_shader.c | 4 +- .../drivers/d3d12/d3d12_resource_state.cpp | 2 +- src/gallium/drivers/radeonsi/si_sqtt.c | 2 +- src/microsoft/vulkan/dzn_meta.c | 2 +- src/util/hash_table.c | 52 ++++++++----------- src/util/hash_table.h | 4 +- src/util/mesa_cache_db.c | 12 ++--- src/vulkan/runtime/rmv/vk_rmv_common.c | 2 +- 8 files changed, 37 insertions(+), 43 deletions(-) diff --git a/src/amd/vulkan/radv_shader.c b/src/amd/vulkan/radv_shader.c index 600523a6615..11eb7abf02c 100644 --- a/src/amd/vulkan/radv_shader.c +++ b/src/amd/vulkan/radv_shader.c @@ -1186,13 +1186,13 @@ radv_free_shader_memory(struct radv_device *device, union radv_shader_arena_bloc if (device->capture_replay_arena_vas) { struct hash_entry *arena_entry = NULL; - hash_table_foreach (device->capture_replay_arena_vas->table, entry) { + hash_table_foreach (&device->capture_replay_arena_vas->table, entry) { if (entry->data == arena) { arena_entry = entry; break; } } - _mesa_hash_table_remove(device->capture_replay_arena_vas->table, arena_entry); + _mesa_hash_table_remove(&device->capture_replay_arena_vas->table, arena_entry); } free(arena); diff --git a/src/gallium/drivers/d3d12/d3d12_resource_state.cpp b/src/gallium/drivers/d3d12/d3d12_resource_state.cpp index 0acccb52b77..1a625291eb4 100644 --- a/src/gallium/drivers/d3d12/d3d12_resource_state.cpp +++ b/src/gallium/drivers/d3d12/d3d12_resource_state.cpp @@ -205,7 +205,7 @@ d3d12_context_state_table_init(struct d3d12_context *ctx) void d3d12_context_state_table_destroy(struct d3d12_context *ctx) { - hash_table_foreach(ctx->bo_state_table->table, entry) { + hash_table_foreach(&ctx->bo_state_table->table, entry) { d3d12_destroy_context_state_table_entry((d3d12_context_state_table_entry *)entry->data); free(entry->data); } diff --git a/src/gallium/drivers/radeonsi/si_sqtt.c b/src/gallium/drivers/radeonsi/si_sqtt.c index ce3789bd2be..80e0991aed3 100644 --- a/src/gallium/drivers/radeonsi/si_sqtt.c +++ b/src/gallium/drivers/radeonsi/si_sqtt.c @@ -412,7 +412,7 @@ void si_destroy_sqtt(struct si_context *sctx) ac_sqtt_finish(sctx->sqtt); - hash_table_foreach (sctx->sqtt->pipeline_bos->table, entry) { + hash_table_foreach (&sctx->sqtt->pipeline_bos->table, entry) { struct si_sqtt_fake_pipeline *pipeline = (struct si_sqtt_fake_pipeline *)entry->data; si_resource_reference(&pipeline->bo, NULL); diff --git a/src/microsoft/vulkan/dzn_meta.c b/src/microsoft/vulkan/dzn_meta.c index cfadb5b36ed..8c50b59cad6 100644 --- a/src/microsoft/vulkan/dzn_meta.c +++ b/src/microsoft/vulkan/dzn_meta.c @@ -763,7 +763,7 @@ dzn_meta_blits_finish(struct dzn_device *device) } if (meta->contexts) { - hash_table_foreach(meta->contexts->table, he) + hash_table_foreach(&meta->contexts->table, he) dzn_meta_blit_destroy(device, he->data); _mesa_hash_table_u64_destroy(meta->contexts); } diff --git a/src/util/hash_table.c b/src/util/hash_table.c index 90122c88876..1f930943751 100644 --- a/src/util/hash_table.c +++ b/src/util/hash_table.c @@ -882,11 +882,10 @@ _mesa_hash_table_u64_create(void *mem_ctx) return NULL; if (sizeof(void *) == 8) { - ht->table = _mesa_hash_table_create(ht, _mesa_hash_pointer, - _mesa_key_pointer_equal); + _mesa_hash_table_init(&ht->table, ht, _mesa_hash_pointer, + _mesa_key_pointer_equal); } else { - ht->table = _mesa_hash_table_create(ht, key_u64_hash, - key_u64_equals); + _mesa_hash_table_init(&ht->table, ht, key_u64_hash, key_u64_equals); /* Allocate a ralloc sub-context which takes the u64 hash table * as a parent and attach a destructor to it so we can free the @@ -894,28 +893,25 @@ _mesa_hash_table_u64_create(void *mem_ctx) * _mesa_hash_table_u64_insert(). * * The order of creation of this sub-context is crucial: it needs - * to happen after the _mesa_hash_table_create() call to guarantee + * to happen after the _mesa_hash_table_init() call to guarantee * that the destructor is called before ht->table and its children * are freed, otherwise the _mesa_hash_table_u64_clear() call in the * destructor leads to a use-after-free situation. */ - if (ht->table) { - void *dummy_ctx = ralloc_context(ht); + void *dummy_ctx = ralloc_context(ht); - /* If we can't allocate a sub-context, free the hash table - * immediately and return NULL to avoid future leaks. - */ - if (!dummy_ctx) { - ralloc_free(ht); - return NULL; - } - - ralloc_set_destructor(dummy_ctx, _mesa_hash_table_u64_delete_keys); + /* If we can't allocate a sub-context, free the hash table + * immediately and return NULL to avoid future leaks. + */ + if (!dummy_ctx) { + ralloc_free(ht); + return NULL; } + + ralloc_set_destructor(dummy_ctx, _mesa_hash_table_u64_delete_keys); } - if (ht->table) - _mesa_hash_table_set_deleted_key(ht->table, uint_key(DELETED_KEY_VALUE)); + _mesa_hash_table_set_deleted_key(&ht->table, uint_key(DELETED_KEY_VALUE)); return ht; } @@ -938,7 +934,7 @@ _mesa_hash_table_u64_clear(struct hash_table_u64 *ht) if (!ht) return; - _mesa_hash_table_clear(ht->table, _mesa_hash_table_u64_delete_key); + _mesa_hash_table_clear(&ht->table, _mesa_hash_table_u64_delete_key); ht->freed_key_data = NULL; ht->deleted_key_data = NULL; } @@ -946,8 +942,6 @@ _mesa_hash_table_u64_clear(struct hash_table_u64 *ht) void _mesa_hash_table_u64_destroy(struct hash_table_u64 *ht) { - if (!ht) - return; ralloc_free(ht); } @@ -966,7 +960,7 @@ _mesa_hash_table_u64_insert(struct hash_table_u64 *ht, uint64_t key, } if (sizeof(void *) == 8) { - _mesa_hash_table_insert(ht->table, (void *)(uintptr_t)key, data); + _mesa_hash_table_insert(&ht->table, (void *)(uintptr_t)key, data); } else { struct hash_key_u64 *_key = CALLOC_STRUCT(hash_key_u64); @@ -975,7 +969,7 @@ _mesa_hash_table_u64_insert(struct hash_table_u64 *ht, uint64_t key, _key->value = key; struct hash_entry *entry = - hash_table_get_entry(ht->table, key_u64_hash(_key), _key); + hash_table_get_entry(&ht->table, key_u64_hash(_key), _key); if (!entry) { FREE(_key); @@ -983,7 +977,7 @@ _mesa_hash_table_u64_insert(struct hash_table_u64 *ht, uint64_t key, } entry->data = data; - if (!entry_is_present(ht->table, entry)) + if (!entry_is_present(&ht->table, entry)) entry->key = _key; else FREE(_key); @@ -994,10 +988,10 @@ static struct hash_entry * hash_table_u64_search(struct hash_table_u64 *ht, uint64_t key) { if (sizeof(void *) == 8) { - return _mesa_hash_table_search(ht->table, (void *)(uintptr_t)key); + return _mesa_hash_table_search(&ht->table, (void *)(uintptr_t)key); } else { struct hash_key_u64 _key = { .value = key }; - return _mesa_hash_table_search(ht->table, &_key); + return _mesa_hash_table_search(&ht->table, &_key); } } @@ -1039,11 +1033,11 @@ _mesa_hash_table_u64_remove(struct hash_table_u64 *ht, uint64_t key) return; if (sizeof(void *) == 8) { - _mesa_hash_table_remove(ht->table, entry); + _mesa_hash_table_remove(&ht->table, entry); } else { struct hash_key *_key = (struct hash_key *)entry->key; - _mesa_hash_table_remove(ht->table, entry); + _mesa_hash_table_remove(&ht->table, entry); FREE(_key); } } @@ -1074,7 +1068,7 @@ _mesa_hash_table_u64_next_entry(struct hash_table_u64 *ht, /* All other entries: regular */ struct hash_entry *next = - _mesa_hash_table_next_entry(ht->table, ent ? ent->_entry : NULL); + _mesa_hash_table_next_entry(&ht->table, ent ? ent->_entry : NULL); if (!next) return (struct hash_entry_u64){.data = NULL}; diff --git a/src/util/hash_table.h b/src/util/hash_table.h index 230668e8319..409c1118795 100644 --- a/src/util/hash_table.h +++ b/src/util/hash_table.h @@ -219,7 +219,7 @@ hash_table_call_foreach(struct hash_table *ht, * Hash table wrapper which supports 64-bit keys. */ struct hash_table_u64 { - struct hash_table *table; + struct hash_table table; void *freed_key_data; void *deleted_key_data; }; @@ -262,7 +262,7 @@ static inline uint32_t _mesa_hash_table_u64_num_entries(struct hash_table_u64 *ht) { return (!!ht->freed_key_data) + (!!ht->deleted_key_data) + - _mesa_hash_table_num_entries(ht->table); + _mesa_hash_table_num_entries(&ht->table); } /** diff --git a/src/util/mesa_cache_db.c b/src/util/mesa_cache_db.c index 575348fb46f..74ed9499153 100644 --- a/src/util/mesa_cache_db.c +++ b/src/util/mesa_cache_db.c @@ -296,9 +296,9 @@ mesa_db_update_index(struct mesa_cache_db *db) if (!mesa_db_seek(db->index.file, db->index.offset)) return false; - old_entries = _mesa_hash_table_num_entries(db->index_db->table); + old_entries = _mesa_hash_table_num_entries(&db->index_db->table); new_entries = (file_length - db->index.offset) / sizeof(*index_entries); - _mesa_hash_table_reserve(db->index_db->table, old_entries + new_entries); + _mesa_hash_table_reserve(&db->index_db->table, old_entries + new_entries); new_index_size = new_entries * sizeof(*index_entries); index_entries = malloc(new_index_size); @@ -542,7 +542,7 @@ mesa_db_compact(struct mesa_cache_db *db, int64_t blob_size, if (!remove_entry && !mesa_db_reload(db)) return false; - num_entries = _mesa_hash_table_num_entries(db->index_db->table); + num_entries = _mesa_hash_table_num_entries(&db->index_db->table); if (!num_entries) return true; @@ -563,7 +563,7 @@ mesa_db_compact(struct mesa_cache_db *db, int64_t blob_size, index_header.uuid != db->uuid) goto cleanup; - hash_table_foreach(db->index_db->table, entry) { + hash_table_foreach(&db->index_db->table, entry) { entries[i] = entry->data; entries[i]->evicted = (entries[i] == remove_entry); buffer_size = MAX2(buffer_size, blob_file_size(entries[i]->size)); @@ -1037,12 +1037,12 @@ mesa_cache_db_eviction_score(struct mesa_cache_db *db) if (!mesa_db_reload(db)) goto fail_fatal; - num_entries = _mesa_hash_table_num_entries(db->index_db->table); + num_entries = _mesa_hash_table_num_entries(&db->index_db->table); entries = calloc(num_entries, sizeof(*entries)); if (!entries) goto fail; - hash_table_foreach(db->index_db->table, entry) + hash_table_foreach(&db->index_db->table, entry) entries[i++] = entry->data; util_qsort_r(entries, num_entries, sizeof(*entries), diff --git a/src/vulkan/runtime/rmv/vk_rmv_common.c b/src/vulkan/runtime/rmv/vk_rmv_common.c index 48873d463c3..e058e9fe052 100644 --- a/src/vulkan/runtime/rmv/vk_rmv_common.c +++ b/src/vulkan/runtime/rmv/vk_rmv_common.c @@ -59,7 +59,7 @@ vk_memory_trace_finish(struct vk_device *device) } } util_dynarray_fini(&device->memory_trace_data.tokens); - if (_mesa_hash_table_num_entries(device->memory_trace_data.handle_table->table)) + if (_mesa_hash_table_num_entries(&device->memory_trace_data.handle_table->table)) fprintf(stderr, "mesa: Unfreed resources detected at device destroy, there may be memory leaks!\n"); _mesa_hash_table_u64_destroy(device->memory_trace_data.handle_table);