Avoid spurious wait in concurrent reindex

This is like commit c98763bf51bf, but for REINDEX CONCURRENTLY.  To wit:
this flags indicates that the current process is safe to ignore for the
purposes of waiting for other snapshots, when doing CREATE INDEX
CONCURRENTLY and REINDEX CONCURRENTLY.  This helps two processes doing
either of those things not deadlock, and also avoids spurious waits.

Author: Álvaro Herrera <alvherre@alvh.no-ip.org>
Reviewed-by: Dmitry Dolgov <9erthalion6@gmail.com>
Reviewed-by: Hamid Akhtar <hamid.akhtar@gmail.com>
Reviewed-by: Masahiko Sawada <sawada.mshk@gmail.com>
Discussion: https://postgr.es/m/20201130195439.GA24598@alvherre.pgsql

diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index 8c9c39a4675337b101d5a416ccd9973b5445fdec..1b71859020c8f4b572c5414c75bc6f018f5d0674 100644 (file)
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -385,7 +385,7 @@ CompareOpclassOptions(Datum *opts1, Datum *opts2, int natts)
  * lazy VACUUMs, because they won't be fazed by missing index entries
  * either.  (Manual ANALYZEs, however, can't be excluded because they
  * might be within transactions that are going to do arbitrary operations
- * later.)  Processes running CREATE INDEX CONCURRENTLY
+ * later.)  Processes running CREATE INDEX CONCURRENTLY or REINDEX CONCURRENTLY
  * on indexes that are neither expressional nor partial are also safe to
  * ignore, since we know that those processes won't examine any data
  * outside the table they're indexing.
@@ -3066,6 +3066,7 @@ ReindexRelationConcurrently(Oid relationOid, int options)
        Oid         indexId;
        Oid         tableId;
        Oid         amId;
+       bool        safe;       /* for set_indexsafe_procflags */
    } ReindexIndexInfo;
    List       *heapRelationIds = NIL;
    List       *indexIds = NIL;
@@ -3377,6 +3378,9 @@ ReindexRelationConcurrently(Oid relationOid, int options)
        heapRel = table_open(indexRel->rd_index->indrelid,
                             ShareUpdateExclusiveLock);
 
+       /* determine safety of this index for set_indexsafe_procflags */
+       idx->safe = (indexRel->rd_indexprs == NIL &&
+                    indexRel->rd_indpred == NIL);
        idx->tableId = RelationGetRelid(heapRel);
        idx->amId = indexRel->rd_rel->relam;
 
@@ -3418,6 +3422,7 @@ ReindexRelationConcurrently(Oid relationOid, int options)
 
        newidx = palloc(sizeof(ReindexIndexInfo));
        newidx->indexId = newIndexId;
+       newidx->safe = idx->safe;
        newidx->tableId = idx->tableId;
        newidx->amId = idx->amId;
 
@@ -3485,6 +3490,11 @@ ReindexRelationConcurrently(Oid relationOid, int options)
    CommitTransactionCommand();
    StartTransactionCommand();
 
+   /*
+    * Because we don't take a snapshot in this transaction, there's no need
+    * to set the PROC_IN_SAFE_IC flag here.
+    */
+
    /*
     * Phase 2 of REINDEX CONCURRENTLY
     *
@@ -3514,6 +3524,10 @@ ReindexRelationConcurrently(Oid relationOid, int options)
         */
        CHECK_FOR_INTERRUPTS();
 
+       /* Tell concurrent indexing to ignore us, if index qualifies */
+       if (newidx->safe)
+           set_indexsafe_procflags();
+
        /* Set ActiveSnapshot since functions in the indexes may need it */
        PushActiveSnapshot(GetTransactionSnapshot());
 
@@ -3534,8 +3548,14 @@ ReindexRelationConcurrently(Oid relationOid, int options)
        PopActiveSnapshot();
        CommitTransactionCommand();
    }
+
    StartTransactionCommand();
 
+   /*
+    * Because we don't take a snapshot or Xid in this transaction, there's no
+    * need to set the PROC_IN_SAFE_IC flag here.
+    */
+
    /*
     * Phase 3 of REINDEX CONCURRENTLY
     *
@@ -3564,6 +3584,10 @@ ReindexRelationConcurrently(Oid relationOid, int options)
         */
        CHECK_FOR_INTERRUPTS();
 
+       /* Tell concurrent indexing to ignore us, if index qualifies */
+       if (newidx->safe)
+           set_indexsafe_procflags();
+
        /*
         * Take the "reference snapshot" that will be used by validate_index()
         * to filter candidate tuples.
@@ -3607,6 +3631,9 @@ ReindexRelationConcurrently(Oid relationOid, int options)
         * interesting tuples.  But since it might not contain tuples deleted
         * just before the reference snap was taken, we have to wait out any
         * transactions that might have older snapshots.
+        *
+        * Because we don't take a snapshot or Xid in this transaction,
+        * there's no need to set the PROC_IN_SAFE_IC flag here.
         */
        pgstat_progress_update_param(PROGRESS_CREATEIDX_PHASE,
                                     PROGRESS_CREATEIDX_PHASE_WAIT_3);
@@ -3628,6 +3655,13 @@ ReindexRelationConcurrently(Oid relationOid, int options)
 
    StartTransactionCommand();
 
+   /*
+    * Because this transaction only does catalog manipulations and doesn't do
+    * any index operations, we can set the PROC_IN_SAFE_IC flag here
+    * unconditionally.
+    */
+   set_indexsafe_procflags();
+
    forboth(lc, indexIds, lc2, newIndexIds)
    {
        ReindexIndexInfo *oldidx = lfirst(lc);
@@ -3675,6 +3709,12 @@ ReindexRelationConcurrently(Oid relationOid, int options)
    CommitTransactionCommand();
    StartTransactionCommand();
 
+   /*
+    * While we could set PROC_IN_SAFE_IC if all indexes qualified, there's no
+    * real need for that, because we only acquire an Xid after the wait is
+    * done, and that lasts for a very short period.
+    */
+
    /*
     * Phase 5 of REINDEX CONCURRENTLY
     *
@@ -3705,6 +3745,12 @@ ReindexRelationConcurrently(Oid relationOid, int options)
    CommitTransactionCommand();
    StartTransactionCommand();
 
+   /*
+    * While we could set PROC_IN_SAFE_IC if all indexes qualified, there's no
+    * real need for that, because we only acquire an Xid after the wait is
+    * done, and that lasts for a very short period.
+    */
+
    /*
     * Phase 6 of REINDEX CONCURRENTLY
     *

diff --git a/src/include/storage/proc.h b/src/include/storage/proc.h
index 0786fcf103a708542f6b2dd5bf751725460c027d..683ab64f76b8d7261bd9b14bbcf7412b5b780c03 100644 (file)
--- a/src/include/storage/proc.h
+++ b/src/include/storage/proc.h
@@ -54,6 +54,7 @@ struct XidCache
 #define        PROC_IS_AUTOVACUUM  0x01    /* is it an autovac worker? */
 #define        PROC_IN_VACUUM      0x02    /* currently running lazy vacuum */
 #define        PROC_IN_SAFE_IC     0x04    /* currently running CREATE INDEX
+                                        * CONCURRENTLY or REINDEX
                                         * CONCURRENTLY on non-expressional,
                                         * non-partial index */
 #define        PROC_VACUUM_FOR_WRAPAROUND  0x08    /* set by autovac only */