devbox
小蓝xlanll
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Vitis HLS 学习笔记--优化指令-ARRAY_PARTITION

作者：小蓝xlanll | 2024-04-23 12:40:58

赞

踩

Vitis HLS 学习笔记--优化指令-ARRAY_PARTITION

目录

1. ARRAY_PARTITION 概述

2. 语法解析

2.1 参数解释

2.1.1 variable

2.1.2 type

2.1.3 factor

2.1.4 dim

2.2 典型示例

2.2.1 dim=1

2.2.2 dim=2

2.2.3 dim=0

3. 实例演示

4. 总结

1. ARRAY_PARTITION 概述

ARRAY_PARTITION 指令中非常重要，它用于优化数组的存储和访问。该指令可以将一个大数组分割成多个小数组，以提高并行处理能力和减少访问延迟。

其实这个过程类比到RTL种，就是手动分配如下数组：

reg [数据位宽-1:0] my_array [维度2:0][维度1:0];

HLS 提供了一个更高级的抽象层次，允许我们在不需要关心将 my_array 分解为多少个子数组以优化访问时序的情况下进行操作。它为数组分割的快速分析和实施提供了一种极为便捷的方法。

2. 语法解析

#pragma HLS array_partition variable=<name> type=<type> factor=<int> dim=<int>

2.1 参数解释

2.1.1 variable

必要实参，用于指定要分区的阵列变量。

2.1.2 type

指定分区类型，可选。默认类型为 complete。支持以下类型：

  • cyclic：循环分区会通过交织来自原始阵列的元素来创建更小的阵列。该阵列按循环进行分区，具体方式是在每个新阵列中放入一个元素，然后回到第一个阵列以重复该循环直至阵列完全完成分区为止。例如，如果使用 factor=3：
    • 向第 1 个新阵列分配元素 0
    • 向第 2 个新阵列分配元素 1
    • 向第 3 个新阵列分配元素 2
    • 向第 4 个新阵列分配元素 3
  • block：块分区会从原始阵列的连续块创建更小阵列。这样可将阵列有效分区为 N 个相等的块，其中 N 为 factor= 实参定义的整数。
  • complete：完全分区可将阵列分解为多个独立元素。对于一维阵列，这对应于将存储器解析为独立寄存器。这是默认 <type>。

2.1.3 factor

指定要创建的更小的阵列数量。

仅对于 block 和 cyclic 型分区生效！

2.1.4 dim

指定要分区的多维阵列的维度。针对含 <N> 维的阵列，指定范围介于 0 到 <N> 之间的整数：

  • 如果使用 0 值，则使用指定的类型和因子选项对多维阵列的所有维度进行分区。
  • 任意非零值均表示只对指定维度进行分区。例如，如果使用的值为 1，则仅对第 1 个维度进行分区。

2.2 典型示例

complete类型比较多见，故选择此类型进行分析。

  1. int l_A[2][5];
  2. #pragma HLS ARRAY_PARTITION variable=l_A type=complete dim=?

对于l_A[2][5]，其元素分布如下：

l_A[0][0]

l_A[0][1]

l_A[0][2]

l_A[0][3]

l_A[0][4]

l_A[1][0]

l_A[1][1]

l_A[1][2]

l_A[1][3]

l_A[1][4]

2.2.1 dim=1

第 1 个维度进行分区，相当于将l_A[2][5]拆分成两个2元素数组。

它们分别存储在2个 ram_1p 的存储器中。

可以同时访问所有l_A[0][x]和l_A[1][x]。

该分区方法，每个时钟周期可以读取两个数据。

2.2.2 dim=2

第 1 个维度进行分区，相当于将l_A[2][5]拆分成两个5元素数组。

它们分别存储在5个 ram_1p 的存储器种。

可以同时访问所有l_A[x][0]、l_A[x][1]、l_A[x][2]、l_A[x][3]、l_A[x][4]。

该分区方法，每个时钟周期可以读取5个数据。

2.2.3 dim=0

