buf_internals.h File Reference

#include "port/atomics.h"
#include "storage/buf.h"
#include "storage/bufmgr.h"
#include "storage/condition_variable.h"
#include "storage/latch.h"
#include "storage/lwlock.h"
#include "storage/shmem.h"
#include "storage/smgr.h"
#include "storage/spin.h"
#include "utils/relcache.h"

Include dependency graph for buf_internals.h:

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

Go to the source code of this file.

Data Structures
struct	buftag
struct	BufferDesc
union	BufferDescPadded
struct	PendingWriteback
struct	WritebackContext
struct	CkptSortItem

Macros
#define	BUF_REFCOUNT_ONE   1
#define	BUF_REFCOUNT_MASK   ((1U << 18) - 1)
#define	BUF_USAGECOUNT_MASK   0x003C0000U
#define	BUF_USAGECOUNT_ONE   (1U << 18)
#define	BUF_USAGECOUNT_SHIFT   18
#define	BUF_FLAG_MASK   0xFFC00000U
#define	BUF_STATE_GET_REFCOUNT(state)   ((state) & BUF_REFCOUNT_MASK)
#define	BUF_STATE_GET_USAGECOUNT(state)   (((state) & BUF_USAGECOUNT_MASK) >> BUF_USAGECOUNT_SHIFT)
#define	BM_LOCKED   (1U << 22) /* buffer header is locked */
#define	BM_DIRTY   (1U << 23) /* data needs writing */
#define	BM_VALID   (1U << 24) /* data is valid */
#define	BM_TAG_VALID   (1U << 25) /* tag is assigned */
#define	BM_IO_IN_PROGRESS   (1U << 26) /* read or write in progress */
#define	BM_IO_ERROR   (1U << 27) /* previous I/O failed */
#define	BM_JUST_DIRTIED   (1U << 28) /* dirtied since write started */
#define	BM_PIN_COUNT_WAITER   (1U << 29) /* have waiter for sole pin */
#define	BM_CHECKPOINT_NEEDED   (1U << 30) /* must write for checkpoint */
#define	BM_PERMANENT
#define	BM_MAX_USAGE_COUNT   5
#define	CLEAR_BUFFERTAG(a)
#define	INIT_BUFFERTAG(a, xx_rlocator, xx_forkNum, xx_blockNum)
#define	BUFFERTAGS_EQUAL(a, b)
#define	BufTableHashPartition(hashcode)    ((hashcode) % NUM_BUFFER_PARTITIONS)
#define	BufMappingPartitionLock(hashcode)
#define	BufMappingPartitionLockByIndex(i)    (&MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET + (i)].lock)
#define	BUFFERDESC_PAD_TO_SIZE   (SIZEOF_VOID_P == 8 ? 64 : 1)
#define	GetBufferDescriptor(id)   (&BufferDescriptors[(id)].bufferdesc)
#define	GetLocalBufferDescriptor(id)   (&LocalBufferDescriptors[(id)])
#define	BufferDescriptorGetBuffer(bdesc)   ((bdesc)->buf_id + 1)
#define	BufferDescriptorGetIOCV(bdesc)    (&(BufferIOCVArray[(bdesc)->buf_id]).cv)
#define	BufferDescriptorGetContentLock(bdesc)    ((LWLock*) (&(bdesc)->content_lock))
#define	FREENEXT_END_OF_LIST   (-1)
#define	FREENEXT_NOT_IN_LIST   (-2)
#define	UnlockBufHdr(desc, s)

Typedefs
typedef struct buftag	BufferTag
typedef struct BufferDesc	BufferDesc
typedef union BufferDescPadded	BufferDescPadded
typedef struct PendingWriteback	PendingWriteback
typedef struct WritebackContext	WritebackContext
typedef struct CkptSortItem	CkptSortItem

Functions
uint32	LockBufHdr (BufferDesc *desc)
void	WritebackContextInit (WritebackContext *context, int *max_pending)
void	IssuePendingWritebacks (WritebackContext *context)
void	ScheduleBufferTagForWriteback (WritebackContext *context, BufferTag *tag)
BufferDesc *	StrategyGetBuffer (BufferAccessStrategy strategy, uint32 *buf_state)
void	StrategyFreeBuffer (BufferDesc *buf)
bool	StrategyRejectBuffer (BufferAccessStrategy strategy, BufferDesc *buf)
int	StrategySyncStart (uint32 *complete_passes, uint32 *num_buf_alloc)
void	StrategyNotifyBgWriter (int bgwprocno)
Size	StrategyShmemSize (void)
void	StrategyInitialize (bool init)
bool	have_free_buffer (void)
Size	BufTableShmemSize (int size)
void	InitBufTable (int size)
uint32	BufTableHashCode (BufferTag *tagPtr)
int	BufTableLookup (BufferTag *tagPtr, uint32 hashcode)
int	BufTableInsert (BufferTag *tagPtr, uint32 hashcode, int buf_id)
void	BufTableDelete (BufferTag *tagPtr, uint32 hashcode)
PrefetchBufferResult	PrefetchLocalBuffer (SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum)
BufferDesc *	LocalBufferAlloc (SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum, bool *foundPtr)
void	MarkLocalBufferDirty (Buffer buffer)
void	DropRelFileLocatorLocalBuffers (RelFileLocator rlocator, ForkNumber forkNum, BlockNumber firstDelBlock)
void	DropRelFileLocatorAllLocalBuffers (RelFileLocator rlocator)
void	AtEOXact_LocalBuffers (bool isCommit)

Variables
PGDLLIMPORT ConditionVariableMinimallyPadded *	BufferIOCVArray
PGDLLIMPORT BufferDescPadded *	BufferDescriptors
PGDLLIMPORT WritebackContext	BackendWritebackContext
PGDLLIMPORT BufferDesc *	LocalBufferDescriptors
PGDLLIMPORT CkptSortItem *	CkptBufferIds

