PostgreSQL 14在MVCC上面有所增强，以保证在大批量客户端连接场景下性能不会出现显著下降（详细可参见参考资料中的链接），本节对函数GetSnapshotData进行跟踪分析。 ### 一、数据结构 **ProcArrayStruct** ``` /* Our shared memory area */ typedef struct ProcArrayStruct { //有效的procs个数 int numProcs; /* number of valid procs entries */ //分配的procs数组大小 int maxProcs; /* allocated size of procs array */ /* * Known assigned XIDs handling * 已知已分配的XIDs */ int maxKnownAssignedXids; /* allocated size of array ，分配的数组大小*/ int numKnownAssignedXids; /* current # of valid entries，当前第几个entry */ int tailKnownAssignedXids; /* index of oldest valid element，最旧有效元素的索引编号，在数组的尾部 */ int headKnownAssignedXids; /* index of newest element, + 1，最新元素编号+1，在数组的头部 */ slock_t known_assigned_xids_lck; /* protects head/tail pointers，用于保护head/tail指针的锁 */ /* * Highest subxid that has been removed from KnownAssignedXids array to * prevent overflow; or InvalidTransactionId if none. We track this for * similar reasons to tracking overflowing cached subxids in PGPROC * entries. Must hold exclusive ProcArrayLock to change this, and shared * lock to read it. * 从KnownAssignedXids中移除用于避免溢出的的subxid最大值,如无，则为InvalidTransactionId * 跟踪该值的理由与跟踪溢出PGPROC中的subxids类似。 * 在修改该值前必须持有ProcArrayLock独占锁，读取则需要共享锁。 */ TransactionId lastOverflowedXid; /* oldest xmin of any replication slot */ /* 复制槽中最小的xmin */ TransactionId replication_slot_xmin; /* oldest catalog xmin of any replication slot */ /* 复制槽中最小的字典xmin */ TransactionId replication_slot_catalog_xmin; /* indexes into allProcs[], has PROCARRAY_MAXPROCS entries */ /* allProcs索引，个数 = PROCARRAY_MAXPROCS */ int pgprocnos[FLEXIBLE_ARRAY_MEMBER]; } ProcArrayStruct; ``` **PROC_HDR** ``` /* * There is one ProcGlobal struct for the whole database cluster. * 全局的ProcGlobal(PROC_HDR)结构体 * * Adding/Removing an entry into the procarray requires holding *both* * ProcArrayLock and XidGenLock in exclusive mode (in that order). Both are * needed because the dense arrays (see below) are accessed from * GetNewTransactionId() and GetSnapshotData(), and we don't want to add * further contention by both using the same lock. Adding/Removing a procarray * entry is much less frequent. * 对proc数组的插入和删除,需要以独占的模式持有ProcArrayLock和XidGenLock, * 原因是GetNewTransactionId()和GetSnapshotData()函数需要访问,并且我们不希望使用同样的锁来增加争用. * 其实,插入和删除proc数组并不频繁. * * Some fields in PGPROC are mirrored into more densely packed arrays (e.g. * xids), with one entry for each backend. These arrays only contain entries * for PGPROCs that have been added to the shared array with ProcArrayAdd() * (in contrast to PGPROC array which has unused PGPROCs interspersed). * PGPROC中的一些字段镜像到更稠密的数组中(如xids),每一个后台进程都有一项. * 这些数组只包含使用ProcArrayAdd()加入到共享数组的PGPROCs. * * The dense arrays are indexed by PGPROC->pgxactoff. Any concurrent * ProcArrayAdd() / ProcArrayRemove() can lead to pgxactoff of a procarray * member to change. Therefore it is only safe to use PGPROC->pgxactoff to * access the dense array while holding either ProcArrayLock or XidGenLock. * 稠密数组通过PGPROC->pgxactoff字段进行索引,所有同步ProcArrayAdd和ProcArrayRemove操作 * 会改变procarray中的pgxactoff成员变量. * * As long as a PGPROC is in the procarray, the mirrored values need to be * maintained in both places in a coherent manner. * 由于PGPROC在proc数组中,镜像值需要以一致的方式进行运维. * * The denser separate arrays are beneficial for three main reasons: First, to * allow for as tight loops accessing the data as possible. Second, to prevent * updates of frequently changing data (e.g. xmin) from invalidating * cachelines also containing less frequently changing data (e.g. xid, * statusFlags). Third to condense frequently accessed data into as few * cachelines as possible. * 基于以下3点原因,更稠密单独的数组会带来不少好处. * 1.紧密的循环访问数据成为可能; * 2.避免了对修改频度不高的数据进行修改导致CPU缓存无效的情况出现; * 3.使频繁访问的数据放在小量的CPU缓存中成为可能. * * There are two main reasons to have the data mirrored between these dense * arrays and PGPROC. First, as explained above, a PGPROC's array entries can * only be accessed with either ProcArrayLock or XidGenLock held, whereas the * PGPROC entries do not require that (obviously there may still be locking * requirements around the individual field, separate from the concerns * here). That is particularly important for a backend to efficiently checks * it own values, which it often can safely do without locking. Second, the * PGPROC fields allow to avoid unnecessary accesses and modification to the * dense arrays. A backend's own PGPROC is more likely to be in a local cache, * whereas the cachelines for the dense array will be modified by other * backends (often removing it from the cache for other cores/sockets). At * commit/abort time a check of the PGPROC value can avoid accessing/dirtying * the corresponding array value. * 让这些稠密数组和PGPROC之间生成数据镜像,有两个主要原因: * 1.如上所述,PGPROC数组条目需要在持有ProcArrayLock和XidGenLock的前提下才能访问,但实际上并不需要. * 在没有锁的情况下,后台进程有效且安全的检查自己的值是十分重要的. * 2.PGPROC中的字段避免不必要的访问和修改.后台进程自己的PGPROC更应该在自己的本地缓存中, * 而无需理会数组会被其他进程修改.在事务提交或回滚时,检查PGPROC值可以避免访问或者弄脏相应的数组值 * * Basically it makes sense to access the PGPROC variable when checking a * single backend's data, especially when already looking at the PGPROC for * other reasons already. It makes sense to look at the "dense" arrays if we * need to look at many / most entries, because we then benefit from the * reduced indirection and better cross-process cache-ability. * 检查单个后台进程数据时,访问PGPROC值是比较敏感的,特别是在已经因为其他原因检索过PGPROC的情况下 * * When entering a PGPROC for 2PC transactions with ProcArrayAdd(), the data * in the dense arrays is initialized from the PGPROC while it already holds * ProcArrayLock. * 在2PC事务的情况下,通过ProcArrayAdd方法进入PGPROC时, * 数组中的数据在持有ProcArrayLock锁的情况下初始化数组. */ typedef struct PROC_HDR { /* Array of PGPROC structures (not including dummies for prepared txns) */ //PGPROC结构体数组 PGPROC *allProcs; /* Array mirroring PGPROC.xid for each PGPROC currently in the procarray */ // 镜像每一个PGPROC.xid TransactionId *xids; /* * Array mirroring PGPROC.subxidStatus for each PGPROC currently in the * procarray. */ //镜像PGPROC.subxidStatus XidCacheStatus *subxidStates; /* * Array mirroring PGPROC.statusFlags for each PGPROC currently in the * procarray. */ //镜像PGPROC.statusFlags uint8 *statusFlags; /* Length of allProcs array */ //allProcs数组的大小 uint32 allProcCount; /* Head of list of free PGPROC structures */ //空闲PGPROC结构体链表头 PGPROC *freeProcs; /* Head of list of autovacuum's free PGPROC structures */ //autovacuum进程空闲PGPROC结构体链表头 PGPROC *autovacFreeProcs; /* Head of list of bgworker free PGPROC structures */ //bgworker进程 PGPROC *bgworkerFreeProcs; /* Head of list of walsender free PGPROC structures */ //walsender PGPROC *walsenderFreeProcs; /* First pgproc waiting for group XID clear */ //等待XID组清理的第一个pgproc pg_atomic_uint32 procArrayGroupFirst; /* First pgproc waiting for group transaction status update */ //等待事务状态组更新的首个pgproc pg_atomic_uint32 clogGroupFirst; /* WALWriter process's latch */ //WALWriter进程latch Latch *walwriterLatch; /* Checkpointer process's latch */ //检查点进程latch Latch *checkpointerLatch; /* Current shared estimate of appropriate spins_per_delay value */ //spins_per_delay int spins_per_delay; /* The proc of the Startup process, since not in ProcArray */ //Startup进程的proc结构体,不再Proc数组中 PGPROC *startupProc; int startupProcPid; /* Buffer id of the buffer that Startup process waits for pin on, or -1 */ //Startup进程等待pin的缓存ID int startupBufferPinWaitBufId; } PROC_HDR; extern PGDLLIMPORT PROC_HDR *ProcGlobal; ``` **PGPROC** ``` /* * Note: MAX_BACKENDS is limited to 2^18-1 because that's the width reserved * for buffer references in buf_internals.h. This limitation could be lifted * by using a 64bit state; but it's unlikely to be worthwhile as 2^18-1 * backends exceed currently realistic configurations. Even if that limitation * were removed, we still could not a) exceed 2^23-1 because inval.c stores * the backend ID as a 3-byte signed integer, b) INT_MAX/4 because some places * compute 4*MaxBackends without any overflow check. This is rechecked in the * relevant GUC check hooks and in RegisterBackgroundWorker(). * 注意:MAX_BACKENDS限制为2^18-1, * 这是因为该值为buf_internals.h中定义的缓存依赖的最大宽度. * 该限制可以通过使用64bit的状态来提升,但它看起来并不值当. * 如果去掉该限制,我们仍然不能够超过: * a) 2^23-1,因为inval.c使用3个字节的有符号整数存储后台进程ID * b) INT_MAX/4 ,因为某些地方没有任何的溢出检查,直接计算4*MaxBackends的值. * 该值会在相关的GUC检查钩子和RegisterBackgroundWorker()函数中检查. */ #define MAX_BACKENDS 0x3FFFF /* shmqueue.c */ typedef struct SHM_QUEUE { struct SHM_QUEUE *prev; struct SHM_QUEUE *next; } SHM_QUEUE; /* * An invalid pgprocno. Must be larger than the maximum number of PGPROC * structures we could possibly have. See comments for MAX_BACKENDS. * 无效的pg进程号. * 必须大于我们可能拥有的最大的PGPROC数目. * 详细解释见MAX_BACKENDS */ #define INVALID_PGPROCNO PG_INT32_MAX /* * Each backend has a PGPROC struct in shared memory. There is also a list of * currently-unused PGPROC structs that will be reallocated to new backends. * 每个后台进程在共享内存中都有一个PGPROC结构体. * 存在未使用的PGPROC结构体链表,用于为新的后台进程重新进行分配. * * links: list link for any list the PGPROC is in. When waiting for a lock, * the PGPROC is linked into that lock's waitProcs queue. A recycled PGPROC * is linked into ProcGlobal's freeProcs list. * links: PGPROC所在的链表的链接. * 在等待锁时,PGPROC链接到该锁的waiProc队列中. * 回收的PGPROC链接到ProcGlobal的freeProcs链表中. * * Note: twophase.c also sets up a dummy PGPROC struct for each currently * prepared transaction. These PGPROCs appear in the ProcArray data structure * so that the prepared transactions appear to be still running and are * correctly shown as holding locks. A prepared transaction PGPROC can be * distinguished from a real one at need by the fact that it has pid == 0. * The semaphore and lock-activity fields in a prepared-xact PGPROC are unused, * but its myProcLocks[] lists are valid. * 注意:twophase.c也会为每一个当前已准备妥当的事务配置一个虚拟的PGPROC结构. * 这些PGPROCs在数组ProcArray数据结构中出现,以便已准备的事务看起来仍在运行, * 并正确的显示为持有锁. * 已准备妥当的事务PGPROC与一个真正的PGPROC事实上的区别是pid == 0. * 在prepared-xact PGPROC中的信号量和活动锁域字段没有使用,但myProcLocks[]链表是有效的. */ struct PGPROC { /* proc->links MUST BE FIRST IN STRUCT (see ProcSleep,ProcWakeup,etc) */ //proc->links必须是结构体的第一个域(参考ProcSleep,ProcWakeup...等) //如进程在链表中,这是链表的链接 SHM_QUEUE links; /* list link if process is in a list */ //持有该PGPROC的procglobal链表数组 PGPROC **procgloballist; /* procglobal list that owns this PGPROC */ //可以休眠的信号量 PGSemaphore sem; /* ONE semaphore to sleep on */ //状态为:STATUS_WAITING, STATUS_OK or STATUS_ERROR int waitStatus; /* STATUS_WAITING, STATUS_OK or STATUS_ERROR */ //进程通用的latch Latch procLatch; /* generic latch for process */ //运行中的进程正在执行的最高层的事务本地ID,如无运行则为InvalidLocalTransactionId LocalTransactionId lxid; /* local id of top-level transaction currently * being executed by this proc, if running; * else InvalidLocalTransactionId */ //后台进程的ID,如为虚拟事务则为0 int pid; /* Backend's process ID; 0 if prepared xact */ int pgprocno; /* These fields are zero while a backend is still starting up: */ //------------ 这些域在进程正在启动时为0 //已分配的后台进程的backend ID BackendId backendId; /* This backend's backend ID (if assigned) */ //该进程使用的数据库ID Oid databaseId; /* OID of database this backend is using */ //使用该进程的角色ID Oid roleId; /* OID of role using this backend */ //该进程使用的临时schema OID Oid tempNamespaceId; /* OID of temp schema this backend is * using */ //如后台进程,则为T bool isBackgroundWorker; /* true if background worker. */ /* * While in hot standby mode, shows that a conflict signal has been sent * for the current transaction. Set/cleared while holding ProcArrayLock, * though not required. Accessed without lock, if needed. * 如在hot standby模式,显示已为当前事务发送冲突信号. * 尽管不需要,设置/清除持有的ProcArrayLock. * 如需要,则在没有持有锁的情况下访问. */ bool recoveryConflictPending; /* Info about LWLock the process is currently waiting for, if any. */ //-------------- 进程正在等待的LWLock相关信息 //等待LW lock,为T bool lwWaiting; /* true if waiting for an LW lock */ //正在等的LWLock锁模式 uint8 lwWaitMode; /* lwlock mode being waited for */ //等待链表中的位置 proclist_node lwWaitLink; /* position in LW lock wait list */ /* Support for condition variables. */ //-------------- 支持条件变量 //CV等待链表中的位置 proclist_node cvWaitLink; /* position in CV wait list */ /* Info about lock the process is currently waiting for, if any. */ //-------------- 进程正在等待的锁信息 /* waitLock and waitProcLock are NULL if not currently waiting. */ //如没有在等待,则waitLock和waitProcLock为NULL //休眠...等待的锁对象 LOCK *waitLock; /* Lock object we're sleeping on ... */ //等待锁的每个持锁人信息 PROCLOCK *waitProcLock; /* Per-holder info for awaited lock */ //等待的所类型 LOCKMODE waitLockMode; /* type of lock we're waiting for */ //该进程已持有锁的类型位掩码 LOCKMASK heldLocks; /* bitmask for lock types already held on this * lock object by this backend */ /* * Info to allow us to wait for synchronous replication, if needed. * waitLSN is InvalidXLogRecPtr if not waiting; set only by user backend. * syncRepState must not be touched except by owning process or WALSender. * syncRepLinks used only while holding SyncRepLock. * 允许我们等待同步复制的相关信息. * 如无需等待,则waitLSN为InvalidXLogRecPtr;仅允许由用户后台设置。 * 除非拥有process或WALSender，否则不能修改syncRepState。 * 仅在持有SyncRepLock时使用的syncrepink。 */ //--------------------- //等待该LSN或者更高的LSN XLogRecPtr waitLSN; /* waiting for this LSN or higher */ //同步复制的等待状态 int syncRepState; /* wait state for sync rep */ //如进程处于syncrep队列中,则该值保存链表链接 SHM_QUEUE syncRepLinks; /* list link if process is in syncrep queue */ /* * All PROCLOCK objects for locks held or awaited by this backend are * linked into one of these lists, according to the partition number of * their lock. * 该后台进程持有或等待的锁相关的所有PROCLOCK对象链接在这些链表的末尾, * 根据棣属于这些锁的分区号进行区分. */ SHM_QUEUE myProcLocks[NUM_LOCK_PARTITIONS]; //子事务的XIDs struct XidCache subxids; /* cache for subtransaction XIDs */ /* Support for group XID clearing. */ /* true, if member of ProcArray group waiting for XID clear */ //支持XID分组清除 //如属于等待XID清理的ProcArray组,则为T bool procArrayGroupMember; /* next ProcArray group member waiting for XID clear */ //等待XID清理的下一个ProcArray组编号 pg_atomic_uint32 procArrayGroupNext; /* * latest transaction id among the transaction's main XID and * subtransactions * 在事务主XID和子事务之间的最后的事务ID */ TransactionId procArrayGroupMemberXid; //进程的等待信息 uint32 wait_event_info; /* proc's wait information */ /* Support for group transaction status update. */ //--------------- 支持组事务状态更新 //clog组成员,则为T bool clogGroupMember; /* true, if member of clog group */ //下一个clog组成员 pg_atomic_uint32 clogGroupNext; /* next clog group member */ //clog组成员事务ID TransactionId clogGroupMemberXid; /* transaction id of clog group member */ //clog组成员的事务状态 XidStatus clogGroupMemberXidStatus; /* transaction status of clog * group member */ //属于clog组成员的事务ID的clog page int clogGroupMemberPage; /* clog page corresponding to * transaction id of clog group member */ //clog组成员已提交记录的WAL位置 XLogRecPtr clogGroupMemberLsn; /* WAL location of commit record for clog * group member */ /* Per-backend LWLock. Protects fields below (but not group fields). */ //每一个后台进程一个LWLock.保护下面的域字段(非组字段) LWLock backendLock; /* Lock manager data, recording fast-path locks taken by this backend. */ //---------- 锁管理数据,记录该后台进程以最快路径获得的锁 //每一个fast-path slot的锁模式 uint64 fpLockBits; /* lock modes held for each fast-path slot */ //rel oids的slots Oid fpRelId[FP_LOCK_SLOTS_PER_BACKEND]; /* slots for rel oids */ //是否持有fast-path VXID锁 bool fpVXIDLock; /* are we holding a fast-path VXID lock? */ //fast-path VXID锁的lxid LocalTransactionId fpLocalTransactionId; /* lxid for fast-path VXID * lock */ /* * Support for lock groups. Use LockHashPartitionLockByProc on the group * leader to get the LWLock protecting these fields. */ //--------- 支持锁组. // 在组leader中使用LockHashPartitionLockByProc获取LWLock保护这些域 //锁组的leader,如果"我"是其中一员 PGPROC *lockGroupLeader; /* lock group leader, if I'm a member */ //如果"我"是leader,这是成员的链表 dlist_head lockGroupMembers; /* list of members, if I'm a leader */ //成员连接,如果"我"是其中一员 dlist_node lockGroupLink; /* my member link, if I'm a member */ }; /* NOTE: "typedef struct PGPROC PGPROC" appears in storage/lock.h. */ //注意:"typedef struct PGPROC PGPROC"在storage/lock.h中出现 extern PGDLLIMPORT PGPROC *MyProc; extern PGDLLIMPORT struct PGXACT *MyPgXact; ``` **SnapshotData** ``` /* * The different snapshot types. We use SnapshotData structures to represent * both "regular" (MVCC) snapshots and "special" snapshots that have non-MVCC * semantics. The specific semantics of a snapshot are encoded by its type. * 快照类型。 * 使用SnapshotData结构体表示常规的（MVCC）的快照和特别的快照（非MVCC语义）。 * 快照的特殊语义通过其类型进行编码。 * * The behaviour of each type of snapshot should be documented alongside its * enum value, best in terms that are not specific to an individual table AM. * 每种快照类型的行为与其enum值一起记录而不是特定于单个表的AM。 * * The reason the snapshot type rather than a callback as it used to be is * that that allows to use the same snapshot for different table AMs without * having one callback per AM. * 使用快照类型而不是回调函数的原因是对于不同的表AMs（访问方法）可使用相同的快照而不是每个AM使用一个回调函数 */ typedef enum SnapshotType { /*------------------------------------------------------------------------- * A tuple is visible iff the tuple is valid for the given MVCC snapshot. * * Here, we consider the effects of: * - all transactions committed as of the time of the given snapshot * - previous commands of this transaction * * Does _not_ include: * - transactions shown as in-progress by the snapshot * - transactions started after the snapshot was taken * - changes made by the current command * 元组对于给定的MVCC快照是有效的，则该元组可见 * 考虑： * 给定快照时所有提交的事务 * 该事务先前执行的命令 * 不考虑： * 正在处理中的事务 * 快照点之后的事务 * 当前命令做出的修改 * ------------------------------------------------------------------------- */ SNAPSHOT_MVCC = 0,//常规的MVCC /*------------------------------------------------------------------------- * A tuple is visible iff the tuple is valid "for itself". * 对于“自身”是有效，则元组可见 * * Here, we consider the effects of: * - all committed transactions (as of the current instant) * - previous commands of this transaction * - changes made by the current command * * Does _not_ include: * - in-progress transactions (as of the current instant) * 考虑： * 所有已提交的事务（当前实例） * 本事务先前的命令 * 当前命令的修改 * 不考虑 * 正在进行中的事务 * ------------------------------------------------------------------------- */ SNAPSHOT_SELF, /* * Any tuple is visible. * 所有元组都是可见的 */ SNAPSHOT_ANY, /* * A tuple is visible iff the tuple is valid as a TOAST row. * 元组作为TOAST行为有效时，元组是可见的。 */ SNAPSHOT_TOAST, /*------------------------------------------------------------------------- * A tuple is visible iff the tuple is valid including effects of open * transactions. * 只要元组有效（包括开放事务的影响）则元组可见 * * Here, we consider the effects of: * - all committed and in-progress transactions (as of the current instant) * - previous commands of this transaction * - changes made by the current command * 这里，考虑： * 所有已提交和处理中的事务 * 该事务先前的命令 * 当前命令作出的修改 * * This is essentially like SNAPSHOT_SELF as far as effects of the current * transaction and committed/aborted xacts are concerned. However, it * also includes the effects of other xacts still in progress. * 就当前和提交/中止事务的影响来看，本质上类似于SNAPSHOT_SELF。 * * A special hack is that when a snapshot of this type is used to * determine tuple visibility, the passed-in snapshot struct is used as an * output argument to return the xids of concurrent xacts that affected * the tuple. snapshot->xmin is set to the tuple's xmin if that is * another transaction that's still in progress; or to * InvalidTransactionId if the tuple's xmin is committed good, committed * dead, or my own xact. Similarly for snapshot->xmax and the tuple's * xmax. If the tuple was inserted speculatively, meaning that the * inserter might still back down on the insertion without aborting the * whole transaction, the associated token is also returned in * snapshot->speculativeToken. See also InitDirtySnapshot(). * 这种快照用于确定元组的可见性，传入的快照结构体用作输出参数返回当前影响元组的事务xids。 * snapshot->xmin设置为元组的xmin，如果这是另外一个进行中的事务； * 设置为InvalidTransactionId如果元组的xmin对应的事务已完成提交/终止/或者是本事务 * snapshot->xmax与元组xmax与此类似。 * 如果tuple是speculatively插入的，这意味着插入事务仍可以继续插入，而不会中止整个事务， * 相关的令牌会通过snapshot—>speculativeToken返回。 * ------------------------------------------------------------------------- */ SNAPSHOT_DIRTY, /* * A tuple is visible iff it follows the rules of SNAPSHOT_MVCC, but * supports being called in timetravel context (for decoding catalog * contents in the context of logical decoding). * 如遵循SNAPSHOT_MVCC规则，则元组是可见的，但支持在timetravel上下文中调用 * （在逻辑解码上下文时解码catalog内容） */ SNAPSHOT_HISTORIC_MVCC, /* * A tuple is visible iff the tuple might be visible to some transaction; * false if it's surely dead to everyone, i.e., vacuumable. * * For visibility checks snapshot->min must have been set up with the xmin * horizon to use. * 对于某些事务是可见的，则元组可见。 * 如已确认“死亡”则为False，如需要被清理。 * 对于可见性检查而言，snapshot->min必须使用xmin来配置 */ SNAPSHOT_NON_VACUUMABLE } SnapshotType; typedef struct SnapshotData *Snapshot; #define InvalidSnapshot ((Snapshot) NULL) /* * Struct representing all kind of possible snapshots. * 对应所有可能快照的结构体 * * There are several different kinds of snapshots: * * Normal MVCC snapshots * * MVCC snapshots taken during recovery (in Hot-Standby mode) * * Historic MVCC snapshots used during logical decoding * * snapshots passed to HeapTupleSatisfiesDirty() * * snapshots passed to HeapTupleSatisfiesNonVacuumable() * * snapshots used for SatisfiesAny, Toast, Self where no members are * accessed. * 快照类型包括（详见SnapshotType）： * 普通的MVCC快照 * 恢复期间的MVCC快照 * 逻辑解码时的历史MVCC快照 * 传递给HeapTupleSatisfiesDirty的快照 * 传递给HeapTupleSatisfiesNonVacuumable的快照 * 传递给SatisfiesAny，Toast，Self的快照 * * TODO: It's probably a good idea to split this struct using a NodeTag * similar to how parser and executor nodes are handled, with one type for * each different kind of snapshot to avoid overloading the meaning of * individual fields. * TODO：通过NodeTag来拆分结构体 */ typedef struct SnapshotData { //快照类型 SnapshotType snapshot_type; /* type of snapshot */ /* * The remaining fields are used only for MVCC snapshots, and are normally * just zeroes in special snapshots. (But xmin and xmax are used * specially by HeapTupleSatisfiesDirty, and xmin is used specially by * HeapTupleSatisfiesNonVacuumable.) * 余下字段用于MVCC快照，其他特殊的快照设置为0. * （xmin和xmax用于HeapTupleSatisfiesDirty，xmin用于HeapTupleSatisfiesNonVacuumable） * * An MVCC snapshot can never see the effects of XIDs >= xmax. It can see * the effects of all older XIDs except those listed in the snapshot. xmin * is stored as an optimization to avoid needing to search the XID arrays * for most tuples. * MVCC快照用于都看不到XIDs >= xmax的影响，但可以看到除了快照列表中的事务影响。 * xmin作为优化的手段用于避免检索XID数组 */ TransactionId xmin; /* all XID < xmin are visible to me */ TransactionId xmax; /* all XID >= xmax are invisible to me */ /* * For normal MVCC snapshot this contains the all xact IDs that are in * progress, unless the snapshot was taken during recovery in which case * it's empty. For historic MVCC snapshots, the meaning is inverted, i.e. * it contains *committed* transactions between xmin and xmax. * xip用于存放所有正在进行中的事务，除了在恢复期间的快照。 * 对于历史MVCC快照，意思的相反的，也就是说xip是xmin和xmax之间已提交的事务 * * note: all ids in xip[] satisfy xmin <= xip[i] < xmax * xip数组中的元素满足：xmin <= xip[i] < xmax */ TransactionId *xip; uint32 xcnt; /* 数组大小，# of xact ids in xip[] */ /* * For non-historic MVCC snapshots, this contains subxact IDs that are in * progress (and other transactions that are in progress if taken during * recovery). For historic snapshot it contains *all* xids assigned to the * replayed transaction, including the toplevel xid. * 对于非历史MVCC快照，包含正在进行中的子事务IDs。 * 对于历史MVCC快照，包含所有分配给已回放事务的所有xids（包括顶层xid） * * note: all ids in subxip[] are >= xmin, but we don't bother filtering * out any that are >= xmax */ TransactionId *subxip; int32 subxcnt; /* 数组大小，# of xact ids in subxip[] */ bool suboverflowed; /* 数组溢出？has the subxip array overflowed? */ bool takenDuringRecovery; /* recovery-shaped snapshot? */ bool copied; /* false if it's a static snapshot */ CommandId curcid; /* 在本事务中，CID < curcid则可见，in my xact, CID < curcid are visible */ /* * An extra return value for HeapTupleSatisfiesDirty, not used in MVCC * snapshots. * HeapTupleSatisfiesDirty额外的返回值 */ uint32 speculativeToken; /* * For SNAPSHOT_NON_VACUUMABLE (and hopefully more in the future) this is * used to determine whether row could be vacuumed. * 对于SNAPSHOT_NON_VACUUMABLE，用于确定哪些行可以被清理 */ struct GlobalVisState *vistest; /* * Book-keeping information, used by the snapshot manager * 用于快照管理器的信息 */ uint32 active_count; /* refcount on ActiveSnapshot stack */ uint32 regd_count; /* refcount on RegisteredSnapshots */ pairingheap_node ph_node; /* link in the RegisteredSnapshots heap */ TimestampTz whenTaken; /* timestamp when snapshot was taken */ XLogRecPtr lsn; /* position in the WAL stream when taken */ /* * The transaction completion count at the time GetSnapshotData() built * this snapshot. Allows to avoid re-computing static snapshots when no * transactions completed since the last GetSnapshotData(). */ uint64 snapXactCompletionCount; } SnapshotData; ``` **VariableCacheData** ``` /* * VariableCache is a data structure in shared memory that is used to track * OID and XID assignment state. For largely historical reasons, there is * just one struct with different fields that are protected by different * LWLocks. * VariableCache是共享内存中的一种数据结构，用于跟踪OID和XID分配状态。 * 由于历史原因，这个结构体有不同的字段,由不同的LWLocks保护。 * * Note: xidWrapLimit and oldestXidDB are not "active" values, but are * used just to generate useful messages when xidWarnLimit or xidStopLimit * are exceeded. * 注意:xidWrapLimit和oldestXidDB是不"活跃"的值,在xidWarnLimit或xidStopLimit * 超出限制时用于产生有用的信息. */ typedef struct VariableCacheData { /* * These fields are protected by OidGenLock. * 这些域字段通过OidGenLock字段保护 */ //下一个待分配的OID Oid nextOid; /* next OID to assign */ //在必须执行XLOG work前可用OIDs uint32 oidCount; /* OIDs available before must do XLOG work */ /* * These fields are protected by XidGenLock. * 这些字段通过XidGenLock锁保护. */ //下一个待分配的事务ID TransactionId nextXid; /* next XID to assign */ //集群范围内最小datfrozenxid TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */ //在该XID开始强制执行autovacuum TransactionId xidVacLimit; /* start forcing autovacuums here */ //在该XID开始提出警告 TransactionId xidWarnLimit; /* start complaining here */ //在该XID开外,拒绝生成下一个XID TransactionId xidStopLimit; /* refuse to advance nextXid beyond here */ //"世界末日"XID,需回卷 TransactionId xidWrapLimit; /* where the world ends */ //持有最小datfrozenxid的DB Oid oldestXidDB; /* database with minimum datfrozenxid */ /* * These fields are protected by CommitTsLock * 这些字段通过CommitTsLock锁保护 */ TransactionId oldestCommitTsXid; TransactionId newestCommitTsXid; /* * These fields are protected by ProcArrayLock. * 这些字段通过ProcArrayLock锁保护 */ TransactionId latestCompletedXid; /* newest XID that has committed or * aborted */ /* * These fields are protected by CLogTruncationLock * 这些字段通过CLogTruncationLock锁保护 */ //clog中最古老的XID TransactionId oldestClogXid; /* oldest it's safe to look up in clog */ } VariableCacheData; //结构体指针 typedef VariableCacheData *VariableCache; /* pointer to "variable cache" in shared memory (set up by shmem.c) */ //共享内存中的指针(通过shmem.c设置) VariableCache ShmemVariableCache = NULL; ``` **GlobalVisState** ``` /* * State for the GlobalVisTest* family of functions. Those functions can * e.g. be used to decide if a deleted row can be removed without violating * MVCC semantics: If the deleted row's xmax is not considered to be running * by anyone, the row can be removed. * 用于配合GlobalVisTest*函数族使用的数据结构。 * 这些函数用于确定删除的行在不违反MVCC语义的情况下是否可以被清除： * 如果被删除的行的xmax与所有运行的事务无关，那么可以清除。 * * To avoid slowing down GetSnapshotData(), we don't calculate a precise * cutoff XID while building a snapshot (looking at the frequently changing * xmins scales badly). Instead we compute two boundaries while building the * snapshot: * * 1) definitely_needed, indicating that rows deleted by XIDs >= * definitely_needed are definitely still visible. * * 2) maybe_needed, indicating that rows deleted by XIDs < maybe_needed can * definitely be removed * * 为了避免影响GetSnapshotData()的性能，在构建快照时我们不会计算精确的cutoff XID， * 相反，我们会在构建快照时计算两个边界，分别是： * 1）definitely_needed，表示如果删除事务的XIDs >= definitely_needed，则可见 * 2）maybe_needed，表示被XIDs < maybe_needed 事务删除的，可以确定被清除 * * When testing an XID that falls in between the two (i.e. XID >= maybe_needed * && XID < definitely_needed), the boundaries can be recomputed (using * ComputeXidHorizons()) to get a more accurate answer. This is cheaper than * maintaining an accurate value all the time. * 对于XID >= maybe_needed && XID < definitely_needed的XID， * 边界需要使用函数ComputeXidHorizons重新计算来获取更精确的结果，这比在所有情况下都维护一个精确值成本要低 * * As it is not cheap to compute accurate boundaries, we limit the number of * times that happens in short succession. See GlobalVisTestShouldUpdate(). * 计算精确的边界成本高昂，因此需要限制短时间内出现的次数，详细参见GlobalVisTestShouldUpdate函数 * * There are three backend lifetime instances of this struct, optimized for * different types of relations. As e.g. a normal user defined table in one * database is inaccessible to backends connected to another database, a test * specific to a relation can be more aggressive than a test for a shared * relation. Currently we track four different states: * 对于不同的关系，出于优化的目的，该结构有三种不同的backend生命周期。 * 比如某个数据库中用户定义的普通表对于连接到另外一个数据库的backends是不可见的， * 对某个特定关系的验证比起共享关系的验证要更为积极。我们跟踪四种不同的状态： * * 1) GlobalVisSharedRels, which only considers an XID's * effects visible-to-everyone if neither snapshots in any database, nor a * replication slot's xmin, nor a replication slot's catalog_xmin might * still consider XID as running. * 1）GlobalVisSharedRels，事务对该Relation的操作会影响所有数据库中的快照、复制槽的xmin和复制槽的catalog_xmin。 * * 2) GlobalVisCatalogRels, which only considers an XID's * effects visible-to-everyone if neither snapshots in the current * database, nor a replication slot's xmin, nor a replication slot's * catalog_xmin might still consider XID as running. * * I.e. the difference to GlobalVisSharedRels is that * snapshot in other databases are ignored. * 2）GlobalVisCatalogRels，事务对该Relation的操作会影响当前数据库中的快照、复制槽的xmin和复制槽的catalog_xmin * 与GlobalVisSharedRels不同之处是其他数据库的快照会被忽略 * * 3) GlobalVisDataRels, which only considers an XID's * effects visible-to-everyone if neither snapshots in the current * database, nor a replication slot's xmin consider XID as running. * * I.e. the difference to GlobalVisCatalogRels is that * replication slot's catalog_xmin is not taken into account. * * 3）GlobalVisDataRels，事务对该Relation的操作会影响当前数据库中的快照、复制槽的xmin * 与GlobalVisCatalogRels不同的是catalog_xmin不作考虑 * * 4) GlobalVisTempRels, which only considers the current session, as temp * tables are not visible to other sessions. * * 4）GlobalVisTempRels，只考虑当前会话，临时表对其他session不可见 * * GlobalVisTestFor(relation) returns the appropriate state * for the relation. * GlobalVisTestFor(relation)返回关系正确的状态 * * The boundaries are FullTransactionIds instead of TransactionIds to avoid * wraparound dangers. There e.g. would otherwise exist no procarray state to * prevent maybe_needed to become old enough after the GetSnapshotData() * call. * 边界使用FullTransactionIds而不是TransactionIds以避免因为回卷而导致的错误。 * 例如，在GetSnapshotData()调用后，将不存在procarray状态来防止maybe_needed变得32bit XID中存在的过老现象。 * * The typedef is in the header. */ struct GlobalVisState { /* XIDs >= are considered running by some backend */ //大于等于该值的XIDs：其他活动backend可见 FullTransactionId definitely_needed; /* XIDs < are not considered to be running by any backend */ //小于该值的XIDs：不再视为正在运行,均可见 FullTransactionId maybe_needed; }; /* * A 64 bit value that contains an epoch and a TransactionId. This is * wrapped in a struct to prevent implicit conversion to/from TransactionId. * Not all values represent valid normal XIDs. * 号外：PG 14已支持64 bit XID，令人厌烦的XID回卷问题不复存在 */ typedef struct FullTransactionId { uint64 value; } FullTransactionId; ``` ### 二、源码解读 N/A ### 三、跟踪分析 **SESSION** ``` -- session 1 [local:/opt/data5014]:5014 pgmaster@testdb=# begin; BEGIN Time: 0.370 ms [local:/opt/data5014]:5014 pgmaster@testdb=#* insert into t1 values(1); INSERT 0 1 Time: 0.805 ms [local:/opt/data5014]:5014 pgmaster@testdb=#* select txid_current(); txid_current -------------- 541 (1 row) Time: 0.596 ms [local:/opt/data5014]:5014 pgmaster@testdb=#* -- session 2(GDB跟踪的进程) [local:/opt/data5014]:5014 pgmaster@testdb=# begin; BEGIN Time: 0.299 ms [local:/opt/data5014]:5014 pgmaster@testdb=#* select * from t1; -- session 3 [local:/opt/data5014]:5014 pgmaster@testdb=# select txid_current(); txid_current -------------- 542 (1 row) Time: 4.314 ms [local:/opt/data5014]:5014 pgmaster@testdb=# ``` **跟踪分析** ``` (gdb) b GetSnapshotData Breakpoint 1 at 0x924965: file procarray.c, line 2111. (gdb) c Continuing. Breakpoint 1, GetSnapshotData (snapshot=0x103adc0 <CurrentSnapshotData>) at procarray.c:2111 2111 ProcArrayStruct *arrayP = procArray; //ProcArrayStruct结构体 (gdb) p *procArray $3 = {numProcs = 4, maxProcs = 122, maxKnownAssignedXids = 7930, numKnownAssignedXids = 0, tailKnownAssignedXids = 0, headKnownAssignedXids = 0, known_assigned_xids_lck = 0 '\000', lastOverflowedXid = 0, replication_slot_xmin = 0, replication_slot_catalog_xmin = 0, pgprocnos = 0x7fee7e2148a8} (gdb) p *procArray->pgprocnos $4 = 97 (gdb) n 2112 TransactionId *other_xids = ProcGlobal->xids; //PROC_HDR结构体 (gdb) p *ProcGlobal $5 = {allProcs = 0x7fee7e1f9300, xids = 0x7fee7e214480, subxidStates = 0x7fee7e214680, statusFlags = 0x7fee7e214780 "", allProcCount = 126, freeProcs = 0x7fee7e20dd00, autovacFreeProcs = 0x7fee7e20f1a0, bgworkerFreeProcs = 0x7fee7e210d20, walsenderFreeProcs = 0x7fee7e2132f0, procArrayGroupFirst = {value = 2147483647}, clogGroupFirst = {value = 2147483647}, walwriterLatch = 0x7fee7e2139f4, checkpointerLatch = 0x7fee7e213684, spins_per_delay = 208, startupProc = 0x0, startupProcPid = 0, startupBufferPinWaitBufId = -1} //PGPROC结构体数组(这里打印了数组的第一个元素) (gdb) p *ProcGlobal->allProcs $6 = {links = {prev = 0x0, next = 0x0}, procgloballist = 0x7fee7e1f92a8, sem = 0x7fee75684038, waitStatus = PROC_WAIT_STATUS_OK, procLatch = {is_set = 0, is_shared = true, owner_pid = 0}, xid = 0, xmin = 0, lxid = 0, pid = 0, pgxactoff = 0, pgprocno = 0, backendId = 0, databaseId = 0, roleId = 0, tempNamespaceId = 0, isBackgroundWorker = false, recoveryConflictPending = false, lwWaiting = false, lwWaitMode = 0 '\000', lwWaitLink = { next = 0, prev = 0}, cvWaitLink = {next = 0, prev = 0}, waitLock = 0x0, waitProcLock = 0x0, waitLockMode = 0, heldLocks = 0, waitStart = {value = 0}, delayChkpt = false, statusFlags = 0 '\000', waitLSN = 0, syncRepState = 0, syncRepLinks = {prev = 0x0, next = 0x0}, myProcLocks = {{prev = 0x7fee7e1f93b8, next = 0x7fee7e1f93b8}, {prev = 0x7fee7e1f93c8, next = 0x7fee7e1f93c8}, {prev = 0x7fee7e1f93d8, next = 0x7fee7e1f93d8}, { prev = 0x7fee7e1f93e8, next = 0x7fee7e1f93e8}, {prev = 0x7fee7e1f93f8, next = 0x7fee7e1f93f8}, {prev = 0x7fee7e1f9408, next = 0x7fee7e1f9408}, {prev = 0x7fee7e1f9418, next = 0x7fee7e1f9418}, {prev = 0x7fee7e1f9428, next = 0x7fee7e1f9428}, {prev = 0x7fee7e1f9438, next = 0x7fee7e1f9438}, {prev = 0x7fee7e1f9448, next = 0x7fee7e1f9448}, {prev = 0x7fee7e1f9458, next = 0x7fee7e1f9458}, {prev = 0x7fee7e1f9468, next = 0x7fee7e1f9468}, {prev = 0x7fee7e1f9478, next = 0x7fee7e1f9478}, {prev = 0x7fee7e1f9488, next = 0x7fee7e1f9488}, {prev = 0x7fee7e1f9498, next = 0x7fee7e1f9498}, {prev = 0x7fee7e1f94a8, next = 0x7fee7e1f94a8}}, subxidStatus = {count = 0 '\000', overflowed = false}, subxids = {xids = {0 <repeats 64 times>}}, procArrayGroupMember = false, procArrayGroupNext = {value = 2147483647}, procArrayGroupMemberXid = 0, wait_event_info = 0, clogGroupMember = false, clogGroupNext = {value = 2147483647}, clogGroupMemberXid = 0, clogGroupMemberXidStatus = 0, clogGroupMemberPage = 0, clogGroupMemberLsn = 0, fpInfoLock = {tranche = 60, state = {value = 536870912}, waiters = {head = 2147483647, tail = 2147483647}}, fpLockBits = 0, fpRelId = {0 <repeats 16 times>}, fpVXIDLock = false, fpLocalTransactionId = 0, lockGroupLeader = 0x0, lockGroupMembers = {head = {prev = 0x7fee7e1f9650, next = 0x7fee7e1f9650}}, lockGroupLink = {prev = 0x0, next = 0x0}} (gdb) p *ProcGlobal->xids $7 = 0 (gdb) n 2115 size_t count = 0; (gdb) 2116 int subcount = 0; (gdb) 2117 bool suboverflowed = false; (gdb) //无流复制 2124 TransactionId replication_slot_xmin = InvalidTransactionId; (gdb) 2125 TransactionId replication_slot_catalog_xmin = InvalidTransactionId; (gdb) 2127 Assert(snapshot != NULL); (gdb) 2140 if (snapshot->xip == NULL) (gdb) //已共享模式获取ProcArrayLock 2165 LWLockAcquire(ProcArrayLock, LW_SHARED); (gdb) //判断快照是否可以重用 2167 if (GetSnapshotDataReuse(snapshot)) (gdb) step //进入GetSnapshotDataReuse GetSnapshotDataReuse (snapshot=0x103adc0 <CurrentSnapshotData>) at procarray.c:2030 2030 Assert(LWLockHeldByMe(ProcArrayLock)); //快照信息 (gdb) p *snapshot $8 = {snapshot_type = SNAPSHOT_MVCC, xmin = 540, xmax = 540, xip = 0x2c15080, xcnt = 0, subxip = 0x2c6a350, subxcnt = 0, suboverflowed = false, takenDuringRecovery = false, copied = false, curcid = 0, speculativeToken = 0, vistest = 0x0, active_count = 0, regd_count = 0, ph_node = {first_child = 0x0, next_sibling = 0x0, prev_or_parent = 0x0}, whenTaken = 0, lsn = 0, snapXactCompletionCount = 1} (gdb) n 2032 if (unlikely(snapshot->snapXactCompletionCount == 0)) (gdb) 2035 curXactCompletionCount = ShmemVariableCache->xactCompletionCount; (gdb) //两者不等,不能重用 2036 if (curXactCompletionCount != snapshot->snapXactCompletionCount) //共享变量缓存 //最后一个已完成事务的xid=542,因此xmax=543 (gdb) p *ShmemVariableCache $9 = {nextOid = 16388, oidCount = 8189, nextXid = {value = 543}, oldestXid = 532, xidVacLimit = 200000532, xidWarnLimit = 2107484179, xidStopLimit = 2144484179, xidWrapLimit = 2147484179, oldestXidDB = 1, oldestCommitTsXid = 0, newestCommitTsXid = 0, latestCompletedXid = {value = 542}, xactCompletionCount = 3, oldestClogXid = 532} (gdb) n 2037 return false; (gdb) 2073 } (gdb) GetSnapshotData (snapshot=0x103adc0 <CurrentSnapshotData>) at procarray.c:2173 2173 latest_completed = ShmemVariableCache->latestCompletedXid; (gdb) 2174 mypgxactoff = MyProc->pgxactoff; (gdb) 2175 myxid = other_xids[mypgxactoff]; //获取快照的进程PGPROC结构体信息 (gdb) p *MyProc $10 = {links = {prev = 0x0, next = 0x0}, procgloballist = 0x7fee7e1f92a8, sem = 0x7fee756871b8, waitStatus = PROC_WAIT_STATUS_OK, procLatch = {is_set = 0, is_shared = true, owner_pid = 2593}, xid = 0, xmin = 0, lxid = 10, pid = 2593, pgxactoff = 2, pgprocno = 99, backendId = 3, databaseId = 16384, roleId = 10, tempNamespaceId = 0, isBackgroundWorker = false, recoveryConflictPending = false, lwWaiting = false, lwWaitMode = 0 '\000', lwWaitLink = {next = 0, prev = 0}, cvWaitLink = {next = 0, prev = 0}, waitLock = 0x0, waitProcLock = 0x0, waitLockMode = 0, heldLocks = 0, waitStart = {value = 0}, delayChkpt = false, statusFlags = 0 '\000', waitLSN = 0, syncRepState = 0, syncRepLinks = {prev = 0x0, next = 0x0}, myProcLocks = {{prev = 0x7fee7e20e808, next = 0x7fee7e20e808}, {prev = 0x7fee7e20e818, next = 0x7fee7e20e818}, { prev = 0x7fee7e20e828, next = 0x7fee7e20e828}, {prev = 0x7fee7e20e838, next = 0x7fee7e20e838}, {prev = 0x7fee7e20e848, next = 0x7fee7e20e848}, {prev = 0x7fee7e20e858, next = 0x7fee7e20e858}, {prev = 0x7fee7e20e868, next = 0x7fee7e20e868}, {prev = 0x7fee7e20e878, next = 0x7fee7e20e878}, {prev = 0x7fee7e20e888, next = 0x7fee7e20e888}, {prev = 0x7fee7e20e898, next = 0x7fee7e20e898}, {prev = 0x7fee7e20e8a8, next = 0x7fee7e20e8a8}, {prev = 0x7fee7e20e8b8, next = 0x7fee7e20e8b8}, {prev = 0x7fee7e20e8c8, next = 0x7fee7e20e8c8}, {prev = 0x7fee7e20e8d8, next = 0x7fee7e20e8d8}, {prev = 0x7fee7e20e8e8, next = 0x7fee7e20e8e8}, {prev = 0x7fee7e20e8f8, next = 0x7fee7e20e8f8}}, subxidStatus = {count = 0 '\000', overflowed = false}, subxids = {xids = {0 <repeats 64 times>}}, procArrayGroupMember = false, procArrayGroupNext = {value = 2147483647}, procArrayGroupMemberXid = 0, wait_event_info = 0, clogGroupMember = false, clogGroupNext = {value = 2147483647}, clogGroupMemberXid = 0, clogGroupMemberXidStatus = 0, clogGroupMemberPage = -1, clogGroupMemberLsn = 0, fpInfoLock = {tranche = 60, state = {value = 536870912}, waiters = {head = 2147483647, tail = 2147483647}}, fpLockBits = 0, fpRelId = {0 <repeats 14 times>, 2703, 1247}, fpVXIDLock = true, fpLocalTransactionId = 10, lockGroupLeader = 0x0, lockGroupMembers = {head = {prev = 0x7fee7e20eaa0, next = 0x7fee7e20eaa0}}, lockGroupLink = {prev = 0x0, next = 0x0}} (gdb) p mypgxactoff $11 = 2 (gdb) p other_xids[mypgxactoff] $12 = 0 (gdb) n 2176 Assert(myxid == MyProc->xid); (gdb) p MyProc->xid $13 = 0 (gdb) n 2178 oldestxid = ShmemVariableCache->oldestXid; (gdb) //curXactCompletionCount = 3 2179 curXactCompletionCount = ShmemVariableCache->xactCompletionCount; (gdb) 2182 xmax = XidFromFullTransactionId(latest_completed); (gdb) 2183 TransactionIdAdvance(xmax); (gdb) p xmax $14 = 542 (gdb) n 2184 Assert(TransactionIdIsNormal(xmax)); //xmax = 543(542 + 1) (gdb) p xmax $15 = 543 (gdb) n //初始化,xmin = xmax 2187 xmin = xmax; (gdb) 2190 if (TransactionIdIsNormal(myxid) && NormalTransactionIdPrecedes(myxid, xmin)) (gdb) p myxid $16 = 0 (gdb) n 2193 snapshot->takenDuringRecovery = RecoveryInProgress(); (gdb) 2195 if (!snapshot->takenDuringRecovery) (gdb) //不在恢复过程中 2197 size_t numProcs = arrayP->numProcs; (gdb) 2198 TransactionId *xip = snapshot->xip; (gdb) p numProcs $17 = 5 (gdb) n 2199 int *pgprocnos = arrayP->pgprocnos; (gdb) p *xip $18 = 2258962920 (gdb) p (int)*xip $19 = -2036004376 (gdb) n 2200 XidCacheStatus *subxidStates = ProcGlobal->subxidStates; (gdb) 2201 uint8 *allStatusFlags = ProcGlobal->statusFlags; (gdb) //遍历PGPROC数组,这是成本比较高的逻辑 2207 for (size_t pgxactoff = 0; pgxactoff < numProcs; pgxactoff++) (gdb) 2210 TransactionId xid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]); (gdb) 2213 Assert(allProcs[arrayP->pgprocnos[pgxactoff]].pgxactoff == pgxactoff); (gdb) p xid $20 = 0 (gdb) n //无效的xid,继续下一循环 2219 if (likely(xid == InvalidTransactionId)) (gdb) 2220 continue; (gdb) 2207 for (size_t pgxactoff = 0; pgxactoff < numProcs; pgxactoff++) (gdb) 2210 TransactionId xid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]); (gdb) 2213 Assert(allProcs[arrayP->pgprocnos[pgxactoff]].pgxactoff == pgxactoff); (gdb) p xid $21 = 541 //这是有效的xid (gdb) n 2219 if (likely(xid == InvalidTransactionId)) (gdb) //不是当前的事务,是其他事务xid 2227 if (pgxactoff == mypgxactoff) (gdb) 2236 Assert(TransactionIdIsNormal(xid)); (gdb) 2243 if (!NormalTransactionIdPrecedes(xid, xmax)) (gdb) p xid $22 = 541 (gdb) p xmax $23 = 543 (gdb) n 2250 statusFlags = allStatusFlags[pgxactoff]; (gdb) 2251 if (statusFlags & (PROC_IN_LOGICAL_DECODING | PROC_IN_VACUUM)) (gdb) p statusFlags $24 = 0 '\000' (gdb) n 2254 if (NormalTransactionIdPrecedes(xid, xmin)) (gdb) 2255 xmin = xid; (gdb) p xmin $25 = 543 (gdb) p xid $26 = 541 (gdb) n //该事务还没有完成,放在xip数组中 2258 xip[count++] = xid; (gdb) 2275 if (!suboverflowed) (gdb) p xip[0] $27 = 541 (gdb) n 2278 if (subxidStates[pgxactoff].overflowed) (gdb) 2282 int nsubxids = subxidStates[pgxactoff].count; (gdb) 2284 if (nsubxids > 0) (gdb) 2207 for (size_t pgxactoff = 0; pgxactoff < numProcs; pgxactoff++) (gdb) 2210 TransactionId xid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]); (gdb) 2213 Assert(allProcs[arrayP->pgprocnos[pgxactoff]].pgxactoff == pgxactoff); (gdb) p xid $29 = 0 (gdb) n 2219 if (likely(xid == InvalidTransactionId)) (gdb) 2220 continue; (gdb) 2207 for (size_t pgxactoff = 0; pgxactoff < numProcs; pgxactoff++) (gdb) 2210 TransactionId xid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]); (gdb) 2213 Assert(allProcs[arrayP->pgprocnos[pgxactoff]].pgxactoff == pgxactoff); (gdb) p xid $30 = 0 (gdb) n 2219 if (likely(xid == InvalidTransactionId)) (gdb) 2220 continue; (gdb) 2207 for (size_t pgxactoff = 0; pgxactoff < numProcs; pgxactoff++) (gdb) 2210 TransactionId xid = UINT32_ACCESS_ONCE(other_xids[pgxactoff]); (gdb) 2213 Assert(allProcs[arrayP->pgprocnos[pgxactoff]].pgxactoff == pgxactoff); (gdb) p xid $31 = 0 (gdb) n 2219 if (likely(xid == InvalidTransactionId)) (gdb) 2220 continue; //完成PGPROC数组的遍历 (gdb) 2207 for (size_t pgxactoff = 0; pgxactoff < numProcs; pgxactoff++) (gdb) 2344 replication_slot_xmin = procArray->replication_slot_xmin; (gdb) 2345 replication_slot_catalog_xmin = procArray->replication_slot_catalog_xmin; (gdb) 2347 if (!TransactionIdIsValid(MyProc->xmin)) (gdb) 2348 MyProc->xmin = TransactionXmin = xmin; (gdb) //释放锁 2350 LWLockRelease(ProcArrayLock); (gdb) 2365 oldestfxid = FullXidRelativeTo(latest_completed, oldestxid); (gdb) 2369 TransactionIdRetreatedBy(xmin, vacuum_defer_cleanup_age); (gdb) p oldestfxid $32 = {value = 532} (gdb) p latest_completed $33 = {value = 542} (gdb) n 2368 def_vis_xid_data = (gdb) p xmin $34 = 541 (gdb) n 2372 def_vis_xid_data = (gdb) 2379 def_vis_xid = def_vis_xid_data; (gdb) 2385 def_vis_xid = (gdb) 2388 def_vis_fxid = FullXidRelativeTo(latest_completed, def_vis_xid); (gdb) 2389 def_vis_fxid_data = FullXidRelativeTo(latest_completed, def_vis_xid_data); (gdb) p def_vis_fxid $35 = {value = 541} (gdb) n 2396 GlobalVisSharedRels.definitely_needed = (gdb) 2399 GlobalVisCatalogRels.definitely_needed = (gdb) 2402 GlobalVisDataRels.definitely_needed = (gdb) 2406 if (TransactionIdIsNormal(myxid)) //definitely_needed : 大于等于该值的XIDs：其他活动backend可见 //maybe_needed : 小于该值的XIDs：不再视为正在运行,均可见 (gdb) p GlobalVisDataRels $36 = {definitely_needed = {value = 541}, maybe_needed = {value = 532}} (gdb) n 2411 GlobalVisTempRels.definitely_needed = latest_completed; (gdb) 2412 FullTransactionIdAdvance(&GlobalVisTempRels.definitely_needed); (gdb) 2423 GlobalVisSharedRels.maybe_needed = (gdb) 2426 GlobalVisCatalogRels.maybe_needed = (gdb) 2429 GlobalVisDataRels.maybe_needed = (gdb) 2433 GlobalVisTempRels.maybe_needed = GlobalVisTempRels.definitely_needed; (gdb) 2436 RecentXmin = xmin; //临时表 (gdb) p GlobalVisTempRels $37 = {definitely_needed = {value = 543}, maybe_needed = {value = 543}} (gdb) n 2437 Assert(TransactionIdPrecedesOrEquals(TransactionXmin, RecentXmin)); (gdb) 2439 snapshot->xmin = xmin; (gdb) 2440 snapshot->xmax = xmax; (gdb) 2441 snapshot->xcnt = count; (gdb) 2442 snapshot->subxcnt = subcount; (gdb) 2443 snapshot->suboverflowed = suboverflowed; (gdb) 2444 snapshot->snapXactCompletionCount = curXactCompletionCount; (gdb) 2446 snapshot->curcid = GetCurrentCommandId(false); (gdb) 2452 snapshot->active_count = 0; (gdb) 2453 snapshot->regd_count = 0; (gdb) 2454 snapshot->copied = false; (gdb) 2456 GetSnapshotDataInitOldSnapshot(snapshot); (gdb) 2458 return snapshot; (gdb) 2459 } //最后获得的快照信息 (gdb) p *snapshot $38 = {snapshot_type = SNAPSHOT_MVCC, xmin = 541, xmax = 543, xip = 0x2c15080, xcnt = 1, subxip = 0x2c6a350, subxcnt = 0, suboverflowed = false, takenDuringRecovery = false, copied = false, curcid = 0, speculativeToken = 0, vistest = 0x0, active_count = 0, regd_count = 0, ph_node = {first_child = 0x0, next_sibling = 0x0, prev_or_parent = 0x0}, whenTaken = 0, lsn = 0, snapXactCompletionCount = 3} (gdb) ``` ### 四、参考资料 1.[Improving connection scalability: GetSnapshotData()](https://www.postgresql.org/message-id/20200301083601.ews6hz5dduc3w2se%40alap3.anarazel.de)