From 61b13cc9a2a0445d6ab992520a945437cd0f275c Mon Sep 17 00:00:00 2001 From: Tomas Vondra Date: Fri, 13 Oct 2023 23:04:39 +0200 Subject: [PATCH 3/4] remove prefetch_reset --- src/backend/access/heap/heapam_handler.c | 6 +-- src/backend/access/index/genam.c | 4 +- src/backend/access/index/indexam.c | 38 +++++++---------- src/backend/executor/execIndexing.c | 2 +- src/backend/executor/execReplication.c | 2 +- src/backend/executor/nodeIndexonlyscan.c | 6 +-- src/backend/executor/nodeIndexscan.c | 53 ++++++++++-------------- src/backend/utils/adt/selfuncs.c | 3 +- src/include/access/genam.h | 6 +-- src/include/access/relscan.h | 4 +- 10 files changed, 52 insertions(+), 72 deletions(-) diff --git a/src/backend/access/heap/heapam_handler.c b/src/backend/access/heap/heapam_handler.c index ca91bc5e878..89474078951 100644 --- a/src/backend/access/heap/heapam_handler.c +++ b/src/backend/access/heap/heapam_handler.c @@ -748,14 +748,14 @@ heapam_relation_copy_for_cluster(Relation OldHeap, Relation NewHeap, PROGRESS_CLUSTER_INDEX_RELID }; int64 ci_val[2]; - int prefetch_target; + int prefetch_max; /* * Get the prefetch target for the old tablespace (which is what we'll * read using the index). We'll use it as a reset value too, although * there should be no rescans for CLUSTER etc. */ - prefetch_target = get_tablespace_io_concurrency(OldHeap->rd_rel->reltablespace); + prefetch_max = get_tablespace_io_concurrency(OldHeap->rd_rel->reltablespace); /* Set phase and OIDOldIndex to columns */ ci_val[0] = PROGRESS_CLUSTER_PHASE_INDEX_SCAN_HEAP; @@ -765,7 +765,7 @@ heapam_relation_copy_for_cluster(Relation OldHeap, Relation NewHeap, tableScan = NULL; heapScan = NULL; indexScan = index_beginscan(OldHeap, OldIndex, SnapshotAny, 0, 0, - prefetch_target, prefetch_target); + prefetch_max); index_rescan(indexScan, NULL, 0, NULL, 0); } else diff --git a/src/backend/access/index/genam.c b/src/backend/access/index/genam.c index 6e3aa6bb1fd..d45a209ee3a 100644 --- a/src/backend/access/index/genam.c +++ b/src/backend/access/index/genam.c @@ -456,7 +456,7 @@ systable_beginscan(Relation heapRelation, * use effective_io_concurrency, but it doesn't seem worth it. */ sysscan->iscan = index_beginscan(heapRelation, irel, - snapshot, nkeys, 0, 0, 0); + snapshot, nkeys, 0, 0); index_rescan(sysscan->iscan, key, nkeys, NULL, 0); sysscan->scan = NULL; } @@ -724,7 +724,7 @@ systable_beginscan_ordered(Relation heapRelation, * use effective_io_concurrency, but it doesn't seem worth it. */ sysscan->iscan = index_beginscan(heapRelation, indexRelation, - snapshot, nkeys, 0, 0, 0); + snapshot, nkeys, 0, 0); index_rescan(sysscan->iscan, key, nkeys, NULL, 0); sysscan->scan = NULL; diff --git a/src/backend/access/index/indexam.c b/src/backend/access/index/indexam.c index e45a3a89387..8c56acfd638 100644 --- a/src/backend/access/index/indexam.c +++ b/src/backend/access/index/indexam.c @@ -109,7 +109,7 @@ do { \ static IndexScanDesc index_beginscan_internal(Relation indexRelation, int nkeys, int norderbys, Snapshot snapshot, ParallelIndexScanDesc pscan, bool temp_snap, - int prefetch_target, int prefetch_reset); + int prefetch_max); static void index_prefetch(IndexScanDesc scan, ItemPointer tid); @@ -206,13 +206,10 @@ index_insert(Relation indexRelation, * * Caller must be holding suitable locks on the heap and the index. * - * prefetch_target determines if prefetching is requested for this index scan, + * prefetch_max determines if prefetching is requested for this index scan, * and how far ahead we want to prefetch * - * prefetch_reset specifies the prefetch distance to start with on rescans (so - * that we don't ramp-up to prefetch_target and use that forever) - * - * Setting prefetch_target to 0 disables prefetching for the index scan. We do + * Setting prefetch_max to 0 disables prefetching for the index scan. We do * this for two reasons - for scans on system catalogs, and/or for cases where * prefetching is expected to be pointless (like IOS). * @@ -236,14 +233,14 @@ index_beginscan(Relation heapRelation, Relation indexRelation, Snapshot snapshot, int nkeys, int norderbys, - int prefetch_target, int prefetch_reset) + int prefetch_max) { IndexScanDesc scan; Assert(snapshot != InvalidSnapshot); - scan = index_beginscan_internal(indexRelation, nkeys, norderbys, snapshot, NULL, false, - prefetch_target, prefetch_reset); + scan = index_beginscan_internal(indexRelation, nkeys, norderbys, snapshot, + NULL, false, prefetch_max); /* * Save additional parameters into the scandesc. Everything else was set @@ -273,12 +270,8 @@ index_beginscan_bitmap(Relation indexRelation, Assert(snapshot != InvalidSnapshot); - /* - * No prefetch for bitmap index scans. In this case prefetching happens at - * the heapscan level. - */ - scan = index_beginscan_internal(indexRelation, nkeys, 0, snapshot, NULL, false, - 0, 0); + /* No prefetch in bitmap scans, prefetch is done by the heap scan. */ + scan = index_beginscan_internal(indexRelation, nkeys, 0, snapshot, NULL, false, 0); /* * Save additional parameters into the scandesc. Everything else was set @@ -296,7 +289,7 @@ static IndexScanDesc index_beginscan_internal(Relation indexRelation, int nkeys, int norderbys, Snapshot snapshot, ParallelIndexScanDesc pscan, bool temp_snap, - int prefetch_target, int prefetch_reset) + int prefetch_max) { IndexScanDesc scan; @@ -321,7 +314,7 @@ index_beginscan_internal(Relation indexRelation, scan->xs_temp_snap = temp_snap; /* With prefetching requested, initialize the prefetcher state. */ - if (prefetch_target > 0) + if (prefetch_max > 0) { IndexPrefetch prefetcher = palloc0(sizeof(IndexPrefetchData)); @@ -330,8 +323,7 @@ index_beginscan_internal(Relation indexRelation, prefetcher->queueEnd = 0; prefetcher->prefetchTarget = 0; - prefetcher->prefetchMaxTarget = prefetch_target; - prefetcher->prefetchReset = prefetch_reset; + prefetcher->prefetchMaxTarget = prefetch_max; scan->xs_prefetch = prefetcher; } @@ -382,8 +374,8 @@ index_rescan(IndexScanDesc scan, prefetcher->queueIndex = 0; prefetcher->prefetchDone = false; - prefetcher->prefetchTarget = Min(prefetcher->prefetchTarget, - prefetcher->prefetchReset); + /* restart the incremental ramp-up */ + prefetcher->prefetchTarget = 0; } } @@ -576,7 +568,7 @@ index_parallelrescan(IndexScanDesc scan) IndexScanDesc index_beginscan_parallel(Relation heaprel, Relation indexrel, int nkeys, int norderbys, ParallelIndexScanDesc pscan, - int prefetch_target, int prefetch_reset) + int prefetch_max) { Snapshot snapshot; IndexScanDesc scan; @@ -585,7 +577,7 @@ index_beginscan_parallel(Relation heaprel, Relation indexrel, int nkeys, snapshot = RestoreSnapshot(pscan->ps_snapshot_data); RegisterSnapshot(snapshot); scan = index_beginscan_internal(indexrel, nkeys, norderbys, snapshot, - pscan, true, prefetch_target, prefetch_reset); + pscan, true, prefetch_max); /* * Save additional parameters into the scandesc. Everything else was set diff --git a/src/backend/executor/execIndexing.c b/src/backend/executor/execIndexing.c index 09418f715fa..eae1d8f9233 100644 --- a/src/backend/executor/execIndexing.c +++ b/src/backend/executor/execIndexing.c @@ -773,7 +773,7 @@ check_exclusion_or_unique_constraint(Relation heap, Relation index, retry: conflict = false; found_self = false; - index_scan = index_beginscan(heap, index, &DirtySnapshot, indnkeyatts, 0, 0, 0); + index_scan = index_beginscan(heap, index, &DirtySnapshot, indnkeyatts, 0, 0); index_rescan(index_scan, scankeys, indnkeyatts, NULL, 0); while (index_getnext_slot(index_scan, ForwardScanDirection, existing_slot)) diff --git a/src/backend/executor/execReplication.c b/src/backend/executor/execReplication.c index f3e1a8d22a4..91676ccff95 100644 --- a/src/backend/executor/execReplication.c +++ b/src/backend/executor/execReplication.c @@ -210,7 +210,7 @@ RelationFindReplTupleByIndex(Relation rel, Oid idxoid, * probably using a PK / UNIQUE index, so does not seem worth it. If we * reconsider this, calclate prefetch_target like in nodeIndexscan. */ - scan = index_beginscan(rel, idxrel, &snap, skey_attoff, 0, 0, 0); + scan = index_beginscan(rel, idxrel, &snap, skey_attoff, 0, 0); retry: found = false; diff --git a/src/backend/executor/nodeIndexonlyscan.c b/src/backend/executor/nodeIndexonlyscan.c index 75b44db33c6..7c27913502c 100644 --- a/src/backend/executor/nodeIndexonlyscan.c +++ b/src/backend/executor/nodeIndexonlyscan.c @@ -100,7 +100,7 @@ IndexOnlyNext(IndexOnlyScanState *node) estate->es_snapshot, node->ioss_NumScanKeys, node->ioss_NumOrderByKeys, - 0, 0); /* no index prefetch for IOS */ + 0); /* no prefetching for IOS */ node->ioss_ScanDesc = scandesc; @@ -667,7 +667,7 @@ ExecIndexOnlyScanInitializeDSM(IndexOnlyScanState *node, node->ioss_NumScanKeys, node->ioss_NumOrderByKeys, piscan, - 0, 0); /* no index prefetch for IOS */ + 0); /* no prefetching for IOS */ node->ioss_ScanDesc->xs_want_itup = true; node->ioss_VMBuffer = InvalidBuffer; @@ -713,7 +713,7 @@ ExecIndexOnlyScanInitializeWorker(IndexOnlyScanState *node, node->ioss_NumScanKeys, node->ioss_NumOrderByKeys, piscan, - 0, 0); /* no index prefetch for IOS */ + 0); /* no prefetching for IOS */ node->ioss_ScanDesc->xs_want_itup = true; /* diff --git a/src/backend/executor/nodeIndexscan.c b/src/backend/executor/nodeIndexscan.c index 9796f8b979c..a5f5394ef49 100644 --- a/src/backend/executor/nodeIndexscan.c +++ b/src/backend/executor/nodeIndexscan.c @@ -105,12 +105,11 @@ IndexNext(IndexScanState *node) if (scandesc == NULL) { - int prefetch_target; - int prefetch_reset; + int prefetch_max; /* - * Determine number of heap pages to prefetch for this index. This is - * essentially just effective_io_concurrency for the table (or the + * Determine number of heap pages to prefetch for this index scan. This + * is essentially just effective_io_concurrency for the table (or the * tablespace it's in). * * XXX Should this also look at plan.plan_rows and maybe cap the target @@ -118,8 +117,8 @@ IndexNext(IndexScanState *node) * just reset to that value during prefetching, after reading the next * index page (or rather after rescan)? */ - prefetch_target = get_tablespace_io_concurrency(heapRel->rd_rel->reltablespace); - prefetch_reset = Min(prefetch_target, node->ss.ps.plan->plan_rows); + prefetch_max = Min(get_tablespace_io_concurrency(heapRel->rd_rel->reltablespace), + node->ss.ps.plan->plan_rows); /* * We reach here if the index scan is not parallel, or if we're @@ -130,8 +129,7 @@ IndexNext(IndexScanState *node) estate->es_snapshot, node->iss_NumScanKeys, node->iss_NumOrderByKeys, - prefetch_target, - prefetch_reset); + prefetch_max); node->iss_ScanDesc = scandesc; @@ -197,6 +195,7 @@ IndexNextWithReorder(IndexScanState *node) Datum *lastfetched_vals; bool *lastfetched_nulls; int cmp; + Relation heapRel = node->ss.ss_currentRelation; estate = node->ss.ps.state; @@ -218,9 +217,7 @@ IndexNextWithReorder(IndexScanState *node) if (scandesc == NULL) { - Relation heapRel = node->ss.ss_currentRelation; - int prefetch_target; - int prefetch_reset; + int prefetch_max; /* * Determine number of heap pages to prefetch for this index. This is @@ -232,8 +229,8 @@ IndexNextWithReorder(IndexScanState *node) * just reset to that value during prefetching, after reading the next * index page (or rather after rescan)? */ - prefetch_target = get_tablespace_io_concurrency(heapRel->rd_rel->reltablespace); - prefetch_reset = Min(prefetch_target, node->ss.ps.plan->plan_rows); + prefetch_max = Min(get_tablespace_io_concurrency(heapRel->rd_rel->reltablespace), + node->ss.ps.plan->plan_rows); /* * We reach here if the index scan is not parallel, or if we're @@ -244,8 +241,7 @@ IndexNextWithReorder(IndexScanState *node) estate->es_snapshot, node->iss_NumScanKeys, node->iss_NumOrderByKeys, - prefetch_target, - prefetch_reset); + prefetch_max); node->iss_ScanDesc = scandesc; @@ -1701,9 +1697,8 @@ ExecIndexScanInitializeDSM(IndexScanState *node, { EState *estate = node->ss.ps.state; ParallelIndexScanDesc piscan; - Relation heapRel; - int prefetch_target; - int prefetch_reset; + Relation heapRel = node->ss.ss_currentRelation; + int prefetch_max; /* * Determine number of heap pages to prefetch for this index. This is @@ -1717,10 +1712,9 @@ ExecIndexScanInitializeDSM(IndexScanState *node, * * XXX Maybe reduce the value with parallel workers? */ - heapRel = node->ss.ss_currentRelation; - prefetch_target = get_tablespace_io_concurrency(heapRel->rd_rel->reltablespace); - prefetch_reset = Min(prefetch_target, node->ss.ps.plan->plan_rows); + prefetch_max = Min(get_tablespace_io_concurrency(heapRel->rd_rel->reltablespace), + node->ss.ps.plan->plan_rows); piscan = shm_toc_allocate(pcxt->toc, node->iss_PscanLen); index_parallelscan_initialize(node->ss.ss_currentRelation, @@ -1734,8 +1728,7 @@ ExecIndexScanInitializeDSM(IndexScanState *node, node->iss_NumScanKeys, node->iss_NumOrderByKeys, piscan, - prefetch_target, - prefetch_reset); + prefetch_max); /* * If no run-time keys to calculate or they are ready, go ahead and pass @@ -1771,9 +1764,8 @@ ExecIndexScanInitializeWorker(IndexScanState *node, ParallelWorkerContext *pwcxt) { ParallelIndexScanDesc piscan; - Relation heapRel; - int prefetch_target; - int prefetch_reset; + Relation heapRel = node->ss.ss_currentRelation; + int prefetch_max; /* * Determine number of heap pages to prefetch for this index. This is @@ -1787,10 +1779,8 @@ ExecIndexScanInitializeWorker(IndexScanState *node, * * XXX Maybe reduce the value with parallel workers? */ - heapRel = node->ss.ss_currentRelation; - - prefetch_target = get_tablespace_io_concurrency(heapRel->rd_rel->reltablespace); - prefetch_reset = Min(prefetch_target, node->ss.ps.plan->plan_rows); + prefetch_max = Min(get_tablespace_io_concurrency(heapRel->rd_rel->reltablespace), + node->ss.ps.plan->plan_rows); piscan = shm_toc_lookup(pwcxt->toc, node->ss.ps.plan->plan_node_id, false); node->iss_ScanDesc = @@ -1799,8 +1789,7 @@ ExecIndexScanInitializeWorker(IndexScanState *node, node->iss_NumScanKeys, node->iss_NumOrderByKeys, piscan, - prefetch_target, - prefetch_reset); + prefetch_max); /* * If no run-time keys to calculate or they are ready, go ahead and pass diff --git a/src/backend/utils/adt/selfuncs.c b/src/backend/utils/adt/selfuncs.c index 0b02b6265d0..52e3aaaf20a 100644 --- a/src/backend/utils/adt/selfuncs.c +++ b/src/backend/utils/adt/selfuncs.c @@ -6216,9 +6216,10 @@ get_actual_variable_endpoint(Relation heapRel, InitNonVacuumableSnapshot(SnapshotNonVacuumable, GlobalVisTestFor(heapRel)); + /* XXX Maybe should do prefetching using the default prefetch parameters? */ index_scan = index_beginscan(heapRel, indexRel, &SnapshotNonVacuumable, - 1, 0, 0, 0); /* XXX maybe do prefetch? */ + 1, 0, 0); /* Set it up for index-only scan */ index_scan->xs_want_itup = true; index_rescan(index_scan, scankeys, 1, NULL, 0); diff --git a/src/include/access/genam.h b/src/include/access/genam.h index 907ab886d3e..ceb6279b0b0 100644 --- a/src/include/access/genam.h +++ b/src/include/access/genam.h @@ -154,8 +154,7 @@ extern IndexScanDesc index_beginscan(Relation heapRelation, Relation indexRelation, Snapshot snapshot, int nkeys, int norderbys, - int prefetch_target, - int prefetch_reset); + int prefetch_max); extern IndexScanDesc index_beginscan_bitmap(Relation indexRelation, Snapshot snapshot, int nkeys); @@ -173,8 +172,7 @@ extern void index_parallelrescan(IndexScanDesc scan); extern IndexScanDesc index_beginscan_parallel(Relation heaprel, Relation indexrel, int nkeys, int norderbys, ParallelIndexScanDesc pscan, - int prefetch_target, - int prefetch_reset); + int prefetch_max); extern ItemPointer index_getnext_tid(IndexScanDesc scan, ScanDirection direction); struct TupleTableSlot; diff --git a/src/include/access/relscan.h b/src/include/access/relscan.h index c119fe597d8..231a30ecc46 100644 --- a/src/include/access/relscan.h +++ b/src/include/access/relscan.h @@ -107,7 +107,7 @@ typedef struct IndexFetchTableData } IndexFetchTableData; /* - * Forward declaration, defined in genam.h. + * Forward declarations, defined in genam.h. */ typedef struct IndexPrefetchData IndexPrefetchData; typedef struct IndexPrefetchData *IndexPrefetch; @@ -168,7 +168,7 @@ typedef struct IndexScanDescData bool *xs_orderbynulls; bool xs_recheckorderby; - /* prefetching state (or NULL if disabled) */ + /* prefetching state (or NULL if disabled for this scan) */ IndexPrefetchData *xs_prefetch; /* parallel index scan information, in shared memory */ -- 2.41.0