Merge branch 'PGPROEE9_6' into mm_2pc_cleanup

kelvich · kelvich · commit 26221147e443 · 2017-11-09T01:03:41.000+03:00
diff --git a/doc/src/sgml/ref/pgbench.sgml b/doc/src/sgml/ref/pgbench.sgml
@@ -472,18 +472,18 @@ pgbench <optional> <replaceable>options</> </optional> <replaceable>dbname</>
         transaction scheduled start time, not the actual transaction beginning
         time. Thus, the latency also includes the average schedule lag time. If
         any transactions have been rolled back and retried after a
-        serialization/deadlock failure since the last report, the report
+        serialization/deadlock error since the last report, the report
         includes the number of such transactions and the sum of all retries. Use
         the <option>--max-tries</> to enable transactions retries after
-        serialization/deadlock failures.
+        serialization/deadlock errors.
        </para>
        <note>
         <para>
          If a custom script contains multiple transactions, its run is reported
          as failed if any of its transactions ended with a
          serialization/deadlock failure. The run of this script is reported as
          retried if any of its transactions was retried after a
-         serialization/deadlock failure. The total sum of retries includes the
+         serialization/deadlock error. The total sum of retries includes the
          retries for all transactions in this script.
         </para>
        </note>
@@ -639,7 +639,7 @@ pgbench <optional> <replaceable>options</> </optional> <replaceable>dbname</>
       <listitem>
        <para>
         Set the maximum number of tries for transactions with
-        serialization/deadlock failures. The default is 1.
+        serialization/deadlock errors. The default is 1.
        </para>
 
        <note>
@@ -655,8 +655,8 @@ pgbench <optional> <replaceable>options</> </optional> <replaceable>dbname</>
        <note>
         <para>
          Transactions that span over more than one script are not rolled back
-         and will not be retried in case of a failure. In such cases, the script
-         in which the failure occurred is reported as failed.
+         and will not be retried in case of an error. In such cases, the script
+         in which the error occurred is reported as failed.
         </para>
        </note>
       </listitem>
@@ -1234,7 +1234,7 @@ END;
    the <replaceable>time</> for a skipped transaction will be reported as
    <literal>skipped</>.
    <replaceable>serialization_retries</> and <replaceable>deadlock_retries</>
-   are the sums of all the retries after the corresponding failures during the
+   are the sums of all the retries after the corresponding errors during the
    current script execution. They are only present when the maximum number of
    tries for transactions is more than 1 (<option>--max-tries</>).
    If the transaction ended with a serialization/deadlock failure, its
@@ -1322,7 +1322,7 @@ END;
    serialization/deadlock failures within the interval (see
    <xref linkend="failures-and-retries" endterm="failures-and-retries-title">
    for more information). A transaction is counted into the interval when it was
-   committed. The fields in the end, <replaceable>lag_sum</>,
+   committed. The fields near the end, <replaceable>lag_sum</>,
    <replaceable>lag_2_sum</>, <replaceable>min_lag</>, and
    <replaceable>max_lag</>, are only present if the <option>--rate</> option is
    used. The next field, <replaceable>skipped_transactions</>, is only
@@ -1333,7 +1333,7 @@ END;
    <replaceable>serialization_retries</>, and <replaceable>deadlock_retries</>
    fields are only present if the maximum number of tries for transactions is
    more than 1 (<option>--max-tries</>). They report the number of retried
-   transactions and the sum of all the retries after the corresponding failures
+   transactions and the sum of all the retries after the corresponding errors
    within the interval.
   </para>
 
@@ -1346,7 +1346,7 @@ END;
     statistics is increased by one, regardless of the number of retried
     transactions. However, the <replaceable>serialization_retries</> and
     <replaceable>deadlock_retries</> include the sum of all retries after the
-    corresponding failures for all transactions in this script.
+    corresponding errors for all transactions in this script.
    </para>
   </note>
 
@@ -1384,14 +1384,14 @@ END;
      </listitem>
      <listitem>
        <para>
