Performance Benefits of mdspan

Using std::mdspan can provide several performance benefits compared to using nested vectors or arrays for representing multidimensional data. Here are a few key advantages:

Contiguous Memory Layout

std::mdspan is designed to work with contiguous memory layouts, where all elements are stored in a single contiguous block of memory.

This is in contrast to nested vectors or arrays, where each inner vector or array is allocated separately, resulting in non-contiguous memory. Contiguous memory layout has several benefits:

Better Cache Locality

When accessing elements sequentially, contiguous memory allows for better utilization of the CPU cache, leading to faster memory access.

Reduced Memory Fragmentation

Contiguous memory allocation reduces memory fragmentation, which can improve overall memory usage efficiency.

Avoiding Memory Allocations

When using nested vectors or arrays, each inner vector or array requires its own memory allocation. This can lead to numerous small allocations, which can be inefficient and add overhead.

With std::mdspan, you typically allocate a single contiguous block of memory upfront (e.g., using std::vector or std::array) and then create an mdspan view over that memory. This avoids the need for multiple allocations and deallocations.

Efficient Element Access

std::mdspan provides an efficient way to access elements using multiple indices.

The indices are mapped to the corresponding position in the underlying contiguous memory block using a layout mapping function.

This mapping is typically optimized and can be more efficient compared to the nested indexing required with nested vectors or arrays.

Compatibility with Existing Code

std::mdspan is designed to be compatible with existing code that operates on contiguous memory, such as C-style arrays or single-dimensional std::vector or std::array.

This means you can easily integrate std::mdspan into existing codebases without major changes, while still benefiting from the performance advantages it offers.

Here's a simple example comparing element access using std::mdspan and nested vectors:

1#include <chrono>
2#include <iostream>
3#include <mdspan>
4#include <vector>
5
6int main() {
7  using namespace std::chrono;
8  const int rows = 1000;
9  const int cols = 1000;
10
11  // Nested vectors
12  std::vector<std::vector<int>> nestedVectors(
13    rows, std::vector<int>(cols));
14
15  // Contiguous memory with mdspan
16  std::vector<int> contiguousData(rows * cols);
17  std::mdspan<int, std::extents<
18    std::size_t, rows, cols>> mdspanView{
19      contiguousData.data()};
20
21  // Measure access time for nested vectors
22  auto startNested = high_resolution_clock::now();
23  for (int i = 0; i < rows; ++i) {
24    for (int j = 0; j < cols; ++j) {
25      nestedVectors[i][j] = i * cols + j;
26    }
27  }
28  auto endNested = high_resolution_clock::now();
29
30  // Measure access time for mdspan
31  auto startMdspan = high_resolution_clock::now();
32  for (int i = 0; i < rows; ++i) {
33    for (int j = 0; j < cols; ++j) {
34      mdspanView[i, j] = i * cols + j;  
35    }
36  }
37  auto endMdspan = high_resolution_clock::now();
38
39  // Print access times
40  duration<double> nestedTime =
41    endNested - startNested;
42  duration<double> mdspanTime =
43    endMdspan - startMdspan;
44
45  std::cout << "Nested vectors access time: "
46    << nestedTime.count() << " seconds\n";
47
48  std::cout << "mdspan access time: "
49    << mdspanTime.count() << " seconds\n";
50}

In this example, we compare the element access time for nested vectors and std::mdspan. The mdspan version typically demonstrates faster access times due to the benefits mentioned above.

Please note that the actual performance gains may vary depending on factors such as data size, access patterns, and hardware characteristics. It's always recommended to profile and benchmark your specific use case to determine the actual performance impact.