PostgreSQL Source Code git master
Data Structures | Typedefs | Functions
tidstore.h File Reference
#include "storage/itemptr.h"
#include "utils/dsa.h"
Include dependency graph for tidstore.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct   TidStoreIterResult
 

Typedefs

typedef struct TidStore  TidStore
 
typedef struct TidStoreIter  TidStoreIter
 
typedef struct TidStoreIterResult  TidStoreIterResult
 

Functions

TidStore *  TidStoreCreateLocal (size_t max_bytes, bool insert_only)
 
TidStore *  TidStoreCreateShared (size_t max_bytes, int tranche_id)
 
TidStore *  TidStoreAttach (dsa_handle area_handle, dsa_pointer handle)
 
void  TidStoreDetach (TidStore *ts)
 
void  TidStoreLockExclusive (TidStore *ts)
 
void  TidStoreLockShare (TidStore *ts)
 
void  TidStoreUnlock (TidStore *ts)
 
void  TidStoreDestroy (TidStore *ts)
 
void  TidStoreSetBlockOffsets (TidStore *ts, BlockNumber blkno, OffsetNumber *offsets, int num_offsets)
 
bool  TidStoreIsMember (TidStore *ts, ItemPointer tid)
 
TidStoreIter *  TidStoreBeginIterate (TidStore *ts)
 
TidStoreIterResult *  TidStoreIterateNext (TidStoreIter *iter)
 
int  TidStoreGetBlockOffsets (TidStoreIterResult *result, OffsetNumber *offsets, int max_offsets)
 
void  TidStoreEndIterate (TidStoreIter *iter)
 
size_t  TidStoreMemoryUsage (TidStore *ts)
 
dsa_pointer  TidStoreGetHandle (TidStore *ts)
 
dsa_area *  TidStoreGetDSA (TidStore *ts)
 

Typedef Documentation

◆ TidStore

typedef struct TidStore TidStore

Definition at line 20 of file tidstore.h.

◆ TidStoreIter

typedef struct TidStoreIter TidStoreIter

Definition at line 21 of file tidstore.h.

◆ TidStoreIterResult

typedef struct TidStoreIterResult TidStoreIterResult

Function Documentation

◆ TidStoreAttach()

TidStore * TidStoreAttach ( dsa_handle  area_handle,
dsa_pointer  handle 
)

Definition at line 244 of file tidstore.c.

245{
246 TidStore *ts;
247 dsa_area *area;
248
249 Assert(area_handle != DSA_HANDLE_INVALID);
250 Assert(DsaPointerIsValid(handle));
251
252 /* create per-backend state */
253 ts = palloc0(sizeof(TidStore));
254
255 area = dsa_attach(area_handle);
256
257 /* Find the shared the shared radix tree */
258 ts->tree.shared = shared_ts_attach(area, handle);
259 ts->area = area;
260
261 return ts;
262}
dsa_area * dsa_attach(dsa_handle handle)
Definition: dsa.c:510
#define DSA_HANDLE_INVALID
Definition: dsa.h:139
#define DsaPointerIsValid(x)
Definition: dsa.h:106
Assert(PointerIsAligned(start, uint64))
void * palloc0(Size size)
Definition: mcxt.c:1395
dsa_area * area
Definition: tidstore.c:130
shared_ts_radix_tree * shared
Definition: tidstore.c:126
union TidStore::@13 tree
Definition: dsa.c:348

References TidStore::area, Assert(), dsa_attach(), DSA_HANDLE_INVALID, DsaPointerIsValid, palloc0(), TidStore::shared, and TidStore::tree.

Referenced by parallel_vacuum_main().

◆ TidStoreBeginIterate()

TidStoreIter * TidStoreBeginIterate ( TidStore *  ts )

Definition at line 471 of file tidstore.c.

472{
473 TidStoreIter *iter;
474
475 iter = palloc0(sizeof(TidStoreIter));
476 iter->ts = ts;
477
478 if (TidStoreIsShared(ts))
479 iter->tree_iter.shared = shared_ts_begin_iterate(ts->tree.shared);
480 else
481 iter->tree_iter.local = local_ts_begin_iterate(ts->tree.local);
482
483 return iter;
484}
shared_ts_iter * shared
Definition: tidstore.c:142
local_ts_iter * local
Definition: tidstore.c:143
TidStore * ts
Definition: tidstore.c:137
union TidStoreIter::@14 tree_iter
local_ts_radix_tree * local
Definition: tidstore.c:125
#define TidStoreIsShared(ts)
Definition: tidstore.c:132

