Mostly cosmetical improvements.

 * (Arguably) improved comments around locking during circular buffer
   maintenance; also, don't lock procarray during global_snapshot_xmin bump.
 * s/snaphot/snapshot, other typos.
 * Don't track_global_snapshots by default -- while handy for testing, it
   doesn't look generally good.

(cherry picked from commit f9dd1c3)

Author: arssher

src/backend/access/transam/global_snapshot.c

@@ -172,7 +172,7 @@ GlobalSnapshotShmemInit()
 /*
  * GlobalSnapshotStartup
  *
- * Set gsXidMap etnries to oldestActiveXID during startup.
+ * Set gsXidMap entries to oldestActiveXID during startup.
  */
 void
 GlobalSnapshotStartup(TransactionId oldestActiveXID)
@@ -200,24 +200,33 @@ GlobalSnapshotStartup(TransactionId oldestActiveXID)
  * global transaction. Otherwise old versions of tuples that were needed for
  * this transaction can be recycled by other processes (vacuum, HOT, etc).
  *
- * Called upon each snapshot creation after ProcArrayLock is released. Such
- * usage creates a race condition. It is possible that backend who got
- * glabal_csn called GlobalSnapshotMapXmin() only after other backends managed
- * to get snapshot and complete GlobalSnapshotMapXmin() call. To address that
- * race we do two thigs:
+ * Locking here is not trivial. Called upon each snapshot creation after
+ * ProcArrayLock is released. Such usage creates several race conditions. It
+ * is possible that backend who got global_csn called GlobalSnapshotMapXmin()
+ * only after other backends managed to get snapshot and complete
+ * GlobalSnapshotMapXmin() call, or even committed. This is safe because
  *
- *		* snapshot_global_csn is always rounded up to next second. So that is
- *		  okay if call to GlobalSnapshotMapXmin() with later global_csn will
- *		  succeed first -- it anyway will be taken into account for a next
+ *      * We already hold our xmin in MyPgXact, so our snapshot will not be
+ * 	      harmed even though ProcArrayLock is released.
+ *
+ *		* snapshot_global_csn is always pessmistically rounded up to the next
  *		  second.
  *
+ *      * For performance reasons, xmin value for particular second is filled
+ *        only once. Because of that instead of writing to buffer just our
+ *        xmin (which is enough for our snapshot), we bump oldestXmin there --
+ *        it mitigates the possibility of damaging someone else's snapshot by
+ *        writing to the buffer too advanced value in case of slowness of
+ *        another backend who generated csn earlier, but didn't manage to
+ *        insert it before us.
+ *
  *		* if GlobalSnapshotMapXmin() founds a gap in several seconds between
  *		  current call and latest completed call then it should fill that gap
- *		  with latest known values instead of new one. Otherwise it is possible
- *		  (however highly unlikely) that this gap also happend between taking
- *		  snapshot and call to GlobalSnapshotMapXmin() for some backend. And we
- *		  are at risk to fill circullar buffer with oldestXmin's that are
- *		  bigger then they actually were.
+ *		  with latest known values instead of new one. Otherwise it is
+ *		  possible (however highly unlikely) that this gap also happend
+ *		  between taking snapshot and call to GlobalSnapshotMapXmin() for some
+ *		  backend. And we are at risk to fill circullar buffer with
+ *		  oldestXmin's that are bigger then they actually were.
  */
 void
 GlobalSnapshotMapXmin(GlobalCSN snapshot_global_csn)
@@ -233,10 +242,7 @@ GlobalSnapshotMapXmin(GlobalCSN snapshot_global_csn)
 	Assert(gsXidMap != NULL);
 
 	/*
-	 * We don't have guarantee that process who called us first for this
-	 * csn_seconds is actually one who took snapshot firt in this second.
-	 * So just round up global_csn to the next second -- snapshots for next
-	 * second would have oldestXmin greater or equal then ours anyway.
+	 * Round up global_csn to the next second -- pessimistically and safely.
 	 */
 	csn_seconds = (snapshot_global_csn / NSECS_PER_SEC + 1);
 
@@ -290,16 +296,15 @@ GlobalSnapshotMapXmin(GlobalCSN snapshot_global_csn)
 
 	/* Fill new entry with current_oldest_xmin */
 	gsXidMap->xmin_by_second[offset] = current_oldest_xmin;
-	offset = (offset + gsXidMap->size - 1) % gsXidMap->size;
 
 	/*
 	 * If we have gap then fill it with previous_oldest_xmin for reasons
 	 * outlined in comment above this function.
 	 */
 	for (i = 1; i < gap; i++)
 	{
-		gsXidMap->xmin_by_second[offset] = previous_oldest_xmin;
 		offset = (offset + gsXidMap->size - 1) % gsXidMap->size;
+		gsXidMap->xmin_by_second[offset] = previous_oldest_xmin;
 	}
 
 	oldest_deferred_xmin =
