PostgreSQL Source Code git master
Data Structures | Macros | Typedefs | Functions | Variables
freelist.c File Reference
#include "postgres.h"
#include "pgstat.h"
#include "port/atomics.h"
#include "storage/buf_internals.h"
#include "storage/bufmgr.h"
#include "storage/proc.h"
Include dependency graph for freelist.c:

Go to the source code of this file.

Data Structures

struct   BufferStrategyControl
 
struct   BufferAccessStrategyData
 

Macros

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

Typedefs

typedef struct BufferAccessStrategyData  BufferAccessStrategyData
 

Functions

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

Variables

static BufferStrategyControl *  StrategyControl = NULL
 

Macro Definition Documentation

◆ INT_ACCESS_ONCE

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

Definition at line 24 of file freelist.c.

Typedef Documentation

◆ BufferAccessStrategyData

typedef struct BufferAccessStrategyData BufferAccessStrategyData

Function Documentation

◆ AddBufferToRing()

static void AddBufferToRing ( BufferAccessStrategy  strategy,
BufferDesc *  buf 
)
static

Definition at line 673 of file freelist.c.

674{
675 strategy->buffers[strategy->current] = BufferDescriptorGetBuffer(buf);
676}
static Buffer BufferDescriptorGetBuffer(const BufferDesc *bdesc)
Definition: buf_internals.h:343
static char * buf
Definition: pg_test_fsync.c:72
Buffer buffers[FLEXIBLE_ARRAY_MEMBER]
Definition: freelist.c:83

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

Referenced by StrategyGetBuffer().

◆ ClockSweepTick()

static uint32 ClockSweepTick ( void  )
inlinestatic

Definition at line 100 of file freelist.c.

101{
102 uint32 victim;
103
104 /*
105 * Atomically move hand ahead one buffer - if there's several processes
106 * doing this, this can lead to buffers being returned slightly out of
107 * apparent order.
108 */
109 victim =
111
112 if (victim >= NBuffers)
113 {
114 uint32 originalVictim = victim;
115
116 /* always wrap what we look up in BufferDescriptors */
117 victim = victim % NBuffers;
118
119 /*
120 * If we're the one that just caused a wraparound, force
121 * completePasses to be incremented while holding the spinlock. We
122 * need the spinlock so StrategySyncStart() can return a consistent
123 * value consisting of nextVictimBuffer and completePasses.
124 */
125 if (victim == 0)
126 {
127 uint32 expected;
128 uint32 wrapped;
129 bool success = false;
130
131 expected = originalVictim + 1;
132
133 while (!success)
134 {
135 /*
136 * Acquire the spinlock while increasing completePasses. That
137 * allows other readers to read nextVictimBuffer and
138 * completePasses in a consistent manner which is required for
139 * StrategySyncStart(). In theory delaying the increment
140 * could lead to an overflow of nextVictimBuffers, but that's
141 * highly unlikely and wouldn't be particularly harmful.
142 */
144
145 wrapped = expected % NBuffers;
146
148 &expected, wrapped);
149 if (success)
152 }
153 }
154 }
155 return victim;
156}
static bool pg_atomic_compare_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 *expected, uint32 newval)
Definition: atomics.h:347
static uint32 pg_atomic_fetch_add_u32(volatile pg_atomic_uint32 *ptr, int32 add_)
Definition: atomics.h:364
uint32_t uint32
Definition: c.h:538
static BufferStrategyControl * StrategyControl
Definition: freelist.c:57
int NBuffers
Definition: globals.c:142
static bool success
Definition: initdb.c:187
#define SpinLockRelease(lock)
Definition: spin.h:61
#define SpinLockAcquire(lock)
Definition: spin.h:59
pg_atomic_uint32 nextVictimBuffer
Definition: freelist.c:40
uint32 completePasses
Definition: freelist.c:46
slock_t buffer_strategy_lock
Definition: freelist.c:33

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

Referenced by StrategyGetBuffer().

◆ FreeAccessStrategy()

void FreeAccessStrategy ( BufferAccessStrategy  strategy )

Definition at line 606 of file freelist.c.

607{
608 /* don't crash if called on a "default" strategy */
609 if (strategy != NULL)
610 pfree(strategy);
611}
void pfree(void *pointer)
Definition: mcxt.c:1594

References pfree().

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

◆ GetAccessStrategy()

BufferAccessStrategy GetAccessStrategy ( BufferAccessStrategyType  btype )

Definition at line 424 of file freelist.c.