Macro Definition Documentation

BM_CHECKPOINT_NEEDED

#define BM_CHECKPOINT_NEEDED   (1U << 30) /* must write for checkpoint */

Definition at line 66 of file buf_internals.h.

BM_DIRTY

#define BM_DIRTY   (1U << 23) /* data needs writing */

Definition at line 59 of file buf_internals.h.

BM_IO_ERROR

#define BM_IO_ERROR   (1U << 27) /* previous I/O failed */

Definition at line 63 of file buf_internals.h.

BM_IO_IN_PROGRESS

#define BM_IO_IN_PROGRESS   (1U << 26) /* read or write in progress */

Definition at line 62 of file buf_internals.h.

BM_JUST_DIRTIED

#define BM_JUST_DIRTIED   (1U << 28) /* dirtied since write started */

Definition at line 64 of file buf_internals.h.

BM_LOCKED

#define BM_LOCKED   (1U << 22) /* buffer header is locked */

Definition at line 58 of file buf_internals.h.

BM_MAX_USAGE_COUNT

#define BM_MAX_USAGE_COUNT   5

Definition at line 76 of file buf_internals.h.

BM_PERMANENT

#define BM_PERMANENT

Value:

                                             (1U << 31) /* permanent buffer (not unlogged,
                                             * or init fork) */

Definition at line 67 of file buf_internals.h.

BM_PIN_COUNT_WAITER

#define BM_PIN_COUNT_WAITER   (1U << 29) /* have waiter for sole pin */

Definition at line 65 of file buf_internals.h.

BM_TAG_VALID

#define BM_TAG_VALID   (1U << 25) /* tag is assigned */

Definition at line 61 of file buf_internals.h.

BM_VALID

#define BM_VALID   (1U << 24) /* data is valid */

Definition at line 60 of file buf_internals.h.

BUF_FLAG_MASK

#define BUF_FLAG_MASK   0xFFC00000U

Definition at line 46 of file buf_internals.h.

BUF_REFCOUNT_MASK

#define BUF_REFCOUNT_MASK   ((1U << 18) - 1)

Definition at line 42 of file buf_internals.h.

BUF_REFCOUNT_ONE

#define BUF_REFCOUNT_ONE   1

Definition at line 41 of file buf_internals.h.

BUF_STATE_GET_REFCOUNT

#define BUF_STATE_GET_REFCOUNT

(

state

)

((state) & BUF_REFCOUNT_MASK)

Definition at line 49 of file buf_internals.h.

BUF_STATE_GET_USAGECOUNT

#define BUF_STATE_GET_USAGECOUNT

(

state

)

(((state) & BUF_USAGECOUNT_MASK) >> BUF_USAGECOUNT_SHIFT)

Definition at line 50 of file buf_internals.h.

BUF_USAGECOUNT_MASK

#define BUF_USAGECOUNT_MASK   0x003C0000U

Definition at line 43 of file buf_internals.h.

BUF_USAGECOUNT_ONE

#define BUF_USAGECOUNT_ONE   (1U << 18)

Definition at line 44 of file buf_internals.h.

BUF_USAGECOUNT_SHIFT

#define BUF_USAGECOUNT_SHIFT   18

Definition at line 45 of file buf_internals.h.

BUFFERDESC_PAD_TO_SIZE

#define BUFFERDESC_PAD_TO_SIZE   (SIZEOF_VOID_P == 8 ? 64 : 1)

Definition at line 214 of file buf_internals.h.

BufferDescriptorGetBuffer

#define BufferDescriptorGetBuffer

(

bdesc

)

((bdesc)->buf_id + 1)

Definition at line 225 of file buf_internals.h.

BufferDescriptorGetContentLock

#define BufferDescriptorGetContentLock

(

bdesc

)

((LWLock*) (&(bdesc)->content_lock))

Definition at line 229 of file buf_internals.h.

BufferDescriptorGetIOCV

#define BufferDescriptorGetIOCV

(

bdesc

)

(&(BufferIOCVArray[(bdesc)->buf_id]).cv)

Definition at line 227 of file buf_internals.h.

BUFFERTAGS_EQUAL

#define BUFFERTAGS_EQUAL	(		a,
			b
	)

Value:

( \
    RelFileLocatorEquals((a).rlocator, (b).rlocator) && \
    (a).blockNum == (b).blockNum && \
    (a).forkNum == (b).forkNum \
)

Definition at line 113 of file buf_internals.h.

BufMappingPartitionLock

#define BufMappingPartitionLock

(

hashcode

)

Value:

    (&MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET + \
        BufTableHashPartition(hashcode)].lock)

Definition at line 128 of file buf_internals.h.

BufMappingPartitionLockByIndex

#define BufMappingPartitionLockByIndex

(

i

)

(&MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET + (i)].lock)

Definition at line 131 of file buf_internals.h.

BufTableHashPartition

#define BufTableHashPartition

(

hashcode

)

((hashcode) % NUM_BUFFER_PARTITIONS)

Definition at line 126 of file buf_internals.h.

CLEAR_BUFFERTAG

#define CLEAR_BUFFERTAG

(

a

)

Value:

( \
    (a).rlocator.spcOid = InvalidOid, \
    (a).rlocator.dbOid = InvalidOid, \
    (a).rlocator.relNumber = InvalidRelFileNumber, \
    (a).forkNum = InvalidForkNumber, \
    (a).blockNum = InvalidBlockNumber \
)

Definition at line 97 of file buf_internals.h.

FREENEXT_END_OF_LIST

#define FREENEXT_END_OF_LIST   (-1)

Definition at line 238 of file buf_internals.h.

FREENEXT_NOT_IN_LIST

