freelist.c File Reference

#include "postgres.h"
#include "pgstat.h"
#include "port/atomics.h"
#include "storage/buf_internals.h"
#include "storage/bufmgr.h"
#include "storage/proc.h"

Include dependency graph for freelist.c:

Go to the source code of this file.

Data Structures
struct	BufferStrategyControl
struct	BufferAccessStrategyData

Macros
#define	INT_ACCESS_ONCE(var)   ((int)(*((volatile int *)&(var))))

Typedefs
typedef struct BufferAccessStrategyData	BufferAccessStrategyData

Functions
static BufferDesc *	GetBufferFromRing (BufferAccessStrategy strategy, uint32 *buf_state)
static void	AddBufferToRing (BufferAccessStrategy strategy, BufferDesc *buf)
static uint32	ClockSweepTick (void)
BufferDesc *	StrategyGetBuffer (BufferAccessStrategy strategy, uint32 *buf_state, bool *from_ring)
int	StrategySyncStart (uint32 *complete_passes, uint32 *num_buf_alloc)
void	StrategyNotifyBgWriter (int bgwprocno)
Size	StrategyShmemSize (void)
void	StrategyInitialize (bool init)
BufferAccessStrategy	GetAccessStrategy (BufferAccessStrategyType btype)
BufferAccessStrategy	GetAccessStrategyWithSize (BufferAccessStrategyType btype, int ring_size_kb)
int	GetAccessStrategyBufferCount (BufferAccessStrategy strategy)
int	GetAccessStrategyPinLimit (BufferAccessStrategy strategy)
void	FreeAccessStrategy (BufferAccessStrategy strategy)
IOContext	IOContextForStrategy (BufferAccessStrategy strategy)
bool	StrategyRejectBuffer (BufferAccessStrategy strategy, BufferDesc *buf, bool from_ring)

Variables
static BufferStrategyControl *	StrategyControl = NULL

Macro Definition Documentation

INT_ACCESS_ONCE

#define INT_ACCESS_ONCE

(

var

)

((int)(*((volatile int *)&(var))))

Definition at line 24 of file freelist.c.

Typedef Documentation

BufferAccessStrategyData

typedef struct BufferAccessStrategyData BufferAccessStrategyData

Function Documentation

AddBufferToRing()

static void AddBufferToRing ( BufferAccessStrategy  strategy, BufferDesc *  buf  )

static

Definition at line 737 of file freelist.c.

{
    strategy->buffers[strategy->current] = BufferDescriptorGetBuffer(buf);
}

References buf, BufferDescriptorGetBuffer(), BufferAccessStrategyData::buffers, and BufferAccessStrategyData::current.

Referenced by StrategyGetBuffer().

ClockSweepTick()

static uint32 ClockSweepTick ( void  )

inlinestatic

Definition at line 100 of file freelist.c.

{
    uint32      victim;
 
    /*
     * Atomically move hand ahead one buffer - if there's several processes
     * doing this, this can lead to buffers being returned slightly out of
     * apparent order.
     */
    victim =
        pg_atomic_fetch_add_u32(&StrategyControl->nextVictimBuffer, 1);
 
    if (victim >= NBuffers)
    {
        uint32      originalVictim = victim;
 
        /* always wrap what we look up in BufferDescriptors */
        victim = victim % NBuffers;
 
        /*
         * If we're the one that just caused a wraparound, force
         * completePasses to be incremented while holding the spinlock. We
         * need the spinlock so StrategySyncStart() can return a consistent
         * value consisting of nextVictimBuffer and completePasses.
         */
        if (victim == 0)
        {
            uint32      expected;
            uint32      wrapped;
            bool        success = false;
 
            expected = originalVictim + 1;
 
            while (!success)
            {
                /*
                 * Acquire the spinlock while increasing completePasses. That
                 * allows other readers to read nextVictimBuffer and
                 * completePasses in a consistent manner which is required for
                 * StrategySyncStart().  In theory delaying the increment
                 * could lead to an overflow of nextVictimBuffers, but that's
                 * highly unlikely and wouldn't be particularly harmful.
                 */
                SpinLockAcquire(&StrategyControl->buffer_strategy_lock);
 
                wrapped = expected % NBuffers;
 
                success = pg_atomic_compare_exchange_u32(&StrategyControl->nextVictimBuffer,
                                                         &expected, wrapped);
                if (success)
                    StrategyControl->completePasses++;
                SpinLockRelease(&StrategyControl->buffer_strategy_lock);
            }
        }
    }
    return victim;
}

