#include "storage/buf.h"
#include "storage/bufmgr.h"
#include "storage/latch.h"
#include "storage/lwlock.h"
#include "storage/shmem.h"
#include "storage/smgr.h"
#include "port/atomics.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_rnode, 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	BufferDescriptorGetIOLock(bdesc) (&(BufferIOLWLockArray[(bdesc)->buf_id]).lock)

#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)

void	LocalPrefetchBuffer (SMgrRelation smgr, ForkNumber forkNum, BlockNumber blockNum)

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

void	MarkLocalBufferDirty (Buffer buffer)

void	DropRelFileNodeLocalBuffers (RelFileNode rnode, ForkNumber forkNum, BlockNumber firstDelBlock)

void	DropRelFileNodeAllLocalBuffers (RelFileNode rnode)

void	AtEOXact_LocalBuffers (bool isCommit)

Variables
PGDLLIMPORT LWLockMinimallyPadded *	BufferIOLWLockArray

PGDLLIMPORT BufferDescPadded *	BufferDescriptors

PGDLLIMPORT WritebackContext	BackendWritebackContext

BufferDesc *	LocalBufferDescriptors

CkptSortItem *	CkptBufferIds

Macro Definition Documentation

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

Definition at line 66 of file buf_internals.h.

Referenced by BufferAlloc(), BufferSync(), and TerminateBufferIO().

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

Definition at line 59 of file buf_internals.h.

Referenced by AbortBufferIO(), BufferAlloc(), BufferSync(), FlushDatabaseBuffers(), FlushRelationBuffers(), LocalBufferAlloc(), MarkBufferDirty(), MarkBufferDirtyHint(), MarkLocalBufferDirty(), pg_buffercache_pages(), StartBufferIO(), SyncOneBuffer(), and TerminateBufferIO().

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

Definition at line 63 of file buf_internals.h.

Referenced by AbortBufferIO(), BufferAlloc(), LocalBufferAlloc(), and TerminateBufferIO().

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

Definition at line 62 of file buf_internals.h.

Referenced by AbortBufferIO(), StartBufferIO(), TerminateBufferIO(), and WaitIO().

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

Definition at line 64 of file buf_internals.h.

Referenced by BufferAlloc(), FlushBuffer(), FlushRelationBuffers(), LocalBufferAlloc(), MarkBufferDirty(), MarkBufferDirtyHint(), and TerminateBufferIO().

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

Definition at line 58 of file buf_internals.h.

Referenced by InvalidateBuffer(), LockBufHdr(), MarkBufferDirty(), PinBuffer(), PinBuffer_Locked(), UnpinBuffer(), and WaitBufHdrUnlocked().

#define BM_MAX_USAGE_COUNT 5

Definition at line 77 of file buf_internals.h.

Referenced by LocalBufferAlloc(), and PinBuffer().

#define BM_PERMANENT

Value:

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

* or init fork) */

Definition at line 67 of file buf_internals.h.

Referenced by apw_dump_now(), BufferAlloc(), BufferIsPermanent(), BufferSync(), FlushBuffer(), and MarkBufferDirtyHint().

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

Definition at line 65 of file buf_internals.h.

Referenced by LockBufferForCleanup(), UnlockBuffers(), and UnpinBuffer().

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

Definition at line 61 of file buf_internals.h.

Referenced by apw_dump_now(), BufferAlloc(), DropRelFileNodeAllLocalBuffers(), DropRelFileNodeLocalBuffers(), InvalidateBuffer(), LocalBufferAlloc(), and pg_buffercache_pages().

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

Definition at line 60 of file buf_internals.h.

Referenced by AbortBufferIO(), BufferAlloc(), FlushDatabaseBuffers(), FlushRelationBuffers(), LocalBufferAlloc(), pg_buffercache_pages(), PinBuffer(), ReadBuffer_common(), StartBufferIO(), and SyncOneBuffer().

#define BUF_FLAG_MASK 0xFFC00000U

Definition at line 46 of file buf_internals.h.

Referenced by BufferAlloc(), DropRelFileNodeAllLocalBuffers(), DropRelFileNodeLocalBuffers(), InvalidateBuffer(), and PrintBufferLeakWarning().

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

Definition at line 42 of file buf_internals.h.

#define BUF_REFCOUNT_ONE 1

Definition at line 41 of file buf_internals.h.

Referenced by PinBuffer(), PinBuffer_Locked(), and UnpinBuffer().

#define BUF_STATE_GET_REFCOUNT ( state ) ((state) & BUF_REFCOUNT_MASK)

Definition at line 49 of file buf_internals.h.

Referenced by BufferAlloc(), ConditionalLockBufferForCleanup(), GetBufferFromRing(), InvalidateBuffer(), IsBufferCleanupOK(), LockBufferForCleanup(), MarkBufferDirty(), MarkBufferDirtyHint(), pg_buffercache_pages(), PrintBufferLeakWarning(), StrategyGetBuffer(), SyncOneBuffer(), and UnpinBuffer().

#define BUF_STATE_GET_USAGECOUNT ( state ) (((state) & BUF_USAGECOUNT_MASK) >> BUF_USAGECOUNT_SHIFT)

Definition at line 50 of file buf_internals.h.

Referenced by GetBufferFromRing(), LocalBufferAlloc(), pg_buffercache_pages(), PinBuffer(), StrategyGetBuffer(), and SyncOneBuffer().

#define BUF_USAGECOUNT_MASK 0x003C0000U

Definition at line 43 of file buf_internals.h.

Referenced by BufferAlloc(), DropRelFileNodeAllLocalBuffers(), DropRelFileNodeLocalBuffers(), InvalidateBuffer(), and LocalBufferAlloc().

#define BUF_USAGECOUNT_ONE (1U << 18)

Definition at line 44 of file buf_internals.h.

Referenced by BufferAlloc(), LocalBufferAlloc(), PinBuffer(), and StrategyGetBuffer().

#define BUF_USAGECOUNT_SHIFT 18

Definition at line 45 of file buf_internals.h.

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

Definition at line 212 of file buf_internals.h.

#define BufferDescriptorGetBuffer ( bdesc ) ((bdesc)->buf_id + 1)

Definition at line 223 of file buf_internals.h.

Referenced by AddBufferToRing(), InvalidateBuffer(), LocalBufferAlloc(), pg_buffercache_pages(), PinBuffer(), PinBuffer_Locked(), ReadBuffer_common(), StrategyRejectBuffer(), and UnpinBuffer().

#define BufferDescriptorGetContentLock ( bdesc ) ((LWLock*) (&(bdesc)->content_lock))

Definition at line 227 of file buf_internals.h.

Referenced by BufferAlloc(), ConditionalLockBuffer(), FlushDatabaseBuffers(), FlushOneBuffer(), FlushRelationBuffers(), InitBufferPool(), IsBufferCleanupOK(), LockBuffer(), MarkBufferDirty(), MarkBufferDirtyHint(), ReadBuffer_common(), SyncOneBuffer(), and UnpinBuffer().

#define BufferDescriptorGetIOLock ( bdesc ) (&(BufferIOLWLockArray[(bdesc)->buf_id]).lock)

Definition at line 225 of file buf_internals.h.

Referenced by AbortBufferIO(), InitBufferPool(), StartBufferIO(), TerminateBufferIO(), UnpinBuffer(), and WaitIO().

#define BUFFERTAGS_EQUAL	(	a,
		b
	)

Value:

( \
	RelFileNodeEquals((a).rnode, (b).rnode) && \
    (a).blockNum == (b).blockNum && \
    (a).forkNum == (b).forkNum \
)

Definition at line 114 of file buf_internals.h.

Referenced by InvalidateBuffer(), and LocalBufferAlloc().

#define BufMappingPartitionLock ( hashcode )

Value:

(&MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET + \

BufTableHashPartition(hashcode)].lock)

BUFFER_MAPPING_LWLOCK_OFFSET

#define BUFFER_MAPPING_LWLOCK_OFFSET

Definition: lwlock.h:124

BufTableHashPartition

#define BufTableHashPartition(hashcode)

Definition: buf_internals.h:127

LWLockPadded::lock

LWLock lock

Definition: lwlock.h:79

MainLWLockArray

LWLockPadded * MainLWLockArray

Definition: lwlock.c:125

Definition at line 129 of file buf_internals.h.

Referenced by BufferAlloc(), InvalidateBuffer(), and PrefetchBuffer().

#define BufMappingPartitionLockByIndex ( i ) (&MainLWLockArray[BUFFER_MAPPING_LWLOCK_OFFSET + (i)].lock)

Definition at line 132 of file buf_internals.h.

#define BufTableHashPartition ( hashcode ) ((hashcode) % NUM_BUFFER_PARTITIONS)

Definition at line 127 of file buf_internals.h.

#define CLEAR_BUFFERTAG ( a )

Value:

( \
    (a).rnode.spcNode = InvalidOid, \
    (a).rnode.dbNode = InvalidOid, \
    (a).rnode.relNode = InvalidOid, \
    (a).forkNum = InvalidForkNumber, \
    (a).blockNum = InvalidBlockNumber \
)

Definition at line 98 of file buf_internals.h.

Referenced by DropRelFileNodeAllLocalBuffers(), DropRelFileNodeLocalBuffers(), InitBufferPool(), InvalidateBuffer(), and LocalBufferAlloc().

#define FREENEXT_END_OF_LIST (-1)

Definition at line 236 of file buf_internals.h.

Referenced by InitBufferPool().

#define FREENEXT_NOT_IN_LIST (-2)

Definition at line 237 of file buf_internals.h.

Referenced by StrategyFreeBuffer(), and StrategyGetBuffer().

#define GetBufferDescriptor ( id ) (&BufferDescriptors[(id)].bufferdesc)

#define GetLocalBufferDescriptor ( id ) (&LocalBufferDescriptors[(id)])

Definition at line 221 of file buf_internals.h.

Referenced by BufferGetBlockNumber(), BufferGetTag(), DropRelFileNodeAllLocalBuffers(), DropRelFileNodeLocalBuffers(), FlushRelationBuffers(), InitLocalBuffers(), LocalBufferAlloc(), MarkLocalBufferDirty(), PrintBufferLeakWarning(), and ReleaseAndReadBuffer().

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

Value:

( \
    (a).rnode = (xx_rnode), \
    (a).forkNum = (xx_forkNum), \
    (a).blockNum = (xx_blockNum) \
)

Definition at line 107 of file buf_internals.h.

Referenced by BufferAlloc(), LocalBufferAlloc(), LocalPrefetchBuffer(), and PrefetchBuffer().

#define UnlockBufHdr	(	desc,
		s
	)

Value:

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

Definition at line 244 of file buf_internals.h.

Referenced by AbortBufferIO(), apw_dump_now(), BufferAlloc(), BufferGetLSNAtomic(), BufferSync(), ConditionalLockBufferForCleanup(), DropDatabaseBuffers(), DropRelFileNodeBuffers(), DropRelFileNodesAllBuffers(), FlushBuffer(), FlushDatabaseBuffers(), FlushRelationBuffers(), GetBufferFromRing(), InvalidateBuffer(), IsBufferCleanupOK(), LockBufferForCleanup(), MarkBufferDirtyHint(), pg_buffercache_pages(), PinBuffer_Locked(), ReadBuffer_common(), StartBufferIO(), StrategyGetBuffer(), SyncOneBuffer(), TerminateBufferIO(), UnlockBuffers(), UnpinBuffer(), and WaitIO().

Typedef Documentation

typedef struct BufferDesc BufferDesc

typedef union BufferDescPadded BufferDescPadded

typedef struct buftag BufferTag

typedef struct CkptSortItem CkptSortItem

typedef struct PendingWriteback PendingWriteback

typedef struct WritebackContext WritebackContext

Function Documentation

void AtEOXact_LocalBuffers ( bool isCommit )

Definition at line 572 of file localbuf.c.

References CheckForLocalBufferLeaks().

Referenced by AtEOXact_Buffers().

 {
     CheckForLocalBufferLeaks();
 }

void BufTableDelete	(	BufferTag *	tagPtr,
		uint32	hashcode
	)

Definition at line 150 of file buf_table.c.

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

Referenced by BufferAlloc(), and InvalidateBuffer().

 {
     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");
 }

uint32 BufTableHashCode ( BufferTag * tagPtr )

Definition at line 80 of file buf_table.c.

References get_hash_value().

Referenced by BufferAlloc(), InvalidateBuffer(), and PrefetchBuffer().

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

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

Definition at line 120 of file buf_table.c.

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

Referenced by BufferAlloc().

 {
     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;
 }

int BufTableLookup	(	BufferTag *	tagPtr,
		uint32	hashcode
	)

Definition at line 92 of file buf_table.c.

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

Referenced by BufferAlloc(), and PrefetchBuffer().

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

Size BufTableShmemSize ( int size )

Definition at line 43 of file buf_table.c.

References hash_estimate_size().

Referenced by StrategyShmemSize().

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

void DropRelFileNodeAllLocalBuffers ( RelFileNode rnode )