#define FREENEXT_NOT_IN_LIST   (-2)

Definition at line 239 of file buf_internals.h.

GetBufferDescriptor

#define GetBufferDescriptor

(

id

)

(&BufferDescriptors[(id)].bufferdesc)

Definition at line 222 of file buf_internals.h.

GetLocalBufferDescriptor

#define GetLocalBufferDescriptor

(

id

)

(&LocalBufferDescriptors[(id)])

Definition at line 223 of file buf_internals.h.

INIT_BUFFERTAG

#define INIT_BUFFERTAG	(		a,
			xx_rlocator,
			xx_forkNum,
			xx_blockNum
	)

Value:

( \
    (a).rlocator = (xx_rlocator), \
    (a).forkNum = (xx_forkNum), \
    (a).blockNum = (xx_blockNum) \
)

Definition at line 106 of file buf_internals.h.

UnlockBufHdr

#define UnlockBufHdr	(		desc,
			s
	)

Value:

    do {    \
        pg_write_barrier(); \
        pg_atomic_write_u32(&(desc)->state, (s) & (~BM_LOCKED)); \
    } while (0)

Definition at line 246 of file buf_internals.h.

Typedef Documentation

BufferDesc

typedef struct BufferDesc BufferDesc

BufferDescPadded

typedef union BufferDescPadded BufferDescPadded

BufferTag

typedef struct buftag BufferTag

CkptSortItem

typedef struct CkptSortItem CkptSortItem

PendingWriteback

typedef struct PendingWriteback PendingWriteback

WritebackContext

typedef struct WritebackContext WritebackContext

Function Documentation

AtEOXact_LocalBuffers()

void AtEOXact_LocalBuffers

(

bool

isCommit

)

Definition at line 577 of file localbuf.c.

{
    CheckForLocalBufferLeaks();
}

References CheckForLocalBufferLeaks().

Referenced by AtEOXact_Buffers().

BufTableDelete()

void BufTableDelete	(	BufferTag *	tagPtr,
		uint32	hashcode
	)

Definition at line 149 of file buf_table.c.

{
    BufferLookupEnt *result;
 
    result = (BufferLookupEnt *)
        hash_search_with_hash_value(SharedBufHash,
                                    (void *) tagPtr,
                                    hashcode,
                                    HASH_REMOVE,
                                    NULL);
 
    if (!result)                /* shouldn't happen */
        elog(ERROR, "shared buffer hash table corrupted");
}

References elog(), ERROR, HASH_REMOVE, hash_search_with_hash_value(), and SharedBufHash.

Referenced by BufferAlloc(), and InvalidateBuffer().

BufTableHashCode()

uint32 BufTableHashCode

(

BufferTag *

tagPtr

)

Definition at line 79 of file buf_table.c.

{
    return get_hash_value(SharedBufHash, (void *) tagPtr);
}

References get_hash_value(), and SharedBufHash.

Referenced by BufferAlloc(), FindAndDropRelFileLocatorBuffers(), InvalidateBuffer(), and PrefetchSharedBuffer().

BufTableInsert()

int BufTableInsert	(	BufferTag *	tagPtr,
		uint32	hashcode,
		int	buf_id
	)

Definition at line 119 of file buf_table.c.

{
    BufferLookupEnt *result;
    bool        found;
 
    Assert(buf_id >= 0);        /* -1 is reserved for not-in-table */
    Assert(tagPtr->blockNum != P_NEW);  /* invalid tag */
 
    result = (BufferLookupEnt *)
        hash_search_with_hash_value(SharedBufHash,
                                    (void *) tagPtr,
                                    hashcode,
                                    HASH_ENTER,
                                    &found);
 
    if (found)                  /* found something already in the table */
        return result->id;
 
    result->id = buf_id;
 
    return -1;
}

References Assert(), buftag::blockNum, HASH_ENTER, hash_search_with_hash_value(), BufferLookupEnt::id, P_NEW, and SharedBufHash.

Referenced by BufferAlloc().

BufTableLookup()

int BufTableLookup	(	BufferTag *	tagPtr,
		uint32	hashcode
	)

Definition at line 91 of file buf_table.c.

{
    BufferLookupEnt *result;
 
    result = (BufferLookupEnt *)
        hash_search_with_hash_value(SharedBufHash,
                                    (void *) tagPtr,
                                    hashcode,
                                    HASH_FIND,
                                    NULL);
 
    if (!result)
        return -1;
 
    return result->id;
}

References HASH_FIND, hash_search_with_hash_value(), BufferLookupEnt::id, and SharedBufHash.

Referenced by BufferAlloc(), FindAndDropRelFileLocatorBuffers(), and PrefetchSharedBuffer().

BufTableShmemSize()

Size BufTableShmemSize

(

int

size

)

Definition at line 42 of file buf_table.c.

{
    return hash_estimate_size(size, sizeof(BufferLookupEnt));
}

References hash_estimate_size().

Referenced by StrategyShmemSize().

DropRelFileLocatorAllLocalBuffers()

void DropRelFileLocatorAllLocalBuffers

(

RelFileLocator

rlocator

)

Definition at line 373 of file localbuf.c.

{
    int         i;
 
    for (i = 0; i < NLocBuffer; i++)
    {
        BufferDesc *bufHdr = GetLocalBufferDescriptor(i);
        LocalBufferLookupEnt *hresult;
        uint32      buf_state;
 
        buf_state = pg_atomic_read_u32(&bufHdr->state);
 
        if ((buf_state & BM_TAG_VALID) &&
            RelFileLocatorEquals(bufHdr->tag.rlocator, rlocator))
        {
            if (LocalRefCount[i] != 0)
                elog(ERROR, "block %u of %s is still referenced (local %u)",
                     bufHdr->tag.blockNum,
                     relpathbackend(bufHdr->tag.rlocator, MyBackendId,
                                    bufHdr->tag.forkNum),
                     LocalRefCount[i]);
            /* Remove entry from hashtable */
            hresult = (LocalBufferLookupEnt *)
                hash_search(LocalBufHash, (void *) &bufHdr->tag,
                            HASH_REMOVE, NULL);
            if (!hresult)       /* shouldn't happen */
                elog(ERROR, "local buffer hash table corrupted");
            /* Mark buffer invalid */
            CLEAR_BUFFERTAG(bufHdr->tag);
            buf_state &= ~BUF_FLAG_MASK;
            buf_state &= ~BUF_USAGECOUNT_MASK;
            pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
        }
    }
}

