Movatterモバイル変換

[0]ホーム
URL:

Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly

 Sign up
Appearance settings

Commit4d330a6

Browse files
committed
Add smgrzeroextend(), FileZero(), FileFallocate()
smgrzeroextend() uses FileFallocate() to efficiently extend files by multipleblocks. When extending by a small number of blocks, use FileZero() instead, asusing posix_fallocate() for small numbers of blocks is inefficient for somefile systems / operating systems. FileZero() is also used as the fallback forFileFallocate() on platforms / filesystems that don't support fallocate.A big advantage of using posix_fallocate() is that it typically won't causedirty buffers in the kernel pagecache. So far the most common pattern in ourcode is that we smgrextend() a page full of zeroes and put the correspondingpage into shared buffers, from where we later write out the actual contents ofthe page. If the kernel, e.g. due to memory pressure or elapsed time, alreadywrote back the all-zeroes page, this can lead to doubling the amount of writesreaching storage.There are no users of smgrzeroextend() as of this commit. That will follow infuture commits.Reviewed-by: Melanie Plageman <melanieplageman@gmail.com>Reviewed-by: Heikki Linnakangas <hlinnaka@iki.fi>Reviewed-by: Kyotaro Horiguchi <horikyota.ntt@gmail.com>Reviewed-by: David Rowley <dgrowleyml@gmail.com>Reviewed-by: John Naylor <john.naylor@enterprisedb.com>Discussion:https://postgr.es/m/20221029025420.eplyow6k7tgu6he3@awork3.anarazel.de
1 parent4766eef commit4d330a6

File tree

6 files changed

+231
-0
lines changed

6 files changed

+231
-0
lines changed

‎src/backend/storage/file/fd.c‎

Lines changed: 88 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2206,6 +2206,94 @@ FileSync(File file, uint32 wait_event_info)
22062206
returnreturnCode;
22072207
}
22082208

2209+
/*
2210+
* Zero a region of the file.
2211+
*
2212+
* Returns 0 on success, -1 otherwise. In the latter case errno is set to the
2213+
* appropriate error.
2214+
*/
2215+
int
2216+
FileZero(Filefile,off_toffset,off_tamount,uint32wait_event_info)
2217+
{
2218+
intreturnCode;
2219+
ssize_twritten;
2220+
2221+
Assert(FileIsValid(file));
2222+
2223+
DO_DB(elog(LOG,"FileZero: %d (%s) "INT64_FORMAT" "INT64_FORMAT,
2224+
file,VfdCache[file].fileName,
2225+
(int64)offset, (int64)amount));
2226+
2227+
returnCode=FileAccess(file);
2228+
if (returnCode<0)
2229+
returnreturnCode;
2230+
2231+
pgstat_report_wait_start(wait_event_info);
2232+
written=pg_pwrite_zeros(VfdCache[file].fd,amount,offset);
2233+
pgstat_report_wait_end();
2234+
2235+
if (written<0)
2236+
return-1;
2237+
elseif (written!=amount)
2238+
{
2239+
/* if errno is unset, assume problem is no disk space */
2240+
if (errno==0)
2241+
errno=ENOSPC;
2242+
return-1;
2243+
}
2244+
2245+
return0;
2246+
}
2247+
2248+
/*
2249+
* Try to reserve file space with posix_fallocate(). If posix_fallocate() is
2250+
* not implemented on the operating system or fails with EINVAL / EOPNOTSUPP,
2251+
* use FileZero() instead.
2252+
*
2253+
* Note that at least glibc() implements posix_fallocate() in userspace if not
2254+
* implemented by the filesystem. That's not the case for all environments
2255+
* though.
2256+
*
2257+
* Returns 0 on success, -1 otherwise. In the latter case errno is set to the
2258+
* appropriate error.
2259+
*/
2260+
int
2261+
FileFallocate(Filefile,off_toffset,off_tamount,uint32wait_event_info)
2262+
{
2263+
#ifdefHAVE_POSIX_FALLOCATE
2264+
intreturnCode;
2265+
2266+
Assert(FileIsValid(file));
2267+
2268+
DO_DB(elog(LOG,"FileFallocate: %d (%s) "INT64_FORMAT" "INT64_FORMAT,
2269+
file,VfdCache[file].fileName,
2270+
(int64)offset, (int64)amount));
2271+
2272+
returnCode=FileAccess(file);
2273+
if (returnCode<0)
2274+
return-1;
2275+
2276+
pgstat_report_wait_start(wait_event_info);
2277+
returnCode=posix_fallocate(VfdCache[file].fd,offset,amount);
2278+
pgstat_report_wait_end();
2279+
2280+
if (returnCode==0)
2281+
return0;
2282+
2283+
/* for compatibility with %m printing etc */
2284+
errno=returnCode;
2285+
2286+
/*
2287+
* Return in cases of a "real" failure, if fallocate is not supported,
2288+
* fall through to the FileZero() backed implementation.
2289+
*/
2290+
if (returnCode!=EINVAL&&returnCode!=EOPNOTSUPP)
2291+
return-1;
2292+
#endif
2293+
2294+
returnFileZero(file,offset,amount,wait_event_info);
2295+
}
2296+
22092297
off_t
22102298
FileSize(Filefile)
22112299
{

‎src/backend/storage/smgr/md.c‎

Lines changed: 108 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -500,6 +500,114 @@ mdextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
500500
Assert(_mdnblocks(reln,forknum,v) <= ((BlockNumber)RELSEG_SIZE));
501501
}
502502

