#include "postgres.h"
#include "storage/buf_internals.h"
#include "storage/bufmgr.h"
#include "storage/proc.h"

Include dependency graph for buf_init.c:

Functions
void	InitBufferPool (void)

Size	BufferShmemSize (void)

Variables
BufferDescPadded *	BufferDescriptors

char *	BufferBlocks

ConditionVariableMinimallyPadded *	BufferIOCVArray

WritebackContext	BackendWritebackContext

CkptSortItem *	CkptBufferIds

Function Documentation

◆ BufferShmemSize()

Size BufferShmemSize ( void )

Definition at line 160 of file buf_init.c.

 {
     Size        size = 0;
  
     /* size of buffer descriptors */
     size = add_size(size, mul_size(NBuffers, sizeof(BufferDescPadded)));
     /* to allow aligning buffer descriptors */
     size = add_size(size, PG_CACHE_LINE_SIZE);
  
     /* size of data pages, plus alignment padding */
     size = add_size(size, PG_IO_ALIGN_SIZE);
     size = add_size(size, mul_size(NBuffers, BLCKSZ));
  
     /* size of stuff controlled by freelist.c */
     size = add_size(size, StrategyShmemSize());
  
     /* size of I/O condition variables */
     size = add_size(size, mul_size(NBuffers,
                                    sizeof(ConditionVariableMinimallyPadded)));
     /* to allow aligning the above */
     size = add_size(size, PG_CACHE_LINE_SIZE);
  
     /* size of checkpoint sort array in bufmgr.c */
     size = add_size(size, mul_size(NBuffers, sizeof(CkptSortItem)));
  
     return size;
 }

References add_size(), mul_size(), NBuffers, PG_CACHE_LINE_SIZE, PG_IO_ALIGN_SIZE, and StrategyShmemSize().

Referenced by CalculateShmemSize().

◆ InitBufferPool()

void InitBufferPool ( void )

Definition at line 68 of file buf_init.c.

 {
     bool        foundBufs,
                 foundDescs,
                 foundIOCV,
                 foundBufCkpt;
  
     /* Align descriptors to a cacheline boundary. */
     BufferDescriptors = (BufferDescPadded *)
         ShmemInitStruct("Buffer Descriptors",
                         NBuffers * sizeof(BufferDescPadded),
                         &foundDescs);
  
     /* Align buffer pool on IO page size boundary. */
     BufferBlocks = (char *)
         TYPEALIGN(PG_IO_ALIGN_SIZE,
                   ShmemInitStruct("Buffer Blocks",
                                   NBuffers * (Size) BLCKSZ + PG_IO_ALIGN_SIZE,
                                   &foundBufs));
  
     /* Align condition variables to cacheline boundary. */
     BufferIOCVArray = (ConditionVariableMinimallyPadded *)
         ShmemInitStruct("Buffer IO Condition Variables",
                         NBuffers * sizeof(ConditionVariableMinimallyPadded),
                         &foundIOCV);
  
     /*
      * The array used to sort to-be-checkpointed buffer ids is located in
      * shared memory, to avoid having to allocate significant amounts of
      * memory at runtime. As that'd be in the middle of a checkpoint, or when
      * the checkpointer is restarted, memory allocation failures would be
      * painful.
      */
     CkptBufferIds = (CkptSortItem *)
         ShmemInitStruct("Checkpoint BufferIds",
                         NBuffers * sizeof(CkptSortItem), &foundBufCkpt);
  
     if (foundDescs || foundBufs || foundIOCV || foundBufCkpt)
     {
         /* should find all of these, or none of them */
         Assert(foundDescs && foundBufs && foundIOCV && foundBufCkpt);
         /* note: this path is only taken in EXEC_BACKEND case */
     }
     else
     {
         int         i;
  
         /*
          * Initialize all the buffer headers.
          */
         for (i = 0; i < NBuffers; i++)
         {
             BufferDesc *buf = GetBufferDescriptor(i);
  
             ClearBufferTag(&buf->tag);
  
             pg_atomic_init_u32(&buf->state, 0);
             buf->wait_backend_pgprocno = INVALID_PGPROCNO;
  
             buf->buf_id = i;
  
             /*
              * Initially link all the buffers together as unused. Subsequent
              * management of this list is done by freelist.c.
              */
             buf->freeNext = i + 1;
  
             LWLockInitialize(BufferDescriptorGetContentLock(buf),
                              LWTRANCHE_BUFFER_CONTENT);
  
             ConditionVariableInit(BufferDescriptorGetIOCV(buf));
         }
  
         /* Correct last entry of linked list */
         GetBufferDescriptor(NBuffers - 1)->freeNext = FREENEXT_END_OF_LIST;
     }
  
     /* Init other shared buffer-management stuff */
     StrategyInitialize(!foundDescs);
  
     /* Initialize per-backend file flush context */
     WritebackContextInit(&BackendWritebackContext,
                          &backend_flush_after);
 }