References BufferStrategyControl::buffer_strategy_lock, BufferStrategyControl::completePasses, NBuffers, BufferStrategyControl::nextVictimBuffer, pg_atomic_compare_exchange_u32(), pg_atomic_fetch_add_u32(), SpinLockAcquire, SpinLockRelease, StrategyControl, and success.

Referenced by StrategyGetBuffer().

FreeAccessStrategy()

void FreeAccessStrategy

(

BufferAccessStrategy

strategy

)

Definition at line 643 of file freelist.c.

{
    /* don't crash if called on a "default" strategy */
    if (strategy != NULL)
        pfree(strategy);
}

References pfree().

Referenced by blgetbitmap(), FreeBulkInsertState(), heap_endscan(), initscan(), parallel_vacuum_main(), and RelationCopyStorageUsingBuffer().

GetAccessStrategy()

BufferAccessStrategy GetAccessStrategy

(

BufferAccessStrategyType

btype

)

Definition at line 461 of file freelist.c.

{
    int         ring_size_kb;
 
    /*
     * Select ring size to use.  See buffer/README for rationales.
     *
     * Note: if you change the ring size for BAS_BULKREAD, see also
     * SYNC_SCAN_REPORT_INTERVAL in access/heap/syncscan.c.
     */
    switch (btype)
    {
        case BAS_NORMAL:
            /* if someone asks for NORMAL, just give 'em a "default" object */
            return NULL;
 
        case BAS_BULKREAD:
            {
                int         ring_max_kb;
 
                /*
                 * The ring always needs to be large enough to allow some
                 * separation in time between providing a buffer to the user
                 * of the strategy and that buffer being reused. Otherwise the
                 * user's pin will prevent reuse of the buffer, even without
                 * concurrent activity.
                 *
                 * We also need to ensure the ring always is large enough for
                 * SYNC_SCAN_REPORT_INTERVAL, as noted above.
                 *
                 * Thus we start out a minimal size and increase the size
                 * further if appropriate.
                 */
                ring_size_kb = 256;
 
                /*
                 * There's no point in a larger ring if we won't be allowed to
                 * pin sufficiently many buffers.  But we never limit to less
                 * than the minimal size above.
                 */
                ring_max_kb = GetPinLimit() * (BLCKSZ / 1024);
                ring_max_kb = Max(ring_size_kb, ring_max_kb);
 
                /*
                 * We would like the ring to additionally have space for the
                 * configured degree of IO concurrency. While being read in,
                 * buffers can obviously not yet be reused.
                 *
                 * Each IO can be up to io_combine_limit blocks large, and we
                 * want to start up to effective_io_concurrency IOs.
                 *
                 * Note that effective_io_concurrency may be 0, which disables
                 * AIO.
                 */
                ring_size_kb += (BLCKSZ / 1024) *
                    io_combine_limit * effective_io_concurrency;
 
                if (ring_size_kb > ring_max_kb)
                    ring_size_kb = ring_max_kb;
                break;
            }
        case BAS_BULKWRITE:
            ring_size_kb = 16 * 1024;
            break;
        case BAS_VACUUM:
            ring_size_kb = 2048;
            break;
 
        default:
            elog(ERROR, "unrecognized buffer access strategy: %d",
                 (int) btype);
            return NULL;        /* keep compiler quiet */
    }
 
    return GetAccessStrategyWithSize(btype, ring_size_kb);
}

