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

### 一、資料結構

**PruneState**
用於heap_page_prune和子函式的結構體
```C

/* Working data for heap_page_prune and subroutines */
typedef struct
{
	Relation	rel;

/* tuple visibility test, initialized for the relation */
	//元組可見性驗證，為relation而準備
	GlobalVisState *vistest;

/*
	 * Thresholds set by TransactionIdLimitedForOldSnapshots() if they have
	 * been computed (done on demand, and only if
	 * OldSnapshotThresholdActive()). The first time a tuple is about to be
	 * removed based on the limited horizon, old_snap_used is set to true, and
	 * SetOldSnapshotThresholdTimestamp() is called. See
	 * heap_prune_satisfies_vacuum().
	 * 如果已計算並且OldSnapshotThresholdActive()返回為真，則透過函式TransactionIdLimitedForOldSnapshots設定閾值，
	 * 第一次某個元組基於有限邊界將要被刪除時，old_snap_used設定為真，同時呼叫SetOldSnapshotThresholdTimestamp函式，
	 * 詳細參見heap_prune_satisfies_vacuum
	 */
	TimestampTz old_snap_ts;//拍照時的時間點
	TransactionId old_snap_xmin;//拍照時的xmin
	bool		old_snap_used;//有元組因此而被刪除

TransactionId new_prune_xid;	/* page中新的清除標記值，new prune hint value for page */
	TransactionId latestRemovedXid; /* 該清除動作最後的xid，latest xid to be removed by this prune */
	int			nredirected;	/* 下面陣列的元素個數，numbers of entries in arrays below */
	int			ndead;//
	int			nunused;
	/* arrays that accumulate indexes of items to be changed */
	OffsetNumber redirected[MaxHeapTuplesPerPage * 2];
	OffsetNumber nowdead[MaxHeapTuplesPerPage];
	OffsetNumber nowunused[MaxHeapTuplesPerPage];
	/* marked[i] is true if item i is entered in one of the above arrays */
	bool		marked[MaxHeapTuplesPerPage + 1];
} PruneState;

```

### 二、原始碼解讀

