slru.h File Reference

#include "access/transam.h"
#include "access/xlogdefs.h"
#include "storage/lwlock.h"
#include "storage/shmem.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	SlruOpts
struct	SlruDesc

Macros
#define	SLRU_MAX_ALLOWED_BUFFERS   ((1024 * 1024 * 1024) / BLCKSZ)
#define	SimpleLruRequest(...)    SimpleLruRequestWithOpts(&(SlruOpts){__VA_ARGS__})
#define	SlruPagePrecedesUnitTests(ctl, per_page)   do {} while (0)

Typedefs
typedef struct SlruSharedData	SlruSharedData
typedef SlruSharedData *	SlruShared
typedef struct SlruDesc	SlruDesc
typedef struct SlruOpts	SlruOpts
typedef bool(*	SlruScanCallback) (SlruDesc *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 (SlruDesc *ctl, int64 pageno)
void	SimpleLruRequestWithOpts (const SlruOpts *options)
int	SimpleLruAutotuneBuffers (int divisor, int max)
int	SimpleLruZeroPage (SlruDesc *ctl, int64 pageno)
void	SimpleLruZeroAndWritePage (SlruDesc *ctl, int64 pageno)
int	SimpleLruReadPage (SlruDesc *ctl, int64 pageno, bool write_ok, const void *opaque_data)
int	SimpleLruReadPage_ReadOnly (SlruDesc *ctl, int64 pageno, const void *opaque_data)
void	SimpleLruWritePage (SlruDesc *ctl, int slotno)
void	SimpleLruWriteAll (SlruDesc *ctl, bool allow_redirtied)
void	SimpleLruTruncate (SlruDesc *ctl, int64 cutoffPage)
bool	SimpleLruDoesPhysicalPageExist (SlruDesc *ctl, int64 pageno)
bool	SlruScanDirectory (SlruDesc *ctl, SlruScanCallback callback, void *data)
void	SlruDeleteSegment (SlruDesc *ctl, int64 segno)
int	SlruSyncFileTag (SlruDesc *ctl, const FileTag *ftag, char *path)
bool	SlruScanDirCbReportPresence (SlruDesc *ctl, char *filename, int64 segpage, void *data)
bool	SlruScanDirCbDeleteAll (SlruDesc *ctl, char *filename, int64 segpage, void *data)
bool	check_slru_buffers (const char *name, int *newval)
void	shmem_slru_init (void *location, ShmemStructOpts *base_options)
void	shmem_slru_attach (void *location, ShmemStructOpts *base_options)

Macro Definition Documentation

SimpleLruRequest

#define SimpleLruRequest

(

...

)

SimpleLruRequestWithOpts(&(SlruOpts){__VA_ARGS__})

Definition at line 218 of file slru.h.

                                        {__VA_ARGS__})

SLRU_MAX_ALLOWED_BUFFERS

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

Definition at line 26 of file slru.h.

SlruPagePrecedesUnitTests

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

Definition at line 233 of file slru.h.

Typedef Documentation

SlruDesc

typedef struct SlruDesc SlruDesc

Definition at line 110 of file slru.h.

SlruOpts

typedef struct SlruOpts SlruOpts

SlruScanCallback

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

Definition at line 238 of file slru.h.

SlruShared

typedef SlruSharedData* SlruShared

Definition at line 108 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 34 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  )

extern

Definition at line 377 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().

shmem_slru_attach()

void shmem_slru_attach ( void *  location, ShmemStructOpts *  base_options  )

extern

Definition at line 359 of file slru.c.

{
    SlruOpts   *options = (SlruOpts *) base_options;
    SlruDesc   *desc = (SlruDesc *) options->desc;
    int         nslots = options->nslots;
    int         nbanks = nslots / SLRU_BANK_SIZE;
 
    desc->shared = (SlruShared) location;
    desc->nbanks = nbanks;
    memcpy(&desc->options, options, sizeof(SlruOpts));
}

References fb(), memcpy(), SlruDesc::nbanks, SlruDesc::options, SlruDesc::shared, and SLRU_BANK_SIZE.

Referenced by AttachShmemIndexEntry().

shmem_slru_init()

void shmem_slru_init ( void *  location, ShmemStructOpts *  base_options  )

extern

Definition at line 267 of file slru.c.