References BAS_BULKREAD, BAS_BULKWRITE, BAS_NORMAL, BAS_VACUUM, effective_io_concurrency, elog, ERROR, GetAccessStrategyWithSize(), GetPinLimit(), io_combine_limit, and Max.

Referenced by blgetbitmap(), bt_check_every_level(), collect_corrupt_items(), collect_visibility_data(), GetBulkInsertState(), gin_check_parent_keys_consistency(), gin_check_posting_tree_parent_keys_consistency(), initscan(), pgstat_index(), pgstathashindex(), pgstatindex_impl(), RelationCopyStorageUsingBuffer(), ScanSourceDatabasePgClass(), statapprox_heap(), and verify_heapam().

GetAccessStrategyBufferCount()

int GetAccessStrategyBufferCount

(

BufferAccessStrategy

strategy

)

Definition at line 586 of file freelist.c.

{
    if (strategy == NULL)
        return 0;
 
    return strategy->nbuffers;
}

References BufferAccessStrategyData::nbuffers.

Referenced by parallel_vacuum_init().

GetAccessStrategyPinLimit()

int GetAccessStrategyPinLimit

(

BufferAccessStrategy

strategy

)

Definition at line 609 of file freelist.c.

{
    if (strategy == NULL)
        return NBuffers;
 
    switch (strategy->btype)
    {
        case BAS_BULKREAD:
 
            /*
             * Since BAS_BULKREAD uses StrategyRejectBuffer(), dirty buffers
             * shouldn't be a problem and the caller is free to pin up to the
             * entire ring at once.
             */
            return strategy->nbuffers;
 
        default:
 
            /*
             * Tell caller not to pin more than half the buffers in the ring.
             * This is a trade-off between look ahead distance and deferring
             * writeback and associated WAL traffic.
             */
            return strategy->nbuffers / 2;
    }
}

References BAS_BULKREAD, BufferAccessStrategyData::btype, BufferAccessStrategyData::nbuffers, and NBuffers.

Referenced by read_stream_begin_impl().

GetAccessStrategyWithSize()

BufferAccessStrategy GetAccessStrategyWithSize	(	BufferAccessStrategyType	btype,
		int	ring_size_kb
	)

Definition at line 546 of file freelist.c.

{
    int         ring_buffers;
    BufferAccessStrategy strategy;
 
    Assert(ring_size_kb >= 0);
 
    /* Figure out how many buffers ring_size_kb is */
    ring_buffers = ring_size_kb / (BLCKSZ / 1024);
 
    /* 0 means unlimited, so no BufferAccessStrategy required */
    if (ring_buffers == 0)
        return NULL;
 
    /* Cap to 1/8th of shared_buffers */
    ring_buffers = Min(NBuffers / 8, ring_buffers);
 
    /* NBuffers should never be less than 16, so this shouldn't happen */
    Assert(ring_buffers > 0);
 
    /* Allocate the object and initialize all elements to zeroes */
    strategy = (BufferAccessStrategy)
        palloc0(offsetof(BufferAccessStrategyData, buffers) +
                ring_buffers * sizeof(Buffer));
 
    /* Set fields that don't start out zero */
    strategy->btype = btype;
    strategy->nbuffers = ring_buffers;
 
    return strategy;
}

References Assert(), BufferAccessStrategyData::btype, Min, BufferAccessStrategyData::nbuffers, NBuffers, and palloc0().

Referenced by do_autovacuum(), ExecVacuum(), GetAccessStrategy(), and parallel_vacuum_main().

GetBufferFromRing()

static BufferDesc * GetBufferFromRing ( BufferAccessStrategy  strategy, uint32 *  buf_state  )

static

Definition at line 658 of file freelist.c.