@@ -309,8 +314,11 @@ GlobalSnapshotMapXmin(GlobalCSN snapshot_global_csn)
 
 	/*
 	 * Advance procArray->global_snapshot_xmin after we released
-	 * GlobalSnapshotXidMapLock.
+	 * GlobalSnapshotXidMapLock. Since we gather not xmin but oldestXmin, it
+	 * never goes backwards regardless of how slow we can do that.
 	 */
+	Assert(TransactionIdFollowsOrEquals(oldest_deferred_xmin,
+										ProcArrayGetGlobalSnapshotXmin()));
 	ProcArraySetGlobalSnapshotXmin(oldest_deferred_xmin);
 }
 
@@ -554,7 +562,7 @@ XidInvisibleInGlobalSnapshot(TransactionId xid, Snapshot snapshot)
  * Functions to handle distributed commit on transaction coordinator:
  * GlobalSnapshotPrepareCurrent() / GlobalSnapshotAssignCsnCurrent().
  * Correspoding functions for remote nodes are defined in twophase.c:
- * pg_global_snaphot_prepare/pg_global_snaphot_assign.
+ * pg_global_snapshot_prepare/pg_global_snapshot_assign.
  *****************************************************************************/
 
 
@@ -594,7 +602,7 @@ GlobalSnapshotPrepareCurrent()
  *
  * Asign GlobalCSN for currently active transaction. GlobalCSN is supposedly
  * maximal among of values returned by GlobalSnapshotPrepareCurrent and
- * pg_global_snaphot_prepare.
+ * pg_global_snapshot_prepare.
  */
 void
 GlobalSnapshotAssignCsnCurrent(GlobalCSN global_csn)
@@ -609,7 +617,7 @@ GlobalSnapshotAssignCsnCurrent(GlobalCSN global_csn)
 	if (!GlobalCSNIsNormal(global_csn))
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("pg_global_snaphot_assign expects normal global_csn")));
+				 errmsg("pg_global_snapshot_assign expects normal global_csn")));
 
 	/* Skip emtpty transactions */
 	if (!TransactionIdIsValid(GetCurrentTransactionIdIfAny()))
@@ -633,7 +641,7 @@ GlobalSnapshotAssignCsnCurrent(GlobalCSN global_csn)
  * proc->assignedGlobalCsn to GlobalCSNLog.
  *
  * Same rules applies to global transaction, except that global_csn is already
- * assigned by GlobalSnapshotAssignCsnCurrent/pg_global_snaphot_assign and
+ * assigned by GlobalSnapshotAssignCsnCurrent/pg_global_snapshot_assign and
  * GlobalSnapshotPrecommit is basically no-op.
  *
  * GlobalSnapshotAbort is slightly different comparing to commit because abort

src/backend/access/transam/twophase.c

@@ -2596,7 +2596,7 @@ GlobalSnapshotPrepareTwophase(const char *gid)
  * TODO: Rewrite this as PREPARE TRANSACTION 'gid' RETURNING SNAPSHOT
  */
 Datum
-pg_global_snaphot_prepare(PG_FUNCTION_ARGS)
+pg_global_snapshot_prepare(PG_FUNCTION_ARGS)
 {
 	const char *gid = text_to_cstring(PG_GETARG_TEXT_PP(0));
 	GlobalCSN	global_csn;
@@ -2612,7 +2612,7 @@ pg_global_snaphot_prepare(PG_FUNCTION_ARGS)
  *
  * Asign GlobalCSN for currently active transaction. GlobalCSN is supposedly
  * maximal among of values returned by GlobalSnapshotPrepareCurrent and
- * pg_global_snaphot_prepare.
+ * pg_global_snapshot_prepare.
  *
  * This function is a counterpart of GlobalSnapshotAssignCsnCurrent() for
  * twophase transactions.
@@ -2633,7 +2633,7 @@ GlobalSnapshotAssignCsnTwoPhase(const char *gid, GlobalCSN global_csn)
 	if (!GlobalCSNIsNormal(global_csn))
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("pg_global_snaphot_assign expects normal global_csn")));
+				 errmsg("pg_global_snapshot_assign expects normal global_csn")));
 
 	/*
 	 * Validate the GID, and lock the GXACT to ensure that two backends do not
@@ -2657,7 +2657,7 @@ GlobalSnapshotAssignCsnTwoPhase(const char *gid, GlobalCSN global_csn)
  * TODO: Rewrite this as COMMIT PREPARED 'gid' SNAPSHOT 'global_csn'
  */
 Datum
