typedef struct TransactionStateData
{
	...
	TransactionId *childXids;	/* subcommitted child XIDs, in XID order */
	int			nChildXids;		/* # of subcommitted child XIDs */
	int			maxChildXids;	/* allocated size of childXids[] */
	...
    struct TransactionStateData *parent;	/* back link to parent */
} TransactionStateData;

/*
 * We will return true for the Xid of the current subtransaction, any of
 * its subcommitted children, any of its parents, or any of their
 * previously subcommitted children.  However, a transaction being aborted
 * is no longer "current", even though it may still have an entry on the
 * state stack.
 */
for (s = CurrentTransactionState; s != NULL; s = s->parent)
{
	int			low,
				high;

	if (s->state == TRANS_ABORT)
		continue;
	if (!FullTransactionIdIsValid(s->fullTransactionId))
		continue;			/* it can't have any child XIDs either */
	if (TransactionIdEquals(xid, XidFromFullTransactionId(s->fullTransactionId)))
		return true;
	/* As the childXids array is ordered, we can use binary search */
	low = 0;
	high = s->nChildXids - 1;
	while (low <= high)
	{
		int			middle;
		TransactionId probe;

		middle = low + (high - low) / 2;
		probe = s->childXids[middle];
		if (TransactionIdEquals(probe, xid))
			return true;
		else if (TransactionIdPrecedes(probe, xid))
			low = middle + 1;
		else
			high = middle - 1;
	}
}

/*
 * ...
 * If there's no room to fit a subtransaction XID into PGPROC, set the
 * cache-overflowed flag instead.  This forces readers to look in
 * pg_subtrans to map subtransaction XIDs up to top-level XIDs.
 * ...
 */
if (!isSubXact)
{
	...
}
else
{
	XidCacheStatus *substat = &ProcGlobal->subxidStates[MyProc->pgxactoff];
	int			nxids = MyProc->subxidStatus.count;
	Assert(substat->count == MyProc->subxidStatus.count);
	Assert(substat->overflowed == MyProc->subxidStatus.overflowed);
	if (nxids < PGPROC_MAX_CACHED_SUBXIDS)
	{
		MyProc->subxids.xids[nxids] = xid;
		pg_write_barrier();
		MyProc->subxidStatus.count = substat->count = nxids + 1;
	}
	else
		MyProc->subxidStatus.overflowed = substat->overflowed = true;
}

for (int pgxactoff = 0; pgxactoff < numProcs; pgxactoff++)
{
  ...
  /*
   * Save subtransaction XIDs if possible (if we've already
   * overflowed, there's no point).  Note that the subxact XIDs must
   * be later than their parent, so no need to check them against
   * xmin.  We could filter against xmax, but it seems better not to
   * do that much work while holding the ProcArrayLock.
   *
   * The other backend can add more subxids concurrently, but cannot
   * remove any.  Hence it's important to fetch nxids just once.
   * Should be safe to use memcpy, though.  (We needn't worry about
   * missing any xids added concurrently, because they must postdate
   * xmax.)
   *
   * Again, our own XIDs are not included in the snapshot.
   */
  if (!suboverflowed)
  {

      if (subxidStates[pgxactoff].overflowed)
          suboverflowed = true;
      else
      {
          int			nsubxids = subxidStates[pgxactoff].count;

          if (nsubxids > 0)
          {
              int			pgprocno = pgprocnos[pgxactoff];
              PGPROC	   *proc = &allProcs[pgprocno];

              pg_read_barrier();	/* pairs with GetNewTransactionId */

              memcpy(snapshot->subxip + subcount,
                     proc->subxids.xids,
                     nsubxids * sizeof(TransactionId));
              subcount += nsubxids;
          }
      }
  }
}
...
snapshot->suboverflowed = suboverflowed;

/*
 * If the snapshot contains full subxact data, the fastest way to
 * check things is just to compare the given XID against both subxact
 * XIDs and top-level XIDs.  If the snapshot overflowed, we have to
 * use pg_subtrans to convert a subxact XID to its parent XID, but
 * then we need only look at top-level XIDs not subxacts.
 */
if (!snapshot->suboverflowed)
{
	/* we have full data, so search subxip */
	if (pg_lfind32(xid, snapshot->subxip, snapshot->subxcnt))
		return true;
	/* not there, fall through to search xip[] */
}
else
{
	/*
	 * Snapshot overflowed, so convert xid to top-level.  This is safe
	 * because we eliminated too-old XIDs above.
	 */
	xid = SubTransGetTopmostTransaction(xid);
	/*
	 * If xid was indeed a subxact, we might now have an xid < xmin,
	 * so recheck to avoid an array scan.  No point in rechecking
	 * xmax.
	 */
	if (TransactionIdPrecedes(xid, snapshot->xmin))
		return false;
}
if (pg_lfind32(xid, snapshot->xip, snapshot->xcnt))
	return true;