slru.h File Reference

#include "access/xlogdefs.h"
#include "storage/lwlock.h"
#include "storage/sync.h"

Include dependency graph for slru.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	SlruSharedData
struct	SlruCtlData

Macros
#define	SLRU_MAX_ALLOWED_BUFFERS   ((1024 * 1024 * 1024) / BLCKSZ)
#define	SlruPagePrecedesUnitTests(ctl, per_page)   do {} while (0)

Typedefs
typedef struct SlruSharedData	SlruSharedData
typedef SlruSharedData *	SlruShared
typedef struct SlruCtlData	SlruCtlData
typedef SlruCtlData *	SlruCtl
typedef bool(*	SlruScanCallback) (SlruCtl ctl, char *filename, int64 segpage, void *data)

Enumerations
enum	SlruPageStatus { SLRU_PAGE_EMPTY , SLRU_PAGE_READ_IN_PROGRESS , SLRU_PAGE_VALID , SLRU_PAGE_WRITE_IN_PROGRESS }

Functions
static LWLock *	SimpleLruGetBankLock (SlruCtl ctl, int64 pageno)
Size	SimpleLruShmemSize (int nslots, int nlsns)
int	SimpleLruAutotuneBuffers (int divisor, int max)
void	SimpleLruInit (SlruCtl ctl, const char *name, int nslots, int nlsns, const char *subdir, int buffer_tranche_id, int bank_tranche_id, SyncRequestHandler sync_handler, bool long_segment_names)
int	SimpleLruZeroPage (SlruCtl ctl, int64 pageno)
void	SimpleLruZeroAndWritePage (SlruCtl ctl, int64 pageno)
int	SimpleLruReadPage (SlruCtl ctl, int64 pageno, bool write_ok, TransactionId xid)
int	SimpleLruReadPage_ReadOnly (SlruCtl ctl, int64 pageno, TransactionId xid)
void	SimpleLruWritePage (SlruCtl ctl, int slotno)
void	SimpleLruWriteAll (SlruCtl ctl, bool allow_redirtied)
void	SimpleLruTruncate (SlruCtl ctl, int64 cutoffPage)
bool	SimpleLruDoesPhysicalPageExist (SlruCtl ctl, int64 pageno)
bool	SlruScanDirectory (SlruCtl ctl, SlruScanCallback callback, void *data)
void	SlruDeleteSegment (SlruCtl ctl, int64 segno)
int	SlruSyncFileTag (SlruCtl ctl, const FileTag *ftag, char *path)
bool	SlruScanDirCbReportPresence (SlruCtl ctl, char *filename, int64 segpage, void *data)
bool	SlruScanDirCbDeleteAll (SlruCtl ctl, char *filename, int64 segpage, void *data)
bool	check_slru_buffers (const char *name, int *newval)

Macro Definition Documentation

SLRU_MAX_ALLOWED_BUFFERS

#define SLRU_MAX_ALLOWED_BUFFERS   ((1024 * 1024 * 1024) / BLCKSZ)

Definition at line 24 of file slru.h.

SlruPagePrecedesUnitTests

#define SlruPagePrecedesUnitTests	(		ctl,
			per_page
	)		do {} while (0)

Definition at line 185 of file slru.h.

Typedef Documentation

SlruCtl

typedef SlruCtlData* SlruCtl

Definition at line 151 of file slru.h.

SlruCtlData

typedef struct SlruCtlData SlruCtlData

SlruScanCallback

typedef bool(* SlruScanCallback) (SlruCtl ctl, char *filename, int64 segpage, void *data)

Definition at line 190 of file slru.h.

SlruShared

typedef SlruSharedData* SlruShared

Definition at line 106 of file slru.h.

SlruSharedData

typedef struct SlruSharedData SlruSharedData

Enumeration Type Documentation

SlruPageStatus

enum SlruPageStatus

Enumerator
SLRU_PAGE_EMPTY
SLRU_PAGE_READ_IN_PROGRESS
SLRU_PAGE_VALID
SLRU_PAGE_WRITE_IN_PROGRESS

Definition at line 32 of file slru.h.

