Adjust tuplestore stats API

1eff8279d added an API to tuplestore.c to allow callers to obtain
storage telemetry data.  That API wasn't quite good enough for callers
that perform tuplestore_clear() as the telemetry functions only
accounted for the current state of the tuplestore, not the maximums
before tuplestore_clear() was called.

There's a pending patch that would like to add tuplestore telemetry
output to EXPLAIN ANALYZE for WindowAgg.  That node type uses
tuplestore_clear() before moving to the next window partition and we
want to show the maximum space used, not the space used for the final
partition.

Reviewed-by: Tatsuo Ishii, Ashutosh Bapat
Discussion: https://postgres/m/CAApHDvoY8cibGcicLV0fNh=9JVx9PANcWvhkdjBnDCc9Quqytg@mail.gmail.com

diff --git a/src/backend/commands/explain.c b/src/backend/commands/explain.c
index 14cd36c87c5a00604ce959e17c3005d683581341..2819e479f82a93e7a3cc01d35c86f3bdab5cc1a1 100644 (file)
--- a/src/backend/commands/explain.c
+++ b/src/backend/commands/explain.c
@@ -3350,8 +3350,9 @@ static void
 show_material_info(MaterialState *mstate, ExplainState *es)
 {
    Tuplestorestate *tupstore = mstate->tuplestorestate;
-   const char *storageType;
-   int64       spaceUsedKB;
+   char       *maxStorageType;
+   int64       maxSpaceUsed,
+               maxSpaceUsedKB;
 
    /*
     * Nothing to show if ANALYZE option wasn't used or if execution didn't
@@ -3360,21 +3361,21 @@ show_material_info(MaterialState *mstate, ExplainState *es)
    if (!es->analyze || tupstore == NULL)
        return;
 
-   storageType = tuplestore_storage_type_name(tupstore);
-   spaceUsedKB = BYTES_TO_KILOBYTES(tuplestore_space_used(tupstore));
+   tuplestore_get_stats(tupstore, &maxStorageType, &maxSpaceUsed);
+   maxSpaceUsedKB = BYTES_TO_KILOBYTES(maxSpaceUsed);
 
    if (es->format != EXPLAIN_FORMAT_TEXT)
    {
-       ExplainPropertyText("Storage", storageType, es);
-       ExplainPropertyInteger("Maximum Storage", "kB", spaceUsedKB, es);
+       ExplainPropertyText("Storage", maxStorageType, es);
+       ExplainPropertyInteger("Maximum Storage", "kB", maxSpaceUsedKB, es);
    }
    else
    {
        ExplainIndentText(es);
        appendStringInfo(es->str,
                         "Storage: %s  Maximum Storage: " INT64_FORMAT "kB\n",
-                        storageType,
-                        spaceUsedKB);
+                        maxStorageType,
+                        maxSpaceUsedKB);
    }
 }
 

diff --git a/src/backend/utils/sort/tuplestore.c b/src/backend/utils/sort/tuplestore.c
index 444c8e25c21fc11cc6ce2fa7976f01f1875b153a..a720d7020016861e82cbdbfbe5270072dc6ce3e3 100644 (file)
--- a/src/backend/utils/sort/tuplestore.c
+++ b/src/backend/utils/sort/tuplestore.c
@@ -107,9 +107,10 @@ struct Tuplestorestate
    bool        backward;       /* store extra length words in file? */
    bool        interXact;      /* keep open through transactions? */
    bool        truncated;      /* tuplestore_trim has removed tuples? */
+   bool        usedDisk;       /* used by tuplestore_get_stats() */
+   int64       maxSpace;       /* used by tuplestore_get_stats() */
    int64       availMem;       /* remaining memory available, in bytes */
    int64       allowedMem;     /* total memory allowed, in bytes */
-   int64       maxSpace;       /* maximum space used in memory */
    int64       tuples;         /* number of tuples added */
    BufFile    *myfile;         /* underlying file, or NULL if none */
    MemoryContext context;      /* memory context for holding tuples */
@@ -262,9 +263,10 @@ tuplestore_begin_common(int eflags, bool interXact, int maxKBytes)
    state->eflags = eflags;
    state->interXact = interXact;
    state->truncated = false;
+   state->usedDisk = false;
+   state->maxSpace = 0;
    state->allowedMem = maxKBytes * 1024L;
    state->availMem = state->allowedMem;
-   state->maxSpace = 0;
    state->myfile = NULL;
 
    /*
@@ -870,6 +872,14 @@ tuplestore_puttuple_common(Tuplestorestate *state, void *tuple)
             * though callers might drop the requirement.
             */
            state->backward = (state->eflags & EXEC_FLAG_BACKWARD) != 0;
+
+           /*
+            * Update the maximum space used before dumping the tuples.  It's
+            * possible that more space will be used by the tuples in memory
+            * than the space that will be used on disk.
+            */
+           tuplestore_updatemax(state);
+
            state->status = TSS_WRITEFILE;
            dumptuples(state);
            break;
@@ -1444,7 +1454,7 @@ tuplestore_trim(Tuplestorestate *state)
    Assert(nremove >= state->memtupdeleted);
    Assert(nremove <= state->memtupcount);
 
-   /* before freeing any memory, update maxSpace */
+   /* before freeing any memory, update the statistics */
    tuplestore_updatemax(state);
 
    /* Release no-longer-needed tuples */
@@ -1491,7 +1501,8 @@ tuplestore_trim(Tuplestorestate *state)
 
 /*
  * tuplestore_updatemax
- *     Update maxSpace field
+ *     Update the maximum space used by this tuplestore and the method used
+ *     for storage.
  */
 static void
 tuplestore_updatemax(Tuplestorestate *state)
@@ -1499,37 +1510,37 @@ tuplestore_updatemax(Tuplestorestate *state)
    if (state->status == TSS_INMEM)
        state->maxSpace = Max(state->maxSpace,
                              state->allowedMem - state->availMem);
-}
-
-/*
- * tuplestore_storage_type_name
- *     Return a string description of the storage method used to store the
- *     tuples.
- */
-const char *
-tuplestore_storage_type_name(Tuplestorestate *state)
-{
-   if (state->status == TSS_INMEM)
-       return "Memory";
    else
-       return "Disk";
+   {
+       state->maxSpace = Max(state->maxSpace,
+                             BufFileSize(state->myfile));
+
+       /*
+        * usedDisk never gets set to false again after spilling to disk, even
+        * if tuplestore_clear() is called and new tuples go to memory again.
+        */
+       state->usedDisk = true;
+   }
 }
 
 /*
- * tuplestore_space_used
- *     Return the maximum space used in memory unless the tuplestore has spilled
- *     to disk, in which case, return the disk space used.
+ * tuplestore_get_stats
+ *     Obtain statistics about the maximum space used by the tuplestore.
+ *     These statistics are the maximums and are not reset by calls to
+ *     tuplestore_trim() or tuplestore_clear().
  */
