SLRU

#define SLRU_PAGES_PER_SEGMENT	32

typedef struct SlruSharedData
{
	LWLock	   *ControlLock;

	/* Number of buffers managed by this SLRU structure */
	int			num_slots;

	/*
	 * Arrays holding info for each buffer slot.  Page number is undefined
	 * when status is EMPTY, as is page_lru_count.
	 */
	char	  **page_buffer;
	SlruPageStatus *page_status;
	bool	   *page_dirty;
	int		   *page_number;
	int		   *page_lru_count;
	LWLockPadded *buffer_locks;

    XLogRecPtr *group_lsn;
	int			lsn_groups_per_page;

	/*----------
	 * We mark a page "most recently used" by setting
	 *		page_lru_count[slotno] = ++cur_lru_count;
	 * The oldest page is therefore the one with the highest value of
	 *		cur_lru_count - page_lru_count[slotno]
	 * The counts will eventually wrap around, but this calculation still
	 * works as long as no page's age exceeds INT_MAX counts.
	 *----------
	 */
	int			cur_lru_count;
} SlruSharedData;

page_lru_count[slotno] = ++cur_lru_count;

typedef enum
{
	SLRU_PAGE_EMPTY,			/* buffer is not in use */
	SLRU_PAGE_READ_IN_PROGRESS, /* page is being read in */
	SLRU_PAGE_VALID,			/* page is valid and not being written */
	SLRU_PAGE_WRITE_IN_PROGRESS /* page is being written out */
} SlruPageStatus;

/*
 * SlruCtlData is an unshared structure that points to the active information
 * in shared memory.
 */
typedef struct SlruCtlData
{
	SlruShared	shared;

	/*
	 * Decide whether a page is "older" for truncation and as a hint for
	 * evicting pages in LRU order.  
	 */
	bool		(*PagePrecedes) (int, int);

	/*
	 * Dir is set during SimpleLruInit and does not change thereafter. Since
	 * it's always the same, it doesn't need to be in shared memory.
	 */
	char		Dir[64];
} SlruCtlData;

/* Select the slot to re-use when we need a free slot. */
/* Control lock must be held at entry, and will be held at exit. */
static int
SlruSelectLRUPage(SlruCtl ctl, int pageno)
{
	for (;;)
		# return if we have such a slot
		# return if we have an empty slot "SLRU_PAGE_EMPTY"
		# select a lru slot
			# return it if it's clean. Or
			# victim it if dirty
	# loop end -- It's a very clever design to dealing with corner cases
	#             such as the victim page being re-dirtied while we wrote it.
}

#define SlruRecentlyUsed(shared, slotno)	\
	do { \
		int		new_lru_count = (shared)->cur_lru_count; \
		if (new_lru_count != (shared)->page_lru_count[slotno]) { \
			(shared)->cur_lru_count = ++new_lru_count; \
			(shared)->page_lru_count[slotno] = new_lru_count; \
		} \
	} while (0)

SlruPhysicalReadPage
{
    int	segno = pageno / SLRU_PAGES_PER_SEGMENT;
    SlruFileName(ctl, path, segno);

    /*
     * In a crash-and-restart situation, it's possible for us to receive
     * commands to set the commit status of transactions whose bits are in
     * already-truncated segments of the commit log
     */
    fd = OpenTransientFile(path, O_RDONLY | PG_BINARY);
    if (fd < 0 && !InRecovery) ereport()

    pg_pread(fd, shared->page_buffer[slotno], BLCKSZ, offset)
}

SlruPhysicalWritePage
{
    /* We must flush WAL before flush slru pages */
    if (shared->group_lsn != NULL)
    {
        max_lsn = shared->group_lsn[lsnindex++];
        XLogFlush(max_lsn);
    }

    SlruFileName(ctl, path, segno);
    fd = OpenTransientFile(path, O_RDWR | O_CREAT | PG_BINARY);
    pg_pwrite(fd, shared->page_buffer[slotno], BLCKSZ, offset)
    /* Queue up a sync request for the checkpointer. */
    ...
}

/* Initialize (or reinitialize) a page to zeroes. */
int
SimpleLruZeroPage(SlruCtl ctl, int pageno)
{
	slotno = SlruSelectLRUPage(ctl, pageno);
	SlruRecentlyUsed(shared, slotno);

	# SlruSelectLRUPage may return a in-use page, we must clear it
	MemSet(shared->page_buffer[slotno], 0, BLCKSZ);

	SimpleLruZeroLSNs(ctl, slotno);
}

/* Control lock must be held at entry, and will be held at exit. */
SimpleLruReadPage
{
    #infinite loop
        slotno = SlruSelectLRUPage(ctl, pageno);
        # for in IO slots, just wait
        /* update in-memory status */
        shared->page_number[slotno] = pageno;
        shared->page_status[slotno] = SLRU_PAGE_READ_IN_PROGRESS;
        shared->page_dirty[slotno] = false;

        /* Acquire per-buffer lock and release control lock */
        LWLockAcquire(&shared->buffer_locks[slotno].lock, LW_EXCLUSIVE);
        LWLockRelease(shared->ControlLock);

        ok = SlruPhysicalReadPage(ctl, pageno, slotno);

        /* re-acquire control lock */
        LWLockAcquire(shared->ControlLock, LW_EXCLUSIVE);
        # others
}

/* Control lock must be held at entry, and will be held at exit. */
SimpleLruZeroPage
{
    slotno = SlruSelectLRUPage(ctl, pageno);
    shared->page_number[slotno] = pageno;
    shared->page_status[slotno] = SLRU_PAGE_VALID;
    shared->page_dirty[slotno] = true;
}

/* Control lock must be held at entry, and will be held at exit. */
SlruInternalWritePage
{
    /* If a write is in progress, wait for it to finish */
    /* Do nothing if page is not dirty */

    /* update in-memory status */
    shared->page_status[slotno] = SLRU_PAGE_WRITE_IN_PROGRESS;
    shared->page_dirty[slotno] = false;

    /* Acquire per-buffer lock and release control lock */
    LWLockAcquire(&shared->buffer_locks[slotno].lock, LW_EXCLUSIVE);
    LWLockRelease(shared->ControlLock);

    SlruPhysicalWritePage(ctl, pageno, slotno, fdata);

    /* re-acquire control lock */
    LWLockAcquire(shared->ControlLock, LW_EXCLUSIVE);

    shared->page_status[slotno] = SLRU_PAGE_VALID;
}