Accessor Policy in mdspan

The accessor policy in std::mdspan is an optional template parameter that allows you to customize how elements are accessed and potentially modified when using the [] operator or the accessor member function of mdspan.

The primary purposes of the accessor policy are:

Customizing Element Access Behavior

The accessor policy enables you to define custom behavior for accessing elements in the mdspan. This can be useful in various scenarios, such as:

• Adding bounds checking: You can implement an accessor policy that checks if the accessed indices are within the valid range of the mdspan, preventing out-of-bounds access.
• Applying transformations: You can define an accessor policy that applies certain transformations to the elements before returning them, such as scaling, offsetting, or type conversions.
• Implementing read-only or write-only access: You can create accessor policies that restrict access to read-only or write-only operations, enforcing specific access patterns.

Interoperability with External Libraries or APIs

When working with external libraries or APIs that expect a specific accessor behavior, you can use an appropriate accessor policy to adapt the mdspan to match those expectations.

For example, if an external library expects accessor objects with certain member functions or operators, you can define an accessor policy that provides those required interfaces.

Performance Optimization

In some cases, the accessor policy can be used to optimize element access performance. By defining a custom accessor policy, you can avoid unnecessary function calls or indirections and provide a more efficient way to access elements.

However, it's important to note that the performance impact of accessor policies depends on the specific use case and compiler optimizations. In many cases, the default accessor policy provided by std::mdspan is already optimized for common scenarios.

Here's an example that demonstrates a custom accessor policy that applies a scaling factor to the elements:

1#include <iostream>
2#include <mdspan>
3
4// Custom accessor policy that scales
5// elements by a factor of 10
6struct ScalingAccessor {
7  template <typename T>
8  struct accessor {
9    T* data;
10
11    accessor(T* ptr) : data(ptr) {}
12
13    T read(std::size_t offset) const {
14      return data[offset] * 10;  
15    }
16
17    void write(std::size_t offset, T value) {
18      data[offset] = value / 10;  
19    }
20  };
21};
22
23int main() {
24  std::array<int, 6> arr{1, 2, 3, 4, 5, 6};
25  std::mdspan<int, std::extents<
26    std::size_t, 2, 3>, std::layout_right,
27      ScalingAccessor>
28      scalingSpan{arr.data()};
29
30  std::cout << "Original elements:\n";
31  for (std::size_t i = 0;
32    i < scalingSpan.extent(0); ++i) {
33    for (std::size_t j = 0;
34      j < scalingSpan.extent(1); ++j) {
35      std::cout << scalingSpan[i, j] << " ";
36    }
37    std::cout << "\n";
38  }
39
40  // Modify elements through the accessor policy
41  scalingSpan[0, 0] = 10;
42  scalingSpan[1, 1] = 50;
43
44  std::cout << "\nModified elements:\n";
45  for (std::size_t i = 0;
46    i < scalingSpan.extent(0); ++i) {
47    for (std::size_t j = 0;
48      j < scalingSpan.extent(1); ++j) {
49      std::cout
50        << arr[i * scalingSpan.extent(1) + j]
51        << " ";
52    }
53    std::cout << "\n";
54  }
55}

1Original elements:
210 20 30
340 50 60
4
5Modified elements:
61 2 3
74 5 6

In this example, we define a custom accessor policy called ScalingAccessor that scales the elements by a factor of 10 when reading and divides them by 10 when writing.

We create an mdspan object scalingSpan with the ScalingAccessor policy. When accessing elements through scalingSpan, the scaling behavior is applied transparently.

Note that the accessor policy only affects the access through the mdspan object. When we modify elements through scalingSpan, the underlying array arr is updated with the original unscaled values.

Accessor policies provide a powerful way to customize element access behavior in mdspan, enabling various use cases and optimizations.