C++23 `std::mdspan`的设计原理：实现多维数组的零拷贝视图与外部数据集成 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

C++23 `std::mdspan`: 多维数组的零拷贝视图与外部数据集成

各位来宾，大家好。今天我们来深入探讨C++23引入的std::mdspan，一个强大的工具，它为多维数组提供了零拷贝的视图，并实现了与外部数据的无缝集成。

`std::mdspan` 诞生的背景

在传统的C++编程中，处理多维数组常常面临一些挑战：

所有权和生命周期管理： 当我们将多维数组传递给函数时，必须明确数组的所有权和生命周期。这可能导致不必要的拷贝，或者更糟糕的，悬挂指针。
数据布局的灵活性： 标准的C++数组（T[M][N]）使用行优先（row-major）布局，这限制了我们在与其他语言或库（如Fortran，其使用列优先布局）交互时的灵活性。
与外部数据的集成： 直接访问外部数据（例如，从文件或网络读取的数据）而不进行拷贝通常很困难。

std::mdspan旨在解决这些问题，它提供了一种非拥有（non-owning）的多维数组视图，允许我们以不同的布局方式访问数据，并与外部数据源无缝集成。

`std::mdspan` 的核心概念

std::mdspan 本身是一个模板类，其模板参数主要包括：

元素类型 (ElementType)： 数组中元素的类型（例如，int，double，std::complex<float>）。
秩 (Rank)： 数组的维数（例如，1表示一维数组，2表示二维数组）。
范围 (Extents)： 一个描述数组每一维度大小的类型。这通常是一个 std::extents 对象，也可以是其他符合 Extents 概念的类型。
布局映射策略 (LayoutPolicy)： 一个定义数组元素在内存中排列方式的类型。这可以是 std::layout_right (列优先，Fortran风格), std::layout_left (行优先，C/C++风格), std::layout_stride (通用步长布局) 或者用户自定义的布局。
访问器策略 (AccessorPolicy)： 一个定义如何访问底层存储的类型。默认情况下，使用 std::default_accessor。

简单来说，mdspan 就像一个“智能指针”，指向一块连续的内存区域，并提供了以多维数组的方式访问这块内存的接口。但与智能指针不同的是，mdspan 通常不负责管理底层内存的生命周期。

`std::extents`：描述数组的形状

std::extents 是一个描述多维数组形状的类。它指定了数组每一维的大小。std::extents 可以是 静态的 （编译时已知大小）或 动态的 （运行时确定大小）。

静态 Extents： 所有维度的大小都在编译时已知。例如，std::extents<3, 4> 表示一个 3×4 的二维数组。
动态 Extents： 至少有一个维度的大小在运行时确定。例如，std::extents<std::dynamic_extent, std::dynamic_extent> 表示一个行数和列数都在运行时确定的二维数组。std::dynamic_extent 是一个特殊的占位符，表示维度的大小在运行时确定。
混合 Extents： 某些维度的大小在编译时已知，而另一些维度的大小在运行时确定。例如，std::extents<3, std::dynamic_extent> 表示一个行数为 3，列数在运行时确定的二维数组。

#include <mdspan>
#include <iostream>

int main() {
    // 静态 extents
    std::extents<3, 4> static_extents;
    std::cout << "Static extents: rank = " << static_extents.rank() << ", extent(0) = " << static_extents.extent(0) << ", extent(1) = " << static_extents.extent(1) << std::endl;

    // 动态 extents
    std::extents<std::dynamic_extent, std::dynamic_extent> dynamic_extents(5, 6);
    std::cout << "Dynamic extents: rank = " << dynamic_extents.rank() << ", extent(0) = " << dynamic_extents.extent(0) << ", extent(1) = " << dynamic_extents.extent(1) << std::endl;

    // 混合 extents
    std::extents<3, std::dynamic_extent> mixed_extents(7);
    std::cout << "Mixed extents: rank = " << mixed_extents.rank() << ", extent(0) = " << mixed_extents.extent(0) << ", extent(1) = " << mixed_extents.extent(1) << std::endl;

    return 0;
}

这段代码演示了如何创建和访问不同类型的 std::extents 对象。 rank() 方法返回数组的维数， extent(i) 方法返回第 i 维的大小。

`std::layout_right` 和 `std::layout_left`：控制数据布局

std::layout_right 和 std::layout_left 是两种常用的布局策略，它们分别对应于列优先（Fortran风格）和行优先（C/C++风格）的内存布局。

std::layout_right (列优先): 最右边的维度是连续存储的。例如，对于一个 3×4 的二维数组，元素在内存中的排列顺序为 a[0][0], a[1][0], a[2][0], a[0][1], a[1][1], a[2][1], ...。
std::layout_left (行优先): 最左边的维度是连续存储的。例如，对于一个 3×4 的二维数组，元素在内存中的排列顺序为 a[0][0], a[0][1], a[0][2], a[0][3], a[1][0], a[1][1], a[1][2], a[1][3], ...。

