public inbox for [email protected]
help / color / mirror / Atom feedFrom: bucoo <[email protected]>
To: Tomas Vondra <[email protected]>
To: 'pgsql-hackers' <[email protected]>
Cc: 'Tom Lane' <[email protected]>
Cc: 'Robert Haas' <[email protected]>
Subject: Re: optimize hashjoin
Date: Thu, 22 Aug 2024 20:08:12 +0800 (CST)
Message-ID: <[email protected]> (raw)
------=_Part_35779_1338760973.1724328493004
Content-Type: text/html;charset=utf-8
Content-Transfer-Encoding: base64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------=_Part_35779_1338760973.1724328493004
Content-Type: application/octet-stream; name=optimize-hashjoin-master.patch
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename=optimize-hashjoin-master.patch
Content-Length: 12172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------=_Part_35779_1338760973.1724328493004--
Attachments:
[application/octet-stream] optimize-hashjoin-master.patch (11.9K, ../[email protected]/2-optimize-hashjoin-master.patch)
download | inline diff:
diff --git a/src/backend/executor/nodeHash.c b/src/backend/executor/nodeHash.c
index 570a90ebe1..5e702a37ff 100644
--- a/src/backend/executor/nodeHash.c
+++ b/src/backend/executor/nodeHash.c
@@ -190,7 +190,7 @@ MultiExecPrivateHash(HashState *node)
else
{
/* Not subject to skew optimization, so insert normally */
- ExecHashTableInsert(hashtable, slot, hashvalue);
+ ExecHashTableInsertSlot(hashtable, slot, hashvalue);
}
hashtable->totalTuples += 1;
}
@@ -1594,7 +1594,7 @@ ExecParallelHashIncreaseNumBuckets(HashJoinTable hashtable)
}
/*
- * ExecHashTableInsert
+ * ExecHashTableInsertSlot
* insert a tuple into the hash table depending on the hash value
* it may just go to a temp file for later batches
*
@@ -1605,12 +1605,29 @@ ExecParallelHashIncreaseNumBuckets(HashJoinTable hashtable)
* worth the messiness required.
*/
void
-ExecHashTableInsert(HashJoinTable hashtable,
- TupleTableSlot *slot,
- uint32 hashvalue)
+ExecHashTableInsertSlot(HashJoinTable hashtable,
+ TupleTableSlot *slot,
+ uint32 hashvalue)
{
bool shouldFree;
MinimalTuple tuple = ExecFetchSlotMinimalTuple(slot, &shouldFree);
+
+ ExecHashTableInsertTuple(hashtable, tuple, hashvalue);
+
+ if (shouldFree)
+ heap_free_minimal_tuple(tuple);
+}
+
+/*
+ * ExecHashTableInsertTuple
+ * insert a tuple into the hash table depending on the hash value
+ * it may just go to a temp file for later batches
+ */
+void
+ExecHashTableInsertTuple(HashJoinTable hashtable,
+ MinimalTuple tuple,
+ uint32 hashvalue)
+{
int bucketno;
int batchno;
@@ -1685,9 +1702,6 @@ ExecHashTableInsert(HashJoinTable hashtable,
&hashtable->innerBatchFile[batchno],
hashtable);
}
-
- if (shouldFree)
- heap_free_minimal_tuple(tuple);
}
/*
@@ -1761,12 +1775,10 @@ retry:
* tuples that belong in the current batch once growth has been disabled.
*/
void
-ExecParallelHashTableInsertCurrentBatch(HashJoinTable hashtable,
- TupleTableSlot *slot,
- uint32 hashvalue)
+ExecParallelHashTableInsertTupleCurrentBatch(HashJoinTable hashtable,
+ MinimalTuple tuple,
+ uint32 hashvalue)
{
- bool shouldFree;
- MinimalTuple tuple = ExecFetchSlotMinimalTuple(slot, &shouldFree);
HashJoinTuple hashTuple;
dsa_pointer shared;
int batchno;
@@ -1782,6 +1794,21 @@ ExecParallelHashTableInsertCurrentBatch(HashJoinTable hashtable,
HeapTupleHeaderClearMatch(HJTUPLE_MINTUPLE(hashTuple));
ExecParallelHashPushTuple(&hashtable->buckets.shared[bucketno],
hashTuple, shared);
+}
+
+/*
+ * like ExecParallelHashTableInsertTupleCurrentBatch,
+ * but this function accept a TupleTableSlot
+ */
+void
+ExecParallelHashTableInsertSlotCurrentBatch(HashJoinTable hashtable,
+ TupleTableSlot *slot,
+ uint32 hashvalue)
+{
+ bool shouldFree;
+ MinimalTuple tuple = ExecFetchSlotMinimalTuple(slot, &shouldFree);
+
+ ExecParallelHashTableInsertTupleCurrentBatch(hashtable, tuple, hashvalue);
if (shouldFree)
heap_free_minimal_tuple(tuple);
@@ -2454,7 +2481,7 @@ ExecHashGetSkewBucket(HashJoinTable hashtable, uint32 hashvalue)
* Insert a tuple into the skew hashtable.
*
* This should generally match up with the current-batch case in
- * ExecHashTableInsert.
+ * ExecHashTableInsertSlot.
*/
static void
ExecHashSkewTableInsert(HashJoinTable hashtable,
@@ -2534,8 +2561,8 @@ ExecHashRemoveNextSkewBucket(HashJoinTable hashtable)
Size tupleSize;
/*
- * This code must agree with ExecHashTableInsert. We do not use
- * ExecHashTableInsert directly as ExecHashTableInsert expects a
+ * This code must agree with ExecHashTableInsertSlot. We do not use
+ * ExecHashTableInsertSlot directly as ExecHashTableInsertSlot expects a
* TupleTableSlot while we already have HashJoinTuples.
*/
tuple = HJTUPLE_MINTUPLE(hashTuple);
diff --git a/src/backend/executor/nodeHashjoin.c b/src/backend/executor/nodeHashjoin.c
index 2f7170604d..ba5c1d4b49 100644
--- a/src/backend/executor/nodeHashjoin.c
+++ b/src/backend/executor/nodeHashjoin.c
@@ -195,10 +195,10 @@ static TupleTableSlot *ExecHashJoinOuterGetTuple(PlanState *outerNode,
static TupleTableSlot *ExecParallelHashJoinOuterGetTuple(PlanState *outerNode,
HashJoinState *hjstate,
uint32 *hashvalue);
-static TupleTableSlot *ExecHashJoinGetSavedTuple(HashJoinState *hjstate,
- BufFile *file,
- uint32 *hashvalue,
- TupleTableSlot *tupleSlot);
+static MinimalTuple ExecHashJoinGetSavedTuple(HashJoinState *hjstate,
+ BufFile *file,
+ uint32 *hashvalue,
+ StringInfo buf);
static bool ExecHashJoinNewBatch(HashJoinState *hjstate);
static bool ExecParallelHashJoinNewBatch(HashJoinState *hjstate);
static void ExecParallelHashJoinPartitionOuter(HashJoinState *hjstate);
@@ -925,6 +925,7 @@ ExecInitHashJoin(HashJoin *node, EState *estate, int eflags)
*/
hjstate->hj_HashTable = NULL;
hjstate->hj_FirstOuterTupleSlot = NULL;
+ hjstate->hj_outerTupleBuffer = NULL;
hjstate->hj_CurHashValue = 0;
hjstate->hj_CurBucketNo = 0;
@@ -1030,6 +1031,7 @@ ExecHashJoinOuterGetTuple(PlanState *outerNode,
}
else if (curbatch < hashtable->nbatch)
{
+ MinimalTuple mtup;
BufFile *file = hashtable->outerBatchFile[curbatch];
/*
@@ -1039,12 +1041,38 @@ ExecHashJoinOuterGetTuple(PlanState *outerNode,
if (file == NULL)
return NULL;
- slot = ExecHashJoinGetSavedTuple(hjstate,
+ if (unlikely(hjstate->hj_outerTupleBuffer == NULL))
+ {
+ /*
+ * Avoid realloc memory for MinimalTuple, we alloc a buffer
+ * to reuse store MinimalTuple. MemoryContext same as hjstate.
+ */
+ MemoryContext oldcontext = MemoryContextSwitchTo(GetMemoryChunkContext(hjstate));
+ hjstate->hj_outerTupleBuffer = makeStringInfo();
+ MemoryContextSwitchTo(oldcontext);
+ }
+
+ mtup = ExecHashJoinGetSavedTuple(hjstate,
file,
hashvalue,
- hjstate->hj_OuterTupleSlot);
- if (!TupIsNull(slot))
+ hjstate->hj_outerTupleBuffer);
+ if (likely(mtup != NULL))
+ {
+ slot = hjstate->hj_OuterTupleSlot;
+
+ /*
+ * mtup is hold in hjstate->hj_outerTupleBuffer, so we can using
+ * shouldFree as false to call ExecForceStoreMinimalTuple().
+ *
+ * When slot is TTSOpsMinimalTuple we can avoid realloc memory for
+ * new MinimalTuple(reuse StringInfo to call ExecHashJoinGetSavedTuple).
+ *
+ * More importantly, in non-TTSOpsMinimalTuple scenarios, it can avoid
+ * reform(materialize) tuple(see ExecForceStoreMinimalTuple).
+ */
+ ExecForceStoreMinimalTuple(mtup, slot, false);
return slot;
+ }
}
/* End of this batch */
@@ -1133,7 +1161,6 @@ ExecHashJoinNewBatch(HashJoinState *hjstate)
int nbatch;
int curbatch;
BufFile *innerFile;
- TupleTableSlot *slot;
uint32 hashvalue;
nbatch = hashtable->nbatch;
@@ -1224,21 +1251,25 @@ ExecHashJoinNewBatch(HashJoinState *hjstate)
if (innerFile != NULL)
{
+ StringInfoData buf;
+ MinimalTuple tuple;
+
if (BufFileSeek(innerFile, 0, 0, SEEK_SET))
ereport(ERROR,
(errcode_for_file_access(),
errmsg("could not rewind hash-join temporary file")));
- while ((slot = ExecHashJoinGetSavedTuple(hjstate,
- innerFile,
- &hashvalue,
- hjstate->hj_HashTupleSlot)))
+ initStringInfo(&buf);
+ while ((tuple = ExecHashJoinGetSavedTuple(hjstate,
+ innerFile,
+ &hashvalue,
+ &buf)))
{
/*
* NOTE: some tuples may be sent to future batches. Also, it is
* possible for hashtable->nbatch to be increased here!
*/
- ExecHashTableInsert(hashtable, slot, hashvalue);
+ ExecHashTableInsertTuple(hashtable, tuple, hashvalue);
}
/*
@@ -1247,6 +1278,7 @@ ExecHashJoinNewBatch(HashJoinState *hjstate)
*/
BufFileClose(innerFile);
hashtable->innerBatchFile[curbatch] = NULL;
+ pfree(buf.data);
}
/*
@@ -1297,7 +1329,6 @@ ExecParallelHashJoinNewBatch(HashJoinState *hjstate)
{
uint32 hashvalue;
MinimalTuple tuple;
- TupleTableSlot *slot;
if (!hashtable->batches[batchno].done)
{
@@ -1329,12 +1360,9 @@ ExecParallelHashJoinNewBatch(HashJoinState *hjstate)
while ((tuple = sts_parallel_scan_next(inner_tuples,
&hashvalue)))
{
- ExecForceStoreMinimalTuple(tuple,
- hjstate->hj_HashTupleSlot,
- false);
- slot = hjstate->hj_HashTupleSlot;
- ExecParallelHashTableInsertCurrentBatch(hashtable, slot,
- hashvalue);
+ ExecParallelHashTableInsertTupleCurrentBatch(hashtable,
+ tuple,
+ hashvalue);
}
sts_end_parallel_scan(inner_tuples);
BarrierArriveAndWait(batch_barrier,
@@ -1448,14 +1476,14 @@ ExecHashJoinSaveTuple(MinimalTuple tuple, uint32 hashvalue,
* ExecHashJoinGetSavedTuple
* read the next tuple from a batch file. Return NULL if no more.
*
- * On success, *hashvalue is set to the tuple's hash value, and the tuple
- * itself is stored in the given slot.
+ * On success, *hashvalue is set to the tuple's hash value, and return
+ * the tuple(stored in the given buf) itself.
*/
-static TupleTableSlot *
+static MinimalTuple
ExecHashJoinGetSavedTuple(HashJoinState *hjstate,
BufFile *file,
uint32 *hashvalue,
- TupleTableSlot *tupleSlot)
+ StringInfo buf)
{
uint32 header[2];
size_t nread;
@@ -1474,19 +1502,20 @@ ExecHashJoinGetSavedTuple(HashJoinState *hjstate,
* cheating.
*/
nread = BufFileReadMaybeEOF(file, header, sizeof(header), true);
- if (nread == 0) /* end of file */
- {
- ExecClearTuple(tupleSlot);
+ if (unlikely(nread == 0)) /* end of file */
return NULL;
- }
+
+ buf->len = 0; /* inline resetStringInfo(buf); */
+ enlargeStringInfo(buf, header[1]);
+ buf->len = header[1];
*hashvalue = header[0];
- tuple = (MinimalTuple) palloc(header[1]);
+ tuple = (MinimalTuple) buf->data;
tuple->t_len = header[1];
BufFileReadExact(file,
(char *) tuple + sizeof(uint32),
header[1] - sizeof(uint32));
- ExecForceStoreMinimalTuple(tuple, tupleSlot, true);
- return tupleSlot;
+
+ return tuple;
}
diff --git a/src/include/executor/nodeHash.h b/src/include/executor/nodeHash.h
index e4eb7bc635..6cc2264692 100644
--- a/src/include/executor/nodeHash.h
+++ b/src/include/executor/nodeHash.h
@@ -33,15 +33,21 @@ extern void ExecHashTableDetachBatch(HashJoinTable hashtable);
extern void ExecParallelHashTableSetCurrentBatch(HashJoinTable hashtable,
int batchno);
-extern void ExecHashTableInsert(HashJoinTable hashtable,
- TupleTableSlot *slot,
- uint32 hashvalue);
+extern void ExecHashTableInsertSlot(HashJoinTable hashtable,
+ TupleTableSlot *slot,
+ uint32 hashvalue);
+extern void ExecHashTableInsertTuple(HashJoinTable hashtable,
+ MinimalTuple tuple,
+ uint32 hashvalue);
extern void ExecParallelHashTableInsert(HashJoinTable hashtable,
TupleTableSlot *slot,
uint32 hashvalue);
-extern void ExecParallelHashTableInsertCurrentBatch(HashJoinTable hashtable,
- TupleTableSlot *slot,
- uint32 hashvalue);
+extern void ExecParallelHashTableInsertSlotCurrentBatch(HashJoinTable hashtable,
+ TupleTableSlot *slot,
+ uint32 hashvalue);
+extern void ExecParallelHashTableInsertTupleCurrentBatch(HashJoinTable hashtable,
+ MinimalTuple tuple,
+ uint32 hashvalue);
extern void ExecHashGetBucketAndBatch(HashJoinTable hashtable,
uint32 hashvalue,
int *bucketno,
diff --git a/src/include/nodes/execnodes.h b/src/include/nodes/execnodes.h
index af7d8fd1e7..299f66af13 100644
--- a/src/include/nodes/execnodes.h
+++ b/src/include/nodes/execnodes.h
@@ -2225,6 +2225,7 @@ typedef struct HashJoinState
TupleTableSlot *hj_NullOuterTupleSlot;
TupleTableSlot *hj_NullInnerTupleSlot;
TupleTableSlot *hj_FirstOuterTupleSlot;
+ StringInfo hj_outerTupleBuffer;
int hj_JoinState;
bool hj_MatchedOuter;
bool hj_OuterNotEmpty;
view thread (2+ messages)
reply
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Reply to all the recipients using the --to and --cc options:
reply via email
To: [email protected]
Cc: [email protected], [email protected], [email protected], [email protected]
Subject: Re: optimize hashjoin
In-Reply-To: <[email protected]>
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox