# Tensorarray — MindSpore Signal+ 使用手册 alpha 文档

# Tensorarray

张量数组操作，支持从张量数组中读取指定索引的张量，或将张量写入到张量数组的指定索引位置。该算子不区分数据类型，适用于所有数据类型。

TensorArrayRead（读取操作）：

从张量数组中读取指定索引的张量，并将其数据复制到输出。

\[\text{output} = \text{tensors}[\text{index}]\]

TensorArrayWrite（写入操作）：

将输入张量的数据复制到张量数组的指定索引位置。

\[\text{tensors}[\text{index}] = \text{input}\]

两个操作都会复制数据，复制大小为 size * type_size 字节。

输入（TensorArrayRead）：

  - tensors - 张量数组（Tensor** 类型），包含多个张量。

  - index - 读取的索引（int 类型），指定从 tensors 数组中读取哪个张量。

  - core_mask - 核掩码（int），仅共享存储版本需要。

输出（TensorArrayRead）：

  - output - 输出张量（Tensor* 类型），包含复制后的数据。输出张量的 size 和 type_size 应与选中的输入张量相同。

输入（TensorArrayWrite）：

  - input - 输入张量（Tensor* 类型），待写入的数据。

  - index - 写入的索引（int 类型），指定写入到 tensors 数组的哪个位置。

  - tensors - 张量数组（Tensor** 类型），目标数组。

  - core_mask - 核掩码（int），仅共享存储版本需要。

输出（TensorArrayWrite）：

  - tensors[index] - 张量数组指定位置的数据会被更新。

支持平台：

  `FT78NE` `MT7004`

备注

- 该算子不区分数据类型，适用于所有数据类型

- 算子会复制数据，输入和输出张量数据独立

- 调用前需要确保目标内存空间足够大（至少 size * type_size 字节）

- 读取和写入时，涉及的张量的 size 和 type_size 应匹配

共享存储版本:

TensorArrayRead（读取操作）:

void tensorarrayread_s(Tensor **tensors, int index, Tensor *output, int core_mask)

TensorArrayWrite（写入操作）:

void tensorarraywrite_s(Tensor *input, int index, Tensor **tensors, int core_mask)

C调用示例（TensorArrayRead）：

     1//FT78NE示例
     2#include <stdio.h>
     3#include <tensorarray.h>
     4
     5int main(int argc, char* argv[]) {
     6    // 假设在DDR空间
     7    Tensor tensor0, tensor1, tensor2;
     8    Tensor output;
     9
    10    // 初始化张量数组中的张量
    11    tensor0.type_size = 4;  // float32
    12    tensor0.size = 1000;
    13    tensor0.data = (void *)0xA0000000;
    14
    15    tensor1.type_size = 4;
    16    tensor1.size = 1000;
    17    tensor1.data = (void *)0xA1000000;
    18
    19    tensor2.type_size = 4;
    20    tensor2.size = 1000;
    21    tensor2.data = (void *)0xA2000000;
    22
    23    // 初始化输出张量
    24    output.type_size = 4;
    25    output.size = 1000;
    26    output.data = (void *)0xB0000000;  // 需要预先分配足够的内存
    27
    28    // 创建张量数组
    29    Tensor* tensors[3] = {&tensor0, &tensor1, &tensor2};
    30
    31    int index = 1;  // 读取 tensor1
    32    int core_mask = 0xff;
    33
    34    tensorarrayread_s(tensors, index, &output, core_mask);
    35
    36    // 此时 output.data 包含 tensor1.data 的副本
    37
    38    return 0;
    39}

C调用示例（TensorArrayWrite）：

     1//FT78NE示例
     2#include <stdio.h>
     3#include <tensorarray.h>
     4
     5int main(int argc, char* argv[]) {
     6    // 假设在DDR空间
     7    Tensor input;
     8    Tensor tensor0, tensor1, tensor2;
     9
    10    // 初始化输入张量
    11    input.type_size = 4;  // float32
    12    input.size = 1000;
    13    input.data = (void *)0xA0000000;
    14
    15    // 初始化张量数组中的张量（需要预先分配内存）
    16    tensor0.type_size = 4;
    17    tensor0.size = 1000;
    18    tensor0.data = (void *)0xB0000000;
    19
    20    tensor1.type_size = 4;
    21    tensor1.size = 1000;
    22    tensor1.data = (void *)0xB0100000;
    23
    24    tensor2.type_size = 4;
    25    tensor2.size = 1000;
    26    tensor2.data = (void *)0xB0200000;
    27
    28    // 创建张量数组
    29    Tensor* tensors[3] = {&tensor0, &tensor1, &tensor2};
    30
    31    int index = 1;  // 写入到 tensor1 的位置
    32    int core_mask = 0xff;
    33
    34    tensorarraywrite_s(&input, index, tensors, core_mask);
    35
    36    // 此时 tensors[1]->data 包含 input.data 的副本
    37
    38    return 0;
    39}

私有存储版本:

TensorArrayRead（读取操作）:

void tensorarrayread_p(Tensor **tensors, int index, Tensor *output)

TensorArrayWrite（写入操作）:

void tensorarraywrite_p(Tensor *input, int index, Tensor **tensors)

C调用示例（私有存储版本）：

     1//FT78NE示例
     2#include <stdio.h>
     3#include <tensorarray.h>
     4
     5int main(int argc, char* argv[]) {
     6    // 假设在L2空间
     7    Tensor tensor0, tensor1, tensor2;
     8    Tensor output;
     9
    10    tensor0.type_size = 4;  // float32
    11    tensor0.size = 1000;
    12    tensor0.data = (void *)0x10000000;
    13
    14    tensor1.type_size = 4;
    15    tensor1.size = 1000;
    16    tensor1.data = (void *)0x10001000;
    17
    18    tensor2.type_size = 4;
    19    tensor2.size = 1000;
    20    tensor2.data = (void *)0x10002000;
    21
    22    output.type_size = 4;
    23    output.size = 1000;
    24    output.data = (void *)0x10003000;  // 需要预先分配足够的内存
    25
    26    Tensor* tensors[3] = {&tensor0, &tensor1, &tensor2};
    27
    28    int index = 0;  // 读取 tensor0
    29
    30    tensorarrayread_p(tensors, index, &output);
    31
    32    return 0;
    33}