Introduce a maintenance_io_concurrency setting.

Introduce a GUC and a tablespace option to control I/O prefetching, much
like effective_io_concurrency, but for work that is done on behalf of
many client sessions.

Use the new setting in heapam.c instead of the hard-coded formula
effective_io_concurrency + 10 introduced by commit 558a9165e08.  Go with
a default value of 10 for now, because it's a round number pretty close
to the value used for that existing case.

Discussion: https://postgr.es/m/CA%2BhUKGJUw08dPs_3EUcdO6M90GnjofPYrWp4YSLaBkgYwS-AqA%40mail.gmail.com

diff --git a/doc/src/sgml/config.sgml b/doc/src/sgml/config.sgml
index 3cac340f3237f2358c6ca503945a56ad8ecc792d..672bf6f1ee7e2086987d167cd3cb06071c5b1c0d 100644 (file)
--- a/doc/src/sgml/config.sgml
+++ b/doc/src/sgml/config.sgml
@@ -2229,6 +2229,26 @@ include_dir 'conf.d'
        </listitem>
       </varlistentry>
 
+      <varlistentry id="guc-maintenance-io-concurrency" xreflabel="maintenance_io_concurrency">
+       <term><varname>maintenance_io_concurrency</varname> (<type>integer</type>)
+       <indexterm>
+        <primary><varname>maintenance_io_concurrency</varname> configuration parameter</primary>
+       </indexterm>
+       </term>
+       <listitem>
+        <para>
+         Similar to <varname>effective_io_concurrency</varname>, but used
+         for maintenance work that is done on behalf of many client sessions.
+        </para>
+        <para>
+         The default is 10 on supported systems, otherwise 0.  This value can
+         be overridden for tables in a particular tablespace by setting the
+         tablespace parameter of the same name (see
+         <xref linkend="sql-altertablespace"/>).
+        </para>
+       </listitem>
+      </varlistentry>
+ 
       <varlistentry id="guc-max-worker-processes" xreflabel="max_worker_processes">
        <term><varname>max_worker_processes</varname> (<type>integer</type>)
        <indexterm>

diff --git a/doc/src/sgml/ref/alter_tablespace.sgml b/doc/src/sgml/ref/alter_tablespace.sgml
index acec33469f12ca626e858c2f0f7cda624f089698..356fb9f93f32df8f49a2d1c8985f158274571055 100644 (file)
--- a/doc/src/sgml/ref/alter_tablespace.sgml
+++ b/doc/src/sgml/ref/alter_tablespace.sgml
@@ -84,13 +84,16 @@ ALTER TABLESPACE <replaceable>name</replaceable> RESET ( <replaceable class="par
      <para>
       A tablespace parameter to be set or reset.  Currently, the only
       available parameters are <varname>seq_page_cost</varname>,
-      <varname>random_page_cost</varname> and <varname>effective_io_concurrency</varname>.
-      Setting either value for a particular tablespace will override the
+      <varname>random_page_cost</varname>, <varname>effective_io_concurrency</varname>
+      and <varname>maintenance_io_concurrency</varname>.
+      Setting these values for a particular tablespace will override the
       planner's usual estimate of the cost of reading pages from tables in
-      that tablespace, as established by the configuration parameters of the
+      that tablespace, and the executor's prefetching behavior, as established
+      by the configuration parameters of the
       same name (see <xref linkend="guc-seq-page-cost"/>,
       <xref linkend="guc-random-page-cost"/>,
-      <xref linkend="guc-effective-io-concurrency"/>).  This may be useful if
+      <xref linkend="guc-effective-io-concurrency"/>,
+      <xref linkend="guc-maintenance-io-concurrency"/>).  This may be useful if
       one tablespace is located on a disk which is faster or slower than the
       remainder of the I/O subsystem.
      </para>

diff --git a/doc/src/sgml/ref/create_tablespace.sgml b/doc/src/sgml/ref/create_tablespace.sgml
index c621ec2c6bf802e90bf7c6c4df8d8facf10abe5f..462b8831c27464e3f1e3b5d20e6d7b4b11a5f394 100644 (file)
--- a/doc/src/sgml/ref/create_tablespace.sgml
+++ b/doc/src/sgml/ref/create_tablespace.sgml
@@ -106,13 +106,16 @@ CREATE TABLESPACE <replaceable class="parameter">tablespace_name</replaceable>
        <para>
         A tablespace parameter to be set or reset.  Currently, the only
         available parameters are <varname>seq_page_cost</varname>,
