From cf6eb2e645304382d9d4a6ad0ec17e10938363f7 Mon Sep 17 00:00:00 2001 From: Andres Freund Date: Mon, 14 Jan 2019 12:50:05 -0800 Subject: [PATCH v1 3/4] WIP: Allow to reset tuple hashtables. This has the advantage that the comparator expression, the table's slot, etc do not have to be rebuilt. Additionally the simplehash.h hashtable within the tuple hashtable now keeps its previous size and doesn't need to be reallocated. That both reduces allocator overhead, and improves performance in cases where the input estimation was off by a significant factor. To avoid an API/ABI break, the new parameter is exposed via the new BuildTupleHashTableExt(), and BuildTupleHashTable() now is a wrapper around the former, that continues to allocate the table itself in the tablecxt. Author: Reviewed-By: Discussion: https://postgr.es/m/ Backpatch: --- src/backend/executor/execGrouping.c | 70 +++++++++++++++++++++++------ src/include/executor/executor.h | 10 +++++ 2 files changed, 66 insertions(+), 14 deletions(-) diff --git a/src/backend/executor/execGrouping.c b/src/backend/executor/execGrouping.c index 7cf001518a1..a9d80e692b5 100644 --- a/src/backend/executor/execGrouping.c +++ b/src/backend/executor/execGrouping.c @@ -139,7 +139,8 @@ execTuplesHashPrepare(int numCols, * hashfunctions: datatype-specific hashing functions to use * nbuckets: initial estimate of hashtable size * additionalsize: size of data stored in ->additional - * tablecxt: memory context in which to store table and table entries + * metacxt: memory context for long-lived allocation, but not per-entry data + * tablecxt: memory context in which to store table entries * tempcxt: short-lived context for evaluation hash and comparison functions * * The function arrays may be made with execTuplesHashPrepare(). Note they @@ -150,14 +151,16 @@ execTuplesHashPrepare(int numCols, * storage that will live as long as the hashtable does. */ TupleHashTable -BuildTupleHashTable(PlanState *parent, - TupleDesc inputDesc, - int numCols, AttrNumber *keyColIdx, - const Oid *eqfuncoids, - FmgrInfo *hashfunctions, - long nbuckets, Size additionalsize, - MemoryContext tablecxt, MemoryContext tempcxt, - bool use_variable_hash_iv) +BuildTupleHashTableExt(PlanState *parent, + TupleDesc inputDesc, + int numCols, AttrNumber *keyColIdx, + const Oid *eqfuncoids, + FmgrInfo *hashfunctions, + long nbuckets, Size additionalsize, + MemoryContext metacxt, + MemoryContext tablecxt, + MemoryContext tempcxt, + bool use_variable_hash_iv) { TupleHashTable hashtable; Size entrysize = sizeof(TupleHashEntryData) + additionalsize; @@ -168,8 +171,9 @@ BuildTupleHashTable(PlanState *parent, /* Limit initial table size request to not more than work_mem */ nbuckets = Min(nbuckets, (long) ((work_mem * 1024L) / entrysize)); - hashtable = (TupleHashTable) - MemoryContextAlloc(tablecxt, sizeof(TupleHashTableData)); + oldcontext = MemoryContextSwitchTo(metacxt); + + hashtable = (TupleHashTable) palloc(sizeof(TupleHashTableData)); hashtable->numCols = numCols; hashtable->keyColIdx = keyColIdx; @@ -195,9 +199,7 @@ BuildTupleHashTable(PlanState *parent, else hashtable->hash_iv = 0; - hashtable->hashtab = tuplehash_create(tablecxt, nbuckets, hashtable); - - oldcontext = MemoryContextSwitchTo(hashtable->tablecxt); + hashtable->hashtab = tuplehash_create(metacxt, nbuckets, hashtable); /* * We copy the input tuple descriptor just for safety --- we assume all @@ -227,6 +229,46 @@ BuildTupleHashTable(PlanState *parent, return hashtable; } +/* + * BuildTupleHashTable is a backwards-compatibilty wrapper for + * BuildTupleHashTableExt(), that allocates the hashtable's metadata in + * tablecxt. Note that hashtables created this way cannot be reset leak-free + * with ResetTupleHashTable(). + */ +TupleHashTable +BuildTupleHashTable(PlanState *parent, + TupleDesc inputDesc, + int numCols, AttrNumber *keyColIdx, + const Oid *eqfuncoids, + FmgrInfo *hashfunctions, + long nbuckets, Size additionalsize, + MemoryContext tablecxt, + MemoryContext tempcxt, + bool use_variable_hash_iv) +{ + return BuildTupleHashTableExt(parent, + inputDesc, + numCols, keyColIdx, + eqfuncoids, + hashfunctions, + nbuckets, additionalsize, + tablecxt, + tablecxt, + tempcxt, + use_variable_hash_iv); +} + +/* + * Reset contents of the hashtable to be empty, preserving all the non-content + * state. Note that the tablecxt passed to BuildTupleHashTableExt() should + * also be reset, otherwise there will be leaks. + */ +void +ResetTupleHashTable(TupleHashTable hashtable) +{ + tuplehash_reset(hashtable->hashtab); +} + /* * Find or create a hashtable entry for the tuple group containing the * given tuple. The tuple must be the same type as the hashtable entries. diff --git a/src/include/executor/executor.h b/src/include/executor/executor.h index 50a943b6183..530e9c65749 100644 --- a/src/include/executor/executor.h +++ b/src/include/executor/executor.h @@ -123,6 +123,15 @@ extern TupleHashTable BuildTupleHashTable(PlanState *parent, long nbuckets, Size additionalsize, MemoryContext tablecxt, MemoryContext tempcxt, bool use_variable_hash_iv); +extern TupleHashTable BuildTupleHashTableExt(PlanState *parent, + TupleDesc inputDesc, + int numCols, AttrNumber *keyColIdx, + const Oid *eqfuncoids, + FmgrInfo *hashfunctions, + long nbuckets, Size additionalsize, + MemoryContext metacxt, + MemoryContext tablecxt, + MemoryContext tempcxt, bool use_variable_hash_iv); extern TupleHashEntry LookupTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot, bool *isnew); @@ -130,6 +139,7 @@ extern TupleHashEntry FindTupleHashEntry(TupleHashTable hashtable, TupleTableSlot *slot, ExprState *eqcomp, FmgrInfo *hashfunctions); +extern void ResetTupleHashTable(TupleHashTable hashtable); /* * prototypes from functions in execJunk.c -- 2.18.0.rc2.dirty