buf_internals.h File Reference

#include "pgstat.h"
#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 "utils/resowner.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	BUFFERDESC_PAD_TO_SIZE   (SIZEOF_VOID_P == 8 ? 64 : 1)
#define	FREENEXT_END_OF_LIST   (-1)
#define	FREENEXT_NOT_IN_LIST   (-2)

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
static RelFileNumber	BufTagGetRelNumber (const BufferTag *tag)
static ForkNumber	BufTagGetForkNum (const BufferTag *tag)
static void	BufTagSetRelForkDetails (BufferTag *tag, RelFileNumber relnumber, ForkNumber forknum)
static RelFileLocator	BufTagGetRelFileLocator (const BufferTag *tag)
static void	ClearBufferTag (BufferTag *tag)
static void	InitBufferTag (BufferTag *tag, const RelFileLocator *rlocator, ForkNumber forkNum, BlockNumber blockNum)
static bool	BufferTagsEqual (const BufferTag *tag1, const BufferTag *tag2)
static bool	BufTagMatchesRelFileLocator (const BufferTag *tag, const RelFileLocator *rlocator)
static uint32	BufTableHashPartition (uint32 hashcode)
static LWLock *	BufMappingPartitionLock (uint32 hashcode)
static LWLock *	BufMappingPartitionLockByIndex (uint32 index)
static BufferDesc *	GetBufferDescriptor (uint32 id)
static BufferDesc *	GetLocalBufferDescriptor (uint32 id)
static Buffer	BufferDescriptorGetBuffer (const BufferDesc *bdesc)
static ConditionVariable *	BufferDescriptorGetIOCV (const BufferDesc *bdesc)
static LWLock *	BufferDescriptorGetContentLock (const BufferDesc *bdesc)
uint32	LockBufHdr (BufferDesc *desc)
static void	UnlockBufHdr (BufferDesc *desc, uint32 buf_state)
static void	ResourceOwnerRememberBuffer (ResourceOwner owner, Buffer buffer)
static void	ResourceOwnerForgetBuffer (ResourceOwner owner, Buffer buffer)
static void	ResourceOwnerRememberBufferIO (ResourceOwner owner, Buffer buffer)
static void	ResourceOwnerForgetBufferIO (ResourceOwner owner, Buffer buffer)
void	WritebackContextInit (WritebackContext *context, int *max_pending)
void	IssuePendingWritebacks (WritebackContext *wb_context, IOContext io_context)
void	ScheduleBufferTagForWriteback (WritebackContext *wb_context, IOContext io_context, BufferTag *tag)
IOContext	IOContextForStrategy (BufferAccessStrategy strategy)
BufferDesc *	StrategyGetBuffer (BufferAccessStrategy strategy, uint32 *buf_state, bool *from_ring)
void	StrategyFreeBuffer (BufferDesc *buf)
bool	StrategyRejectBuffer (BufferAccessStrategy strategy, BufferDesc *buf, bool from_ring)
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)
bool	PinLocalBuffer (BufferDesc *buf_hdr, bool adjust_usagecount)
void	UnpinLocalBuffer (Buffer buffer)
void	UnpinLocalBufferNoOwner (Buffer buffer)
PrefetchBufferResult	PrefetchLocalBuffer (SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum)
BufferDesc *	LocalBufferAlloc (SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum, bool *foundPtr)
BlockNumber	ExtendBufferedRelLocal (BufferManagerRelation bmr, ForkNumber fork, uint32 flags, uint32 extend_by, BlockNumber extend_upto, Buffer *buffers, uint32 *extended_by)
void	MarkLocalBufferDirty (Buffer buffer)
void	DropRelationLocalBuffers (RelFileLocator rlocator, ForkNumber forkNum, BlockNumber firstDelBlock)
void	DropRelationAllLocalBuffers (RelFileLocator rlocator)
void	AtEOXact_LocalBuffers (bool isCommit)

Variables
PGDLLIMPORT BufferDescPadded *	BufferDescriptors
PGDLLIMPORT ConditionVariableMinimallyPadded *	BufferIOCVArray
PGDLLIMPORT WritebackContext	BackendWritebackContext
PGDLLIMPORT BufferDesc *	LocalBufferDescriptors
PGDLLIMPORT CkptSortItem *	CkptBufferIds
PGDLLIMPORT const ResourceOwnerDesc	buffer_io_resowner_desc
PGDLLIMPORT const ResourceOwnerDesc	buffer_pin_resowner_desc

Macro Definition Documentation

BM_CHECKPOINT_NEEDED

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

Definition at line 68 of file buf_internals.h.

BM_DIRTY

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

Definition at line 61 of file buf_internals.h.

BM_IO_ERROR

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

Definition at line 65 of file buf_internals.h.

BM_IO_IN_PROGRESS

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

Definition at line 64 of file buf_internals.h.

BM_JUST_DIRTIED

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

Definition at line 66 of file buf_internals.h.

BM_LOCKED

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

Definition at line 60 of file buf_internals.h.

BM_MAX_USAGE_COUNT

#define BM_MAX_USAGE_COUNT   5

Definition at line 78 of file buf_internals.h.

BM_PERMANENT

#define BM_PERMANENT

Value:

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

Definition at line 69 of file buf_internals.h.

BM_PIN_COUNT_WAITER

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

Definition at line 67 of file buf_internals.h.

BM_TAG_VALID

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

Definition at line 63 of file buf_internals.h.

BM_VALID

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

Definition at line 62 of file buf_internals.h.

BUF_FLAG_MASK

#define BUF_FLAG_MASK   0xFFC00000U

Definition at line 48 of file buf_internals.h.

BUF_REFCOUNT_MASK

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