425{
426 int ring_size_kb;
427
428 /*
429 * Select ring size to use. See buffer/README for rationales.
430 *
431 * Note: if you change the ring size for BAS_BULKREAD, see also
432 * SYNC_SCAN_REPORT_INTERVAL in access/heap/syncscan.c.
433 */
434 switch (btype)
435 {
436 case BAS_NORMAL:
437 /* if someone asks for NORMAL, just give 'em a "default" object */
438 return NULL;
439
440 case BAS_BULKREAD:
441 {
442 int ring_max_kb;
443
444 /*
445 * The ring always needs to be large enough to allow some
446 * separation in time between providing a buffer to the user
447 * of the strategy and that buffer being reused. Otherwise the
448 * user's pin will prevent reuse of the buffer, even without
449 * concurrent activity.
450 *
451 * We also need to ensure the ring always is large enough for
452 * SYNC_SCAN_REPORT_INTERVAL, as noted above.
453 *
454 * Thus we start out a minimal size and increase the size
455 * further if appropriate.
456 */
457 ring_size_kb = 256;
458
459 /*
460 * There's no point in a larger ring if we won't be allowed to
461 * pin sufficiently many buffers. But we never limit to less
462 * than the minimal size above.
463 */
464 ring_max_kb = GetPinLimit() * (BLCKSZ / 1024);
465 ring_max_kb = Max(ring_size_kb, ring_max_kb);
466
467 /*
468 * We would like the ring to additionally have space for the
469 * configured degree of IO concurrency. While being read in,
470 * buffers can obviously not yet be reused.
471 *
472 * Each IO can be up to io_combine_limit blocks large, and we
473 * want to start up to effective_io_concurrency IOs.
474 *
475 * Note that effective_io_concurrency may be 0, which disables
476 * AIO.
477 */
478 ring_size_kb += (BLCKSZ / 1024) *
480
481 if (ring_size_kb > ring_max_kb)
482 ring_size_kb = ring_max_kb;
483 break;
484 }
485 case BAS_BULKWRITE:
486 ring_size_kb = 16 * 1024;
487 break;
488 case BAS_VACUUM:
489 ring_size_kb = 2048;
490 break;
491
492 default:
493 elog(ERROR, "unrecognized buffer access strategy: %d",
494 (int) btype);
495 return NULL; /* keep compiler quiet */
496 }
497
498 return GetAccessStrategyWithSize(btype, ring_size_kb);
499}
int effective_io_concurrency
Definition: bufmgr.c:155
int io_combine_limit
Definition: bufmgr.c:170
uint32 GetPinLimit(void)
Definition: bufmgr.c:2493
@ BAS_BULKREAD
Definition: bufmgr.h:37
@ BAS_NORMAL
Definition: bufmgr.h:36
@ BAS_VACUUM
Definition: bufmgr.h:40
@ BAS_BULKWRITE
Definition: bufmgr.h:39
#define Max(x, y)
Definition: c.h:997
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
BufferAccessStrategy GetAccessStrategyWithSize(BufferAccessStrategyType btype, int ring_size_kb)
Definition: freelist.c:509

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

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

◆ GetAccessStrategyBufferCount()

int GetAccessStrategyBufferCount ( BufferAccessStrategy  strategy )

Definition at line 549 of file freelist.c.

550{
551 if (strategy == NULL)
552 return 0;
553
554 return strategy->nbuffers;
555}

References BufferAccessStrategyData::nbuffers.

Referenced by parallel_vacuum_init().

◆ GetAccessStrategyPinLimit()

int GetAccessStrategyPinLimit ( BufferAccessStrategy  strategy )

Definition at line 572 of file freelist.c.

573{
574 if (strategy == NULL)
575 return NBuffers;
576
577 switch (strategy->btype)
578 {
579 case BAS_BULKREAD:
580
581 /*
582 * Since BAS_BULKREAD uses StrategyRejectBuffer(), dirty buffers
583 * shouldn't be a problem and the caller is free to pin up to the
584 * entire ring at once.
585 */
586 return strategy->nbuffers;
587
588 default:
589
590 /*
591 * Tell caller not to pin more than half the buffers in the ring.
592 * This is a trade-off between look ahead distance and deferring
593 * writeback and associated WAL traffic.
594 */
595 return strategy->nbuffers / 2;
596 }
597}
BufferAccessStrategyType btype
Definition: freelist.c:67

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

Referenced by read_stream_begin_impl().

◆ GetAccessStrategyWithSize()

BufferAccessStrategy GetAccessStrategyWithSize ( BufferAccessStrategyType  btype,
int  ring_size_kb 
)

Definition at line 509 of file freelist.c.