{
    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;

Function Documentation

check_slru_buffers()

bool check_slru_buffers	(	const char *	name,
		int *	newval
	)

Definition at line 355 of file slru.c.

{
    /* Valid values are multiples of SLRU_BANK_SIZE */
    if (*newval % SLRU_BANK_SIZE == 0)
        return true;
 
    GUC_check_errdetail("\"%s\" must be a multiple of %d.", name,
                        SLRU_BANK_SIZE);
    return false;
}

References GUC_check_errdetail, name, newval, and SLRU_BANK_SIZE.

Referenced by check_commit_ts_buffers(), check_multixact_member_buffers(), check_multixact_offset_buffers(), check_notify_buffers(), check_serial_buffers(), check_subtrans_buffers(), and check_transaction_buffers().

SimpleLruAutotuneBuffers()

int SimpleLruAutotuneBuffers	(	int	divisor,
		int	max
	)

Definition at line 231 of file slru.c.

{
    return Min(max - (max % SLRU_BANK_SIZE),
               Max(SLRU_BANK_SIZE,
                   NBuffers / divisor - (NBuffers / divisor) % SLRU_BANK_SIZE));
}

References Max, Min, NBuffers, and SLRU_BANK_SIZE.

Referenced by CLOGShmemBuffers(), CommitTsShmemBuffers(), and SUBTRANSShmemBuffers().

SimpleLruDoesPhysicalPageExist()

bool SimpleLruDoesPhysicalPageExist	(	SlruCtl	ctl,
		int64	pageno
	)

Definition at line 771 of file slru.c.

{
    int64       segno = pageno / SLRU_PAGES_PER_SEGMENT;
    int         rpageno = pageno % SLRU_PAGES_PER_SEGMENT;
    int         offset = rpageno * BLCKSZ;
    char        path[MAXPGPATH];
    int         fd;
    bool        result;
    off_t       endpos;
 
    /* update the stats counter of checked pages */
    pgstat_count_slru_blocks_exists(ctl->shared->slru_stats_idx);
 
    SlruFileName(ctl, path, segno);
 
    fd = OpenTransientFile(path, O_RDONLY | PG_BINARY);
    if (fd < 0)
    {
        /* expected: file doesn't exist */
        if (errno == ENOENT)
            return false;
 
        /* report error normally */
        slru_errcause = SLRU_OPEN_FAILED;
        slru_errno = errno;
        SlruReportIOError(ctl, pageno, 0);
    }
 
    if ((endpos = lseek(fd, 0, SEEK_END)) < 0)
    {
        slru_errcause = SLRU_SEEK_FAILED;
        slru_errno = errno;
        SlruReportIOError(ctl, pageno, 0);
    }
 
    result = endpos >= (off_t) (offset + BLCKSZ);
 
    if (CloseTransientFile(fd) != 0)
    {
        slru_errcause = SLRU_CLOSE_FAILED;
        slru_errno = errno;
        return false;
    }
 
    return result;
}

References CloseTransientFile(), ctl, endpos, fd(), MAXPGPATH, OpenTransientFile(), PG_BINARY, pgstat_count_slru_blocks_exists(), SlruWriteAllData::segno, SLRU_CLOSE_FAILED, slru_errcause, slru_errno, SLRU_OPEN_FAILED, SLRU_PAGES_PER_SEGMENT, SLRU_SEEK_FAILED, SlruFileName(), and SlruReportIOError().

Referenced by ActivateCommitTs(), find_multixact_start(), MaybeExtendOffsetSlru(), and test_slru_page_exists().

SimpleLruGetBankLock()

static LWLock * SimpleLruGetBankLock ( SlruCtl  ctl, int64  pageno  )

inlinestatic

Definition at line 160 of file slru.h.

{
    int         bankno;
 
    bankno = pageno % ctl->nbanks;
    return &(ctl->shared->bank_locks[bankno].lock);
}

References ctl.

Referenced by AsyncNotifyFreezeXids(), asyncQueueAddEntries(), asyncQueueProcessPageEntries(), ExtendCLOG(), ExtendCommitTs(), ExtendMultiXactMember(), ExtendMultiXactOffset(), ExtendSUBTRANS(), find_multixact_start(), GetMultiXactIdMembers(), MaybeExtendOffsetSlru(), RecordNewMultiXact(), SerialAdd(), SerialGetMinConflictCommitSeqNo(), SetXidCommitTsInPage(), SimpleLruReadPage(), SimpleLruReadPage_ReadOnly(), SimpleLruZeroAndWritePage(), SimpleLruZeroPage(), SlruInternalWritePage(), SlruSelectLRUPage(), StartupSUBTRANS(), SubTransGetParent(), SubTransSetParent(), test_slru_page_exists(), test_slru_page_read(), test_slru_page_readonly(), test_slru_page_write(), TransactionGroupUpdateXidStatus(), TransactionIdGetCommitTsData(), TransactionIdGetStatus(), TransactionIdSetPageStatus(), TransactionIdSetPageStatusInternal(), TransactionIdSetStatusBit(), TrimCLOG(), and TrimMultiXact().

SimpleLruInit()

void SimpleLruInit	(	SlruCtl	ctl,
		const char *	name,
		int	nslots,
		int	nlsns,
		const char *	subdir,
		int	buffer_tranche_id,
		int	bank_tranche_id,
		SyncRequestHandler	sync_handler,
		bool	long_segment_names
	)

Definition at line 252 of file slru.c.

{
    SlruShared  shared;
    bool        found;
    int         nbanks = nslots / SLRU_BANK_SIZE;
 
    Assert(nslots <= SLRU_MAX_ALLOWED_BUFFERS);
 
    shared = (SlruShared) ShmemInitStruct(name,
                                          SimpleLruShmemSize(nslots, nlsns),
                                          &found);
 
    if (!IsUnderPostmaster)
    {
        /* Initialize locks and shared memory area */
        char       *ptr;
        Size        offset;
 
        Assert(!found);
 
        memset(shared, 0, sizeof(SlruSharedData));
 
        shared->num_slots = nslots;
        shared->lsn_groups_per_page = nlsns;
 
        pg_atomic_init_u64(&shared->latest_page_number, 0);
 
        shared->slru_stats_idx = pgstat_get_slru_index(name);
 
        ptr = (char *) shared;
        offset = MAXALIGN(sizeof(SlruSharedData));
        shared->page_buffer = (char **) (ptr + offset);
        offset += MAXALIGN(nslots * sizeof(char *));
        shared->page_status = (SlruPageStatus *) (ptr + offset);
        offset += MAXALIGN(nslots * sizeof(SlruPageStatus));
        shared->page_dirty = (bool *) (ptr + offset);
        offset += MAXALIGN(nslots * sizeof(bool));
        shared->page_number = (int64 *) (ptr + offset);
        offset += MAXALIGN(nslots * sizeof(int64));
        shared->page_lru_count = (int *) (ptr + offset);
        offset += MAXALIGN(nslots * sizeof(int));
 
        /* Initialize LWLocks */
        shared->buffer_locks = (LWLockPadded *) (ptr + offset);
        offset += MAXALIGN(nslots * sizeof(LWLockPadded));
        shared->bank_locks = (LWLockPadded *) (ptr + offset);
        offset += MAXALIGN(nbanks * sizeof(LWLockPadded));
        shared->bank_cur_lru_count = (int *) (ptr + offset);
        offset += MAXALIGN(nbanks * sizeof(int));
 
        if (nlsns > 0)
        {
            shared->group_lsn = (XLogRecPtr *) (ptr + offset);
            offset += MAXALIGN(nslots * nlsns * sizeof(XLogRecPtr));
        }
 
        ptr += BUFFERALIGN(offset);
        for (int slotno = 0; slotno < nslots; slotno++)
        {
            LWLockInitialize(&shared->buffer_locks[slotno].lock,
                             buffer_tranche_id);
 
            shared->page_buffer[slotno] = ptr;
            shared->page_status[slotno] = SLRU_PAGE_EMPTY;
            shared->page_dirty[slotno] = false;
            shared->page_lru_count[slotno] = 0;
            ptr += BLCKSZ;
        }
 
        /* Initialize the slot banks. */
        for (int bankno = 0; bankno < nbanks; bankno++)
        {
            LWLockInitialize(&shared->bank_locks[bankno].lock, bank_tranche_id);
            shared->bank_cur_lru_count[bankno] = 0;
        }
 
        /* Should fit to estimated shmem size */
        Assert(ptr - (char *) shared <= SimpleLruShmemSize(nslots, nlsns));
    }
    else
    {
        Assert(found);
        Assert(shared->num_slots == nslots);
    }
 
    /*
     * Initialize the unshared control struct, including directory path. We
     * assume caller set PagePrecedes.
     */
    ctl->shared = shared;
    ctl->sync_handler = sync_handler;
    ctl->long_segment_names = long_segment_names;
    ctl->nbanks = nbanks;
    strlcpy(ctl->Dir, subdir, sizeof(ctl->Dir));
}

References Assert(), SlruSharedData::bank_cur_lru_count, SlruSharedData::bank_locks, SlruSharedData::buffer_locks, BUFFERALIGN, ctl, SlruSharedData::group_lsn, IsUnderPostmaster, SlruSharedData::latest_page_number, LWLockPadded::lock, SlruSharedData::lsn_groups_per_page, LWLockInitialize(), MAXALIGN, name, SlruSharedData::num_slots, SlruSharedData::page_buffer, SlruSharedData::page_dirty, SlruSharedData::page_lru_count, SlruSharedData::page_number, SlruSharedData::page_status, pg_atomic_init_u64(), pgstat_get_slru_index(), ShmemInitStruct(), SimpleLruShmemSize(), SLRU_BANK_SIZE, SLRU_MAX_ALLOWED_BUFFERS, SLRU_PAGE_EMPTY, SlruSharedData::slru_stats_idx, and strlcpy().

Referenced by AsyncShmemInit(), CLOGShmemInit(), CommitTsShmemInit(), MultiXactShmemInit(), SerialInit(), SUBTRANSShmemInit(), and test_slru_shmem_startup().

SimpleLruReadPage()

int SimpleLruReadPage	(	SlruCtl	ctl,
		int64	pageno,
		bool	write_ok,
		TransactionId	xid
	)

Definition at line 527 of file slru.c.

{
    SlruShared  shared = ctl->shared;
    LWLock     *banklock = SimpleLruGetBankLock(ctl, pageno);
 
    Assert(LWLockHeldByMeInMode(banklock, LW_EXCLUSIVE));
 
    /* Outer loop handles restart if we must wait for someone else's I/O */
    for (;;)
    {
        int         slotno;
        bool        ok;
 
        /* See if page already is in memory; if not, pick victim slot */
        slotno = SlruSelectLRUPage(ctl, pageno);
 
        /* Did we find the page in memory? */
        if (shared->page_status[slotno] != SLRU_PAGE_EMPTY &&
            shared->page_number[slotno] == pageno)
        {
            /*
             * If page is still being read in, we must wait for I/O.  Likewise
             * if the page is being written and the caller said that's not OK.
             */
            if (shared->page_status[slotno] == SLRU_PAGE_READ_IN_PROGRESS ||
                (shared->page_status[slotno] == SLRU_PAGE_WRITE_IN_PROGRESS &&
                 !write_ok))
            {
                SimpleLruWaitIO(ctl, slotno);
                /* Now we must recheck state from the top */
                continue;
            }
            /* Otherwise, it's ready to use */
            SlruRecentlyUsed(shared, slotno);
 
            /* update the stats counter of pages found in the SLRU */
            pgstat_count_slru_blocks_hit(shared->slru_stats_idx);
 
            return slotno;
        }
 
        /* We found no match; assert we selected a freeable slot */
        Assert(shared->page_status[slotno] == SLRU_PAGE_EMPTY ||
               (shared->page_status[slotno] == SLRU_PAGE_VALID &&
                !shared->page_dirty[slotno]));
 
        /* Mark the slot read-busy */
        shared->page_number[slotno] = pageno;
        shared->page_status[slotno] = SLRU_PAGE_READ_IN_PROGRESS;
        shared->page_dirty[slotno] = false;
 
        /* Acquire per-buffer lock (cannot deadlock, see notes at top) */
        LWLockAcquire(&shared->buffer_locks[slotno].lock, LW_EXCLUSIVE);
 
        /* Release bank lock while doing I/O */
        LWLockRelease(banklock);
 
        /* Do the read */
        ok = SlruPhysicalReadPage(ctl, pageno, slotno);
 
        /* Set the LSNs for this newly read-in page to zero */
        SimpleLruZeroLSNs(ctl, slotno);
 
        /* Re-acquire bank control lock and update page state */
        LWLockAcquire(banklock, LW_EXCLUSIVE);
 
        Assert(shared->page_number[slotno] == pageno &&
               shared->page_status[slotno] == SLRU_PAGE_READ_IN_PROGRESS &&
               !shared->page_dirty[slotno]);
 
        shared->page_status[slotno] = ok ? SLRU_PAGE_VALID : SLRU_PAGE_EMPTY;
 
        LWLockRelease(&shared->buffer_locks[slotno].lock);
 
        /* Now it's okay to ereport if we failed */
        if (!ok)
            SlruReportIOError(ctl, pageno, xid);
 
        SlruRecentlyUsed(shared, slotno);
 
        /* update the stats counter of pages not found in SLRU */
        pgstat_count_slru_blocks_read(shared->slru_stats_idx);
 
        return slotno;
    }
}

References Assert(), SlruSharedData::buffer_locks, ctl, LWLockPadded::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockHeldByMeInMode(), LWLockRelease(), SlruSharedData::page_dirty, SlruSharedData::page_number, SlruSharedData::page_status, pgstat_count_slru_blocks_hit(), pgstat_count_slru_blocks_read(), SimpleLruGetBankLock(), SimpleLruWaitIO(), SimpleLruZeroLSNs(), SLRU_PAGE_EMPTY, SLRU_PAGE_READ_IN_PROGRESS, SLRU_PAGE_VALID, SLRU_PAGE_WRITE_IN_PROGRESS, SlruSharedData::slru_stats_idx, SlruPhysicalReadPage(), SlruRecentlyUsed(), SlruReportIOError(), and SlruSelectLRUPage().

Referenced by AsyncNotifyFreezeXids(), asyncQueueAddEntries(), GetMultiXactIdMembers(), RecordNewMultiXact(), SerialAdd(), SetXidCommitTsInPage(), SimpleLruReadPage_ReadOnly(), SubTransSetParent(), test_slru_page_read(), TransactionIdSetPageStatusInternal(), TrimCLOG(), and TrimMultiXact().

SimpleLruReadPage_ReadOnly()

int SimpleLruReadPage_ReadOnly	(	SlruCtl	ctl,
		int64	pageno,
		TransactionId	xid
	)

Definition at line 630 of file slru.c.

{
    SlruShared  shared = ctl->shared;
    LWLock     *banklock = SimpleLruGetBankLock(ctl, pageno);
    int         bankno = pageno % ctl->nbanks;
    int         bankstart = bankno * SLRU_BANK_SIZE;
    int         bankend = bankstart + SLRU_BANK_SIZE;
 
    /* Try to find the page while holding only shared lock */
    LWLockAcquire(banklock, LW_SHARED);
 
    /* See if page is already in a buffer */
    for (int slotno = bankstart; slotno < bankend; slotno++)
    {
        if (shared->page_status[slotno] != SLRU_PAGE_EMPTY &&
            shared->page_number[slotno] == pageno &&
            shared->page_status[slotno] != SLRU_PAGE_READ_IN_PROGRESS)
        {
            /* See comments for SlruRecentlyUsed() */
            SlruRecentlyUsed(shared, slotno);
 
            /* update the stats counter of pages found in the SLRU */
            pgstat_count_slru_blocks_hit(shared->slru_stats_idx);
 
            return slotno;
        }
    }
 
    /* No luck, so switch to normal exclusive lock and do regular read */
    LWLockRelease(banklock);
    LWLockAcquire(banklock, LW_EXCLUSIVE);
 
    return SimpleLruReadPage(ctl, pageno, true, xid);
}

References ctl, LW_EXCLUSIVE, LW_SHARED, LWLockAcquire(), LWLockRelease(), SlruSharedData::page_number, SlruSharedData::page_status, pgstat_count_slru_blocks_hit(), SimpleLruGetBankLock(), SimpleLruReadPage(), SLRU_BANK_SIZE, SLRU_PAGE_EMPTY, SLRU_PAGE_READ_IN_PROGRESS, SlruSharedData::slru_stats_idx, and SlruRecentlyUsed().

Referenced by asyncQueueProcessPageEntries(), find_multixact_start(), SerialGetMinConflictCommitSeqNo(), SubTransGetParent(), test_slru_page_readonly(), TransactionIdGetCommitTsData(), and TransactionIdGetStatus().

SimpleLruShmemSize()

Size SimpleLruShmemSize	(	int	nslots,
		int	nlsns
	)

Definition at line 198 of file slru.c.

{
    int         nbanks = nslots / SLRU_BANK_SIZE;
    Size        sz;
 
    Assert(nslots <= SLRU_MAX_ALLOWED_BUFFERS);
    Assert(nslots % SLRU_BANK_SIZE == 0);
 
    /* we assume nslots isn't so large as to risk overflow */
    sz = MAXALIGN(sizeof(SlruSharedData));
    sz += MAXALIGN(nslots * sizeof(char *));    /* page_buffer[] */
    sz += MAXALIGN(nslots * sizeof(SlruPageStatus));    /* page_status[] */
    sz += MAXALIGN(nslots * sizeof(bool));  /* page_dirty[] */
    sz += MAXALIGN(nslots * sizeof(int64)); /* page_number[] */
    sz += MAXALIGN(nslots * sizeof(int));   /* page_lru_count[] */
    sz += MAXALIGN(nslots * sizeof(LWLockPadded));  /* buffer_locks[] */
    sz += MAXALIGN(nbanks * sizeof(LWLockPadded));  /* bank_locks[] */
    sz += MAXALIGN(nbanks * sizeof(int));   /* bank_cur_lru_count[] */
 
    if (nlsns > 0)
        sz += MAXALIGN(nslots * nlsns * sizeof(XLogRecPtr));    /* group_lsn[] */
 
    return BUFFERALIGN(sz) + BLCKSZ * nslots;
}

References Assert(), BUFFERALIGN, MAXALIGN, SLRU_BANK_SIZE, and SLRU_MAX_ALLOWED_BUFFERS.

Referenced by AsyncShmemSize(), CLOGShmemSize(), CommitTsShmemSize(), MultiXactShmemSize(), PredicateLockShmemSize(), SimpleLruInit(), SUBTRANSShmemSize(), and test_slru_shmem_request().

SimpleLruTruncate()

void SimpleLruTruncate	(	SlruCtl	ctl,
		int64	cutoffPage
	)

Definition at line 1433 of file slru.c.

{
    SlruShared  shared = ctl->shared;
    int         prevbank;
 
    /* update the stats counter of truncates */
    pgstat_count_slru_truncate(shared->slru_stats_idx);
 
    /*
     * Scan shared memory and remove any pages preceding the cutoff page, to
     * ensure we won't rewrite them later.  (Since this is normally called in
     * or just after a checkpoint, any dirty pages should have been flushed
     * already ... we're just being extra careful here.)
     */
restart:
 
    /*
     * An important safety check: the current endpoint page must not be
     * eligible for removal.  This check is just a backstop against wraparound
     * bugs elsewhere in SLRU handling, so we don't care if we read a slightly
     * outdated value; therefore we don't add a memory barrier.
     */
    if (ctl->PagePrecedes(pg_atomic_read_u64(&shared->latest_page_number),
                          cutoffPage))
    {
        ereport(LOG,
                (errmsg("could not truncate directory \"%s\": apparent wraparound",
                        ctl->Dir)));
        return;
    }
 
    prevbank = SlotGetBankNumber(0);
    LWLockAcquire(&shared->bank_locks[prevbank].lock, LW_EXCLUSIVE);
    for (int slotno = 0; slotno < shared->num_slots; slotno++)
    {
        int         curbank = SlotGetBankNumber(slotno);
 
        /*
         * If the current bank lock is not same as the previous bank lock then
         * release the previous lock and acquire the new lock.
         */
        if (curbank != prevbank)
        {
            LWLockRelease(&shared->bank_locks[prevbank].lock);
            LWLockAcquire(&shared->bank_locks[curbank].lock, LW_EXCLUSIVE);
            prevbank = curbank;
        }
 
        if (shared->page_status[slotno] == SLRU_PAGE_EMPTY)
            continue;
        if (!ctl->PagePrecedes(shared->page_number[slotno], cutoffPage))
            continue;
 
        /*
         * If page is clean, just change state to EMPTY (expected case).
         */
        if (shared->page_status[slotno] == SLRU_PAGE_VALID &&
            !shared->page_dirty[slotno])
        {
            shared->page_status[slotno] = SLRU_PAGE_EMPTY;
            continue;
        }
 
        /*
         * Hmm, we have (or may have) I/O operations acting on the page, so
         * we've got to wait for them to finish and then start again. This is
         * the same logic as in SlruSelectLRUPage.  (XXX if page is dirty,
         * wouldn't it be OK to just discard it without writing it?
         * SlruMayDeleteSegment() uses a stricter qualification, so we might
         * not delete this page in the end; even if we don't delete it, we
         * won't have cause to read its data again.  For now, keep the logic
         * the same as it was.)
         */
        if (shared->page_status[slotno] == SLRU_PAGE_VALID)
            SlruInternalWritePage(ctl, slotno, NULL);
        else
            SimpleLruWaitIO(ctl, slotno);
 
        LWLockRelease(&shared->bank_locks[prevbank].lock);
        goto restart;
    }
 
    LWLockRelease(&shared->bank_locks[prevbank].lock);
 
    /* Now we can remove the old segment(s) */
    (void) SlruScanDirectory(ctl, SlruScanDirCbDeleteCutoff, &cutoffPage);
}

References SlruSharedData::bank_locks, ctl, ereport, errmsg(), SlruSharedData::latest_page_number, LWLockPadded::lock, LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SlruSharedData::num_slots, SlruSharedData::page_dirty, SlruSharedData::page_number, SlruSharedData::page_status, pg_atomic_read_u64(), pgstat_count_slru_truncate(), SimpleLruWaitIO(), SlotGetBankNumber, SLRU_PAGE_EMPTY, SLRU_PAGE_VALID, SlruSharedData::slru_stats_idx, SlruInternalWritePage(), SlruScanDirCbDeleteCutoff(), and SlruScanDirectory().

Referenced by asyncQueueAdvanceTail(), CheckPointPredicate(), clog_redo(), commit_ts_redo(), PerformOffsetsTruncation(), test_slru_page_truncate(), TruncateCLOG(), TruncateCommitTs(), and TruncateSUBTRANS().

SimpleLruWriteAll()

void SimpleLruWriteAll	(	SlruCtl	ctl,
		bool	allow_redirtied
	)

Definition at line 1347 of file slru.c.

{
    SlruShared  shared = ctl->shared;
    SlruWriteAllData fdata;
    int64       pageno = 0;
    int         prevbank = SlotGetBankNumber(0);
    bool        ok;
 
    /* update the stats counter of flushes */
    pgstat_count_slru_flush(shared->slru_stats_idx);
 
    /*
     * Find and write dirty pages
     */
    fdata.num_files = 0;
 
    LWLockAcquire(&shared->bank_locks[prevbank].lock, LW_EXCLUSIVE);
 
    for (int slotno = 0; slotno < shared->num_slots; slotno++)
    {
        int         curbank = SlotGetBankNumber(slotno);
 
        /*
         * If the current bank lock is not same as the previous bank lock then
         * release the previous lock and acquire the new lock.
         */
        if (curbank != prevbank)
        {
            LWLockRelease(&shared->bank_locks[prevbank].lock);
            LWLockAcquire(&shared->bank_locks[curbank].lock, LW_EXCLUSIVE);
            prevbank = curbank;
        }
 
        /* Do nothing if slot is unused */
        if (shared->page_status[slotno] == SLRU_PAGE_EMPTY)
            continue;
 
        SlruInternalWritePage(ctl, slotno, &fdata);
 
        /*
         * In some places (e.g. checkpoints), we cannot assert that the slot
         * is clean now, since another process might have re-dirtied it
         * already.  That's okay.
         */
        Assert(allow_redirtied ||
               shared->page_status[slotno] == SLRU_PAGE_EMPTY ||
               (shared->page_status[slotno] == SLRU_PAGE_VALID &&
                !shared->page_dirty[slotno]));
    }
 
    LWLockRelease(&shared->bank_locks[prevbank].lock);
 
    /*
     * Now close any files that were open
     */
    ok = true;
    for (int i = 0; i < fdata.num_files; i++)
    {
        if (CloseTransientFile(fdata.fd[i]) != 0)
        {
            slru_errcause = SLRU_CLOSE_FAILED;
            slru_errno = errno;
            pageno = fdata.segno[i] * SLRU_PAGES_PER_SEGMENT;
            ok = false;
        }
    }
    if (!ok)
        SlruReportIOError(ctl, pageno, InvalidTransactionId);
 
    /* Ensure that directory entries for new files are on disk. */
    if (ctl->sync_handler != SYNC_HANDLER_NONE)
        fsync_fname(ctl->Dir, true);
}

References Assert(), SlruSharedData::bank_locks, CloseTransientFile(), ctl, SlruWriteAllData::fd, fsync_fname(), i, InvalidTransactionId, LWLockPadded::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SlruWriteAllData::num_files, SlruSharedData::num_slots, SlruSharedData::page_dirty, SlruSharedData::page_status, pgstat_count_slru_flush(), SlruWriteAllData::segno, SlotGetBankNumber, SLRU_CLOSE_FAILED, slru_errcause, slru_errno, SLRU_PAGE_EMPTY, SLRU_PAGE_VALID, SLRU_PAGES_PER_SEGMENT, SlruSharedData::slru_stats_idx, SlruInternalWritePage(), SlruReportIOError(), and SYNC_HANDLER_NONE.

Referenced by CheckPointCLOG(), CheckPointCommitTs(), CheckPointMultiXact(), CheckPointPredicate(), CheckPointSUBTRANS(), find_multixact_start(), and test_slru_page_writeall().

SimpleLruWritePage()

void SimpleLruWritePage	(	SlruCtl	ctl,
		int	slotno
	)

Definition at line 757 of file slru.c.

{
    Assert(ctl->shared->page_status[slotno] != SLRU_PAGE_EMPTY);
 
    SlruInternalWritePage(ctl, slotno, NULL);
}

References Assert(), ctl, SLRU_PAGE_EMPTY, and SlruInternalWritePage().

Referenced by MaybeExtendOffsetSlru(), SimpleLruZeroAndWritePage(), and test_slru_page_write().

SimpleLruZeroAndWritePage()

void SimpleLruZeroAndWritePage	(	SlruCtl	ctl,
		int64	pageno
	)

Definition at line 444 of file slru.c.

{
    int         slotno;
    LWLock     *lock;
 
    lock = SimpleLruGetBankLock(ctl, pageno);
    LWLockAcquire(lock, LW_EXCLUSIVE);
 
    /* Create and zero the page */
    slotno = SimpleLruZeroPage(ctl, pageno);
 
    /* Make sure it's written out */
    SimpleLruWritePage(ctl, slotno);
    Assert(!ctl->shared->page_dirty[slotno]);
 
    LWLockRelease(lock);
}

References Assert(), ctl, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SimpleLruGetBankLock(), SimpleLruWritePage(), and SimpleLruZeroPage().

Referenced by ActivateCommitTs(), BootStrapCLOG(), BootStrapMultiXact(), BootStrapSUBTRANS(), clog_redo(), commit_ts_redo(), and multixact_redo().

SimpleLruZeroPage()

int SimpleLruZeroPage	(	SlruCtl	ctl,
		int64	pageno
	)

Definition at line 375 of file slru.c.

{
    SlruShared  shared = ctl->shared;
    int         slotno;
 
    Assert(LWLockHeldByMeInMode(SimpleLruGetBankLock(ctl, pageno), LW_EXCLUSIVE));
 
    /* Find a suitable buffer slot for the page */
    slotno = SlruSelectLRUPage(ctl, pageno);
    Assert(shared->page_status[slotno] == SLRU_PAGE_EMPTY ||
           (shared->page_status[slotno] == SLRU_PAGE_VALID &&
            !shared->page_dirty[slotno]) ||
           shared->page_number[slotno] == pageno);
 
    /* Mark the slot as containing this page */
    shared->page_number[slotno] = pageno;
    shared->page_status[slotno] = SLRU_PAGE_VALID;
    shared->page_dirty[slotno] = true;
    SlruRecentlyUsed(shared, slotno);
 
    /* Set the buffer to zeroes */
    MemSet(shared->page_buffer[slotno], 0, BLCKSZ);
 
    /* Set the LSNs for this new page to zero */
    SimpleLruZeroLSNs(ctl, slotno);
 
    /*
     * Assume this page is now the latest active page.
     *
     * Note that because both this routine and SlruSelectLRUPage run with a
     * SLRU bank lock held, it is not possible for this to be zeroing a page
     * that SlruSelectLRUPage is going to evict simultaneously.  Therefore,
     * there's no memory barrier here.
     */
    pg_atomic_write_u64(&shared->latest_page_number, pageno);
 
    /* update the stats counter of zeroed pages */
    pgstat_count_slru_blocks_zeroed(shared->slru_stats_idx);
 
    return slotno;
}

References Assert(), ctl, SlruSharedData::latest_page_number, LW_EXCLUSIVE, LWLockHeldByMeInMode(), MemSet, SlruSharedData::page_buffer, SlruSharedData::page_dirty, SlruSharedData::page_number, SlruSharedData::page_status, pg_atomic_write_u64(), pgstat_count_slru_blocks_zeroed(), SimpleLruGetBankLock(), SimpleLruZeroLSNs(), SLRU_PAGE_EMPTY, SLRU_PAGE_VALID, SlruSharedData::slru_stats_idx, SlruRecentlyUsed(), and SlruSelectLRUPage().

Referenced by asyncQueueAddEntries(), ExtendCLOG(), ExtendCommitTs(), ExtendMultiXactMember(), ExtendMultiXactOffset(), ExtendSUBTRANS(), MaybeExtendOffsetSlru(), SerialAdd(), SimpleLruZeroAndWritePage(), StartupSUBTRANS(), test_slru_page_write(), and TrimMultiXact().

SlruDeleteSegment()

void SlruDeleteSegment	(	SlruCtl	ctl,
		int64	segno
	)

Definition at line 1551 of file slru.c.

{
    SlruShared  shared = ctl->shared;
    int         prevbank = SlotGetBankNumber(0);
    bool        did_write;
 
    /* Clean out any possibly existing references to the segment. */
    LWLockAcquire(&shared->bank_locks[prevbank].lock, LW_EXCLUSIVE);
restart:
    did_write = false;
    for (int slotno = 0; slotno < shared->num_slots; slotno++)
    {
        int64       pagesegno;
        int         curbank = SlotGetBankNumber(slotno);
 
        /*
         * If the current bank lock is not same as the previous bank lock then
         * release the previous lock and acquire the new lock.
         */
        if (curbank != prevbank)
        {
            LWLockRelease(&shared->bank_locks[prevbank].lock);
            LWLockAcquire(&shared->bank_locks[curbank].lock, LW_EXCLUSIVE);
            prevbank = curbank;
        }
 
        if (shared->page_status[slotno] == SLRU_PAGE_EMPTY)
            continue;
 
        pagesegno = shared->page_number[slotno] / SLRU_PAGES_PER_SEGMENT;
        /* not the segment we're looking for */
        if (pagesegno != segno)
            continue;
 
        /* If page is clean, just change state to EMPTY (expected case). */
        if (shared->page_status[slotno] == SLRU_PAGE_VALID &&
            !shared->page_dirty[slotno])
        {
            shared->page_status[slotno] = SLRU_PAGE_EMPTY;
            continue;
        }
 
        /* Same logic as SimpleLruTruncate() */
        if (shared->page_status[slotno] == SLRU_PAGE_VALID)
            SlruInternalWritePage(ctl, slotno, NULL);
        else
            SimpleLruWaitIO(ctl, slotno);
 
        did_write = true;
    }
 
    /*
     * Be extra careful and re-check. The IO functions release the control
     * lock, so new pages could have been read in.
     */
    if (did_write)
        goto restart;
 
    SlruInternalDeleteSegment(ctl, segno);
 
    LWLockRelease(&shared->bank_locks[prevbank].lock);
}

References SlruSharedData::bank_locks, ctl, LWLockPadded::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SlruSharedData::num_slots, SlruSharedData::page_dirty, SlruSharedData::page_number, SlruSharedData::page_status, SlruWriteAllData::segno, SimpleLruWaitIO(), SlotGetBankNumber, SLRU_PAGE_EMPTY, SLRU_PAGE_VALID, SLRU_PAGES_PER_SEGMENT, SlruInternalDeleteSegment(), and SlruInternalWritePage().

Referenced by PerformMembersTruncation(), and test_slru_page_delete().

SlruScanDirCbDeleteAll()

bool SlruScanDirCbDeleteAll	(	SlruCtl	ctl,
		char *	filename,
		int64	segpage,
		void *	data
	)

Definition at line 1769 of file slru.c.

{
    SlruInternalDeleteSegment(ctl, segpage / SLRU_PAGES_PER_SEGMENT);
 
    return false;               /* keep going */
}

References ctl, SLRU_PAGES_PER_SEGMENT, and SlruInternalDeleteSegment().

Referenced by AsyncShmemInit(), DeactivateCommitTs(), and test_slru_scan_cb().

SlruScanDirCbReportPresence()

bool SlruScanDirCbReportPresence	(	SlruCtl	ctl,
		char *	filename,
		int64	segpage,
		void *	data
	)

Definition at line 1737 of file slru.c.

{
    int64       cutoffPage = *(int64 *) data;
 
    if (SlruMayDeleteSegment(ctl, segpage, cutoffPage))
        return true;            /* found one; don't iterate any more */
 
    return false;               /* keep going */
}

References ctl, data, and SlruMayDeleteSegment().

Referenced by TruncateCLOG(), and TruncateCommitTs().

SlruScanDirectory()

bool SlruScanDirectory	(	SlruCtl	ctl,
		SlruScanCallback	callback,
		void *	data
	)

Definition at line 1816 of file slru.c.

{
    bool        retval = false;
    DIR        *cldir;
    struct dirent *clde;
    int64       segno;
    int64       segpage;
 
    cldir = AllocateDir(ctl->Dir);
    while ((clde = ReadDir(cldir, ctl->Dir)) != NULL)
    {
        size_t      len;
 
        len = strlen(clde->d_name);
 
        if (SlruCorrectSegmentFilenameLength(ctl, len) &&
            strspn(clde->d_name, "0123456789ABCDEF") == len)
        {
            segno = strtoi64(clde->d_name, NULL, 16);
            segpage = segno * SLRU_PAGES_PER_SEGMENT;
 
            elog(DEBUG2, "SlruScanDirectory invoking callback on %s/%s",
                 ctl->Dir, clde->d_name);
            retval = callback(ctl, clde->d_name, segpage, data);
            if (retval)
                break;
        }
    }
    FreeDir(cldir);
 
    return retval;
}

References AllocateDir(), callback(), ctl, dirent::d_name, data, DEBUG2, elog, FreeDir(), len, ReadDir(), SLRU_PAGES_PER_SEGMENT, and SlruCorrectSegmentFilenameLength().

Referenced by AsyncShmemInit(), DeactivateCommitTs(), SimpleLruTruncate(), test_slru_delete_all(), TruncateCLOG(), TruncateCommitTs(), and TruncateMultiXact().

SlruSyncFileTag()

int SlruSyncFileTag	(	SlruCtl	ctl,
		const FileTag *	ftag,
		char *	path
	)

Definition at line 1856 of file slru.c.

{
    int         fd;
    int         save_errno;
    int         result;
 
    SlruFileName(ctl, path, ftag->segno);
 
    fd = OpenTransientFile(path, O_RDWR | PG_BINARY);
    if (fd < 0)
        return -1;
 
    pgstat_report_wait_start(WAIT_EVENT_SLRU_FLUSH_SYNC);
    result = pg_fsync(fd);
    pgstat_report_wait_end();
    save_errno = errno;
 
    CloseTransientFile(fd);
 
    errno = save_errno;
    return result;
}

References CloseTransientFile(), ctl, fd(), OpenTransientFile(), PG_BINARY, pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), FileTag::segno, and SlruFileName().

Referenced by clogsyncfiletag(), committssyncfiletag(), multixactmemberssyncfiletag(), multixactoffsetssyncfiletag(), and test_slru_page_sync().