通过流水线提高性能是计算机架构设计的8个伟大思想之一,不管是硬件设计还是软件设计,流水线设计(pipeline)都能够用更多的资源来实现高速。流水线设计的具体内容在我看到的这篇博客【FPGA中流水线的原因和方法】中讲的很明白,这里不再赘述。
在HLS中,pipeline指令单指函数内部的流水,举一个简单的例子:
void func(int m, int n, int o){
for(int i = 2; i >= 0; i--){
#pragma HLS pipeline ii = 1
op_Read;
op_Compute;
op_Write;
}
}
我们可以使用II参数指定期望的流水线启动时间间隔,HLS工具会尝试满足此请求,但根据数据之间的依赖关系,最终的II可能会更大。
dataflow指令通常和stream指令一起使用,可以启用任务级流水打拍,允许函数和循环在其操作过程中重叠,增加 RTL 实现的并发度,并增加设计的整体吞吐量。在功能上,任务级流水线和函数内部的流水十分相似。
举一个简单的例子:
void top(int a, int b, int c,int d){
# pragma HLS dataflow
func_A(a,b,i1);
func_B(c,i1,i2);
func_C(i2,d);
}
为什么有pipeline指令,还需要用到任务级流水线?
假如一个函数用到的资源过多,那么单个函数内的走线就会过长,这会导致时序违规。
以下行为可能阻止或限制 Vitis HLS 可在数据流模型内执行的重叠:
由于篇幅原因,这里就不细讲了,详情可以参考Vitis高层次综合用户指南 (UG1399)
array_partition指令能够将阵列分区为更小的阵列或者独立元素,并提供下列特性:
对于array_partition指令,常用的参数有四个,这里直接把文档的内容贴过来:
variable=
必要实参,用于指定要分区的阵列变量。
type=
(可选)指定分区类型。默认类型为 complete。支持以下类型:
循环分区会通过交织来自原始阵列的元素来创建更小的阵列。该阵列按循环进行分区,具体方式是在每个新阵列中放入一个元素,然后回到第一个阵列以重复该循环直至阵列完全完成分区为止。例如,如果使用 factor=3:
块分区会从原始阵列的连续块创建更小阵列。这样可将阵列有效分区为 N 个相等的块,其中 N 为 factor=实参定义的整数。
完全分区可将阵列分解为多个独立元素。对于一维阵列,这对应于将存储器解析为独立寄存器。这是默认。
factor=
指定要创建的更小的阵列数量。对于 complete 型分区,不指定该因子。对于 block 和 cyclic 型分区,需指定 factor=。
dim=
指定要分区的多维阵列的维度。针对含N维的阵列,指定范围介于0到N之间的整数。
对于一维数组,给定如下代码:
int AB1[13];
int AB2[13];
int AB3[13];
#pragma HLS array_partition variable=AB1 type=block factor=4
#pragma HLS array_partition variable=AB2 type=cycle factor=4
#pragma HLS array_partition variable=AB3 type=complete
array_reshape指令与array_partition指令的功能类似,能够重构阵列,并提供对数据的并行访问。对于一维数组,给定如下代码:
void foo (...) {
int array1[N];
int array2[N];
int array3[N];
#pragma HLS array_reshape variable=array1 type=block factor=2 dim=1
#pragma HLS array_reshape variable=array2 type=cycle factor=2 dim=1
#pragma HLS array_reshape variable=array3 type=complete dim=1
...
}
看到这里有些读者可能就有点困惑了,这张图和array_partition的示意图十分类似,那为什么有了array_partition指令,还需要array_reshape指令呢?
先简单概括一下二者的区别:
接下来举一个二维数组的例子,对于二维数组,最经典的设计莫过于矩阵乘法了,给定如下代码:
void matrixmul(int A[N][M], int B[M][P], int AB[N][P]) {
#pragma HLS array_reshape variable=A complete dim=2
#pragma HLS array_reshape variable=B complete dim=1
/* for each row and column of AB */
row: for(int i = 0; i < N; ++i) {
col: for(int j = 0; j < P; ++j) {
#pragma HLS PIPELINE II=1
/* compute (AB)i,j */
int ABij = 0;
product: for(int k = 0; k < M; ++k) {
ABij += A[i][k] * B[k][j];
}
AB[i][j] = ABij;
}
}
}
上面的代码使用了array_reshape指令提高了一个时钟周期内可以读取的数组元素个数,当然使用array_partition也是可以的,它们支持相同的操作,可以循环和阻塞分块或者根据多维度的数据进行不同维度的分块。
但是!!!在使用array_reshape的时候,所有的元素在变换后的数组中共用同一个地址,而array_partition变换后数组中地址是不相关的。
假设板卡上最小的BRAM是18Kbits,可以支持不同深度和宽度的组合,那么对于维度是[1024][4] 的4-bit数组:如果使用array_partition指令,就会使用4个BRAM将数组配置为4个 1Kbit x 4,每个BRAM都没有被充分利用;但如果使用array_reshape指令,就会使用1个BRAM将数组配置为1个4Kbit x 4。
unroll指令能够将循环完全展开或部分展开。完全展开循环会在 RTL 内为每个循环迭代创建一份循环主体副本,使得整个循环可以并行。部分展开循环允许指定因子 N 以创建 N 份循环主体副本,并相应减少循环迭代。
使用unroll指令部分展开循环,不用保证循环边界已知,但如果要完全展开循环,在编译时循环边界必须已知,因为编译器需要知道它创建副本的数量。
以一段简单的for循环代码为例:
for(int i = 0; i < 8; i++) {
a[i] = b[i] + c[i];
}
当没有添加任何优化指令时,硬件上运行这段代码需要花费8个时钟周期,这是万万不能令人接受的。unroll指令能够帮助我们在在 RTL 设计中创建循环主体的多个副本,使得运行这段代码只耗费1个时钟周期:
for(int i = 0; i < 8; i++) {
#pragma HLS unroll
a[i] = b[i] + c[i];
}
这段代码与下面的代码是等效的,vitis-hls会将这些语句并行执行:
a[0] = b[0] + c[0];
a[1] = b[1] + c[1];
a[2] = b[2] + c[2];
a[3] = b[3] + c[3];
a[4] = b[4] + c[4];
a[5] = b[5] + c[5];
a[6] = b[6] + c[6];
a[7] = b[7] + c[7];
虽然我们一直可以手动执行循环展开,但是利用工具为我们执行循环展开明显更容易,它使代码更易阅读,并且可以减少编码错误。
unroll指令默认是全部展开的,但也可以通过设置factor参数的方式部分展开循环,例如以下代码:
for(int i = 0; i < X; i++) {
#pragma HLS unroll factor=2
a[i] = b[i] + c[i];
}
按照因子2展开的循环可以将代码有效变换为如下所示代码:
for(int i = 0; i < X; i += 2) {
a[i] = b[i] + c[i];
if (i+1 >= X) break;
a[i+1] = b[i+1] + c[i+1];
}
为了保证逻辑,需要在中间加入if判断逻辑,这会使得整个威廉希尔官方网站 的控制逻辑变得复杂。但假如我们已经知道指定的展开因子(在此示例中为 2)是最大迭代计数 X 的整数因子,那么我们就可以使用skip_exit_check 参数手动移除掉if判断逻辑:
for(int i = 0; i < X; i++) {
#pragma HLS unroll factor=2 skip_exit_check
a[i] = b[i] + c[i];
}
这样一来,代码就可以有效的变换成我们想要的代码了:
for(int i = 0; i < X; i += 2) {
a[i] = b[i] + c[i];
a[i+1] = b[i+1] + c[i+1];
}
由于项目中片上资源还是比较充足的,因此除非遇到边界不确定的情况,否则我很少使用到factor这个参数,对于小循环直接全部展开,而对大循环使用pipeline优化。
loop_flatten指令允许把嵌套循环平铺为已改善时延的单一循环层级,举一个简单的例子:
void foo (int num_samples, int result, int a, int b) {
loop_1:
for(int i = 0; i < num_samples; i++) {
loop_2:
for(int j = 0; j < 2; j++) {
#pragma HLS loop_flatten
result = a + b;
}
}
}
在这个例子中,无论是从loop_1移动到loop_2,还是从loop_2移动到loop_1,都需要额外花费一个时钟周期的时间。loop_flatten指令能够通过嵌套循环平铺的方式将loop_1与loop_2作为单一循环,节省时钟周期。
只有在完美循环嵌套或半完美循环嵌套时,才能够使用loop_flatten指令!!
完美循环嵌套
半完美循环嵌套
非完美循环嵌套
还是上面的例子,当内层循环具有变量边界时,它就是一个非完美循环嵌套:
void foo (int num_samples, int result, int a, int b) {
loop_1:
for(int i = 0; i < num_samples; i++) {
loop_2:
for(int j = 0; j < num_samples; j++) { // 内层循环具有变量边界
#pragma HLS loop_flatten
result = a + b;
}
}
}
循环主体未完全包含在内层循环内时,它同样是一个非完美循环嵌套:
void foo (int num_samples, int result, int a, int b) {
loop_1:
for(int i = 0; i < num_samples; i++) {
loop_2:
result = a;// 循环主体未完全包含在内层循环内
for(int j = 0; j < 2; j++) {
#pragma HLS loop_flatten
result = a + b;
}
result = b;// 循环主体未完全包含在内层循环内
}
}
loop_flatten指令同样可以用于多个嵌套循环之中,需要将loop_flatten指令应用于循环层级的最内层循环的循环主体,所有内层循环均需要使用常量,并且循环语句之间不能指定任何逻辑:
void foo (int num_samples, int result, int a, int b) {
loop_1:
for(int i = 0; i < num_samples; i++) {
loop_2:
for(int j = 0; j < 2; j++) {
loop_3:
for(int k = 0; k < 2; k++) {
#pragma HLS loop_flatten
result = a + b;
}
}
}
}
和loop_flatten指令类似,连续循环之间同样需要耗费额外的时钟周期。loop_merge指令能够将连续循环合并到单个循环内,以缩短总体时延、增加共享,并提升逻辑最优化。
合并循环的规则是:
这里仅举一个能够成功合并的例子:
void foo (int num_samples, int a, int b) {
#pragma HLS loop_merge
loop_1:
for(int i=0;i< num_samples;i++) {
a = 1;
}
loop_2:
for(int j=0;j< num_samples;j++) {
b = 2;
}
}
由于这条指令的应用条件十分苛刻,因此很少使用。一般直接通过代码重构的方式对连续循环进行优化。
更多回帖