{
    BufferDesc *buf;
    Buffer      bufnum;
    uint32      old_buf_state;
    uint32      local_buf_state;    /* to avoid repeated (de-)referencing */
 
 
    /* Advance to next ring slot */
    if (++strategy->current >= strategy->nbuffers)
        strategy->current = 0;
 
    /*
     * If the slot hasn't been filled yet, tell the caller to allocate a new
     * buffer with the normal allocation strategy.  He will then fill this
     * slot by calling AddBufferToRing with the new buffer.
     */
    bufnum = strategy->buffers[strategy->current];
    if (bufnum == InvalidBuffer)
        return NULL;
 
    buf = GetBufferDescriptor(bufnum - 1);
 
    /*
     * Check whether the buffer can be used and pin it if so. Do this using a
     * CAS loop, to avoid having to lock the buffer header.
     */
    old_buf_state = pg_atomic_read_u32(&buf->state);
    for (;;)
    {
        local_buf_state = old_buf_state;
 
        /*
         * If the buffer is pinned we cannot use it under any circumstances.
         *
         * If usage_count is 0 or 1 then the buffer is fair game (we expect 1,
         * since our own previous usage of the ring element would have left it
         * there, but it might've been decremented by clock-sweep since then).
         * A higher usage_count indicates someone else has touched the buffer,
         * so we shouldn't re-use it.
         */
        if (BUF_STATE_GET_REFCOUNT(local_buf_state) != 0
            || BUF_STATE_GET_USAGECOUNT(local_buf_state) > 1)
            break;
 
        /* See equivalent code in PinBuffer() */
        if (unlikely(local_buf_state & BM_LOCKED))
        {
            old_buf_state = WaitBufHdrUnlocked(buf);
            continue;
        }
 
        /* pin the buffer if the CAS succeeds */
        local_buf_state += BUF_REFCOUNT_ONE;
 
        if (pg_atomic_compare_exchange_u32(&buf->state, &old_buf_state,
                                           local_buf_state))
        {
            *buf_state = local_buf_state;
 
            TrackNewBufferPin(BufferDescriptorGetBuffer(buf));
            return buf;
        }
    }
 
    /*
     * Tell caller to allocate a new buffer with the normal allocation
     * strategy.  He'll then replace this ring element via AddBufferToRing.
     */
    return NULL;
}

References BM_LOCKED, buf, BUF_REFCOUNT_ONE, BUF_STATE_GET_REFCOUNT, BUF_STATE_GET_USAGECOUNT, BufferDescriptorGetBuffer(), BufferAccessStrategyData::buffers, BufferAccessStrategyData::current, GetBufferDescriptor(), InvalidBuffer, BufferAccessStrategyData::nbuffers, pg_atomic_compare_exchange_u32(), pg_atomic_read_u32(), TrackNewBufferPin(), unlikely, and WaitBufHdrUnlocked().

Referenced by StrategyGetBuffer().

IOContextForStrategy()

IOContext IOContextForStrategy

(

BufferAccessStrategy

strategy

)

Definition at line 747 of file freelist.c.

{
    if (!strategy)
        return IOCONTEXT_NORMAL;
 
    switch (strategy->btype)
    {
        case BAS_NORMAL:
 
            /*
             * Currently, GetAccessStrategy() returns NULL for
             * BufferAccessStrategyType BAS_NORMAL, so this case is
             * unreachable.
             */
            pg_unreachable();
            return IOCONTEXT_NORMAL;
        case BAS_BULKREAD:
            return IOCONTEXT_BULKREAD;
        case BAS_BULKWRITE:
            return IOCONTEXT_BULKWRITE;
        case BAS_VACUUM:
            return IOCONTEXT_VACUUM;
    }
 
    elog(ERROR, "unrecognized BufferAccessStrategyType: %d", strategy->btype);
    pg_unreachable();
}

References BAS_BULKREAD, BAS_BULKWRITE, BAS_NORMAL, BAS_VACUUM, BufferAccessStrategyData::btype, elog, ERROR, IOCONTEXT_BULKREAD, IOCONTEXT_BULKWRITE, IOCONTEXT_NORMAL, IOCONTEXT_VACUUM, and pg_unreachable.