503+
/*
504+
*mdzeroextend() -- Add new zeroed out blocks to the specified relation.
505+
*
506+
*Similar to mdextend(), except the relation can be extended by multiple
507+
*blocks at once and the added blocks will be filled with zeroes.
508+
*/
509+
void
510+
mdzeroextend(SMgrRelationreln,ForkNumberforknum,
511+
BlockNumberblocknum,intnblocks,boolskipFsync)
512+
{
513+
MdfdVec*v;
514+
BlockNumbercurblocknum=blocknum;
515+
intremblocks=nblocks;
516+
517+
Assert(nblocks>0);
518+
519+
/* This assert is too expensive to have on normally ... */
520+
#ifdefCHECK_WRITE_VS_EXTEND
521+
Assert(blocknum >=mdnblocks(reln,forknum));
522+
#endif
523+
524+
/*
525+
* If a relation manages to grow to 2^32-1 blocks, refuse to extend it any
526+
* more --- we mustn't create a block whose number actually is
527+
* InvalidBlockNumber or larger.
528+
*/
529+
if ((uint64)blocknum+nblocks >= (uint64)InvalidBlockNumber)
530+
ereport(ERROR,
531+
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
532+
errmsg("cannot extend file \"%s\" beyond %u blocks",
533+
relpath(reln->smgr_rlocator,forknum),
534+
InvalidBlockNumber)));
535+
536+
while (remblocks>0)
537+
{
538+
BlockNumbersegstartblock=curblocknum % ((BlockNumber)RELSEG_SIZE);
539+
off_tseekpos= (off_t)BLCKSZ*segstartblock;
540+
intnumblocks;
541+
542+
if (segstartblock+remblocks>RELSEG_SIZE)
543+
numblocks=RELSEG_SIZE-segstartblock;
544+
else
545+
numblocks=remblocks;
546+
547+
v=_mdfd_getseg(reln,forknum,curblocknum,skipFsync,EXTENSION_CREATE);
548+
549+
Assert(segstartblock<RELSEG_SIZE);
550+
Assert(segstartblock+numblocks <=RELSEG_SIZE);
551+
552+
/*
553+
* If available and useful, use posix_fallocate() (via FileAllocate())
554+
* to extend the relation. That's often more efficient than using
555+
* write(), as it commonly won't cause the kernel to allocate page
556+
* cache space for the extended pages.
557+
*
558+
* However, we don't use FileAllocate() for small extensions, as it
559+
* defeats delayed allocation on some filesystems. Not clear where
560+
* that decision should be made though? For now just use a cutoff of
561+
* 8, anything between 4 and 8 worked OK in some local testing.
562+
*/
563+
if (numblocks>8)
564+
{
565+
intret;
566+
567+
ret=FileFallocate(v->mdfd_vfd,
568+
seekpos, (off_t)BLCKSZ*numblocks,
569+
WAIT_EVENT_DATA_FILE_EXTEND);
570+
if (ret!=0)
571+
{
572+
ereport(ERROR,
573+
errcode_for_file_access(),
574+
errmsg("could not extend file \"%s\" with FileFallocate(): %m",
575+
FilePathName(v->mdfd_vfd)),
576+
errhint("Check free disk space."));
577+
}
578+
}
579+
else
580+
{
581+
intret;
582+
583+
/*
584+
* Even if we don't want to use fallocate, we can still extend a
585+
* bit more efficiently than writing each 8kB block individually.
586+
* pg_pwrite_zeroes() (via FileZero()) uses
587+
* pg_pwritev_with_retry() to avoid multiple writes or needing a
588+
* zeroed buffer for the whole length of the extension.
589+
*/
590+
ret=FileZero(v->mdfd_vfd,
591+
seekpos, (off_t)BLCKSZ*numblocks,
592+
WAIT_EVENT_DATA_FILE_EXTEND);
593+
if (ret<0)
594+
ereport(ERROR,
595+
errcode_for_file_access(),
596+
errmsg("could not extend file \"%s\": %m",
597+
FilePathName(v->mdfd_vfd)),
598+
errhint("Check free disk space."));
599+
}
600+
601+
if (!skipFsync&& !SmgrIsTemp(reln))
602+
register_dirty_segment(reln,forknum,v);
603+
604+
Assert(_mdnblocks(reln,forknum,v) <= ((BlockNumber)RELSEG_SIZE));
605+
606+
remblocks-=numblocks;
607+
curblocknum+=numblocks;
608+
}
609+
}
610+
503611
/*
504612
*mdopenfork() -- Open one fork of the specified relation.
505613
*

‎src/backend/storage/smgr/smgr.c‎

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -50,6 +50,8 @@ typedef struct f_smgr
5050
boolisRedo);
5151
void(*smgr_extend) (SMgrRelationreln,ForkNumberforknum,
5252
BlockNumberblocknum,constvoid*buffer,boolskipFsync);
53+
void(*smgr_zeroextend) (SMgrRelationreln,ForkNumberforknum,
54+
BlockNumberblocknum,intnblocks,boolskipFsync);
5355
bool(*smgr_prefetch) (SMgrRelationreln,ForkNumberforknum,
5456
BlockNumberblocknum);
5557
void(*smgr_read) (SMgrRelationreln,ForkNumberforknum,
@@ -75,6 +77,7 @@ static const f_smgr smgrsw[] = {
7577
.smgr_exists=mdexists,
7678
.smgr_unlink=mdunlink,
7779
.smgr_extend=mdextend,
80+
.smgr_zeroextend=mdzeroextend,
7881
.smgr_prefetch=mdprefetch,
7982
.smgr_read=mdread,
8083
.smgr_write=mdwrite,
@@ -507,6 +510,31 @@ smgrextend(SMgrRelation reln, ForkNumber forknum, BlockNumber blocknum,
507510
reln->smgr_cached_nblocks[forknum]=InvalidBlockNumber;
508511
}
509512

513+
/*
514+
*smgrzeroextend() -- Add new zeroed out blocks to a file.
515+
*
516+
*Similar to smgrextend(), except the relation can be extended by
517+
*multiple blocks at once and the added blocks will be filled with
518+
*zeroes.
519+
*/
520+
void
521+
smgrzeroextend(SMgrRelationreln,ForkNumberforknum,BlockNumberblocknum,
522+
intnblocks,boolskipFsync)
523+
{
524+
smgrsw[reln->smgr_which].smgr_zeroextend(reln,forknum,blocknum,
525+
nblocks,skipFsync);
526+
527+
/*
528+
* Normally we expect this to increase the fork size by nblocks, but if
529+
* the cached value isn't as expected, just invalidate it so the next call
530+
* asks the kernel.
531+
*/
532+
if (reln->smgr_cached_nblocks[forknum]==blocknum)
533+
reln->smgr_cached_nblocks[forknum]=blocknum+nblocks;
534+
else
535+
reln->smgr_cached_nblocks[forknum]=InvalidBlockNumber;
536+
}
537+
510538
/*
511539
*smgrprefetch() -- Initiate asynchronous read of the specified block of a relation.
512540
*

‎src/include/storage/fd.h‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -106,6 +106,9 @@ extern intFilePrefetch(File file, off_t offset, off_t amount, uint32 wait_event
106106
externintFileRead(Filefile,void*buffer,size_tamount,off_toffset,uint32wait_event_info);
107107
externintFileWrite(Filefile,constvoid*buffer,size_tamount,off_toffset,uint32wait_event_info);
108108
externintFileSync(Filefile,uint32wait_event_info);
109+
externintFileZero(Filefile,off_toffset,off_tamount,uint32wait_event_info);
110+
externintFileFallocate(Filefile,off_toffset,off_tamount,uint32wait_event_info);
111+
109112
externoff_tFileSize(Filefile);
110113
externintFileTruncate(Filefile,off_toffset,uint32wait_event_info);
111114
externvoidFileWriteback(Filefile,off_toffset,off_tnbytes,uint32wait_event_info);

‎src/include/storage/md.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,8 @@ extern bool mdexists(SMgrRelation reln, ForkNumber forknum);
2828
externvoidmdunlink(RelFileLocatorBackendrlocator,ForkNumberforknum,boolisRedo);
2929
externvoidmdextend(SMgrRelationreln,ForkNumberforknum,
3030
BlockNumberblocknum,constvoid*buffer,boolskipFsync);
31+
externvoidmdzeroextend(SMgrRelationreln,ForkNumberforknum,
32+
BlockNumberblocknum,intnblocks,boolskipFsync);
3133
externboolmdprefetch(SMgrRelationreln,ForkNumberforknum,
3234
BlockNumberblocknum);
3335
externvoidmdread(SMgrRelationreln,ForkNumberforknum,BlockNumberblocknum,

‎src/include/storage/smgr.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -92,6 +92,8 @@ extern void smgrdosyncall(SMgrRelation *rels, int nrels);
9292
externvoidsmgrdounlinkall(SMgrRelation*rels,intnrels,boolisRedo);
9393
externvoidsmgrextend(SMgrRelationreln,ForkNumberforknum,
9494
BlockNumberblocknum,constvoid*buffer,boolskipFsync);
95+
externvoidsmgrzeroextend(SMgrRelationreln,ForkNumberforknum,
96+
BlockNumberblocknum,intnblocks,boolskipFsync);
9597
externboolsmgrprefetch(SMgrRelationreln,ForkNumberforknum,
9698
BlockNumberblocknum);
9799
externvoidsmgrread(SMgrRelationreln,ForkNumberforknum,

0 commit comments

Comments
 (0)
[8]ページ先頭
©2009-2025 Movatter.jp