blvacuum.c File Reference

#include "postgres.h"
#include "access/genam.h"
#include "bloom.h"
#include "commands/vacuum.h"
#include "storage/bufmgr.h"
#include "storage/indexfsm.h"
#include "storage/read_stream.h"

Include dependency graph for blvacuum.c:

Go to the source code of this file.

Functions
IndexBulkDeleteResult *	blbulkdelete (IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
IndexBulkDeleteResult *	blvacuumcleanup (IndexVacuumInfo *info, IndexBulkDeleteResult *stats)

Function Documentation

blbulkdelete()

IndexBulkDeleteResult * blbulkdelete	(	IndexVacuumInfo *	info,
		IndexBulkDeleteResult *	stats,
		IndexBulkDeleteCallback	callback,
		void *	callback_state
	)

Definition at line 31 of file blvacuum.c.

{
    Relation    index = info->index;
    BlockNumber blkno,
                npages;
    FreeBlockNumberArray notFullPage;
    int         countPage = 0;
    BloomState  state;
    Buffer      buffer;
    Page        page;
    BloomMetaPageData *metaData;
    GenericXLogState *gxlogState;
    BlockRangeReadStreamPrivate p;
    ReadStream *stream;
 
    if (stats == NULL)
        stats = palloc0_object(IndexBulkDeleteResult);
 
    initBloomState(&state, index);
 
    /*
     * Iterate over the pages. We don't care about concurrently added pages,
     * they can't contain tuples to delete.
     */
    npages = RelationGetNumberOfBlocks(index);
 
    /* Scan all blocks except the metapage using streaming reads */
    p.current_blocknum = BLOOM_HEAD_BLKNO;
    p.last_exclusive = npages;
 
    /*
     * It is safe to use batchmode as block_range_read_stream_cb takes no
     * locks.
     */
    stream = read_stream_begin_relation(READ_STREAM_MAINTENANCE |
                                        READ_STREAM_FULL |
                                        READ_STREAM_USE_BATCHING,
                                        info->strategy,
                                        index,
                                        MAIN_FORKNUM,
                                        block_range_read_stream_cb,
                                        &p,
                                        0);
 
    for (blkno = BLOOM_HEAD_BLKNO; blkno < npages; blkno++)
    {
        BloomTuple *itup,
                   *itupPtr,
                   *itupEnd;
 
        vacuum_delay_point(false);
 
        buffer = read_stream_next_buffer(stream, NULL);
 
        LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
        gxlogState = GenericXLogStart(index);
        page = GenericXLogRegisterBuffer(gxlogState, buffer, 0);
 
        /* Ignore empty/deleted pages until blvacuumcleanup() */
        if (PageIsNew(page) || BloomPageIsDeleted(page))
        {
            UnlockReleaseBuffer(buffer);
            GenericXLogAbort(gxlogState);
            continue;
        }
 
        /*
         * Iterate over the tuples.  itup points to current tuple being
         * scanned, itupPtr points to where to save next non-deleted tuple.
         */
        itup = itupPtr = BloomPageGetTuple(&state, page, FirstOffsetNumber);
        itupEnd = BloomPageGetTuple(&state, page,
                                    OffsetNumberNext(BloomPageGetMaxOffset(page)));
        while (itup < itupEnd)
        {
            /* Do we have to delete this tuple? */
            if (callback(&itup->heapPtr, callback_state))
            {
                /* Yes; adjust count of tuples that will be left on page */
                BloomPageGetOpaque(page)->maxoff--;
                stats->tuples_removed += 1;
            }
            else
            {
                /* No; copy it to itupPtr++, but skip copy if not needed */
                if (itupPtr != itup)
                    memmove(itupPtr, itup, state.sizeOfBloomTuple);
                itupPtr = BloomPageGetNextTuple(&state, itupPtr);
            }
 
            itup = BloomPageGetNextTuple(&state, itup);
        }
 
        /* Assert that we counted correctly */
        Assert(itupPtr == BloomPageGetTuple(&state, page,
                                            OffsetNumberNext(BloomPageGetMaxOffset(page))));
 
        /*
         * Add page to new notFullPage list if we will not mark page as
         * deleted and there is free space on it
         */
        if (BloomPageGetMaxOffset(page) != 0 &&
            BloomPageGetFreeSpace(&state, page) >= state.sizeOfBloomTuple &&
            countPage < BloomMetaBlockN)
            notFullPage[countPage++] = blkno;
 
        /* Did we delete something? */
        if (itupPtr != itup)
        {
            /* Is it empty page now? */
            if (BloomPageGetMaxOffset(page) == 0)
                BloomPageSetDeleted(page);
            /* Adjust pd_lower */
            ((PageHeader) page)->pd_lower = (char *) itupPtr - page;
            /* Finish WAL-logging */
            GenericXLogFinish(gxlogState);
        }
        else
        {
            /* Didn't change anything: abort WAL-logging */
            GenericXLogAbort(gxlogState);
        }
        UnlockReleaseBuffer(buffer);
    }
 
    Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
    read_stream_end(stream);
 
    /*
     * Update the metapage's notFullPage list with whatever we found.  Our
     * info could already be out of date at this point, but blinsert() will
     * cope if so.
     */
    buffer = ReadBuffer(index, BLOOM_METAPAGE_BLKNO);
    LockBuffer(buffer, BUFFER_LOCK_EXCLUSIVE);
 
    gxlogState = GenericXLogStart(index);
    page = GenericXLogRegisterBuffer(gxlogState, buffer, 0);
 
    metaData = BloomPageGetMeta(page);
    memcpy(metaData->notFullPage, notFullPage, sizeof(BlockNumber) * countPage);
    metaData->nStart = 0;
    metaData->nEnd = countPage;
 
    GenericXLogFinish(gxlogState);
    UnlockReleaseBuffer(buffer);
 
    return stats;
}

References Assert, block_range_read_stream_cb(), BLOOM_HEAD_BLKNO, BLOOM_METAPAGE_BLKNO, BloomMetaBlockN, BloomPageGetFreeSpace, BloomPageGetMaxOffset, BloomPageGetMeta, BloomPageGetNextTuple, BloomPageGetOpaque, BloomPageGetTuple, BloomPageIsDeleted, BloomPageSetDeleted, BUFFER_LOCK_EXCLUSIVE, callback(), BlockRangeReadStreamPrivate::current_blocknum, fb(), FirstOffsetNumber, GenericXLogAbort(), GenericXLogFinish(), GenericXLogRegisterBuffer(), GenericXLogStart(), BloomTuple::heapPtr, IndexVacuumInfo::index, initBloomState(), InvalidBuffer, BlockRangeReadStreamPrivate::last_exclusive, LockBuffer(), MAIN_FORKNUM, OffsetNumberNext, PageIsNew(), palloc0_object, read_stream_begin_relation(), read_stream_end(), READ_STREAM_FULL, READ_STREAM_MAINTENANCE, read_stream_next_buffer(), READ_STREAM_USE_BATCHING, ReadBuffer(), RelationGetNumberOfBlocks, IndexVacuumInfo::strategy, IndexBulkDeleteResult::tuples_removed, UnlockReleaseBuffer(), and vacuum_delay_point().

Referenced by blhandler().

blvacuumcleanup()

IndexBulkDeleteResult * blvacuumcleanup	(	IndexVacuumInfo *	info,
		IndexBulkDeleteResult *	stats
	)

Definition at line 188 of file blvacuum.c.

{
    Relation    index = info->index;
    BlockNumber npages,
                blkno;
    BlockRangeReadStreamPrivate p;
    ReadStream *stream;
 
    if (info->analyze_only)
        return stats;
 
    if (stats == NULL)
        stats = palloc0_object(IndexBulkDeleteResult);
 
    /*
     * Iterate over the pages: insert deleted pages into FSM and collect
     * statistics.
     */
    npages = RelationGetNumberOfBlocks(index);
    stats->num_pages = npages;
    stats->pages_free = 0;
    stats->num_index_tuples = 0;
 
    /* Scan all blocks except the metapage using streaming reads */
    p.current_blocknum = BLOOM_HEAD_BLKNO;
    p.last_exclusive = npages;
 
    /*
     * It is safe to use batchmode as block_range_read_stream_cb takes no
     * locks.
     */
    stream = read_stream_begin_relation(READ_STREAM_MAINTENANCE |
                                        READ_STREAM_FULL |
                                        READ_STREAM_USE_BATCHING,
                                        info->strategy,
                                        index,
                                        MAIN_FORKNUM,
                                        block_range_read_stream_cb,
                                        &p,
                                        0);
 
    for (blkno = BLOOM_HEAD_BLKNO; blkno < npages; blkno++)
    {
        Buffer      buffer;
        Page        page;
 
        vacuum_delay_point(false);
 
        buffer = read_stream_next_buffer(stream, NULL);
        LockBuffer(buffer, BUFFER_LOCK_SHARE);
        page = BufferGetPage(buffer);
 
        if (PageIsNew(page) || BloomPageIsDeleted(page))
        {
            RecordFreeIndexPage(index, blkno);
            stats->pages_free++;
        }
        else
        {
            stats->num_index_tuples += BloomPageGetMaxOffset(page);
        }
 
        UnlockReleaseBuffer(buffer);
    }
 
    Assert(read_stream_next_buffer(stream, NULL) == InvalidBuffer);
    read_stream_end(stream);
 
    IndexFreeSpaceMapVacuum(info->index);
 
    return stats;
}

References IndexVacuumInfo::analyze_only, Assert, block_range_read_stream_cb(), BLOOM_HEAD_BLKNO, BloomPageGetMaxOffset, BloomPageIsDeleted, BUFFER_LOCK_SHARE, BufferGetPage(), BlockRangeReadStreamPrivate::current_blocknum, fb(), IndexVacuumInfo::index, IndexFreeSpaceMapVacuum(), InvalidBuffer, BlockRangeReadStreamPrivate::last_exclusive, LockBuffer(), MAIN_FORKNUM, IndexBulkDeleteResult::num_index_tuples, IndexBulkDeleteResult::num_pages, PageIsNew(), IndexBulkDeleteResult::pages_free, palloc0_object, read_stream_begin_relation(), read_stream_end(), READ_STREAM_FULL, READ_STREAM_MAINTENANCE, read_stream_next_buffer(), READ_STREAM_USE_BATCHING, RecordFreeIndexPage(), RelationGetNumberOfBlocks, IndexVacuumInfo::strategy, UnlockReleaseBuffer(), and vacuum_delay_point().

Referenced by blhandler().