510{
511 int ring_buffers;
512 BufferAccessStrategy strategy;
513
514 Assert(ring_size_kb >= 0);
515
516 /* Figure out how many buffers ring_size_kb is */
517 ring_buffers = ring_size_kb / (BLCKSZ / 1024);
518
519 /* 0 means unlimited, so no BufferAccessStrategy required */
520 if (ring_buffers == 0)
521 return NULL;
522
523 /* Cap to 1/8th of shared_buffers */
524 ring_buffers = Min(NBuffers / 8, ring_buffers);
525
526 /* NBuffers should never be less than 16, so this shouldn't happen */
527 Assert(ring_buffers > 0);
528
529 /* Allocate the object and initialize all elements to zeroes */
530 strategy = (BufferAccessStrategy)
531 palloc0(offsetof(BufferAccessStrategyData, buffers) +
532 ring_buffers * sizeof(Buffer));
533
534 /* Set fields that don't start out zero */
535 strategy->btype = btype;
536 strategy->nbuffers = ring_buffers;
537
538 return strategy;
539}
int Buffer
Definition: buf.h:23
struct BufferAccessStrategyData * BufferAccessStrategy
Definition: buf.h:44
#define Min(x, y)
Definition: c.h:1003
Assert(PointerIsAligned(start, uint64))
void * palloc0(Size size)
Definition: mcxt.c:1395

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

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

◆ GetBufferFromRing()

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

Definition at line 620 of file freelist.c.

621{
623 Buffer bufnum;
624 uint32 local_buf_state; /* to avoid repeated (de-)referencing */
625
626
627 /* Advance to next ring slot */
628 if (++strategy->current >= strategy->nbuffers)
629 strategy->current = 0;
630
631 /*
632 * If the slot hasn't been filled yet, tell the caller to allocate a new
633 * buffer with the normal allocation strategy. He will then fill this
634 * slot by calling AddBufferToRing with the new buffer.
635 */
636 bufnum = strategy->buffers[strategy->current];
637 if (bufnum == InvalidBuffer)
638 return NULL;
639
640 /*
641 * If the buffer is pinned we cannot use it under any circumstances.
642 *
643 * If usage_count is 0 or 1 then the buffer is fair game (we expect 1,
644 * since our own previous usage of the ring element would have left it
645 * there, but it might've been decremented by clock-sweep since then). A
646 * higher usage_count indicates someone else has touched the buffer, so we
647 * shouldn't re-use it.
648 */
649 buf = GetBufferDescriptor(bufnum - 1);
650 local_buf_state = LockBufHdr(buf);
651 if (BUF_STATE_GET_REFCOUNT(local_buf_state) == 0
652 && BUF_STATE_GET_USAGECOUNT(local_buf_state) <= 1)
653 {
654 *buf_state = local_buf_state;
655 return buf;
656 }
657 UnlockBufHdr(buf, local_buf_state);
658
659 /*
660 * Tell caller to allocate a new buffer with the normal allocation
661 * strategy. He'll then replace this ring element via AddBufferToRing.
662 */
663 return NULL;
664}
#define InvalidBuffer
Definition: buf.h:25
static void UnlockBufHdr(BufferDesc *desc, uint32 buf_state)
Definition: buf_internals.h:367
#define BUF_STATE_GET_USAGECOUNT(state)
Definition: buf_internals.h:60
#define BUF_STATE_GET_REFCOUNT(state)
Definition: buf_internals.h:59
static BufferDesc * GetBufferDescriptor(uint32 id)
Definition: buf_internals.h:331
uint32 LockBufHdr(BufferDesc *desc)
Definition: bufmgr.c:6224

References buf, BUF_STATE_GET_REFCOUNT, BUF_STATE_GET_USAGECOUNT, BufferAccessStrategyData::buffers, BufferAccessStrategyData::current, GetBufferDescriptor(), InvalidBuffer, LockBufHdr(), BufferAccessStrategyData::nbuffers, and UnlockBufHdr().

Referenced by StrategyGetBuffer().

◆ IOContextForStrategy()

IOContext IOContextForStrategy ( BufferAccessStrategy  strategy )

Definition at line 683 of file freelist.c.

