8000 Make bgwriter sleep longer when it has no work to do, to save electri… · postgrespro/postgres@6d90eaa · GitHub
[go: up one dir, main page]
Skip to content

Commit 6d90eaa

Browse files
hlinnakahlinnaka
committed
Make bgwriter sleep longer when it has no work to do, to save electricity.
To make it wake up promptly when activity starts again, backends nudge it by setting a latch in MarkBufferDirty(). The latch is kept set while bgwriter is active, so there is very little overhead from that when the system is busy. It is only armed before going into longer sleep. Peter Geoghegan, with some changes by me.
1 parent 467ff20 commit 6d90eaa

File tree

4 files changed

+163
-26
lines changed

4 files changed

+163
-26
lines changed

‎src/backend/postmaster/bgwriter.c

Lines changed: 129 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,7 @@
5151
#include "storage/ipc.h"
5252
#include "storage/lwlock.h"
5353
#include "storage/pmsignal.h"
54+
#include "storage/proc.h"
5455
#include "storage/shmem.h"
5556
#include "storage/smgr.h"
5657
#include "storage/spin.h"
@@ -64,6 +65,11 @@
6465
*/
6566
int BgWriterDelay = 200;
6667

68+
/*
69+
* Time to sleep between bgwriter rounds, when it has no work to do.
70+
*/
71+
#define BGWRITER_HIBERNATE_MS 10000
72+
6773
/*
6874
* Flags set by interrupt handlers for later service in the main loop.
6975
*/
@@ -77,13 +83,14 @@ static bool am_bg_writer = false;
7783

7884
/* Prototypes for private functions */
7985

80-
static void BgWriterNap(void);
86+
static void BgWriterNap(bool hibernating);
8187

8288
/* Signal handlers */
8389

8490
static void bg_quickdie(SIGNAL_ARGS);
8591
static void BgSigHupHandler(SIGNAL_ARGS);
8692
static void ReqShutdownHandler(SIGNAL_ARGS);
93+
static void bgwriter_sigusr1_handler(SIGNAL_ARGS);
8794

8895

8996
/*
@@ -97,6 +104,7 @@ BackgroundWriterMain(void)
97104
{
98105
sigjmp_buf local_sigjmp_buf;
99106
MemoryContext bgwriter_context;
107+
bool hibernating;
100108

101109
am_bg_writer = true;
102110

@@ -112,18 +120,18 @@ BackgroundWriterMain(void)
112120
#endif
113121

114122
/*
115-
* Properly accept or ignore signals the postmaster might send us
123+
* Properly accept or ignore signals the postmaster might send us.
116124
*
117-
* SIGUSR1 is presently unused; keep it spare in case someday we want this
118-
* process to participate in ProcSignal signalling.
125+
* bgwriter doesn't participate in ProcSignal signalling, but a SIGUSR1
126+
* handler is still needed for latch wakeups.
119127
*/
120128
pqsignal(SIGHUP, BgSigHupHandler); /* set flag to read config file */
121129
pqsignal(SIGINT, SIG_IGN); /* as of 9.2 no longer requests checkpoint */
122130
pqsignal(SIGTERM, ReqShutdownHandler); /* shutdown */
123131
pqsignal(SIGQUIT, bg_quickdie); /* hard crash time */
124132
pqsignal(SIGALRM, SIG_IGN);
125133
pqsignal(SIGPIPE, SIG_IGN);
126-
pqsignal(SIGUSR1, SIG_IGN); /* reserve for ProcSignal */
134+
pqsignal(SIGUSR1, bgwriter_sigusr1_handler);
127135
pqsignal(SIGUSR2, SIG_IGN);
128136

129137
/*
@@ -138,6 +146,12 @@ BackgroundWriterMain(void)
138146
/* We allow SIGQUIT (quickdie) at all times */
139147
sigdelset(&BlockSig, SIGQUIT);
140148