References buftag::blockNum, BM_TAG_VALID, BUF_FLAG_MASK, BUF_USAGECOUNT_MASK, CLEAR_BUFFERTAG, elog(), ERROR, buftag::forkNum, GetLocalBufferDescriptor, HASH_REMOVE, hash_search(), i, LocalBufHash, LocalRefCount, MyBackendId, NLocBuffer, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), RelFileLocatorEquals, relpathbackend, buftag::rlocator, BufferDesc::state, and BufferDesc::tag.

Referenced by DropRelFileLocatorsAllBuffers().

DropRelFileLocatorLocalBuffers()

void DropRelFileLocatorLocalBuffers	(	RelFileLocator	rlocator,
		ForkNumber	forkNum,
		BlockNumber	firstDelBlock
	)

Definition at line 326 of file localbuf.c.

{
    int         i;
 
    for (i = 0; i < NLocBuffer; i++)
    {
        BufferDesc *bufHdr = GetLocalBufferDescriptor(i);
        LocalBufferLookupEnt *hresult;
        uint32      buf_state;
 
        buf_state = pg_atomic_read_u32(&bufHdr->state);
 
        if ((buf_state & BM_TAG_VALID) &&
            RelFileLocatorEquals(bufHdr->tag.rlocator, rlocator) &&
            bufHdr->tag.forkNum == forkNum &&
            bufHdr->tag.blockNum >= firstDelBlock)
        {
            if (LocalRefCount[i] != 0)
                elog(ERROR, "block %u of %s is still referenced (local %u)",
                     bufHdr->tag.blockNum,
                     relpathbackend(bufHdr->tag.rlocator, MyBackendId,
                                    bufHdr->tag.forkNum),
                     LocalRefCount[i]);
            /* Remove entry from hashtable */
            hresult = (LocalBufferLookupEnt *)
                hash_search(LocalBufHash, (void *) &bufHdr->tag,
                            HASH_REMOVE, NULL);
            if (!hresult)       /* shouldn't happen */
                elog(ERROR, "local buffer hash table corrupted");
            /* Mark buffer invalid */
            CLEAR_BUFFERTAG(bufHdr->tag);
            buf_state &= ~BUF_FLAG_MASK;
            buf_state &= ~BUF_USAGECOUNT_MASK;
            pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
        }
    }
}

References buftag::blockNum, BM_TAG_VALID, BUF_FLAG_MASK, BUF_USAGECOUNT_MASK, CLEAR_BUFFERTAG, elog(), ERROR, buftag::forkNum, GetLocalBufferDescriptor, HASH_REMOVE, hash_search(), i, LocalBufHash, LocalRefCount, MyBackendId, NLocBuffer, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), RelFileLocatorEquals, relpathbackend, buftag::rlocator, BufferDesc::state, and BufferDesc::tag.

Referenced by DropRelFileLocatorBuffers().

have_free_buffer()

bool have_free_buffer

(

void

)

Definition at line 180 of file freelist.c.

{
    if (StrategyControl->firstFreeBuffer >= 0)
        return true;
    else
        return false;
}

References BufferStrategyControl::firstFreeBuffer, and StrategyControl.

Referenced by apw_load_buffers(), and autoprewarm_database_main().

InitBufTable()

void InitBufTable

(

int

size

)

Definition at line 52 of file buf_table.c.

{
    HASHCTL     info;
 
    /* assume no locking is needed yet */
 
    /* BufferTag maps to Buffer */
    info.keysize = sizeof(BufferTag);
    info.entrysize = sizeof(BufferLookupEnt);
    info.num_partitions = NUM_BUFFER_PARTITIONS;
 
    SharedBufHash = ShmemInitHash("Shared Buffer Lookup Table",
                                  size, size,
                                  &info,
                                  HASH_ELEM | HASH_BLOBS | HASH_PARTITION);
}

References HASHCTL::entrysize, HASH_BLOBS, HASH_ELEM, HASH_PARTITION, HASHCTL::keysize, NUM_BUFFER_PARTITIONS, HASHCTL::num_partitions, SharedBufHash, and ShmemInitHash().

Referenced by StrategyInitialize().

IssuePendingWritebacks()

void IssuePendingWritebacks

(

WritebackContext *

context

)

Definition at line 4924 of file bufmgr.c.