Referenced by AsyncReadBuffers(), ExtendBufferedRelShared(), PinBufferForBlock(), and WaitReadBuffers().

StrategyGetBuffer()

BufferDesc * StrategyGetBuffer	(	BufferAccessStrategy	strategy,
		uint32 *	buf_state,
		bool *	from_ring
	)

Definition at line 174 of file freelist.c.

{
    BufferDesc *buf;
    int         bgwprocno;
    int         trycounter;
 
    *from_ring = false;
 
    /*
     * If given a strategy object, see whether it can select a buffer. We
     * assume strategy objects don't need buffer_strategy_lock.
     */
    if (strategy != NULL)
    {
        buf = GetBufferFromRing(strategy, buf_state);
        if (buf != NULL)
        {
            *from_ring = true;
            return buf;
        }
    }
 
    /*
     * If asked, we need to waken the bgwriter. Since we don't want to rely on
     * a spinlock for this we force a read from shared memory once, and then
     * set the latch based on that value. We need to go through that length
     * because otherwise bgwprocno might be reset while/after we check because
     * the compiler might just reread from memory.
     *
     * This can possibly set the latch of the wrong process if the bgwriter
     * dies in the wrong moment. But since PGPROC->procLatch is never
     * deallocated the worst consequence of that is that we set the latch of
     * some arbitrary process.
     */
    bgwprocno = INT_ACCESS_ONCE(StrategyControl->bgwprocno);
    if (bgwprocno != -1)
    {
        /* reset bgwprocno first, before setting the latch */
        StrategyControl->bgwprocno = -1;
 
        /*
         * Not acquiring ProcArrayLock here which is slightly icky. It's
         * actually fine because procLatch isn't ever freed, so we just can
         * potentially set the wrong process' (or no process') latch.
         */
        SetLatch(&ProcGlobal->allProcs[bgwprocno].procLatch);
    }
 
    /*
     * We count buffer allocation requests so that the bgwriter can estimate
     * the rate of buffer consumption.  Note that buffers recycled by a
     * strategy object are intentionally not counted here.
     */
    pg_atomic_fetch_add_u32(&StrategyControl->numBufferAllocs, 1);
 
    /* Use the "clock sweep" algorithm to find a free buffer */
    trycounter = NBuffers;
    for (;;)
    {
        uint32      old_buf_state;
        uint32      local_buf_state;
 
        buf = GetBufferDescriptor(ClockSweepTick());
 
        /*
         * Check whether the buffer can be used and pin it if so. Do this
         * using a CAS loop, to avoid having to lock the buffer header.
         */
        old_buf_state = pg_atomic_read_u32(&buf->state);
        for (;;)
        {
            local_buf_state = old_buf_state;
 
            /*
             * If the buffer is pinned or has a nonzero usage_count, we cannot
             * use it; decrement the usage_count (unless pinned) and keep
             * scanning.
             */
 
            if (BUF_STATE_GET_REFCOUNT(local_buf_state) != 0)
            {
                if (--trycounter == 0)
                {
                    /*
                     * We've scanned all the buffers without making any state
                     * changes, so all the buffers are pinned (or were when we
                     * looked at them). We could hope that someone will free
                     * one eventually, but it's probably better to fail than
                     * to risk getting stuck in an infinite loop.
                     */
                    elog(ERROR, "no unpinned buffers available");
                }
                break;
            }
 
            /* See equivalent code in PinBuffer() */
            if (unlikely(local_buf_state & BM_LOCKED))
            {
                old_buf_state = WaitBufHdrUnlocked(buf);
                continue;
            }
 
            if (BUF_STATE_GET_USAGECOUNT(local_buf_state) != 0)
            {
                local_buf_state -= BUF_USAGECOUNT_ONE;
 
                if (pg_atomic_compare_exchange_u32(&buf->state, &old_buf_state,
                                                   local_buf_state))
                {
                    trycounter = NBuffers;
                    break;
                }
            }
            else
            {
                /* pin the buffer if the CAS succeeds */
                local_buf_state += BUF_REFCOUNT_ONE;
 
                if (pg_atomic_compare_exchange_u32(&buf->state, &old_buf_state,
                                                   local_buf_state))
                {
                    /* Found a usable buffer */
                    if (strategy != NULL)
                        AddBufferToRing(strategy, buf);
                    *buf_state = local_buf_state;
 
                    TrackNewBufferPin(BufferDescriptorGetBuffer(buf));
 
                    return buf;
                }
            }
        }
    }
}