References TidStore::local, TidStoreIter::local, palloc0(), TidStore::shared, TidStoreIter::shared, TidStoreIsShared, TidStore::tree, TidStoreIter::tree_iter, and TidStoreIter::ts.

Referenced by check_set_block_offsets(), and lazy_vacuum_heap_rel().

◆ TidStoreCreateLocal()

TidStore * TidStoreCreateLocal ( size_t  max_bytes,
bool  insert_only 
)

Definition at line 162 of file tidstore.c.

163{
164 TidStore *ts;
165 size_t initBlockSize = ALLOCSET_DEFAULT_INITSIZE;
166 size_t minContextSize = ALLOCSET_DEFAULT_MINSIZE;
167 size_t maxBlockSize = ALLOCSET_DEFAULT_MAXSIZE;
168
169 ts = palloc0(sizeof(TidStore));
170
171 /* choose the maxBlockSize to be no larger than 1/16 of max_bytes */
172 while (16 * maxBlockSize > max_bytes)
173 maxBlockSize >>= 1;
174
175 if (maxBlockSize < ALLOCSET_DEFAULT_INITSIZE)
176 maxBlockSize = ALLOCSET_DEFAULT_INITSIZE;
177
178 /* Create a memory context for the TID storage */
179 if (insert_only)
180 {
182 "TID storage",
183 minContextSize,
184 initBlockSize,
185 maxBlockSize);
186 }
187 else
188 {
190 "TID storage",
191 minContextSize,
192 initBlockSize,
193 maxBlockSize);
194 }
195
196 ts->tree.local = local_ts_create(ts->rt_context);
197
198 return ts;
199}
MemoryContext BumpContextCreate(MemoryContext parent, const char *name, Size minContextSize, Size initBlockSize, Size maxBlockSize)
Definition: bump.c:133
MemoryContext CurrentMemoryContext
Definition: mcxt.c:160
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_MAXSIZE
Definition: memutils.h:159
#define ALLOCSET_DEFAULT_MINSIZE
Definition: memutils.h:157
#define ALLOCSET_DEFAULT_INITSIZE
Definition: memutils.h:158
MemoryContext rt_context
Definition: tidstore.c:120

References ALLOCSET_DEFAULT_INITSIZE, ALLOCSET_DEFAULT_MAXSIZE, ALLOCSET_DEFAULT_MINSIZE, AllocSetContextCreate, BumpContextCreate(), CurrentMemoryContext, TidStore::local, palloc0(), TidStore::rt_context, and TidStore::tree.

Referenced by dead_items_alloc(), dead_items_reset(), and test_create().

◆ TidStoreCreateShared()

TidStore * TidStoreCreateShared ( size_t  max_bytes,
int  tranche_id 
)

Definition at line 208 of file tidstore.c.

209{
210 TidStore *ts;
211 dsa_area *area;
212 size_t dsa_init_size = DSA_DEFAULT_INIT_SEGMENT_SIZE;
213 size_t dsa_max_size = DSA_MAX_SEGMENT_SIZE;
214
215 ts = palloc0(sizeof(TidStore));
216
217 /*
218 * Choose the initial and maximum DSA segment sizes to be no longer than
219 * 1/8 of max_bytes.
220 */
221 while (8 * dsa_max_size > max_bytes)
222 dsa_max_size >>= 1;
223
224 if (dsa_max_size < DSA_MIN_SEGMENT_SIZE)
225 dsa_max_size = DSA_MIN_SEGMENT_SIZE;
226
227 if (dsa_init_size > dsa_max_size)
228 dsa_init_size = dsa_max_size;
229
230 area = dsa_create_ext(tranche_id, dsa_init_size, dsa_max_size);
231 ts->tree.shared = shared_ts_create(area, tranche_id);
232 ts->area = area;
233
234 return ts;
235}
dsa_area * dsa_create_ext(int tranche_id, size_t init_segment_size, size_t max_segment_size)
Definition: dsa.c:421
#define DSA_MIN_SEGMENT_SIZE
Definition: dsa.h:100
#define DSA_DEFAULT_INIT_SEGMENT_SIZE
Definition: dsa.h:97
#define DSA_MAX_SEGMENT_SIZE
Definition: dsa.h:103

References TidStore::area, dsa_create_ext(), DSA_DEFAULT_INIT_SEGMENT_SIZE, DSA_MAX_SEGMENT_SIZE, DSA_MIN_SEGMENT_SIZE, palloc0(), TidStore::shared, and TidStore::tree.

Referenced by parallel_vacuum_init(), parallel_vacuum_reset_dead_items(), and test_create().