#include <mdspan>
#include <iostream>

int main() {
    int data[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

    // 行优先布局
    std::mdspan<int, std::extents<3, 4>, std::layout_left> row_major(data[0], 3, 4);
    std::cout << "Row-major: " << row_major(0, 0) << ", " << row_major(0, 1) << ", " << row_major(1, 0) << std::endl;

    // 列优先布局
    std::mdspan<int, std::extents<3, 4>, std::layout_right> col_major(data[0], 3, 4);
    std::cout << "Column-major: " << col_major(0, 0) << ", " << col_major(0, 1) << ", " << col_major(1, 0) << std::endl;

    return 0;
}

这段代码演示了如何使用 std::layout_left 和 std::layout_right 创建 mdspan 对象，并访问其中的元素。注意，访问元素的方式 ( mdspan(i, j) ) 与标准C++数组相同，但 mdspan 确保了根据指定的布局策略正确地访问内存。

`std::layout_stride`：实现自定义布局

std::layout_stride 提供了最大的灵活性，允许我们定义任意的步长布局。步长是指在特定维度上，从一个元素移动到下一个元素所需的内存偏移量（以元素大小为单位）。

#include <mdspan>
#include <iostream>

int main() {
    int data[12] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

    // 创建一个 3x4 的 mdspan，但以步长为 1 和 4 的方式访问数据
    std::mdspan<int, std::extents<3, 4>, std::layout_stride> strided_view(data, std::array<std::size_t, 2>{4, 1}, std::array<std::size_t, 2>{3, 4});

    std::cout << "Strided view: " << strided_view(0, 0) << ", " << strided_view(0, 1) << ", " << strided_view(1, 0) << std::endl;

    return 0;
}

在上面的代码中，std::array<std::size_t, 2>{4, 1} 指定了每一维度的大小，std::array<std::size_t, 2>{3, 4} 指定了每一维度的步长。这意味着，在第一个维度（行）上，从一个元素移动到下一个元素需要跳过 4 个元素（即，一个完整的列），在第二个维度（列）上，从一个元素移动到下一个元素需要跳过 1 个元素。这段代码实际上以列优先的方式访问数据，尽管底层数据存储是连续的。

`std::submdspan`：创建子视图

std::submdspan 允许我们从现有的 mdspan 中创建一个子视图，而无需拷贝数据。这对于处理大型数据集的特定区域非常有用。

#include <mdspan>
#include <iostream>

int main() {
    int data[5][5] = {
        {1, 2, 3, 4, 5},
        {6, 7, 8, 9, 10},
        {11, 12, 13, 14, 15},
        {16, 17, 18, 19, 20},
        {21, 22, 23, 24, 25}
    };

    std::mdspan<int, std::extents<5, 5>> original_view(data[0], 5, 5);

    // 创建一个从 (1, 1) 开始的 3x3 子视图
    auto subview = std::submdspan(original_view, std::pair{1, 4}, std::pair{1,4});

    std::cout << "Sub-view: " << subview.extent(0) << "x" << subview.extent(1) << std::endl;
    std::cout << "Sub-view element (0, 0): " << subview(0, 0) << std::endl; // 应该输出 7

    return 0;
}

这段代码展示了如何使用 std::submdspan 从 original_view 中提取一个子视图。std::pair{1, 4}和std::pair{1, 4}定义了子视图的起始位置，结束位置（不包含）。这意味着子视图从原始视图的 data[1][1] 开始，并包含 3 行 3 列的元素。

与外部数据集成：零拷贝访问

std::mdspan 最大的优势之一是能够与外部数据源集成，而无需进行数据拷贝。这对于处理大型数据集或者需要与其他语言或库（例如，Fortran，CUDA）交互的场景非常重要。

#include <mdspan>
#include <iostream>
#include <fstream>

int main() {
    // 假设我们从文件中读取了一些数据
    std::ifstream file("data.bin", std::ios::binary);
    if (!file.is_open()) {
        std::cerr << "Failed to open file." << std::endl;
        return 1;
    }

    // 获取文件大小
    file.seekg(0, std::ios::end);
    size_t file_size = file.tellg();
    file.seekg(0, std::ios::beg);

    // 假设文件包含一个 10x10 的浮点数矩阵
    size_t num_elements = 10 * 10;
    if (file_size != num_elements * sizeof(float)) {
        std::cerr << "File size mismatch." << std::endl;
        return 1;
    }

    // 分配一块内存来存储数据
    float* data = new float[num_elements];

    // 读取数据到内存
    file.read(reinterpret_cast<char*>(data), file_size);
    file.close();

    // 创建一个 mdspan 来访问数据，无需拷贝
    std::mdspan<float, std::extents<10, 10>> matrix_view(data, 10, 10);

    // 访问数据
    std::cout << "Matrix element (0, 0): " << matrix_view(0, 0) << std::endl;
    std::cout << "Matrix element (5, 5): " << matrix_view(5, 5) << std::endl;

    delete[] data; // 重要：释放分配的内存

    return 0;
}

在这个例子中，我们首先从一个二进制文件中读取数据到一块动态分配的内存中。然后，我们创建了一个 std::mdspan 对象，它指向这块内存，但并不拥有这块内存的所有权。这意味着，我们可以像访问一个普通的二维数组一样访问文件中的数据，而无需进行任何数据拷贝。 重要提示： 由于 mdspan 不拥有底层内存的所有权，因此我们需要手动释放分配的内存，以避免内存泄漏。

`std::mdspan` 的优势总结

总的来说，std::mdspan 提供了以下几个关键优势：

零拷贝视图： 避免了不必要的数据拷贝，提高了性能，尤其是在处理大型数据集时。
灵活的内存布局： 支持行优先、列优先和自定义的步长布局，方便与其他语言或库交互。
与外部数据集成： 允许直接访问外部数据，无需拷贝，简化了数据处理流程。
编译时和运行时的维度： 允许在编译时或运行时指定数组的维度，提供了更大的灵活性。
子视图： 可以从现有 mdspan 中创建子视图，而无需拷贝数据。

代码示例：矩阵乘法

下面是一个使用 std::mdspan 实现矩阵乘法的示例。

#include <mdspan>
#include <iostream>

void matrix_multiply(std::mdspan<const double, std::extents<std::dynamic_extent, std::dynamic_extent>> a,
                     std::mdspan<const double, std::extents<std::dynamic_extent, std::dynamic_extent>> b,
                     std::mdspan<double, std::extents<std::dynamic_extent, std::dynamic_extent>> c) {
    size_t m = a.extent(0);
    size_t n = b.extent(1);
    size_t k = a.extent(1);

    if (b.extent(0) != k || c.extent(0) != m || c.extent(1) != n) {
        throw std::runtime_error("Matrix dimensions mismatch.");
    }

    for (size_t i = 0; i < m; ++i) {
        for (size_t j = 0; j < n; ++j) {
            c(i, j) = 0.0;
            for (size_t l = 0; l < k; ++l) {
                c(i, j) += a(i, l) * b(l, j);
            }
        }
    }
}

int main() {
    double a_data[2][3] = {{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}};
    double b_data[3][2] = {{7.0, 8.0}, {9.0, 10.0}, {11.0, 12.0}};
    double c_data[2][2] = {{0.0, 0.0}, {0.0, 0.0}};

    std::mdspan<const double, std::extents<std::dynamic_extent, std::dynamic_extent>> a(a_data[0], 2, 3);
    std::mdspan<const double, std::extents<std::dynamic_extent, std::dynamic_extent>> b(b_data[0], 3, 2);
    std::mdspan<double, std::extents<std::dynamic_extent, std::dynamic_extent>> c(c_data[0], 2, 2);

    matrix_multiply(a, b, c);

    for (size_t i = 0; i < 2; ++i) {
        for (size_t j = 0; j < 2; ++j) {
            std::cout << c(i, j) << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

这个例子展示了如何使用 std::mdspan 将矩阵传递给函数，并在函数内部进行矩阵乘法运算。 std::dynamic_extent 用于指定矩阵的维度在运行时确定。

`std::mdspan` 的使用场景

std::mdspan 在许多场景下都非常有用，包括：

科学计算： 处理大型数据集，进行数值模拟和数据分析。
图像处理： 访问和操作图像数据，进行图像滤波、分割和识别。
机器学习： 处理训练数据和模型参数，进行模型训练和预测。
游戏开发： 处理游戏场景中的物体和数据，进行碰撞检测和渲染。
嵌入式系统： 访问和操作传感器数据，进行实时控制和数据处理。

对未来的展望

std::mdspan 是 C++23 中一个重要的特性，它为多维数组的处理提供了更高效、更灵活的解决方案。随着 C++ 标准的不断发展，我们可以期待 std::mdspan 在未来发挥更大的作用，并与其他 C++ 特性（例如，协程、ranges）更好地集成，为我们带来更强大的编程能力。

总结：简化多维数据处理，拥抱 `std::mdspan`

std::mdspan 通过提供零拷贝视图和灵活的布局策略，极大地简化了多维数据的处理，使得与外部数据源的集成变得更加容易。掌握 std::mdspan 的使用，可以提高代码的性能和可维护性，并为我们打开更广阔的编程视野。

更多IT精英技术系列讲座，到智猿学院

C++23 std::mdspan: 多维数组的零拷贝视图与外部数据集成

std::mdspan 诞生的背景

std::mdspan 的核心概念

std::extents：描述数组的形状

std::layout_right 和 std::layout_left：控制数据布局

std::layout_stride：实现自定义布局

std::submdspan：创建子视图