149+
/*
150+
* Advertise our latch that backends can use to wake us up while we're
151+
* sleeping.
152+
*/
153+
ProcGlobal->bgwriterLatch = &MyProc->procLatch;
154+
141155
/*
142156
* Create a resource owner to keep track of our resources (currently only
143157
* buffer pins).
@@ -235,8 +249,11 @@ BackgroundWriterMain(void)
235249
/*
236250
* Loop forever
237251
*/
252+
hibernating = false;
238253
for (;;)
239254
{
255+
bool lapped;
256+
240257
/*
241258
* Emergency bailout if postmaster has died. This is to avoid the
242259
* necessity for manual cleanup of all postmaster children.
@@ -264,18 +281,66 @@ BackgroundWriterMain(void)
264281
/*
265282
* Do one cycle of dirty-buffer writing.
266283
*/
267-
BgBufferSync();
284+
if (hibernating && bgwriter_lru_maxpages > 0)
285+
ResetLatch(&MyProc->procLatch);
286+
lapped = BgBufferSync();
287+
288+
if (lapped && !hibernating)
289+
{
290+
/*
291+
* BgBufferSync did nothing. Since there doesn't seem to be any
292+
* work for the bgwriter to do, go into slower-paced
293+
* "hibernation" mode, where we sleep for much longer times than
294+
* bgwriter_delay says. Fewer wakeups saves electricity. If a
295+
* backend starts dirtying pages again, it will wake us up by
296+
* setting our latch.
297+
*
298+
* The latch is kept set during productive cycles where buffers
299+
* are written, and only reset before going into a longer sleep.
300+
* That ensures that when there's a constant trickle of activity,
301+
* the SetLatch() calls that backends have to do will see the
302+
* latch as already set, and are not slowed down by having to
303+
* actually set the latch and signal us.
304+
*/
305+
hibernating = true;
268306

269-
/* Nap for the configured time. */
270-
BgWriterNap();
307+
/*
308+
* Take one more short nap and perform one more bgwriter cycle -
309+
* someone might've dirtied a buffer just after we finished the
310+
* previous bgwriter cycle, while the latch was still set. If
311+
* we still find nothing to do after this cycle, the next sleep
312+
* will be longer.
313+
*/
314+
BgWriterNap(false);
315+
continue;
316+
}
317+
else if (!lapped && hibernating)
318+
{
319+
/*
320+
* Woken up from hibernation. Set the latch just in case it's
321+
* not set yet (usually we wake up from hibernation because a
322+
* backend already set the latch, but not necessarily).
323+
*/
324+
SetLatch(&MyProc->procLatch);
325+
hibernating = false;
326+
}
327+
328+
/*
329+
* Take a short or long nap, depending on whether there was any work
330+
* to do.
331+
*/
332+
BgWriterNap(hibernating);
271333
}
272334
}
273335