Definition at line 367 of file localbuf.c.

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

Referenced by DropRelFileNodesAllBuffers().

 {
     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) &&
             RelFileNodeEquals(bufHdr->tag.rnode, rnode))
         {
             if (LocalRefCount[i] != 0)
                 elog(ERROR, "block %u of %s is still referenced (local %u)",
                      bufHdr->tag.blockNum,
                      relpathbackend(bufHdr->tag.rnode, 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);
         }
     }
 }

void DropRelFileNodeLocalBuffers	(	RelFileNode	rnode,
		ForkNumber	forkNum,
		BlockNumber	firstDelBlock
	)

Definition at line 320 of file localbuf.c.

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

Referenced by DropRelFileNodeBuffers().

 {
     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) &&
             RelFileNodeEquals(bufHdr->tag.rnode, rnode) &&
             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.rnode, 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);
         }
     }
 }

bool have_free_buffer ( void )

Definition at line 180 of file freelist.c.

References BufferStrategyControl::firstFreeBuffer.

Referenced by apw_load_buffers(), and autoprewarm_database_main().

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

void InitBufTable ( int size )

Definition at line 53 of file buf_table.c.

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

Referenced by StrategyInitialize().

 {
     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);
 }

void IssuePendingWritebacks ( WritebackContext * context )

Definition at line 4276 of file bufmgr.c.

References buftag::blockNum, buffertag_comparator(), cur, buftag::forkNum, i, InvalidBackendId, next, WritebackContext::nr_pending, WritebackContext::pending_writebacks, qsort, RelFileNodeEquals, buftag::rnode, smgropen(), smgrwriteback(), and PendingWriteback::tag.

Referenced by BufferSync(), and ScheduleBufferTagForWriteback().

 {
     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.
      */
     qsort(&context->pending_writebacks, context->nr_pending,
           sizeof(PendingWriteback), buffertag_comparator);
 
     /*
      * 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 (!RelFileNodeEquals(cur->tag.rnode, next->tag.rnode) ||
                 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.rnode, InvalidBackendId);
         smgrwriteback(reln, tag.forkNum, tag.blockNum, nblocks);
     }
 
     context->nr_pending = 0;
 }

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

Definition at line 103 of file localbuf.c.

References Assert, 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, FALSE, buftag::forkNum, GetLocalBufferDescriptor, GetLocalBufferStorage(), HASH_ENTER, HASH_FIND, HASH_REMOVE, hash_search(), LocalBufferLookupEnt::id, INIT_BUFFERTAG, InitLocalBuffers(), BufferUsage::local_blks_written, LocalBufHdrGetBlock, LocalRefCount, MyBackendId, nextFreeLocalBuf, NLocBuffer, RelFileNodeBackend::node, PageSetChecksumInplace(), pg_atomic_read_u32(), pg_atomic_unlocked_write_u32(), pgBufferUsage, RelFileNode::relNode, ResourceOwnerRememberBuffer(), buftag::rnode, SMgrRelationData::smgr_rnode, smgropen(), smgrwrite(), BufferDesc::state, BufferDesc::tag, and TRUE.

Referenced by ReadBuffer_common().

 {
     BufferTag   newTag;         /* identity of requested block */
     LocalBufferLookupEnt *hresult;
     BufferDesc *bufHdr;
     int         b;
     int         trycounter;
     bool        found;
     uint32      buf_state;
 
     INIT_BUFFERTAG(newTag, smgr->smgr_rnode.node, 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_rnode.node.relNode, 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_rnode.node.relNode, 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.rnode, 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;
 }

void LocalPrefetchBuffer	(	SMgrRelation	smgr,
		ForkNumber	forkNum,
		BlockNumber	blockNum
	)

Definition at line 64 of file localbuf.c.

References HASH_FIND, hash_search(), INIT_BUFFERTAG, InitLocalBuffers(), RelFileNodeBackend::node, SMgrRelationData::smgr_rnode, and smgrprefetch().

Referenced by PrefetchBuffer().

 {
 #ifdef USE_PREFETCH
     BufferTag   newTag;         /* identity of requested block */
     LocalBufferLookupEnt *hresult;
 
     INIT_BUFFERTAG(newTag, smgr->smgr_rnode.node, 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 */
         return;
     }
 
     /* Not in buffers, so initiate prefetch */
     smgrprefetch(smgr, forkNum, blockNum);
 #endif                          /* USE_PREFETCH */
 }

uint32 LockBufHdr ( BufferDesc * desc )

Definition at line 4092 of file bufmgr.c.

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(), DropRelFileNodeBuffers(), DropRelFileNodesAllBuffers(), FlushBuffer(), FlushDatabaseBuffers(), FlushRelationBuffers(), GetBufferFromRing(), InvalidateBuffer(), IsBufferCleanupOK(), LockBufferForCleanup(), MarkBufferDirtyHint(), pg_buffercache_pages(), ReadBuffer_common(), StartBufferIO(), StrategyGetBuffer(), SyncOneBuffer(), TerminateBufferIO(), UnlockBuffers(), UnpinBuffer(), and WaitIO().

 {
     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;
 }

void MarkLocalBufferDirty ( Buffer buffer )

Definition at line 280 of file localbuf.c.

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

Referenced by MarkBufferDirty(), and MarkBufferDirtyHint().

 {
     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);
 }