References AddBufferToRing(), PROC_HDR::allProcs, BufferStrategyControl::bgwprocno, BM_LOCKED, buf, BUF_REFCOUNT_ONE, BUF_STATE_GET_REFCOUNT, BUF_STATE_GET_USAGECOUNT, BUF_USAGECOUNT_ONE, BufferDescriptorGetBuffer(), ClockSweepTick(), elog, ERROR, GetBufferDescriptor(), GetBufferFromRing(), INT_ACCESS_ONCE, NBuffers, BufferStrategyControl::numBufferAllocs, pg_atomic_compare_exchange_u32(), pg_atomic_fetch_add_u32(), pg_atomic_read_u32(), ProcGlobal, PGPROC::procLatch, SetLatch(), StrategyControl, TrackNewBufferPin(), unlikely, and WaitBufHdrUnlocked().

Referenced by GetVictimBuffer().

StrategyInitialize()

void StrategyInitialize

(

bool

init

)

Definition at line 401 of file freelist.c.

{
    bool        found;
 
    /*
     * Initialize the shared buffer lookup hashtable.
     *
     * Since we can't tolerate running out of lookup table entries, we must be
     * sure to specify an adequate table size here.  The maximum steady-state
     * usage is of course NBuffers entries, but BufferAlloc() tries to insert
     * a new entry before deleting the old.  In principle this could be
     * happening in each partition concurrently, so we could need as many as
     * NBuffers + NUM_BUFFER_PARTITIONS entries.
     */
    InitBufTable(NBuffers + NUM_BUFFER_PARTITIONS);
 
    /*
     * Get or create the shared strategy control block
     */
    StrategyControl = (BufferStrategyControl *)
        ShmemInitStruct("Buffer Strategy Status",
                        sizeof(BufferStrategyControl),
                        &found);
 
    if (!found)
    {
        /*
         * Only done once, usually in postmaster
         */
        Assert(init);
 
        SpinLockInit(&StrategyControl->buffer_strategy_lock);
 
        /* Initialize the clock-sweep pointer */
        pg_atomic_init_u32(&StrategyControl->nextVictimBuffer, 0);
 
        /* Clear statistics */
        StrategyControl->completePasses = 0;
        pg_atomic_init_u32(&StrategyControl->numBufferAllocs, 0);
 
        /* No pending notification */
        StrategyControl->bgwprocno = -1;
    }
    else
        Assert(!init);
}

References Assert(), BufferStrategyControl::bgwprocno, BufferStrategyControl::buffer_strategy_lock, BufferStrategyControl::completePasses, init, InitBufTable(), NBuffers, BufferStrategyControl::nextVictimBuffer, NUM_BUFFER_PARTITIONS, BufferStrategyControl::numBufferAllocs, pg_atomic_init_u32(), ShmemInitStruct(), SpinLockInit, and StrategyControl.

Referenced by BufferManagerShmemInit().

StrategyNotifyBgWriter()

void StrategyNotifyBgWriter

(

int

bgwprocno

)

Definition at line 358 of file freelist.c.