◆ TidStoreDestroy()

void TidStoreDestroy ( TidStore *  ts )

Definition at line 317 of file tidstore.c.

318{
319 /* Destroy underlying radix tree */
320 if (TidStoreIsShared(ts))
321 {
322 shared_ts_free(ts->tree.shared);
323 dsa_detach(ts->area);
324 }
325 else
326 {
327 local_ts_free(ts->tree.local);
329 }
330
331 pfree(ts);
332}
void dsa_detach(dsa_area *area)
Definition: dsa.c:1967
void pfree(void *pointer)
Definition: mcxt.c:1594
void MemoryContextDelete(MemoryContext context)
Definition: mcxt.c:469

References TidStore::area, dsa_detach(), TidStore::local, MemoryContextDelete(), pfree(), TidStore::rt_context, TidStore::shared, TidStoreIsShared, and TidStore::tree.

Referenced by dead_items_reset(), parallel_vacuum_end(), parallel_vacuum_reset_dead_items(), and test_destroy().

◆ TidStoreDetach()

void TidStoreDetach ( TidStore *  ts )

Definition at line 269 of file tidstore.c.

270{
272
273 shared_ts_detach(ts->tree.shared);
274 dsa_detach(ts->area);
275
276 pfree(ts);
277}

References TidStore::area, Assert(), dsa_detach(), pfree(), TidStore::shared, TidStoreIsShared, and TidStore::tree.

Referenced by parallel_vacuum_main().

◆ TidStoreEndIterate()

void TidStoreEndIterate ( TidStoreIter *  iter )

Definition at line 518 of file tidstore.c.

519{
520 if (TidStoreIsShared(iter->ts))
521 shared_ts_end_iterate(iter->tree_iter.shared);
522 else
523 local_ts_end_iterate(iter->tree_iter.local);
524
525 pfree(iter);
526}

References TidStoreIter::local, pfree(), TidStoreIter::shared, TidStoreIsShared, TidStoreIter::tree_iter, and TidStoreIter::ts.

Referenced by check_set_block_offsets(), and lazy_vacuum_heap_rel().

◆ TidStoreGetBlockOffsets()

int TidStoreGetBlockOffsets ( TidStoreIterResult *  result,
OffsetNumber *  offsets,
int  max_offsets 
)

Definition at line 566 of file tidstore.c.

569{
570 BlocktableEntry *page = result->internal_page;
571 int num_offsets = 0;
572 int wordnum;
573
574 if (page->header.nwords == 0)
575 {
576 /* we have offsets in the header */
577 for (int i = 0; i < NUM_FULL_OFFSETS; i++)
578 {
580 {
581 if (num_offsets < max_offsets)
582 offsets[num_offsets] = page->header.full_offsets[i];
583 num_offsets++;
584 }
585 }
586 }
587 else
588 {
589 for (wordnum = 0; wordnum < page->header.nwords; wordnum++)
590 {
591 bitmapword w = page->words[wordnum];
592 int off = wordnum * BITS_PER_BITMAPWORD;
593
594 while (w != 0)
595 {
596 if (w & 1)
597 {
598 if (num_offsets < max_offsets)
599 offsets[num_offsets] = (OffsetNumber) off;
600 num_offsets++;
601 }
602 off++;
603 w >>= 1;
604 }
605 }
606 }
607
608 return num_offsets;
609}
uint32 bitmapword
Definition: bitmapset.h:44
#define BITS_PER_BITMAPWORD
Definition: bitmapset.h:43
i
int i
Definition: isn.c:77
#define InvalidOffsetNumber
Definition: off.h:26
uint16 OffsetNumber
Definition: off.h:24
int8 nwords
Definition: tidstore.c:56
bitmapword words[FLEXIBLE_ARRAY_MEMBER]
Definition: tidstore.c:76
struct BlocktableEntry::@12 header
OffsetNumber full_offsets[NUM_FULL_OFFSETS]
Definition: tidstore.c:63
void * internal_page
Definition: tidstore.h:30
#define NUM_FULL_OFFSETS
Definition: tidstore.c:38

References BITS_PER_BITMAPWORD, BlocktableEntry::full_offsets, BlocktableEntry::header, i, TidStoreIterResult::internal_page, InvalidOffsetNumber, NUM_FULL_OFFSETS, BlocktableEntry::nwords, and BlocktableEntry::words.

Referenced by check_set_block_offsets(), and lazy_vacuum_heap_rel().

◆ TidStoreGetDSA()

dsa_area * TidStoreGetDSA ( TidStore *  ts )