{
    SlruOpts   *options = (SlruOpts *) base_options;
    SlruDesc   *desc = (SlruDesc *) options->desc;
    char        namebuf[NAMEDATALEN];
    SlruShared  shared;
    int         nslots = options->nslots;
    int         nbanks = nslots / SLRU_BANK_SIZE;
    int         nlsns = options->nlsns;
    char       *ptr;
    Size        offset;
 
    shared = (SlruShared) location;
    desc->shared = shared;
    desc->nbanks = nbanks;
    memcpy(&desc->options, options, sizeof(SlruOpts));
 
    /* assign new tranche IDs, if not given */
    if (desc->options.buffer_tranche_id == 0)
    {
        snprintf(namebuf, sizeof(namebuf), "%s buffer", desc->options.name);
        desc->options.buffer_tranche_id = LWLockNewTrancheId(namebuf);
    }
    if (desc->options.bank_tranche_id == 0)
    {
        snprintf(namebuf, sizeof(namebuf), "%s bank", desc->options.name);
        desc->options.bank_tranche_id = LWLockNewTrancheId(namebuf);
    }
 
    Assert(nslots <= SLRU_MAX_ALLOWED_BUFFERS);
 
    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(desc->options.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,
                         desc->options.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, desc->options.bank_tranche_id);
        shared->bank_cur_lru_count[bankno] = 0;
    }
 
    /* Should fit to estimated shmem size */
    Assert(ptr - (char *) shared <= SimpleLruShmemSize(nslots, nlsns));
}

References Assert, SlruSharedData::bank_cur_lru_count, SlruSharedData::bank_locks, SlruOpts::bank_tranche_id, SlruSharedData::buffer_locks, SlruOpts::buffer_tranche_id, BUFFERALIGN, fb(), SlruSharedData::group_lsn, SlruSharedData::latest_page_number, LWLockPadded::lock, SlruSharedData::lsn_groups_per_page, LWLockInitialize(), LWLockNewTrancheId(), MAXALIGN, memcpy(), SlruOpts::name, NAMEDATALEN, SlruDesc::nbanks, SlruSharedData::num_slots, SlruDesc::options, SlruSharedData::page_buffer, SlruSharedData::page_dirty, SlruSharedData::page_lru_count, SlruSharedData::page_number, SlruSharedData::page_status, pg_atomic_init_u64(), pgstat_get_slru_index(), SlruDesc::shared, SimpleLruShmemSize(), SLRU_BANK_SIZE, SLRU_MAX_ALLOWED_BUFFERS, SLRU_PAGE_EMPTY, SlruSharedData::slru_stats_idx, and snprintf.

Referenced by InitShmemIndexEntry().

SimpleLruAutotuneBuffers()

int SimpleLruAutotuneBuffers ( int  divisor, int  max  )

extern

Definition at line 235 of file slru.c.

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

References fb(), Max, Min, NBuffers, and SLRU_BANK_SIZE.

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

SimpleLruDoesPhysicalPageExist()

bool SimpleLruDoesPhysicalPageExist ( SlruDesc *  ctl, int64  pageno  )

extern

Definition at line 795 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, NULL);
    }
 
    if ((endpos = lseek(fd, 0, SEEK_END)) < 0)
    {
        slru_errcause = SLRU_SEEK_FAILED;
        slru_errno = errno;
        SlruReportIOError(ctl, pageno, NULL);
    }
 
    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, fb(), fd(), MAXPGPATH, OpenTransientFile(), PG_BINARY, pgstat_count_slru_blocks_exists(), result, 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(), and test_slru_page_exists().

SimpleLruGetBankLock()

static LWLock * SimpleLruGetBankLock ( SlruDesc *  ctl, int64  pageno  )

inlinestatic

Definition at line 207 of file slru.h.

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

References Assert, ctl, and fb().

Referenced by AsyncNotifyFreezeXids(), asyncQueueAddEntries(), asyncQueueProcessPageEntries(), ExtendCLOG(), ExtendCommitTs(), ExtendMultiXactMember(), ExtendMultiXactOffset(), ExtendSUBTRANS(), find_multixact_start(), GetMultiXactIdMembers(), 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().

SimpleLruReadPage()

int SimpleLruReadPage ( SlruDesc *  ctl, int64  pageno, bool  write_ok, const void *  opaque_data  )

extern

Definition at line 550 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, opaque_data);
 
        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, fb(), 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 ( SlruDesc *  ctl, int64  pageno, const void *  opaque_data  )

extern

Definition at line 654 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, opaque_data);
}

