From 6f4ff3584cbbf4db3ed7268ebc360df0ad328696 Mon Sep 17 00:00:00 2001 From: Masahiko Sawada Date: Mon, 17 Apr 2023 17:47:10 +0900 Subject: [PATCH v32 11/18] tidstore, vacuum: Use camel case for TidStore APIs --- src/backend/access/common/tidstore.c | 64 +++++++++--------- src/backend/access/heap/vacuumlazy.c | 44 ++++++------ src/backend/commands/vacuum.c | 4 +- src/backend/commands/vacuumparallel.c | 12 ++-- src/include/access/tidstore.h | 34 +++++----- .../modules/test_tidstore/test_tidstore.c | 67 ++++++++++--------- 6 files changed, 114 insertions(+), 111 deletions(-) diff --git a/src/backend/access/common/tidstore.c b/src/backend/access/common/tidstore.c index 8c05e60d92..283a326d13 100644 --- a/src/backend/access/common/tidstore.c +++ b/src/backend/access/common/tidstore.c @@ -7,9 +7,9 @@ * Internally, a tid is encoded as a pair of 64-bit key and 64-bit value, and * stored in the radix tree. * - * A TidStore can be shared among parallel worker processes by passing DSA area - * to tidstore_create(). Other backends can attach to the shared TidStore by - * tidstore_attach(). + * TidStore can be shared among parallel worker processes by passing DSA area + * to TidStoreCreate(). Other backends can attach to the shared TidStore by + * TidStoreAttach(). * * Regarding the concurrency, it basically relies on the concurrency support in * the radix tree, but we acquires the lock on a TidStore in some cases, for @@ -106,7 +106,7 @@ typedef struct TidStoreControl LWLock lock; /* handles for TidStore and radix tree */ - tidstore_handle handle; + TidStoreHandle handle; shared_rt_handle tree_handle; } TidStoreControl; @@ -164,7 +164,7 @@ static inline uint64 tid_to_key_off(TidStore *ts, ItemPointer tid, uint64 *off_b * The radix tree for storage is allocated in DSA area is 'area' is non-NULL. */ TidStore * -tidstore_create(size_t max_bytes, int max_offset, dsa_area *area) +TidStoreCreate(size_t max_bytes, int max_off, dsa_area *area) { TidStore *ts; @@ -176,12 +176,12 @@ tidstore_create(size_t max_bytes, int max_offset, dsa_area *area) * Memory consumption depends on the number of stored tids, but also on the * distribution of them, how the radix tree stores, and the memory management * that backed the radix tree. The maximum bytes that a TidStore can - * use is specified by the max_bytes in tidstore_create(). We want the total + * use is specified by the max_bytes in TidStoreCreate(). We want the total * amount of memory consumption by a TidStore not to exceed the max_bytes. * * In local TidStore cases, the radix tree uses slab allocators for each kind * of node class. The most memory consuming case while adding Tids associated - * with one page (i.e. during tidstore_add_tids()) is that we allocate a new + * with one page (i.e. during TidStoreSetBlockOffsets()) is that we allocate a new * slab block for a new radix tree node, which is approximately 70kB. Therefore, * we deduct 70kB from the max_bytes. * @@ -235,7 +235,7 @@ tidstore_create(size_t max_bytes, int max_offset, dsa_area *area) * allocated in backend-local memory using the CurrentMemoryContext. */ TidStore * -tidstore_attach(dsa_area *area, tidstore_handle handle) +TidStoreAttach(dsa_area *area, TidStoreHandle handle) { TidStore *ts; dsa_pointer control; @@ -266,7 +266,7 @@ tidstore_attach(dsa_area *area, tidstore_handle handle) * to the operating system. */ void -tidstore_detach(TidStore *ts) +TidStoreDetach(TidStore *ts) { Assert(TidStoreIsShared(ts) && ts->control->magic == TIDSTORE_MAGIC); @@ -279,12 +279,12 @@ tidstore_detach(TidStore *ts) * * TODO: The caller must be certain that no other backend will attempt to * access the TidStore before calling this function. Other backend must - * explicitly call tidstore_detach to free up backend-local memory associated - * with the TidStore. The backend that calls tidstore_destroy must not call - * tidstore_detach. + * explicitly call TidStoreDetach() to free up backend-local memory associated + * with the TidStore. The backend that calls TidStoreDestroy() must not call + * TidStoreDetach(). */ void -tidstore_destroy(TidStore *ts) +TidStoreDestroy(TidStore *ts) { if (TidStoreIsShared(ts)) { @@ -309,11 +309,11 @@ tidstore_destroy(TidStore *ts) } /* - * Forget all collected Tids. It's similar to tidstore_destroy but we don't free + * Forget all collected Tids. It's similar to TidStoreDestroy() but we don't free * entire TidStore but recreate only the radix tree storage. */ void -tidstore_reset(TidStore *ts) +TidStoreReset(TidStore *ts) { if (TidStoreIsShared(ts)) { @@ -352,8 +352,8 @@ tidstore_reset(TidStore *ts) /* Add Tids on a block to TidStore */ void -tidstore_add_tids(TidStore *ts, BlockNumber blkno, OffsetNumber *offsets, - int num_offsets) +TidStoreSetBlockOffsets(TidStore *ts, BlockNumber blkno, OffsetNumber *offsets, + int num_offsets) { uint64 *values; uint64 key; @@ -431,7 +431,7 @@ tidstore_add_tids(TidStore *ts, BlockNumber blkno, OffsetNumber *offsets, /* Return true if the given tid is present in the TidStore */ bool -tidstore_lookup_tid(TidStore *ts, ItemPointer tid) +TidStoreIsMember(TidStore *ts, ItemPointer tid) { uint64 key; uint64 val = 0; @@ -452,14 +452,16 @@ tidstore_lookup_tid(TidStore *ts, ItemPointer tid) } /* - * Prepare to iterate through a TidStore. Since the radix tree is locked during the - * iteration, so tidstore_end_iterate() needs to called when finished. + * Prepare to iterate through a TidStore. Since the radix tree is locked during + * the iteration, so TidStoreEndIterate() needs to be called when finished. + * + * The TidStoreIter struct is created in the caller's memory context. * * Concurrent updates during the iteration will be blocked when inserting a * key-value to the radix tree. */ TidStoreIter * -tidstore_begin_iterate(TidStore *ts) +TidStoreBeginIterate(TidStore *ts) { TidStoreIter *iter; @@ -477,7 +479,7 @@ tidstore_begin_iterate(TidStore *ts) iter->tree_iter.local = local_rt_begin_iterate(ts->tree.local); /* If the TidStore is empty, there is no business */ - if (tidstore_num_tids(ts) == 0) + if (TidStoreNumTids(ts) == 0) iter->finished = true; return iter; @@ -498,7 +500,7 @@ tidstore_iter_kv(TidStoreIter *iter, uint64 *key, uint64 *val) * numbers in each result is also sorted in ascending order. */ TidStoreIterResult * -tidstore_iterate_next(TidStoreIter *iter) +TidStoreIterateNext(TidStoreIter *iter) { uint64 key; uint64 val; @@ -544,7 +546,7 @@ tidstore_iterate_next(TidStoreIter *iter) * or when existing an iteration. */ void -tidstore_end_iterate(TidStoreIter *iter) +TidStoreEndIterate(TidStoreIter *iter) { if (TidStoreIsShared(iter->ts)) shared_rt_end_iterate(iter->tree_iter.shared); @@ -557,7 +559,7 @@ tidstore_end_iterate(TidStoreIter *iter) /* Return the number of tids we collected so far */ int64 -tidstore_num_tids(TidStore *ts) +TidStoreNumTids(TidStore *ts) { uint64 num_tids; @@ -575,16 +577,16 @@ tidstore_num_tids(TidStore *ts) /* Return true if the current memory usage of TidStore exceeds the limit */ bool -tidstore_is_full(TidStore *ts) +TidStoreIsFull(TidStore *ts) { Assert(!TidStoreIsShared(ts) || ts->control->magic == TIDSTORE_MAGIC); - return (tidstore_memory_usage(ts) > ts->control->max_bytes); + return (TidStoreMemoryUsage(ts) > ts->control->max_bytes); } /* Return the maximum memory TidStore can use */ size_t -tidstore_max_memory(TidStore *ts) +TidStoreMaxMemory(TidStore *ts) { Assert(!TidStoreIsShared(ts) || ts->control->magic == TIDSTORE_MAGIC); @@ -593,7 +595,7 @@ tidstore_max_memory(TidStore *ts) /* Return the memory usage of TidStore */ size_t -tidstore_memory_usage(TidStore *ts) +TidStoreMemoryUsage(TidStore *ts) { Assert(!TidStoreIsShared(ts) || ts->control->magic == TIDSTORE_MAGIC); @@ -611,8 +613,8 @@ tidstore_memory_usage(TidStore *ts) /* * Get a handle that can be used by other processes to attach to this TidStore */ -tidstore_handle -tidstore_get_handle(TidStore *ts) +TidStoreHandle +TidStoreGetHandle(TidStore *ts) { Assert(TidStoreIsShared(ts) && ts->control->magic == TIDSTORE_MAGIC); diff --git a/src/backend/access/heap/vacuumlazy.c b/src/backend/access/heap/vacuumlazy.c index 2c72088e69..be487aced6 100644 --- a/src/backend/access/heap/vacuumlazy.c +++ b/src/backend/access/heap/vacuumlazy.c @@ -842,7 +842,7 @@ lazy_scan_heap(LVRelState *vacrel) /* Report that we're scanning the heap, advertising total # of blocks */ initprog_val[0] = PROGRESS_VACUUM_PHASE_SCAN_HEAP; initprog_val[1] = rel_pages; - initprog_val[2] = tidstore_max_memory(vacrel->dead_items); + initprog_val[2] = TidStoreMaxMemory(vacrel->dead_items); pgstat_progress_update_multi_param(3, initprog_index, initprog_val); /* Set up an initial range of skippable blocks using the visibility map */ @@ -909,7 +909,7 @@ lazy_scan_heap(LVRelState *vacrel) * dead_items TIDs, pause and do a cycle of vacuuming before we tackle * this page. */ - if (tidstore_is_full(vacrel->dead_items)) + if (TidStoreIsFull(vacrel->dead_items)) { /* * Before beginning index vacuuming, we release any pin we may @@ -1078,16 +1078,16 @@ lazy_scan_heap(LVRelState *vacrel) * with prunestate-driven visibility map and FSM steps (just like * the two-pass strategy). */ - Assert(tidstore_num_tids(dead_items) == 0); + Assert(TidStoreNumTids(dead_items) == 0); } else if (prunestate.num_offsets > 0) { /* Save details of the LP_DEAD items from the page in dead_items */ - tidstore_add_tids(dead_items, blkno, prunestate.deadoffsets, - prunestate.num_offsets); + TidStoreSetBlockOffsets(dead_items, blkno, prunestate.deadoffsets, + prunestate.num_offsets); pgstat_progress_update_param(PROGRESS_VACUUM_DEAD_TUPLE_BYTES, - tidstore_memory_usage(dead_items)); + TidStoreMemoryUsage(dead_items)); } /* @@ -1258,7 +1258,7 @@ lazy_scan_heap(LVRelState *vacrel) * Do index vacuuming (call each index's ambulkdelete routine), then do * related heap vacuuming */ - if (tidstore_num_tids(dead_items) > 0) + if (TidStoreNumTids(dead_items) > 0) lazy_vacuum(vacrel); /* @@ -2125,10 +2125,10 @@ lazy_scan_noprune(LVRelState *vacrel, */ vacrel->lpdead_item_pages++; - tidstore_add_tids(dead_items, blkno, deadoffsets, lpdead_items); + TidStoreSetBlockOffsets(dead_items, blkno, deadoffsets, lpdead_items); pgstat_progress_update_param(PROGRESS_VACUUM_DEAD_TUPLE_BYTES, - tidstore_memory_usage(dead_items)); + TidStoreMemoryUsage(dead_items)); vacrel->lpdead_items += lpdead_items; @@ -2177,7 +2177,7 @@ lazy_vacuum(LVRelState *vacrel) if (!vacrel->do_index_vacuuming) { Assert(!vacrel->do_index_cleanup); - tidstore_reset(vacrel->dead_items); + TidStoreReset(vacrel->dead_items); return; } @@ -2206,7 +2206,7 @@ lazy_vacuum(LVRelState *vacrel) BlockNumber threshold; Assert(vacrel->num_index_scans == 0); - Assert(vacrel->lpdead_items == tidstore_num_tids(vacrel->dead_items)); + Assert(vacrel->lpdead_items == TidStoreNumTids(vacrel->dead_items)); Assert(vacrel->do_index_vacuuming); Assert(vacrel->do_index_cleanup); @@ -2234,7 +2234,7 @@ lazy_vacuum(LVRelState *vacrel) */ threshold = (double) vacrel->rel_pages * BYPASS_THRESHOLD_PAGES; bypass = (vacrel->lpdead_item_pages < threshold) && - tidstore_memory_usage(vacrel->dead_items) < (32L * 1024L * 1024L); + TidStoreMemoryUsage(vacrel->dead_items) < (32L * 1024L * 1024L); } if (bypass) @@ -2279,7 +2279,7 @@ lazy_vacuum(LVRelState *vacrel) * Forget the LP_DEAD items that we just vacuumed (or just decided to not * vacuum) */ - tidstore_reset(vacrel->dead_items); + TidStoreReset(vacrel->dead_items); } /* @@ -2352,7 +2352,7 @@ lazy_vacuum_all_indexes(LVRelState *vacrel) * place). */ Assert(vacrel->num_index_scans > 0 || - tidstore_num_tids(vacrel->dead_items) == vacrel->lpdead_items); + TidStoreNumTids(vacrel->dead_items) == vacrel->lpdead_items); Assert(allindexes || VacuumFailsafeActive); /* @@ -2407,8 +2407,8 @@ lazy_vacuum_heap_rel(LVRelState *vacrel) VACUUM_ERRCB_PHASE_VACUUM_HEAP, InvalidBlockNumber, InvalidOffsetNumber); - iter = tidstore_begin_iterate(vacrel->dead_items); - while ((result = tidstore_iterate_next(iter)) != NULL) + iter = TidStoreBeginIterate(vacrel->dead_items); + while ((iter_result = TidStoreIterateNext(iter)) != NULL) { BlockNumber blkno; Buffer buf; @@ -2442,7 +2442,7 @@ lazy_vacuum_heap_rel(LVRelState *vacrel) RecordPageWithFreeSpace(vacrel->rel, blkno, freespace); vacuumed_pages++; } - tidstore_end_iterate(iter); + TidStoreEndIterate(iter); vacrel->blkno = InvalidBlockNumber; if (BufferIsValid(vmbuffer)) @@ -2453,12 +2453,12 @@ lazy_vacuum_heap_rel(LVRelState *vacrel) * the second heap pass. No more, no less. */ Assert(vacrel->num_index_scans > 1 || - (tidstore_num_tids(vacrel->dead_items) == vacrel->lpdead_items && + (TidStoreNumTids(vacrel->dead_items) == vacrel->lpdead_items && vacuumed_pages == vacrel->lpdead_item_pages)); ereport(DEBUG2, - (errmsg("table \"%s\": removed " UINT64_FORMAT "dead item identifiers in %u pages", - vacrel->relname, tidstore_num_tids(vacrel->dead_items), + (errmsg("table \"%s\": removed " INT64_FORMAT "dead item identifiers in %u pages", + vacrel->relname, TidStoreNumTids(vacrel->dead_items), vacuumed_pages))); /* Revert to the previous phase information for error traceback */ @@ -3125,8 +3125,8 @@ dead_items_alloc(LVRelState *vacrel, int nworkers) } /* Serial VACUUM case */ - vacrel->dead_items = tidstore_create(vac_work_mem, MaxHeapTuplesPerPage, - NULL); + vacrel->dead_items = TidStoreCreate(vac_work_mem, MaxHeapTuplesPerPage, + NULL); } /* diff --git a/src/backend/commands/vacuum.c b/src/backend/commands/vacuum.c index f3922b72dc..84f71fb14a 100644 --- a/src/backend/commands/vacuum.c +++ b/src/backend/commands/vacuum.c @@ -2486,7 +2486,7 @@ vac_bulkdel_one_index(IndexVacuumInfo *ivinfo, IndexBulkDeleteResult *istat, ereport(ivinfo->message_level, (errmsg("scanned index \"%s\" to remove " UINT64_FORMAT " row versions", RelationGetRelationName(ivinfo->index), - tidstore_num_tids(dead_items)))); + TidStoreNumTids(dead_items)))); return istat; } @@ -2527,5 +2527,5 @@ vac_tid_reaped(ItemPointer itemptr, void *state) { TidStore *dead_items = (TidStore *) state; - return tidstore_lookup_tid(dead_items, itemptr); + return TidStoreIsMember(dead_items, itemptr); } diff --git a/src/backend/commands/vacuumparallel.c b/src/backend/commands/vacuumparallel.c index c363f45e32..be83ceb871 100644 --- a/src/backend/commands/vacuumparallel.c +++ b/src/backend/commands/vacuumparallel.c @@ -110,7 +110,7 @@ typedef struct PVShared pg_atomic_uint32 idx; /* Handle of the shared TidStore */ - tidstore_handle dead_items_handle; + TidStoreHandle dead_items_handle; } PVShared; /* Status used during parallel index vacuum or cleanup */ @@ -372,7 +372,7 @@ parallel_vacuum_init(Relation rel, Relation *indrels, int nindexes, dead_items_dsa = dsa_create_in_place(area_space, dsa_minsize, LWTRANCHE_PARALLEL_VACUUM_DSA, pcxt->seg); - dead_items = tidstore_create(vac_work_mem, max_offset, dead_items_dsa); + dead_items = TidStoreCreate(vac_work_mem, max_offset, dead_items_dsa); pvs->dead_items = dead_items; pvs->dead_items_area = dead_items_dsa; @@ -385,7 +385,7 @@ parallel_vacuum_init(Relation rel, Relation *indrels, int nindexes, (nindexes_mwm > 0) ? maintenance_work_mem / Min(parallel_workers, nindexes_mwm) : maintenance_work_mem; - shared->dead_items_handle = tidstore_get_handle(dead_items); + shared->dead_items_handle = TidStoreGetHandle(dead_items); /* Use the same buffer size for all workers */ shared->ring_nbuffers = GetAccessStrategyBufferCount(bstrategy); @@ -454,7 +454,7 @@ parallel_vacuum_end(ParallelVacuumState *pvs, IndexBulkDeleteResult **istats) istats[i] = NULL; } - tidstore_destroy(pvs->dead_items); + TidStoreDestroy(pvs->dead_items); dsa_detach(pvs->dead_items_area); DestroyParallelContext(pvs->pcxt); @@ -1013,7 +1013,7 @@ parallel_vacuum_main(dsm_segment *seg, shm_toc *toc) /* Set dead items */ area_space = shm_toc_lookup(toc, PARALLEL_VACUUM_KEY_DEAD_ITEMS, false); dead_items_area = dsa_attach_in_place(area_space, seg); - dead_items = tidstore_attach(dead_items_area, shared->dead_items_handle); + dead_items = TidStoreAttach(dead_items_area, shared->dead_items_handle); /* Set cost-based vacuum delay */ VacuumUpdateCosts(); @@ -1061,7 +1061,7 @@ parallel_vacuum_main(dsm_segment *seg, shm_toc *toc) InstrEndParallelQuery(&buffer_usage[ParallelWorkerNumber], &wal_usage[ParallelWorkerNumber]); - tidstore_detach(pvs.dead_items); + TidStoreDetach(dead_items); dsa_detach(dead_items_area); /* Pop the error context stack */ diff --git a/src/include/access/tidstore.h b/src/include/access/tidstore.h index a35a52124a..f0a432d0da 100644 --- a/src/include/access/tidstore.h +++ b/src/include/access/tidstore.h @@ -17,7 +17,7 @@ #include "storage/itemptr.h" #include "utils/dsa.h" -typedef dsa_pointer tidstore_handle; +typedef dsa_pointer TidStoreHandle; typedef struct TidStore TidStore; typedef struct TidStoreIter TidStoreIter; @@ -29,21 +29,21 @@ typedef struct TidStoreIterResult int num_offsets; } TidStoreIterResult; -extern TidStore *tidstore_create(size_t max_bytes, int max_offset, dsa_area *dsa); -extern TidStore *tidstore_attach(dsa_area *dsa, dsa_pointer handle); -extern void tidstore_detach(TidStore *ts); -extern void tidstore_destroy(TidStore *ts); -extern void tidstore_reset(TidStore *ts); -extern void tidstore_add_tids(TidStore *ts, BlockNumber blkno, OffsetNumber *offsets, - int num_offsets); -extern bool tidstore_lookup_tid(TidStore *ts, ItemPointer tid); -extern TidStoreIter * tidstore_begin_iterate(TidStore *ts); -extern TidStoreIterResult *tidstore_iterate_next(TidStoreIter *iter); -extern void tidstore_end_iterate(TidStoreIter *iter); -extern int64 tidstore_num_tids(TidStore *ts); -extern bool tidstore_is_full(TidStore *ts); -extern size_t tidstore_max_memory(TidStore *ts); -extern size_t tidstore_memory_usage(TidStore *ts); -extern tidstore_handle tidstore_get_handle(TidStore *ts); +extern TidStore *TidStoreCreate(size_t max_bytes, int max_off, dsa_area *dsa); +extern TidStore *TidStoreAttach(dsa_area *dsa, dsa_pointer handle); +extern void TidStoreDetach(TidStore *ts); +extern void TidStoreDestroy(TidStore *ts); +extern void TidStoreReset(TidStore *ts); +extern void TidStoreSetBlockOffsets(TidStore *ts, BlockNumber blkno, OffsetNumber *offsets, + int num_offsets); +extern bool TidStoreIsMember(TidStore *ts, ItemPointer tid); +extern TidStoreIter * TidStoreBeginIterate(TidStore *ts); +extern TidStoreIterResult *TidStoreIterateNext(TidStoreIter *iter); +extern void TidStoreEndIterate(TidStoreIter *iter); +extern int64 TidStoreNumTids(TidStore *ts); +extern bool TidStoreIsFull(TidStore *ts); +extern size_t TidStoreMaxMemory(TidStore *ts); +extern size_t TidStoreMemoryUsage(TidStore *ts); +extern TidStoreHandle TidStoreGetHandle(TidStore *ts); #endif /* TIDSTORE_H */ diff --git a/src/test/modules/test_tidstore/test_tidstore.c b/src/test/modules/test_tidstore/test_tidstore.c index 9a1217f833..12d3027624 100644 --- a/src/test/modules/test_tidstore/test_tidstore.c +++ b/src/test/modules/test_tidstore/test_tidstore.c @@ -37,10 +37,10 @@ check_tid(TidStore *ts, BlockNumber blkno, OffsetNumber off, bool expect) ItemPointerSet(&tid, blkno, off); - found = tidstore_lookup_tid(ts, &tid); + found = TidStoreIsMember(ts, &tid); if (found != expect) - elog(ERROR, "lookup TID (%u, %u) returned %d, expected %d", + elog(ERROR, "TidStoreIsMember for TID (%u, %u) returned %d, expected %d", blkno, off, found, expect); } @@ -69,9 +69,9 @@ test_basic(int max_offset) LWLockRegisterTranche(tranche_id, "test_tidstore"); dsa = dsa_create(tranche_id); - ts = tidstore_create(TEST_TIDSTORE_MAX_BYTES, max_offset, dsa); + ts = TidStoreCreate(TEST_TIDSTORE_MAX_BYTES, max_offset, dsa); #else - ts = tidstore_create(TEST_TIDSTORE_MAX_BYTES, max_offset, NULL); + ts = TidStoreCreate(TEST_TIDSTORE_MAX_BYTES, max_offset, NULL); #endif /* prepare the offset array */ @@ -83,7 +83,7 @@ test_basic(int max_offset) /* add tids */ for (int i = 0; i < TEST_TIDSTORE_NUM_BLOCKS; i++) - tidstore_add_tids(ts, blks[i], offs, TEST_TIDSTORE_NUM_OFFSETS); + TidStoreSetBlockOffsets(ts, blks[i], offs, TEST_TIDSTORE_NUM_OFFSETS); /* lookup test */ for (OffsetNumber off = FirstOffsetNumber ; off < max_offset; off++) @@ -105,30 +105,30 @@ test_basic(int max_offset) } /* test the number of tids */ - if (tidstore_num_tids(ts) != (TEST_TIDSTORE_NUM_BLOCKS * TEST_TIDSTORE_NUM_OFFSETS)) - elog(ERROR, "tidstore_num_tids returned " UINT64_FORMAT ", expected %d", - tidstore_num_tids(ts), + if (TidStoreNumTids(ts) != (TEST_TIDSTORE_NUM_BLOCKS * TEST_TIDSTORE_NUM_OFFSETS)) + elog(ERROR, "TidStoreNumTids returned " UINT64_FORMAT ", expected %d", + TidStoreNumTids(ts), TEST_TIDSTORE_NUM_BLOCKS * TEST_TIDSTORE_NUM_OFFSETS); /* iteration test */ - iter = tidstore_begin_iterate(ts); + iter = TidStoreBeginIterate(ts); blk_idx = 0; - while ((iter_result = tidstore_iterate_next(iter)) != NULL) + while ((iter_result = TidStoreIterateNext(iter)) != NULL) { /* check the returned block number */ if (blks_sorted[blk_idx] != iter_result->blkno) - elog(ERROR, "tidstore_iterate_next returned block number %u, expected %u", + elog(ERROR, "TidStoreIterateNext returned block number %u, expected %u", iter_result->blkno, blks_sorted[blk_idx]); /* check the returned offset numbers */ if (TEST_TIDSTORE_NUM_OFFSETS != iter_result->num_offsets) - elog(ERROR, "tidstore_iterate_next returned %u offsets, expected %u", + elog(ERROR, "TidStoreIterateNext %u offsets, expected %u", iter_result->num_offsets, TEST_TIDSTORE_NUM_OFFSETS); for (int i = 0; i < iter_result->num_offsets; i++) { if (offs[i] != iter_result->offsets[i]) - elog(ERROR, "tidstore_iterate_next returned offset number %u on block %u, expected %u", + elog(ERROR, "TidStoreIterateNext offset number %u on block %u, expected %u", iter_result->offsets[i], iter_result->blkno, offs[i]); } @@ -136,15 +136,15 @@ test_basic(int max_offset) } if (blk_idx != TEST_TIDSTORE_NUM_BLOCKS) - elog(ERROR, "tidstore_iterate_next returned %d blocks, expected %d", + elog(ERROR, "TidStoreIterateNext returned %d blocks, expected %d", blk_idx, TEST_TIDSTORE_NUM_BLOCKS); /* remove all tids */ - tidstore_reset(ts); + TidStoreReset(ts); /* test the number of tids */ - if (tidstore_num_tids(ts) != 0) - elog(ERROR, "tidstore_num_tids on empty store returned non-zero"); + if (TidStoreNumTids(ts) != 0) + elog(ERROR, "TidStoreNumTids on empty store returned non-zero"); /* lookup test for empty store */ for (OffsetNumber off = FirstOffsetNumber ; off < MaxHeapTuplesPerPage; @@ -156,7 +156,7 @@ test_basic(int max_offset) check_tid(ts, MaxBlockNumber, off, false); } - tidstore_destroy(ts); + TidStoreDestroy(ts); #ifdef TEST_SHARED_TIDSTORE dsa_detach(dsa); @@ -177,36 +177,37 @@ test_empty(void) LWLockRegisterTranche(tranche_id, "test_tidstore"); dsa = dsa_create(tranche_id); - ts = tidstore_create(TEST_TIDSTORE_MAX_BYTES, MaxHeapTuplesPerPage, dsa); + ts = TidStoreCreate(TEST_TIDSTORE_MAX_BYTES, MaxHeapTuplesPerPage, dsa); #else - ts = tidstore_create(TEST_TIDSTORE_MAX_BYTES, MaxHeapTuplesPerPage, NULL); + ts = TidStoreCreate(TEST_TIDSTORE_MAX_BYTES, MaxHeapTuplesPerPage, NULL); #endif elog(NOTICE, "testing empty tidstore"); ItemPointerSet(&tid, 0, FirstOffsetNumber); - if (tidstore_lookup_tid(ts, &tid)) - elog(ERROR, "tidstore_lookup_tid for (0,1) on empty store returned true"); + if (TidStoreIsMember(ts, &tid)) + elog(ERROR, "TidStoreIsMember for TID (%u,%u) on empty store returned true", + 0, FirstOffsetNumber); ItemPointerSet(&tid, MaxBlockNumber, MaxOffsetNumber); - if (tidstore_lookup_tid(ts, &tid)) - elog(ERROR, "tidstore_lookup_tid for (%u,%u) on empty store returned true", + if (TidStoreIsMember(ts, &tid)) + elog(ERROR, "TidStoreIsMember for TID (%u,%u) on empty store returned true", MaxBlockNumber, MaxOffsetNumber); - if (tidstore_num_tids(ts) != 0) - elog(ERROR, "tidstore_num_entries on empty store returned non-zero"); + if (TidStoreNumTids(ts) != 0) + elog(ERROR, "TidStoreNumTids on empty store returned non-zero"); - if (tidstore_is_full(ts)) - elog(ERROR, "tidstore_is_full on empty store returned true"); + if (TidStoreIsFull(ts)) + elog(ERROR, "TidStoreIsFull on empty store returned true"); - iter = tidstore_begin_iterate(ts); + iter = TidStoreBeginIterate(ts); - if (tidstore_iterate_next(iter) != NULL) - elog(ERROR, "tidstore_iterate_next on empty store returned TIDs"); + if (TidStoreIterateNext(iter) != NULL) + elog(ERROR, "TidStoreIterateNext on empty store returned TIDs"); - tidstore_end_iterate(iter); + TidStoreEndIterate(iter); - tidstore_destroy(ts); + TidStoreDestroy(ts); #ifdef TEST_SHARED_TIDSTORE dsa_detach(dsa); -- 2.31.1