P3771R0: constexpr mutex, locks, and condition variable

Example with std::mutex

Type std::mutex has constexpr default constructor since C++11, but std::lock_guard doesn't. You can't just wrap the auto _ = std::lock_guard{mtx} into if consteval.

template <typename T> class locked_queue {
	std::queue<T> impl{};
	std::mutex mtx{};
public:
	locked_queue() = default;
	
	constexpr void push(T input) {
		auto _ = std::lock_guard{mtx}; // BEFORE: unable to call non-constexpr constructor
		                               // AFTER: fine
		impl.push(std::move(input));
	}
	constexpr std::optional<T> pop() {
		auto _ = std::lock_guard{mtx}; // BEFORE: unable to call non-constexpr constructor
		                               // AFTER: fine
		if (impl.empty()) {
			return std::nullopt;
		}
		
		auto r = std::move(impl.front());
		impl.pop();
		return r;
	}
}

consteval foo my_algorithm() {
	auto queue = locked_queue<int>{};
	queue.push(1);  // BEFORE: unable to call non-constexpr constructor of `lock_guard`
	queue.push(42); //                                                                 
	queue.push(11); //                                                                 
	                // AFTER: I can reuse my code!
	return process(queue); 
}

One possibility to make this work without this paper would look like this:

template <typename T> class locked_queue {
	std::queue<T> impl{};
	std::mutex mtx{};
	
	constexpr void unsync_push(T input) {
		impl.push(std::move(input));
	}
	
	constexpr std::optional<T> unsync_pop() {
		if (impl.empty()) {
			return std::nullopt;
		}
		
		auto r = std::move(impl.front());
		impl.pop();
		return r;
	}
	
public:
	constexpr void push(T input) {
		if consteval {
			unsafe_push(std::move(input));
		} else {
			auto _ = std::lock_guard{mtx};
			unsafe_push(std::move(input));
		}
	}
	constexpr std::optional<T> pop() {
		if consteval {
			return unsafe_pop();
		} else {
			auto _ = std::lock_guard{mtx};
			return unsafe_pop();
		}
	}
}

This pattern is terrible and it creates opportunities for more bugs, and it makes testing harder (especially when test coverage mapping is used).

Example with std::shared_mutex

template <typename T> class protected_object {
	std::optional<T> object{std::nullopt};
	std::shared_mutex mtx{}; // BEFORE: unable to use non-constexpr constructor
		                       // AFTER: fine
public:
	template <typename... Args> constexpr void set(Args && ... args) {
		auto _ = std::unique_lock{mtx};
		object.emplace(std::forward<Args>(args)...);
	}
	std::optional<T;> get() const {
		auto _ = std::shared_lock{mtx};
		return object;
	}
}

Type std::shared_mutex doesn't have constexpr default constructor. There is not a simple solution how to avoid the error.

why is it in source files

Based on my experience implementing constexpr exceptions I have noticed libc++ tends to hide the exception throwing code in to source files in shared library. This code mostly will be needed to moved to header files anyway due the constexpr exception support. The two layer of abstraction for mutex and condition_variable won't be needed anymore after that.

shared_mutex implementation detail in libc++

This is code from libc++ with removed annotational macros. Unfortunetely the __shared_mutex_base contains methods defined in a .cpp file. But internal mutex and condition_variable types are already default constexpr constructible and the __shared_mutex_base constructor only sets __state_ to zero, so this constructor can be easily made constexpr.

All the single-threaded semantic can be then put into shared_mutex type, with if consteval and compiler builtin to attach constant evaluation metadata to an object.

struct __shared_mutex_base {
  mutex __mut_;
  condition_variable __gate1_;
  condition_variable __gate2_;
  unsigned __state_{0};

  static const unsigned __write_entered_ = 1U << (sizeof(unsigned) * __CHAR_BIT__ - 1);
  static const unsigned __n_readers_     = ~__write_entered_;

  __shared_mutex_base() = default;
  ~__shared_mutex_base() = default;

  __shared_mutex_base(const __shared_mutex_base&)            = delete;
  __shared_mutex_base& operator=(const __shared_mutex_base&) = delete;