void ScheduleBufferTagForWriteback	(	WritebackContext *	context,
		BufferTag *	tag
	)

Definition at line 4242 of file bufmgr.c.

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

Referenced by BufferAlloc(), and SyncOneBuffer().

 {
     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);
 }

void StrategyFreeBuffer ( BufferDesc * buf )

Definition at line 364 of file freelist.c.

References BufferDesc::buf_id, BufferStrategyControl::buffer_strategy_lock, BufferStrategyControl::firstFreeBuffer, BufferDesc::freeNext, FREENEXT_NOT_IN_LIST, BufferStrategyControl::lastFreeBuffer, SpinLockAcquire, and SpinLockRelease.

Referenced by InvalidateBuffer().

 {
     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);
 }

BufferDesc* StrategyGetBuffer	(	BufferAccessStrategy	strategy,
		uint32 *	buf_state
	)

Definition at line 201 of file freelist.c.

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, BufferDesc::freeNext, FREENEXT_NOT_IN_LIST, GetBufferDescriptor, GetBufferFromRing(), INT_ACCESS_ONCE, LockBufHdr(), NBuffers, BufferStrategyControl::numBufferAllocs, pg_atomic_fetch_add_u32(), ProcGlobal, PGPROC::procLatch, SetLatch(), SpinLockAcquire, SpinLockRelease, and UnlockBufHdr.

Referenced by BufferAlloc().

 {
     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 bgprocno 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);
     }
 }

void StrategyInitialize ( bool init )

Definition at line 475 of file freelist.c.

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

Referenced by InitBufferPool().

 {
     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);
 }

void StrategyNotifyBgWriter ( int bgwprocno )

Definition at line 432 of file freelist.c.

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

Referenced by BackgroundWriterMain().

 {
     /*
      * 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);
 }

bool StrategyRejectBuffer	(	BufferAccessStrategy	strategy,
		BufferDesc *	buf
	)

Definition at line 686 of file freelist.c.

References BAS_BULKREAD, BufferAccessStrategyData::btype, BufferDescriptorGetBuffer, BufferAccessStrategyData::buffers, BufferAccessStrategyData::current, BufferAccessStrategyData::current_was_in_ring, and InvalidBuffer.

Referenced by BufferAlloc().

 {
     /* 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;
 }

Size StrategyShmemSize ( void )

Definition at line 454 of file freelist.c.

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

Referenced by BufferShmemSize().

 {
     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;
 }

int StrategySyncStart	(	uint32 *	complete_passes,
		uint32 *	num_buf_alloc
	)

Definition at line 395 of file freelist.c.

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

Referenced by BgBufferSync().

 {
     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;
 }

void WritebackContextInit	(	WritebackContext *	context,
		int *	max_pending
	)

Definition at line 4230 of file bufmgr.c.

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

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

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

Variable Documentation

PGDLLIMPORT WritebackContext BackendWritebackContext

Definition at line 24 of file buf_init.c.

Referenced by BufferAlloc().

PGDLLIMPORT BufferDescPadded* BufferDescriptors

Definition at line 21 of file buf_init.c.

PGDLLIMPORT LWLockMinimallyPadded* BufferIOLWLockArray

Definition at line 23 of file buf_init.c.

CkptSortItem* CkptBufferIds

Definition at line 25 of file buf_init.c.

Referenced by BufferSync().

BufferDesc* LocalBufferDescriptors

Definition at line 43 of file localbuf.c.

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

Typedef Documentation

Function Documentation

Variable Documentation