{
    /*
     * We acquire buffer_strategy_lock just to ensure that the store appears
     * atomic to StrategyGetBuffer.  The bgwriter should call this rather
     * infrequently, so there's no performance penalty from being safe.
     */
    SpinLockAcquire(&StrategyControl->buffer_strategy_lock);
    StrategyControl->bgwprocno = bgwprocno;
    SpinLockRelease(&StrategyControl->buffer_strategy_lock);
}

References BufferStrategyControl::bgwprocno, BufferStrategyControl::buffer_strategy_lock, SpinLockAcquire, SpinLockRelease, and StrategyControl.

Referenced by BackgroundWriterMain().

StrategyRejectBuffer()

bool StrategyRejectBuffer	(	BufferAccessStrategy	strategy,
		BufferDesc *	buf,
		bool	from_ring
	)

Definition at line 787 of file freelist.c.

{
    /* We only do this in bulkread mode */
    if (strategy->btype != BAS_BULKREAD)
        return false;
 
    /* Don't muck with behavior of normal buffer-replacement strategy */
    if (!from_ring ||
        strategy->buffers[strategy->current] != BufferDescriptorGetBuffer(buf))
        return false;
 
    /*
     * Remove the dirty buffer from the ring; necessary to prevent infinite
     * loop if all ring members are dirty.
     */
    strategy->buffers[strategy->current] = InvalidBuffer;
 
    return true;
}

References BAS_BULKREAD, BufferAccessStrategyData::btype, buf, BufferDescriptorGetBuffer(), BufferAccessStrategyData::buffers, BufferAccessStrategyData::current, and InvalidBuffer.

Referenced by GetVictimBuffer().

StrategyShmemSize()

Size StrategyShmemSize

(

void

)

Definition at line 380 of file freelist.c.

{
    Size        size = 0;
 
    /* size of lookup hash table ... see comment in StrategyInitialize */
    size = add_size(size, BufTableShmemSize(NBuffers + NUM_BUFFER_PARTITIONS));
 
    /* size of the shared replacement strategy control block */
    size = add_size(size, MAXALIGN(sizeof(BufferStrategyControl)));
 
    return size;
}

References add_size(), BufTableShmemSize(), MAXALIGN, NBuffers, and NUM_BUFFER_PARTITIONS.

Referenced by BufferManagerShmemSize().

StrategySyncStart()

int StrategySyncStart	(	uint32 *	complete_passes,
		uint32 *	num_buf_alloc
	)

Definition at line 321 of file freelist.c.

{
    uint32      nextVictimBuffer;
    int         result;
 
    SpinLockAcquire(&StrategyControl->buffer_strategy_lock);
    nextVictimBuffer = pg_atomic_read_u32(&StrategyControl->nextVictimBuffer);
    result = nextVictimBuffer % NBuffers;
 
    if (complete_passes)
    {
        *complete_passes = StrategyControl->completePasses;
 
        /*
         * Additionally add the number of wraparounds that happened before
         * completePasses could be incremented. C.f. ClockSweepTick().
         */
        *complete_passes += nextVictimBuffer / NBuffers;
    }
 
    if (num_buf_alloc)
    {
        *num_buf_alloc = pg_atomic_exchange_u32(&StrategyControl->numBufferAllocs, 0);
    }
    SpinLockRelease(&StrategyControl->buffer_strategy_lock);
    return result;
}

References BufferStrategyControl::buffer_strategy_lock, BufferStrategyControl::completePasses, NBuffers, BufferStrategyControl::nextVictimBuffer, BufferStrategyControl::numBufferAllocs, pg_atomic_exchange_u32(), pg_atomic_read_u32(), SpinLockAcquire, SpinLockRelease, and StrategyControl.

Referenced by BgBufferSync().

Variable Documentation

StrategyControl

BufferStrategyControl* StrategyControl = NULL

static

Definition at line 57 of file freelist.c.

Referenced by ClockSweepTick(), StrategyGetBuffer(), StrategyInitialize(), StrategyNotifyBgWriter(), and StrategySyncStart().