bulk_write.h File Reference

#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:

Go to the source code of this file.

Typedefs
typedef struct BulkWriteState	BulkWriteState
typedef PGIOAlignedBlock *	BulkWriteBuffer
typedef struct SMgrRelationData *	SMgrRelation

Functions
BulkWriteState *	smgr_bulk_start_rel (Relation rel, ForkNumber forknum)
BulkWriteState *	smgr_bulk_start_smgr (SMgrRelation 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 21 of file bulk_write.h.

SMgrRelation

typedef struct SMgrRelationData* SMgrRelation

Definition at line 31 of file bulk_write.h.

Function Documentation

smgr_bulk_finish()

void smgr_bulk_finish

(

BulkWriteState *

bulkstate

)

Definition at line 130 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 347 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 87 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	(	SMgrRelation	smgr,
		ForkNumber	forknum,
		bool	use_wal
	)

Definition at line 100 of file bulk_write.c.

{
    BulkWriteState *state;
 
    state = palloc(sizeof(BulkWriteState));
    state->smgr = smgr;
    state->forknum = forknum;
    state->use_wal = use_wal;
 
    state->npending = 0;
    state->relsize = smgrnblocks(smgr, forknum);
 
    state->start_RedoRecPtr = GetRedoRecPtr();
 
    /*
     * Remember the memory context.  We will use it to allocate all the
     * buffers later.
     */
    state->memcxt = CurrentMemoryContext;
 
    return state;
}

References CurrentMemoryContext, GetRedoRecPtr(), palloc(), and smgrnblocks().

Referenced by RelationCopyStorage(), and smgr_bulk_start_rel().

smgr_bulk_write()

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

Definition at line 323 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().