#include "storage/smgr.h"
#include "utils/rel.h"

Include dependency graph for bulk_write.h:

This graph shows which files directly or indirectly include this file:

Typedefs
typedef struct BulkWriteState	BulkWriteState

typedef PGIOAlignedBlock *	BulkWriteBuffer

Functions
BulkWriteState *	smgr_bulk_start_rel (Relation rel, ForkNumber forknum)

BulkWriteState *	smgr_bulk_start_smgr (struct SMgrRelationData *smgr, ForkNumber forknum, bool use_wal)

BulkWriteBuffer	smgr_bulk_get_buf (BulkWriteState *bulkstate)

void	smgr_bulk_write (BulkWriteState *bulkstate, BlockNumber blocknum, BulkWriteBuffer buf, bool page_std)

void	smgr_bulk_finish (BulkWriteState *bulkstate)

Typedef Documentation

◆ BulkWriteBuffer

typedef PGIOAlignedBlock* BulkWriteBuffer

Definition at line 28 of file bulk_write.h.

◆ BulkWriteState

typedef struct BulkWriteState BulkWriteState

Definition at line 1 of file bulk_write.h.

Function Documentation

◆ smgr_bulk_finish()

void smgr_bulk_finish ( BulkWriteState * bulkstate )

Definition at line 129 of file bulk_write.c.

 {
     /* WAL-log and flush any remaining pages */
     smgr_bulk_flush(bulkstate);
  
     /*
      * Fsync the relation, or register it for the next checkpoint, if
      * necessary.
      */
     if (SmgrIsTemp(bulkstate->smgr))
     {
         /* Temporary relations don't need to be fsync'd, ever */
     }
     else if (!bulkstate->use_wal)
     {
         /*----------
          * This is either an unlogged relation, or a permanent relation but we
          * skipped WAL-logging because wal_level=minimal:
          *
          * A) Unlogged relation
          *
          *    Unlogged relations will go away on crash, but they need to be
          *    fsync'd on a clean shutdown. It's sufficient to call
          *    smgrregistersync(), that ensures that the checkpointer will
          *    flush it at the shutdown checkpoint. (It will flush it on the
          *    next online checkpoint too, which is not strictly necessary.)
          *
          *    Note that the init-fork of an unlogged relation is not
          *    considered unlogged for our purposes. It's treated like a
          *    regular permanent relation. The callers will pass use_wal=true
          *    for the init fork.
          *
          * B) Permanent relation, WAL-logging skipped because wal_level=minimal
          *
          *    This is a new relation, and we didn't WAL-log the pages as we
          *    wrote, but they need to be fsync'd before commit.
          *
          *    We don't need to do that here, however. The fsync() is done at
          *    commit, by smgrDoPendingSyncs() (*).
          *
          *    (*) smgrDoPendingSyncs() might decide to WAL-log the whole
          *    relation at commit instead of fsyncing it, if the relation was
          *    very small, but it's smgrDoPendingSyncs() responsibility in any
          *    case.
          *
          * We cannot distinguish the two here, so conservatively assume it's
          * an unlogged relation. A permanent relation with wal_level=minimal
          * would require no actions, see above.
          */
         smgrregistersync(bulkstate->smgr, bulkstate->forknum);
     }
     else
     {
         /*
          * Permanent relation, WAL-logged normally.
          *
          * We already WAL-logged all the pages, so they will be replayed from
          * WAL on crash. However, when we wrote out the pages, we passed
          * skipFsync=true to avoid the overhead of registering all the writes
          * with the checkpointer.  Register the whole relation now.
          *
          * There is one hole in that idea: If a checkpoint occurred while we
          * were writing the pages, it already missed fsyncing the pages we had
          * written before the checkpoint started.  A crash later on would
          * replay the WAL starting from the checkpoint, therefore it wouldn't
          * replay our earlier WAL records.  So if a checkpoint started after
          * the bulk write, fsync the files now.
          */
  
         /*
          * Prevent a checkpoint from starting between the GetRedoRecPtr() and
          * smgrregistersync() calls.
          */
         Assert((MyProc->delayChkptFlags & DELAY_CHKPT_START) == 0);
         MyProc->delayChkptFlags |= DELAY_CHKPT_START;
  
         if (bulkstate->start_RedoRecPtr != GetRedoRecPtr())
         {
             /*
              * A checkpoint occurred and it didn't know about our writes, so
              * fsync() the relation ourselves.
              */
             MyProc->delayChkptFlags &= ~DELAY_CHKPT_START;
             smgrimmedsync(bulkstate->smgr, bulkstate->forknum);
             elog(DEBUG1, "flushed relation because a checkpoint occurred concurrently");
         }
         else
         {
             smgrregistersync(bulkstate->smgr, bulkstate->forknum);
             MyProc->delayChkptFlags &= ~DELAY_CHKPT_START;
         }
     }
 }