Definition at line 44 of file buf_internals.h.

BUF_REFCOUNT_ONE

#define BUF_REFCOUNT_ONE   1

Definition at line 43 of file buf_internals.h.

BUF_STATE_GET_REFCOUNT

#define BUF_STATE_GET_REFCOUNT

(

state

)

((state) & BUF_REFCOUNT_MASK)

Definition at line 51 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 52 of file buf_internals.h.

BUF_USAGECOUNT_MASK

#define BUF_USAGECOUNT_MASK   0x003C0000U

Definition at line 45 of file buf_internals.h.

BUF_USAGECOUNT_ONE

#define BUF_USAGECOUNT_ONE   (1U << 18)

Definition at line 46 of file buf_internals.h.

BUF_USAGECOUNT_SHIFT

#define BUF_USAGECOUNT_SHIFT   18

Definition at line 47 of file buf_internals.h.

BUFFERDESC_PAD_TO_SIZE

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

Definition at line 277 of file buf_internals.h.

FREENEXT_END_OF_LIST

#define FREENEXT_END_OF_LIST   (-1)

Definition at line 351 of file buf_internals.h.

FREENEXT_NOT_IN_LIST

#define FREENEXT_NOT_IN_LIST   (-2)

Definition at line 352 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 819 of file localbuf.c.

{
    CheckForLocalBufferLeaks();
}

References CheckForLocalBufferLeaks().

Referenced by AtEOXact_Buffers().

BufferDescriptorGetBuffer()

static Buffer BufferDescriptorGetBuffer ( const BufferDesc *  bdesc )

inlinestatic

Definition at line 330 of file buf_internals.h.