  // Exclusive ownership
  void lock(); // blocking
  bool try_lock();
  void unlock();

  // Shared ownership
  void lock_shared(); // blocking
  bool try_lock_shared();
  void unlock_shared();
};
	
class shared_mutex {
  __shared_mutex_base __base_;

public:
  constexpr shared_mutex() : __base_() {}
  ~shared_mutex() = default;

  shared_mutex(const shared_mutex&)            = delete;
  shared_mutex& operator=(const shared_mutex&) = delete;

  // Exclusive ownership
  constexpr void lock() {
    if consteval {
      return __builtin_metadata_unique_lock(&__base_);
      if (__base_.state != 0) std::abort;
      __base_.state = 1;
    } else {
      return __base_.lock();
    }
  }
  constexpr bool try_lock() {
    if consteval {
      return __builtin_metadata_try_unique_lock(&__base_);
      if (__base_.state != 0) return false;
      __base_.state = 1;
      return true;
    } else {
      return __base_.try_lock();
    }
  }
  constexpr void unlock() {
    if consteval {
      return __builtin_metadata_unique_unlock(&__base_);
      if (__base_.state != 1) std::abort();
      __base_.state = 0;
    } else {
      return __base_.unlock();
    }
  }

  // Shared ownership
  constexpr void lock_shared() {
    if consteval {
      return __builtin_metadata_shared_lock(&__base_);
      if (__base_.state == 0) __base_.state = 2;
      else if (__base_.state == 1) std::abort();
      else ++__base_.state;
    } else {
      return __base_.lock_shared();
    }
  }
  constexpr bool try_lock_shared() {
    if consteval {
      return __builtin_metadata_try_shared_lock(&__base_);
      if (__base_.state == 0) __base_.state = 2;
      else if (__base_.state == 1) return false;
      else ++__base_.state;
      return true;
    } else {
      return __base_.try_lock_shared();
    }
  }
  constexpr void unlock_shared() {
    if consteval {
      return __builtin_metadata_shared_unlock(&__base_);
      if (__base_.state == 0) std::abort();
      else if (__base_.state == 1) std::abort();
			else if (__base_.state == 2) __base_.state = 0;
      else --__base_.state;
    } else {
      return __base_.unlock_shared();
    }
  }
};

Purposes of these builtins is to provided associated metadata to the object itself, and use them for useful diagnostics.

Alternative approach would be use __shared_mutex_base::__state_ for it, and use library functionality to provide error messages in case of deadlock, but this approach doesn't allow us easily to diagnose where the lock was previously obtained.

std::mutex

Most basic mutex type is all defined in headers it's default constructor is defaulted or explicitly made constexpr in presence of macro __GTHREAD_MUTEX_INIT. Native type is hidden in __mutex_base which in order to support constexpr default initialize the __gthread_mutex_t native handle.

std::shared_mutex

Shared mutex type's default constructor is not historically marked constexpr. It's also defined all in a header file. Construction of native handle is abstract in __shared_mutex_pthread or __shared_mutex_cv which is used when platform doesn't provide _GLIBCXX_USE_PTHREAD_RWLOCK_T and its implementation is normal mutex and two condition variables, similarly as in libc++.

In case pthread of the platform provides RW lock, the type __shared_mutex_pthread abstracts it away. If macro PTHREAD_RWLOCK_INITIALIZER is available, it's used to defualt initialize the lock. This macro is on most major platform providing aggregate or numeric constant initialization (macOS, linux, win32's pthreads).

lock guards

All lock guards types (lock_guard, unique_lock, shared_lock, scoped_lock) are just RAII wrappers over interfaces of mutexes. There is nothing special and nothing which interfere with making them constexpr, these are already defined in header files.

std::condition_variable

Condition variable types are defined partially in header file. Implementation of some function is in a source file and they are not doing anything platform specific. Type __condvar which abstracts native handle is defined next to std::mutex. It doesn't contain same abstraction as was done for the mutex type, even when most pthread libraries provides equivalent macro PTHREAD_COND_INITIALIZER for constant initialization. This piece of code would benefit from update. Making __condvar constexpr compatible would be then trivial.