Definition at line 544 of file tidstore.c.

545{
547
548 return ts->area;
549}

References TidStore::area, Assert(), and TidStoreIsShared.

Referenced by parallel_vacuum_init(), parallel_vacuum_reset_dead_items(), and test_create().

◆ TidStoreGetHandle()

dsa_pointer TidStoreGetHandle ( TidStore *  ts )

Definition at line 552 of file tidstore.c.

553{
555
556 return (dsa_pointer) shared_ts_get_handle(ts->tree.shared);
557}
uint64 dsa_pointer
Definition: dsa.h:62

References Assert(), TidStore::shared, TidStoreIsShared, and TidStore::tree.

Referenced by parallel_vacuum_init(), and parallel_vacuum_reset_dead_items().

◆ TidStoreIsMember()

bool TidStoreIsMember ( TidStore *  ts,
ItemPointer  tid 
)

Definition at line 421 of file tidstore.c.

422{
423 int wordnum;
424 int bitnum;
425 BlocktableEntry *page;
428
429 if (TidStoreIsShared(ts))
430 page = shared_ts_find(ts->tree.shared, blk);
431 else
432 page = local_ts_find(ts->tree.local, blk);
433
434 /* no entry for the blk */
435 if (page == NULL)
436 return false;
437
438 if (page->header.nwords == 0)
439 {
440 /* we have offsets in the header */
441 for (int i = 0; i < NUM_FULL_OFFSETS; i++)
442 {
443 if (page->header.full_offsets[i] == off)
444 return true;
445 }
446 return false;
447 }
448 else
449 {
450 wordnum = WORDNUM(off);
451 bitnum = BITNUM(off);
452
453 /* no bitmap for the off */
454 if (wordnum >= page->header.nwords)
455 return false;
456
457 return (page->words[wordnum] & ((bitmapword) 1 << bitnum)) != 0;
458 }
459}
uint32 BlockNumber
Definition: block.h:31
static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)
Definition: itemptr.h:124
static BlockNumber ItemPointerGetBlockNumber(const ItemPointerData *pointer)
Definition: itemptr.h:103
#define WORDNUM(x)
Definition: tidstore.c:31
#define BITNUM(x)
Definition: tidstore.c:32

References BITNUM, BlocktableEntry::full_offsets, BlocktableEntry::header, i, ItemPointerGetBlockNumber(), ItemPointerGetOffsetNumber(), TidStore::local, NUM_FULL_OFFSETS, BlocktableEntry::nwords, TidStore::shared, TidStoreIsShared, TidStore::tree, WORDNUM, and BlocktableEntry::words.

Referenced by check_set_block_offsets(), and vac_tid_reaped().

◆ TidStoreIterateNext()

TidStoreIterResult * TidStoreIterateNext ( TidStoreIter *  iter )

Definition at line 493 of file tidstore.c.

494{
495 uint64 key;
496 BlocktableEntry *page;
497
498 if (TidStoreIsShared(iter->ts))
499 page = shared_ts_iterate_next(iter->tree_iter.shared, &key);
500 else
501 page = local_ts_iterate_next(iter->tree_iter.local, &key);
502
503 if (page == NULL)
504 return NULL;
505
506 iter->output.blkno = key;
507 iter->output.internal_page = page;
508
509 return &(iter->output);
510}
uint64_t uint64
Definition: c.h:539
BlockNumber blkno
Definition: tidstore.h:29
TidStoreIterResult output
Definition: tidstore.c:147

References TidStoreIterResult::blkno, TidStoreIterResult::internal_page, sort-test::key, TidStoreIter::local, TidStoreIter::output, TidStoreIter::shared, TidStoreIsShared, TidStoreIter::tree_iter, and TidStoreIter::ts.

Referenced by check_set_block_offsets(), and vacuum_reap_lp_read_stream_next().

◆ TidStoreLockExclusive()

void TidStoreLockExclusive ( TidStore *  ts )

Definition at line 287 of file tidstore.c.

288{
289 if (TidStoreIsShared(ts))
290 shared_ts_lock_exclusive(ts->tree.shared);
291}

References TidStore::shared, TidStoreIsShared, and TidStore::tree.

Referenced by do_set_block_offsets().

◆ TidStoreLockShare()

void TidStoreLockShare ( TidStore *  ts )

Definition at line 294 of file tidstore.c.

295{
296 if (TidStoreIsShared(ts))
297 shared_ts_lock_share(ts->tree.shared);
298}

References TidStore::shared, TidStoreIsShared, and TidStore::tree.

Referenced by check_set_block_offsets().