-         The number of serialization and deadlock failures that did not cause a
-         retry. See <xref linkend="failures-and-retries"
+         The number of serialization and deadlock failures. See
+         <xref linkend="failures-and-retries"
          endterm="failures-and-retries-title"> for more information.
        </para>
      </listitem>
      <listitem>
        <para>
-         The number of retries after a serialization/deadlock failure in this
+         The number of retries after a serialization/deadlock error in this
          statement; they are reported as serialization/deadlock retries,
          respectively.
        </para>
@@ -1513,16 +1513,16 @@ script statistics:
   <title id="failures-and-retries-title">Serialization/Deadlock Failures and Retries</title>
 
   <para>
-   Transactions with serialization or deadlock failures are rolled back and
+   Transactions with serialization or deadlock errors are rolled back and
    repeated until they complete successfully or reach the maximum number of
    tries specified by the <option>--max-tries</> option. If the last transaction
    run fails, this transaction will be reported as failed.
   </para>
 
   <para>
    Transactions that span over more than one script are not rolled back and will
-   not be retried in case of a failure. In such cases, the script in which the
-   failure occurred is reported as failed.
+   not be retried in case of an error. In such cases, the script in which the
+   error occurred is reported as failed.
   </para>
 
   <para>
@@ -1536,15 +1536,15 @@ script statistics:
    If the total number of retried transactions is non-zero, the main report also
    contains the statistics related to retries: the total number of retried
    transactions, the total number of retries, and the number of retries after
-   each kind of failure (use option <option>--max-tries</> to make it possible).
+   each kind of error (use option <option>--max-tries</> to make it possible).
    The per-statement report inherits all columns from the main report.
   </para>
   <note>
    <para>
     If a custom script contains multiple transactions, its run is reported as
     failed if any of its transactions ended with a serialization/deadlock
     failure. The run of this script is reported as retried if any of its
-    transactions was retried after a serialization/deadlock failure. The total
+    transactions was retried after a serialization/deadlock error. The total
     sum of retries includes the retries for all transactions in this script.
    </para>
   </note>
diff --git a/src/backend/access/transam/xact.c b/src/backend/access/transam/xact.c
@@ -1855,6 +1855,8 @@ typedef struct {
 	void *TriggerState;
 	void *SPIState;
 	void *SnapshotState;
+	void *PredicateState;
+	void *StorageState;
 	struct TransInvalidationInfo* InvalidationInfo;
 
 	List *on_commit_actions;
@@ -2196,19 +2198,16 @@ CommitTransaction(void)
 						 RESOURCE_RELEASE_AFTER_LOCKS,
 						 true, true);
 
-	if (!is_autonomous_transaction) 
-	{
-		/*
-		 * Likewise, dropping of files deleted during the transaction is best done
-		 * after releasing relcache and buffer pins.  (This is not strictly
-		 * necessary during commit, since such pins should have been released
-		 * already, but this ordering is definitely critical during abort.)  Since
-		 * this may take many seconds, also delay until after releasing locks.
-		 * Other backends will observe the attendant catalog changes and not
-		 * attempt to access affected files.
-		 */
-		smgrDoPendingDeletes(true);
-	}
+	/*
+	 * Likewise, dropping of files deleted during the transaction is best done
+	 * after releasing relcache and buffer pins.  (This is not strictly
+	 * necessary during commit, since such pins should have been released
+	 * already, but this ordering is definitely critical during abort.)  Since
+	 * this may take many seconds, also delay until after releasing locks.
+	 * Other backends will observe the attendant catalog changes and not
+	 * attempt to access affected files.
+	 */
+	smgrDoPendingDeletes(true);
 
 	AtCommit_Notify();
 	AtEOXact_GUC(true, s->gucNestLevel);
@@ -3530,7 +3529,9 @@ void SuspendTransaction(void)
 		sus->TopTransactionStateData = TopTransactionStateData;
 
 		sus->SnapshotState = SuspendSnapshot(); /* only before the resource-owner stuff */