{
    int         i;
 
    if (context->nr_pending == 0)
        return;
 
    /*
     * Executing the writes in-order can make them a lot faster, and allows to
     * merge writeback requests to consecutive blocks into larger writebacks.
     */
    sort_pending_writebacks(context->pending_writebacks, context->nr_pending);
 
    /*
     * Coalesce neighbouring writes, but nothing else. For that we iterate
     * through the, now sorted, array of pending flushes, and look forward to
     * find all neighbouring (or identical) writes.
     */
    for (i = 0; i < context->nr_pending; i++)
    {
        PendingWriteback *cur;
        PendingWriteback *next;
        SMgrRelation reln;
        int         ahead;
        BufferTag   tag;
        Size        nblocks = 1;
 
        cur = &context->pending_writebacks[i];
        tag = cur->tag;
 
        /*
         * Peek ahead, into following writeback requests, to see if they can
         * be combined with the current one.
         */
        for (ahead = 0; i + ahead + 1 < context->nr_pending; ahead++)
        {
            next = &context->pending_writebacks[i + ahead + 1];
 
            /* different file, stop */
            if (!RelFileLocatorEquals(cur->tag.rlocator, next->tag.rlocator) ||
                cur->tag.forkNum != next->tag.forkNum)
                break;
 
            /* ok, block queued twice, skip */
            if (cur->tag.blockNum == next->tag.blockNum)
                continue;
 
            /* only merge consecutive writes */
            if (cur->tag.blockNum + 1 != next->tag.blockNum)
                break;
 
            nblocks++;
            cur = next;
        }
 
        i += ahead;
 
        /* and finally tell the kernel to write the data to storage */
        reln = smgropen(tag.rlocator, InvalidBackendId);
        smgrwriteback(reln, tag.forkNum, tag.blockNum, nblocks);
    }
 
    context->nr_pending = 0;
}

References buftag::blockNum, cur, buftag::forkNum, i, InvalidBackendId, next, WritebackContext::nr_pending, WritebackContext::pending_writebacks, RelFileLocatorEquals, buftag::rlocator, smgropen(), and smgrwriteback().

Referenced by BufferSync(), and ScheduleBufferTagForWriteback().

LocalBufferAlloc()

BufferDesc* LocalBufferAlloc	(	SMgrRelation	smgr,
		ForkNumber	forkNum,
		BlockNumber	blockNum,
		bool *	foundPtr
	)

Definition at line 109 of file localbuf.c.

{
    BufferTag   newTag;         /* identity of requested block */
    LocalBufferLookupEnt *hresult;
    BufferDesc *bufHdr;
    int         b;
    int         trycounter;
    bool        found;
    uint32      buf_state;
 
    INIT_BUFFERTAG(newTag, smgr->smgr_rlocator.locator, forkNum, blockNum);
 
    /* Initialize local buffers if first request in this session */
    if (LocalBufHash == NULL)
        InitLocalBuffers();
 
    /* See if the desired buffer already exists */
    hresult = (LocalBufferLookupEnt *)
        hash_search(LocalBufHash, (void *) &newTag, HASH_FIND, NULL);
 
    if (hresult)
    {
        b = hresult->id;
        bufHdr = GetLocalBufferDescriptor(b);
        Assert(BUFFERTAGS_EQUAL(bufHdr->tag, newTag));
#ifdef LBDEBUG
        fprintf(stderr, "LB ALLOC (%u,%d,%d) %d\n",
                smgr->smgr_rlocator.locator.relNumber, forkNum, blockNum, -b - 1);
#endif
        buf_state = pg_atomic_read_u32(&bufHdr->state);
 
        /* this part is equivalent to PinBuffer for a shared buffer */
        if (LocalRefCount[b] == 0)
        {
            if (BUF_STATE_GET_USAGECOUNT(buf_state) < BM_MAX_USAGE_COUNT)
            {
                buf_state += BUF_USAGECOUNT_ONE;
                pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
            }
        }
        LocalRefCount[b]++;
        ResourceOwnerRememberBuffer(CurrentResourceOwner,
                                    BufferDescriptorGetBuffer(bufHdr));
        if (buf_state & BM_VALID)
            *foundPtr = true;
        else
        {
            /* Previous read attempt must have failed; try again */
            *foundPtr = false;
        }
        return bufHdr;
    }
 
#ifdef LBDEBUG
    fprintf(stderr, "LB ALLOC (%u,%d,%d) %d\n",
            smgr->smgr_rlocator.locator.relNumber, forkNum, blockNum,
            -nextFreeLocalBuf - 1);
#endif
 
    /*
     * Need to get a new buffer.  We use a clock sweep algorithm (essentially
     * the same as what freelist.c does now...)
     */
    trycounter = NLocBuffer;
    for (;;)
    {
        b = nextFreeLocalBuf;
 
        if (++nextFreeLocalBuf >= NLocBuffer)
            nextFreeLocalBuf = 0;
 
        bufHdr = GetLocalBufferDescriptor(b);
 
        if (LocalRefCount[b] == 0)
        {
            buf_state = pg_atomic_read_u32(&bufHdr->state);
 
            if (BUF_STATE_GET_USAGECOUNT(buf_state) > 0)
            {
                buf_state -= BUF_USAGECOUNT_ONE;
                pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
                trycounter = NLocBuffer;
            }
            else
            {
                /* Found a usable buffer */
                LocalRefCount[b]++;
                ResourceOwnerRememberBuffer(CurrentResourceOwner,
                                            BufferDescriptorGetBuffer(bufHdr));
                break;
            }
        }
        else if (--trycounter == 0)
            ereport(ERROR,
                    (errcode(ERRCODE_INSUFFICIENT_RESOURCES),
                     errmsg("no empty local buffer available")));
    }
 
    /*
     * this buffer is not referenced but it might still be dirty. if that's
     * the case, write it out before reusing it!
     */
    if (buf_state & BM_DIRTY)
    {
        SMgrRelation oreln;
        Page        localpage = (char *) LocalBufHdrGetBlock(bufHdr);
 
        /* Find smgr relation for buffer */
        oreln = smgropen(bufHdr->tag.rlocator, MyBackendId);
 
        PageSetChecksumInplace(localpage, bufHdr->tag.blockNum);
 
        /* And write... */
        smgrwrite(oreln,
                  bufHdr->tag.forkNum,
                  bufHdr->tag.blockNum,
                  localpage,
                  false);
 
        /* Mark not-dirty now in case we error out below */
        buf_state &= ~BM_DIRTY;
        pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
 
        pgBufferUsage.local_blks_written++;
    }
 
    /*
     * lazy memory allocation: allocate space on first use of a buffer.
     */
    if (LocalBufHdrGetBlock(bufHdr) == NULL)
    {
        /* Set pointer for use by BufferGetBlock() macro */
        LocalBufHdrGetBlock(bufHdr) = GetLocalBufferStorage();
    }
 
    /*
     * Update the hash table: remove old entry, if any, and make new one.
     */
    if (buf_state & BM_TAG_VALID)
    {
        hresult = (LocalBufferLookupEnt *)
            hash_search(LocalBufHash, (void *) &bufHdr->tag,
                        HASH_REMOVE, NULL);
        if (!hresult)           /* shouldn't happen */
            elog(ERROR, "local buffer hash table corrupted");
        /* mark buffer invalid just in case hash insert fails */
        CLEAR_BUFFERTAG(bufHdr->tag);
        buf_state &= ~(BM_VALID | BM_TAG_VALID);
        pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
    }
 
    hresult = (LocalBufferLookupEnt *)
        hash_search(LocalBufHash, (void *) &newTag, HASH_ENTER, &found);
    if (found)                  /* shouldn't happen */
        elog(ERROR, "local buffer hash table corrupted");
    hresult->id = b;
 
    /*
     * it's all ours now.
     */
    bufHdr->tag = newTag;
    buf_state &= ~(BM_VALID | BM_DIRTY | BM_JUST_DIRTIED | BM_IO_ERROR);
    buf_state |= BM_TAG_VALID;
    buf_state &= ~BUF_USAGECOUNT_MASK;
    buf_state += BUF_USAGECOUNT_ONE;
    pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
 
    *foundPtr = false;
    return bufHdr;
}