当dim=0时，表示对整个数组进行完全分区，不考虑具体的维度。这意味着数组的每个元素都将被单独存储，完全独立地占用资源。对于l_A[2][5]，这将导致所有10个元素都被独立存储，每个元素可以被单独访问，这最大化了并行访问能力，但也大量占用资源。

3. 实例演示

  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. #define MAX_SIZE 16
  5.  
  6. const unsigned int c_dim = MAX_SIZE;
  7.  
  8. extern "C" {
  9. void matmul(int* in1, int* in2, int* out_r, int size, int rep_count) {
  10.     // Local buffers to hold input data
  11.     int A[MAX_SIZE][MAX_SIZE];
  12.     int B[MAX_SIZE][MAX_SIZE];
  13.     int C[MAX_SIZE][MAX_SIZE];
  14.     int temp_sum[MAX_SIZE];
  15.  
  16. // Read data from global memory and write into local buffer for in1
  17. readA:
  18.     for (int itr = 0, i = 0, j = 0; itr < size * size; itr++, j++) {
  19. #pragma HLS LOOP_TRIPCOUNT min = c_dim* c_dim max = c_dim * c_dim
  20.         if (j == size) {
  21.             j = 0;
  22.             i++;
  23.         }
  24.         A[i][j] = in1[itr];
  25.     }
  26.  
  27. // Read data from global memory and write into local buffer for in2
  28. readB:
  29.     for (int itr = 0, i = 0, j = 0; itr < size * size; itr++, j++) {
  30. #pragma HLS LOOP_TRIPCOUNT min = c_dim* c_dim max = c_dim * c_dim
  31.         if (j == size) {
  32.             j = 0;
  33.             i++;
  34.         }
  35.         B[i][j] = in2[itr];
  36.     }
  37.  
  38. // Calculate matrix multiplication using local data buffer based on input size,
  39. // and write results into C
  40. count_loop:
  41.     for (int i = 0; i < rep_count; i++) {
  42.     nopart1:
  43.         for (int row = 0; row < size; row++) {
  44. #pragma HLS LOOP_TRIPCOUNT min = c_dim max = c_dim
  45.         nopart2:
  46.             for (int col = 0; col < size; col++) {
  47. #pragma HLS LOOP_TRIPCOUNT min = c_dim max = c_dim
  48.             nopart3:
  49.                 for (int j = 0; j < MAX_SIZE; j++) {
  50. #pragma HLS LOOP_TRIPCOUNT min = c_dim max = c_dim
  51.                     int result = (col == 0) ? 0 : temp_sum[j];
  52.                     result += A[row][col] * B[col][j];
  53.                     temp_sum[j] = result;
  54.                     if (col == size - 1) C[row][j] = result;
  55.                 }
  56.             }
  57.         }
  58.     }
  59.  
  60. // Write results from local buffer to global memory for out
  61. writeC:
  62.     for (int itr = 0, i = 0, j = 0; itr < size * size; itr++, j++) {
  63. #pragma HLS LOOP_TRIPCOUNT min = c_dim* c_dim max = c_dim * c_dim
  64.         if (j == size) {
  65.             j = 0;
  66.             i++;
  67.         }
  68.         out_r[itr] = C[i][j];
  69.     }
  70. }
  71. }

添加这几行指令：

#pragma HLS ARRAY_PARTITION variable = B dim = 2 complete
#pragma HLS ARRAY_PARTITION variable = C dim = 2 complete
#pragma HLS ARRAY_PARTITION variable = temp_sum dim = 1 complete