References ctl, fb(), 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().

SimpleLruRequestWithOpts()

void SimpleLruRequestWithOpts ( const SlruOpts *  options )

extern

Definition at line 246 of file slru.c.

{
    SlruOpts   *options_copy;
 
    Assert(options->name != NULL);
    Assert(options->nslots > 0);
    Assert(options->PagePrecedes != NULL);
    Assert(options->errdetail_for_io_error != NULL);
 
    options_copy = MemoryContextAlloc(TopMemoryContext,
                                      sizeof(SlruOpts));
    memcpy(options_copy, options, sizeof(SlruOpts));
 
    options_copy->base.name = options->name;
    options_copy->base.size = SimpleLruShmemSize(options_copy->nslots, options_copy->nlsns);
 
    ShmemRequestInternal(&options_copy->base, SHMEM_KIND_SLRU);
}

References Assert, fb(), memcpy(), MemoryContextAlloc(), SHMEM_KIND_SLRU, ShmemRequestInternal(), SimpleLruShmemSize(), and TopMemoryContext.

SimpleLruTruncate()

void SimpleLruTruncate ( SlruDesc *  ctl, int64  cutoffPage  )

extern

Definition at line 1458 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->options.PagePrecedes(pg_atomic_read_u64(&shared->latest_page_number),
                                  cutoffPage))
    {
        ereport(LOG,
                (errmsg("could not truncate directory \"%s\": apparent wraparound",
                        ctl->options.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->options.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, fb(), 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(), PerformMembersTruncation(), PerformOffsetsTruncation(), test_slru_page_truncate(), TruncateCLOG(), TruncateCommitTs(), and TruncateSUBTRANS().

SimpleLruWriteAll()

void SimpleLruWriteAll ( SlruDesc *  ctl, bool  allow_redirtied  )

extern

Definition at line 1372 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, NULL);
 
    /* Ensure that directory entries for new files are on disk. */
    if (ctl->options.sync_handler != SYNC_HANDLER_NONE)
        fsync_fname(ctl->options.Dir, true);
}

References Assert, SlruSharedData::bank_locks, CloseTransientFile(), ctl, fb(), fsync_fname(), i, LWLockPadded::lock, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), SlruSharedData::num_slots, SlruSharedData::page_dirty, SlruSharedData::page_status, pgstat_count_slru_flush(), 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 ( SlruDesc *  ctl, int  slotno  )

extern

Definition at line 781 of file slru.c.

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

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

Referenced by SimpleLruZeroAndWritePage(), and test_slru_page_write().

SimpleLruZeroAndWritePage()

void SimpleLruZeroAndWritePage ( SlruDesc *  ctl, int64  pageno  )

extern

Definition at line 466 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, fb(), 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 ( SlruDesc *  ctl, int64  pageno  )

extern

Definition at line 397 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, fb(), 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(), SerialAdd(), SimpleLruZeroAndWritePage(), StartupSUBTRANS(), test_slru_page_write(), and TrimMultiXact().

SlruDeleteSegment()

void SlruDeleteSegment ( SlruDesc *  ctl, int64  segno  )

extern

Definition at line 1576 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, fb(), 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 test_slru_page_delete().

SlruScanDirCbDeleteAll()

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

extern

Definition at line 1797 of file slru.c.

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

References ctl, fb(), SLRU_PAGES_PER_SEGMENT, and SlruInternalDeleteSegment().

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

SlruScanDirCbReportPresence()

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

extern

Definition at line 1765 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, fb(), and SlruMayDeleteSegment().

Referenced by TruncateCLOG(), and TruncateCommitTs().

SlruScanDirectory()

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

extern

Definition at line 1844 of file slru.c.

{
    bool        retval = false;
    DIR        *cldir;
    struct dirent *clde;
    int64       segno;
    int64       segpage;
 
    cldir = AllocateDir(ctl->options.Dir);
    while ((clde = ReadDir(cldir, ctl->options.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->options.Dir, clde->d_name);
            retval = callback(ctl, clde->d_name, segpage, data);
            if (retval)
                break;
        }
    }
    FreeDir(cldir);
 
    return retval;
}

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

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

SlruSyncFileTag()

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

extern

Definition at line 1884 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, fb(), fd(), OpenTransientFile(), PG_BINARY, pg_fsync(), pgstat_report_wait_end(), pgstat_report_wait_start(), result, FileTag::segno, and SlruFileName().

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