References Assert(), b, buftag::blockNum, BM_DIRTY, BM_IO_ERROR, BM_JUST_DIRTIED, BM_MAX_USAGE_COUNT, BM_TAG_VALID, BM_VALID, BUF_STATE_GET_USAGECOUNT, BUF_USAGECOUNT_MASK, BUF_USAGECOUNT_ONE, BufferDescriptorGetBuffer, BUFFERTAGS_EQUAL, CLEAR_BUFFERTAG, CurrentResourceOwner, elog(), ereport, errcode(), errmsg(), ERROR, buftag::forkNum, fprintf, GetLocalBufferDescriptor, GetLocalBufferStorage(), HASH_ENTER, HASH_FIND, HASH_REMOVE, hash_search(), LocalBufferLookupEnt::id, INIT_BUFFERTAG, InitLocalBuffers(), BufferUsage::local_blks_written, LocalBufHash, LocalBufHdrGetBlock, LocalRefCount, RelFileLocatorBackend::locator, MyBackendId, nextFreeLocalBuf, NLocBuffer, PageSetChecksumInplace(), pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), pgBufferUsage, RelFileLocator::relNumber, ResourceOwnerRememberBuffer(), buftag::rlocator, SMgrRelationData::smgr_rlocator, smgropen(), smgrwrite(), BufferDesc::state, and BufferDesc::tag.

Referenced by ReadBuffer_common().

LockBufHdr()

uint32 LockBufHdr

(

BufferDesc *

desc

)

Definition at line 4736 of file bufmgr.c.

{
    SpinDelayStatus delayStatus;
    uint32      old_buf_state;
 
    init_local_spin_delay(&delayStatus);
 
    while (true)
    {
        /* set BM_LOCKED flag */
        old_buf_state = pg_atomic_fetch_or_u32(&desc->state, BM_LOCKED);
        /* if it wasn't set before we're OK */
        if (!(old_buf_state & BM_LOCKED))
            break;
        perform_spin_delay(&delayStatus);
    }
    finish_spin_delay(&delayStatus);
    return old_buf_state | BM_LOCKED;
}

References BM_LOCKED, finish_spin_delay(), init_local_spin_delay, perform_spin_delay(), pg_atomic_fetch_or_u32(), and BufferDesc::state.

Referenced by AbortBufferIO(), apw_dump_now(), BufferAlloc(), BufferGetLSNAtomic(), BufferSync(), ConditionalLockBufferForCleanup(), DropDatabaseBuffers(), DropRelFileLocatorBuffers(), DropRelFileLocatorsAllBuffers(), FindAndDropRelFileLocatorBuffers(), FlushBuffer(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetBufferFromRing(), InvalidateBuffer(), IsBufferCleanupOK(), LockBufferForCleanup(), MarkBufferDirtyHint(), pg_buffercache_pages(), ReadBuffer_common(), ReadRecentBuffer(), StartBufferIO(), StrategyGetBuffer(), SyncOneBuffer(), TerminateBufferIO(), UnlockBuffers(), UnpinBuffer(), and WaitIO().

MarkLocalBufferDirty()

void MarkLocalBufferDirty

(

Buffer

buffer

)

Definition at line 286 of file localbuf.c.

{
    int         bufid;
    BufferDesc *bufHdr;
    uint32      buf_state;
 
    Assert(BufferIsLocal(buffer));
 
#ifdef LBDEBUG
    fprintf(stderr, "LB DIRTY %d\n", buffer);
#endif
 
    bufid = -(buffer + 1);
 
    Assert(LocalRefCount[bufid] > 0);
 
    bufHdr = GetLocalBufferDescriptor(bufid);
 
    buf_state = pg_atomic_read_u32(&bufHdr->state);
 
    if (!(buf_state & BM_DIRTY))
        pgBufferUsage.local_blks_dirtied++;
 
    buf_state |= BM_DIRTY;
 
    pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
}

References Assert(), BM_DIRTY, BufferIsLocal, fprintf, GetLocalBufferDescriptor, BufferUsage::local_blks_dirtied, LocalRefCount, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), pgBufferUsage, and BufferDesc::state.

Referenced by MarkBufferDirty(), and MarkBufferDirtyHint().