运行 Vitis HLS 编译器，我们得到如下结果：

  1. ================================================================
  2. == Bind Storage Report
  3. ================================================================
  4. +--------------------+------+------+--------+----------+---------+------+---------+
  5. | Name               | BRAM | URAM | Pragma | Variable | Storage | Impl | Latency |
  6. +--------------------+------+------+--------+----------+---------+------+---------+
  7. | + matmul_partition | 1    | 0    |        |          |         |      |         |
  8. |   A_U              | 2    | -    |        | A        | ram_1p  | auto | 1       |
  9. |   B_U              | -    | -    |        | B        | ram_1p  | auto | 1       |
  10. |   B_1_U            | -    | -    |        | B_1      | ram_1p  | auto | 1       |
  11. |   B_2_U            | -    | -    |        | B_2      | ram_1p  | auto | 1       |
  12. |   B_3_U            | -    | -    |        | B_3      | ram_1p  | auto | 1       |
  13. |   B_4_U            | -    | -    |        | B_4      | ram_1p  | auto | 1       |
  14. |   B_5_U            | -    | -    |        | B_5      | ram_1p  | auto | 1       |
  15. |   B_6_U            | -    | -    |        | B_6      | ram_1p  | auto | 1       |
  16. |   B_7_U            | -    | -    |        | B_7      | ram_1p  | auto | 1       |
  17. |   B_8_U            | -    | -    |        | B_8      | ram_1p  | auto | 1       |
  18. |   B_9_U            | -    | -    |        | B_9      | ram_1p  | auto | 1       |
  19. |   B_10_U           | -    | -    |        | B_10     | ram_1p  | auto | 1       |
  20. |   B_11_U           | -    | -    |        | B_11     | ram_1p  | auto | 1       |
  21. |   B_12_U           | -    | -    |        | B_12     | ram_1p  | auto | 1       |
  22. |   B_13_U           | -    | -    |        | B_13     | ram_1p  | auto | 1       |
  23. |   B_14_U           | -    | -    |        | B_14     | ram_1p  | auto | 1       |
  24. |   B_15_U           | -    | -    |        | B_15     | ram_1p  | auto | 1       |
  25. |   C_U              | -    | -    |        | C        | ram_1p  | auto | 1       |
  26. |   C_1_U            | -    | -    |        | C_1      | ram_1p  | auto | 1       |
  27. |   C_2_U            | -    | -    |        | C_2      | ram_1p  | auto | 1       |
  28. |   C_3_U            | -    | -    |        | C_3      | ram_1p  | auto | 1       |
  29. |   C_4_U            | -    | -    |        | C_4      | ram_1p  | auto | 1       |
  30. |   C_5_U            | -    | -    |        | C_5      | ram_1p  | auto | 1       |
  31. |   C_6_U            | -    | -    |        | C_6      | ram_1p  | auto | 1       |
  32. |   C_7_U            | -    | -    |        | C_7      | ram_1p  | auto | 1       |
  33. |   C_8_U            | -    | -    |        | C_8      | ram_1p  | auto | 1       |
  34. |   C_9_U            | -    | -    |        | C_9      | ram_1p  | auto | 1       |
  35. |   C_10_U           | -    | -    |        | C_10     | ram_1p  | auto | 1       |
  36. |   C_11_U           | -    | -    |        | C_11     | ram_1p  | auto | 1       |
  37. |   C_12_U           | -    | -    |        | C_12     | ram_1p  | auto | 1       |
  38. |   C_13_U           | -    | -    |        | C_13     | ram_1p  | auto | 1       |
  39. |   C_14_U           | -    | -    |        | C_14     | ram_1p  | auto | 1       |
  40. |   C_15_U           | -    | -    |        | C_15     | ram_1p  | auto | 1       |
  41. +--------------------+------+------+--------+----------+---------+------+---------+

数组A未指定特定分区，因此将整体存储于单个ram_1p存储器中。而数组B与数组C经过特定设置，按照dim=2的维度被分割为16个区块（即16个ramp_1p存储器），这意味着数组B和数组C能够并行读取16个数据项。此举显著提升了程序处理的吞吐率。

4. 总结

ARRAY_PARTITION指令是高层次综合中一个强大的工具，它可以帮助设计者在保证性能的同时，更有效地利用硬件资源。合理的数组分区可以在不牺牲性能的前提下，优化硬件资源的使用，尤其是在资源受限的设计中。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小蓝xlanll/article/detail/473940
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号