heapam: Pass number of required pages to RelationGetBufferForTuple()

A future commit will use this information to determine how aggressively to
extend the relation by. In heap_multi_insert() we know accurately how many
pages we need once we need to extend the relation, providing an accurate lower
bound for how much to extend.

Reviewed-by: Melanie Plageman <melanieplageman@gmail.com>
Discussion: https://postgr.es/m/20221029025420.eplyow6k7tgu6he3@awork3.anarazel.de

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index f7d9ce59a4790aef587beef073f37fdea8c8b449..57083a33ee5da33ea2797a4cc36ee98314d8da94 100644 (file)
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -1847,7 +1847,8 @@ heap_insert(Relation relation, HeapTuple tup, CommandId cid,
         */
        buffer = RelationGetBufferForTuple(relation, heaptup->t_len,
                                                                           InvalidBuffer, options, bistate,
-                                                                          &vmbuffer, NULL);
+                                                                          &vmbuffer, NULL,
+                                                                          0);
 
        /*
         * We're about to do the actual insert -- but check for conflict first, to
@@ -2050,6 +2051,32 @@ heap_prepare_insert(Relation relation, HeapTuple tup, TransactionId xid,
                return tup;
 }
 
+/*
+ * Helper for heap_multi_insert() that computes the number of entire pages
+ * that inserting the remaining heaptuples requires. Used to determine how
+ * much the relation needs to be extended by.
+ */
+static int
+heap_multi_insert_pages(HeapTuple *heaptuples, int done, int ntuples, Size saveFreeSpace)
+{
+       size_t          page_avail = BLCKSZ - SizeOfPageHeaderData - saveFreeSpace;
+       int                     npages = 1;
+
+       for (int i = done; i < ntuples; i++)
+       {
+               size_t          tup_sz = sizeof(ItemIdData) + MAXALIGN(heaptuples[i]->t_len);
+
+               if (page_avail < tup_sz)
+               {
+                       npages++;
+                       page_avail = BLCKSZ - SizeOfPageHeaderData - saveFreeSpace;
+               }
+               page_avail -= tup_sz;
+       }
+
+       return npages;
+}
+
 /*
  *     heap_multi_insert       - insert multiple tuples into a heap
  *
@@ -2076,6 +2103,9 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
        Size            saveFreeSpace;
        bool            need_tuple_data = RelationIsLogicallyLogged(relation);
        bool            need_cids = RelationIsAccessibleInLogicalDecoding(relation);
+       bool            starting_with_empty_page = false;
+       int                     npages = 0;
+       int                     npages_used = 0;
 
        /* currently not needed (thus unsupported) for heap_multi_insert() */
        Assert(!(options & HEAP_INSERT_NO_LOGICAL));
@@ -2126,13 +2156,31 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
        while (ndone < ntuples)
        {
                Buffer          buffer;
-               bool            starting_with_empty_page;
                bool            all_visible_cleared = false;
                bool            all_frozen_set = false;
                int                     nthispage;
 
                CHECK_FOR_INTERRUPTS();
 
+               /*
+                * Compute number of pages needed to fit the to-be-inserted tuples in
+                * the worst case.  This will be used to determine how much to extend
+                * the relation by in RelationGetBufferForTuple(), if needed.  If we
+                * filled a prior page from scratch, we can just update our last
+                * computation, but if we started with a partially filled page,
+                * recompute from scratch, the number of potentially required pages
+                * can vary due to tuples needing to fit onto the page, page headers
+                * etc.
+                */
+               if (ndone == 0 || !starting_with_empty_page)
+               {
+                       npages = heap_multi_insert_pages(heaptuples, ndone, ntuples,
+                                                                                        saveFreeSpace);
+                       npages_used = 0;
+               }
+               else
+                       npages_used++;
+
                /*
                 * Find buffer where at least the next tuple will fit.  If the page is
                 * all-visible, this will also pin the requisite visibility map page.
@@ -2142,7 +2190,8 @@ heap_multi_insert(Relation relation, TupleTableSlot **slots, int ntuples,
                 */
                buffer = RelationGetBufferForTuple(relation, heaptuples[ndone]->t_len,
                                                                                   InvalidBuffer, options, bistate,
-                                                                                  &vmbuffer, NULL);
+                                                                                  &vmbuffer, NULL,
+                                                                                  npages - npages_used);
                page = BufferGetPage(buffer);
 
                starting_with_empty_page = PageGetMaxOffsetNumber(page) == 0;
@@ -3576,7 +3625,8 @@ l2:
                                /* It doesn't fit, must use RelationGetBufferForTuple. */
                                newbuf = RelationGetBufferForTuple(relation, heaptup->t_len,
                                                                                                   buffer, 0, NULL,
-                                                                                                  &vmbuffer_new, &vmbuffer);
+                                                                                                  &vmbuffer_new, &vmbuffer,
+                                                                                                  0);
                                /* We're all done. */
                                break;
                        }

diff --git a/src/backend/access/heap/hio.c b/src/backend/access/heap/hio.c
index a0713c178ac31f9fc1e466d51740489c70f26a0f..f24e3d96eb9722f482b42bed7c60ab395365a8f2 100644 (file)
--- a/src/backend/access/heap/hio.c
+++ b/src/backend/access/heap/hio.c
@@ -301,6 +301,11 @@ RelationAddExtraBlocks(Relation relation, BulkInsertState bistate)
  *     Returns pinned and exclusive-locked buffer of a page in given relation
  *     with free space >= given len.
  *
+ *     If num_pages is > 1, we will try to extend the relation by at least that
+ *     many pages when we decide to extend the relation. This is more efficient
+ *     for callers that know they will need multiple pages
+ *     (e.g. heap_multi_insert()).
+ *
  *     If otherBuffer is not InvalidBuffer, then it references a previously
  *     pinned buffer of another page in the same relation; on return, this
  *     buffer will also be exclusive-locked.  (This case is used by heap_update;
@@ -359,7 +364,8 @@ Buffer
 RelationGetBufferForTuple(Relation relation, Size len,
                                                  Buffer otherBuffer, int options,
                                                  BulkInsertState bistate,
-                                                 Buffer *vmbuffer, Buffer *vmbuffer_other)
+                                                 Buffer *vmbuffer, Buffer *vmbuffer_other,
+                                                 int num_pages)
 {
        bool            use_fsm = !(options & HEAP_INSERT_SKIP_FSM);
        Buffer          buffer = InvalidBuffer;

diff --git a/src/include/access/hio.h b/src/include/access/hio.h
index 3f20b585326a2934b4a3af398548f69c42af4b6b..b665de7d41eaedfb180068d0cdaee0bf39af5115 100644 (file)
--- a/src/include/access/hio.h
+++ b/src/include/access/hio.h
@@ -38,6 +38,7 @@ extern void RelationPutHeapTuple(Relation relation, Buffer buffer,
 extern Buffer RelationGetBufferForTuple(Relation relation, Size len,
                                                                                Buffer otherBuffer, int options,
                                                                                BulkInsertStateData *bistate,
-                                                                               Buffer *vmbuffer, Buffer *vmbuffer_other);
+                                                                               Buffer *vmbuffer, Buffer *vmbuffer_other,
+                                                                               int num_pages);
 
 #endif                                                 /* HIO_H */