-pg_global_snaphot_assign(PG_FUNCTION_ARGS)
+pg_global_snapshot_assign(PG_FUNCTION_ARGS)
 {
 	const char *gid = text_to_cstring(PG_GETARG_TEXT_PP(0));
 	GlobalCSN	global_csn = PG_GETARG_INT64(1);

src/backend/storage/ipc/procarray.c

@@ -3083,28 +3083,17 @@ ProcArrayGetReplicationSlotXmin(TransactionId *xmin,
 void
 ProcArraySetGlobalSnapshotXmin(TransactionId xmin)
 {
-	LWLockAcquire(ProcArrayLock, LW_SHARED);
-
-	if (TransactionIdFollows(xmin, procArray->global_snapshot_xmin))
-		procArray->global_snapshot_xmin = xmin;
-
-	LWLockRelease(ProcArrayLock);
+	/* We rely on atomic fetch/store of xid */
+	procArray->global_snapshot_xmin = xmin;
 }
 
 /*
  * ProcArrayGetGlobalSnapshotXmin
  */
 TransactionId
-ProcArrayGetGlobalSnapshotXmin(bool locked)
+ProcArrayGetGlobalSnapshotXmin()
 {
-	volatile TransactionId xmin;
-
-	if (!locked)
-		LWLockAcquire(ProcArrayLock, LW_SHARED);
-	xmin = procArray->global_snapshot_xmin;
-	if (!locked)
-		LWLockRelease(ProcArrayLock);
-	return xmin;
+	return procArray->global_snapshot_xmin;
 }
 
 #define XidCacheRemove(i) \

src/backend/utils/misc/guc.c

@@ -1018,7 +1018,7 @@ static struct config_bool ConfigureNamesBool[] =
 			gettext_noop("Used to achieve REPEATEBLE READ isolation level for postgres_fdw transactions.")
 		},
 		&track_global_snapshots,
-		true, /* XXX: set true to simplify tesing. XXX2: Seems that RESOURCES_MEM isn't the best catagory */
+		false, /* XXX: Seems that RESOURCES_MEM isn't the best catagory */
 		NULL, NULL, NULL
 	},
 	{

src/backend/utils/time/snapmgr.c

@@ -2227,7 +2227,7 @@ ExportGlobalSnapshot()
 
 /* SQL accessor to ExportGlobalSnapshot() */
 Datum
-pg_global_snaphot_export(PG_FUNCTION_ARGS)
+pg_global_snapshot_export(PG_FUNCTION_ARGS)
 {
 	GlobalCSN	global_csn = ExportGlobalSnapshot();
 	PG_RETURN_UINT64(global_csn);
@@ -2289,7 +2289,7 @@ ImportGlobalSnapshot(GlobalCSN snap_global_csn)
 
 /* SQL accessor to ImportGlobalSnapshot() */
 Datum
-pg_global_snaphot_import(PG_FUNCTION_ARGS)
+pg_global_snapshot_import(PG_FUNCTION_ARGS)
 {
 	GlobalCSN	global_csn = PG_GETARG_UINT64(0);
 	ImportGlobalSnapshot(global_csn);

src/include/catalog/pg_proc.dat

@@ -10208,16 +10208,16 @@
 
 # global transaction handling
 { oid => '3430', descr => 'export global transaction snapshot',
-  proname => 'pg_global_snaphot_export', provolatile => 'v', proparallel => 'u',
-  prorettype => 'int8', proargtypes => '', prosrc => 'pg_global_snaphot_export' },
+  proname => 'pg_global_snapshot_export', provolatile => 'v', proparallel => 'u',
+  prorettype => 'int8', proargtypes => '', prosrc => 'pg_global_snapshot_export' },
 { oid => '3431', descr => 'import global transaction snapshot',
-  proname => 'pg_global_snaphot_import', provolatile => 'v', proparallel => 'u',
-  prorettype => 'void', proargtypes => 'int8', prosrc => 'pg_global_snaphot_import' },
+  proname => 'pg_global_snapshot_import', provolatile => 'v', proparallel => 'u',
+  prorettype => 'void', proargtypes => 'int8', prosrc => 'pg_global_snapshot_import' },
 { oid => '3432', descr => 'prepare distributed transaction for commit, get global_csn',
-  proname => 'pg_global_snaphot_prepare', provolatile => 'v', proparallel => 'u',
-  prorettype => 'int8', proargtypes => 'text', prosrc => 'pg_global_snaphot_prepare' },
+  proname => 'pg_global_snapshot_prepare', provolatile => 'v', proparallel => 'u',
+  prorettype => 'int8', proargtypes => 'text', prosrc => 'pg_global_snapshot_prepare' },
 { oid => '3433', descr => 'assign global_csn to distributed transaction',
-  proname => 'pg_global_snaphot_assign', provolatile => 'v', proparallel => 'u',
-  prorettype => 'void', proargtypes => 'text int8', prosrc => 'pg_global_snaphot_assign' },
+  proname => 'pg_global_snapshot_assign', provolatile => 'v', proparallel => 'u',
+  prorettype => 'void', proargtypes => 'text int8', prosrc => 'pg_global_snapshot_assign' },
 
 ]

src/include/storage/procarray.h

@@ -130,6 +130,6 @@ extern void ProcArrayGetReplicationSlotXmin(TransactionId *xmin,
 
 extern void ProcArraySetGlobalSnapshotXmin(TransactionId xmin);
 
-extern TransactionId ProcArrayGetGlobalSnapshotXmin(bool locked);
+extern TransactionId ProcArrayGetGlobalSnapshotXmin();
 
 #endif							/* PROCARRAY_H */