From 26faf1d5ab11a0782d5c6c8f48f9415701599771 Mon Sep 17 00:00:00 2001 From: Jelte Fennema-Nio Date: Thu, 4 Dec 2025 15:36:19 +0100 Subject: [PATCH v3 2/5] Use hash_make macros throughout the codebase This shows how our code base looks when using the new APIs. This has some typesafety, readability and maintanability benefits, but it also introduces some backpatching problems. These backpatching problems cannot be resolved by backporting the new hash_make macros, because some of them require C11 (which we only require on master for now). I think it's unlikely that we'll need to backpatch things in code that creates hashtables though, so it could still be worth it to do this complete refactor. At the very least we should choose a few places where we use the new macros to make sure they have coverage. --- contrib/dblink/dblink.c | 10 +-- .../pg_stat_statements/pg_stat_statements.c | 10 +-- contrib/pg_trgm/trgm_regexp.c | 9 +-- contrib/postgres_fdw/connection.c | 10 +-- contrib/postgres_fdw/shippable.c | 10 ++- contrib/tablefunc/tablefunc.c | 17 ++--- src/backend/access/common/heaptuple.c | 13 +--- src/backend/access/gist/gistbuild.c | 11 +--- src/backend/access/gist/gistbuildbuffers.c | 10 +-- src/backend/access/hash/hashpage.c | 13 +--- src/backend/access/heap/rewriteheap.c | 39 ++++------- src/backend/access/transam/xlogprefetcher.c | 8 +-- src/backend/access/transam/xlogutils.c | 13 ++-- src/backend/catalog/pg_enum.c | 24 ++----- src/backend/catalog/pg_inherits.c | 11 +--- src/backend/catalog/storage.c | 21 ++---- src/backend/commands/async.c | 14 ++-- src/backend/commands/prepare.c | 12 +--- src/backend/commands/sequence.c | 10 +-- src/backend/commands/tablecmds.c | 16 +---- src/backend/executor/nodeModifyTable.c | 10 +-- src/backend/nodes/extensible.c | 10 +-- src/backend/optimizer/util/plancat.c | 17 ++--- src/backend/optimizer/util/predtest.c | 9 +-- src/backend/optimizer/util/relnode.c | 13 +--- src/backend/parser/parse_oper.c | 10 ++- src/backend/partitioning/partdesc.c | 9 +-- src/backend/postmaster/autovacuum.c | 22 ++----- src/backend/postmaster/checkpointer.c | 12 +--- .../replication/logical/applyparallelworker.c | 13 +--- src/backend/replication/logical/relation.c | 22 ++----- .../replication/logical/reorderbuffer.c | 29 ++------ src/backend/replication/logical/tablesync.c | 10 ++- src/backend/replication/pgoutput/pgoutput.c | 11 +--- src/backend/storage/buffer/buf_table.c | 15 ++--- src/backend/storage/buffer/bufmgr.c | 11 ++-- src/backend/storage/buffer/localbuf.c | 11 +--- src/backend/storage/file/reinit.c | 8 +-- src/backend/storage/ipc/shmem.c | 33 +++++++--- src/backend/storage/ipc/standby.c | 20 ++---- src/backend/storage/lmgr/lock.c | 55 +++++----------- src/backend/storage/lmgr/lwlock.c | 8 +-- src/backend/storage/lmgr/predicate.c | 66 ++++++++----------- src/backend/storage/smgr/smgr.c | 10 ++- src/backend/storage/sync/sync.c | 11 +--- src/backend/tsearch/ts_typanalyze.c | 13 +--- src/backend/utils/activity/wait_event.c | 23 +++---- src/backend/utils/adt/array_typanalyze.c | 23 ++----- src/backend/utils/adt/json.c | 15 +---- src/backend/utils/adt/jsonfuncs.c | 20 ++---- src/backend/utils/adt/mcxtfuncs.c | 11 +--- src/backend/utils/adt/ri_triggers.c | 29 ++++---- src/backend/utils/adt/ruleutils.c | 23 ++----- src/backend/utils/cache/attoptcache.c | 16 ++--- src/backend/utils/cache/evtcache.c | 9 +-- src/backend/utils/cache/funccache.c | 14 ++-- src/backend/utils/cache/relcache.c | 19 ++---- src/backend/utils/cache/relfilenumbermap.c | 9 +-- src/backend/utils/cache/spccache.c | 9 +-- src/backend/utils/cache/ts_cache.c | 27 +++----- src/backend/utils/cache/typcache.c | 33 ++++------ src/backend/utils/fmgr/dfmgr.c | 12 ++-- src/backend/utils/fmgr/fmgr.c | 11 +--- src/backend/utils/misc/guc.c | 14 ++-- src/backend/utils/misc/injection_point.c | 14 ++-- src/backend/utils/mmgr/portalmem.c | 10 +-- src/backend/utils/time/combocid.c | 13 +--- src/pl/plperl/plperl.c | 32 +++------ src/pl/plpgsql/src/pl_exec.c | 32 ++++----- src/pl/plpython/plpy_plpymodule.c | 9 ++- src/pl/plpython/plpy_procedure.c | 9 +-- src/pl/tcl/pltcl.c | 19 ++---- src/timezone/pgtz.c | 12 +--- 73 files changed, 371 insertions(+), 835 deletions(-) diff --git a/contrib/dblink/dblink.c b/contrib/dblink/dblink.c index 8bf8fc8ea2f..2951c39d69f 100644 --- a/contrib/dblink/dblink.c +++ b/contrib/dblink/dblink.c @@ -2540,13 +2540,9 @@ getConnectionByName(const char *name) static HTAB * createConnHash(void) { - HASHCTL ctl; - - ctl.keysize = NAMEDATALEN; - ctl.entrysize = sizeof(remoteConnHashEnt); - - return hash_create("Remote Con hash", NUMCONN, &ctl, - HASH_ELEM | HASH_STRINGS); + return hash_make_cxt(remoteConnHashEnt, name, + "Remote Con hash", NUMCONN, + TopMemoryContext); } static remoteConn * diff --git a/contrib/pg_stat_statements/pg_stat_statements.c b/contrib/pg_stat_statements/pg_stat_statements.c index 39208f80b5b..2c55b78e9ba 100644 --- a/contrib/pg_stat_statements/pg_stat_statements.c +++ b/contrib/pg_stat_statements/pg_stat_statements.c @@ -517,7 +517,6 @@ static void pgss_shmem_startup(void) { bool found; - HASHCTL info; FILE *file = NULL; FILE *qfile = NULL; uint32 header; @@ -557,12 +556,9 @@ pgss_shmem_startup(void) pgss->stats.stats_reset = GetCurrentTimestamp(); } - info.keysize = sizeof(pgssHashKey); - info.entrysize = sizeof(pgssEntry); - pgss_hash = ShmemInitHash("pg_stat_statements hash", - pgss_max, pgss_max, - &info, - HASH_ELEM | HASH_BLOBS); + pgss_hash = shmem_hash_make(pgssEntry, key, + "pg_stat_statements hash", + pgss_max, pgss_max); LWLockRelease(AddinShmemInitLock); diff --git a/contrib/pg_trgm/trgm_regexp.c b/contrib/pg_trgm/trgm_regexp.c index 1a76794c422..df7d3b70d04 100644 --- a/contrib/pg_trgm/trgm_regexp.c +++ b/contrib/pg_trgm/trgm_regexp.c @@ -893,7 +893,6 @@ convertPgWchar(pg_wchar c, trgm_mb_char *result) static void transformGraph(TrgmNFA *trgmNFA) { - HASHCTL hashCtl; TrgmStateKey initkey; TrgmState *initstate; ListCell *lc; @@ -905,13 +904,7 @@ transformGraph(TrgmNFA *trgmNFA) trgmNFA->overflowed = false; /* Create hashtable for states */ - hashCtl.keysize = sizeof(TrgmStateKey); - hashCtl.entrysize = sizeof(TrgmState); - hashCtl.hcxt = CurrentMemoryContext; - trgmNFA->states = hash_create("Trigram NFA", - 1024, - &hashCtl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + trgmNFA->states = hash_make(TrgmState, stateKey, "Trigram NFA", 1024); trgmNFA->nstates = 0; /* Create initial state: ambiguous prefix, NFA's initial state */ diff --git a/contrib/postgres_fdw/connection.c b/contrib/postgres_fdw/connection.c index 953c2e0ab82..042a7fb3ac1 100644 --- a/contrib/postgres_fdw/connection.c +++ b/contrib/postgres_fdw/connection.c @@ -214,17 +214,13 @@ GetConnection(UserMapping *user, bool will_prep_stmt, PgFdwConnState **state) /* First time through, initialize connection cache hashtable */ if (ConnectionHash == NULL) { - HASHCTL ctl; - if (pgfdw_we_get_result == 0) pgfdw_we_get_result = WaitEventExtensionNew("PostgresFdwGetResult"); - ctl.keysize = sizeof(ConnCacheKey); - ctl.entrysize = sizeof(ConnCacheEntry); - ConnectionHash = hash_create("postgres_fdw connections", 8, - &ctl, - HASH_ELEM | HASH_BLOBS); + ConnectionHash = hash_make_cxt(ConnCacheEntry, key, + "postgres_fdw connections", 8, + TopMemoryContext); /* * Register some callback functions that manage connection cleanup. diff --git a/contrib/postgres_fdw/shippable.c b/contrib/postgres_fdw/shippable.c index da3b13b207d..66d2d0b9ff4 100644 --- a/contrib/postgres_fdw/shippable.c +++ b/contrib/postgres_fdw/shippable.c @@ -28,6 +28,7 @@ #include "postgres_fdw.h" #include "utils/hsearch.h" #include "utils/inval.h" +#include "utils/memutils.h" #include "utils/syscache.h" /* Hash table for caching the results of shippability lookups */ @@ -90,13 +91,10 @@ InvalidateShippableCacheCallback(Datum arg, int cacheid, uint32 hashvalue) static void InitializeShippableCache(void) { - HASHCTL ctl; - /* Create the hash table. */ - ctl.keysize = sizeof(ShippableCacheKey); - ctl.entrysize = sizeof(ShippableCacheEntry); - ShippableCacheHash = - hash_create("Shippability cache", 256, &ctl, HASH_ELEM | HASH_BLOBS); + ShippableCacheHash = hash_make_cxt(ShippableCacheEntry, key, + "Shippability cache", 256, + TopMemoryContext); /* Set up invalidation callback on pg_foreign_server. */ CacheRegisterSyscacheCallback(FOREIGNSERVEROID, diff --git a/contrib/tablefunc/tablefunc.c b/contrib/tablefunc/tablefunc.c index c40fd36dc96..519855189cf 100644 --- a/contrib/tablefunc/tablefunc.c +++ b/contrib/tablefunc/tablefunc.c @@ -705,24 +705,17 @@ static HTAB * load_categories_hash(char *cats_sql, MemoryContext per_query_ctx) { HTAB *crosstab_hash; - HASHCTL ctl; int ret; uint64 proc; MemoryContext SPIcontext; - /* initialize the category hash table */ - ctl.keysize = MAX_CATNAME_LEN; - ctl.entrysize = sizeof(crosstab_HashEnt); - ctl.hcxt = per_query_ctx; - /* - * use INIT_CATS, defined above as a guess of how many hash table entries - * to create, initially + * Initialize the category hash table. Use INIT_CATS, defined above as a + * guess of how many hash table entries to create, initially. */ - crosstab_hash = hash_create("crosstab hash", - INIT_CATS, - &ctl, - HASH_ELEM | HASH_STRINGS | HASH_CONTEXT); + crosstab_hash = hash_make_cxt(crosstab_HashEnt, internal_catname, + "crosstab hash", INIT_CATS, + per_query_ctx); /* Connect to SPI manager */ SPI_connect(); diff --git a/src/backend/access/common/heaptuple.c b/src/backend/access/common/heaptuple.c index 1967b047020..98793a3f2eb 100644 --- a/src/backend/access/common/heaptuple.c +++ b/src/backend/access/common/heaptuple.c @@ -125,18 +125,9 @@ missing_match(const void *key1, const void *key2, Size keysize) static void init_missing_cache(void) { - HASHCTL hash_ctl; - - hash_ctl.keysize = sizeof(missing_cache_key); - hash_ctl.entrysize = sizeof(missing_cache_key); - hash_ctl.hcxt = TopMemoryContext; - hash_ctl.hash = missing_hash; - hash_ctl.match = missing_match; missing_cache = - hash_create("Missing Values Cache", - 32, - &hash_ctl, - HASH_ELEM | HASH_CONTEXT | HASH_FUNCTION | HASH_COMPARE); + hashset_make_fn_cxt(missing_cache_key, "Missing Values Cache", 32, + missing_hash, missing_match, TopMemoryContext); } /* ---------------------------------------------------------------- diff --git a/src/backend/access/gist/gistbuild.c b/src/backend/access/gist/gistbuild.c index be0fd5b753d..629558d905b 100644 --- a/src/backend/access/gist/gistbuild.c +++ b/src/backend/access/gist/gistbuild.c @@ -1515,15 +1515,8 @@ typedef struct static void gistInitParentMap(GISTBuildState *buildstate) { - HASHCTL hashCtl; - - hashCtl.keysize = sizeof(BlockNumber); - hashCtl.entrysize = sizeof(ParentMapEntry); - hashCtl.hcxt = CurrentMemoryContext; - buildstate->parentMap = hash_create("gistbuild parent map", - 1024, - &hashCtl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + buildstate->parentMap = hash_make(ParentMapEntry, childblkno, + "gistbuild parent map", 1024); } static void diff --git a/src/backend/access/gist/gistbuildbuffers.c b/src/backend/access/gist/gistbuildbuffers.c index 0707254d18e..fc36c90d333 100644 --- a/src/backend/access/gist/gistbuildbuffers.c +++ b/src/backend/access/gist/gistbuildbuffers.c @@ -44,7 +44,6 @@ GISTBuildBuffers * gistInitBuildBuffers(int pagesPerBuffer, int levelStep, int maxLevel) { GISTBuildBuffers *gfbb; - HASHCTL hashCtl; gfbb = palloc(sizeof(GISTBuildBuffers)); gfbb->pagesPerBuffer = pagesPerBuffer; @@ -72,13 +71,8 @@ gistInitBuildBuffers(int pagesPerBuffer, int levelStep, int maxLevel) * nodeBuffersTab hash is association between index blocks and it's * buffers. */ - hashCtl.keysize = sizeof(BlockNumber); - hashCtl.entrysize = sizeof(GISTNodeBuffer); - hashCtl.hcxt = CurrentMemoryContext; - gfbb->nodeBuffersTab = hash_create("gistbuildbuffers", - 1024, - &hashCtl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + gfbb->nodeBuffersTab = hash_make(GISTNodeBuffer, nodeBlocknum, + "gistbuildbuffers", 1024); gfbb->bufferEmptyingQueue = NIL; diff --git a/src/backend/access/hash/hashpage.c b/src/backend/access/hash/hashpage.c index b8e5bd005e5..cf71fa9cb4f 100644 --- a/src/backend/access/hash/hashpage.c +++ b/src/backend/access/hash/hashpage.c @@ -1356,7 +1356,6 @@ void _hash_finish_split(Relation rel, Buffer metabuf, Buffer obuf, Bucket obucket, uint32 maxbucket, uint32 highmask, uint32 lowmask) { - HASHCTL hash_ctl; HTAB *tidhtab; Buffer bucket_nbuf = InvalidBuffer; Buffer nbuf; @@ -1367,16 +1366,8 @@ _hash_finish_split(Relation rel, Buffer metabuf, Buffer obuf, Bucket obucket, Bucket nbucket; bool found; - /* Initialize hash tables used to track TIDs */ - hash_ctl.keysize = sizeof(ItemPointerData); - hash_ctl.entrysize = sizeof(ItemPointerData); - hash_ctl.hcxt = CurrentMemoryContext; - - tidhtab = - hash_create("bucket ctids", - 256, /* arbitrary initial size */ - &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + /* Initialize hash tables used to track TIDs (with arbitrary initial size) */ + tidhtab = hashset_make(ItemPointerData, "bucket ctids", 256); bucket_nblkno = nblkno = _hash_get_newblock_from_oldbucket(rel, obucket); diff --git a/src/backend/access/heap/rewriteheap.c b/src/backend/access/heap/rewriteheap.c index 66ab48f0fe0..dc2c46742fd 100644 --- a/src/backend/access/heap/rewriteheap.c +++ b/src/backend/access/heap/rewriteheap.c @@ -237,7 +237,6 @@ begin_heap_rewrite(Relation old_heap, Relation new_heap, TransactionId oldest_xm RewriteState state; MemoryContext rw_cxt; MemoryContext old_cxt; - HASHCTL hash_ctl; /* * To ease cleanup, make a separate context that will contain the @@ -262,24 +261,19 @@ begin_heap_rewrite(Relation old_heap, Relation new_heap, TransactionId oldest_xm state->rs_cxt = rw_cxt; state->rs_bulkstate = smgr_bulk_start_rel(new_heap, MAIN_FORKNUM); - /* Initialize hash tables used to track update chains */ - hash_ctl.keysize = sizeof(TidHashKey); - hash_ctl.entrysize = sizeof(UnresolvedTupData); - hash_ctl.hcxt = state->rs_cxt; - + /* + * Initialize hash tables used to track update chains (with arbitrary + * initial sizes) + */ state->rs_unresolved_tups = - hash_create("Rewrite / Unresolved ctids", - 128, /* arbitrary initial size */ - &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); - - hash_ctl.entrysize = sizeof(OldToNewMappingData); + hash_make_cxt(UnresolvedTupData, key, + "Rewrite / Unresolved ctids", 128, + state->rs_cxt); state->rs_old_new_tid_map = - hash_create("Rewrite / Old to new tid map", - 128, /* arbitrary initial size */ - &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + hash_make_cxt(OldToNewMappingData, key, + "Rewrite / Old to new tid map", 128, + state->rs_cxt); MemoryContextSwitchTo(old_cxt); @@ -757,7 +751,6 @@ raw_heap_insert(RewriteState state, HeapTuple tup) static void logical_begin_heap_rewrite(RewriteState state) { - HASHCTL hash_ctl; TransactionId logical_xmin; /* @@ -788,15 +781,11 @@ logical_begin_heap_rewrite(RewriteState state) state->rs_begin_lsn = GetXLogInsertRecPtr(); state->rs_num_rewrite_mappings = 0; - hash_ctl.keysize = sizeof(TransactionId); - hash_ctl.entrysize = sizeof(RewriteMappingFile); - hash_ctl.hcxt = state->rs_cxt; - state->rs_logical_mappings = - hash_create("Logical rewrite mapping", - 128, /* arbitrary initial size */ - &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + hash_make_cxt(RewriteMappingFile, xid, + "Logical rewrite mapping", + 128, /* arbitrary initial size */ + state->rs_cxt); } /* diff --git a/src/backend/access/transam/xlogprefetcher.c b/src/backend/access/transam/xlogprefetcher.c index ed3aacabc98..f790eea87ff 100644 --- a/src/backend/access/transam/xlogprefetcher.c +++ b/src/backend/access/transam/xlogprefetcher.c @@ -362,15 +362,13 @@ XLogPrefetcher * XLogPrefetcherAllocate(XLogReaderState *reader) { XLogPrefetcher *prefetcher; - HASHCTL ctl; prefetcher = palloc0(sizeof(XLogPrefetcher)); prefetcher->reader = reader; - ctl.keysize = sizeof(RelFileLocator); - ctl.entrysize = sizeof(XLogPrefetcherFilter); - prefetcher->filter_table = hash_create("XLogPrefetcherFilterTable", 1024, - &ctl, HASH_ELEM | HASH_BLOBS); + prefetcher->filter_table = hash_make_cxt(XLogPrefetcherFilter, rlocator, + "XLogPrefetcherFilterTable", 1024, + TopMemoryContext); dlist_init(&prefetcher->filter_queue); SharedStats->wal_distance = 0; diff --git a/src/backend/access/transam/xlogutils.c b/src/backend/access/transam/xlogutils.c index ce2a3e42146..9e24759f5cc 100644 --- a/src/backend/access/transam/xlogutils.c +++ b/src/backend/access/transam/xlogutils.c @@ -27,6 +27,7 @@ #include "storage/fd.h" #include "storage/smgr.h" #include "utils/hsearch.h" +#include "utils/memutils.h" #include "utils/rel.h" @@ -131,15 +132,9 @@ log_invalid_page(RelFileLocator locator, ForkNumber forkno, BlockNumber blkno, if (invalid_page_tab == NULL) { /* create hash table when first needed */ - HASHCTL ctl; - - ctl.keysize = sizeof(xl_invalid_page_key); - ctl.entrysize = sizeof(xl_invalid_page); - - invalid_page_tab = hash_create("XLOG invalid-page table", - 100, - &ctl, - HASH_ELEM | HASH_BLOBS); + invalid_page_tab = hash_make_cxt(xl_invalid_page, key, + "XLOG invalid-page table", 100, + TopMemoryContext); } /* we currently assume xl_invalid_page_key contains no padding */ diff --git a/src/backend/catalog/pg_enum.c b/src/backend/catalog/pg_enum.c index da9c2a46cfa..4787a61c7d3 100644 --- a/src/backend/catalog/pg_enum.c +++ b/src/backend/catalog/pg_enum.c @@ -267,15 +267,9 @@ EnumValuesDelete(Oid enumTypeOid) static void init_uncommitted_enum_types(void) { - HASHCTL hash_ctl; - - hash_ctl.keysize = sizeof(Oid); - hash_ctl.entrysize = sizeof(Oid); - hash_ctl.hcxt = TopTransactionContext; - uncommitted_enum_types = hash_create("Uncommitted enum types", - 32, - &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + uncommitted_enum_types = hashset_make_cxt(Oid, + "Uncommitted enum types", 32, + TopTransactionContext); } /* @@ -284,15 +278,9 @@ init_uncommitted_enum_types(void) static void init_uncommitted_enum_values(void) { - HASHCTL hash_ctl; - - hash_ctl.keysize = sizeof(Oid); - hash_ctl.entrysize = sizeof(Oid); - hash_ctl.hcxt = TopTransactionContext; - uncommitted_enum_values = hash_create("Uncommitted enum values", - 32, - &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + uncommitted_enum_values = hashset_make_cxt(Oid, + "Uncommitted enum values", 32, + TopTransactionContext); } /* diff --git a/src/backend/catalog/pg_inherits.c b/src/backend/catalog/pg_inherits.c index 929bb53b620..c78aa727f0b 100644 --- a/src/backend/catalog/pg_inherits.c +++ b/src/backend/catalog/pg_inherits.c @@ -256,19 +256,12 @@ find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, List **numparents) { /* hash table for O(1) rel_oid -> rel_numparents cell lookup */ HTAB *seen_rels; - HASHCTL ctl; List *rels_list, *rel_numparents; ListCell *l; - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(SeenRelsEntry); - ctl.hcxt = CurrentMemoryContext; - - seen_rels = hash_create("find_all_inheritors temporary table", - 32, /* start small and extend */ - &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + seen_rels = hash_make(SeenRelsEntry, rel_id, + "find_all_inheritors temporary table", 32); /* * We build a list starting with the given rel and adding all direct and diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c index c58e9418ac3..1d13b4a1f39 100644 --- a/src/backend/catalog/storage.c +++ b/src/backend/catalog/storage.c @@ -90,15 +90,9 @@ AddPendingSync(const RelFileLocator *rlocator) /* create the hash if not yet */ if (!pendingSyncHash) - { - HASHCTL ctl; - - ctl.keysize = sizeof(RelFileLocator); - ctl.entrysize = sizeof(PendingRelSync); - ctl.hcxt = TopTransactionContext; - pendingSyncHash = hash_create("pending sync hash", 16, &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); - } + pendingSyncHash = hash_make_cxt(PendingRelSync, rlocator, + "pending sync hash", 16, + TopTransactionContext); pending = hash_search(pendingSyncHash, rlocator, HASH_ENTER, &found); Assert(!found); @@ -600,7 +594,6 @@ void SerializePendingSyncs(Size maxSize, char *startAddress) { HTAB *tmphash; - HASHCTL ctl; HASH_SEQ_STATUS scan; PendingRelSync *sync; PendingRelDelete *delete; @@ -611,12 +604,8 @@ SerializePendingSyncs(Size maxSize, char *startAddress) goto terminate; /* Create temporary hash to collect active relfilelocators */ - ctl.keysize = sizeof(RelFileLocator); - ctl.entrysize = sizeof(RelFileLocator); - ctl.hcxt = CurrentMemoryContext; - tmphash = hash_create("tmp relfilelocators", - hash_get_num_entries(pendingSyncHash), &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + tmphash = hashset_make(RelFileLocator, "tmp relfilelocators", + hash_get_num_entries(pendingSyncHash)); /* collect all rlocator from pending syncs */ hash_seq_init(&scan, pendingSyncHash); diff --git a/src/backend/commands/async.c b/src/backend/commands/async.c index eb86402cae4..9a7c8d1fb95 100644 --- a/src/backend/commands/async.c +++ b/src/backend/commands/async.c @@ -2414,20 +2414,14 @@ AddEventToPendingNotifies(Notification *n) if (list_length(pendingNotifies->events) >= MIN_HASHABLE_NOTIFIES && pendingNotifies->hashtab == NULL) { - HASHCTL hash_ctl; ListCell *l; /* Create the hash table */ - hash_ctl.keysize = sizeof(Notification *); - hash_ctl.entrysize = sizeof(struct NotificationHash); - hash_ctl.hash = notification_hash; - hash_ctl.match = notification_match; - hash_ctl.hcxt = CurTransactionContext; pendingNotifies->hashtab = - hash_create("Pending Notifies", - 256L, - &hash_ctl, - HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_CONTEXT); + hash_make_fn_cxt(struct NotificationHash, event, + "Pending Notifies", 256, + notification_hash, notification_match, + CurTransactionContext); /* Insert all the already-existing events */ foreach(l, pendingNotifies->events) diff --git a/src/backend/commands/prepare.c b/src/backend/commands/prepare.c index 34b6410d6a2..0002c6dc993 100644 --- a/src/backend/commands/prepare.c +++ b/src/backend/commands/prepare.c @@ -371,15 +371,9 @@ EvaluateParams(ParseState *pstate, PreparedStatement *pstmt, List *params, static void InitQueryHashTable(void) { - HASHCTL hash_ctl; - - hash_ctl.keysize = NAMEDATALEN; - hash_ctl.entrysize = sizeof(PreparedStatement); - - prepared_queries = hash_create("Prepared Queries", - 32, - &hash_ctl, - HASH_ELEM | HASH_STRINGS); + prepared_queries = hash_make_cxt(PreparedStatement, stmt_name, + "Prepared Queries", 32, + TopMemoryContext); } /* diff --git a/src/backend/commands/sequence.c b/src/backend/commands/sequence.c index 51567994126..5fbb3ce9030 100644 --- a/src/backend/commands/sequence.c +++ b/src/backend/commands/sequence.c @@ -1113,13 +1113,9 @@ lock_and_open_sequence(SeqTable seq) static void create_seq_hashtable(void) { - HASHCTL ctl; - - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(SeqTableData); - - seqhashtab = hash_create("Sequence values", 16, &ctl, - HASH_ELEM | HASH_BLOBS); + seqhashtab = hash_make_cxt(SeqTableData, relid, + "Sequence values", 16, + TopMemoryContext); } /* diff --git a/src/backend/commands/tablecmds.c b/src/backend/commands/tablecmds.c index 07e5b95782e..7f0fb263772 100644 --- a/src/backend/commands/tablecmds.c +++ b/src/backend/commands/tablecmds.c @@ -2154,19 +2154,9 @@ ExecuteTruncateGuts(List *explicit_rels, /* First time through, initialize hashtable for foreign tables */ if (!ft_htab) - { - HASHCTL hctl; - - memset(&hctl, 0, sizeof(HASHCTL)); - hctl.keysize = sizeof(Oid); - hctl.entrysize = sizeof(ForeignTruncateInfo); - hctl.hcxt = CurrentMemoryContext; - - ft_htab = hash_create("TRUNCATE for Foreign Tables", - 32, /* start small and extend */ - &hctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); - } + ft_htab = hash_make(ForeignTruncateInfo, serverid, + "TRUNCATE for Foreign Tables", + 32); /* start small and extend */ /* Find or create cached entry for the foreign table */ ft_info = hash_search(ft_htab, &serverid, HASH_ENTER, &found); diff --git a/src/backend/executor/nodeModifyTable.c b/src/backend/executor/nodeModifyTable.c index e44f1223886..537901ad5a0 100644 --- a/src/backend/executor/nodeModifyTable.c +++ b/src/backend/executor/nodeModifyTable.c @@ -5134,15 +5134,9 @@ ExecInitModifyTable(ModifyTable *node, EState *estate, int eflags) #endif if (nrels >= MT_NRELS_HASH) { - HASHCTL hash_ctl; - - hash_ctl.keysize = sizeof(Oid); - hash_ctl.entrysize = sizeof(MTTargetRelLookup); - hash_ctl.hcxt = CurrentMemoryContext; mtstate->mt_resultOidHash = - hash_create("ModifyTable target hash", - nrels, &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + hash_make(MTTargetRelLookup, relationOid, + "ModifyTable target hash", nrels); for (i = 0; i < nrels; i++) { Oid hashkey; diff --git a/src/backend/nodes/extensible.c b/src/backend/nodes/extensible.c index 3ede1ee0f5d..1c0e2b20cd1 100644 --- a/src/backend/nodes/extensible.c +++ b/src/backend/nodes/extensible.c @@ -22,6 +22,7 @@ #include "nodes/extensible.h" #include "utils/hsearch.h" +#include "utils/memutils.h" static HTAB *extensible_node_methods = NULL; static HTAB *custom_scan_methods = NULL; @@ -45,13 +46,8 @@ RegisterExtensibleNodeEntry(HTAB **p_htable, const char *htable_label, if (*p_htable == NULL) { - HASHCTL ctl; - - ctl.keysize = EXTNODENAME_MAX_LEN; - ctl.entrysize = sizeof(ExtensibleNodeEntry); - - *p_htable = hash_create(htable_label, 100, &ctl, - HASH_ELEM | HASH_STRINGS); + *p_htable = hash_make_cxt(ExtensibleNodeEntry, extnodename, + htable_label, 100, TopMemoryContext); } if (strlen(extnodename) >= EXTNODENAME_MAX_LEN) diff --git a/src/backend/optimizer/util/plancat.c b/src/backend/optimizer/util/plancat.c index 07f92fac239..32435933a93 100644 --- a/src/backend/optimizer/util/plancat.c +++ b/src/backend/optimizer/util/plancat.c @@ -694,19 +694,10 @@ get_relation_notnullatts(PlannerInfo *root, Relation relation) /* create the hash table if it hasn't been created yet */ if (root->glob->rel_notnullatts_hash == NULL) { - HTAB *hashtab; - HASHCTL hash_ctl; - - hash_ctl.keysize = sizeof(Oid); - hash_ctl.entrysize = sizeof(NotnullHashEntry); - hash_ctl.hcxt = CurrentMemoryContext; - - hashtab = hash_create("Relation NOT NULL attnums", - 64L, /* arbitrary initial size */ - &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); - - root->glob->rel_notnullatts_hash = hashtab; + root->glob->rel_notnullatts_hash = + hash_make(NotnullHashEntry, relid, + "Relation NOT NULL attnums", + 64L); /* arbitrary initial size */ } /* diff --git a/src/backend/optimizer/util/predtest.c b/src/backend/optimizer/util/predtest.c index ac28573cd0a..43291f128fd 100644 --- a/src/backend/optimizer/util/predtest.c +++ b/src/backend/optimizer/util/predtest.c @@ -2117,12 +2117,9 @@ lookup_proof_cache(Oid pred_op, Oid clause_op, bool refute_it) if (OprProofCacheHash == NULL) { /* First time through: initialize the hash table */ - HASHCTL ctl; - - ctl.keysize = sizeof(OprProofCacheKey); - ctl.entrysize = sizeof(OprProofCacheEntry); - OprProofCacheHash = hash_create("Btree proof lookup cache", 256, - &ctl, HASH_ELEM | HASH_BLOBS); + OprProofCacheHash = hash_make_cxt(OprProofCacheEntry, key, + "Btree proof lookup cache", 256, + TopMemoryContext); /* Arrange to flush cache on pg_amop changes */ CacheRegisterSyscacheCallback(AMOPOPID, diff --git a/src/backend/optimizer/util/relnode.c b/src/backend/optimizer/util/relnode.c index 1158bc194c3..3ed61fefb0a 100644 --- a/src/backend/optimizer/util/relnode.c +++ b/src/backend/optimizer/util/relnode.c @@ -601,19 +601,12 @@ static void build_join_rel_hash(PlannerInfo *root) { HTAB *hashtab; - HASHCTL hash_ctl; ListCell *l; /* Create the hash table */ - hash_ctl.keysize = sizeof(Relids); - hash_ctl.entrysize = sizeof(JoinHashEntry); - hash_ctl.hash = bitmap_hash; - hash_ctl.match = bitmap_match; - hash_ctl.hcxt = CurrentMemoryContext; - hashtab = hash_create("JoinRelHashTable", - 256L, - &hash_ctl, - HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_CONTEXT); + hashtab = hash_make_fn(JoinHashEntry, join_relids, + "JoinRelHashTable", 256, + bitmap_hash, bitmap_match); /* Insert all the already-existing joinrels */ foreach(l, root->join_rel_list) diff --git a/src/backend/parser/parse_oper.c b/src/backend/parser/parse_oper.c index 7bd7a336fd6..f9588865cfc 100644 --- a/src/backend/parser/parse_oper.c +++ b/src/backend/parser/parse_oper.c @@ -27,6 +27,7 @@ #include "utils/builtins.h" #include "utils/inval.h" #include "utils/lsyscache.h" +#include "utils/memutils.h" #include "utils/syscache.h" #include "utils/typcache.h" @@ -1028,12 +1029,9 @@ find_oper_cache_entry(OprCacheKey *key) if (OprCacheHash == NULL) { /* First time through: initialize the hash table */ - HASHCTL ctl; - - ctl.keysize = sizeof(OprCacheKey); - ctl.entrysize = sizeof(OprCacheEntry); - OprCacheHash = hash_create("Operator lookup cache", 256, - &ctl, HASH_ELEM | HASH_BLOBS); + OprCacheHash = hash_make_cxt(OprCacheEntry, key, + "Operator lookup cache", 256, + TopMemoryContext); /* Arrange to flush cache on pg_operator and pg_cast changes */ CacheRegisterSyscacheCallback(OPERNAMENSP, diff --git a/src/backend/partitioning/partdesc.c b/src/backend/partitioning/partdesc.c index 328b4d450e4..b3fbd781494 100644 --- a/src/backend/partitioning/partdesc.c +++ b/src/backend/partitioning/partdesc.c @@ -424,17 +424,12 @@ CreatePartitionDirectory(MemoryContext mcxt, bool omit_detached) { MemoryContext oldcontext = MemoryContextSwitchTo(mcxt); PartitionDirectory pdir; - HASHCTL ctl; pdir = palloc(sizeof(PartitionDirectoryData)); pdir->pdir_mcxt = mcxt; - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(PartitionDirectoryEntry); - ctl.hcxt = mcxt; - - pdir->pdir_hash = hash_create("partition directory", 256, &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + pdir->pdir_hash = hash_make_cxt(PartitionDirectoryEntry, reloid, + "partition directory", 256, mcxt); pdir->omit_detached = omit_detached; MemoryContextSwitchTo(oldcontext); diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index 1c38488f2cb..f1b6b1a24a9 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -907,7 +907,6 @@ rebuild_database_list(Oid newdb) MemoryContext newcxt; MemoryContext oldcxt; MemoryContext tmpcxt; - HASHCTL hctl; int score; int nelems; HTAB *dbhash; @@ -937,12 +936,10 @@ rebuild_database_list(Oid newdb) * score, and finally put the array elements into the new doubly linked * list. */ - hctl.keysize = sizeof(Oid); - hctl.entrysize = sizeof(avl_dbase); - hctl.hcxt = tmpcxt; - dbhash = hash_create("autovacuum db hash", 20, &hctl, /* magic number here - * FIXME */ - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + dbhash = hash_make_cxt(avl_dbase, adl_datid, + "autovacuum db hash", + 20, /* magic number here FIXME */ + tmpcxt); /* start by inserting the new database */ score = 0; @@ -1904,7 +1901,6 @@ do_autovacuum(void) Form_pg_database dbForm; List *table_oids = NIL; List *orphan_oids = NIL; - HASHCTL ctl; HTAB *table_toast_map; ListCell *volatile cell; BufferAccessStrategy bstrategy; @@ -1977,13 +1973,9 @@ do_autovacuum(void) pg_class_desc = CreateTupleDescCopy(RelationGetDescr(classRel)); /* create hash table for toast <-> main relid mapping */ - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(av_relation); - - table_toast_map = hash_create("TOAST to main relid map", - 100, - &ctl, - HASH_ELEM | HASH_BLOBS); + table_toast_map = hash_make_cxt(av_relation, ar_toastrelid, + "TOAST to main relid map", 100, + TopMemoryContext); /* * Scan pg_class to determine which tables to vacuum. diff --git a/src/backend/postmaster/checkpointer.c b/src/backend/postmaster/checkpointer.c index e84e8663e96..83bae2b75b6 100644 --- a/src/backend/postmaster/checkpointer.c +++ b/src/backend/postmaster/checkpointer.c @@ -1301,7 +1301,6 @@ CompactCheckpointerRequestQueue(void) int num_requests; int read_idx, write_idx; - HASHCTL ctl; HTAB *htab; bool *skip_slot; @@ -1321,14 +1320,9 @@ CompactCheckpointerRequestQueue(void) head = CheckpointerShmem->head; /* Initialize temporary hash table */ - ctl.keysize = sizeof(CheckpointerRequest); - ctl.entrysize = sizeof(struct CheckpointerSlotMapping); - ctl.hcxt = CurrentMemoryContext; - - htab = hash_create("CompactCheckpointerRequestQueue", - CheckpointerShmem->num_requests, - &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + htab = hash_make(struct CheckpointerSlotMapping, request, + "CompactCheckpointerRequestQueue", + CheckpointerShmem->num_requests); /* * The basic idea here is that a request can be skipped if it's followed diff --git a/src/backend/replication/logical/applyparallelworker.c b/src/backend/replication/logical/applyparallelworker.c index a4eb3962cb1..eadf5b67eb5 100644 --- a/src/backend/replication/logical/applyparallelworker.c +++ b/src/backend/replication/logical/applyparallelworker.c @@ -484,16 +484,9 @@ pa_allocate_worker(TransactionId xid) /* First time through, initialize parallel apply worker state hashtable. */ if (!ParallelApplyTxnHash) { - HASHCTL ctl; - - MemSet(&ctl, 0, sizeof(ctl)); - ctl.keysize = sizeof(TransactionId); - ctl.entrysize = sizeof(ParallelApplyWorkerEntry); - ctl.hcxt = ApplyContext; - - ParallelApplyTxnHash = hash_create("logical replication parallel apply workers hash", - 16, &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + ParallelApplyTxnHash = hash_make_cxt(ParallelApplyWorkerEntry, xid, + "logical replication parallel apply workers hash", + 16, ApplyContext); } /* Create an entry for the requested transaction. */ diff --git a/src/backend/replication/logical/relation.c b/src/backend/replication/logical/relation.c index 10b3d0d9b82..c4af85d74f1 100644 --- a/src/backend/replication/logical/relation.c +++ b/src/backend/replication/logical/relation.c @@ -104,8 +104,6 @@ logicalrep_relmap_invalidate_cb(Datum arg, Oid reloid) static void logicalrep_relmap_init(void) { - HASHCTL ctl; - if (!LogicalRepRelMapContext) LogicalRepRelMapContext = AllocSetContextCreate(CacheMemoryContext, @@ -113,12 +111,9 @@ logicalrep_relmap_init(void) ALLOCSET_DEFAULT_SIZES); /* Initialize the relation hash table. */ - ctl.keysize = sizeof(LogicalRepRelId); - ctl.entrysize = sizeof(LogicalRepRelMapEntry); - ctl.hcxt = LogicalRepRelMapContext; - - LogicalRepRelMap = hash_create("logicalrep relation map cache", 128, &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + LogicalRepRelMap = hash_make_cxt(LogicalRepRelMapEntry, remoterel.remoteid, + "logicalrep relation map cache", 128, + LogicalRepRelMapContext); /* Watch for invalidation events. */ CacheRegisterRelcacheCallback(logicalrep_relmap_invalidate_cb, @@ -610,8 +605,6 @@ logicalrep_partmap_reset_relmap(LogicalRepRelation *remoterel) static void logicalrep_partmap_init(void) { - HASHCTL ctl; - if (!LogicalRepPartMapContext) LogicalRepPartMapContext = AllocSetContextCreate(CacheMemoryContext, @@ -619,12 +612,9 @@ logicalrep_partmap_init(void) ALLOCSET_DEFAULT_SIZES); /* Initialize the relation hash table. */ - ctl.keysize = sizeof(Oid); /* partition OID */ - ctl.entrysize = sizeof(LogicalRepPartMapEntry); - ctl.hcxt = LogicalRepPartMapContext; - - LogicalRepPartMap = hash_create("logicalrep partition map cache", 64, &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + LogicalRepPartMap = hash_make_cxt(LogicalRepPartMapEntry, partoid, + "logicalrep partition map cache", 64, + LogicalRepPartMapContext); /* Watch for invalidation events. */ CacheRegisterRelcacheCallback(logicalrep_partmap_invalidate_cb, diff --git a/src/backend/replication/logical/reorderbuffer.c b/src/backend/replication/logical/reorderbuffer.c index eb6a84554b7..e09516d3d8b 100644 --- a/src/backend/replication/logical/reorderbuffer.c +++ b/src/backend/replication/logical/reorderbuffer.c @@ -324,7 +324,6 @@ ReorderBuffer * ReorderBufferAllocate(void) { ReorderBuffer *buffer; - HASHCTL hash_ctl; MemoryContext new_ctx; Assert(MyReplicationSlot != NULL); @@ -337,8 +336,6 @@ ReorderBufferAllocate(void) buffer = (ReorderBuffer *) MemoryContextAlloc(new_ctx, sizeof(ReorderBuffer)); - memset(&hash_ctl, 0, sizeof(hash_ctl)); - buffer->context = new_ctx; buffer->change_context = SlabContextCreate(new_ctx, @@ -367,12 +364,8 @@ ReorderBufferAllocate(void) SLAB_DEFAULT_BLOCK_SIZE, SLAB_DEFAULT_BLOCK_SIZE); - hash_ctl.keysize = sizeof(TransactionId); - hash_ctl.entrysize = sizeof(ReorderBufferTXNByIdEnt); - hash_ctl.hcxt = buffer->context; - - buffer->by_txn = hash_create("ReorderBufferByXid", 1000, &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + buffer->by_txn = hash_make_cxt(ReorderBufferTXNByIdEnt, xid, + "ReorderBufferByXid", 1000, buffer->context); buffer->by_txn_last_xid = InvalidTransactionId; buffer->by_txn_last_txn = NULL; @@ -1836,22 +1829,17 @@ static void ReorderBufferBuildTupleCidHash(ReorderBuffer *rb, ReorderBufferTXN *txn) { dlist_iter iter; - HASHCTL hash_ctl; if (!rbtxn_has_catalog_changes(txn) || dlist_is_empty(&txn->tuplecids)) return; - hash_ctl.keysize = sizeof(ReorderBufferTupleCidKey); - hash_ctl.entrysize = sizeof(ReorderBufferTupleCidEnt); - hash_ctl.hcxt = rb->context; - /* * create the hash with the exact number of to-be-stored tuplecids from * the start */ txn->tuplecid_hash = - hash_create("ReorderBufferTupleCid", txn->ntuplecids, &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + hash_make_cxt(ReorderBufferTupleCidEnt, key, + "ReorderBufferTupleCid", txn->ntuplecids, rb->context); dlist_foreach(iter, &txn->tuplecids) { @@ -4977,15 +4965,10 @@ StartupReorderBuffer(void) static void ReorderBufferToastInitHash(ReorderBuffer *rb, ReorderBufferTXN *txn) { - HASHCTL hash_ctl; - Assert(txn->toast_hash == NULL); - hash_ctl.keysize = sizeof(Oid); - hash_ctl.entrysize = sizeof(ReorderBufferToastEnt); - hash_ctl.hcxt = rb->context; - txn->toast_hash = hash_create("ReorderBufferToastHash", 5, &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + txn->toast_hash = hash_make_cxt(ReorderBufferToastEnt, chunk_id, + "ReorderBufferToastHash", 5, rb->context); } /* diff --git a/src/backend/replication/logical/tablesync.c b/src/backend/replication/logical/tablesync.c index 6bb0cbeedad..276b746b4db 100644 --- a/src/backend/replication/logical/tablesync.c +++ b/src/backend/replication/logical/tablesync.c @@ -117,6 +117,7 @@ #include "utils/array.h" #include "utils/builtins.h" #include "utils/lsyscache.h" +#include "utils/memutils.h" #include "utils/rls.h" #include "utils/snapmgr.h" #include "utils/syscache.h" @@ -390,12 +391,9 @@ ProcessSyncingTablesForApply(XLogRecPtr current_lsn) */ if (table_states_not_ready != NIL && !last_start_times) { - HASHCTL ctl; - - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(struct tablesync_start_time_mapping); - last_start_times = hash_create("Logical replication table sync worker start times", - 256, &ctl, HASH_ELEM | HASH_BLOBS); + last_start_times = hash_make_cxt(struct tablesync_start_time_mapping, relid, + "Logical replication table sync worker start times", + 256, TopMemoryContext); } /* diff --git a/src/backend/replication/pgoutput/pgoutput.c b/src/backend/replication/pgoutput/pgoutput.c index 942e1abdb58..6dea24ff0a6 100644 --- a/src/backend/replication/pgoutput/pgoutput.c +++ b/src/backend/replication/pgoutput/pgoutput.c @@ -1969,7 +1969,6 @@ pgoutput_stream_prepare_txn(LogicalDecodingContext *ctx, static void init_rel_sync_cache(MemoryContext cachectx) { - HASHCTL ctl; static bool relation_callbacks_registered = false; /* Nothing to do if hash table already exists */ @@ -1977,13 +1976,9 @@ init_rel_sync_cache(MemoryContext cachectx) return; /* Make a new hash table for the cache */ - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(RelationSyncEntry); - ctl.hcxt = cachectx; - - RelationSyncCache = hash_create("logical replication output relation cache", - 128, &ctl, - HASH_ELEM | HASH_CONTEXT | HASH_BLOBS); + RelationSyncCache = hash_make_cxt(RelationSyncEntry, relid, + "logical replication output relation cache", + 128, cachectx); Assert(RelationSyncCache != NULL); diff --git a/src/backend/storage/buffer/buf_table.c b/src/backend/storage/buffer/buf_table.c index 9d256559bab..bfcec855ff6 100644 --- a/src/backend/storage/buffer/buf_table.c +++ b/src/backend/storage/buffer/buf_table.c @@ -50,19 +50,16 @@ BufTableShmemSize(int size) void InitBufTable(int size) { - HASHCTL info; + HASHOPTS opts = {0}; /* assume no locking is needed yet */ /* BufferTag maps to Buffer */ - info.keysize = sizeof(BufferTag); - info.entrysize = sizeof(BufferLookupEnt); - info.num_partitions = NUM_BUFFER_PARTITIONS; - - SharedBufHash = ShmemInitHash("Shared Buffer Lookup Table", - size, size, - &info, - HASH_ELEM | HASH_BLOBS | HASH_PARTITION | HASH_FIXED_SIZE); + opts.num_partitions = NUM_BUFFER_PARTITIONS; + opts.fixed_size = true; + SharedBufHash = shmem_hash_make_ext(BufferLookupEnt, key, + "Shared Buffer Lookup Table", + size, size, &opts); } /* diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c index ce52d6ca81f..781738956af 100644 --- a/src/backend/storage/buffer/bufmgr.c +++ b/src/backend/storage/buffer/bufmgr.c @@ -62,6 +62,7 @@ #include "storage/smgr.h" #include "storage/standby.h" #include "utils/memdebug.h" +#include "utils/memutils.h" #include "utils/ps_status.h" #include "utils/rel.h" #include "utils/resowner.h" @@ -4006,8 +4007,6 @@ AtEOXact_Buffers(bool isCommit) void InitBufferManagerAccess(void) { - HASHCTL hash_ctl; - /* * An advisory limit on the number of pins each backend should hold, based * on shared_buffers and the maximum number of connections possible. @@ -4019,11 +4018,9 @@ InitBufferManagerAccess(void) memset(&PrivateRefCountArray, 0, sizeof(PrivateRefCountArray)); - hash_ctl.keysize = sizeof(Buffer); - hash_ctl.entrysize = sizeof(PrivateRefCountEntry); - - PrivateRefCountHash = hash_create("PrivateRefCount", 100, &hash_ctl, - HASH_ELEM | HASH_BLOBS); + PrivateRefCountHash = hash_make_cxt(PrivateRefCountEntry, buffer, + "PrivateRefCount", 100, + TopMemoryContext); /* * AtProcExit_Buffers needs LWLock access, and thereby has to be called at diff --git a/src/backend/storage/buffer/localbuf.c b/src/backend/storage/buffer/localbuf.c index 15aac7d1c9f..a66f2975a47 100644 --- a/src/backend/storage/buffer/localbuf.c +++ b/src/backend/storage/buffer/localbuf.c @@ -728,7 +728,6 @@ static void InitLocalBuffers(void) { int nbufs = num_temp_buffers; - HASHCTL info; int i; /* @@ -779,13 +778,9 @@ InitLocalBuffers(void) } /* Create the lookup hash table */ - info.keysize = sizeof(BufferTag); - info.entrysize = sizeof(LocalBufferLookupEnt); - - LocalBufHash = hash_create("Local Buffer Lookup Table", - nbufs, - &info, - HASH_ELEM | HASH_BLOBS); + LocalBufHash = hash_make_cxt(LocalBufferLookupEnt, key, + "Local Buffer Lookup Table", nbufs, + TopMemoryContext); if (!LocalBufHash) elog(ERROR, "could not initialize local buffer hash table"); diff --git a/src/backend/storage/file/reinit.c b/src/backend/storage/file/reinit.c index 5c8275cf536..a943982715b 100644 --- a/src/backend/storage/file/reinit.c +++ b/src/backend/storage/file/reinit.c @@ -175,7 +175,6 @@ ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op) if ((op & UNLOGGED_RELATION_CLEANUP) != 0) { HTAB *hash; - HASHCTL ctl; /* * It's possible that someone could create a ton of unlogged relations @@ -184,11 +183,8 @@ ResetUnloggedRelationsInDbspaceDir(const char *dbspacedirname, int op) * need to be reset. Otherwise, this cleanup operation would be * O(n^2). */ - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(unlogged_relation_entry); - ctl.hcxt = CurrentMemoryContext; - hash = hash_create("unlogged relation OIDs", 32, &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + hash = hash_make(unlogged_relation_entry, relnumber, + "unlogged relation OIDs", 32); /* Scan the directory. */ dbspace_dir = AllocateDir(dbspacedirname); diff --git a/src/backend/storage/ipc/shmem.c b/src/backend/storage/ipc/shmem.c index ee3408df301..2d4c518dec2 100644 --- a/src/backend/storage/ipc/shmem.c +++ b/src/backend/storage/ipc/shmem.c @@ -284,8 +284,6 @@ ShmemAddrIsValid(const void *addr) void InitShmemIndex(void) { - HASHCTL info; - /* * Create the shared memory shmem index. * @@ -294,13 +292,8 @@ InitShmemIndex(void) * initializing the ShmemIndex itself. The special "ShmemIndex" hash * table name will tell ShmemInitStruct to fake it. */ - info.keysize = SHMEM_INDEX_KEYSIZE; - info.entrysize = sizeof(ShmemIndexEnt); - - ShmemIndex = ShmemInitHash("ShmemIndex", - SHMEM_INDEX_SIZE, SHMEM_INDEX_SIZE, - &info, - HASH_ELEM | HASH_STRINGS); + ShmemIndex = shmem_hash_make(ShmemIndexEnt, key, "ShmemIndex", + SHMEM_INDEX_SIZE, SHMEM_INDEX_SIZE); } /* @@ -369,6 +362,28 @@ ShmemInitHash(const char *name, /* table string name for shmem index */ return hash_create(name, init_size, infoP, hash_flags); } +/* + * Implementation function for shmem_hash_make macros. + * + * Creates a shared memory hash table with simplified parameters. + * Pass NULL for opts to use all defaults. + */ +HTAB * +shmem_hash_make_impl(const char *name, int64 init_size, int64 max_size, + Size keysize, Size entrysize, bool string_key, + const HASHOPTS *opts) +{ + HASHCTL ctl; + int flags; + + /* Shared memory hash tables use ShmemAllocNoError, not a custom allocator */ + Assert(opts == NULL || opts->alloc == NULL); + + hash_opts_init(&ctl, &flags, keysize, entrysize, string_key, opts); + + return ShmemInitHash(name, init_size, max_size, &ctl, flags); +} + /* * ShmemInitStruct -- Create/attach to a structure in shared memory. * diff --git a/src/backend/storage/ipc/standby.c b/src/backend/storage/ipc/standby.c index fc45d72c79b..7b9f7e218aa 100644 --- a/src/backend/storage/ipc/standby.c +++ b/src/backend/storage/ipc/standby.c @@ -32,6 +32,7 @@ #include "storage/standby.h" #include "utils/hsearch.h" #include "utils/injection_point.h" +#include "utils/memutils.h" #include "utils/ps_status.h" #include "utils/timeout.h" #include "utils/timestamp.h" @@ -95,7 +96,6 @@ void InitRecoveryTransactionEnvironment(void) { VirtualTransactionId vxid; - HASHCTL hash_ctl; Assert(RecoveryLockHash == NULL); /* don't run this twice */ @@ -103,18 +103,12 @@ InitRecoveryTransactionEnvironment(void) * Initialize the hash tables for tracking the locks held by each * transaction. */ - hash_ctl.keysize = sizeof(xl_standby_lock); - hash_ctl.entrysize = sizeof(RecoveryLockEntry); - RecoveryLockHash = hash_create("RecoveryLockHash", - 64, - &hash_ctl, - HASH_ELEM | HASH_BLOBS); - hash_ctl.keysize = sizeof(TransactionId); - hash_ctl.entrysize = sizeof(RecoveryLockXidEntry); - RecoveryLockXidHash = hash_create("RecoveryLockXidHash", - 64, - &hash_ctl, - HASH_ELEM | HASH_BLOBS); + RecoveryLockHash = hash_make_cxt(RecoveryLockEntry, key, + "RecoveryLockHash", 64, + TopMemoryContext); + RecoveryLockXidHash = hash_make_cxt(RecoveryLockXidEntry, xid, + "RecoveryLockXidHash", 64, + TopMemoryContext); /* * Initialize shared invalidation management for Startup process, being diff --git a/src/backend/storage/lmgr/lock.c b/src/backend/storage/lmgr/lock.c index 9cb78ead105..e5ea54e7824 100644 --- a/src/backend/storage/lmgr/lock.c +++ b/src/backend/storage/lmgr/lock.c @@ -443,7 +443,7 @@ static void GetSingleProcBlockerStatusData(PGPROC *blocked_proc, void LockManagerShmemInit(void) { - HASHCTL info; + HASHOPTS opts; int64 init_table_size, max_table_size; bool found; @@ -459,15 +459,11 @@ LockManagerShmemInit(void) * Allocate hash table for LOCK structs. This stores per-locked-object * information. */ - info.keysize = sizeof(LOCKTAG); - info.entrysize = sizeof(LOCK); - info.num_partitions = NUM_LOCK_PARTITIONS; - - LockMethodLockHash = ShmemInitHash("LOCK hash", - init_table_size, - max_table_size, - &info, - HASH_ELEM | HASH_BLOBS | HASH_PARTITION); + MemSet(&opts, 0, sizeof(opts)); + opts.num_partitions = NUM_LOCK_PARTITIONS; + LockMethodLockHash = shmem_hash_make_ext(LOCK, tag, "LOCK hash", + init_table_size, max_table_size, + &opts); /* Assume an average of 2 holders per lock */ max_table_size *= 2; @@ -477,16 +473,12 @@ LockManagerShmemInit(void) * Allocate hash table for PROCLOCK structs. This stores * per-lock-per-holder information. */ - info.keysize = sizeof(PROCLOCKTAG); - info.entrysize = sizeof(PROCLOCK); - info.hash = proclock_hash; - info.num_partitions = NUM_LOCK_PARTITIONS; - - LockMethodProcLockHash = ShmemInitHash("PROCLOCK hash", - init_table_size, - max_table_size, - &info, - HASH_ELEM | HASH_FUNCTION | HASH_PARTITION); + MemSet(&opts, 0, sizeof(opts)); + opts.hash = proclock_hash; + opts.num_partitions = NUM_LOCK_PARTITIONS; + LockMethodProcLockHash = shmem_hash_make_ext(PROCLOCK, tag, "PROCLOCK hash", + init_table_size, max_table_size, + &opts); /* * Allocate fast-path structures. @@ -508,15 +500,9 @@ InitLockManagerAccess(void) * Allocate non-shared hash table for LOCALLOCK structs. This stores lock * counts and resource owner information. */ - HASHCTL info; - - info.keysize = sizeof(LOCALLOCKTAG); - info.entrysize = sizeof(LOCALLOCK); - - LockMethodLocalHash = hash_create("LOCALLOCK hash", - 16, - &info, - HASH_ELEM | HASH_BLOBS); + LockMethodLocalHash = hash_make_cxt(LOCALLOCK, tag, + "LOCALLOCK hash", 16, + TopMemoryContext); } @@ -3396,20 +3382,13 @@ CheckForSessionAndXactLocks(void) bool xactLock; /* is any lockmode held at xact level? */ } PerLockTagEntry; - HASHCTL hash_ctl; HTAB *lockhtab; HASH_SEQ_STATUS status; LOCALLOCK *locallock; /* Create a local hash table keyed by LOCKTAG only */ - hash_ctl.keysize = sizeof(LOCKTAG); - hash_ctl.entrysize = sizeof(PerLockTagEntry); - hash_ctl.hcxt = CurrentMemoryContext; - - lockhtab = hash_create("CheckForSessionAndXactLocks table", - 256, /* arbitrary initial size */ - &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + lockhtab = hash_make(PerLockTagEntry, lock, + "CheckForSessionAndXactLocks table", 256); /* Scan local lock table to find entries for each LOCKTAG */ hash_seq_init(&status, LockMethodLocalHash); diff --git a/src/backend/storage/lmgr/lwlock.c b/src/backend/storage/lmgr/lwlock.c index 255cfa8fa95..1f749beadce 100644 --- a/src/backend/storage/lmgr/lwlock.c +++ b/src/backend/storage/lmgr/lwlock.c @@ -285,7 +285,6 @@ static lwlock_stats * get_lwlock_stats_entry(LWLock *lock); static void init_lwlock_stats(void) { - HASHCTL ctl; static MemoryContext lwlock_stats_cxt = NULL; static bool exit_registered = false; @@ -305,11 +304,8 @@ init_lwlock_stats(void) ALLOCSET_DEFAULT_SIZES); MemoryContextAllowInCriticalSection(lwlock_stats_cxt, true); - ctl.keysize = sizeof(lwlock_stats_key); - ctl.entrysize = sizeof(lwlock_stats); - ctl.hcxt = lwlock_stats_cxt; - lwlock_stats_htab = hash_create("lwlock stats", 16384, &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + lwlock_stats_htab = hash_make_cxt(lwlock_stats, key, + "lwlock stats", 16384, lwlock_stats_cxt); if (!exit_registered) { on_shmem_exit(print_lwlock_stats, 0); diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c index f12f8f77aad..c2d85032716 100644 --- a/src/backend/storage/lmgr/predicate.c +++ b/src/backend/storage/lmgr/predicate.c @@ -212,6 +212,7 @@ #include "storage/proc.h" #include "storage/procarray.h" #include "utils/guc_hooks.h" +#include "utils/memutils.h" #include "utils/rel.h" #include "utils/snapmgr.h" @@ -1144,7 +1145,7 @@ CheckPointPredicate(void) void PredicateLockShmemInit(void) { - HASHCTL info; + HASHOPTS opts; int64 max_table_size; Size requestSize; bool found; @@ -1163,16 +1164,13 @@ PredicateLockShmemInit(void) * Allocate hash table for PREDICATELOCKTARGET structs. This stores * per-predicate-lock-target information. */ - info.keysize = sizeof(PREDICATELOCKTARGETTAG); - info.entrysize = sizeof(PREDICATELOCKTARGET); - info.num_partitions = NUM_PREDICATELOCK_PARTITIONS; - - PredicateLockTargetHash = ShmemInitHash("PREDICATELOCKTARGET hash", - max_table_size, - max_table_size, - &info, - HASH_ELEM | HASH_BLOBS | - HASH_PARTITION | HASH_FIXED_SIZE); + MemSet(&opts, 0, sizeof(opts)); + opts.num_partitions = NUM_PREDICATELOCK_PARTITIONS; + opts.fixed_size = true; + PredicateLockTargetHash = shmem_hash_make_ext(PREDICATELOCKTARGET, tag, + "PREDICATELOCKTARGET hash", + max_table_size, max_table_size, + &opts); /* * Reserve a dummy entry in the hash table; we use it to make sure there's @@ -1195,20 +1193,17 @@ PredicateLockShmemInit(void) * Allocate hash table for PREDICATELOCK structs. This stores per * xact-lock-of-a-target information. */ - info.keysize = sizeof(PREDICATELOCKTAG); - info.entrysize = sizeof(PREDICATELOCK); - info.hash = predicatelock_hash; - info.num_partitions = NUM_PREDICATELOCK_PARTITIONS; - /* Assume an average of 2 xacts per target */ max_table_size *= 2; - PredicateLockHash = ShmemInitHash("PREDICATELOCK hash", - max_table_size, - max_table_size, - &info, - HASH_ELEM | HASH_FUNCTION | - HASH_PARTITION | HASH_FIXED_SIZE); + MemSet(&opts, 0, sizeof(opts)); + opts.hash = predicatelock_hash; + opts.num_partitions = NUM_PREDICATELOCK_PARTITIONS; + opts.fixed_size = true; + PredicateLockHash = shmem_hash_make_ext(PREDICATELOCK, tag, + "PREDICATELOCK hash", + max_table_size, max_table_size, + &opts); /* * Compute size for serializable transaction hashtable. Note these @@ -1282,15 +1277,12 @@ PredicateLockShmemInit(void) * Allocate hash table for SERIALIZABLEXID structs. This stores per-xid * information for serializable transactions which have accessed data. */ - info.keysize = sizeof(SERIALIZABLEXIDTAG); - info.entrysize = sizeof(SERIALIZABLEXID); - - SerializableXidHash = ShmemInitHash("SERIALIZABLEXID hash", - max_table_size, - max_table_size, - &info, - HASH_ELEM | HASH_BLOBS | - HASH_FIXED_SIZE); + MemSet(&opts, 0, sizeof(opts)); + opts.fixed_size = true; + SerializableXidHash = shmem_hash_make_ext(SERIALIZABLEXID, tag, + "SERIALIZABLEXID hash", + max_table_size, max_table_size, + &opts); /* * Allocate space for tracking rw-conflicts in lists attached to the @@ -1939,16 +1931,12 @@ GetSerializableTransactionSnapshotInt(Snapshot snapshot, static void CreateLocalPredicateLockHash(void) { - HASHCTL hash_ctl; - /* Initialize the backend-local hash table of parent locks */ Assert(LocalPredicateLockHash == NULL); - hash_ctl.keysize = sizeof(PREDICATELOCKTARGETTAG); - hash_ctl.entrysize = sizeof(LOCALPREDICATELOCK); - LocalPredicateLockHash = hash_create("Local predicate lock", - max_predicate_locks_per_xact, - &hash_ctl, - HASH_ELEM | HASH_BLOBS); + LocalPredicateLockHash = hash_make_cxt(LOCALPREDICATELOCK, tag, + "Local predicate lock", + max_predicate_locks_per_xact, + TopMemoryContext); } /* diff --git a/src/backend/storage/smgr/smgr.c b/src/backend/storage/smgr/smgr.c index bce37a36d51..d4fa6a144f1 100644 --- a/src/backend/storage/smgr/smgr.c +++ b/src/backend/storage/smgr/smgr.c @@ -73,6 +73,7 @@ #include "storage/smgr.h" #include "utils/hsearch.h" #include "utils/inval.h" +#include "utils/memutils.h" /* @@ -250,12 +251,9 @@ smgropen(RelFileLocator rlocator, ProcNumber backend) if (SMgrRelationHash == NULL) { /* First time through: initialize the hash table */ - HASHCTL ctl; - - ctl.keysize = sizeof(RelFileLocatorBackend); - ctl.entrysize = sizeof(SMgrRelationData); - SMgrRelationHash = hash_create("smgr relation table", 400, - &ctl, HASH_ELEM | HASH_BLOBS); + SMgrRelationHash = hash_make_cxt(SMgrRelationData, smgr_rlocator, + "smgr relation table", 400, + TopMemoryContext); dlist_init(&unpinned_relns); } diff --git a/src/backend/storage/sync/sync.c b/src/backend/storage/sync/sync.c index fc16db90133..42b7fc11288 100644 --- a/src/backend/storage/sync/sync.c +++ b/src/backend/storage/sync/sync.c @@ -130,8 +130,6 @@ InitSync(void) */ if (!IsUnderPostmaster || AmCheckpointerProcess()) { - HASHCTL hash_ctl; - /* * XXX: The checkpointer needs to add entries to the pending ops table * when absorbing fsync requests. That is done within a critical @@ -146,13 +144,8 @@ InitSync(void) ALLOCSET_DEFAULT_SIZES); MemoryContextAllowInCriticalSection(pendingOpsCxt, true); - hash_ctl.keysize = sizeof(FileTag); - hash_ctl.entrysize = sizeof(PendingFsyncEntry); - hash_ctl.hcxt = pendingOpsCxt; - pendingOps = hash_create("Pending Ops Table", - 100L, - &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + pendingOps = hash_make_cxt(PendingFsyncEntry, tag, + "Pending Ops Table", 100L, pendingOpsCxt); pendingUnlinks = NIL; } } diff --git a/src/backend/tsearch/ts_typanalyze.c b/src/backend/tsearch/ts_typanalyze.c index 93aab00a3ca..a9bc6901a12 100644 --- a/src/backend/tsearch/ts_typanalyze.c +++ b/src/backend/tsearch/ts_typanalyze.c @@ -149,7 +149,6 @@ compute_tsvector_stats(VacAttrStats *stats, /* This is D from the LC algorithm. */ HTAB *lexemes_tab; - HASHCTL hash_ctl; HASH_SEQ_STATUS scan_status; /* This is the current bucket number from the LC algorithm */ @@ -180,15 +179,9 @@ compute_tsvector_stats(VacAttrStats *stats, * worry about overflowing the initial size. Also we don't need to pay any * attention to locking and memory management. */ - hash_ctl.keysize = sizeof(LexemeHashKey); - hash_ctl.entrysize = sizeof(TrackItem); - hash_ctl.hash = lexeme_hash; - hash_ctl.match = lexeme_match; - hash_ctl.hcxt = CurrentMemoryContext; - lexemes_tab = hash_create("Analyzed lexemes table", - num_mcelem, - &hash_ctl, - HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_CONTEXT); + lexemes_tab = hash_make_fn(TrackItem, key, + "Analyzed lexemes table", num_mcelem, + lexeme_hash, lexeme_match); /* Initialize counters. */ b_current = 1; diff --git a/src/backend/utils/activity/wait_event.c b/src/backend/utils/activity/wait_event.c index 96d61f77f6e..35aa0208fc9 100644 --- a/src/backend/utils/activity/wait_event.c +++ b/src/backend/utils/activity/wait_event.c @@ -119,7 +119,6 @@ void WaitEventCustomShmemInit(void) { bool found; - HASHCTL info; WaitEventCustomCounter = (WaitEventCustomCounterData *) ShmemInitStruct("WaitEventCustomCounterData", @@ -133,24 +132,18 @@ WaitEventCustomShmemInit(void) } /* initialize or attach the hash tables to store custom wait events */ - info.keysize = sizeof(uint32); - info.entrysize = sizeof(WaitEventCustomEntryByInfo); WaitEventCustomHashByInfo = - ShmemInitHash("WaitEventCustom hash by wait event information", - WAIT_EVENT_CUSTOM_HASH_INIT_SIZE, - WAIT_EVENT_CUSTOM_HASH_MAX_SIZE, - &info, - HASH_ELEM | HASH_BLOBS); + shmem_hash_make(WaitEventCustomEntryByInfo, wait_event_info, + "WaitEventCustom hash by wait event information", + WAIT_EVENT_CUSTOM_HASH_INIT_SIZE, + WAIT_EVENT_CUSTOM_HASH_MAX_SIZE); /* key is a NULL-terminated string */ - info.keysize = sizeof(char[NAMEDATALEN]); - info.entrysize = sizeof(WaitEventCustomEntryByName); WaitEventCustomHashByName = - ShmemInitHash("WaitEventCustom hash by name", - WAIT_EVENT_CUSTOM_HASH_INIT_SIZE, - WAIT_EVENT_CUSTOM_HASH_MAX_SIZE, - &info, - HASH_ELEM | HASH_STRINGS); + shmem_hash_make(WaitEventCustomEntryByName, wait_event_name, + "WaitEventCustom hash by name", + WAIT_EVENT_CUSTOM_HASH_INIT_SIZE, + WAIT_EVENT_CUSTOM_HASH_MAX_SIZE); } /* diff --git a/src/backend/utils/adt/array_typanalyze.c b/src/backend/utils/adt/array_typanalyze.c index 560b27f3ca7..cc310c044b3 100644 --- a/src/backend/utils/adt/array_typanalyze.c +++ b/src/backend/utils/adt/array_typanalyze.c @@ -223,7 +223,6 @@ compute_array_stats(VacAttrStats *stats, AnalyzeAttrFetchFunc fetchfunc, /* This is D from the LC algorithm. */ HTAB *elements_tab; - HASHCTL elem_hash_ctl; HASH_SEQ_STATUS scan_status; /* This is the current bucket number from the LC algorithm */ @@ -236,7 +235,6 @@ compute_array_stats(VacAttrStats *stats, AnalyzeAttrFetchFunc fetchfunc, TrackItem *item; int slot_idx; HTAB *count_tab; - HASHCTL count_hash_ctl; DECountItem *count_item; extra_data = (ArrayAnalyzeExtraData *) stats->extra_data; @@ -276,24 +274,13 @@ compute_array_stats(VacAttrStats *stats, AnalyzeAttrFetchFunc fetchfunc, * worry about overflowing the initial size. Also we don't need to pay any * attention to locking and memory management. */ - elem_hash_ctl.keysize = sizeof(Datum); - elem_hash_ctl.entrysize = sizeof(TrackItem); - elem_hash_ctl.hash = element_hash; - elem_hash_ctl.match = element_match; - elem_hash_ctl.hcxt = CurrentMemoryContext; - elements_tab = hash_create("Analyzed elements table", - num_mcelem, - &elem_hash_ctl, - HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_CONTEXT); + elements_tab = hash_make_fn(TrackItem, key, + "Analyzed elements table", num_mcelem, + element_hash, element_match); /* hashtable for array distinct elements counts */ - count_hash_ctl.keysize = sizeof(int); - count_hash_ctl.entrysize = sizeof(DECountItem); - count_hash_ctl.hcxt = CurrentMemoryContext; - count_tab = hash_create("Array distinct element count table", - 64, - &count_hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + count_tab = hash_make(DECountItem, count, + "Array distinct element count table", 64); /* Initialize counters. */ b_current = 1; diff --git a/src/backend/utils/adt/json.c b/src/backend/utils/adt/json.c index 06dd62f0008..56aa88e495e 100644 --- a/src/backend/utils/adt/json.c +++ b/src/backend/utils/adt/json.c @@ -933,19 +933,8 @@ json_unique_hash_match(const void *key1, const void *key2, Size keysize) static void json_unique_check_init(JsonUniqueCheckState *cxt) { - HASHCTL ctl; - - memset(&ctl, 0, sizeof(ctl)); - ctl.keysize = sizeof(JsonUniqueHashEntry); - ctl.entrysize = sizeof(JsonUniqueHashEntry); - ctl.hcxt = CurrentMemoryContext; - ctl.hash = json_unique_hash; - ctl.match = json_unique_hash_match; - - *cxt = hash_create("json object hashtable", - 32, - &ctl, - HASH_ELEM | HASH_CONTEXT | HASH_FUNCTION | HASH_COMPARE); + *cxt = hashset_make_fn(JsonUniqueHashEntry, "json object hashtable", 32, + json_unique_hash, json_unique_hash_match); } static void diff --git a/src/backend/utils/adt/jsonfuncs.c b/src/backend/utils/adt/jsonfuncs.c index 22de18bc5b9..b369a9e3b16 100644 --- a/src/backend/utils/adt/jsonfuncs.c +++ b/src/backend/utils/adt/jsonfuncs.c @@ -3808,18 +3808,12 @@ static HTAB * get_json_object_as_hash(const char *json, int len, const char *funcname, Node *escontext) { - HASHCTL ctl; HTAB *tab; JHashState *state; JsonSemAction *sem; - ctl.keysize = NAMEDATALEN; - ctl.entrysize = sizeof(JsonHashEntry); - ctl.hcxt = CurrentMemoryContext; - tab = hash_create("json object hashtable", - 100, - &ctl, - HASH_ELEM | HASH_STRINGS | HASH_CONTEXT); + tab = hash_make(JsonHashEntry, fname, + "json object hashtable", 100); state = palloc0(sizeof(JHashState)); sem = palloc0(sizeof(JsonSemAction)); @@ -4213,7 +4207,6 @@ populate_recordset_object_start(void *state) { PopulateRecordsetState *_state = (PopulateRecordsetState *) state; int lex_level = _state->lex->lex_level; - HASHCTL ctl; /* Reject object at top level: we must have an array at level 0 */ if (lex_level == 0) @@ -4227,13 +4220,8 @@ populate_recordset_object_start(void *state) return JSON_SUCCESS; /* Object at level 1: set up a new hash table for this object */ - ctl.keysize = NAMEDATALEN; - ctl.entrysize = sizeof(JsonHashEntry); - ctl.hcxt = CurrentMemoryContext; - _state->json_hash = hash_create("json object hashtable", - 100, - &ctl, - HASH_ELEM | HASH_STRINGS | HASH_CONTEXT); + _state->json_hash = hash_make(JsonHashEntry, fname, + "json object hashtable", 100); return JSON_SUCCESS; } diff --git a/src/backend/utils/adt/mcxtfuncs.c b/src/backend/utils/adt/mcxtfuncs.c index fe6dce9cba3..84b43f5c4e0 100644 --- a/src/backend/utils/adt/mcxtfuncs.c +++ b/src/backend/utils/adt/mcxtfuncs.c @@ -185,17 +185,10 @@ pg_get_backend_memory_contexts(PG_FUNCTION_ARGS) ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo; int context_id; List *contexts; - HASHCTL ctl; HTAB *context_id_lookup; - ctl.keysize = sizeof(MemoryContext); - ctl.entrysize = sizeof(MemoryContextId); - ctl.hcxt = CurrentMemoryContext; - - context_id_lookup = hash_create("pg_get_backend_memory_contexts", - 256, - &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + context_id_lookup = hash_make(MemoryContextId, context, + "pg_get_backend_memory_contexts", 256); InitMaterializedSRF(fcinfo, 0); diff --git a/src/backend/utils/adt/ri_triggers.c b/src/backend/utils/adt/ri_triggers.c index 059fc5ebf60..e0f05f2cc4a 100644 --- a/src/backend/utils/adt/ri_triggers.c +++ b/src/backend/utils/adt/ri_triggers.c @@ -2857,30 +2857,25 @@ ri_NullCheck(TupleDesc tupDesc, static void ri_InitHashTables(void) { - HASHCTL ctl; - - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(RI_ConstraintInfo); - ri_constraint_cache = hash_create("RI constraint cache", - RI_INIT_CONSTRAINTHASHSIZE, - &ctl, HASH_ELEM | HASH_BLOBS); + ri_constraint_cache = hash_make_cxt(RI_ConstraintInfo, constraint_id, + "RI constraint cache", + RI_INIT_CONSTRAINTHASHSIZE, + TopMemoryContext); /* Arrange to flush cache on pg_constraint changes */ CacheRegisterSyscacheCallback(CONSTROID, InvalidateConstraintCacheCallBack, (Datum) 0); - ctl.keysize = sizeof(RI_QueryKey); - ctl.entrysize = sizeof(RI_QueryHashEntry); - ri_query_cache = hash_create("RI query cache", - RI_INIT_QUERYHASHSIZE, - &ctl, HASH_ELEM | HASH_BLOBS); - - ctl.keysize = sizeof(RI_CompareKey); - ctl.entrysize = sizeof(RI_CompareHashEntry); - ri_compare_cache = hash_create("RI compare cache", + ri_query_cache = hash_make_cxt(RI_QueryHashEntry, key, + "RI query cache", RI_INIT_QUERYHASHSIZE, - &ctl, HASH_ELEM | HASH_BLOBS); + TopMemoryContext); + + ri_compare_cache = hash_make_cxt(RI_CompareHashEntry, key, + "RI compare cache", + RI_INIT_QUERYHASHSIZE, + TopMemoryContext); } diff --git a/src/backend/utils/adt/ruleutils.c b/src/backend/utils/adt/ruleutils.c index 6cf90be40bb..98d331c290f 100644 --- a/src/backend/utils/adt/ruleutils.c +++ b/src/backend/utils/adt/ruleutils.c @@ -3887,7 +3887,6 @@ static void set_rtable_names(deparse_namespace *dpns, List *parent_namespaces, Bitmapset *rels_used) { - HASHCTL hash_ctl; HTAB *names_hash; NameHashEntry *hentry; bool found; @@ -3903,13 +3902,9 @@ set_rtable_names(deparse_namespace *dpns, List *parent_namespaces, * We use a hash table to hold known names, so that this process is O(N) * not O(N^2) for N names. */ - hash_ctl.keysize = NAMEDATALEN; - hash_ctl.entrysize = sizeof(NameHashEntry); - hash_ctl.hcxt = CurrentMemoryContext; - names_hash = hash_create("set_rtable_names names", - list_length(dpns->rtable), - &hash_ctl, - HASH_ELEM | HASH_STRINGS | HASH_CONTEXT); + names_hash = hash_make(NameHashEntry, name, + "set_rtable_names names", + list_length(dpns->rtable)); /* Preload the hash table with names appearing in parent_namespaces */ foreach(lc, parent_namespaces) @@ -4980,7 +4975,6 @@ expand_colnames_array_to(deparse_columns *colinfo, int n) static void build_colinfo_names_hash(deparse_columns *colinfo) { - HASHCTL hash_ctl; int i; ListCell *lc; @@ -4996,13 +4990,10 @@ build_colinfo_names_hash(deparse_columns *colinfo) * Set up the hash table. The entries are just strings with no other * payload. */ - hash_ctl.keysize = NAMEDATALEN; - hash_ctl.entrysize = NAMEDATALEN; - hash_ctl.hcxt = CurrentMemoryContext; - colinfo->names_hash = hash_create("deparse_columns names", - colinfo->num_cols + colinfo->num_new_cols, - &hash_ctl, - HASH_ELEM | HASH_STRINGS | HASH_CONTEXT); + colinfo->names_hash = + hashset_make_cxt(NameData, "deparse_columns names", + colinfo->num_cols + colinfo->num_new_cols, + CurrentMemoryContext); /* * Preload the hash table with any names already present (these would have diff --git a/src/backend/utils/cache/attoptcache.c b/src/backend/utils/cache/attoptcache.c index 45d1e2be007..caae39e3bb1 100644 --- a/src/backend/utils/cache/attoptcache.c +++ b/src/backend/utils/cache/attoptcache.c @@ -21,6 +21,7 @@ #include "utils/catcache.h" #include "utils/hsearch.h" #include "utils/inval.h" +#include "utils/memutils.h" #include "utils/syscache.h" #include "varatt.h" @@ -96,22 +97,15 @@ relatt_cache_syshash(const void *key, Size keysize) static void InitializeAttoptCache(void) { - HASHCTL ctl; - - /* Initialize the hash table. */ - ctl.keysize = sizeof(AttoptCacheKey); - ctl.entrysize = sizeof(AttoptCacheEntry); - /* * AttoptCacheEntry takes hash value from the system cache. For * AttoptCacheHash we use the same hash in order to speedup search by hash * value. This is used by hash_seq_init_with_hash_value(). */ - ctl.hash = relatt_cache_syshash; - - AttoptCacheHash = - hash_create("Attopt cache", 256, &ctl, - HASH_ELEM | HASH_FUNCTION); + AttoptCacheHash = hash_make_fn_cxt(AttoptCacheEntry, key, + "Attopt cache", 256, + relatt_cache_syshash, NULL, + TopMemoryContext); /* Make sure we've initialized CacheMemoryContext. */ if (!CacheMemoryContext) diff --git a/src/backend/utils/cache/evtcache.c b/src/backend/utils/cache/evtcache.c index 76ba2db5390..f5ce873f43c 100644 --- a/src/backend/utils/cache/evtcache.c +++ b/src/backend/utils/cache/evtcache.c @@ -76,7 +76,6 @@ EventCacheLookup(EventTriggerEvent event) static void BuildEventTriggerCache(void) { - HASHCTL ctl; HTAB *cache; Relation rel; Relation irel; @@ -113,11 +112,9 @@ BuildEventTriggerCache(void) EventTriggerCacheState = ETCS_REBUILD_STARTED; /* Create new hash table. */ - ctl.keysize = sizeof(EventTriggerEvent); - ctl.entrysize = sizeof(EventTriggerCacheEntry); - ctl.hcxt = EventTriggerCacheContext; - cache = hash_create("EventTriggerCacheHash", 32, &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + cache = hash_make_cxt(EventTriggerCacheEntry, event, + "EventTriggerCacheHash", 32, + EventTriggerCacheContext); /* * Prepare to scan pg_event_trigger in name order. diff --git a/src/backend/utils/cache/funccache.c b/src/backend/utils/cache/funccache.c index afc048a051e..34438a9f93b 100644 --- a/src/backend/utils/cache/funccache.c +++ b/src/backend/utils/cache/funccache.c @@ -58,19 +58,13 @@ static int cfunc_match(const void *key1, const void *key2, Size keysize); static void cfunc_hashtable_init(void) { - HASHCTL ctl; - /* don't allow double-initialization */ Assert(cfunc_hashtable == NULL); - ctl.keysize = sizeof(CachedFunctionHashKey); - ctl.entrysize = sizeof(CachedFunctionHashEntry); - ctl.hash = cfunc_hash; - ctl.match = cfunc_match; - cfunc_hashtable = hash_create("Cached function hash", - FUNCS_PER_USER, - &ctl, - HASH_ELEM | HASH_FUNCTION | HASH_COMPARE); + cfunc_hashtable = hash_make_fn_cxt(CachedFunctionHashEntry, key, + "Cached function hash", FUNCS_PER_USER, + cfunc_hash, cfunc_match, + TopMemoryContext); } /* diff --git a/src/backend/utils/cache/relcache.c b/src/backend/utils/cache/relcache.c index 915d0bc9084..b76d6bbd5c9 100644 --- a/src/backend/utils/cache/relcache.c +++ b/src/backend/utils/cache/relcache.c @@ -1677,17 +1677,14 @@ LookupOpclassInfo(Oid operatorClassOid, if (OpClassCache == NULL) { - /* First time through: initialize the opclass cache */ - HASHCTL ctl; - /* Also make sure CacheMemoryContext exists */ if (!CacheMemoryContext) CreateCacheMemoryContext(); - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(OpClassCacheEnt); - OpClassCache = hash_create("Operator class cache", 64, - &ctl, HASH_ELEM | HASH_BLOBS); + /* First time through: initialize the opclass cache */ + OpClassCache = hash_make_cxt(OpClassCacheEnt, opclassoid, + "Operator class cache", 64, + TopMemoryContext); } opcentry = (OpClassCacheEnt *) hash_search(OpClassCache, @@ -4001,7 +3998,6 @@ RelationAssumeNewRelfilelocator(Relation relation) void RelationCacheInitialize(void) { - HASHCTL ctl; int allocsize; /* @@ -4013,10 +4009,9 @@ RelationCacheInitialize(void) /* * create hashtable that indexes the relcache */ - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(RelIdCacheEnt); - RelationIdCache = hash_create("Relcache by OID", INITRELCACHESIZE, - &ctl, HASH_ELEM | HASH_BLOBS); + RelationIdCache = hash_make_cxt(RelIdCacheEnt, reloid, + "Relcache by OID", INITRELCACHESIZE, + TopMemoryContext); /* * reserve enough in_progress_list slots for many cases diff --git a/src/backend/utils/cache/relfilenumbermap.c b/src/backend/utils/cache/relfilenumbermap.c index 0b6f9cf3fa1..69aba463eae 100644 --- a/src/backend/utils/cache/relfilenumbermap.c +++ b/src/backend/utils/cache/relfilenumbermap.c @@ -85,7 +85,6 @@ RelfilenumberMapInvalidateCallback(Datum arg, Oid relid) static void InitializeRelfilenumberMap(void) { - HASHCTL ctl; int i; /* Make sure we've initialized CacheMemoryContext. */ @@ -113,13 +112,9 @@ InitializeRelfilenumberMap(void) * initialized when fmgr_info_cxt() above ERRORs out with an out of memory * error. */ - ctl.keysize = sizeof(RelfilenumberMapKey); - ctl.entrysize = sizeof(RelfilenumberMapEntry); - ctl.hcxt = CacheMemoryContext; - RelfilenumberMapHash = - hash_create("RelfilenumberMap cache", 64, &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + hash_make_cxt(RelfilenumberMapEntry, key, + "RelfilenumberMap cache", 64, CacheMemoryContext); /* Watch for invalidation events. */ CacheRegisterRelcacheCallback(RelfilenumberMapInvalidateCallback, diff --git a/src/backend/utils/cache/spccache.c b/src/backend/utils/cache/spccache.c index 23458599298..bcfd6a9f0d2 100644 --- a/src/backend/utils/cache/spccache.c +++ b/src/backend/utils/cache/spccache.c @@ -27,6 +27,7 @@ #include "utils/catcache.h" #include "utils/hsearch.h" #include "utils/inval.h" +#include "utils/memutils.h" #include "utils/spccache.h" #include "utils/syscache.h" #include "varatt.h" @@ -77,14 +78,10 @@ InvalidateTableSpaceCacheCallback(Datum arg, int cacheid, uint32 hashvalue) static void InitializeTableSpaceCache(void) { - HASHCTL ctl; - /* Initialize the hash table. */ - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(TableSpaceCacheEntry); TableSpaceCacheHash = - hash_create("TableSpace cache", 16, &ctl, - HASH_ELEM | HASH_BLOBS); + hash_make_cxt(TableSpaceCacheEntry, oid, + "TableSpace cache", 16, TopMemoryContext); /* Make sure we've initialized CacheMemoryContext. */ if (!CacheMemoryContext) diff --git a/src/backend/utils/cache/ts_cache.c b/src/backend/utils/cache/ts_cache.c index e8ae53238d0..cfa6d8b09a4 100644 --- a/src/backend/utils/cache/ts_cache.c +++ b/src/backend/utils/cache/ts_cache.c @@ -117,12 +117,9 @@ lookup_ts_parser_cache(Oid prsId) if (TSParserCacheHash == NULL) { /* First time through: initialize the hash table */ - HASHCTL ctl; - - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(TSParserCacheEntry); - TSParserCacheHash = hash_create("Tsearch parser cache", 4, - &ctl, HASH_ELEM | HASH_BLOBS); + TSParserCacheHash = hash_make_cxt(TSParserCacheEntry, prsId, + "Tsearch parser cache", 4, + TopMemoryContext); /* Flush cache on pg_ts_parser changes */ CacheRegisterSyscacheCallback(TSPARSEROID, InvalidateTSCacheCallBack, PointerGetDatum(TSParserCacheHash)); @@ -212,12 +209,9 @@ lookup_ts_dictionary_cache(Oid dictId) if (TSDictionaryCacheHash == NULL) { /* First time through: initialize the hash table */ - HASHCTL ctl; - - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(TSDictionaryCacheEntry); - TSDictionaryCacheHash = hash_create("Tsearch dictionary cache", 8, - &ctl, HASH_ELEM | HASH_BLOBS); + TSDictionaryCacheHash = hash_make_cxt(TSDictionaryCacheEntry, dictId, + "Tsearch dictionary cache", 8, + TopMemoryContext); /* Flush cache on pg_ts_dict and pg_ts_template changes */ CacheRegisterSyscacheCallback(TSDICTOID, InvalidateTSCacheCallBack, PointerGetDatum(TSDictionaryCacheHash)); @@ -363,12 +357,9 @@ lookup_ts_dictionary_cache(Oid dictId) static void init_ts_config_cache(void) { - HASHCTL ctl; - - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(TSConfigCacheEntry); - TSConfigCacheHash = hash_create("Tsearch configuration cache", 16, - &ctl, HASH_ELEM | HASH_BLOBS); + TSConfigCacheHash = hash_make_cxt(TSConfigCacheEntry, cfgId, + "Tsearch configuration cache", 16, + TopMemoryContext); /* Flush cache on pg_ts_config and pg_ts_config_map changes */ CacheRegisterSyscacheCallback(TSCONFIGOID, InvalidateTSCacheCallBack, PointerGetDatum(TSConfigCacheHash)); diff --git a/src/backend/utils/cache/typcache.c b/src/backend/utils/cache/typcache.c index 6a347698edf..7e4ffbe6708 100644 --- a/src/backend/utils/cache/typcache.c +++ b/src/backend/utils/cache/typcache.c @@ -392,28 +392,23 @@ lookup_type_cache(Oid type_id, int flags) if (TypeCacheHash == NULL) { /* First time through: initialize the hash table */ - HASHCTL ctl; int allocsize; - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(TypeCacheEntry); - /* * TypeCacheEntry takes hash value from the system cache. For * TypeCacheHash we use the same hash in order to speedup search by * hash value. This is used by hash_seq_init_with_hash_value(). */ - ctl.hash = type_cache_syshash; - - TypeCacheHash = hash_create("Type information cache", 64, - &ctl, HASH_ELEM | HASH_FUNCTION); + TypeCacheHash = hash_make_fn_cxt(TypeCacheEntry, type_id, + "Type information cache", 64, + type_cache_syshash, NULL, + TopMemoryContext); Assert(RelIdToTypeIdCacheHash == NULL); - ctl.keysize = sizeof(Oid); - ctl.entrysize = sizeof(RelIdToTypeIdCacheEntry); - RelIdToTypeIdCacheHash = hash_create("Map from relid to OID of cached composite type", 64, - &ctl, HASH_ELEM | HASH_BLOBS); + RelIdToTypeIdCacheHash = hash_make_cxt(RelIdToTypeIdCacheEntry, relid, + "Map from relid to OID of cached composite type", + 64, TopMemoryContext); /* Also set up callbacks for SI invalidations */ CacheRegisterRelcacheCallback(TypeCacheRelCallback, (Datum) 0); @@ -2050,15 +2045,11 @@ assign_record_type_typmod(TupleDesc tupDesc) if (RecordCacheHash == NULL) { /* First time through: initialize the hash table */ - HASHCTL ctl; - - ctl.keysize = sizeof(TupleDesc); /* just the pointer */ - ctl.entrysize = sizeof(RecordCacheEntry); - ctl.hash = record_type_typmod_hash; - ctl.match = record_type_typmod_compare; - RecordCacheHash = hash_create("Record information cache", 64, - &ctl, - HASH_ELEM | HASH_FUNCTION | HASH_COMPARE); + RecordCacheHash = hash_make_fn_cxt(RecordCacheEntry, tupdesc, + "Record information cache", 64, + record_type_typmod_hash, + record_type_typmod_compare, + TopMemoryContext); /* Also make sure CacheMemoryContext exists */ if (!CacheMemoryContext) diff --git a/src/backend/utils/fmgr/dfmgr.c b/src/backend/utils/fmgr/dfmgr.c index 1366521f471..f587bbb4cf9 100644 --- a/src/backend/utils/fmgr/dfmgr.c +++ b/src/backend/utils/fmgr/dfmgr.c @@ -26,6 +26,7 @@ #include "storage/fd.h" #include "storage/shmem.h" #include "utils/hsearch.h" +#include "utils/memutils.h" /* signature for PostgreSQL-specific library init function */ @@ -671,14 +672,9 @@ find_rendezvous_variable(const char *varName) /* Create a hashtable if we haven't already done so in this process */ if (rendezvousHash == NULL) { - HASHCTL ctl; - - ctl.keysize = NAMEDATALEN; - ctl.entrysize = sizeof(rendezvousHashEntry); - rendezvousHash = hash_create("Rendezvous variable hash", - 16, - &ctl, - HASH_ELEM | HASH_STRINGS); + rendezvousHash = hash_make_cxt(rendezvousHashEntry, varName, + "Rendezvous variable hash", 16, + TopMemoryContext); } /* Find or create the hashtable entry for this varName */ diff --git a/src/backend/utils/fmgr/fmgr.c b/src/backend/utils/fmgr/fmgr.c index 0fe63c6bb83..fc85a05367c 100644 --- a/src/backend/utils/fmgr/fmgr.c +++ b/src/backend/utils/fmgr/fmgr.c @@ -32,6 +32,7 @@ #include "utils/fmgrtab.h" #include "utils/guc.h" #include "utils/lsyscache.h" +#include "utils/memutils.h" #include "utils/syscache.h" /* @@ -547,14 +548,8 @@ record_C_func(HeapTuple procedureTuple, /* Create the hash table if it doesn't exist yet */ if (CFuncHash == NULL) { - HASHCTL hash_ctl; - - hash_ctl.keysize = sizeof(Oid); - hash_ctl.entrysize = sizeof(CFuncHashTabEntry); - CFuncHash = hash_create("CFuncHash", - 100, - &hash_ctl, - HASH_ELEM | HASH_BLOBS); + CFuncHash = hash_make_cxt(CFuncHashTabEntry, fn_oid, + "CFuncHash", 100, TopMemoryContext); } entry = (CFuncHashTabEntry *) diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c index c6484aea087..f3897c953d3 100644 --- a/src/backend/utils/misc/guc.c +++ b/src/backend/utils/misc/guc.c @@ -871,7 +871,6 @@ build_guc_variables(void) { int size_vars; int num_vars = 0; - HASHCTL hash_ctl; GUCHashEntry *hentry; bool found; @@ -894,15 +893,10 @@ build_guc_variables(void) */ size_vars = num_vars + num_vars / 4; - hash_ctl.keysize = sizeof(char *); - hash_ctl.entrysize = sizeof(GUCHashEntry); - hash_ctl.hash = guc_name_hash; - hash_ctl.match = guc_name_match; - hash_ctl.hcxt = GUCMemoryContext; - guc_hashtab = hash_create("GUC hash table", - size_vars, - &hash_ctl, - HASH_ELEM | HASH_FUNCTION | HASH_COMPARE | HASH_CONTEXT); + guc_hashtab = hash_make_fn_cxt(GUCHashEntry, gucname, + "GUC hash table", size_vars, + guc_name_hash, guc_name_match, + GUCMemoryContext); for (int i = 0; ConfigureNames[i].name; i++) { diff --git a/src/backend/utils/misc/injection_point.c b/src/backend/utils/misc/injection_point.c index d02618c7ffe..5075399f017 100644 --- a/src/backend/utils/misc/injection_point.c +++ b/src/backend/utils/misc/injection_point.c @@ -127,16 +127,10 @@ injection_point_cache_add(const char *name, /* If first time, initialize */ if (InjectionPointCache == NULL) { - HASHCTL hash_ctl; - - hash_ctl.keysize = sizeof(char[INJ_NAME_MAXLEN]); - hash_ctl.entrysize = sizeof(InjectionPointCacheEntry); - hash_ctl.hcxt = TopMemoryContext; - - InjectionPointCache = hash_create("InjectionPoint cache hash", - MAX_INJECTION_POINTS, - &hash_ctl, - HASH_ELEM | HASH_STRINGS | HASH_CONTEXT); + InjectionPointCache = hash_make_cxt(InjectionPointCacheEntry, name, + "InjectionPoint cache hash", + MAX_INJECTION_POINTS, + TopMemoryContext); } entry = (InjectionPointCacheEntry *) diff --git a/src/backend/utils/mmgr/portalmem.c b/src/backend/utils/mmgr/portalmem.c index 943da087c9f..8241d32f0c6 100644 --- a/src/backend/utils/mmgr/portalmem.c +++ b/src/backend/utils/mmgr/portalmem.c @@ -103,23 +103,19 @@ static MemoryContext TopPortalContext = NULL; void EnablePortalManager(void) { - HASHCTL ctl; - Assert(TopPortalContext == NULL); TopPortalContext = AllocSetContextCreate(TopMemoryContext, "TopPortalContext", ALLOCSET_DEFAULT_SIZES); - ctl.keysize = MAX_PORTALNAME_LEN; - ctl.entrysize = sizeof(PortalHashEnt); - /* * use PORTALS_PER_USER as a guess of how many hash table entries to * create, initially */ - PortalHashTable = hash_create("Portal hash", PORTALS_PER_USER, - &ctl, HASH_ELEM | HASH_STRINGS); + PortalHashTable = hash_make_cxt(PortalHashEnt, portalname, + "Portal hash", PORTALS_PER_USER, + TopMemoryContext); } /* diff --git a/src/backend/utils/time/combocid.c b/src/backend/utils/time/combocid.c index 1e815571570..92662a63177 100644 --- a/src/backend/utils/time/combocid.c +++ b/src/backend/utils/time/combocid.c @@ -214,8 +214,6 @@ GetComboCommandId(CommandId cmin, CommandId cmax) */ if (comboHash == NULL) { - HASHCTL hash_ctl; - /* Make array first; existence of hash table asserts array exists */ comboCids = (ComboCidKeyData *) MemoryContextAlloc(TopTransactionContext, @@ -223,14 +221,9 @@ GetComboCommandId(CommandId cmin, CommandId cmax) sizeComboCids = CCID_ARRAY_SIZE; usedComboCids = 0; - hash_ctl.keysize = sizeof(ComboCidKeyData); - hash_ctl.entrysize = sizeof(ComboCidEntryData); - hash_ctl.hcxt = TopTransactionContext; - - comboHash = hash_create("Combo CIDs", - CCID_HASH_SIZE, - &hash_ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + comboHash = hash_make_cxt(ComboCidEntryData, key, + "Combo CIDs", CCID_HASH_SIZE, + TopTransactionContext); } /* diff --git a/src/pl/plperl/plperl.c b/src/pl/plperl/plperl.c index 73ba1748fe0..e211f821edc 100644 --- a/src/pl/plperl/plperl.c +++ b/src/pl/plperl/plperl.c @@ -390,7 +390,6 @@ _PG_init(void) * "plperl.use_strict" */ static bool inited = false; - HASHCTL hash_ctl; if (inited) return; @@ -460,19 +459,13 @@ _PG_init(void) /* * Create hash tables. */ - hash_ctl.keysize = sizeof(Oid); - hash_ctl.entrysize = sizeof(plperl_interp_desc); - plperl_interp_hash = hash_create("PL/Perl interpreters", - 8, - &hash_ctl, - HASH_ELEM | HASH_BLOBS); - - hash_ctl.keysize = sizeof(plperl_proc_key); - hash_ctl.entrysize = sizeof(plperl_proc_ptr); - plperl_proc_hash = hash_create("PL/Perl procedures", - 32, - &hash_ctl, - HASH_ELEM | HASH_BLOBS); + plperl_interp_hash = hash_make_cxt(plperl_interp_desc, user_id, + "PL/Perl interpreters", 8, + TopMemoryContext); + + plperl_proc_hash = hash_make_cxt(plperl_proc_ptr, proc_key, + "PL/Perl procedures", 32, + TopMemoryContext); /* * Save the default opmask. @@ -578,14 +571,9 @@ select_perl_context(bool trusted) /* Make sure we have a query_hash for this interpreter */ if (interp_desc->query_hash == NULL) { - HASHCTL hash_ctl; - - hash_ctl.keysize = NAMEDATALEN; - hash_ctl.entrysize = sizeof(plperl_query_entry); - interp_desc->query_hash = hash_create("PL/Perl queries", - 32, - &hash_ctl, - HASH_ELEM | HASH_STRINGS); + interp_desc->query_hash = hash_make_cxt(plperl_query_entry, query_name, + "PL/Perl queries", 32, + TopMemoryContext); } /* diff --git a/src/pl/plpgsql/src/pl_exec.c b/src/pl/plpgsql/src/pl_exec.c index d19425b7a71..f3b469432aa 100644 --- a/src/pl/plpgsql/src/pl_exec.c +++ b/src/pl/plpgsql/src/pl_exec.c @@ -3996,8 +3996,6 @@ plpgsql_estate_setup(PLpgSQL_execstate *estate, EState *simple_eval_estate, ResourceOwner simple_eval_resowner) { - HASHCTL ctl; - /* this link will be restored at exit from plpgsql_call_handler */ func->cur_estate = estate; @@ -4052,12 +4050,10 @@ plpgsql_estate_setup(PLpgSQL_execstate *estate, /* Create the session-wide cast-expression hash if we didn't already */ if (cast_expr_hash == NULL) { - ctl.keysize = sizeof(plpgsql_CastHashKey); - ctl.entrysize = sizeof(plpgsql_CastExprHashEntry); - cast_expr_hash = hash_create("PLpgSQL cast expressions", - 16, /* start small and extend */ - &ctl, - HASH_ELEM | HASH_BLOBS); + cast_expr_hash = hash_make_cxt(plpgsql_CastExprHashEntry, key, + "PLpgSQL cast expressions", + 16, /* start small and extend */ + TopMemoryContext); } /* set up for use of appropriate simple-expression EState and cast hash */ @@ -4065,13 +4061,9 @@ plpgsql_estate_setup(PLpgSQL_execstate *estate, { estate->simple_eval_estate = simple_eval_estate; /* Private cast hash just lives in function's main context */ - ctl.keysize = sizeof(plpgsql_CastHashKey); - ctl.entrysize = sizeof(plpgsql_CastHashEntry); - ctl.hcxt = CurrentMemoryContext; - estate->cast_hash = hash_create("PLpgSQL private cast cache", - 16, /* start small and extend */ - &ctl, - HASH_ELEM | HASH_BLOBS | HASH_CONTEXT); + estate->cast_hash = hash_make(plpgsql_CastHashEntry, key, + "PLpgSQL private cast cache", + 16); /* start small and extend */ } else { @@ -4079,12 +4071,10 @@ plpgsql_estate_setup(PLpgSQL_execstate *estate, /* Create the session-wide cast-info hash table if we didn't already */ if (shared_cast_hash == NULL) { - ctl.keysize = sizeof(plpgsql_CastHashKey); - ctl.entrysize = sizeof(plpgsql_CastHashEntry); - shared_cast_hash = hash_create("PLpgSQL cast cache", - 16, /* start small and extend */ - &ctl, - HASH_ELEM | HASH_BLOBS); + shared_cast_hash = hash_make_cxt(plpgsql_CastHashEntry, key, + "PLpgSQL cast cache", + 16, /* start small and extend */ + TopMemoryContext); } estate->cast_hash = shared_cast_hash; } diff --git a/src/pl/plpython/plpy_plpymodule.c b/src/pl/plpython/plpy_plpymodule.c index 89931612c5b..b268b380cd5 100644 --- a/src/pl/plpython/plpy_plpymodule.c +++ b/src/pl/plpython/plpy_plpymodule.c @@ -16,6 +16,7 @@ #include "plpy_subxactobject.h" #include "plpy_util.h" #include "utils/builtins.h" +#include "utils/memutils.h" HTAB *PLy_spi_exceptions = NULL; @@ -172,7 +173,6 @@ static void PLy_add_exceptions(PyObject *plpy) { PyObject *excmod; - HASHCTL hash_ctl; excmod = PyModule_Create(&PLy_exc_module); if (excmod == NULL) @@ -193,10 +193,9 @@ PLy_add_exceptions(PyObject *plpy) PLy_exc_spi_error = PLy_create_exception("plpy.SPIError", NULL, NULL, "SPIError", plpy); - hash_ctl.keysize = sizeof(int); - hash_ctl.entrysize = sizeof(PLyExceptionEntry); - PLy_spi_exceptions = hash_create("PL/Python SPI exceptions", 256, - &hash_ctl, HASH_ELEM | HASH_BLOBS); + PLy_spi_exceptions = hash_make_cxt(PLyExceptionEntry, sqlstate, + "PL/Python SPI exceptions", 256, + TopMemoryContext); PLy_generate_spi_exceptions(excmod, PLy_exc_spi_error); } diff --git a/src/pl/plpython/plpy_procedure.c b/src/pl/plpython/plpy_procedure.c index 655ab1d09ee..6317606e01e 100644 --- a/src/pl/plpython/plpy_procedure.c +++ b/src/pl/plpython/plpy_procedure.c @@ -29,12 +29,9 @@ static char *PLy_procedure_munge_source(const char *name, const char *src); void init_procedure_caches(void) { - HASHCTL hash_ctl; - - hash_ctl.keysize = sizeof(PLyProcedureKey); - hash_ctl.entrysize = sizeof(PLyProcedureEntry); - PLy_procedure_cache = hash_create("PL/Python procedures", 32, &hash_ctl, - HASH_ELEM | HASH_BLOBS); + PLy_procedure_cache = hash_make_cxt(PLyProcedureEntry, key, + "PL/Python procedures", 32, + TopMemoryContext); } /* diff --git a/src/pl/tcl/pltcl.c b/src/pl/tcl/pltcl.c index 73d660e88a6..a3ef429d926 100644 --- a/src/pl/tcl/pltcl.c +++ b/src/pl/tcl/pltcl.c @@ -408,7 +408,6 @@ void _PG_init(void) { Tcl_NotifierProcs notifier; - HASHCTL hash_ctl; /* Be sure we do initialization only once (should be redundant now) */ if (pltcl_pm_init_done) @@ -446,22 +445,16 @@ _PG_init(void) /************************************************************ * Create the hash table for working interpreters ************************************************************/ - hash_ctl.keysize = sizeof(Oid); - hash_ctl.entrysize = sizeof(pltcl_interp_desc); - pltcl_interp_htab = hash_create("PL/Tcl interpreters", - 8, - &hash_ctl, - HASH_ELEM | HASH_BLOBS); + pltcl_interp_htab = hash_make_cxt(pltcl_interp_desc, user_id, + "PL/Tcl interpreters", 8, + TopMemoryContext); /************************************************************ * Create the hash table for function lookup ************************************************************/ - hash_ctl.keysize = sizeof(pltcl_proc_key); - hash_ctl.entrysize = sizeof(pltcl_proc_ptr); - pltcl_proc_htab = hash_create("PL/Tcl functions", - 100, - &hash_ctl, - HASH_ELEM | HASH_BLOBS); + pltcl_proc_htab = hash_make_cxt(pltcl_proc_ptr, proc_key, + "PL/Tcl functions", 100, + TopMemoryContext); /************************************************************ * Define PL/Tcl's custom GUCs diff --git a/src/timezone/pgtz.c b/src/timezone/pgtz.c index 504c0235ffb..ce0edf98266 100644 --- a/src/timezone/pgtz.c +++ b/src/timezone/pgtz.c @@ -22,6 +22,7 @@ #include "pgtz.h" #include "storage/fd.h" #include "utils/hsearch.h" +#include "utils/memutils.h" /* Current session timezone (controlled by TimeZone GUC) */ @@ -201,15 +202,8 @@ static HTAB *timezone_cache = NULL; static bool init_timezone_hashtable(void) { - HASHCTL hash_ctl; - - hash_ctl.keysize = TZ_STRLEN_MAX + 1; - hash_ctl.entrysize = sizeof(pg_tz_cache); - - timezone_cache = hash_create("Timezones", - 4, - &hash_ctl, - HASH_ELEM | HASH_STRINGS); + timezone_cache = hash_make_cxt(pg_tz_cache, tznameupper, + "Timezones", 4, TopMemoryContext); if (!timezone_cache) return false; -- 2.52.0