Incorporate a couple of recent tuplesort.c improvements into tuplestore.c.

In particular, ensure that enlargement of the memtuples[] array doesn't
fall foul of MaxAllocSize when work_mem is very large, and don't bother
enlarging it if that would force an immediate switch into 'tape' mode anyway.

diff --git a/src/backend/utils/sort/tuplestore.c b/src/backend/utils/sort/tuplestore.c
index bb4195f8829d50f5ecbb821986568f877e250d33..ea868d4f539114f4a0a43424beb3430de637ed46 100644 (file)
--- a/src/backend/utils/sort/tuplestore.c
+++ b/src/backend/utils/sort/tuplestore.c
@@ -36,7 +36,7 @@
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
- *   $PostgreSQL: pgsql/src/backend/utils/sort/tuplestore.c,v 1.25 2005/11/22 18:17:27 momjian Exp $
+ *   $PostgreSQL: pgsql/src/backend/utils/sort/tuplestore.c,v 1.26 2006/03/04 19:30:12 tgl Exp $
  *
  *-------------------------------------------------------------------------
  */
@@ -316,15 +316,28 @@ tuplestore_puttuple(Tuplestorestate *state, void *tuple)
    switch (state->status)
    {
        case TSS_INMEM:
-           /* Grow the array as needed */
-           if (state->memtupcount >= state->memtupsize)
+           /*
+            * Grow the array as needed.  Note that we try to grow the array
+            * when there is still one free slot remaining --- if we fail,
+            * there'll still be room to store the incoming tuple, and then
+            * we'll switch to tape-based operation.
+            */
+           if (state->memtupcount >= state->memtupsize - 1)
            {
-               FREEMEM(state, GetMemoryChunkSpace(state->memtuples));
-               state->memtupsize *= 2;
-               state->memtuples = (void **)
-                   repalloc(state->memtuples,
-                            state->memtupsize * sizeof(void *));
-               USEMEM(state, GetMemoryChunkSpace(state->memtuples));
+               /*
+                * See grow_memtuples() in tuplesort.c for the rationale
+                * behind these two tests.
+                */
+               if (state->availMem > (long) (state->memtupsize * sizeof(void *)) &&
+                   (Size) (state->memtupsize * 2) < MaxAllocSize / sizeof(void *))
+               {
+                   FREEMEM(state, GetMemoryChunkSpace(state->memtuples));
+                   state->memtupsize *= 2;
+                   state->memtuples = (void **)
+                       repalloc(state->memtuples,
+                                state->memtupsize * sizeof(void *));
+                   USEMEM(state, GetMemoryChunkSpace(state->memtuples));
+               }
            }
 
            /* Stash the tuple in the in-memory array */
@@ -335,9 +348,9 @@ tuplestore_puttuple(Tuplestorestate *state, void *tuple)
                state->current = state->memtupcount;
 
            /*
-            * Done if we still fit in available memory.
+            * Done if we still fit in available memory and have array slots.
             */
-           if (!LACKMEM(state))
+           if (state->memtupcount < state->memtupsize && !LACKMEM(state))
                return;
 
            /*