```diff
/*
  diff：
  1.PruneState結構體增加rel、vistest等成員變數
  2.引數列表中存在OldestXmin的，均刪除該引數
  3.函式體中存在OldestXmin、RecentGlobalXmin的，修改為GlobalVisXXX函式呼叫
  4.新增heap_prune_satisfies_vacuum函式
*/

--- a/src/backend/access/heap/pruneheap.c
+++ b/src/backend/access/heap/pruneheap.c
@@ -23,12 +23,30 @@
 #include "miscadmin.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "utils/snapmgr.h"
 #include "utils/rel.h"
 #include "utils/snapmgr.h"
 
 /* Working data for heap_page_prune and subroutines */
 // 用於heap_page_prune和子例程的結構體
 typedef struct
 {
+   Relation    rel;
+
+   /* tuple visibility test, initialized for the relation */
+   GlobalVisState *vistest;
+
+   /*
+    * Thresholds set by TransactionIdLimitedForOldSnapshots() if they have
+    * been computed (done on demand, and only if
+    * OldSnapshotThresholdActive()). The first time a tuple is about to be
+    * removed based on the limited horizon, old_snap_used is set to true, and
+    * SetOldSnapshotThresholdTimestamp() is called. See
+    * heap_prune_satisfies_vacuum().
+    */
+   TimestampTz old_snap_ts;
+   TransactionId old_snap_xmin;
+   bool        old_snap_used;
+
    /* 參見資料結構PruneState */
    TransactionId new_prune_xid;    /* new prune hint value for page */
    TransactionId latestRemovedXid; /* latest xid to be removed by this prune */
    int         nredirected;    /* numbers of entries in arrays below */
@@ -43,9 +61,8 @@ typedef struct
 } PruneState;
 
 /* Local functions */
 /* 
    heap_prune_chain函式引數刪除了relation和OldestXmin 
    該函式用於清理指定的line pointer或者HOT鏈
 */
-static int heap_prune_chain(Relation relation, Buffer buffer,
+static int heap_prune_chain(Buffer buffer,
                             OffsetNumber rootoffnum,
-                            TransactionId OldestXmin,
                             PruneState *prstate);
 static void heap_prune_record_prunable(PruneState *prstate, TransactionId xid);
 static void heap_prune_record_redirect(PruneState *prstate,
@@ -65,16 +82,16 @@ static void heap_prune_record_unused(PruneState *prstate, OffsetNumber offnum);
  * if there's not any use in pruning.
  *
  * Caller must have pin on the buffer, and must *not* have a lock on it.
  /* 不再使用OldestXmin */
- *
- * OldestXmin is the cutoff XID used to distinguish whether tuples are DEAD
- * or RECENTLY_DEAD (see HeapTupleSatisfiesVacuum).
  */
 void
 heap_page_prune_opt(Relation relation, Buffer buffer)
 /*
   heap_page_prune_opt函式用於清除page和清理page中的碎片
   該函式執行得很頻繁，只要一有機會就會執行，在執行前呼叫者必須pin快取且沒有鎖
   輸入引數是relation和buffer
 */
 {
    Page        page = BufferGetPage(buffer);//獲取相應的page
+   TransactionId prune_xid;//page上儲存的事務id
+   GlobalVisState *vistest;//詳見GlobalVisState結構體
+   TransactionId limited_xmin = InvalidTransactionId;//
+   TimestampTz limited_ts = 0;//
    Size        minfree;
-   TransactionId OldestXmin;//刪除OldestXmin
 
    /*
     * We can't write WAL in recovery mode, so there's no point trying to
@@ -85,37 +102,55 @@ heap_page_prune_opt(Relation relation, Buffer buffer)
        return;
 
    /*
-    * Use the appropriate xmin horizon for this relation. If it's a proper
-    * catalog relation or a user defined, additional, catalog relation, we
-    * need to use the horizon that includes slots, otherwise the data-only
-    * horizon can be used. Note that the toast relation of user defined
-    * relations are *not* considered catalog relations.
+    * XXX: Magic to keep old_snapshot_threshold tests appear "working". They
+    * currently are broken, and discussion of what to do about them is
+    * ongoing. See
+    * https://www.postgresql.org/message-id/20200403001235.e6jfdll3gh2ygbuc%40alap3.anarazel.de
+    */
+   if (old_snapshot_threshold == 0)//快照閾值
+       SnapshotTooOldMagicForTest();
+
+   /*
+    * First check whether there's any chance there's something to prune,
+    * determining the appropriate horizon is a waste if there's no prune_xid
+    * (i.e. no updates/deletes left potentially dead tuples around).
+    */
+   prune_xid = ((PageHeader) page)->pd_prune_xid;
+   if (!TransactionIdIsValid(prune_xid))//非有效的事務id，退出
+       return;
+
+   /*
+    * Check whether prune_xid indicates that there may be dead rows that can
+    * be cleaned up.
     * 檢查prune_xid是否存在可清除的資料行
     *
-    * It is OK to apply the old snapshot limit before acquiring the cleanup
+    * It is OK to check the old snapshot limit before acquiring the cleanup
     * lock because the worst that can happen is that we are not quite as
     * aggressive about the cleanup (by however many transaction IDs are
     * consumed between this point and acquiring the lock).  This allows us to
     * save significant overhead in the case where the page is found not to be
     * prunable.
+    *
+    * Even if old_snapshot_threshold is set, we first check whether the page
+    * can be pruned without. Both because
+    * TransactionIdLimitedForOldSnapshots() is not cheap, and because not
+    * unnecessarily relying on old_snapshot_threshold avoids causing
+    * conflicts.
     * old_snapshot_threshold 是GUC引數，用於判斷某個快照多長時間後too old，預設為-1（禁用該特性）
     */
-   if (IsCatalogRelation(relation) ||
-       RelationIsAccessibleInLogicalDecoding(relation))
-       OldestXmin = RecentGlobalXmin;
-   else
-       OldestXmin =
-           TransactionIdLimitedForOldSnapshots(RecentGlobalDataXmin,
-                                               relation);
+   vistest = GlobalVisTestFor(relation);//vistest中會有確實需要的xid和不再需要的xid
 
-   Assert(TransactionIdIsValid(OldestXmin));
+   if (!GlobalVisTestIsRemovableXid(vistest, prune_xid))//是否可被清除？返回false，表示不能清除
+   {
+       if (!OldSnapshotThresholdActive())//禁用快照過久特性，則返回
+           return;
 
-   /*
-    * Let's see if we really need pruning.
-    *
-    * Forget it if page is not hinted to contain something prunable that's
-    * older than OldestXmin.
-    */
-   if (!PageIsPrunable(page, OldestXmin))
-       return;
+       if (!TransactionIdLimitedForOldSnapshots(GlobalVisTestNonRemovableHorizon(vistest),
+                                                relation,
+                                                &limited_xmin, &limited_ts))
+           return;//快照過久也需要不限制事務id，返回
+
+       if (!TransactionIdPrecedes(prune_xid, limited_xmin))
+           return;//prune_xid在limited_xmin之後，返回
+   }
 
    /*
     * We prune when a previous UPDATE failed to find enough space on the page
@@ -151,7 +186,9 @@ heap_page_prune_opt(Relation relation, Buffer buffer)
                                                             * needed */
 
            /* OK to prune */
-           (void) heap_page_prune(relation, buffer, OldestXmin, true, &ignore);
+           (void) heap_page_prune(relation, buffer, vistest,
+                                  limited_xmin, limited_ts,
+                                  true, &ignore);//執行清理，輸入引數刪除OldestXmin，新增了vistest/limited_xmin/limited_ts
        }
 
        /* And release buffer lock */
@@ -165,8 +202,11 @@ heap_page_prune_opt(Relation relation, Buffer buffer)
  *
  * Caller must have pin and buffer cleanup lock on the page.
  *
- * OldestXmin is the cutoff XID used to distinguish whether tuples are DEAD
- * or RECENTLY_DEAD (see HeapTupleSatisfiesVacuum).
+ * vistest is used to distinguish whether tuples are DEAD or RECENTLY_DEAD
+ * (see heap_prune_satisfies_vacuum and
+ * HeapTupleSatisfiesVacuum). old_snap_xmin / old_snap_ts need to
+ * either have been set by TransactionIdLimitedForOldSnapshots, or
+ * InvalidTransactionId/0 respectively.
  *
  * If report_stats is true then we send the number of reclaimed heap-only
  * tuples to pgstats.  (This must be false during vacuum, since vacuum will
@@ -177,7 +217,10 @@ heap_page_prune_opt(Relation relation, Buffer buffer)
  * latestRemovedXid.
  */
  /*
    heap_page_prune函式用於清除page和清理page中的碎片
    vistest用於區分元組是DEAD還是RECENTLY_DEAD
    old_snap_xmin / old_snap_ts應由TransactionIdLimitedForOldSnapshots函式設定或者為InvalidTransactionId/0
    如report_stats為真，則傳送heap-only元組給統計程式（pg_stats）
  */
 int
-heap_page_prune(Relation relation, Buffer buffer, TransactionId OldestXmin,
+heap_page_prune(Relation relation, Buffer buffer,
+               GlobalVisState *vistest,
+               TransactionId old_snap_xmin,
+               TimestampTz old_snap_ts,
                bool report_stats, TransactionId *latestRemovedXid)
 {
    int         ndeleted = 0;
@@ -198,6 +241,11 @@ heap_page_prune(Relation relation, Buffer buffer, TransactionId OldestXmin,
     * initialize the rest of our working state.
     */
    prstate.new_prune_xid = InvalidTransactionId;
+   prstate.rel = relation;//PruneState結構體賦值
+   prstate.vistest = vistest;
+   prstate.old_snap_xmin = old_snap_xmin;
+   prstate.old_snap_ts = old_snap_ts;
+   prstate.old_snap_used = false;
    prstate.latestRemovedXid = *latestRemovedXid;
    prstate.nredirected = prstate.ndead = prstate.nunused = 0;
    memset(prstate.marked, 0, sizeof(prstate.marked));
@@ -220,9 +268,7 @@ heap_page_prune(Relation relation, Buffer buffer, TransactionId OldestXmin,
            continue;
 
        /* Process this item or chain of items */
        //清理行指標line pointer
-       ndeleted += heap_prune_chain(relation, buffer, offnum,
-                                    OldestXmin,
-                                    &prstate);
+       ndeleted += heap_prune_chain(buffer, offnum, &prstate);
    }
 
    /* Any error while applying the changes is critical */
@@ -323,6 +369,85 @@ heap_page_prune(Relation relation, Buffer buffer, TransactionId OldestXmin,
 }
 
 
+/*
+ * Perform visiblity checks for heap pruning.
  * 執行可見性檢查
+ *
+ * This is more complicated than just using GlobalVisTestIsRemovableXid()
+ * because of old_snapshot_threshold. We only want to increase the threshold
+ * that triggers errors for old snapshots when we actually decide to remove a
+ * row based on the limited horizon.
  * 由於old_snapshot_threshold的存在，該過程比GlobalVisTestIsRemovableXid要複雜
  * 基於受限的範圍，在確定要刪除行時，我們希望增加由於過久快照而會觸發錯誤的閾值
+ *
+ * Due to its cost we also only want to call
+ * TransactionIdLimitedForOldSnapshots() if necessary, i.e. we might not have
+ * done so in heap_hot_prune_opt() if pd_prune_xid was old enough. But we
+ * still want to be able to remove rows that are too new to be removed
+ * according to prstate->vistest, but that can be removed based on
+ * old_snapshot_threshold. So we call TransactionIdLimitedForOldSnapshots() on
+ * demand in here, if appropriate.
  * 成本上面的考慮，我們希望在需要時才呼叫TransactionIdLimitedForOldSnapshots
  * 在pd_prune_xid過久的情況下，不會考慮在heap_hot_prune_opt中處理這事情
  * 但我們仍然希望可以清理對於prstate->vistest來說過新的行，但基於old_snapshot_threshold可被清除
  * 因此我們在需要時呼叫TransactionIdLimitedForOldSnapshots
+ */
+static HTSV_Result
+heap_prune_satisfies_vacuum(PruneState *prstate, HeapTuple tup, Buffer buffer)
+{
+   HTSV_Result res;
+   TransactionId dead_after;
+
+   res = HeapTupleSatisfiesVacuumHorizon(tup, buffer, &dead_after);//呼叫HeapTupleSatisfiesVacuumHorizon
+
+   if (res != HEAPTUPLE_RECENTLY_DEAD)//只關注HEAPTUPLE_RECENTLY_DEAD
+       return res;
+
+   /*
+    * If we are already relying on the limited xmin, there is no need to
+    * delay doing so anymore.
+    */
+   if (prstate->old_snap_used)//使用快照過舊特性
+   {
+       Assert(TransactionIdIsValid(prstate->old_snap_xmin));
+
+       if (TransactionIdPrecedes(dead_after, prstate->old_snap_xmin))
+           res = HEAPTUPLE_DEAD;//dead_after在old_snap_xmin之前，則可清除
+       return res;
+   }
+
+   /*
+    * First check if GlobalVisTestIsRemovableXid() is sufficient to find the
+    * row dead. If not, and old_snapshot_threshold is enabled, try to use the
+    * lowered horizon.
     * 首先檢查GlobalVisTestIsRemovableXid是否足以找到已死亡的行，
     * 否則如old_snapshot_threshold引數有效，則嘗試使用更低的區間
+    */
+   if (GlobalVisTestIsRemovableXid(prstate->vistest, dead_after))
+       res = HEAPTUPLE_DEAD;//可清除
+   else if (OldSnapshotThresholdActive())//啟用快照過舊特性
+   {
+       /* haven't determined limited horizon yet, requests */
        // 還沒有確定範圍，則確定之
+       if (!TransactionIdIsValid(prstate->old_snap_xmin))
+       {
+           TransactionId horizon =
+           GlobalVisTestNonRemovableHorizon(prstate->vistest);
+
+           TransactionIdLimitedForOldSnapshots(horizon, prstate->rel,
+                                               &prstate->old_snap_xmin,
+                                               &prstate->old_snap_ts);
+       }
+
+       if (TransactionIdIsValid(prstate->old_snap_xmin) && //已確定範圍
+           TransactionIdPrecedes(dead_after, prstate->old_snap_xmin)) //快照過舊
+       {
+           /*
+            * About to remove row based on snapshot_too_old. Need to raise
+            * the threshold so problematic accesses would error.
+            */
+           Assert(!prstate->old_snap_used);
+           SetOldSnapshotThresholdTimestamp(prstate->old_snap_ts,
+                                            prstate->old_snap_xmin);
+           prstate->old_snap_used = true;
+           res = HEAPTUPLE_DEAD;//可以清除
+       }
+   }
+
+   return res;
+}
+
+
 /*
  * Prune specified line pointer or a HOT chain originating at line pointer.
  *
@@ -349,9 +474,7 @@ heap_page_prune(Relation relation, Buffer buffer, TransactionId OldestXmin,
  * Returns the number of tuples (to be) deleted from the page.
  */
 static int
-heap_prune_chain(Relation relation, Buffer buffer, OffsetNumber rootoffnum,
-                TransactionId OldestXmin,//去掉OldestXmin
-                PruneState *prstate)
+heap_prune_chain(Buffer buffer, OffsetNumber rootoffnum, PruneState *prstate)
 {
    int         ndeleted = 0;
    Page        dp = (Page) BufferGetPage(buffer);
@@ -366,7 +489,7 @@ heap_prune_chain(Relation relation, Buffer buffer, OffsetNumber rootoffnum,
                i;
    HeapTupleData tup;
 
-   tup.t_tableOid = RelationGetRelid(relation);
+   tup.t_tableOid = RelationGetRelid(prstate->rel);
 
    rootlp = PageGetItemId(dp, rootoffnum);
 
@@ -401,7 +524,7 @@ heap_prune_chain(Relation relation, Buffer buffer, OffsetNumber rootoffnum,
             * either here or while following a chain below.  Whichever path
             * gets there first will mark the tuple unused.
             */
-           if (HeapTupleSatisfiesVacuum(&tup, OldestXmin, buffer)
+           if (heap_prune_satisfies_vacuum(prstate, &tup, buffer)//改為使用heap_prune_satisfies_vacuum
                == HEAPTUPLE_DEAD && !HeapTupleHeaderIsHotUpdated(htup))
            {
                heap_prune_record_unused(prstate, rootoffnum);
@@ -485,7 +608,7 @@ heap_prune_chain(Relation relation, Buffer buffer, OffsetNumber rootoffnum,
         */
        tupdead = recent_dead = false;
 
-       switch (HeapTupleSatisfiesVacuum(&tup, OldestXmin, buffer))
+       switch (heap_prune_satisfies_vacuum(prstate, &tup, buffer))
        {
            case HEAPTUPLE_DEAD:
                tupdead = true;
```

### 三、跟蹤分析
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 原始碼解讀（252）- PG 14（Improving connection scalability）#4

相關文章