274336
/*
275337
* BgWriterNap -- Nap for the configured time or until a signal is received.
338+
*
339+
* If 'hibernating' is false, sleeps for bgwriter_delay milliseconds.
340+
* Otherwise sleeps longer, but also wakes up if the process latch is set.
276341
*/
277342
static void
278-
BgWriterNap(void)
343+
BgWriterNap(bool hibernating)
279344
{
280345
long udelay;
281346

@@ -285,18 +350,44 @@ BgWriterNap(void)
285350
pgstat_send_bgwriter();
286351

287352
/*
288-
* Nap for the configured time, or sleep for 10 seconds if there is no
289-
* bgwriter activity configured.
353+
* If there was no work to do in the previous bgwriter cycle, take a
354+
* longer nap.
355+
*/
356+
if (hibernating)
357+
{
358+
/*
359+
* We wake on a buffer being dirtied. It's possible that some
360+
* useful work will become available for the bgwriter to do without
361+
* a buffer actually being dirtied, like when a dirty buffer's usage
362+
* count is decremented to zero or it's unpinned. This corner case
363+
* is judged as too marginal to justify adding additional SetLatch()
364+
* calls in very hot code paths, cheap though those calls may be.
365+
*
366+
* We still wake up periodically, so that BufferAlloc stats are
367+
* updated reasonably promptly.
368+
*/
369+
int res = WaitLatch(&MyProc->procLatch,
370+
WL_LATCH_SET | WL_TIMEOUT | WL_POSTMASTER_DEATH,
371+
BGWRITER_HIBERNATE_MS);
372+
373+
/*
374+
* Only do a quick return if timeout was reached (or postmaster died)
375+
* to ensure that no less than BgWriterDelay ms has passed between
376+
* BgBufferSyncs - WaitLatch() might have returned instantaneously.
377+
*/
378+
if (res & (WL_TIMEOUT | WL_POSTMASTER_DEATH))
379+
return;
380+
}
381+
382+
/*
383+
* Nap for the configured time.
290384
*
291385
* On some platforms, signals won't interrupt the sleep. To ensure we
292386
* respond reasonably promptly when someone signals us, break down the
293387
* sleep into 1-second increments, and check for interrupts after each
294388
* nap.
295389
*/
296-
if (bgwriter_lru_maxpages > 0)
297-
udelay = BgWriterDelay * 1000L;
298-
else
299-
udelay = 10000000L; /* Ten seconds */
390+
udelay = BgWriterDelay * 1000L;
300391

301392
while (udelay > 999999L)
302393
{
@@ -351,12 +442,35 @@ bg_quickdie(SIGNAL_ARGS)
351442
static void
352443
BgSigHupHandler(SIGNAL_ARGS)
353444
{
445+
int save_errno = errno;
446+
354447
got_SIGHUP = true;
448+
if (MyProc)
449+
SetLatch(&MyProc->procLatch);
450+
451+
errno = save_errno;
355452
}
356453

357454
/* SIGTERM: set flag to shutdown and exit */
358455
static void
359456
ReqShutdownHandler(SIGNAL_ARGS)
360457
{
458+
int save_errno = errno;
459+
361460
shutdown_requested = true;
461+
if (MyProc)
462+
SetLatch(&MyProc->procLatch);
463+
464+
errno = save_errno;
465+
}
466+
467+
/* SIGUSR1: used for latch wakeups */
468+
static void
469+
bgwriter_sigusr1_handler(SIGNAL_ARGS)
470+
{
471+
int save_errno = errno;
472+
473+
latch_sigusr1_handler();
474+
475+
errno = save_errno;
362476
}

‎src/backend/storage/buffer/bufmgr.c

Lines changed: 31 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -953,6 +953,7 @@ void
953953
MarkBufferDirty(Buffer buffer)
954954
{
955955
volatile BufferDesc *bufHdr;
956+
bool dirtied = false;
956957

957958
if (!BufferIsValid(buffer))
958959
elog(ERROR, "bad buffer ID: %d", buffer);
@@ -973,19 +974,25 @@ MarkBufferDirty(Buffer buffer)
973974

974975
Assert(bufHdr->refcount > 0);
975976

977+
if (!(bufHdr->flags & BM_DIRTY))
978+
dirtied = true;
979+
980+
bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
981+
982+
UnlockBufHdr(bufHdr);
983+
976984
/*
977-
* If the buffer was not dirty already, do vacuum accounting.
985+
* If the buffer was not dirty already, do vacuum accounting, and
986+
* nudge bgwriter.
978987
*/
979-
if (!(bufHdr->flags & BM_DIRTY))
988+
if (dirtied)
980989
{
981990
VacuumPageDirty++;
982991
if (VacuumCostActive)
983992
VacuumCostBalance += VacuumCostPageDirty;
993+
if (ProcGlobal->bgwriterLatch)
994+
SetLatch(ProcGlobal->bgwriterLatch);
984995
}
985-
986-
bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
987-
988-
UnlockBufHdr(bufHdr);
989996
}
990997

991998
/*
@@ -1307,8 +1314,12 @@ BufferSync(int flags)
13071314
* BgBufferSync -- Write out some dirty buffers in the pool.
13081315
*
13091316
* This is called periodically by the background writer process.
1317+
*
1318+
* Returns true if the clocksweep has been "lapped", so that there's nothing
1319+
* to do. Also returns true if there's nothing to do because bgwriter was
1320+
* effectively disabled by setting bgwriter_lru_maxpages to 0.
13101321
*/
1311-
void
1322+
bool
13121323
BgBufferSync(void)
13131324
{
13141325
/* info obtained from freelist.c */
@@ -1365,7 +1376,7 @@ BgBufferSync(void)
13651376
if (bgwriter_lru_maxpages <= 0)
13661377
{
13671378
saved_info_valid = false;
1368-
return;
1379+
return true;
13691380
}
13701381

13711382
/*
@@ -1584,6 +1595,8 @@ BgBufferSync(void)
15841595
recent_alloc, strategy_delta, scans_per_alloc, smoothed_density);
15851596
#endif
15861597
}
1598+
1599+
return (bufs_to_lap == 0);
15871600
}
15881601

15891602
/*
@@ -2341,16 +2354,24 @@ SetBufferCommitInfoNeedsSave(Buffer buffer)
23412354
if ((bufHdr->flags & (BM_DIRTY | BM_JUST_DIRTIED)) !=
23422355
(BM_DIRTY | BM_JUST_DIRTIED))
23432356
{
2357+
bool dirtied = false;
2358+
23442359
LockBufHdr(bufHdr);
23452360
Assert(bufHdr->refcount > 0);
23462361
if (!(bufHdr->flags & BM_DIRTY))
2362+
dirtied = true;
2363+
bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
2364+
UnlockBufHdr(bufHdr);
2365+
2366+
if (dirtied)
23472367
{
23482368
VacuumPageDirty++;
23492369
if (VacuumCostActive)
23502370
VacuumCostBalance += VacuumCostPageDirty;
2371+
/* The bgwriter may need to be woken. */
2372+
if (ProcGlobal->bgwriterLatch)
2373+
SetLatch(ProcGlobal->bgwriterLatch);
23512374
}
2352-
bufHdr->flags |= (BM_DIRTY | BM_JUST_DIRTIED);
2353-
UnlockBufHdr(bufHdr);
23542375
}
23552376
}
23562377

‎src/include/storage/bufmgr.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -213,7 +213,7 @@ extern bool HoldingBufferPinThatDelaysRecovery(void);
213213
extern void AbortBufferIO(void);
214214

215215
extern void BufmgrCommit(void);
216-
extern void BgBufferSync(void);
216+
extern bool BgBufferSync(void);
217217

218218
extern void AtProcExit_LocalBuffers(void);
219219

‎src/include/storage/proc.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -188,6 +188,8 @@ typedef struct PROC_HDR
188188
PGPROC *freeProcs;
189189
/* Head of list of autovacuum's free PGPROC structures */
190190
PGPROC *autovacFreeProcs;
191+
/* BGWriter process latch */
192+
Latch *bgwriterLatch;
191193
/* Current shared estimate of appropriate spins_per_delay value */
192194
int spins_per_delay;
193195
/* The proc of the Startup process, since not in ProcArray */

0 commit comments

Comments
 (0)
0