`<execution>`: execution policies lure users into writing nonportable code

[localspook]

The standard defines execution policies like so:

class parallel_policy { /* unspecified */ };
inline constexpr parallel_policy par { /* unspecified */ };

Nothing guarantees that execution policies are movable, copyable, or default constructible, and portable code cannot assume they are, but, because they look so much like tag types (and indeed are tag types in all major implementations), users can very easily assume that they behave no different than true tag types like from_range_t. To prevent users from making nonportable assumptions, we should make these types impossible to construct, copy, or move. libc++ and stdexec already do this, libstdc++ does not.

If we’re concerned about breaking users, we can do a gradual migration: keep the default constructors and special member functions, but mark them all [[deprecated]] with a helpful message, and only = delete them later.

[frederick-vs-ja]

I think this request makes little sense.

For a certain implementation, one can write either static_assert(std::is_copy_constructible_v<std::execution::parallel_policy>); or static_assert(!std::is_copy_constructible_v<std::execution::parallel_policy>);, both of which are non-portable.

I incline to ensuring them to be normal tag types by fixing the standard, which will eliminate all sorts of non-portability. See also WG21-P3136R1.

Edit: LWG-4273 submitted.

[localspook]

Consider a user that wants to implement a function taking an execution policy and forwarding it to a standard algorithm:

template <typename E>
requires std::is_execution_policy_v<E>
void f(E policy, ...) {
    std::sort(policy, ...);
}

This code is nonportable, it should be:

template <typename E>
requires std::is_execution_policy_v<std::remove_cvref_t<E>>
void f(E&& policy, ...) {
    std::sort(std::forward<E>(policy), ...); 
}

The problem is that the first snippet is a portability trap that’s easy to fall into. I think this is what distinguishes it from your example. The first snippet looks perfectly correct (if you’re not closely reading the standard).

Mandating the 4 standard execution policies to be tag types would not make the first snippet retroactively correct, because we would still have the problem of the possible implementation-defined execution policies. Unless those were also mandated to be tag types (severely limiting their potential usefulness), user code that needs to generically work with any execution policy would still not be able to assume execution policies are tag types.

[frederick-vs-ja]

Mandating the 4 standard execution policies to be tag types would not make the first snippet retroactively correct, because we would still have the problem of the possible implementation-defined execution policies.

Such incorrectness only occurs with implementation-specific codes that use such an extension. Additionally handling non-standard execution isn't the business of "strictly" portable code, IMO.

IIUC existing standard library implementations (stdexec is not one) don't have such an extension since C++20, although libstdc++ backports unseq/unsequenced_policy to C++17.

So you seemed to suggest to align standard-guaranteed library components with the uncertainty of some yet-to-exist extensions, which doesn't seem a good thing to me.

[YexuanXiao]

I acknowledge that there are some inconsistencies here, but I believe what needs to be modified is libc++ rather than the STL. Copying execution tag should be harmless in any case, so there's no need to block it, which is also consistent with other tags in the standard library.

[StephanTLavavej]

Thanks for bringing up this issue. I am not inclined to do anything here - we've been shipping this for the better part of a decade, this hasn't proven to be a portability trap in practice, and the Standard permits what we're doing. If the Standard wants us to make them noncopyable then it should say so.

The only thing I think we should be doing differently is giving these tags explicit default constructors, following the modern practice for tag types.