Rename BgWriterShmem/Request to CheckpointerShmem/Request

diff --git a/src/backend/postmaster/checkpointer.c b/src/backend/postmaster/checkpointer.c
index fa35d4004528336aaddfb0614105b6077e3f46c3..ba268e7cf49dd73248cb91527a3d8b24ce8237bc 100644 (file)
--- a/src/backend/postmaster/checkpointer.c
+++ b/src/backend/postmaster/checkpointer.c
@@ -110,7 +110,7 @@ typedef struct
    ForkNumber  forknum;
    BlockNumber segno;          /* see md.c for special values */
    /* might add a real request-type field later; not needed yet */
-} BgWriterRequest;
+} CheckpointerRequest;
 
 typedef struct
 {
@@ -129,10 +129,10 @@ typedef struct
 
    int         num_requests;   /* current # of requests */
    int         max_requests;   /* allocated array size */
-   BgWriterRequest requests[1];    /* VARIABLE LENGTH ARRAY */
-} BgWriterShmemStruct;
+   CheckpointerRequest requests[1];    /* VARIABLE LENGTH ARRAY */
+} CheckpointerShmemStruct;
 
-static BgWriterShmemStruct *BgWriterShmem;
+static CheckpointerShmemStruct *CheckpointerShmem;
 
 /* interval for calling AbsorbFsyncRequests in CheckpointWriteDelay */
 #define WRITES_PER_ABSORB      1000
@@ -195,7 +195,7 @@ CheckpointerMain(void)
    sigjmp_buf  local_sigjmp_buf;
    MemoryContext checkpointer_context;
 
-   BgWriterShmem->checkpointer_pid = MyProcPid;
+   CheckpointerShmem->checkpointer_pid = MyProcPid;
    am_checkpointer = true;
 
    /*
@@ -302,7 +302,7 @@ CheckpointerMain(void)
        if (ckpt_active)
        {
            /* use volatile pointer to prevent code rearrangement */
-           volatile BgWriterShmemStruct *bgs = BgWriterShmem;
+           volatile CheckpointerShmemStruct *bgs = CheckpointerShmem;
 
            SpinLockAcquire(&bgs->ckpt_lck);
            bgs->ckpt_failed++;
@@ -455,7 +455,7 @@ CheckpointerMain(void)
            bool        do_restartpoint;
 
            /* use volatile pointer to prevent code rearrangement */
-           volatile BgWriterShmemStruct *bgs = BgWriterShmem;
+           volatile CheckpointerShmemStruct *bgs = CheckpointerShmem;
 
            /*
             * Check if we should perform a checkpoint or a restartpoint. As a
@@ -651,7 +651,7 @@ ImmediateCheckpointRequested(void)
 {
    if (checkpoint_requested)
    {
-       volatile BgWriterShmemStruct *bgs = BgWriterShmem;
+       volatile CheckpointerShmemStruct *bgs = CheckpointerShmem;
 
        /*
         * We don't need to acquire the ckpt_lck in this case because we're
@@ -893,11 +893,11 @@ ReqShutdownHandler(SIGNAL_ARGS)
  */
 
 /*
- * BgWriterShmemSize
+ * CheckpointerShmemSize
  *     Compute space needed for bgwriter-related shared memory
  */
 Size
-BgWriterShmemSize(void)
+CheckpointerShmemSize(void)
 {
    Size        size;
 
@@ -905,32 +905,32 @@ BgWriterShmemSize(void)
     * Currently, the size of the requests[] array is arbitrarily set equal to
     * NBuffers.  This may prove too large or small ...
     */
-   size = offsetof(BgWriterShmemStruct, requests);
-   size = add_size(size, mul_size(NBuffers, sizeof(BgWriterRequest)));
+   size = offsetof(CheckpointerShmemStruct, requests);
+   size = add_size(size, mul_size(NBuffers, sizeof(CheckpointerRequest)));
 
    return size;
 }
 
 /*
- * BgWriterShmemInit
+ * CheckpointerShmemInit
  *     Allocate and initialize bgwriter-related shared memory
  */
 void
-BgWriterShmemInit(void)
+CheckpointerShmemInit(void)
 {
    bool        found;
 
-   BgWriterShmem = (BgWriterShmemStruct *)
+   CheckpointerShmem = (CheckpointerShmemStruct *)
        ShmemInitStruct("Background Writer Data",
-                       BgWriterShmemSize(),
+                       CheckpointerShmemSize(),
                        &found);
 
    if (!found)
    {
        /* First time through, so initialize */
-       MemSet(BgWriterShmem, 0, sizeof(BgWriterShmemStruct));
-       SpinLockInit(&BgWriterShmem->ckpt_lck);
-       BgWriterShmem->max_requests = NBuffers;
+       MemSet(CheckpointerShmem, 0, sizeof(CheckpointerShmemStruct));
+       SpinLockInit(&CheckpointerShmem->ckpt_lck);
+       CheckpointerShmem->max_requests = NBuffers;
    }
 }
 
