syncscan.c File Reference

#include "postgres.h"
#include "access/syncscan.h"
#include "miscadmin.h"
#include "storage/lwlock.h"
#include "storage/shmem.h"
#include "storage/subsystems.h"
#include "utils/rel.h"

Include dependency graph for syncscan.c:

Go to the source code of this file.

Data Structures
struct	ss_scan_location_t
struct	ss_lru_item_t
struct	ss_scan_locations_t

Macros
#define	SYNC_SCAN_NELEM   20
#define	SYNC_SCAN_REPORT_INTERVAL   (128 * 1024 / BLCKSZ)
#define	SizeOfScanLocations(N)    (offsetof(ss_scan_locations_t, items) + (N) * sizeof(ss_lru_item_t))

Typedefs
typedef struct ss_scan_location_t	ss_scan_location_t
typedef struct ss_lru_item_t	ss_lru_item_t
typedef struct ss_scan_locations_t	ss_scan_locations_t

Functions
static void	SyncScanShmemRequest (void *arg)
static void	SyncScanShmemInit (void *arg)
static BlockNumber	ss_search (RelFileLocator relfilelocator, BlockNumber location, bool set)
BlockNumber	ss_get_location (Relation rel, BlockNumber relnblocks)
void	ss_report_location (Relation rel, BlockNumber location)

Variables
const ShmemCallbacks	SyncScanShmemCallbacks
static ss_scan_locations_t *	scan_locations

Macro Definition Documentation

SizeOfScanLocations

#define SizeOfScanLocations

(

N

)

(offsetof(ss_scan_locations_t, items) + (N) * sizeof(ss_lru_item_t))

Definition at line 112 of file syncscan.c.

                                              {
    .request_fn = SyncScanShmemRequest,
    .init_fn = SyncScanShmemInit,
};
 
/* Pointer to struct in shared memory */
static ss_scan_locations_t *scan_locations;
 
/* prototypes for internal functions */
static BlockNumber ss_search(RelFileLocator relfilelocator,
                             BlockNumber location, bool set);
 
 
/*
 * SyncScanShmemRequest --- register this module's shared memory
 */
static void
SyncScanShmemRequest(void *arg)
{
    ShmemRequestStruct(.name = "Sync Scan Locations List",
                       .size = SizeOfScanLocations(SYNC_SCAN_NELEM),
                       .ptr = (void **) &scan_locations,
        );
}
 
/*
 * SyncScanShmemInit --- initialize this module's shared memory
 */
static void
SyncScanShmemInit(void *arg)
{
    int         i;
 
    scan_locations->head = &scan_locations->items[0];
    scan_locations->tail = &scan_locations->items[SYNC_SCAN_NELEM - 1];
 
    for (i = 0; i < SYNC_SCAN_NELEM; i++)
    {
        ss_lru_item_t *item = &scan_locations->items[i];
 
        /*
         * Initialize all slots with invalid values. As scans are started,
         * these invalid entries will fall off the LRU list and get replaced
         * with real entries.
         */
        item->location.relfilelocator.spcOid = InvalidOid;
        item->location.relfilelocator.dbOid = InvalidOid;
        item->location.relfilelocator.relNumber = InvalidRelFileNumber;
        item->location.location = InvalidBlockNumber;
 
        item->prev = (i > 0) ?
            (&scan_locations->items[i - 1]) : NULL;
        item->next = (i < SYNC_SCAN_NELEM - 1) ?
            (&scan_locations->items[i + 1]) : NULL;
    }
}
 
/*
 * ss_search --- search the scan_locations structure for an entry with the
 *      given relfilelocator.
 *
 * If "set" is true, the location is updated to the given location.  If no
 * entry for the given relfilelocator is found, it will be created at the head
 * of the list with the given location, even if "set" is false.
 *
 * In any case, the location after possible update is returned.
 *
 * Caller is responsible for having acquired suitable lock on the shared
 * data structure.
 */