-int64
-tuplestore_space_used(Tuplestorestate *state)
+void
+tuplestore_get_stats(Tuplestorestate *state, char **max_storage_type,
+                    int64 *max_space)
 {
-   /* First, update the maxSpace field */
    tuplestore_updatemax(state);
 
-   if (state->status == TSS_INMEM)
-       return state->maxSpace;
+   if (state->usedDisk)
+       *max_storage_type = "Disk";
    else
-       return BufFileSize(state->myfile);
+       *max_storage_type = "Memory";
+
+   *max_space = state->maxSpace;
 }
 
 /*
@@ -1601,7 +1612,6 @@ writetup_heap(Tuplestorestate *state, void *tup)
    if (state->backward)        /* need trailing length word? */
        BufFileWrite(state->myfile, &tuplen, sizeof(tuplen));
 
-   /* no need to call tuplestore_updatemax() when not in TSS_INMEM */
    FREEMEM(state, GetMemoryChunkSpace(tuple));
    heap_free_minimal_tuple(tuple);
 }

diff --git a/src/include/utils/tuplestore.h b/src/include/utils/tuplestore.h
index 3d8a90caaf93f9cd029de9568ebfb2c7074c147b..e4782ac5a7f808dd0c8c2693a6a3ad8cb0903dcb 100644 (file)
--- a/src/include/utils/tuplestore.h
+++ b/src/include/utils/tuplestore.h
@@ -65,9 +65,8 @@ extern void tuplestore_copy_read_pointer(Tuplestorestate *state,
 
 extern void tuplestore_trim(Tuplestorestate *state);
 
-extern const char *tuplestore_storage_type_name(Tuplestorestate *state);
-
-extern int64 tuplestore_space_used(Tuplestorestate *state);
+extern void tuplestore_get_stats(Tuplestorestate *state, char **storage_type,
+                                int64 *max_space);
 
 extern bool tuplestore_in_memory(Tuplestorestate *state);