SSI comment fixes and enhancements. Notably, document that the conflict-out

flag actually means that the transaction has a conflict out to a transaction
that committed before the flagged transaction.

Kevin Grittner

diff --git a/src/backend/storage/lmgr/predicate.c b/src/backend/storage/lmgr/predicate.c
index 5ac762499105a83c3061f68bc1de9dbbe8b0b8af..6facb533e0fbceb2f140742b56bc4d8bc935d09a 100644 (file)
--- a/src/backend/storage/lmgr/predicate.c
+++ b/src/backend/storage/lmgr/predicate.c
@@ -245,6 +245,11 @@
 #define SxactIsReadOnly(sxact) (((sxact)->flags & SXACT_FLAG_READ_ONLY) != 0)
 #define SxactHasSummaryConflictIn(sxact) (((sxact)->flags & SXACT_FLAG_SUMMARY_CONFLICT_IN) != 0)
 #define SxactHasSummaryConflictOut(sxact) (((sxact)->flags & SXACT_FLAG_SUMMARY_CONFLICT_OUT) != 0)
+/*
+ * The following macro actually means that the specified transaction has a
+ * conflict out *to a transaction which committed ahead of it*.  It's hard
+ * to get that into a name of a reasonable length.
+ */
 #define SxactHasConflictOut(sxact) (((sxact)->flags & SXACT_FLAG_CONFLICT_OUT) != 0)
 #define SxactIsDeferrableWaiting(sxact) (((sxact)->flags & SXACT_FLAG_DEFERRABLE_WAITING) != 0)
 #define SxactIsROSafe(sxact) (((sxact)->flags & SXACT_FLAG_RO_SAFE) != 0)
@@ -2708,7 +2713,7 @@ SetNewSxactGlobalXmin(void)
  * up in some relatively timely fashion.
  *
  * If this transaction is committing and is holding any predicate locks,
- * it must be added to a list of completed serializable transaction still
+ * it must be added to a list of completed serializable transactions still
  * holding locks.
  */
 void
@@ -2753,12 +2758,13 @@ ReleasePredicateLocks(const bool isCommit)
        LWLockAcquire(SerializableXactHashLock, LW_EXCLUSIVE);
 
        /*
-        * We don't hold a lock here, assuming that TransactionId is atomic!
+        * We don't hold XidGenLock lock here, assuming that TransactionId is
+        * atomic!
         *
         * If this value is changing, we don't care that much whether we get the
         * old or new value -- it is just used to determine how far
-        * GlobalSerizableXmin must advance before this transaction can be cleaned
-        * fully cleaned up.  The worst that could happen is we wait for ome more
+        * GlobalSerizableXmin must advance before this transaction can be fully
+        * cleaned up.  The worst that could happen is we wait for one more
         * transaction to complete before freeing some RAM; correctness of visible
         * behavior is not affected.
         */
@@ -3860,8 +3866,8 @@ OnConflict_CheckForSerializationFailure(const SERIALIZABLEXACT *reader,
         * Because T2 must've committed first, there is no anomaly if:
         * - the reader committed before T2
         * - the writer committed before T2
-        * - the reader is a READ ONLY transaction and the reader was not
-        *   concurrent with T2 (= reader acquired its snapshot after T2 committed)
+        * - the reader is a READ ONLY transaction and the reader was concurrent
+        *       with T2 (= reader acquired its snapshot before T2 committed)
         */
        if (!failure)
        {

diff --git a/src/include/storage/predicate_internals.h b/src/include/storage/predicate_internals.h
index bd42004c2cd8a2b102d91ae411054a4f61b9007d..b144ab319ae58afab21434fc19d4d5538b3fab84 100644 (file)
--- a/src/include/storage/predicate_internals.h
+++ b/src/include/storage/predicate_internals.h
@@ -92,6 +92,11 @@ typedef struct SERIALIZABLEXACT
 
 #define SXACT_FLAG_ROLLED_BACK                         0x00000001
 #define SXACT_FLAG_COMMITTED                           0x00000002
+/*
+ * The following flag actually means that the flagged transaction has a
+ * conflict out *to a transaction which committed ahead of it*.  It's hard
+ * to get that into a name of a reasonable length.
+ */
 #define SXACT_FLAG_CONFLICT_OUT                                0x00000004
 #define SXACT_FLAG_READ_ONLY                           0x00000008
 #define SXACT_FLAG_DID_WRITE                           0x00000010