◆ TidStoreMemoryUsage()

size_t TidStoreMemoryUsage ( TidStore *  ts )

Definition at line 532 of file tidstore.c.

533{
534 if (TidStoreIsShared(ts))
535 return shared_ts_memory_usage(ts->tree.shared);
536 else
537 return local_ts_memory_usage(ts->tree.local);
538}

References TidStore::local, TidStore::shared, TidStoreIsShared, and TidStore::tree.

Referenced by dead_items_add(), lazy_scan_heap(), lazy_vacuum(), test_create(), and test_is_full().

◆ TidStoreSetBlockOffsets()

void TidStoreSetBlockOffsets ( TidStore *  ts,
BlockNumber  blkno,
OffsetNumber *  offsets,
int  num_offsets 
)

Definition at line 345 of file tidstore.c.

347{
348 union
349 {
351 BlocktableEntry force_align_entry;
352 } data;
353 BlocktableEntry *page = (BlocktableEntry *) data.data;
355 int wordnum;
356 int next_word_threshold;
357 int idx = 0;
358
359 Assert(num_offsets > 0);
360
361 /* Check if the given offset numbers are ordered */
362 for (int i = 1; i < num_offsets; i++)
363 Assert(offsets[i] > offsets[i - 1]);
364
365 memset(page, 0, offsetof(BlocktableEntry, words));
366
367 if (num_offsets <= NUM_FULL_OFFSETS)
368 {
369 for (int i = 0; i < num_offsets; i++)
370 {
371 OffsetNumber off = offsets[i];
372
373 /* safety check to ensure we don't overrun bit array bounds */
374 if (off == InvalidOffsetNumber || off > MAX_OFFSET_IN_BITMAP)
375 elog(ERROR, "tuple offset out of range: %u", off);
376
377 page->header.full_offsets[i] = off;
378 }
379
380 page->header.nwords = 0;
381 }
382 else
383 {
384 for (wordnum = 0, next_word_threshold = BITS_PER_BITMAPWORD;
385 wordnum <= WORDNUM(offsets[num_offsets - 1]);
386 wordnum++, next_word_threshold += BITS_PER_BITMAPWORD)
387 {
388 word = 0;
389
390 while (idx < num_offsets)
391 {
392 OffsetNumber off = offsets[idx];
393
394 /* safety check to ensure we don't overrun bit array bounds */
395 if (off == InvalidOffsetNumber || off > MAX_OFFSET_IN_BITMAP)
396 elog(ERROR, "tuple offset out of range: %u", off);
397
398 if (off >= next_word_threshold)
399 break;
400
401 word |= ((bitmapword) 1 << BITNUM(off));
402 idx++;
403 }
404
405 /* write out offset bitmap for this wordnum */
406 page->words[wordnum] = word;
407 }
408
409 page->header.nwords = wordnum;
410 Assert(page->header.nwords == WORDS_PER_PAGE(offsets[num_offsets - 1]));
411 }
412
413 if (TidStoreIsShared(ts))
414 shared_ts_set(ts->tree.shared, blkno, page);
415 else
416 local_ts_set(ts->tree.local, blkno, page);
417}
Datum idx(PG_FUNCTION_ARGS)
Definition: _int_op.c:262
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
const void * data
static void word(struct vars *v, int dir, struct state *lp, struct state *rp)
Definition: regcomp.c:1476
#define WORDS_PER_PAGE(n)
Definition: tidstore.c:35
#define MAX_OFFSET_IN_BITMAP
Definition: tidstore.c:84
#define MaxBlocktableEntrySize
Definition: tidstore.c:86

References Assert(), BITNUM, BITS_PER_BITMAPWORD, data, elog, ERROR, BlocktableEntry::full_offsets, BlocktableEntry::header, i, idx(), InvalidOffsetNumber, TidStore::local, MAX_OFFSET_IN_BITMAP, MaxBlocktableEntrySize, NUM_FULL_OFFSETS, BlocktableEntry::nwords, TidStore::shared, TidStoreIsShared, TidStore::tree, word(), WORDNUM, BlocktableEntry::words, and WORDS_PER_PAGE.

Referenced by dead_items_add(), and do_set_block_offsets().

◆ TidStoreUnlock()

void TidStoreUnlock ( TidStore *  ts )

Definition at line 301 of file tidstore.c.

302{
303 if (TidStoreIsShared(ts))
304 shared_ts_unlock(ts->tree.shared);
305}

References TidStore::shared, TidStoreIsShared, and TidStore::tree.

Referenced by check_set_block_offsets(), and do_set_block_offsets().

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