{
    return (Buffer) (bdesc->buf_id + 1);

References BufferDesc::buf_id.

Referenced by AddBufferToRing(), ExtendBufferedRelLocal(), ExtendBufferedRelShared(), GetLocalVictimBuffer(), GetVictimBuffer(), InvalidateBuffer(), InvalidateVictimBuffer(), LockBufHdr(), pg_buffercache_pages(), PinBuffer(), PinBuffer_Locked(), PinBufferForBlock(), PinLocalBuffer(), StartBufferIO(), StrategyRejectBuffer(), TerminateBufferIO(), UnpinBuffer(), and UnpinBufferNoOwner().

BufferDescriptorGetContentLock()

static LWLock* BufferDescriptorGetContentLock ( const BufferDesc *  bdesc )

inlinestatic

Definition at line 342 of file buf_internals.h.

{
    return (LWLock *) (&bdesc->content_lock);

References BufferDesc::content_lock.

Referenced by BufferIsDirty(), BufferIsExclusiveLocked(), ConditionalLockBuffer(), EvictUnpinnedBuffer(), ExtendBufferedRelShared(), FlushDatabaseBuffers(), FlushOneBuffer(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetVictimBuffer(), InitBufferPool(), IsBufferCleanupOK(), LockBuffer(), MarkBufferDirty(), MarkBufferDirtyHint(), SyncOneBuffer(), and UnpinBufferNoOwner().

BufferDescriptorGetIOCV()

static ConditionVariable* BufferDescriptorGetIOCV ( const BufferDesc *  bdesc )

inlinestatic

Definition at line 336 of file buf_internals.h.

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

References BufferDesc::buf_id, and BufferIOCVArray.

Referenced by InitBufferPool(), TerminateBufferIO(), and WaitIO().

BufferTagsEqual()

static bool BufferTagsEqual ( const BufferTag *  tag1, const BufferTag *  tag2  )

inlinestatic

Definition at line 153 of file buf_internals.h.

{
    return (tag1->spcOid == tag2->spcOid) &&
        (tag1->dbOid == tag2->dbOid) &&
        (tag1->relNumber == tag2->relNumber) &&
        (tag1->blockNum == tag2->blockNum) &&
        (tag1->forkNum == tag2->forkNum);

References buftag::blockNum, buftag::dbOid, buftag::forkNum, buftag::relNumber, and buftag::spcOid.

Referenced by InvalidateBuffer(), InvalidateVictimBuffer(), LocalBufferAlloc(), and ReadRecentBuffer().

BufMappingPartitionLock()

static LWLock* BufMappingPartitionLock ( uint32  hashcode )

inlinestatic

Definition at line 185 of file buf_internals.h.

{
    return &MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET +
                            BufTableHashPartition(hashcode)].lock;

References BUFFER_MAPPING_LWLOCK_OFFSET, BufTableHashPartition(), LWLockPadded::lock, and MainLWLockArray.

Referenced by BufferAlloc(), ExtendBufferedRelShared(), FindAndDropRelationBuffers(), InvalidateBuffer(), InvalidateVictimBuffer(), and PrefetchSharedBuffer().

BufMappingPartitionLockByIndex()

static LWLock* BufMappingPartitionLockByIndex ( uint32  index )

inlinestatic

Definition at line 192 of file buf_internals.h.

{
    return &MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET + index].lock;

References BUFFER_MAPPING_LWLOCK_OFFSET, LWLockPadded::lock, and MainLWLockArray.

BufTableDelete()

void BufTableDelete	(	BufferTag *	tagPtr,
		uint32	hashcode
	)

Definition at line 148 of file buf_table.c.

{
    BufferLookupEnt *result;
 
    result = (BufferLookupEnt *)
        hash_search_with_hash_value(SharedBufHash,
                                    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 InvalidateBuffer(), and InvalidateVictimBuffer().

BufTableHashCode()

uint32 BufTableHashCode

(

BufferTag *

tagPtr

)

Definition at line 78 of file buf_table.c.

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

References get_hash_value(), and SharedBufHash.

Referenced by BufferAlloc(), ExtendBufferedRelShared(), FindAndDropRelationBuffers(), InvalidateBuffer(), InvalidateVictimBuffer(), and PrefetchSharedBuffer().

BufTableHashPartition()

static uint32 BufTableHashPartition ( uint32  hashcode )

inlinestatic

Definition at line 179 of file buf_internals.h.

{
    return hashcode % NUM_BUFFER_PARTITIONS;

References NUM_BUFFER_PARTITIONS.

Referenced by BufMappingPartitionLock().

BufTableInsert()

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

Definition at line 118 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,
                                    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(), and ExtendBufferedRelShared().

BufTableLookup()

int BufTableLookup	(	BufferTag *	tagPtr,
		uint32	hashcode
	)

Definition at line 90 of file buf_table.c.

{
    BufferLookupEnt *result;
 
    result = (BufferLookupEnt *)
        hash_search_with_hash_value(SharedBufHash,
                                    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(), FindAndDropRelationBuffers(), and PrefetchSharedBuffer().

BufTableShmemSize()

Size BufTableShmemSize

(

int

size

)

Definition at line 41 of file buf_table.c.

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

References hash_estimate_size(), and size.

Referenced by StrategyShmemSize().

BufTagGetForkNum()

static ForkNumber BufTagGetForkNum ( const BufferTag *  tag )

inlinestatic

Definition at line 108 of file buf_internals.h.

{
    return tag->forkNum;

References buftag::forkNum.

Referenced by AbortBufferIO(), apw_dump_now(), BufferGetTag(), BufferSync(), buffertag_comparator(), DebugPrintBufferRefcount(), DropRelationAllLocalBuffers(), DropRelationBuffers(), DropRelationLocalBuffers(), FindAndDropRelationBuffers(), FlushBuffer(), FlushRelationBuffers(), GetLocalVictimBuffer(), IssuePendingWritebacks(), local_buffer_write_error_callback(), pg_buffercache_pages(), ReleaseAndReadBuffer(), and shared_buffer_write_error_callback().

BufTagGetRelFileLocator()

static RelFileLocator BufTagGetRelFileLocator ( const BufferTag *  tag )

inlinestatic

Definition at line 122 of file buf_internals.h.

{
    RelFileLocator rlocator;
 
    rlocator.spcOid = tag->spcOid;
    rlocator.dbOid = tag->dbOid;
    rlocator.relNumber = BufTagGetRelNumber(tag);
 
    return rlocator;

References BufTagGetRelNumber(), buftag::dbOid, RelFileLocator::dbOid, RelFileLocator::relNumber, buftag::spcOid, and RelFileLocator::spcOid.

Referenced by AbortBufferIO(), BufferGetTag(), buffertag_comparator(), DebugPrintBufferRefcount(), DropRelationAllLocalBuffers(), DropRelationLocalBuffers(), DropRelationsAllBuffers(), FlushBuffer(), FlushRelationsAllBuffers(), GetLocalVictimBuffer(), IssuePendingWritebacks(), local_buffer_write_error_callback(), MarkBufferDirtyHint(), and shared_buffer_write_error_callback().

BufTagGetRelNumber()

static RelFileNumber BufTagGetRelNumber ( const BufferTag *  tag )

inlinestatic

Definition at line 102 of file buf_internals.h.

{
    return tag->relNumber;

References buftag::relNumber.

Referenced by apw_dump_now(), BufferSync(), BufTagGetRelFileLocator(), BufTagMatchesRelFileLocator(), and pg_buffercache_pages().

BufTagMatchesRelFileLocator()

static bool BufTagMatchesRelFileLocator ( const BufferTag *  tag, const RelFileLocator *  rlocator  )

inlinestatic

Definition at line 163 of file buf_internals.h.

{
    return (tag->spcOid == rlocator->spcOid) &&
        (tag->dbOid == rlocator->dbOid) &&
        (BufTagGetRelNumber(tag) == rlocator->relNumber);

References BufTagGetRelNumber(), buftag::dbOid, RelFileLocator::dbOid, RelFileLocator::relNumber, buftag::spcOid, and RelFileLocator::spcOid.

Referenced by DropRelationAllLocalBuffers(), DropRelationBuffers(), DropRelationLocalBuffers(), DropRelationsAllBuffers(), FindAndDropRelationBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), and ReleaseAndReadBuffer().

BufTagSetRelForkDetails()

static void BufTagSetRelForkDetails ( BufferTag *  tag, RelFileNumber  relnumber, ForkNumber  forknum  )

inlinestatic

Definition at line 114 of file buf_internals.h.

{
    tag->relNumber = relnumber;
    tag->forkNum = forknum;

References buftag::forkNum, and buftag::relNumber.

Referenced by ClearBufferTag(), and InitBufferTag().

ClearBufferTag()

static void ClearBufferTag ( BufferTag *  tag )

inlinestatic

Definition at line 134 of file buf_internals.h.

{
    tag->spcOid = InvalidOid;
    tag->dbOid = InvalidOid;
    BufTagSetRelForkDetails(tag, InvalidRelFileNumber, InvalidForkNumber);
    tag->blockNum = InvalidBlockNumber;

References buftag::blockNum, BufTagSetRelForkDetails(), buftag::dbOid, InvalidBlockNumber, InvalidForkNumber, InvalidOid, InvalidRelFileNumber, and buftag::spcOid.

Referenced by DropRelationAllLocalBuffers(), DropRelationLocalBuffers(), GetLocalVictimBuffer(), InitBufferPool(), InvalidateBuffer(), and InvalidateVictimBuffer().

DropRelationAllLocalBuffers()

void DropRelationAllLocalBuffers

(

RelFileLocator

rlocator

)

Definition at line 537 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) &&
            BufTagMatchesRelFileLocator(&bufHdr->tag, &rlocator))
        {
            if (LocalRefCount[i] != 0)
                elog(ERROR, "block %u of %s is still referenced (local %u)",
                     bufHdr->tag.blockNum,
                     relpathbackend(BufTagGetRelFileLocator(&bufHdr->tag),
                                    MyProcNumber,
                                    BufTagGetForkNum(&bufHdr->tag)),
                     LocalRefCount[i]);
            /* Remove entry from hashtable */
            hresult = (LocalBufferLookupEnt *)
                hash_search(LocalBufHash, &bufHdr->tag, HASH_REMOVE, NULL);
            if (!hresult)       /* shouldn't happen */
                elog(ERROR, "local buffer hash table corrupted");
            /* Mark buffer invalid */
            ClearBufferTag(&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, BufTagGetForkNum(), BufTagGetRelFileLocator(), BufTagMatchesRelFileLocator(), ClearBufferTag(), elog, ERROR, GetLocalBufferDescriptor(), HASH_REMOVE, hash_search(), i, LocalBufHash, LocalRefCount, MyProcNumber, NLocBuffer, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), relpathbackend, BufferDesc::state, and BufferDesc::tag.

Referenced by DropRelationsAllBuffers().

DropRelationLocalBuffers()

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

Definition at line 489 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) &&
            BufTagMatchesRelFileLocator(&bufHdr->tag, &rlocator) &&
            BufTagGetForkNum(&bufHdr->tag) == forkNum &&
            bufHdr->tag.blockNum >= firstDelBlock)
        {
            if (LocalRefCount[i] != 0)
                elog(ERROR, "block %u of %s is still referenced (local %u)",
                     bufHdr->tag.blockNum,
                     relpathbackend(BufTagGetRelFileLocator(&bufHdr->tag),
                                    MyProcNumber,
                                    BufTagGetForkNum(&bufHdr->tag)),
                     LocalRefCount[i]);
 
            /* Remove entry from hashtable */
            hresult = (LocalBufferLookupEnt *)
                hash_search(LocalBufHash, &bufHdr->tag, HASH_REMOVE, NULL);
            if (!hresult)       /* shouldn't happen */
                elog(ERROR, "local buffer hash table corrupted");
            /* Mark buffer invalid */
            ClearBufferTag(&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, BufTagGetForkNum(), BufTagGetRelFileLocator(), BufTagMatchesRelFileLocator(), ClearBufferTag(), elog, ERROR, GetLocalBufferDescriptor(), HASH_REMOVE, hash_search(), i, LocalBufHash, LocalRefCount, MyProcNumber, NLocBuffer, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), relpathbackend, BufferDesc::state, and BufferDesc::tag.

Referenced by DropRelationBuffers().

ExtendBufferedRelLocal()

BlockNumber ExtendBufferedRelLocal	(	BufferManagerRelation	bmr,
		ForkNumber	fork,
		uint32	flags,
		uint32	extend_by,
		BlockNumber	extend_upto,
		Buffer *	buffers,
		uint32 *	extended_by
	)

Definition at line 313 of file localbuf.c.

{
    BlockNumber first_block;
    instr_time  io_start;
 
    /* Initialize local buffers if first request in this session */
    if (LocalBufHash == NULL)
        InitLocalBuffers();
 
    LimitAdditionalLocalPins(&extend_by);
 
    for (uint32 i = 0; i < extend_by; i++)
    {
        BufferDesc *buf_hdr;
        Block       buf_block;
 
        buffers[i] = GetLocalVictimBuffer();
        buf_hdr = GetLocalBufferDescriptor(-buffers[i] - 1);
        buf_block = LocalBufHdrGetBlock(buf_hdr);
 
        /* new buffers are zero-filled */
        MemSet((char *) buf_block, 0, BLCKSZ);
    }
 
    first_block = smgrnblocks(bmr.smgr, fork);
 
    if (extend_upto != InvalidBlockNumber)
    {
        /*
         * In contrast to shared relations, nothing could change the relation
         * size concurrently. Thus we shouldn't end up finding that we don't
         * need to do anything.
         */
        Assert(first_block <= extend_upto);
 
        Assert((uint64) first_block + extend_by <= extend_upto);
    }
 
    /* Fail if relation is already at maximum possible length */
    if ((uint64) first_block + extend_by >= MaxBlockNumber)
        ereport(ERROR,
                (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
                 errmsg("cannot extend relation %s beyond %u blocks",
                        relpath(bmr.smgr->smgr_rlocator, fork),
                        MaxBlockNumber)));
 
    for (uint32 i = 0; i < extend_by; i++)
    {
        int         victim_buf_id;
        BufferDesc *victim_buf_hdr;
        BufferTag   tag;
        LocalBufferLookupEnt *hresult;
        bool        found;
 
        victim_buf_id = -buffers[i] - 1;
        victim_buf_hdr = GetLocalBufferDescriptor(victim_buf_id);
 
        /* in case we need to pin an existing buffer below */
        ResourceOwnerEnlarge(CurrentResourceOwner);
 
        InitBufferTag(&tag, &bmr.smgr->smgr_rlocator.locator, fork, first_block + i);
 
        hresult = (LocalBufferLookupEnt *)
            hash_search(LocalBufHash, (void *) &tag, HASH_ENTER, &found);
        if (found)
        {
            BufferDesc *existing_hdr;
            uint32      buf_state;
 
            UnpinLocalBuffer(BufferDescriptorGetBuffer(victim_buf_hdr));
 
            existing_hdr = GetLocalBufferDescriptor(hresult->id);
            PinLocalBuffer(existing_hdr, false);
            buffers[i] = BufferDescriptorGetBuffer(existing_hdr);
 
            buf_state = pg_atomic_read_u32(&existing_hdr->state);
            Assert(buf_state & BM_TAG_VALID);
            Assert(!(buf_state & BM_DIRTY));
            buf_state &= ~BM_VALID;
            pg_atomic_unlocked_write_u32(&existing_hdr->state, buf_state);
        }
        else
        {
            uint32      buf_state = pg_atomic_read_u32(&victim_buf_hdr->state);
 
            Assert(!(buf_state & (BM_VALID | BM_TAG_VALID | BM_DIRTY | BM_JUST_DIRTIED)));
 
            victim_buf_hdr->tag = tag;
 
            buf_state |= BM_TAG_VALID | BUF_USAGECOUNT_ONE;
 
            pg_atomic_unlocked_write_u32(&victim_buf_hdr->state, buf_state);
 
            hresult->id = victim_buf_id;
        }
    }
 
    io_start = pgstat_prepare_io_time(track_io_timing);
 
    /* actually extend relation */
    smgrzeroextend(bmr.smgr, fork, first_block, extend_by, false);
 
    pgstat_count_io_op_time(IOOBJECT_TEMP_RELATION, IOCONTEXT_NORMAL, IOOP_EXTEND,
                            io_start, extend_by);
 
    for (uint32 i = 0; i < extend_by; i++)
    {
        Buffer      buf = buffers[i];
        BufferDesc *buf_hdr;
        uint32      buf_state;
 
        buf_hdr = GetLocalBufferDescriptor(-buf - 1);
 
        buf_state = pg_atomic_read_u32(&buf_hdr->state);
        buf_state |= BM_VALID;
        pg_atomic_unlocked_write_u32(&buf_hdr->state, buf_state);
    }
 
    *extended_by = extend_by;
 
    pgBufferUsage.local_blks_written += extend_by;
 
    return first_block;
}

References Assert, BM_DIRTY, BM_JUST_DIRTIED, BM_TAG_VALID, BM_VALID, buf, BUF_USAGECOUNT_ONE, BufferDescriptorGetBuffer(), CurrentResourceOwner, ereport, errcode(), errmsg(), ERROR, GetLocalBufferDescriptor(), GetLocalVictimBuffer(), HASH_ENTER, hash_search(), i, LocalBufferLookupEnt::id, InitBufferTag(), InitLocalBuffers(), InvalidBlockNumber, IOCONTEXT_NORMAL, IOOBJECT_TEMP_RELATION, IOOP_EXTEND, LimitAdditionalLocalPins(), BufferUsage::local_blks_written, LocalBufHash, LocalBufHdrGetBlock, RelFileLocatorBackend::locator, MaxBlockNumber, MemSet, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), pgBufferUsage, pgstat_count_io_op_time(), pgstat_prepare_io_time(), PinLocalBuffer(), relpath, ResourceOwnerEnlarge(), BufferManagerRelation::smgr, SMgrRelationData::smgr_rlocator, smgrnblocks(), smgrzeroextend(), BufferDesc::state, BufferDesc::tag, track_io_timing, and UnpinLocalBuffer().

Referenced by ExtendBufferedRelCommon().

GetBufferDescriptor()

static BufferDesc* GetBufferDescriptor ( uint32  id )

inlinestatic

Definition at line 318 of file buf_internals.h.

{
    return &(BufferDescriptors[id]).bufferdesc;

References BufferDescriptors.

Referenced by AbortBufferIO(), apw_dump_now(), BufferAlloc(), BufferGetBlockNumber(), BufferGetLSNAtomic(), BufferGetTag(), BufferIsDirty(), BufferIsExclusiveLocked(), BufferIsPermanent(), BufferSync(), ConditionalLockBuffer(), ConditionalLockBufferForCleanup(), DebugPrintBufferRefcount(), DropDatabaseBuffers(), DropRelationBuffers(), DropRelationsAllBuffers(), EvictUnpinnedBuffer(), ExtendBufferedRelShared(), FindAndDropRelationBuffers(), FlushDatabaseBuffers(), FlushOneBuffer(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetBufferFromRing(), InitBufferPool(), IsBufferCleanupOK(), LockBuffer(), LockBufferForCleanup(), MarkBufferDirty(), MarkBufferDirtyHint(), pg_buffercache_pages(), pg_buffercache_summary(), ReadRecentBuffer(), ReleaseAndReadBuffer(), ReleaseBuffer(), ResOwnerReleaseBufferPin(), StrategyGetBuffer(), SyncOneBuffer(), WaitReadBuffers(), WaitReadBuffersCanStartIO(), and ZeroBuffer().

GetLocalBufferDescriptor()

static BufferDesc* GetLocalBufferDescriptor ( uint32  id )

inlinestatic

Definition at line 324 of file buf_internals.h.

{
    return &LocalBufferDescriptors[id];

References LocalBufferDescriptors.

Referenced by BufferGetBlockNumber(), BufferGetTag(), BufferIsDirty(), BufferIsExclusiveLocked(), DebugPrintBufferRefcount(), DropRelationAllLocalBuffers(), DropRelationLocalBuffers(), ExtendBufferedRelLocal(), FlushRelationBuffers(), GetLocalVictimBuffer(), InitLocalBuffers(), LocalBufferAlloc(), MarkLocalBufferDirty(), ReadRecentBuffer(), ReleaseAndReadBuffer(), WaitReadBuffers(), WaitReadBuffersCanStartIO(), and ZeroBuffer().

have_free_buffer()

bool have_free_buffer

(

void

)

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

InitBufferTag()

static void InitBufferTag ( BufferTag *  tag, const RelFileLocator *  rlocator, ForkNumber  forkNum, BlockNumber  blockNum  )

inlinestatic

Definition at line 143 of file buf_internals.h.

{
    tag->spcOid = rlocator->spcOid;
    tag->dbOid = rlocator->dbOid;
    BufTagSetRelForkDetails(tag, rlocator->relNumber, forkNum);
    tag->blockNum = blockNum;

References buftag::blockNum, BufTagSetRelForkDetails(), buftag::dbOid, RelFileLocator::dbOid, RelFileLocator::relNumber, buftag::spcOid, and RelFileLocator::spcOid.

Referenced by BufferAlloc(), ExtendBufferedRelLocal(), ExtendBufferedRelShared(), FindAndDropRelationBuffers(), LocalBufferAlloc(), PrefetchLocalBuffer(), PrefetchSharedBuffer(), and ReadRecentBuffer().

InitBufTable()

void InitBufTable

(

int

size

)

Definition at line 51 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, ShmemInitHash(), and size.

Referenced by StrategyInitialize().

IOContextForStrategy()

IOContext IOContextForStrategy

(

BufferAccessStrategy

strategy

)

Definition at line 758 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 ExtendBufferedRelShared(), PinBufferForBlock(), and WaitReadBuffers().

IssuePendingWritebacks()

void IssuePendingWritebacks	(	WritebackContext *	wb_context,
		IOContext	io_context
	)

Definition at line 5887 of file bufmgr.c.

{
    instr_time  io_start;
    int         i;
 
    if (wb_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(wb_context->pending_writebacks,
                            wb_context->nr_pending);
 
    io_start = pgstat_prepare_io_time(track_io_timing);
 
    /*
     * 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 < wb_context->nr_pending; i++)
    {
        PendingWriteback *cur;
        PendingWriteback *next;
        SMgrRelation reln;
        int         ahead;
        BufferTag   tag;
        RelFileLocator currlocator;
        Size        nblocks = 1;
 
        cur = &wb_context->pending_writebacks[i];
        tag = cur->tag;
        currlocator = BufTagGetRelFileLocator(&tag);
 
        /*
         * Peek ahead, into following writeback requests, to see if they can
         * be combined with the current one.
         */
        for (ahead = 0; i + ahead + 1 < wb_context->nr_pending; ahead++)
        {
 
            next = &wb_context->pending_writebacks[i + ahead + 1];
 
            /* different file, stop */
            if (!RelFileLocatorEquals(currlocator,
                                      BufTagGetRelFileLocator(&next->tag)) ||
                BufTagGetForkNum(&cur->tag) != BufTagGetForkNum(&next->tag))
                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(currlocator, INVALID_PROC_NUMBER);
        smgrwriteback(reln, BufTagGetForkNum(&tag), tag.blockNum, nblocks);
    }
 
    /*
     * Assume that writeback requests are only issued for buffers containing
     * blocks of permanent relations.
     */
    pgstat_count_io_op_time(IOOBJECT_RELATION, io_context,
                            IOOP_WRITEBACK, io_start, wb_context->nr_pending);
 
    wb_context->nr_pending = 0;
}

References buftag::blockNum, BufTagGetForkNum(), BufTagGetRelFileLocator(), cur, i, INVALID_PROC_NUMBER, IOOBJECT_RELATION, IOOP_WRITEBACK, next, WritebackContext::nr_pending, WritebackContext::pending_writebacks, pgstat_count_io_op_time(), pgstat_prepare_io_time(), RelFileLocatorEquals, smgropen(), smgrwriteback(), and track_io_timing.

Referenced by BufferSync(), and ScheduleBufferTagForWriteback().

LocalBufferAlloc()

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

Definition at line 116 of file localbuf.c.

{
    BufferTag   newTag;         /* identity of requested block */
    LocalBufferLookupEnt *hresult;
    BufferDesc *bufHdr;
    Buffer      victim_buffer;
    int         bufid;
    bool        found;
 
    InitBufferTag(&newTag, &smgr->smgr_rlocator.locator, forkNum, blockNum);
 
    /* Initialize local buffers if first request in this session */
    if (LocalBufHash == NULL)
        InitLocalBuffers();
 
    ResourceOwnerEnlarge(CurrentResourceOwner);
 
    /* See if the desired buffer already exists */
    hresult = (LocalBufferLookupEnt *)
        hash_search(LocalBufHash, &newTag, HASH_FIND, NULL);
 
    if (hresult)
    {
        bufid = hresult->id;
        bufHdr = GetLocalBufferDescriptor(bufid);
        Assert(BufferTagsEqual(&bufHdr->tag, &newTag));
 
        *foundPtr = PinLocalBuffer(bufHdr, true);
    }
    else
    {
        uint32      buf_state;
 
        victim_buffer = GetLocalVictimBuffer();
        bufid = -victim_buffer - 1;
        bufHdr = GetLocalBufferDescriptor(bufid);
 
        hresult = (LocalBufferLookupEnt *)
            hash_search(LocalBufHash, &newTag, HASH_ENTER, &found);
        if (found)              /* shouldn't happen */
            elog(ERROR, "local buffer hash table corrupted");
        hresult->id = bufid;
 
        /*
         * it's all ours now.
         */
        bufHdr->tag = newTag;
 
        buf_state = pg_atomic_read_u32(&bufHdr->state);
        buf_state &= ~(BUF_FLAG_MASK | BUF_USAGECOUNT_MASK);
        buf_state |= BM_TAG_VALID | BUF_USAGECOUNT_ONE;
        pg_atomic_unlocked_write_u32(&bufHdr->state, buf_state);
 
        *foundPtr = false;
    }
 
    return bufHdr;
}

References Assert, BM_TAG_VALID, BUF_FLAG_MASK, BUF_USAGECOUNT_MASK, BUF_USAGECOUNT_ONE, BufferTagsEqual(), CurrentResourceOwner, elog, ERROR, GetLocalBufferDescriptor(), GetLocalVictimBuffer(), HASH_ENTER, HASH_FIND, hash_search(), LocalBufferLookupEnt::id, InitBufferTag(), InitLocalBuffers(), LocalBufHash, RelFileLocatorBackend::locator, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), PinLocalBuffer(), ResourceOwnerEnlarge(), SMgrRelationData::smgr_rlocator, BufferDesc::state, and BufferDesc::tag.

Referenced by PinBufferForBlock().

LockBufHdr()

uint32 LockBufHdr

(

BufferDesc *

desc

)

Definition at line 5688 of file bufmgr.c.

{
    SpinDelayStatus delayStatus;
    uint32      old_buf_state;
 
    Assert(!BufferIsLocal(BufferDescriptorGetBuffer(desc)));
 
    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 Assert, BM_LOCKED, BufferDescriptorGetBuffer(), BufferIsLocal, 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(), DropRelationBuffers(), DropRelationsAllBuffers(), EvictUnpinnedBuffer(), ExtendBufferedRelShared(), FindAndDropRelationBuffers(), FlushBuffer(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetBufferFromRing(), GetVictimBuffer(), InvalidateBuffer(), InvalidateVictimBuffer(), IsBufferCleanupOK(), LockBufferForCleanup(), MarkBufferDirtyHint(), pg_buffercache_pages(), ReadRecentBuffer(), StartBufferIO(), StrategyGetBuffer(), SyncOneBuffer(), TerminateBufferIO(), UnlockBuffers(), UnpinBufferNoOwner(), WaitIO(), and ZeroBuffer().

MarkLocalBufferDirty()

void MarkLocalBufferDirty

(

Buffer

buffer

)

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

PinLocalBuffer()

bool PinLocalBuffer	(	BufferDesc *	buf_hdr,
		bool	adjust_usagecount
	)

Definition at line 655 of file localbuf.c.

{
    uint32      buf_state;
    Buffer      buffer = BufferDescriptorGetBuffer(buf_hdr);
    int         bufid = -buffer - 1;
 
    buf_state = pg_atomic_read_u32(&buf_hdr->state);
 
    if (LocalRefCount[bufid] == 0)
    {
        NLocalPinnedBuffers++;
        if (adjust_usagecount &&
            BUF_STATE_GET_USAGECOUNT(buf_state) < BM_MAX_USAGE_COUNT)
        {
            buf_state += BUF_USAGECOUNT_ONE;
            pg_atomic_unlocked_write_u32(&buf_hdr->state, buf_state);
        }
    }
    LocalRefCount[bufid]++;
    ResourceOwnerRememberBuffer(CurrentResourceOwner,
                                BufferDescriptorGetBuffer(buf_hdr));
 
    return buf_state & BM_VALID;
}

References BM_MAX_USAGE_COUNT, BM_VALID, BUF_STATE_GET_USAGECOUNT, BUF_USAGECOUNT_ONE, BufferDescriptorGetBuffer(), CurrentResourceOwner, LocalRefCount, NLocalPinnedBuffers, pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), ResourceOwnerRememberBuffer(), and BufferDesc::state.

Referenced by ExtendBufferedRelLocal(), GetLocalVictimBuffer(), LocalBufferAlloc(), and ReadRecentBuffer().

PrefetchLocalBuffer()

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

Definition at line 69 of file localbuf.c.

{
    PrefetchBufferResult result = {InvalidBuffer, false};
    BufferTag   newTag;         /* identity of requested block */
    LocalBufferLookupEnt *hresult;
 
    InitBufferTag(&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, &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 */
        if ((io_direct_flags & IO_DIRECT_DATA) == 0 &&
            smgrprefetch(smgr, forkNum, blockNum, 1))
        {
            result.initiated_io = true;
        }
#endif                          /* USE_PREFETCH */
    }
 
    return result;
}

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

Referenced by PrefetchBuffer().

ResourceOwnerForgetBuffer()

static void ResourceOwnerForgetBuffer ( ResourceOwner  owner, Buffer  buffer  )

inlinestatic

Definition at line 397 of file buf_internals.h.

{
    ResourceOwnerForget(owner, Int32GetDatum(buffer), &buffer_pin_resowner_desc);

References buffer_pin_resowner_desc, Int32GetDatum(), and ResourceOwnerForget().

ResourceOwnerForgetBufferIO()

static void ResourceOwnerForgetBufferIO ( ResourceOwner  owner, Buffer  buffer  )

inlinestatic

Definition at line 407 of file buf_internals.h.

{
    ResourceOwnerForget(owner, Int32GetDatum(buffer), &buffer_io_resowner_desc);

References buffer_io_resowner_desc, Int32GetDatum(), and ResourceOwnerForget().

ResourceOwnerRememberBuffer()

static void ResourceOwnerRememberBuffer ( ResourceOwner  owner, Buffer  buffer  )

inlinestatic

Definition at line 392 of file buf_internals.h.

{
    ResourceOwnerRemember(owner, Int32GetDatum(buffer), &buffer_pin_resowner_desc);

References buffer_pin_resowner_desc, Int32GetDatum(), and ResourceOwnerRemember().

ResourceOwnerRememberBufferIO()

static void ResourceOwnerRememberBufferIO ( ResourceOwner  owner, Buffer  buffer  )

inlinestatic

Definition at line 402 of file buf_internals.h.

{
    ResourceOwnerRemember(owner, Int32GetDatum(buffer), &buffer_io_resowner_desc);

References buffer_io_resowner_desc, Int32GetDatum(), and ResourceOwnerRemember().

ScheduleBufferTagForWriteback()

void ScheduleBufferTagForWriteback	(	WritebackContext *	wb_context,
		IOContext	io_context,
		BufferTag *	tag
	)

Definition at line 5842 of file bufmgr.c.

{
    PendingWriteback *pending;
 
    if (io_direct_flags & IO_DIRECT_DATA)
        return;
 
    /*
     * Add buffer to the pending writeback array, unless writeback control is
     * disabled.
     */
    if (*wb_context->max_pending > 0)
    {
        Assert(*wb_context->max_pending <= WRITEBACK_MAX_PENDING_FLUSHES);
 
        pending = &wb_context->pending_writebacks[wb_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 (wb_context->nr_pending >= *wb_context->max_pending)
        IssuePendingWritebacks(wb_context, io_context);
}

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

Referenced by GetVictimBuffer(), 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 BufferAlloc(), ExtendBufferedRelShared(), and InvalidateBuffer().

StrategyGetBuffer()

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

Definition at line 196 of file freelist.c.

{
    BufferDesc *buf;
    int         bgwprocno;
    int         trycounter;
    uint32      local_buf_state;    /* to avoid repeated (de-)referencing */
 
    *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);
 
    /*
     * 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 GetVictimBuffer().

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,
		bool	from_ring
	)

Definition at line 798 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 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, NUM_BUFFER_PARTITIONS, and size.

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().

UnlockBufHdr()

static void UnlockBufHdr ( BufferDesc *  desc, uint32  buf_state  )

inlinestatic

Definition at line 361 of file buf_internals.h.

{
    pg_write_barrier();
    pg_atomic_write_u32(&desc->state, buf_state & (~BM_LOCKED));

References BM_LOCKED, pg_atomic_write_u32(), pg_write_barrier, and BufferDesc::state.

Referenced by AbortBufferIO(), apw_dump_now(), BufferAlloc(), BufferGetLSNAtomic(), BufferSync(), ConditionalLockBufferForCleanup(), DropDatabaseBuffers(), DropRelationBuffers(), DropRelationsAllBuffers(), EvictUnpinnedBuffer(), ExtendBufferedRelShared(), FindAndDropRelationBuffers(), FlushBuffer(), FlushDatabaseBuffers(), FlushRelationBuffers(), FlushRelationsAllBuffers(), GetBufferFromRing(), GetVictimBuffer(), InvalidateBuffer(), InvalidateVictimBuffer(), IsBufferCleanupOK(), LockBufferForCleanup(), MarkBufferDirtyHint(), pg_buffercache_pages(), PinBuffer_Locked(), ReadRecentBuffer(), StartBufferIO(), StrategyGetBuffer(), SyncOneBuffer(), TerminateBufferIO(), UnlockBuffers(), UnpinBufferNoOwner(), WaitIO(), and ZeroBuffer().

UnpinLocalBuffer()

void UnpinLocalBuffer

(

Buffer

buffer

)

Definition at line 681 of file localbuf.c.

{
    UnpinLocalBufferNoOwner(buffer);
    ResourceOwnerForgetBuffer(CurrentResourceOwner, buffer);
}

References CurrentResourceOwner, ResourceOwnerForgetBuffer(), and UnpinLocalBufferNoOwner().

Referenced by ExtendBufferedRelLocal(), ReleaseAndReadBuffer(), and ReleaseBuffer().

UnpinLocalBufferNoOwner()

void UnpinLocalBufferNoOwner

(

Buffer

buffer

)

Definition at line 688 of file localbuf.c.

{
    int         buffid = -buffer - 1;
 
    Assert(BufferIsLocal(buffer));
    Assert(LocalRefCount[buffid] > 0);
    Assert(NLocalPinnedBuffers > 0);
 
    if (--LocalRefCount[buffid] == 0)
        NLocalPinnedBuffers--;
}

References Assert, BufferIsLocal, LocalRefCount, and NLocalPinnedBuffers.

Referenced by ResOwnerReleaseBufferPin(), and UnpinLocalBuffer().

WritebackContextInit()

void WritebackContextInit	(	WritebackContext *	context,
		int *	max_pending
	)

Definition at line 5830 of file bufmgr.c.

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

References Assert, context, 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 GetVictimBuffer(), and InitBufferPool().

buffer_io_resowner_desc

PGDLLIMPORT const ResourceOwnerDesc buffer_io_resowner_desc

extern

Definition at line 225 of file bufmgr.c.

Referenced by ResourceOwnerForgetBufferIO(), and ResourceOwnerRememberBufferIO().

buffer_pin_resowner_desc

PGDLLIMPORT const ResourceOwnerDesc buffer_pin_resowner_desc

extern

Definition at line 234 of file bufmgr.c.

Referenced by ResourceOwnerForgetBuffer(), and ResourceOwnerRememberBuffer().

BufferDescriptors

PGDLLIMPORT BufferDescPadded* BufferDescriptors

extern

Definition at line 21 of file buf_init.c.

Referenced by GetBufferDescriptor(), and InitBufferPool().

BufferIOCVArray

PGDLLIMPORT ConditionVariableMinimallyPadded* BufferIOCVArray

extern

Definition at line 23 of file buf_init.c.

Referenced by BufferDescriptorGetIOCV(), and 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 44 of file localbuf.c.

Referenced by GetLocalBufferDescriptor(), and InitLocalBuffers().