constexpr atomic<T> and atomic_ref<T>

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.

Intention for wording changes

Mark all functions in [atomics] constexpr excluding all volatile overloads and all wait and notify functions. As all these can be implemented 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 {
		__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.

Question for SG1

• Should we make is_lock_free functions also constexpr? (paper's wording contains this change)

Question for LEWG

• Should we make atomic<shared_ptr<T>> and atomic<weak_ptr<T>> constexpr? (paper's wording contains this change)

  There is associated paper P3037R1 making shared_ptr<T> constexpr.

Example

This example shows how you can easily reuse code between runtime and constant evaluated code without duplication. Without this paper you need to duplicate multiple functions.

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));
}

Proposed changes to wording