-        <varname>random_page_cost</varname> and <varname>effective_io_concurrency</varname>.
-        Setting either value for a particular tablespace will override the
+        <varname>random_page_cost</varname>, <varname>effective_io_concurrency</varname>
+        and <varname>maintenance_io_concurrency</varname>.
+        Setting these values for a particular tablespace will override the
         planner's usual estimate of the cost of reading pages from tables in
-        that tablespace, as established by the configuration parameters of the
+        that tablespace, and the executor's prefetching behavior, as established
+        by the configuration parameters of the
         same name (see <xref linkend="guc-seq-page-cost"/>,
         <xref linkend="guc-random-page-cost"/>,
-        <xref linkend="guc-effective-io-concurrency"/>).  This may be useful if
+        <xref linkend="guc-effective-io-concurrency"/>,
+        <xref linkend="guc-maintenance-io-concurrency"/>).  This may be useful if
         one tablespace is located on a disk which is faster or slower than the
         remainder of the I/O subsystem.
        </para>

diff --git a/src/backend/access/common/reloptions.c b/src/backend/access/common/reloptions.c
index c3d45c7a248ee6f995132c381b6d9c40ce3b4436..ec207d3b26c0e48a8b581f792bc022ed7249efb6 100644 (file)
--- a/src/backend/access/common/reloptions.c
+++ b/src/backend/access/common/reloptions.c
@@ -349,6 +349,19 @@ static relopt_int intRelOpts[] =
                -1, 0, MAX_IO_CONCURRENCY
 #else
                0, 0, 0
