PostgreSQL 14在MVCC上面有所增強，以保證在大批次客戶端連線場景下效能不會出現顯著下降（詳細可參見參考資料中的連結）。本節介紹了提交記錄“Don't compute global horizons while building snapshots.”中heapam_visibility.c中的修改以及涉及的相關資料結構。

### 一、資料結構

**HTSV_Result**
```C

/* Result codes for HeapTupleSatisfiesVacuum */
/* HeapTupleSatisfiesVacuum返回的結果碼 */
typedef enum
{
	HEAPTUPLE_DEAD,				/* 元組已死且可以被清除，tuple is dead and deletable */
	HEAPTUPLE_LIVE,				/* 元組存活，tuple is live (committed, no deleter) */
	HEAPTUPLE_RECENTLY_DEAD,	/* 元組已死，但不能被清除，tuple is dead, but not deletable yet */
	HEAPTUPLE_INSERT_IN_PROGRESS,	/* 插入事務仍在進行中，inserting xact is still in progress */
	HEAPTUPLE_DELETE_IN_PROGRESS	/* 刪除事務仍在進行中，deleting xact is still in progress */
} HTSV_Result;

```
HTSV == HeapTupleSatisfiesVacuum首字母大寫

### 二、原始碼解讀

```diff
--- a/src/backend/access/heap/heapam_visibility.c
+++ b/src/backend/access/heap/heapam_visibility.c
@@ -1154,19 +1154,56 @@ HeapTupleSatisfiesMVCC(HeapTuple htup, Snapshot snapshot,
  * we mainly want to know is if a tuple is potentially visible to *any*
  * running transaction.  If so, it can't be removed yet by VACUUM.
  *
- * OldestXmin is a cutoff XID (obtained from GetOldestXmin()).  Tuples
- * deleted by XIDs >= OldestXmin are deemed "recently dead"; they might
- * still be visible to some open transaction, so we can't remove them,
- * even if we see that the deleting transaction has committed.
+ * OldestXmin is a cutoff XID (obtained from
+ * GetOldestNonRemovableTransactionId()).  Tuples deleted by XIDs >=
+ * OldestXmin are deemed "recently dead"; they might still be visible to some
+ * open transaction, so we can't remove them, even if we see that the deleting
+ * transaction has committed.
  */
  /*
  	設xID = 從GetOldestNonRemovableTransactionId
  	對於所有 < xID 的事務IDs，可被VACUUM清除
  	HeapTupleSatisfiesVacuum函式，
  	呼叫HeapTupleSatisfiesVacuumHorizon判斷元組是否“最近死亡-HEAPTUPLE_RECENTLY_DEAD”，

*/
 HTSV_Result
 HeapTupleSatisfiesVacuum(HeapTuple htup, TransactionId OldestXmin,
                         Buffer buffer)
+{
+   TransactionId dead_after = InvalidTransactionId;
+   HTSV_Result res;
+
+   res = HeapTupleSatisfiesVacuumHorizon(htup, buffer, &dead_after);
+
+   if (res == HEAPTUPLE_RECENTLY_DEAD)
+   {
+       Assert(TransactionIdIsValid(dead_after));
+
+       if (TransactionIdPrecedes(dead_after, OldestXmin))
+           res = HEAPTUPLE_DEAD;
+   }
+   else
+       Assert(!TransactionIdIsValid(dead_after));
+
+   return res;
+}
+
+/*
+ * Work horse for HeapTupleSatisfiesVacuum and similar routines.
+ *
+ * In contrast to HeapTupleSatisfiesVacuum this routine, when encountering a
+ * tuple that could still be visible to some backend, stores the xid that
+ * needs to be compared with the horizon in *dead_after, and returns
+ * HEAPTUPLE_RECENTLY_DEAD. The caller then can perform the comparison with
+ * the horizon.  This is e.g. useful when comparing with different horizons.
+ *
+ * Note: HEAPTUPLE_DEAD can still be returned here, e.g. if the inserting
+ * transaction aborted.
+ */
+HTSV_Result
+HeapTupleSatisfiesVacuumHorizon(HeapTuple htup, Buffer buffer, TransactionId *dead_after)
 {
    HeapTupleHeader tuple = htup->t_data;
 
    Assert(ItemPointerIsValid(&htup->t_self));
    Assert(htup->t_tableOid != InvalidOid);
+   Assert(dead_after != NULL);
+
+   *dead_after = InvalidTransactionId;
 
    /*
     * Has inserting transaction committed?
@@ -1323,17 +1360,15 @@ HeapTupleSatisfiesVacuum(HeapTuple htup, TransactionId OldestXmin,
        else if (TransactionIdDidCommit(xmax))//xmax事務已提交，說明元組已被刪除
        {
            /*
-            * The multixact might still be running due to lockers.  If the
-            * updater is below the xid horizon, we have to return DEAD
-            * regardless -- otherwise we could end up with a tuple where the
-            * updater has to be removed due to the horizon, but is not pruned
-            * away.  It's not a problem to prune that tuple, because any
-            * remaining lockers will also be present in newer tuple versions.
+            * The multixact might still be running due to lockers.  Need to
+            * allow for pruning if below the xid horizon regardless --
+            * otherwise we could end up with a tuple where the updater has to
+            * be removed due to the horizon, but is not pruned away.  It's
+            * not a problem to prune that tuple, because any remaining
+            * lockers will also be present in newer tuple versions.
             */
-           if (!TransactionIdPrecedes(xmax, OldestXmin))
-               return HEAPTUPLE_RECENTLY_DEAD;
-
-           return HEAPTUPLE_DEAD;
+           *dead_after = xmax;//返回xmax
+           return HEAPTUPLE_RECENTLY_DEAD;//狀態：最近死亡
        }
        else if (!MultiXactIdIsRunning(HeapTupleHeaderGetRawXmax(tuple), false))
        {
@@ -1372,14 +1407,11 @@ HeapTupleSatisfiesVacuum(HeapTuple htup, TransactionId OldestXmin,
    }
 
    /*
-    * Deleter committed, but perhaps it was recent enough that some open
-    * transactions could still see the tuple.
+    * Deleter committed, allow caller to check if it was recent enough that
+    * some open transactions could still see the tuple.
	 刪除事務已提交，但仍可能被其他活動事務可見
     */
-   if (!TransactionIdPrecedes(HeapTupleHeaderGetRawXmax(tuple), OldestXmin))
-       return HEAPTUPLE_RECENTLY_DEAD;
-
-   /* Otherwise, it's dead and removable */
-   return HEAPTUPLE_DEAD;
+   *dead_after = HeapTupleHeaderGetRawXmax(tuple);//xmax
+   return HEAPTUPLE_RECENTLY_DEAD;//狀態：最近死亡
 }
 
 
@@ -1393,14 +1425,28 @@ HeapTupleSatisfiesVacuum(HeapTuple htup, TransactionId OldestXmin,
  *
  * This is an interface to HeapTupleSatisfiesVacuum that's callable via
  * HeapTupleSatisfiesSnapshot, so it can be used through a Snapshot.
- * snapshot->xmin must have been set up with the xmin horizon to use.
+ * snapshot->vistest must have been set up with the horizon to use.
    snapshot->vistest必須設定
  */
 static bool
 HeapTupleSatisfiesNonVacuumable(HeapTuple htup, Snapshot snapshot,
                                Buffer buffer)
 {
-   return HeapTupleSatisfiesVacuum(htup, snapshot->xmin, buffer)//原邏輯：呼叫HeapTupleSatisfiesVacuum判斷
-       != HEAPTUPLE_DEAD;
+   TransactionId dead_after = InvalidTransactionId;
+   HTSV_Result res;
+
+   res = HeapTupleSatisfiesVacuumHorizon(htup, buffer, &dead_after);
	//新邏輯：呼叫HeapTupleSatisfiesVacuumHorizon獲取是否最近死亡，
	//		 若是，則進一步呼叫GlobalVisTestIsRemovableXid判斷是否可被清除
+
+   if (res == HEAPTUPLE_RECENTLY_DEAD)//元組最近死亡
+   {
+       Assert(TransactionIdIsValid(dead_after));
+
+       if (GlobalVisTestIsRemovableXid(snapshot->vistest, dead_after))//可見性判斷
+           res = HEAPTUPLE_DEAD;//可以被清除
+   }
+   else
+       Assert(!TransactionIdIsValid(dead_after));
+
+   return res != HEAPTUPLE_DEAD;//HEAPTUPLE_DEAD狀態的元組才能被清除
 }
 
 
@@ -1418,7 +1464,7 @@ HeapTupleSatisfiesNonVacuumable(HeapTuple htup, Snapshot snapshot,
  * if the tuple is removable.
  */
 bool
-HeapTupleIsSurelyDead(HeapTuple htup, TransactionId OldestXmin)
+HeapTupleIsSurelyDead(HeapTuple htup, GlobalVisState *vistest)
 {
    HeapTupleHeader tuple = htup->t_data;
 
@@ -1459,7 +1505,8 @@ HeapTupleIsSurelyDead(HeapTuple htup, TransactionId OldestXmin)
        return false;
 
    /* Deleter committed, so tuple is dead if the XID is old enough. */
-   return TransactionIdPrecedes(HeapTupleHeaderGetRawXmax(tuple), OldestXmin);//原邏輯：元組xmax比OldestXmin要小則可清除，否則不能清除
+   return GlobalVisTestIsRemovableXid(vistest,
+                                      HeapTupleHeaderGetRawXmax(tuple));//新邏輯：呼叫GlobalVisTestXXX函式，確認元組是否可清除
 }
 
 /*
```

GlobalVisTestXXX函式在procarray.c檔案中，後續再行介紹。

### 三、跟蹤分析
N/A

### 四、參考資料
1.[Improving connection scalability: GetSnapshotData()](https://www.postgresql.org/message-id/20200301083601.ews6hz5dduc3w2se%40alap3.anarazel.de)
2.[snapshot scalability: Don't compute global horizons while building snapshots.](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commitdiff;h=dc7420c2c9274a283779ec19718d2d16323640c0)

PostgreSQL 原始碼解讀（251）- PG 14（Improving connection scalability）#3

相關文章