@@ -955,7 +955,7 @@ void
 RequestCheckpoint(int flags)
 {
    /* use volatile pointer to prevent code rearrangement */
-   volatile BgWriterShmemStruct *bgs = BgWriterShmem;
+   volatile CheckpointerShmemStruct *bgs = CheckpointerShmem;
    int         ntries;
    int         old_failed,
                old_started;
@@ -1006,7 +1006,7 @@ RequestCheckpoint(int flags)
     */
    for (ntries = 0;; ntries++)
    {
-       if (BgWriterShmem->checkpointer_pid == 0)
+       if (CheckpointerShmem->checkpointer_pid == 0)
        {
            if (ntries >= 20)   /* max wait 2.0 sec */
            {
@@ -1015,7 +1015,7 @@ RequestCheckpoint(int flags)
                break;
            }
        }
-       else if (kill(BgWriterShmem->checkpointer_pid, SIGINT) != 0)
+       else if (kill(CheckpointerShmem->checkpointer_pid, SIGINT) != 0)
        {
            if (ntries >= 20)   /* max wait 2.0 sec */
            {
@@ -1109,7 +1109,7 @@ bool
 ForwardFsyncRequest(RelFileNodeBackend rnode, ForkNumber forknum,
                    BlockNumber segno)
 {
-   BgWriterRequest *request;
+   CheckpointerRequest *request;
    bool        too_full;
 
    if (!IsUnderPostmaster)
@@ -1121,35 +1121,35 @@ ForwardFsyncRequest(RelFileNodeBackend rnode, ForkNumber forknum,
    LWLockAcquire(CheckpointerCommLock, LW_EXCLUSIVE);
 
    /* Count all backend writes regardless of if they fit in the queue */
-   BgWriterShmem->num_backend_writes++;
+   CheckpointerShmem->num_backend_writes++;
 
    /*
     * If the checkpointer isn't running or the request queue is full,
     * the backend will have to perform its own fsync request.  But before
     * forcing that to happen, we can try to compact the request queue.
     */
-   if (BgWriterShmem->checkpointer_pid == 0 ||
-       (BgWriterShmem->num_requests >= BgWriterShmem->max_requests &&
+   if (CheckpointerShmem->checkpointer_pid == 0 ||
+       (CheckpointerShmem->num_requests >= CheckpointerShmem->max_requests &&
         !CompactCheckpointerRequestQueue()))
    {
        /*
         * Count the subset of writes where backends have to do their own
         * fsync
         */
-       BgWriterShmem->num_backend_fsync++;
+       CheckpointerShmem->num_backend_fsync++;
        LWLockRelease(CheckpointerCommLock);
        return false;
    }
 
    /* OK, insert request */
-   request = &BgWriterShmem->requests[BgWriterShmem->num_requests++];
+   request = &CheckpointerShmem->requests[CheckpointerShmem->num_requests++];
    request->rnode = rnode;
    request->forknum = forknum;
    request->segno = segno;
 
    /* If queue is more than half full, nudge the checkpointer to empty it */
-   too_full = (BgWriterShmem->num_requests >=
-               BgWriterShmem->max_requests / 2);
+   too_full = (CheckpointerShmem->num_requests >=
+               CheckpointerShmem->max_requests / 2);
 
    LWLockRelease(CheckpointerCommLock);
 
@@ -1180,7 +1180,7 @@ CompactCheckpointerRequestQueue(void)
 {
    struct BgWriterSlotMapping
    {
-       BgWriterRequest request;
+       CheckpointerRequest request;
        int         slot;
    };
 
@@ -1196,16 +1196,16 @@ CompactCheckpointerRequestQueue(void)
 
    /* Initialize temporary hash table */
    MemSet(&ctl, 0, sizeof(ctl));
-   ctl.keysize = sizeof(BgWriterRequest);
+   ctl.keysize = sizeof(CheckpointerRequest);
    ctl.entrysize = sizeof(struct BgWriterSlotMapping);
    ctl.hash = tag_hash;
    htab = hash_create("CompactCheckpointerRequestQueue",
-                      BgWriterShmem->num_requests,
+                      CheckpointerShmem->num_requests,
                       &ctl,
                       HASH_ELEM | HASH_FUNCTION);
 
    /* Initialize skip_slot array */
-   skip_slot = palloc0(sizeof(bool) * BgWriterShmem->num_requests);
+   skip_slot = palloc0(sizeof(bool) * CheckpointerShmem->num_requests);
 
    /*
     * The basic idea here is that a request can be skipped if it's followed
@@ -1220,13 +1220,13 @@ CompactCheckpointerRequestQueue(void)
     * anyhow), but it's not clear that the extra complexity would buy us
     * anything.
     */
-   for (n = 0; n < BgWriterShmem->num_requests; ++n)
+   for (n = 0; n < CheckpointerShmem->num_requests; ++n)
    {
-       BgWriterRequest *request;
+       CheckpointerRequest *request;
        struct BgWriterSlotMapping *slotmap;
        bool        found;
 
-       request = &BgWriterShmem->requests[n];
+       request = &CheckpointerShmem->requests[n];
        slotmap = hash_search(htab, request, HASH_ENTER, &found);
        if (found)
        {
@@ -1247,16 +1247,16 @@ CompactCheckpointerRequestQueue(void)
    }
 
    /* We found some duplicates; remove them. */
-   for (n = 0, preserve_count = 0; n < BgWriterShmem->num_requests; ++n)
+   for (n = 0, preserve_count = 0; n < CheckpointerShmem->num_requests; ++n)
    {
        if (skip_slot[n])
            continue;
-       BgWriterShmem->requests[preserve_count++] = BgWriterShmem->requests[n];
+       CheckpointerShmem->requests[preserve_count++] = CheckpointerShmem->requests[n];
    }
    ereport(DEBUG1,
       (errmsg("compacted fsync request queue from %d entries to %d entries",
-              BgWriterShmem->num_requests, preserve_count)));
-   BgWriterShmem->num_requests = preserve_count;
+              CheckpointerShmem->num_requests, preserve_count)));
+   CheckpointerShmem->num_requests = preserve_count;
 
    /* Cleanup. */
    pfree(skip_slot);
@@ -1275,8 +1275,8 @@ CompactCheckpointerRequestQueue(void)
 void
 AbsorbFsyncRequests(void)
 {
-   BgWriterRequest *requests = NULL;
-   BgWriterRequest *request;
+   CheckpointerRequest *requests = NULL;
+   CheckpointerRequest *request;
    int         n;
 
    if (!am_checkpointer)
@@ -1298,19 +1298,19 @@ AbsorbFsyncRequests(void)
    LWLockAcquire(CheckpointerCommLock, LW_EXCLUSIVE);
 
    /* Transfer stats counts into pending pgstats message */
-   BgWriterStats.m_buf_written_backend += BgWriterShmem->num_backend_writes;
-   BgWriterStats.m_buf_fsync_backend += BgWriterShmem->num_backend_fsync;
+   BgWriterStats.m_buf_written_backend += CheckpointerShmem->num_backend_writes;
+   BgWriterStats.m_buf_fsync_backend += CheckpointerShmem->num_backend_fsync;
 
-   BgWriterShmem->num_backend_writes = 0;
-   BgWriterShmem->num_backend_fsync = 0;
+   CheckpointerShmem->num_backend_writes = 0;
+   CheckpointerShmem->num_backend_fsync = 0;
 
-   n = BgWriterShmem->num_requests;
+   n = CheckpointerShmem->num_requests;
    if (n > 0)
    {
-       requests = (BgWriterRequest *) palloc(n * sizeof(BgWriterRequest));
-       memcpy(requests, BgWriterShmem->requests, n * sizeof(BgWriterRequest));
+       requests = (CheckpointerRequest *) palloc(n * sizeof(CheckpointerRequest));
+       memcpy(requests, CheckpointerShmem->requests, n * sizeof(CheckpointerRequest));
    }
-   BgWriterShmem->num_requests = 0;
+   CheckpointerShmem->num_requests = 0;
 
    LWLockRelease(CheckpointerCommLock);
 

diff --git a/src/backend/storage/ipc/ipci.c b/src/backend/storage/ipc/ipci.c
index ef1dc91f6c4f337a56a65decfaf7d7be2c6f092e..7e04e08545a5286baf6eca22e5fa3e202bb61b8e 100644 (file)
--- a/src/backend/storage/ipc/ipci.c
+++ b/src/backend/storage/ipc/ipci.c
@@ -119,7 +119,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
        size = add_size(size, SInvalShmemSize());
        size = add_size(size, PMSignalShmemSize());
        size = add_size(size, ProcSignalShmemSize());
-       size = add_size(size, BgWriterShmemSize());
+       size = add_size(size, CheckpointerShmemSize());
        size = add_size(size, AutoVacuumShmemSize());
        size = add_size(size, WalSndShmemSize());
        size = add_size(size, WalRcvShmemSize());
@@ -224,7 +224,7 @@ CreateSharedMemoryAndSemaphores(bool makePrivate, int port)
     */
    PMSignalShmemInit();
    ProcSignalShmemInit();
-   BgWriterShmemInit();
+   CheckpointerShmemInit();
    AutoVacuumShmemInit();
    WalSndShmemInit();
    WalRcvShmemInit();

diff --git a/src/include/postmaster/bgwriter.h b/src/include/postmaster/bgwriter.h
index 6cc4b62d225b65d0ea7837dc02d3455a3dabe6ca..540c4e9cc0ee22c8ddecf7732d0aa319efdfd21f 100644 (file)
--- a/src/include/postmaster/bgwriter.h
+++ b/src/include/postmaster/bgwriter.h
@@ -32,7 +32,8 @@ extern bool ForwardFsyncRequest(RelFileNodeBackend rnode, ForkNumber forknum,
                    BlockNumber segno);
 extern void AbsorbFsyncRequests(void);
 
-extern Size BgWriterShmemSize(void);
-extern void BgWriterShmemInit(void);
+/* These were previously called BgWriterShmem... */
+extern Size CheckpointerShmemSize(void);
+extern void CheckpointerShmemInit(void);
 
 #endif   /* _BGWRITER_H */