Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Allow "std::byte" as "vec" element type #674

Open
wants to merge 1 commit into
base: main
Choose a base branch
from

Conversation

gmlueck
Copy link
Contributor

@gmlueck gmlueck commented Dec 3, 2024

This is change 7 of 9 that fix problems with the specification of the vec class. An implementation that follows the existing specification would not accept common code patterns and would not pass the CTS. None of the existing implementations actually follow the existing specification.

This change clarifies that std::byte is a legal element type for vec. This is one possible interpretation of the previous wording where we said that the element data type must be a "basic scalar type". We think that phrase included sycl::byte. However, sycl::byte was deprecated in SYCL 2020 saying that std::byte is a replacement.

If we allow std::byte, we need to adjust the constraints for the various vec operators. We decided to allow these operators on vec of std::byte, which mostly follows the C++ rules for operators on plain std::byte:

  • Comparison: ==, !=, <, <=, >, >=
  • Bitwise: &, |, ^, ~, &=, |=, ^=

I decided it was clearer to rephrase the constraints to say which types are allowed rather than listing the types that are not allowed. For example, this results in phrasing like:

Available only when DataT is an integral type.

Rather than:

Available only when: DataT != float && DataT != double &&
DataT != half && DataT != std::byte.

These changes correspond to slide 26 of the presentation that was discussed in the WG meetings.

This is change 7 of 9 that fix problems with the specification of the
`vec` class.  An implementation that follows the existing specification
would not accept common code patterns and would not pass the CTS.  None
of the existing implementations actually follow the existing
specification.

This change clarifies that `std::byte` is a legal element type for
`vec`.  This is one possible interpretation of the previous wording
where we said that the element data type must be a "basic scalar type".
We think that phrase included `sycl::byte`.  However, `sycl::byte` was
deprecated in SYCL 2020 saying that `std::byte` is a replacement.

If we allow `std::byte`, we need to adjust the constraints for the
various `vec` operators.  We decided to allow these operators on `vec`
of `std::byte`, which mostly follows the C++ rules for operators on
plain `std::byte`:

* Comparison: ==, !=, <, <=, >, >=
* Bitwise: &, |, ^, ~, &=, |=, ^=

I decided it was clearer to rephrase the constraints to say which types
are allowed rather than listing the types that are not allowed.  For
example, this results in phrasing like:

> Available only when DataT is an integral type.

Rather than:

> Available only when: DataT != float && DataT != double &&
> DataT != half && DataT != std::byte.

These changes correspond to slide 26 of the presentation that was
discussed in the WG meetings.
Copy link
Member

@keryell keryell left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Thanks for the generalization.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

2 participants