PrefetchLocalBuffer()

PrefetchBufferResult PrefetchLocalBuffer	(	SMgrRelation	smgr,
		ForkNumber	forkNum,
		BlockNumber	blockNum
	)

Definition at line 64 of file localbuf.c.

{
    PrefetchBufferResult result = {InvalidBuffer, false};
    BufferTag   newTag;         /* identity of requested block */
    LocalBufferLookupEnt *hresult;
 
    INIT_BUFFERTAG(newTag, smgr->smgr_rlocator.locator, forkNum, blockNum);
 
    /* Initialize local buffers if first request in this session */
    if (LocalBufHash == NULL)
        InitLocalBuffers();
 
    /* See if the desired buffer already exists */
    hresult = (LocalBufferLookupEnt *)
        hash_search(LocalBufHash, (void *) &newTag, HASH_FIND, NULL);
 
    if (hresult)
    {
        /* Yes, so nothing to do */
        result.recent_buffer = -hresult->id - 1;
    }
    else
    {
#ifdef USE_PREFETCH
        /* Not in buffers, so initiate prefetch */
        smgrprefetch(smgr, forkNum, blockNum);
        result.initiated_io = true;
#endif                          /* USE_PREFETCH */
    }
 
    return result;
}

References HASH_FIND, hash_search(), LocalBufferLookupEnt::id, INIT_BUFFERTAG, PrefetchBufferResult::initiated_io, InitLocalBuffers(), InvalidBuffer, LocalBufHash, RelFileLocatorBackend::locator, PrefetchBufferResult::recent_buffer, SMgrRelationData::smgr_rlocator, and smgrprefetch().

Referenced by PrefetchBuffer().

ScheduleBufferTagForWriteback()

void ScheduleBufferTagForWriteback	(	WritebackContext *	context,
		BufferTag *	tag
	)

Definition at line 4883 of file bufmgr.c.

{
    PendingWriteback *pending;
 
    /*
     * Add buffer to the pending writeback array, unless writeback control is
     * disabled.
     */
    if (*context->max_pending > 0)
    {
        Assert(*context->max_pending <= WRITEBACK_MAX_PENDING_FLUSHES);
 
        pending = &context->pending_writebacks[context->nr_pending++];
 
        pending->tag = *tag;
    }
 
    /*
     * Perform pending flushes if the writeback limit is exceeded. This
     * includes the case where previously an item has been added, but control
     * is now disabled.
     */
    if (context->nr_pending >= *context->max_pending)
        IssuePendingWritebacks(context);
}

References Assert(), IssuePendingWritebacks(), WritebackContext::max_pending, WritebackContext::nr_pending, WritebackContext::pending_writebacks, PendingWriteback::tag, and WRITEBACK_MAX_PENDING_FLUSHES.

Referenced by BufferAlloc(), and SyncOneBuffer().

StrategyFreeBuffer()

void StrategyFreeBuffer

(

BufferDesc *

buf

)

Definition at line 363 of file freelist.c.

{
    SpinLockAcquire(&StrategyControl->buffer_strategy_lock);
 
    /*
     * It is possible that we are told to put something in the freelist that
     * is already in it; don't screw up the list if so.
     */
    if (buf->freeNext == FREENEXT_NOT_IN_LIST)
    {
        buf->freeNext = StrategyControl->firstFreeBuffer;
        if (buf->freeNext < 0)
            StrategyControl->lastFreeBuffer = buf->buf_id;
        StrategyControl->firstFreeBuffer = buf->buf_id;
    }
 
    SpinLockRelease(&StrategyControl->buffer_strategy_lock);
}

References buf, BufferStrategyControl::buffer_strategy_lock, BufferStrategyControl::firstFreeBuffer, FREENEXT_NOT_IN_LIST, BufferStrategyControl::lastFreeBuffer, SpinLockAcquire, SpinLockRelease, and StrategyControl.

Referenced by InvalidateBuffer().

StrategyGetBuffer()

BufferDesc* StrategyGetBuffer	(	BufferAccessStrategy	strategy,
		uint32 *	buf_state
	)

Definition at line 201 of file freelist.c.