References Assert, DEBUG1, DELAY_CHKPT_START, PGPROC::delayChkptFlags, elog, BulkWriteState::forknum, GetRedoRecPtr(), MyProc, BulkWriteState::smgr, smgr_bulk_flush(), smgrimmedsync(), SmgrIsTemp, smgrregistersync(), BulkWriteState::start_RedoRecPtr, and BulkWriteState::use_wal.

Referenced by _bt_load(), btbuildempty(), end_heap_rewrite(), gist_indexsortbuild(), RelationCopyStorage(), and spgbuildempty().

◆ smgr_bulk_get_buf()

BulkWriteBuffer smgr_bulk_get_buf ( BulkWriteState * bulkstate )

Definition at line 345 of file bulk_write.c.

 {
     return MemoryContextAllocAligned(bulkstate->memcxt, BLCKSZ, PG_IO_ALIGN_SIZE, 0);
 }

References BulkWriteState::memcxt, MemoryContextAllocAligned(), and PG_IO_ALIGN_SIZE.

Referenced by _bt_blnewpage(), _bt_uppershutdown(), btbuildempty(), gist_indexsortbuild(), gist_indexsortbuild_levelstate_flush(), raw_heap_insert(), RelationCopyStorage(), and spgbuildempty().

◆ smgr_bulk_start_rel()

BulkWriteState* smgr_bulk_start_rel	(	Relation	rel,
		ForkNumber	forknum
	)

Definition at line 86 of file bulk_write.c.

 {
     return smgr_bulk_start_smgr(RelationGetSmgr(rel),
                                 forknum,
                                 RelationNeedsWAL(rel) || forknum == INIT_FORKNUM);
 }

References INIT_FORKNUM, RelationGetSmgr(), RelationNeedsWAL, and smgr_bulk_start_smgr().

Referenced by _bt_load(), begin_heap_rewrite(), btbuildempty(), gist_indexsortbuild(), and spgbuildempty().

◆ smgr_bulk_start_smgr()

BulkWriteState* smgr_bulk_start_smgr	(	struct SMgrRelationData *	smgr,
		ForkNumber	forknum,
		bool	use_wal
	)

◆ smgr_bulk_write()

void smgr_bulk_write	(	BulkWriteState *	bulkstate,
		BlockNumber	blocknum,
		BulkWriteBuffer	buf,
		bool	page_std
	)

Definition at line 321 of file bulk_write.c.

 {
     PendingWrite *w;
  
     w = &bulkstate->pending_writes[bulkstate->npending++];
     w->buf = buf;
     w->blkno = blocknum;
     w->page_std = page_std;
  
     if (bulkstate->npending == MAX_PENDING_WRITES)
         smgr_bulk_flush(bulkstate);
 }

References PendingWrite::blkno, PendingWrite::buf, buf, MAX_PENDING_WRITES, BulkWriteState::npending, PendingWrite::page_std, BulkWriteState::pending_writes, and smgr_bulk_flush().

Referenced by _bt_blwritepage(), btbuildempty(), end_heap_rewrite(), gist_indexsortbuild(), gist_indexsortbuild_levelstate_flush(), raw_heap_insert(), RelationCopyStorage(), and spgbuildempty().

Typedefs

Functions