684{
685 if (!strategy)
686 return IOCONTEXT_NORMAL;
687
688 switch (strategy->btype)
689 {
690 case BAS_NORMAL:
691
692 /*
693 * Currently, GetAccessStrategy() returns NULL for
694 * BufferAccessStrategyType BAS_NORMAL, so this case is
695 * unreachable.
696 */
698 return IOCONTEXT_NORMAL;
699 case BAS_BULKREAD:
700 return IOCONTEXT_BULKREAD;
701 case BAS_BULKWRITE:
702 return IOCONTEXT_BULKWRITE;
703 case BAS_VACUUM:
704 return IOCONTEXT_VACUUM;
705 }
706
707 elog(ERROR, "unrecognized BufferAccessStrategyType: %d", strategy->btype);
709}
#define pg_unreachable()
Definition: c.h:331
@ IOCONTEXT_NORMAL
Definition: pgstat.h:287
@ IOCONTEXT_VACUUM
Definition: pgstat.h:288
@ IOCONTEXT_BULKREAD
Definition: pgstat.h:284
@ IOCONTEXT_BULKWRITE
Definition: pgstat.h:285

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

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

◆ StrategyGetBuffer()

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

Definition at line 171 of file freelist.c.

172{
174 int bgwprocno;
175 int trycounter;
176 uint32 local_buf_state; /* to avoid repeated (de-)referencing */
177
178 *from_ring = false;
179
180 /*
181 * If given a strategy object, see whether it can select a buffer. We
182 * assume strategy objects don't need buffer_strategy_lock.
183 */
184 if (strategy != NULL)
185 {
186 buf = GetBufferFromRing(strategy, buf_state);
187 if (buf != NULL)
188 {
189 *from_ring = true;
190 return buf;
191 }
192 }
193
194 /*
195 * If asked, we need to waken the bgwriter. Since we don't want to rely on
196 * a spinlock for this we force a read from shared memory once, and then
197 * set the latch based on that value. We need to go through that length
198 * because otherwise bgwprocno might be reset while/after we check because
199 * the compiler might just reread from memory.
200 *
201 * This can possibly set the latch of the wrong process if the bgwriter
202 * dies in the wrong moment. But since PGPROC->procLatch is never
203 * deallocated the worst consequence of that is that we set the latch of
204 * some arbitrary process.
205 */
207 if (bgwprocno != -1)
208 {
209 /* reset bgwprocno first, before setting the latch */
211
212 /*
213 * Not acquiring ProcArrayLock here which is slightly icky. It's
214 * actually fine because procLatch isn't ever freed, so we just can
215 * potentially set the wrong process' (or no process') latch.
216 */
218 }
219
220 /*
221 * We count buffer allocation requests so that the bgwriter can estimate
222 * the rate of buffer consumption. Note that buffers recycled by a
223 * strategy object are intentionally not counted here.
224 */
226
227 /* Use the "clock sweep" algorithm to find a free buffer */
228 trycounter = NBuffers;
229 for (;;)
230 {
232
233 /*
234 * If the buffer is pinned or has a nonzero usage_count, we cannot use
235 * it; decrement the usage_count (unless pinned) and keep scanning.
236 */
237 local_buf_state = LockBufHdr(buf);
238
239 if (BUF_STATE_GET_REFCOUNT(local_buf_state) == 0)
240 {
241 if (BUF_STATE_GET_USAGECOUNT(local_buf_state) != 0)
242 {
243 local_buf_state -= BUF_USAGECOUNT_ONE;
244
245 trycounter = NBuffers;
246 }
247 else
248 {
249 /* Found a usable buffer */
250 if (strategy != NULL)
251 AddBufferToRing(strategy, buf);
252 *buf_state = local_buf_state;
253 return buf;
254 }
255 }
256 else if (--trycounter == 0)
257 {
258 /*
259 * We've scanned all the buffers without making any state changes,
260 * so all the buffers are pinned (or were when we looked at them).
261 * We could hope that someone will free one eventually, but it's
262 * probably better to fail than to risk getting stuck in an
263 * infinite loop.
264 */
265 UnlockBufHdr(buf, local_buf_state);
266 elog(ERROR, "no unpinned buffers available");
267 }
268 UnlockBufHdr(buf, local_buf_state);
269 }
270}
#define BUF_USAGECOUNT_ONE
Definition: buf_internals.h:54
static uint32 ClockSweepTick(void)
Definition: freelist.c:100
static void AddBufferToRing(BufferAccessStrategy strategy, BufferDesc *buf)
Definition: freelist.c:673
#define INT_ACCESS_ONCE(var)
Definition: freelist.c:24
static BufferDesc * GetBufferFromRing(BufferAccessStrategy strategy, uint32 *buf_state)
Definition: freelist.c:620
void SetLatch(Latch *latch)
Definition: latch.c:290
PROC_HDR * ProcGlobal
Definition: proc.c:78
pg_atomic_uint32 numBufferAllocs
Definition: freelist.c:47
Latch procLatch
Definition: proc.h:186
PGPROC * allProcs
Definition: proc.h:388

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

Referenced by GetVictimBuffer().

◆ StrategyInitialize()

void StrategyInitialize ( bool  init )