{
    BufferDesc *buf;
    int         bgwprocno;
    int         trycounter;
    uint32      local_buf_state;    /* to avoid repeated (de-)referencing */
 
    /*
     * 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)
            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);
 
    /*
     * First check, without acquiring the lock, whether there's buffers in the
     * freelist. Since we otherwise don't require the spinlock in every
     * StrategyGetBuffer() invocation, it'd be sad to acquire it here -
     * uselessly in most cases. That obviously leaves a race where a buffer is
     * put on the freelist but we don't see the store yet - but that's pretty
     * harmless, it'll just get used during the next buffer acquisition.
     *
     * If there's buffers on the freelist, acquire the spinlock to pop one
     * buffer of the freelist. Then check whether that buffer is usable and
     * repeat if not.
     *
     * Note that the freeNext fields are considered to be protected by the
     * buffer_strategy_lock not the individual buffer spinlocks, so it's OK to
     * manipulate them without holding the spinlock.
     */
    if (StrategyControl->firstFreeBuffer >= 0)
    {
        while (true)
        {
            /* Acquire the spinlock to remove element from the freelist */
            SpinLockAcquire(&StrategyControl->buffer_strategy_lock);
 
            if (StrategyControl->firstFreeBuffer < 0)
            {
                SpinLockRelease(&StrategyControl->buffer_strategy_lock);
                break;
            }
 
            buf = GetBufferDescriptor(StrategyControl->firstFreeBuffer);
            Assert(buf->freeNext != FREENEXT_NOT_IN_LIST);
 
            /* Unconditionally remove buffer from freelist */
            StrategyControl->firstFreeBuffer = buf->freeNext;
            buf->freeNext = FREENEXT_NOT_IN_LIST;
 
            /*
             * Release the lock so someone else can access the freelist while
             * we check out this buffer.
             */
            SpinLockRelease(&StrategyControl->buffer_strategy_lock);
 
            /*
             * If the buffer is pinned or has a nonzero usage_count, we cannot
             * use it; discard it and retry.  (This can only happen if VACUUM
             * put a valid buffer in the freelist and then someone else used
             * it before we got to it.  It's probably impossible altogether as
             * of 8.3, but we'd better check anyway.)
             */
            local_buf_state = LockBufHdr(buf);
            if (BUF_STATE_GET_REFCOUNT(local_buf_state) == 0
                && BUF_STATE_GET_USAGECOUNT(local_buf_state) == 0)
            {
                if (strategy != NULL)
                    AddBufferToRing(strategy, buf);
                *buf_state = local_buf_state;
                return buf;
            }
            UnlockBufHdr(buf, local_buf_state);
        }
    }
 
    /* Nothing on the freelist, so run the "clock sweep" algorithm */
    trycounter = NBuffers;
    for (;;)
    {
        buf = GetBufferDescriptor(ClockSweepTick());
 
        /*
         * If the buffer is pinned or has a nonzero usage_count, we cannot use
         * it; decrement the usage_count (unless pinned) and keep scanning.
         */
        local_buf_state = LockBufHdr(buf);
 
        if (BUF_STATE_GET_REFCOUNT(local_buf_state) == 0)
        {
            if (BUF_STATE_GET_USAGECOUNT(local_buf_state) != 0)
            {
                local_buf_state -= BUF_USAGECOUNT_ONE;
 
                trycounter = NBuffers;
            }
            else
            {
                /* Found a usable buffer */
                if (strategy != NULL)
                    AddBufferToRing(strategy, buf);
                *buf_state = local_buf_state;
                return buf;
            }
        }
        else 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.
             */
            UnlockBufHdr(buf, local_buf_state);
            elog(ERROR, "no unpinned buffers available");
        }
        UnlockBufHdr(buf, local_buf_state);
    }
}

References AddBufferToRing(), PROC_HDR::allProcs, Assert(), BufferStrategyControl::bgwprocno, buf, BUF_STATE_GET_REFCOUNT, BUF_STATE_GET_USAGECOUNT, BUF_USAGECOUNT_ONE, BufferStrategyControl::buffer_strategy_lock, ClockSweepTick(), elog(), ERROR, BufferStrategyControl::firstFreeBuffer, FREENEXT_NOT_IN_LIST, GetBufferDescriptor, GetBufferFromRing(), INT_ACCESS_ONCE, LockBufHdr(), NBuffers, BufferStrategyControl::numBufferAllocs, pg_atomic_fetch_add_u32(), ProcGlobal, PGPROC::procLatch, SetLatch(), SpinLockAcquire, SpinLockRelease, StrategyControl, and UnlockBufHdr.

Referenced by BufferAlloc().

StrategyInitialize()

void StrategyInitialize

(

bool

init

)

Definition at line 474 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);
 
        /*
         * Grab the whole linked list of free buffers for our strategy. We
         * assume it was previously set up by InitBufferPool().
         */
        StrategyControl->firstFreeBuffer = 0;
        StrategyControl->lastFreeBuffer = NBuffers - 1;
 
        /* 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, BufferStrategyControl::firstFreeBuffer, init, InitBufTable(), BufferStrategyControl::lastFreeBuffer, NBuffers, BufferStrategyControl::nextVictimBuffer, NUM_BUFFER_PARTITIONS, BufferStrategyControl::numBufferAllocs, pg_atomic_init_u32(), ShmemInitStruct(), SpinLockInit, and StrategyControl.

Referenced by InitBufferPool().

StrategyNotifyBgWriter()

void StrategyNotifyBgWriter

(

int

bgwprocno

)

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

Definition at line 685 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 (!strategy->current_was_in_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, BufferAccessStrategyData::current_was_in_ring, and InvalidBuffer.

Referenced by BufferAlloc().

StrategyShmemSize()

Size StrategyShmemSize

(

void

)

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

StrategySyncStart()

int StrategySyncStart	(	uint32 *	complete_passes,
		uint32 *	num_buf_alloc
	)

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

WritebackContextInit()

void WritebackContextInit	(	WritebackContext *	context,
		int *	max_pending
	)

Definition at line 4871 of file bufmgr.c.

{
    Assert(*max_pending <= WRITEBACK_MAX_PENDING_FLUSHES);
 
    context->max_pending = max_pending;
    context->nr_pending = 0;
}

References Assert(), WritebackContext::max_pending, WritebackContext::nr_pending, and WRITEBACK_MAX_PENDING_FLUSHES.

Referenced by BackgroundWriterMain(), BufferSync(), and InitBufferPool().

Variable Documentation

BackendWritebackContext

PGDLLIMPORT WritebackContext BackendWritebackContext

extern

Definition at line 24 of file buf_init.c.

Referenced by BufferAlloc(), and InitBufferPool().

BufferDescriptors

PGDLLIMPORT BufferDescPadded* BufferDescriptors

extern

Definition at line 21 of file buf_init.c.

Referenced by InitBufferPool().

BufferIOCVArray

PGDLLIMPORT ConditionVariableMinimallyPadded* BufferIOCVArray

extern

Definition at line 23 of file buf_init.c.

Referenced by InitBufferPool().

CkptBufferIds

PGDLLIMPORT CkptSortItem* CkptBufferIds

extern

Definition at line 25 of file buf_init.c.

Referenced by BufferSync(), and InitBufferPool().

LocalBufferDescriptors

PGDLLIMPORT BufferDesc* LocalBufferDescriptors

extern

Definition at line 43 of file localbuf.c.

Referenced by InitLocalBuffers().