static BlockNumber
ss_search(RelFileLocator relfilelocator, BlockNumber location, bool set)
{
    ss_lru_item_t *item;
 
    item = scan_locations->head;
    for (;;)
    {
        bool        match;
 
        match = RelFileLocatorEquals(item->location.relfilelocator,
                                     relfilelocator);
 
        if (match || item->next == NULL)
        {
            /*
             * If we reached the end of list and no match was found, take over
             * the last entry
             */
            if (!match)
            {
                item->location.relfilelocator = relfilelocator;
                item->location.location = location;
            }
            else if (set)
                item->location.location = location;
 
            /* Move the entry to the front of the LRU list */
            if (item != scan_locations->head)
            {
                /* unlink */
                if (item == scan_locations->tail)
                    scan_locations->tail = item->prev;
                item->prev->next = item->next;
                if (item->next)
                    item->next->prev = item->prev;
 
                /* link */
                item->prev = NULL;
                item->next = scan_locations->head;
                scan_locations->head->prev = item;
                scan_locations->head = item;
            }
 
            return item->location.location;
        }
 
        item = item->next;
    }
 
    /* not reached */
}
 
/*
 * ss_get_location --- get the optimal starting location for scan
 *
 * Returns the last-reported location of a sequential scan on the
 * relation, or 0 if no valid location is found.
 *
 * We expect the caller has just done RelationGetNumberOfBlocks(), and
 * so that number is passed in rather than computing it again.  The result
 * is guaranteed less than relnblocks (assuming that's > 0).
 */
BlockNumber
ss_get_location(Relation rel, BlockNumber relnblocks)
{
    BlockNumber startloc;
 
    LWLockAcquire(SyncScanLock, LW_EXCLUSIVE);
    startloc = ss_search(rel->rd_locator, 0, false);
    LWLockRelease(SyncScanLock);
 
    /*
     * If the location is not a valid block number for this scan, start at 0.
     *
     * This can happen if for instance a VACUUM truncated the table since the
     * location was saved.
     */
    if (startloc >= relnblocks)
        startloc = 0;
 
#ifdef TRACE_SYNCSCAN
    if (trace_syncscan)
        elog(LOG,
             "SYNC_SCAN: start \"%s\" (size %u) at %u",
             RelationGetRelationName(rel), relnblocks, startloc);
#endif
 
    return startloc;
}
 
/*
 * ss_report_location --- update the current scan location
 *
 * Writes an entry into the shared Sync Scan state of the form
 * (relfilelocator, blocknumber), overwriting any existing entry for the
 * same relfilelocator.
 */
void
ss_report_location(Relation rel, BlockNumber location)
{
#ifdef TRACE_SYNCSCAN
    if (trace_syncscan)
    {
        if ((location % 1024) == 0)
            elog(LOG,
                 "SYNC_SCAN: scanning \"%s\" at %u",
                 RelationGetRelationName(rel), location);
    }
#endif
 
    /*
     * To reduce lock contention, only report scan progress every N pages. For
     * the same reason, don't block if the lock isn't immediately available.
     * Missing a few updates isn't critical, it just means that a new scan
     * that wants to join the pack will start a little bit behind the head of
     * the scan.  Hopefully the pages are still in OS cache and the scan
     * catches up quickly.
     */
    if ((location % SYNC_SCAN_REPORT_INTERVAL) == 0)
    {
        if (LWLockConditionalAcquire(SyncScanLock, LW_EXCLUSIVE))
        {
            (void) ss_search(rel->rd_locator, location, true);
            LWLockRelease(SyncScanLock);
        }
#ifdef TRACE_SYNCSCAN
        else if (trace_syncscan)
            elog(LOG,
                 "SYNC_SCAN: missed update for \"%s\" at %u",
                 RelationGetRelationName(rel), location);
#endif
    }
}

