From ba3395f8a09a3ae3919f3f811296b05b2cddd17c Mon Sep 17 00:00:00 2001 From: Heikki Linnakangas Date: Mon, 6 Jul 2026 01:10:45 +0300 Subject: [PATCH 1/1] Replace pg_atomic_flag with pg_atomic_bool The pg_atomic_flag operations were different from those that we support with pg_atomic_u32/u64. I've learned the u32/u64 functions by now, but whenever I deal with pg_atomic_flag, I need to read the docs to remind myself what the pg_atomic_flag functions do. However, what I really just want is to have a "bool" with an atomic-exchange operation. The pg_atomic_flag operations were slightly different and unintuitive to me at least: - pg_atomic_unlocked_test_flag() returned false, if the flag was set and true if it was not set. That felt backwards if you thought of it as just reading the underlying boolean value. - Similarly, pg_atomic_test_set_flag() returned true if it was not previously set, which was different from what pg_atomic_exchange() returns. (None of the callers of pg_atomic_test_set_flag() actually looked at the return value, however. They all just wanted to set the flag, but there was no pg_atomic_set_flag() function!) - There was no atomic "test and clear" operation - There were differences in the barrier semantics compared to the pg_atomic_u32 variants. We don't expose "acquire" or "release" semantics anywhere else (outside arch-specific headers), we use the terms "read" and "write" barriers instead, and it wasn't quite clear if they're the same thing. Replace the pg_atomic_flag type and functions with pg_atomic_bool, which has functions with same names and semantics as pg_atomic_u32. Remove the x86-specific implementation, and rely on the fallback that defines pg_atomic_bool as a wrapper around pg_atomic_u32 on all platforms. --- contrib/pg_stash_advice/pg_stash_advice.c | 8 +- contrib/pg_stash_advice/pg_stash_advice.h | 2 +- contrib/pg_stash_advice/stashfuncs.c | 4 +- contrib/pg_stash_advice/stashpersist.c | 4 +- src/backend/postmaster/autovacuum.c | 24 ++-- src/include/port/atomics.h | 108 ++++++++-------- src/include/port/atomics/arch-x86.h | 33 ----- src/include/port/atomics/generic-gcc.h | 67 ---------- src/include/port/atomics/generic.h | 150 ++++++++++------------ src/test/regress/regress.c | 34 +++-- src/tools/pgindent/typedefs.list | 2 +- 11 files changed, 164 insertions(+), 272 deletions(-) diff --git a/contrib/pg_stash_advice/pg_stash_advice.c b/contrib/pg_stash_advice/pg_stash_advice.c index 1858c6a135a..6dbb3f57b6b 100644 --- a/contrib/pg_stash_advice/pg_stash_advice.c +++ b/contrib/pg_stash_advice/pg_stash_advice.c @@ -167,7 +167,7 @@ pgsa_advisor(PlannerGlobal *glob, Query *parse, pgsa_attach(); /* If stash data is still being restored from disk, ignore. */ - if (pg_atomic_unlocked_test_flag(&pgsa_state->stashes_ready)) + if (!pg_atomic_read_bool(&pgsa_state->stashes_ready)) return NULL; /* @@ -324,7 +324,7 @@ pgsa_attach(void) void pgsa_check_lockout(void) { - if (pg_atomic_unlocked_test_flag(&pgsa_state->stashes_ready)) + if (!pg_atomic_read_bool(&pgsa_state->stashes_ready)) ereport(ERROR, (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE), errmsg("stash modifications are not allowed because \"%s\" has not been loaded yet", @@ -579,7 +579,7 @@ pgsa_init_shared_state(void *ptr, void *arg) state->stash_hash = DSHASH_HANDLE_INVALID; state->entry_hash = DSHASH_HANDLE_INVALID; state->bgworker_pid = InvalidPid; - pg_atomic_init_flag(&state->stashes_ready); + pg_atomic_init_bool(&state->stashes_ready, false); pg_atomic_init_u64(&state->change_count, 0); /* @@ -594,7 +594,7 @@ pgsa_init_shared_state(void *ptr, void *arg) * which leads to the correct behavior. */ if (!pg_stash_advice_persist) - pg_atomic_test_set_flag(&state->stashes_ready); + pg_atomic_write_bool(&state->stashes_ready, true); } /* diff --git a/contrib/pg_stash_advice/pg_stash_advice.h b/contrib/pg_stash_advice/pg_stash_advice.h index 01aded472f3..e15e09582f8 100644 --- a/contrib/pg_stash_advice/pg_stash_advice.h +++ b/contrib/pg_stash_advice/pg_stash_advice.h @@ -65,7 +65,7 @@ typedef struct pgsa_shared_state dshash_table_handle stash_hash; dshash_table_handle entry_hash; pid_t bgworker_pid; - pg_atomic_flag stashes_ready; + pg_atomic_bool stashes_ready; pg_atomic_uint64 change_count; } pgsa_shared_state; diff --git a/contrib/pg_stash_advice/stashfuncs.c b/contrib/pg_stash_advice/stashfuncs.c index a70df60579b..2af369e4bc8 100644 --- a/contrib/pg_stash_advice/stashfuncs.c +++ b/contrib/pg_stash_advice/stashfuncs.c @@ -99,7 +99,7 @@ pg_get_advice_stashes(PG_FUNCTION_ARGS) pgsa_attach(); /* If stash data is still being restored from disk, ignore. */ - if (pg_atomic_unlocked_test_flag(&pgsa_state->stashes_ready)) + if (!pg_atomic_read_bool(&pgsa_state->stashes_ready)) return (Datum) 0; /* Tally up the number of entries per stash. */ @@ -163,7 +163,7 @@ pg_get_advice_stash_contents(PG_FUNCTION_ARGS) pgsa_attach(); /* If stash data is still being restored from disk, ignore. */ - if (pg_atomic_unlocked_test_flag(&pgsa_state->stashes_ready)) + if (!pg_atomic_read_bool(&pgsa_state->stashes_ready)) return (Datum) 0; /* User can pass NULL for all stashes, or the name of a specific stash. */ diff --git a/contrib/pg_stash_advice/stashpersist.c b/contrib/pg_stash_advice/stashpersist.c index 5bdf4bddaae..c9d7887cb75 100644 --- a/contrib/pg_stash_advice/stashpersist.c +++ b/contrib/pg_stash_advice/stashpersist.c @@ -141,10 +141,10 @@ pg_stash_advice_worker_main(Datum main_arg) * process_shared_preload_libraries() and the data has not yet been * successfully loaded, load it now. */ - if (pg_atomic_unlocked_test_flag(&pgsa_state->stashes_ready)) + if (!pg_atomic_read_bool(&pgsa_state->stashes_ready)) { pgsa_read_from_disk(); - pg_atomic_test_set_flag(&pgsa_state->stashes_ready); + pg_atomic_write_bool(&pgsa_state->stashes_ready, true); } /* Note the current change count so we can detect future changes. */ diff --git a/src/backend/postmaster/autovacuum.c b/src/backend/postmaster/autovacuum.c index 127bd9e7da3..287936efbf8 100644 --- a/src/backend/postmaster/autovacuum.c +++ b/src/backend/postmaster/autovacuum.c @@ -244,7 +244,7 @@ typedef struct WorkerInfoData Oid wi_tableoid; PGPROC *wi_proc; TimestampTz wi_launchtime; - pg_atomic_flag wi_dobalance; + pg_atomic_bool wi_dobalance; bool wi_sharedrel; } WorkerInfoData; @@ -1657,7 +1657,7 @@ FreeWorkerInfo(int code, Datum arg) MyWorkerInfo->wi_sharedrel = false; MyWorkerInfo->wi_proc = NULL; MyWorkerInfo->wi_launchtime = 0; - pg_atomic_clear_flag(&MyWorkerInfo->wi_dobalance); + pg_atomic_write_bool(&MyWorkerInfo->wi_dobalance, false); dclist_push_head(&AutoVacuumShmem->av_freeWorkers, &MyWorkerInfo->wi_links); /* not mine anymore */ @@ -1732,7 +1732,7 @@ VacuumUpdateCosts(void) elog(DEBUG2, "Autovacuum VacuumUpdateCosts(db=%u, rel=%u, dobalance=%s, cost_limit=%d, cost_delay=%g active=%s failsafe=%s)", - dboid, tableoid, pg_atomic_unlocked_test_flag(&MyWorkerInfo->wi_dobalance) ? "no" : "yes", + dboid, tableoid, pg_atomic_read_bool(&MyWorkerInfo->wi_dobalance) ? "yes" : "no", vacuum_cost_limit, vacuum_cost_delay, vacuum_cost_delay > 0 ? "yes" : "no", VacuumFailsafeActive ? "yes" : "no"); @@ -1770,7 +1770,7 @@ AutoVacuumUpdateCostLimit(void) vacuum_cost_limit = VacuumCostLimit; /* Only balance limit if no cost-related storage parameters specified */ - if (pg_atomic_unlocked_test_flag(&MyWorkerInfo->wi_dobalance)) + if (!pg_atomic_read_bool(&MyWorkerInfo->wi_dobalance)) return; Assert(vacuum_cost_limit > 0); @@ -1810,7 +1810,7 @@ autovac_recalculate_workers_for_balance(void) WorkerInfo worker = dlist_container(WorkerInfoData, wi_links, iter.cur); if (worker->wi_proc == NULL || - pg_atomic_unlocked_test_flag(&worker->wi_dobalance)) + !pg_atomic_read_bool(&worker->wi_dobalance)) continue; nworkers_for_balance++; @@ -2465,14 +2465,8 @@ do_autovacuum(void) av_storage_param_cost_delay = tab->at_storage_param_vac_cost_delay; av_storage_param_cost_limit = tab->at_storage_param_vac_cost_limit; - /* - * We only expect this worker to ever set the flag, so don't bother - * checking the return value. We shouldn't have to retry. - */ - if (tab->at_dobalance) - pg_atomic_test_set_flag(&MyWorkerInfo->wi_dobalance); - else - pg_atomic_clear_flag(&MyWorkerInfo->wi_dobalance); + /* We only expect this worker to write the flag */ + pg_atomic_write_bool(&MyWorkerInfo->wi_dobalance, tab->at_dobalance); LWLockAcquire(AutovacuumLock, LW_SHARED); autovac_recalculate_workers_for_balance(); @@ -2578,7 +2572,7 @@ deleted: MyWorkerInfo->wi_tableoid = InvalidOid; MyWorkerInfo->wi_sharedrel = false; LWLockRelease(AutovacuumScheduleLock); - pg_atomic_test_set_flag(&MyWorkerInfo->wi_dobalance); + pg_atomic_write_bool(&MyWorkerInfo->wi_dobalance, true); } list_free_deep(tables_to_process); @@ -3574,7 +3568,7 @@ AutoVacuumShmemInit(void *arg) { dclist_push_head(&AutoVacuumShmem->av_freeWorkers, &worker[i].wi_links); - pg_atomic_init_flag(&worker[i].wi_dobalance); + pg_atomic_init_bool(&worker[i].wi_dobalance, false); } pg_atomic_init_u32(&AutoVacuumShmem->av_nworkersForBalance, 0); diff --git a/src/include/port/atomics.h b/src/include/port/atomics.h index a605ea81d07..bd75d00a558 100644 --- a/src/include/port/atomics.h +++ b/src/include/port/atomics.h @@ -11,7 +11,6 @@ * implementations for the following operations should be provided: * * pg_compiler_barrier(), pg_write_barrier(), pg_read_barrier() * * pg_atomic_compare_exchange_u32(), pg_atomic_fetch_add_u32() - * * pg_atomic_test_set_flag(), pg_atomic_init_flag(), pg_atomic_clear_flag() * * PG_HAVE_8BYTE_SINGLE_COPY_ATOMICITY should be defined if appropriate. * * There exist generic, hardware independent, implementations for several @@ -154,55 +153,6 @@ #define pg_read_barrier() pg_read_barrier_impl() #define pg_write_barrier() pg_write_barrier_impl() -/* - * pg_atomic_init_flag - initialize atomic flag. - * - * No barrier semantics. - */ -static inline void -pg_atomic_init_flag(volatile pg_atomic_flag *ptr) -{ - pg_atomic_init_flag_impl(ptr); -} - -/* - * pg_atomic_test_set_flag - TAS() - * - * Returns true if the flag has successfully been set, false otherwise. - * - * Acquire (including read barrier) semantics. - */ -static inline bool -pg_atomic_test_set_flag(volatile pg_atomic_flag *ptr) -{ - return pg_atomic_test_set_flag_impl(ptr); -} - -/* - * pg_atomic_unlocked_test_flag - Check if the lock is free - * - * Returns true if the flag currently is not set, false otherwise. - * - * No barrier semantics. - */ -static inline bool -pg_atomic_unlocked_test_flag(volatile pg_atomic_flag *ptr) -{ - return pg_atomic_unlocked_test_flag_impl(ptr); -} - -/* - * pg_atomic_clear_flag - release lock set by TAS() - * - * Release (including write barrier) semantics. - */ -static inline void -pg_atomic_clear_flag(volatile pg_atomic_flag *ptr) -{ - pg_atomic_clear_flag_impl(ptr); -} - - /* * pg_atomic_init_u32 - initialize atomic variable * @@ -611,6 +561,64 @@ pg_atomic_monotonic_advance_u64(volatile pg_atomic_uint64 *ptr, uint64 target) return currval; } +/* ---- + * The 'bool' operations have the same semantics as the u32 counterparts + * if they are available. Check the corresponding u32 function for + * documentation. + * + * Note: pg_atomic_bool is currently identical to pg_atomic_u32 on all + * platforms, but it's notationally nice to have a distinct type. + * ---- + */ + +static inline void +pg_atomic_init_bool(volatile pg_atomic_bool *ptr, bool val) +{ + pg_atomic_init_bool_impl(ptr, val); +} + +static inline bool +pg_atomic_read_bool(volatile pg_atomic_bool *ptr) +{ + return pg_atomic_read_bool_impl(ptr); +} + +static inline bool +pg_atomic_read_membarrier_bool(volatile pg_atomic_bool *ptr) +{ + return pg_atomic_read_membarrier_bool_impl(ptr); +} + +static inline void +pg_atomic_write_bool(volatile pg_atomic_bool *ptr, bool val) +{ + pg_atomic_write_bool_impl(ptr, val); +} + +static inline void +pg_atomic_unlocked_write_bool(volatile pg_atomic_bool *ptr, bool val) +{ + pg_atomic_unlocked_write_bool_impl(ptr, val); +} + +static inline void +pg_atomic_write_membarrier_bool(volatile pg_atomic_bool *ptr, bool val) +{ + pg_atomic_write_membarrier_bool_impl(ptr, val); +} + +static inline bool +pg_atomic_exchange_bool(volatile pg_atomic_bool *ptr, bool newval) +{ + return pg_atomic_exchange_bool_impl(ptr, newval); +} + +/* + * Note: There is no pg_atomic_compare_exchange_bool(). Because a boolean has + * only two possible values, it would be no different from + * pg_atomic_exchange_bool(). + */ + #undef INSIDE_ATOMICS_H #endif /* ATOMICS_H */ diff --git a/src/include/port/atomics/arch-x86.h b/src/include/port/atomics/arch-x86.h index 231831dcf59..05d2a2ce7f9 100644 --- a/src/include/port/atomics/arch-x86.h +++ b/src/include/port/atomics/arch-x86.h @@ -51,12 +51,6 @@ */ #if defined(__GNUC__) || defined(__INTEL_COMPILER) -#define PG_HAVE_ATOMIC_FLAG_SUPPORT -typedef struct pg_atomic_flag -{ - volatile char value; -} pg_atomic_flag; - #define PG_HAVE_ATOMIC_U32_SUPPORT typedef struct pg_atomic_uint32 { @@ -76,33 +70,6 @@ typedef struct pg_atomic_uint64 } pg_atomic_uint64; #endif /* __x86_64__ */ -#define PG_HAVE_ATOMIC_TEST_SET_FLAG -static inline bool -pg_atomic_test_set_flag_impl(volatile pg_atomic_flag *ptr) -{ - char _res = 1; - - __asm__ __volatile__( - " lock \n" - " xchgb %0,%1 \n" -: "+q"(_res), "+m"(ptr->value) -: -: "memory"); - return _res == 0; -} - -#define PG_HAVE_ATOMIC_CLEAR_FLAG -static inline void -pg_atomic_clear_flag_impl(volatile pg_atomic_flag *ptr) -{ - /* - * On a TSO architecture like x86 it's sufficient to use a compiler - * barrier to achieve release semantics. - */ - __asm__ __volatile__("" ::: "memory"); - ptr->value = 0; -} - #define PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32 static inline bool pg_atomic_compare_exchange_u32_impl(volatile pg_atomic_uint32 *ptr, diff --git a/src/include/port/atomics/generic-gcc.h b/src/include/port/atomics/generic-gcc.h index 5bfce82f687..9be820f72b1 100644 --- a/src/include/port/atomics/generic-gcc.h +++ b/src/include/port/atomics/generic-gcc.h @@ -61,27 +61,6 @@ #endif -/* generic gcc based atomic flag implementation */ -#if !defined(PG_HAVE_ATOMIC_FLAG_SUPPORT) \ - && (defined(HAVE_GCC__SYNC_INT32_TAS) || defined(HAVE_GCC__SYNC_CHAR_TAS)) - -#define PG_HAVE_ATOMIC_FLAG_SUPPORT -typedef struct pg_atomic_flag -{ - /* - * If we have a choice, use int-width TAS, because that is more efficient - * and/or more reliably implemented on most non-Intel platforms. (Note - * that this code isn't used on x86[_64]; see arch-x86.h for that.) - */ -#ifdef HAVE_GCC__SYNC_INT32_TAS - volatile int value; -#else - volatile char value; -#endif -} pg_atomic_flag; - -#endif /* !ATOMIC_FLAG_SUPPORT && SYNC_INT32_TAS */ - /* generic gcc based atomic uint32 implementation */ #if !defined(PG_HAVE_ATOMIC_U32_SUPPORT) \ && (defined(HAVE_GCC__ATOMIC_INT32_CAS) || defined(HAVE_GCC__SYNC_INT32_CAS)) @@ -107,52 +86,6 @@ typedef struct pg_atomic_uint64 #endif /* defined(HAVE_GCC__ATOMIC_INT64_CAS) || defined(HAVE_GCC__SYNC_INT64_CAS) */ -#ifdef PG_HAVE_ATOMIC_FLAG_SUPPORT - -#if defined(HAVE_GCC__SYNC_CHAR_TAS) || defined(HAVE_GCC__SYNC_INT32_TAS) - -#ifndef PG_HAVE_ATOMIC_TEST_SET_FLAG -#define PG_HAVE_ATOMIC_TEST_SET_FLAG -static inline bool -pg_atomic_test_set_flag_impl(volatile pg_atomic_flag *ptr) -{ - /* NB: only an acquire barrier, not a full one */ - /* some platform only support a 1 here */ - return __sync_lock_test_and_set(&ptr->value, 1) == 0; -} -#endif - -#endif /* defined(HAVE_GCC__SYNC_*_TAS) */ - -#ifndef PG_HAVE_ATOMIC_UNLOCKED_TEST_FLAG -#define PG_HAVE_ATOMIC_UNLOCKED_TEST_FLAG -static inline bool -pg_atomic_unlocked_test_flag_impl(volatile pg_atomic_flag *ptr) -{ - return ptr->value == 0; -} -#endif - -#ifndef PG_HAVE_ATOMIC_CLEAR_FLAG -#define PG_HAVE_ATOMIC_CLEAR_FLAG -static inline void -pg_atomic_clear_flag_impl(volatile pg_atomic_flag *ptr) -{ - __sync_lock_release(&ptr->value); -} -#endif - -#ifndef PG_HAVE_ATOMIC_INIT_FLAG -#define PG_HAVE_ATOMIC_INIT_FLAG -static inline void -pg_atomic_init_flag_impl(volatile pg_atomic_flag *ptr) -{ - pg_atomic_clear_flag_impl(ptr); -} -#endif - -#endif /* defined(PG_HAVE_ATOMIC_FLAG_SUPPORT) */ - /* prefer __atomic, it has a better API */ #if !defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32) && defined(HAVE_GCC__ATOMIC_INT32_CAS) #define PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32 diff --git a/src/include/port/atomics/generic.h b/src/include/port/atomics/generic.h index daa772e9a6d..c5a130c76a2 100644 --- a/src/include/port/atomics/generic.h +++ b/src/include/port/atomics/generic.h @@ -28,12 +28,6 @@ # define pg_write_barrier_impl pg_memory_barrier_impl #endif -/* provide fallback */ -#if !defined(PG_HAVE_ATOMIC_FLAG_SUPPORT) && defined(PG_HAVE_ATOMIC_U32_SUPPORT) -#define PG_HAVE_ATOMIC_FLAG_SUPPORT -typedef pg_atomic_uint32 pg_atomic_flag; -#endif - #ifndef PG_HAVE_ATOMIC_READ_U32 #define PG_HAVE_ATOMIC_READ_U32 static inline uint32 @@ -61,84 +55,6 @@ pg_atomic_unlocked_write_u32_impl(volatile pg_atomic_uint32 *ptr, uint32 val) } #endif -/* - * provide fallback for test_and_set using atomic_exchange if available - */ -#if !defined(PG_HAVE_ATOMIC_TEST_SET_FLAG) && defined(PG_HAVE_ATOMIC_EXCHANGE_U32) - -#define PG_HAVE_ATOMIC_INIT_FLAG -static inline void -pg_atomic_init_flag_impl(volatile pg_atomic_flag *ptr) -{ - pg_atomic_write_u32_impl(ptr, 0); -} - -#define PG_HAVE_ATOMIC_TEST_SET_FLAG -static inline bool -pg_atomic_test_set_flag_impl(volatile pg_atomic_flag *ptr) -{ - return pg_atomic_exchange_u32_impl(ptr, 1) == 0; -} - -#define PG_HAVE_ATOMIC_UNLOCKED_TEST_FLAG -static inline bool -pg_atomic_unlocked_test_flag_impl(volatile pg_atomic_flag *ptr) -{ - return pg_atomic_read_u32_impl(ptr) == 0; -} - - -#define PG_HAVE_ATOMIC_CLEAR_FLAG -static inline void -pg_atomic_clear_flag_impl(volatile pg_atomic_flag *ptr) -{ - /* XXX: release semantics suffice? */ - pg_memory_barrier_impl(); - pg_atomic_write_u32_impl(ptr, 0); -} - -/* - * provide fallback for test_and_set using atomic_compare_exchange if - * available. - */ -#elif !defined(PG_HAVE_ATOMIC_TEST_SET_FLAG) && defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32) - -#define PG_HAVE_ATOMIC_INIT_FLAG -static inline void -pg_atomic_init_flag_impl(volatile pg_atomic_flag *ptr) -{ - pg_atomic_write_u32_impl(ptr, 0); -} - -#define PG_HAVE_ATOMIC_TEST_SET_FLAG -static inline bool -pg_atomic_test_set_flag_impl(volatile pg_atomic_flag *ptr) -{ - uint32 value = 0; - return pg_atomic_compare_exchange_u32_impl(ptr, &value, 1); -} - -#define PG_HAVE_ATOMIC_UNLOCKED_TEST_FLAG -static inline bool -pg_atomic_unlocked_test_flag_impl(volatile pg_atomic_flag *ptr) -{ - return pg_atomic_read_u32_impl(ptr) == 0; -} - -#define PG_HAVE_ATOMIC_CLEAR_FLAG -static inline void -pg_atomic_clear_flag_impl(volatile pg_atomic_flag *ptr) -{ - /* XXX: release semantics suffice? */ - pg_memory_barrier_impl(); - pg_atomic_write_u32_impl(ptr, 0); -} - -#elif !defined(PG_HAVE_ATOMIC_TEST_SET_FLAG) -# error "No pg_atomic_test_and_set provided" -#endif /* !defined(PG_HAVE_ATOMIC_TEST_SET_FLAG) */ - - #ifndef PG_HAVE_ATOMIC_INIT_U32 #define PG_HAVE_ATOMIC_INIT_U32 static inline void @@ -427,4 +343,70 @@ pg_atomic_write_membarrier_u64_impl(volatile pg_atomic_uint64 *ptr, uint64 val) { (void) pg_atomic_exchange_u64_impl(ptr, val); } + + +/* implement pg_atomic_bool over pg_atomic_u32 */ +#if !defined(PG_HAVE_ATOMIC_BOOL_SUPPORT) && defined(PG_HAVE_ATOMIC_U32_SUPPORT) +#define PG_HAVE_ATOMIC_BOOL_SUPPORT +typedef pg_atomic_uint32 pg_atomic_bool; +#endif + +#if !defined(PG_HAVE_ATOMIC_INIT_BOOL) && defined(PG_HAVE_ATOMIC_INIT_U32) +static inline void +pg_atomic_init_bool_impl(volatile pg_atomic_bool *ptr, bool val) +{ + pg_atomic_init_u32_impl(ptr, (uint32) val); +} +#endif + +#if !defined(PG_HAVE_ATOMIC_READ_BOOL) && defined(PG_HAVE_ATOMIC_READ_U32) +static inline bool +pg_atomic_read_bool_impl(volatile pg_atomic_bool *ptr) +{ + return (bool) pg_atomic_read_u32_impl(ptr); +} +#endif + +#if !defined(PG_HAVE_ATOMIC_READ_MEMBARRIER_BOOL) && defined(PG_HAVE_ATOMIC_READ_MEMBARRIER_U32) +static inline bool +pg_atomic_read_membarrier_bool_impl(volatile pg_atomic_bool *ptr) +{ + return (bool) pg_atomic_read_membarrier_u32_impl(ptr); +} +#endif + +#if !defined(PG_HAVE_ATOMIC_WRITE_BOOL) && defined(PG_HAVE_ATOMIC_WRITE_U32) +static inline void +pg_atomic_write_bool_impl(volatile pg_atomic_bool *ptr, bool val) +{ + pg_atomic_write_u32_impl(ptr, (uint32) val); +} +#endif + +#if !defined(PG_HAVE_ATOMIC_UNLOCKED_WRITE_BOOL) && defined(PG_HAVE_ATOMIC_UNLOCKED_WRITE_U32) +static inline void +pg_atomic_unlocked_write_bool_impl(volatile pg_atomic_bool *ptr, bool val) +{ + pg_atomic_unlocked_write_u32_impl(ptr, (uint32) val); +} +#endif + +#if !defined(PG_HAVE_ATOMIC_WRITE_MEMBARRIER_BOOL) && defined(PG_HAVE_ATOMIC_WRITE_MEMBARRIER_U32) +static inline void +pg_atomic_write_membarrier_bool_impl(volatile pg_atomic_bool *ptr, bool val) +{ + pg_atomic_write_membarrier_u32_impl(ptr, (uint32) val); +} +#endif + +#if !defined(PG_HAVE_ATOMIC_EXCHANGE_BOOL) && defined(PG_HAVE_ATOMIC_EXCHANGE_U32) +static inline bool +pg_atomic_exchange_bool_impl(volatile pg_atomic_bool *ptr, bool newval) +{ + return (bool) pg_atomic_exchange_u32_impl(ptr, (uint32) newval); +} +#endif + + + #endif diff --git a/src/test/regress/regress.c b/src/test/regress/regress.c index d5aafdf370c..7287197a1b6 100644 --- a/src/test/regress/regress.c +++ b/src/test/regress/regress.c @@ -63,6 +63,14 @@ #expr, __FILE__, __LINE__); \ } while (0) +#define EXPECT_FALSE(expr) \ + do { \ + if ((expr)) \ + elog(ERROR, \ + "%s was unexpectedly true in file \"%s\" line %u", \ + #expr, __FILE__, __LINE__); \ + } while (0) + #define EXPECT_EQ_U32(result_expr, expected_expr) \ do { \ uint32 actual_result = (result_expr); \ @@ -503,19 +511,19 @@ wait_pid(PG_FUNCTION_ARGS) } static void -test_atomic_flag(void) +test_atomic_bool(void) { - pg_atomic_flag flag; - - pg_atomic_init_flag(&flag); - EXPECT_TRUE(pg_atomic_unlocked_test_flag(&flag)); - EXPECT_TRUE(pg_atomic_test_set_flag(&flag)); - EXPECT_TRUE(!pg_atomic_unlocked_test_flag(&flag)); - EXPECT_TRUE(!pg_atomic_test_set_flag(&flag)); - pg_atomic_clear_flag(&flag); - EXPECT_TRUE(pg_atomic_unlocked_test_flag(&flag)); - EXPECT_TRUE(pg_atomic_test_set_flag(&flag)); - pg_atomic_clear_flag(&flag); + pg_atomic_bool flag; + + pg_atomic_init_bool(&flag, false); + EXPECT_FALSE(pg_atomic_read_bool(&flag)); + pg_atomic_write_bool(&flag, true); + EXPECT_TRUE(pg_atomic_read_bool(&flag)); + + EXPECT_TRUE(pg_atomic_exchange_bool(&flag, true)); + EXPECT_TRUE(pg_atomic_exchange_bool(&flag, false)); + EXPECT_FALSE(pg_atomic_exchange_bool(&flag, false)); + EXPECT_FALSE(pg_atomic_exchange_bool(&flag, true)); } static void @@ -710,7 +718,7 @@ PG_FUNCTION_INFO_V1(test_atomic_ops); Datum test_atomic_ops(PG_FUNCTION_ARGS) { - test_atomic_flag(); + test_atomic_bool(); test_atomic_uint32(); diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list index 117e7379f10..4d5f9bbb5cd 100644 --- a/src/tools/pgindent/typedefs.list +++ b/src/tools/pgindent/typedefs.list @@ -4020,7 +4020,7 @@ pe_test_vector pendingPosition pending_label pgParameterStatus -pg_atomic_flag +pg_atomic_bool pg_atomic_uint32 pg_atomic_uint64 pg_be_sasl_mech -- 2.47.3