PostgreSQL Source Code git master
Macros | Functions
visibilitymap.h File Reference
#include "access/visibilitymapdefs.h"
#include "access/xlogdefs.h"
#include "storage/block.h"
#include "storage/buf.h"
#include "utils/relcache.h"
Include dependency graph for visibilitymap.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define  VM_ALL_VISIBLE(r, b, v)    ((visibilitymap_get_status((r), (b), (v)) & VISIBILITYMAP_ALL_VISIBLE) != 0)
 
#define  VM_ALL_FROZEN(r, b, v)    ((visibilitymap_get_status((r), (b), (v)) & VISIBILITYMAP_ALL_FROZEN) != 0)
 

Functions

bool  visibilitymap_clear (Relation rel, BlockNumber heapBlk, Buffer vmbuf, uint8 flags)
 
void  visibilitymap_pin (Relation rel, BlockNumber heapBlk, Buffer *vmbuf)
 
bool  visibilitymap_pin_ok (BlockNumber heapBlk, Buffer vmbuf)
 
uint8  visibilitymap_set (Relation rel, BlockNumber heapBlk, Buffer heapBuf, XLogRecPtr recptr, Buffer vmBuf, TransactionId cutoff_xid, uint8 flags)
 
uint8  visibilitymap_get_status (Relation rel, BlockNumber heapBlk, Buffer *vmbuf)
 
void  visibilitymap_count (Relation rel, BlockNumber *all_visible, BlockNumber *all_frozen)
 
BlockNumber  visibilitymap_prepare_truncate (Relation rel, BlockNumber nheapblocks)
 

Macro Definition Documentation

◆ VM_ALL_FROZEN

#define VM_ALL_FROZEN (   r,
  b,
  v 
)     ((visibilitymap_get_status((r), (b), (v)) & VISIBILITYMAP_ALL_FROZEN) != 0)

Definition at line 26 of file visibilitymap.h.

◆ VM_ALL_VISIBLE

#define VM_ALL_VISIBLE (   r,
  b,
  v 
)     ((visibilitymap_get_status((r), (b), (v)) & VISIBILITYMAP_ALL_VISIBLE) != 0)

Definition at line 24 of file visibilitymap.h.

Function Documentation

◆ visibilitymap_clear()

bool visibilitymap_clear ( Relation  rel,
BlockNumber  heapBlk,
Buffer  vmbuf,
uint8  flags 
)

Definition at line 138 of file visibilitymap.c.

139{
140 BlockNumber mapBlock = HEAPBLK_TO_MAPBLOCK(heapBlk);
141 int mapByte = HEAPBLK_TO_MAPBYTE(heapBlk);
142 int mapOffset = HEAPBLK_TO_OFFSET(heapBlk);
143 uint8 mask = flags << mapOffset;
144 char *map;
145 bool cleared = false;
146
147 /* Must never clear all_visible bit while leaving all_frozen bit set */
150
151#ifdef TRACE_VISIBILITYMAP
152 elog(DEBUG1, "vm_clear %s %d", RelationGetRelationName(rel), heapBlk);
153#endif
154
155 if (!BufferIsValid(vmbuf) || BufferGetBlockNumber(vmbuf) != mapBlock)
156 elog(ERROR, "wrong buffer passed to visibilitymap_clear");
157
159 map = PageGetContents(BufferGetPage(vmbuf));
160
161 if (map[mapByte] & mask)
162 {
163 map[mapByte] &= ~mask;
164
165 MarkBufferDirty(vmbuf);
166 cleared = true;
167 }
168
170
171 return cleared;
172}
uint32 BlockNumber
Definition: block.h:31
BlockNumber BufferGetBlockNumber(Buffer buffer)
Definition: bufmgr.c:4198
void MarkBufferDirty(Buffer buffer)
Definition: bufmgr.c:2921
void LockBuffer(Buffer buffer, int mode)
Definition: bufmgr.c:5572
#define BUFFER_LOCK_UNLOCK
Definition: bufmgr.h:196
static Page BufferGetPage(Buffer buffer)
Definition: bufmgr.h:417
#define BUFFER_LOCK_EXCLUSIVE
Definition: bufmgr.h:198
static bool BufferIsValid(Buffer bufnum)
Definition: bufmgr.h:368
static char * PageGetContents(Page page)
Definition: bufpage.h:258
uint8_t uint8
Definition: c.h:536
#define DEBUG1
Definition: elog.h:30
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
Assert(PointerIsAligned(start, uint64))
#define RelationGetRelationName(relation)
Definition: rel.h:548
#define HEAPBLK_TO_OFFSET(x)
Definition: visibilitymap.c:119
#define HEAPBLK_TO_MAPBLOCK(x)
Definition: visibilitymap.c:117
#define HEAPBLK_TO_MAPBYTE(x)
Definition: visibilitymap.c:118
#define VISIBILITYMAP_VALID_BITS
#define VISIBILITYMAP_ALL_VISIBLE