SYNC_SCAN_NELEM

#define SYNC_SCAN_NELEM   20

Definition at line 72 of file syncscan.c.

SYNC_SCAN_REPORT_INTERVAL

#define SYNC_SCAN_REPORT_INTERVAL   (128 * 1024 / BLCKSZ)

Definition at line 84 of file syncscan.c.

Typedef Documentation

ss_lru_item_t

typedef struct ss_lru_item_t ss_lru_item_t

ss_scan_location_t

typedef struct ss_scan_location_t ss_scan_location_t

ss_scan_locations_t

typedef struct ss_scan_locations_t ss_scan_locations_t

Function Documentation

ss_get_location()

BlockNumber ss_get_location	(	Relation	rel,
		BlockNumber	relnblocks
	)

Definition at line 252 of file syncscan.c.

{
    BlockNumber startloc;
 
    LWLockAcquire(SyncScanLock, LW_EXCLUSIVE);
    startloc = ss_search(rel->rd_locator, 0, false);
    LWLockRelease(SyncScanLock);
 
    /*
     * If the location is not a valid block number for this scan, start at 0.
     *
     * This can happen if for instance a VACUUM truncated the table since the
     * location was saved.
     */
    if (startloc >= relnblocks)
        startloc = 0;
 
#ifdef TRACE_SYNCSCAN
    if (trace_syncscan)
        elog(LOG,
             "SYNC_SCAN: start \"%s\" (size %u) at %u",
             RelationGetRelationName(rel), relnblocks, startloc);
#endif
 
    return startloc;
}

References elog, fb(), LOG, LW_EXCLUSIVE, LWLockAcquire(), LWLockRelease(), RelationData::rd_locator, RelationGetRelationName, and ss_search().

Referenced by initscan(), and table_block_parallelscan_startblock_init().

ss_report_location()

void ss_report_location	(	Relation	rel,
		BlockNumber	location
	)

Definition at line 287 of file syncscan.c.

{
#ifdef TRACE_SYNCSCAN
    if (trace_syncscan)
    {
        if ((location % 1024) == 0)
            elog(LOG,
                 "SYNC_SCAN: scanning \"%s\" at %u",
                 RelationGetRelationName(rel), location);
    }
#endif
 
    /*
     * To reduce lock contention, only report scan progress every N pages. For
     * the same reason, don't block if the lock isn't immediately available.
     * Missing a few updates isn't critical, it just means that a new scan
     * that wants to join the pack will start a little bit behind the head of
     * the scan.  Hopefully the pages are still in OS cache and the scan
     * catches up quickly.
     */
    if ((location % SYNC_SCAN_REPORT_INTERVAL) == 0)
    {
        if (LWLockConditionalAcquire(SyncScanLock, LW_EXCLUSIVE))
        {
            (void) ss_search(rel->rd_locator, location, true);
            LWLockRelease(SyncScanLock);
        }
#ifdef TRACE_SYNCSCAN
        else if (trace_syncscan)
            elog(LOG,
                 "SYNC_SCAN: missed update for \"%s\" at %u",
                 RelationGetRelationName(rel), location);
#endif
    }
}

References elog, fb(), LOG, LW_EXCLUSIVE, LWLockConditionalAcquire(), LWLockRelease(), RelationData::rd_locator, RelationGetRelationName, ss_search(), and SYNC_SCAN_REPORT_INTERVAL.

Referenced by heapam_scan_sample_next_block(), heapgettup_advance_block(), and table_block_parallelscan_nextpage().

ss_search()

static BlockNumber ss_search ( RelFileLocator  relfilelocator, BlockNumber  location, bool  set  )

static

Definition at line 189 of file syncscan.c.