-		
+		sus->PredicateState = SuspendPredicate();
+		sus->StorageState = SuspendStorage();
+
 		if (HasCatcacheInvalidationMessages()) 
 		{
 			ResetCatalogCaches();
@@ -3652,6 +3653,8 @@ bool ResumeTransaction(void)
 		TopTransactionResourceOwner = sus->TopTransactionResourceOwner;
 
 		ResumeSnapshot(sus->SnapshotState); /* only after the resource-owner stuff */
+		ResumePredicate(sus->PredicateState);
+		ResumeStorage(sus->StorageState);
 		ResumeInvalidationInfo(sus->InvalidationInfo);
 		if (xactHasCatcacheInvalidationMessages) 
 		{
diff --git a/src/backend/catalog/storage.c b/src/backend/catalog/storage.c
@@ -563,3 +563,15 @@ smgr_redo(XLogReaderState *record)
 	else
 		elog(PANIC, "smgr_redo: unknown op code %u", info);
 }
+
+void* SuspendStorage(void)
+{
+	PendingRelDelete* pending = pendingDeletes;
+	pendingDeletes = NULL;
+	return pending;
+}
+
+void ResumeStorage(void* ctx)
+{
+	pendingDeletes = (PendingRelDelete*)ctx;
+}
diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c
@@ -202,6 +202,7 @@
 #include "utils/rel.h"
 #include "utils/snapmgr.h"
 #include "utils/tqual.h"
+#include "utils/memutils.h"
 
 /* Uncomment the next line to test the graceful degradation code. */
 /* #define TEST_OLDSERXID */
@@ -4963,3 +4964,34 @@ predicatelock_twophase_recover(TransactionId xid, uint16 info,
 		CreatePredicateLock(&lockRecord->target, targettaghash, sxact);
 	}
 }
+
+typedef struct SuspendedPredicateState
+{
+	HTAB*             LocalPredicateLockHash;
+	SERIALIZABLEXACT* MySerializableXact;
+	bool              MyXactDidWrite;
+} SuspendedPredicateState;
+
+
+void* SuspendPredicate(void)
+{
+	SuspendedPredicateState *s = (SuspendedPredicateState*)MemoryContextAlloc(TopMemoryContext, sizeof(SuspendedPredicateState));
+	s->LocalPredicateLockHash = LocalPredicateLockHash;
+	s->MySerializableXact = MySerializableXact;
+	s->MyXactDidWrite = MyXactDidWrite;
+
+	LocalPredicateLockHash = NULL;
+	MySerializableXact = InvalidSerializableXact;
+	MyXactDidWrite = false;
+
+	return s;
+}
+
+void ResumePredicate(void *data)
+{
+	SuspendedPredicateState *s = (SuspendedPredicateState*)data;
+	LocalPredicateLockHash = s->LocalPredicateLockHash;
+	MySerializableXact = s->MySerializableXact;
+	MyXactDidWrite = s->MyXactDidWrite;
+	pfree(s);
+}
diff --git a/src/include/catalog/storage.h b/src/include/catalog/storage.h
@@ -33,4 +33,7 @@ extern void AtSubCommit_smgr(void);
 extern void AtSubAbort_smgr(void);
 extern void PostPrepare_smgr(void);
 
+extern void* SuspendStorage(void);
+extern void ResumeStorage(void* ctx);
+
 #endif   /* STORAGE_H */
diff --git a/src/include/storage/predicate.h b/src/include/storage/predicate.h
@@ -70,4 +70,7 @@ extern void PredicateLockTwoPhaseFinish(TransactionId xid, bool isCommit);
 extern void predicatelock_twophase_recover(TransactionId xid, uint16 info,
 							   void *recdata, uint32 len);
 
+extern void* SuspendPredicate(void);
+extern void  ResumePredicate(void *data);
+
 #endif   /* PREDICATE_H */