References Assert(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), DEBUG1, elog, ERROR, HEAPBLK_TO_MAPBLOCK, HEAPBLK_TO_MAPBYTE, HEAPBLK_TO_OFFSET, LockBuffer(), MarkBufferDirty(), PageGetContents(), RelationGetRelationName, VISIBILITYMAP_ALL_VISIBLE, and VISIBILITYMAP_VALID_BITS.

Referenced by heap_delete(), heap_force_common(), heap_insert(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_multi_insert(), heap_update(), heap_xlog_delete(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_multi_insert(), heap_xlog_update(), and lazy_scan_prune().

◆ visibilitymap_count()

void visibilitymap_count ( Relation  rel,
BlockNumber *  all_visible,
BlockNumber *  all_frozen 
)

Definition at line 392 of file visibilitymap.c.

393{
394 BlockNumber mapBlock;
395 BlockNumber nvisible = 0;
396 BlockNumber nfrozen = 0;
397
398 /* all_visible must be specified */
399 Assert(all_visible);
400
401 for (mapBlock = 0;; mapBlock++)
402 {
403 Buffer mapBuffer;
404 uint64 *map;
405
406 /*
407 * Read till we fall off the end of the map. We assume that any extra
408 * bytes in the last page are zeroed, so we don't bother excluding
409 * them from the count.
410 */
411 mapBuffer = vm_readbuf(rel, mapBlock, false);
412 if (!BufferIsValid(mapBuffer))
413 break;
414
415 /*
416 * We choose not to lock the page, since the result is going to be
417 * immediately stale anyway if anyone is concurrently setting or
418 * clearing bits, and we only really need an approximate value.
419 */
420 map = (uint64 *) PageGetContents(BufferGetPage(mapBuffer));
421
422 nvisible += pg_popcount_masked((const char *) map, MAPSIZE, VISIBLE_MASK8);
423 if (all_frozen)
424 nfrozen += pg_popcount_masked((const char *) map, MAPSIZE, FROZEN_MASK8);
425
426 ReleaseBuffer(mapBuffer);
427 }
428
429 *all_visible = nvisible;
430 if (all_frozen)
431 *all_frozen = nfrozen;
432}
int Buffer
Definition: buf.h:23
void ReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:5338
uint64_t uint64
Definition: c.h:539
static uint64 pg_popcount_masked(const char *buf, int bytes, bits8 mask)
Definition: pg_bitutils.h:394
#define MAPSIZE
Definition: visibilitymap.c:108
#define FROZEN_MASK8
Definition: visibilitymap.c:123
#define VISIBLE_MASK8
Definition: visibilitymap.c:122
static Buffer vm_readbuf(Relation rel, BlockNumber blkno, bool extend)
Definition: visibilitymap.c:546

References Assert(), BufferGetPage(), BufferIsValid(), FROZEN_MASK8, MAPSIZE, PageGetContents(), pg_popcount_masked(), ReleaseBuffer(), VISIBLE_MASK8, and vm_readbuf().

Referenced by do_analyze_rel(), heap_vacuum_eager_scan_setup(), heap_vacuum_rel(), and index_update_stats().

◆ visibilitymap_get_status()

uint8 visibilitymap_get_status ( Relation  rel,
BlockNumber  heapBlk,
Buffer *  vmbuf 
)

Definition at line 344 of file visibilitymap.c.

345{
346 BlockNumber mapBlock = HEAPBLK_TO_MAPBLOCK(heapBlk);
347 uint32 mapByte = HEAPBLK_TO_MAPBYTE(heapBlk);
348 uint8 mapOffset = HEAPBLK_TO_OFFSET(heapBlk);
349 char *map;
350 uint8 result;
351
352#ifdef TRACE_VISIBILITYMAP
353 elog(DEBUG1, "vm_get_status %s %d", RelationGetRelationName(rel), heapBlk);
354#endif
355
356 /* Reuse the old pinned buffer if possible */
357 if (BufferIsValid(*vmbuf))
358 {
359 if (BufferGetBlockNumber(*vmbuf) != mapBlock)
360 {
361 ReleaseBuffer(*vmbuf);
362 *vmbuf = InvalidBuffer;
363 }
364 }
365
366 if (!BufferIsValid(*vmbuf))
367 {
368 *vmbuf = vm_readbuf(rel, mapBlock, false);
369 if (!BufferIsValid(*vmbuf))
370 return (uint8) 0;
371 }
372
373 map = PageGetContents(BufferGetPage(*vmbuf));
374
375 /*
376 * A single byte read is atomic. There could be memory-ordering effects
377 * here, but for performance reasons we make it the caller's job to worry
378 * about that.
379 */
380 result = ((map[mapByte] >> mapOffset) & VISIBILITYMAP_VALID_BITS);
381 return result;
382}
#define InvalidBuffer
Definition: buf.h:25
uint32_t uint32
Definition: c.h:538

References BufferGetBlockNumber(), BufferGetPage(), BufferIsValid(), DEBUG1, elog, HEAPBLK_TO_MAPBLOCK, HEAPBLK_TO_MAPBYTE, HEAPBLK_TO_OFFSET, InvalidBuffer, PageGetContents(), RelationGetRelationName, ReleaseBuffer(), VISIBILITYMAP_VALID_BITS, and vm_readbuf().

Referenced by collect_visibility_data(), find_next_unskippable_block(), heapcheck_read_stream_next_unskippable(), lazy_scan_prune(), pg_visibility(), pg_visibility_map(), and pg_visibility_map_summary().

◆ visibilitymap_pin()

void visibilitymap_pin ( Relation  rel,
BlockNumber  heapBlk,
Buffer *  vmbuf 
)

Definition at line 191 of file visibilitymap.c.

192{
193 BlockNumber mapBlock = HEAPBLK_TO_MAPBLOCK(heapBlk);
194
195 /* Reuse the old pinned buffer if possible */
196 if (BufferIsValid(*vmbuf))
197 {
198 if (BufferGetBlockNumber(*vmbuf) == mapBlock)
199 return;
200
201 ReleaseBuffer(*vmbuf);
202 }
203 *vmbuf = vm_readbuf(rel, mapBlock, true);
204}

References BufferGetBlockNumber(), BufferIsValid(), HEAPBLK_TO_MAPBLOCK, ReleaseBuffer(), and vm_readbuf().

Referenced by GetVisibilityMapPins(), heap_delete(), heap_force_common(), heap_lock_tuple(), heap_lock_updated_tuple_rec(), heap_update(), heap_xlog_delete(), heap_xlog_insert(), heap_xlog_lock(), heap_xlog_lock_updated(), heap_xlog_multi_insert(), heap_xlog_update(), lazy_scan_heap(), lazy_vacuum_heap_rel(), and RelationGetBufferForTuple().

◆ visibilitymap_pin_ok()

bool visibilitymap_pin_ok ( BlockNumber  heapBlk,
Buffer  vmbuf 
)

Definition at line 215 of file visibilitymap.c.

216{
217 BlockNumber mapBlock = HEAPBLK_TO_MAPBLOCK(heapBlk);
218
219 return BufferIsValid(vmbuf) && BufferGetBlockNumber(vmbuf) == mapBlock;
220}

References BufferGetBlockNumber(), BufferIsValid(), and HEAPBLK_TO_MAPBLOCK.

Referenced by GetVisibilityMapPins(), and RelationGetBufferForTuple().

◆ visibilitymap_prepare_truncate()

BlockNumber visibilitymap_prepare_truncate ( Relation  rel,
BlockNumber  nheapblocks 
)

Definition at line 446 of file visibilitymap.c.

447{
448 BlockNumber newnblocks;
449
450 /* last remaining block, byte, and bit */
451 BlockNumber truncBlock = HEAPBLK_TO_MAPBLOCK(nheapblocks);
452 uint32 truncByte = HEAPBLK_TO_MAPBYTE(nheapblocks);
453 uint8 truncOffset = HEAPBLK_TO_OFFSET(nheapblocks);
454
455#ifdef TRACE_VISIBILITYMAP
456 elog(DEBUG1, "vm_truncate %s %d", RelationGetRelationName(rel), nheapblocks);
457#endif
458
459 /*
460 * If no visibility map has been created yet for this relation, there's
461 * nothing to truncate.
462 */
464 return InvalidBlockNumber;
465
466 /*
467 * Unless the new size is exactly at a visibility map page boundary, the
468 * tail bits in the last remaining map page, representing truncated heap
469 * blocks, need to be cleared. This is not only tidy, but also necessary
470 * because we don't get a chance to clear the bits if the heap is extended
471 * again.
472 */
473 if (truncByte != 0 || truncOffset != 0)
474 {
475 Buffer mapBuffer;
476 Page page;
477 char *map;
478
479 newnblocks = truncBlock + 1;
480
481 mapBuffer = vm_readbuf(rel, truncBlock, false);
482 if (!BufferIsValid(mapBuffer))
483 {
484 /* nothing to do, the file was already smaller */
485 return InvalidBlockNumber;
486 }
487
488 page = BufferGetPage(mapBuffer);
489 map = PageGetContents(page);
490
492
493 /* NO EREPORT(ERROR) from here till changes are logged */
495
496 /* Clear out the unwanted bytes. */
497 MemSet(&map[truncByte + 1], 0, MAPSIZE - (truncByte + 1));
498
499 /*----
500 * Mask out the unwanted bits of the last remaining byte.
501 *
502 * ((1 << 0) - 1) = 00000000
503 * ((1 << 1) - 1) = 00000001
504 * ...
505 * ((1 << 6) - 1) = 00111111
506 * ((1 << 7) - 1) = 01111111
507 *----
508 */
509 map[truncByte] &= (1 << truncOffset) - 1;
510
511 /*
512 * Truncation of a relation is WAL-logged at a higher-level, and we
513 * will be called at WAL replay. But if checksums are enabled, we need
514 * to still write a WAL record to protect against a torn page, if the
515 * page is flushed to disk before the truncation WAL record. We cannot
516 * use MarkBufferDirtyHint here, because that will not dirty the page
517 * during recovery.
518 */
519 MarkBufferDirty(mapBuffer);
521 log_newpage_buffer(mapBuffer, false);
522
524
525 UnlockReleaseBuffer(mapBuffer);
526 }
527 else
528 newnblocks = truncBlock;
529
530 if (smgrnblocks(RelationGetSmgr(rel), VISIBILITYMAP_FORKNUM) <= newnblocks)
531 {
532 /* nothing to do, the file was already smaller than requested size */
533 return InvalidBlockNumber;
534 }
535
536 return newnblocks;
537}
#define InvalidBlockNumber
Definition: block.h:33
void UnlockReleaseBuffer(Buffer buffer)
Definition: bufmgr.c:5355
PageData * Page
Definition: bufpage.h:82
#define MemSet(start, val, len)
Definition: c.h:1019
#define START_CRIT_SECTION()
Definition: miscadmin.h:149
#define END_CRIT_SECTION()
Definition: miscadmin.h:151
static SMgrRelation RelationGetSmgr(Relation rel)
Definition: rel.h:576
#define RelationNeedsWAL(relation)
Definition: rel.h:637
@ VISIBILITYMAP_FORKNUM
Definition: relpath.h:60
BlockNumber smgrnblocks(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:819
bool smgrexists(SMgrRelation reln, ForkNumber forknum)
Definition: smgr.c:462
#define XLogHintBitIsNeeded()
Definition: xlog.h:120
XLogRecPtr log_newpage_buffer(Buffer buffer, bool page_std)
Definition: xloginsert.c:1249
bool InRecovery
Definition: xlogutils.c:50

References BUFFER_LOCK_EXCLUSIVE, BufferGetPage(), BufferIsValid(), DEBUG1, elog, END_CRIT_SECTION, HEAPBLK_TO_MAPBLOCK, HEAPBLK_TO_MAPBYTE, HEAPBLK_TO_OFFSET, InRecovery, InvalidBlockNumber, LockBuffer(), log_newpage_buffer(), MAPSIZE, MarkBufferDirty(), MemSet, PageGetContents(), RelationGetRelationName, RelationGetSmgr(), RelationNeedsWAL, smgrexists(), smgrnblocks(), START_CRIT_SECTION, UnlockReleaseBuffer(), VISIBILITYMAP_FORKNUM, vm_readbuf(), and XLogHintBitIsNeeded.

Referenced by pg_truncate_visibility_map(), RelationTruncate(), and smgr_redo().

◆ visibilitymap_set()

uint8 visibilitymap_set ( Relation  rel,
BlockNumber  heapBlk,
Buffer  heapBuf,
XLogRecPtr  recptr,
Buffer  vmBuf,
TransactionId  cutoff_xid,
uint8  flags 
)

Definition at line 246 of file visibilitymap.c.

249{
250 BlockNumber mapBlock = HEAPBLK_TO_MAPBLOCK(heapBlk);
251 uint32 mapByte = HEAPBLK_TO_MAPBYTE(heapBlk);
252 uint8 mapOffset = HEAPBLK_TO_OFFSET(heapBlk);
253 Page page;
254 uint8 *map;
255 uint8 status;
256
257#ifdef TRACE_VISIBILITYMAP
258 elog(DEBUG1, "vm_set flags 0x%02X for %s %d",
259 flags, RelationGetRelationName(rel), heapBlk);
260#endif
261
264 Assert((flags & VISIBILITYMAP_VALID_BITS) == flags);
265
266 /* Must never set all_frozen bit without also setting all_visible bit */
268
269 /* Check that we have the right heap page pinned, if present */
270 if (BufferIsValid(heapBuf) && BufferGetBlockNumber(heapBuf) != heapBlk)
271 elog(ERROR, "wrong heap buffer passed to visibilitymap_set");
272
273 Assert(!BufferIsValid(heapBuf) || BufferIsExclusiveLocked(heapBuf));
274
275 /* Check that we have the right VM page pinned */
276 if (!BufferIsValid(vmBuf) || BufferGetBlockNumber(vmBuf) != mapBlock)
277 elog(ERROR, "wrong VM buffer passed to visibilitymap_set");
278
279 page = BufferGetPage(vmBuf);
280 map = (uint8 *) PageGetContents(page);
282
283 status = (map[mapByte] >> mapOffset) & VISIBILITYMAP_VALID_BITS;
284 if (flags != status)
285 {
287
288 map[mapByte] |= (flags << mapOffset);
289 MarkBufferDirty(vmBuf);
290
291 if (RelationNeedsWAL(rel))
292 {
293 if (XLogRecPtrIsInvalid(recptr))
294 {
296 recptr = log_heap_visible(rel, heapBuf, vmBuf, cutoff_xid, flags);
297
298 /*
299 * If data checksums are enabled (or wal_log_hints=on), we
300 * need to protect the heap page from being torn.
301 *
302 * If not, then we must *not* update the heap page's LSN. In
303 * this case, the FPI for the heap page was omitted from the
304 * WAL record inserted above, so it would be incorrect to
305 * update the heap page's LSN.
306 */
308 {
309 Page heapPage = BufferGetPage(heapBuf);
310
311 PageSetLSN(heapPage, recptr);
312 }
313 }
314 PageSetLSN(page, recptr);
315 }
316
318 }
319
321 return status;
322}
bool BufferIsExclusiveLocked(Buffer buffer)
Definition: bufmgr.c:2860
static bool PageIsAllVisible(const PageData *page)
Definition: bufpage.h:429
static void PageSetLSN(Page page, XLogRecPtr lsn)
Definition: bufpage.h:391
XLogRecPtr log_heap_visible(Relation rel, Buffer heap_buffer, Buffer vm_buffer, TransactionId snapshotConflictHorizon, uint8 vmflags)
Definition: heapam.c:8804
#define VISIBILITYMAP_ALL_FROZEN
#define XLogRecPtrIsInvalid(r)
Definition: xlogdefs.h:29

References Assert(), BUFFER_LOCK_EXCLUSIVE, BUFFER_LOCK_UNLOCK, BufferGetBlockNumber(), BufferGetPage(), BufferIsExclusiveLocked(), BufferIsValid(), DEBUG1, elog, END_CRIT_SECTION, ERROR, HEAPBLK_TO_MAPBLOCK, HEAPBLK_TO_MAPBYTE, HEAPBLK_TO_OFFSET, InRecovery, LockBuffer(), log_heap_visible(), MarkBufferDirty(), PageGetContents(), PageIsAllVisible(), PageSetLSN(), RelationGetRelationName, RelationNeedsWAL, START_CRIT_SECTION, VISIBILITYMAP_ALL_FROZEN, VISIBILITYMAP_VALID_BITS, XLogHintBitIsNeeded, and XLogRecPtrIsInvalid.

Referenced by heap_multi_insert(), heap_xlog_visible(), lazy_scan_new_or_empty(), lazy_scan_prune(), and lazy_vacuum_heap_page().

AltStyle によって変換されたページ (->オリジナル) /