{
    ss_lru_item_t *item;
 
    item = scan_locations->head;
    for (;;)
    {
        bool        match;
 
        match = RelFileLocatorEquals(item->location.relfilelocator,
                                     relfilelocator);
 
        if (match || item->next == NULL)
        {
            /*
             * If we reached the end of list and no match was found, take over
             * the last entry
             */
            if (!match)
            {
                item->location.relfilelocator = relfilelocator;
                item->location.location = location;
            }
            else if (set)
                item->location.location = location;
 
            /* Move the entry to the front of the LRU list */
            if (item != scan_locations->head)
            {
                /* unlink */
                if (item == scan_locations->tail)
                    scan_locations->tail = item->prev;
                item->prev->next = item->next;
                if (item->next)
                    item->next->prev = item->prev;
 
                /* link */
                item->prev = NULL;
                item->next = scan_locations->head;
                scan_locations->head->prev = item;
                scan_locations->head = item;
            }
 
            return item->location.location;
        }
 
        item = item->next;
    }
 
    /* not reached */
}

References fb(), ss_scan_locations_t::head, ss_scan_location_t::location, ss_lru_item_t::location, ss_lru_item_t::next, ss_lru_item_t::prev, ss_scan_location_t::relfilelocator, RelFileLocatorEquals, scan_locations, and ss_scan_locations_t::tail.

Referenced by ss_get_location(), and ss_report_location().

SyncScanShmemInit()

static void SyncScanShmemInit ( void *  arg )

static

Definition at line 147 of file syncscan.c.

{
    int         i;
 
    scan_locations->head = &scan_locations->items[0];
    scan_locations->tail = &scan_locations->items[SYNC_SCAN_NELEM - 1];
 
    for (i = 0; i < SYNC_SCAN_NELEM; i++)
    {
        ss_lru_item_t *item = &scan_locations->items[i];
 
        /*
         * Initialize all slots with invalid values. As scans are started,
         * these invalid entries will fall off the LRU list and get replaced
         * with real entries.
         */
        item->location.relfilelocator.spcOid = InvalidOid;
        item->location.relfilelocator.dbOid = InvalidOid;
        item->location.relfilelocator.relNumber = InvalidRelFileNumber;
        item->location.location = InvalidBlockNumber;
 
        item->prev = (i > 0) ?
            (&scan_locations->items[i - 1]) : NULL;
        item->next = (i < SYNC_SCAN_NELEM - 1) ?
            (&scan_locations->items[i + 1]) : NULL;
    }
}

References RelFileLocator::dbOid, fb(), ss_scan_locations_t::head, i, InvalidBlockNumber, InvalidOid, InvalidRelFileNumber, ss_scan_locations_t::items, ss_scan_location_t::location, ss_lru_item_t::location, ss_lru_item_t::next, ss_lru_item_t::prev, ss_scan_location_t::relfilelocator, RelFileLocator::relNumber, scan_locations, RelFileLocator::spcOid, SYNC_SCAN_NELEM, and ss_scan_locations_t::tail.

SyncScanShmemRequest()

static void SyncScanShmemRequest ( void *  arg )

static

Definition at line 135 of file syncscan.c.

{
    ShmemRequestStruct(.name = "Sync Scan Locations List",
                       .size = SizeOfScanLocations(SYNC_SCAN_NELEM),
                       .ptr = (void **) &scan_locations,
        );
}

References name, scan_locations, ShmemRequestStruct, SizeOfScanLocations, and SYNC_SCAN_NELEM.

Variable Documentation

scan_locations

ss_scan_locations_t* scan_locations

static

Definition at line 124 of file syncscan.c.

Referenced by ss_search(), SyncScanShmemInit(), and SyncScanShmemRequest().

SyncScanShmemCallbacks

const ShmemCallbacks SyncScanShmemCallbacks

Initial value:

= {
    .request_fn = SyncScanShmemRequest,
    .init_fn = SyncScanShmemInit,
}

Definition at line 118 of file syncscan.c.

                                              {
    .request_fn = SyncScanShmemRequest,
    .init_fn = SyncScanShmemInit,
};