+#endif
+       },
+       {
+               {
+                       "maintenance_io_concurrency",
+                       "Number of simultaneous requests that can be handled efficiently by the disk subsystem for maintenance work.",
+                       RELOPT_KIND_TABLESPACE,
+                       ShareUpdateExclusiveLock
+               },
+#ifdef USE_PREFETCH
+               -1, 0, MAX_IO_CONCURRENCY
+#else
+               0, 0, 0
 #endif
        },
        {
@@ -1700,7 +1713,8 @@ tablespace_reloptions(Datum reloptions, bool validate)
        static const relopt_parse_elt tab[] = {
                {"random_page_cost", RELOPT_TYPE_REAL, offsetof(TableSpaceOpts, random_page_cost)},
                {"seq_page_cost", RELOPT_TYPE_REAL, offsetof(TableSpaceOpts, seq_page_cost)},
-               {"effective_io_concurrency", RELOPT_TYPE_INT, offsetof(TableSpaceOpts, effective_io_concurrency)}
+               {"effective_io_concurrency", RELOPT_TYPE_INT, offsetof(TableSpaceOpts, effective_io_concurrency)},
+               {"maintenance_io_concurrency", RELOPT_TYPE_INT, offsetof(TableSpaceOpts, maintenance_io_concurrency)}
        };
 
        return (bytea *) build_reloptions(reloptions, validate,

diff --git a/src/backend/access/heap/heapam.c b/src/backend/access/heap/heapam.c
index 5a32e62ed0e761aab4fc5710e2ff2fff80d75990..29694b8aa4a3b6b242ab0b197f02f9a7221499f3 100644 (file)
--- a/src/backend/access/heap/heapam.c
+++ b/src/backend/access/heap/heapam.c
@@ -7003,7 +7003,6 @@ heap_compute_xid_horizon_for_tuples(Relation rel,
        Page            hpage;
 #ifdef USE_PREFETCH
        XidHorizonPrefetchState prefetch_state;
-       int                     io_concurrency;
        int                     prefetch_distance;
 #endif
 
@@ -7026,24 +7025,15 @@ heap_compute_xid_horizon_for_tuples(Relation rel,
        /*
         * Compute the prefetch distance that we will attempt to maintain.
         *
-        * We don't use the regular formula to determine how much to prefetch
-        * here, but instead just add a constant to effective_io_concurrency.
-        * That's because it seems best to do some prefetching here even when
-        * effective_io_concurrency is set to 0, but if the DBA thinks it's OK to
-        * do more prefetching for other operations, then it's probably OK to do
-        * more prefetching in this case, too. It may be that this formula is too
-        * simplistic, but at the moment there is no evidence of that or any idea
-        * about what would work better.
-        *
         * Since the caller holds a buffer lock somewhere in rel, we'd better make
         * sure that isn't a catalog relation before we call code that does
         * syscache lookups, to avoid risk of deadlock.
         */
        if (IsCatalogRelation(rel))
-               io_concurrency = effective_io_concurrency;
+               prefetch_distance = maintenance_io_concurrency;
        else
-               io_concurrency = get_tablespace_io_concurrency(rel->rd_rel->reltablespace);
-       prefetch_distance = Min((io_concurrency) + 10, MAX_IO_CONCURRENCY);
+               prefetch_distance =
+                       get_tablespace_maintenance_io_concurrency(rel->rd_rel->reltablespace);
 
        /* Start prefetching. */
        xid_horizon_prefetch_buffer(rel, &prefetch_state, prefetch_distance);

diff --git a/src/backend/storage/buffer/bufmgr.c b/src/backend/storage/buffer/bufmgr.c
index 7a7748b6955f957ba62bd9c50a86b1e6c436589b..e05e2b34565d077552afa7079943fc5278906fa0 100644 (file)
--- a/src/backend/storage/buffer/bufmgr.c
+++ b/src/backend/storage/buffer/bufmgr.c
@@ -119,6 +119,13 @@ bool               track_io_timing = false;
  */
 int                    effective_io_concurrency = 0;
 
+/*
+ * Like effective_io_concurrency, but used by maintenance code paths that might
+ * benefit from a higher setting because they work on behalf of many sessions.
+ * Overridden by the tablespace setting of the same name.
+ */
+int                    maintenance_io_concurrency = 0;
+
 /*
  * GUC variables about triggering kernel writeback for buffers written; OS
  * dependent defaults are set via the GUC mechanism.

diff --git a/src/backend/utils/cache/spccache.c b/src/backend/utils/cache/spccache.c
index c4a0f719fb5b01f1982f182116dabb678f37220f..e0c3c1b1c1173eb33659827df816880dcc496d10 100644 (file)
--- a/src/backend/utils/cache/spccache.c
+++ b/src/backend/utils/cache/spccache.c
@@ -221,3 +221,17 @@ get_tablespace_io_concurrency(Oid spcid)
        else
                return spc->opts->effective_io_concurrency;
 }
+
+/*
+ * get_tablespace_maintenance_io_concurrency
+ */
+int
+get_tablespace_maintenance_io_concurrency(Oid spcid)
+{
+       TableSpaceCacheEntry *spc = get_tablespace(spcid);
+
+       if (!spc->opts || spc->opts->maintenance_io_concurrency < 0)
+               return maintenance_io_concurrency;
+       else
+               return spc->opts->maintenance_io_concurrency;
+}

diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
index 326e773b25fc6361e91d7cbcf8ad71be3dd574a9..68082315acda0cfcba168a45fed735a27b72b454 100644 (file)
--- a/src/backend/utils/misc/guc.c
+++ b/src/backend/utils/misc/guc.c
@@ -196,6 +196,7 @@ static bool check_autovacuum_max_workers(int *newval, void **extra, GucSource so
 static bool check_max_wal_senders(int *newval, void **extra, GucSource source);
 static bool check_autovacuum_work_mem(int *newval, void **extra, GucSource source);
 static bool check_effective_io_concurrency(int *newval, void **extra, GucSource source);
+static bool check_maintenance_io_concurrency(int *newval, void **extra, GucSource source);
 static void assign_pgstat_temp_directory(const char *newval, void *extra);
 static bool check_application_name(char **newval, void **extra, GucSource source);
 static void assign_application_name(const char *newval, void *extra);
@@ -2884,6 +2885,24 @@ static struct config_int ConfigureNamesInt[] =
                check_effective_io_concurrency, NULL, NULL
        },
 
+       {
+               {"maintenance_io_concurrency",
+                       PGC_USERSET,
+                       RESOURCES_ASYNCHRONOUS,
+                       gettext_noop("A variant of effective_io_concurrency that is used for maintenance work."),
+                       NULL,
+                       GUC_EXPLAIN
+               },
+               &maintenance_io_concurrency,
+#ifdef USE_PREFETCH
+               10,
+#else
+               0,
+#endif
+               0, MAX_IO_CONCURRENCY,
+               check_maintenance_io_concurrency, NULL, NULL
+       },
+
        {
                {"backend_flush_after", PGC_USERSET, RESOURCES_ASYNCHRONOUS,
                        gettext_noop("Number of pages after which previously performed writes are flushed to disk."),
@@ -11466,6 +11485,19 @@ check_effective_io_concurrency(int *newval, void **extra, GucSource source)
        return true;
 }
 
+static bool
+check_maintenance_io_concurrency(int *newval, void **extra, GucSource source)
+{
+#ifndef USE_PREFETCH
+       if (*newval != 0)
+       {
+               GUC_check_errdetail("maintenance_io_concurrency must be set to 0 on platforms that lack posix_fadvise().");
+               return false;
+       }
+#endif                                                 /* USE_PREFETCH */
+       return true;
+}
+
 static void
 assign_pgstat_temp_directory(const char *newval, void *extra)
 {

diff --git a/src/bin/psql/tab-complete.c b/src/bin/psql/tab-complete.c
index 174c3db62309fc50361489aeaddc0566131f77b1..ae35fa4aa98d9c54d06cdcf83d642b695131fcdb 100644 (file)
--- a/src/bin/psql/tab-complete.c
+++ b/src/bin/psql/tab-complete.c
@@ -2140,7 +2140,7 @@ psql_completion(const char *text, int start, int end)
        /* ALTER TABLESPACE <foo> SET|RESET ( */
        else if (Matches("ALTER", "TABLESPACE", MatchAny, "SET|RESET", "("))
                COMPLETE_WITH("seq_page_cost", "random_page_cost",
-                                         "effective_io_concurrency");
+                                         "effective_io_concurrency", "maintenance_io_concurrency");
 
        /* ALTER TEXT SEARCH */
        else if (Matches("ALTER", "TEXT", "SEARCH"))

diff --git a/src/include/commands/tablespace.h b/src/include/commands/tablespace.h
index 41c457052d97d98cc8c91716ce978abe9f63d210..fd1b28fca2268edad243e23b38142c3664aed4e5 100644 (file)
--- a/src/include/commands/tablespace.h
+++ b/src/include/commands/tablespace.h
@@ -40,6 +40,7 @@ typedef struct TableSpaceOpts
        float8          random_page_cost;
        float8          seq_page_cost;
        int                     effective_io_concurrency;
+       int                     maintenance_io_concurrency;
 } TableSpaceOpts;
 
 extern Oid     CreateTableSpace(CreateTableSpaceStmt *stmt);

diff --git a/src/include/storage/bufmgr.h b/src/include/storage/bufmgr.h
index 2bf5afdade6229987e840bbed6f33834c08702c5..d2a5b52f6e20adf783919c33137979a50f75b6a8 100644 (file)
--- a/src/include/storage/bufmgr.h
+++ b/src/include/storage/bufmgr.h
@@ -58,6 +58,7 @@ extern int    bgwriter_lru_maxpages;
 extern double bgwriter_lru_multiplier;
 extern bool track_io_timing;
 extern int     effective_io_concurrency;
+extern int     maintenance_io_concurrency;
 
 extern int     checkpoint_flush_after;
 extern int     backend_flush_after;

diff --git a/src/include/utils/spccache.h b/src/include/utils/spccache.h
index 5112ba3c376cc4b3bf098f36847cf97442200476..7e4ec69aa2ef83bf4cdfa1d8dc71b77dc0197801 100644 (file)
--- a/src/include/utils/spccache.h
+++ b/src/include/utils/spccache.h
@@ -16,5 +16,6 @@
 void           get_tablespace_page_costs(Oid spcid, float8 *spc_random_page_cost,
                                                                          float8 *spc_seq_page_cost);
 int                    get_tablespace_io_concurrency(Oid spcid);
+int                    get_tablespace_maintenance_io_concurrency(Oid spcid);
 
 #endif                                                 /* SPCCACHE_H */