Definition at line 364 of file freelist.c.

365{
366 bool found;
367
368 /*
369 * Initialize the shared buffer lookup hashtable.
370 *
371 * Since we can't tolerate running out of lookup table entries, we must be
372 * sure to specify an adequate table size here. The maximum steady-state
373 * usage is of course NBuffers entries, but BufferAlloc() tries to insert
374 * a new entry before deleting the old. In principle this could be
375 * happening in each partition concurrently, so we could need as many as
376 * NBuffers + NUM_BUFFER_PARTITIONS entries.
377 */
379
380 /*
381 * Get or create the shared strategy control block
382 */
384 ShmemInitStruct("Buffer Strategy Status",
385 sizeof(BufferStrategyControl),
386 &found);
387
388 if (!found)
389 {
390 /*
391 * Only done once, usually in postmaster
392 */
393 Assert(init);
394
396
397 /* Initialize the clock-sweep pointer */
399
400 /* Clear statistics */
403
404 /* No pending notification */
406 }
407 else
408 Assert(!init);
409}
static void pg_atomic_init_u32(volatile pg_atomic_uint32 *ptr, uint32 val)
Definition: atomics.h:219
void InitBufTable(int size)
Definition: buf_table.c:51
int init
Definition: isn.c:79
#define NUM_BUFFER_PARTITIONS
Definition: lwlock.h:91
void * ShmemInitStruct(const char *name, Size size, bool *foundPtr)
Definition: shmem.c:387
#define SpinLockInit(lock)
Definition: spin.h:57

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

Referenced by BufferManagerShmemInit().

◆ StrategyNotifyBgWriter()

void StrategyNotifyBgWriter ( int  bgwprocno )

Definition at line 321 of file freelist.c.

322{
323 /*
324 * We acquire buffer_strategy_lock just to ensure that the store appears
325 * atomic to StrategyGetBuffer. The bgwriter should call this rather
326 * infrequently, so there's no performance penalty from being safe.
327 */
329 StrategyControl->bgwprocno = bgwprocno;
331}

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 723 of file freelist.c.

724{
725 /* We only do this in bulkread mode */
726 if (strategy->btype != BAS_BULKREAD)
727 return false;
728
729 /* Don't muck with behavior of normal buffer-replacement strategy */
730 if (!from_ring ||
731 strategy->buffers[strategy->current] != BufferDescriptorGetBuffer(buf))
732 return false;
733
734 /*
735 * Remove the dirty buffer from the ring; necessary to prevent infinite
736 * loop if all ring members are dirty.
737 */
738 strategy->buffers[strategy->current] = InvalidBuffer;
739
740 return true;
741}

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

Referenced by GetVictimBuffer().

◆ StrategyShmemSize()

Size StrategyShmemSize ( void  )

Definition at line 343 of file freelist.c.

344{
345 Size size = 0;
346
347 /* size of lookup hash table ... see comment in StrategyInitialize */
349
350 /* size of the shared replacement strategy control block */
351 size = add_size(size, MAXALIGN(sizeof(BufferStrategyControl)));
352
353 return size;
354}
Size BufTableShmemSize(int size)
Definition: buf_table.c:41
#define MAXALIGN(LEN)
Definition: c.h:810
size_t Size
Definition: c.h:610
Size add_size(Size s1, Size s2)
Definition: shmem.c:493

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

Referenced by BufferManagerShmemSize().

◆ StrategySyncStart()

int StrategySyncStart ( uint32 *  complete_passes,
uint32 *  num_buf_alloc 
)

Definition at line 284 of file freelist.c.

285{
286 uint32 nextVictimBuffer;
287 int result;
288
291 result = nextVictimBuffer % NBuffers;
292
293 if (complete_passes)
294 {
295 *complete_passes = StrategyControl->completePasses;
296
297 /*
298 * Additionally add the number of wraparounds that happened before
299 * completePasses could be incremented. C.f. ClockSweepTick().
300 */
301 *complete_passes += nextVictimBuffer / NBuffers;
302 }
303
304 if (num_buf_alloc)
305 {
307 }
309 return result;
310}
static uint32 pg_atomic_read_u32(volatile pg_atomic_uint32 *ptr)
Definition: atomics.h:237
static uint32 pg_atomic_exchange_u32(volatile pg_atomic_uint32 *ptr, uint32 newval)
Definition: atomics.h:328

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

Referenced by BgBufferSync().

Variable Documentation

◆ StrategyControl

BufferStrategyControl* StrategyControl = NULL
static

Definition at line 57 of file freelist.c.

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

AltStyle によって変換されたページ (->オリジナル) /