atomic and atomic_ref

Introduction and motivation

This paper proposes marking most of atomic<T> methods and associated functions constexpr to allow usage of atomic code without changes in a constexpr and consteval code.

Proposed changes will allow implementing other types (std::shared_ptr<T>, persistent data structures with atomic pointers) and algorithms (thread safe data-processing, like scanning data with atomic counter) with just sprinkling constexpr to their specification.

Changes

• R2 → R3: Added location of library feature test macro, removed atomic<shared_ptr> and atomic<weak_ptr>.
• R1 → R2: Added clarification for behaviour of wait and notify functions.
• R0 → R1: Make wait and notify functions as requested by SG1. Wording changed accordingly. Updaded link to implementation on Compiler Explorer.

Previous polls

Intention for wording changes

Mark all functions in [atomics] constexpr excluding all volatile overloads. As all these can be implemented in constant expression evaluator or using if consteval:

template<class T>
constexpr T atomic_fetch_add(atomic<T>* target, typename atomic<T>::difference_type diff) noexcept {
	if consteval {
		const auto previous = target->value;
		target->value += diff;
		return previous;
	} else {
		return __c11_atomic_fetch_add(&target->value, diff);
	}
}

Synchronization functions and helpers can be implemented as no-ops (std::kill_dependency, std::atomic_thread_fence). Memory order parameters should be just ignored as constant evaluated code doesn't have multiple threads.

Alternative implementation strategy is to allow atomic builtins to work in constant evaluator.

wait and notify behaviour

Wait and notify operations should work during constant evaluation as expected in a single-threaded environment. Notify will be noop and wait-ing for a different value will be a deadlock which should result in constant evaluation failure according to [expr.const#5.7] an expression that would exceed the implementation-defined limits as every check for the value is considered [intro.progress#4] continous executing of execution steps while waiting for the condition.

constexpr bool process_first_unprocessed(std::atomic<size_t> & counter, std::span<cell> subject) {
	// BEFORE: compile-time error when you try to evaluate this inside constant evaluated code
	// AFTER: work sequentialy in constant-evaluated code
	const size_t current = counter.fetch_add(1); 
	
	if (current >= subject.size()) {
		return false;
	}
	
	process(subject[current]);
	return true;
}

constexpr void process_all(std::span<cell> subject, unsigned thread_count = 1) {
	// BEFORE: calling following function in constant evaluated code will always fail with any number of requested threads
	// AFTER: calling it with argument thread_count == 1 will succeed in constant evaluated code
	std::atomic<size_t> counter{0};
	auto threads = std::vector<std::jthread>{};
	
	assert(thread_count >= 1);
	
	for (unsigned i = 1; i < thread_count; ++i) {
		threads.emplace_back([&]{
			while (process_first_unprocessed(counter, subject));
		});
	}
	
	while (process_first_unprocessed(counter, subject));
}