Vitis HLS 学习笔记--控制驱动TLP-处理deadlock

已于 2024-05-23 21:54:07 修改
阅读量1.3k 收藏 19
点赞数 38
文章标签： 学习 笔记 fpga开发 HLS c++
于 2024-05-22 23:10:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DongDong314/article/details/139124847
版权

目录

1. 简介

2. 代码解析

2.1 HLS kernel代码

2.2 查看接口报告

2.3 TestBench

2.4 Dataflow 报告

3. Takeaways

4. 总结

1. 简介

本文是对《Hardware Acceleration Tutorials: FIFO Sizing for Performance and Avoiding Deadlocks》实验内容的详细解释。

首先需要了解，鉴于数据流优化具有动态特性，且不同并行任务的执行速度各不相同，设置不当的数据流通道可能会引发性能下降或死锁。

数据流通道有两种：FIFO 和 PIPO。可以由工具推断，或者用户自行创建。

FIFO：

  • Streams (including hls::streams and streamed arrays)，用户创建。
  • Scalar propagation FIFOs，工具推断。
  • Streams of blocks，用户创建。

每个通道都有自己的握手信号。因为：

  • 它们的读写操作是被调度的。
  • 它们的读/写信号分别由流水线控制或有限状态机（FSM）单独驱动。
  • 它们的full_n/empty_n信号直接使流水线的单个迭代或FSM的状态暂停。

PIPO：

  • PIPO，用户创建。
  • Task Level FIFOs (TLF)，工具推断。
  • Input and output ports to the upper level，用户创建。

其中，Task Level FIFOs (TLF) 是标量（scalar）FIFO，其连接到生产者的“done”握手信号以进行写入，并连接到消费者的“start”握手信号以进行读取。这些类型的FIFO是由工具自动推断的。由于底层同步机制的缘故，它们被视为类PIPO。

这些通道应该被视为“使用ap_ctrl_chain握手的通道”，因为：

  • 它们的写入和读取操作不会被调度。它们隐式地与进程的“done”握手或“start”握手相关联。
  • 它们的写入和读取信号分别连接到ap_done和ap_ready。
  • 它们的full_n和empty_n分别连接到ap_continue和ap_start。

总结一下，在分析存储深度、性能、死锁等方面，真正需要关系的是：

  • 通道是否拥有自己的握手机制（FIFOs）。它们的访问在其进程执行期间被分散开来。例如，你可以在管道的第一个II之外读取一个FIFO，或者甚至在数据流网络的最后一个过程中读取。
  • 通道是否通过ap_ctrl_chain进行握手（PIPOs）。它们的读取必须在管道的第一个II中，或者在数据流网络的第一个“层级”的过程中进行，类似地，它们的写入必须在最后一个II或在最后一个“层级”中进行。
  • 另一个区别基于一次操作中传输的数据量，这对于资源分析比对性能分析更为重要：对于PIPOs来说是数组，对于流来说是块流、标量流，对于标量传播FIFOs和任务级FIFOs来说是标量。

2. 代码解析

2.1 HLS kernel代码

#include "example.h"

void example(hls::stream<int>& A, hls::stream<int>& B){
#pragma HLS dataflow
#pragma HLS INTERFACE ap_fifo port=A
#pragma HLS INTERFACE ap_fifo port=B
    hls::stream<int> data_channel1;
    hls::stream<int> data_channel2;

    proc_1(A, data_channel1, data_channel2);
    proc_2(data_channel1, data_channel2, B);
}

void proc_1(hls::stream<int>& A, hls::stream<int>& B, hls::stream<int>& C){
#pragma HLS dataflow
    hls::stream<int> data_channel1;
    hls::stream<int> data_channel2;

    proc_1_1(A, data_channel1, data_channel2);
    proc_1_2(B, C, data_channel1, data_channel2);
}

void proc_1_1(hls::stream<int>& A, hls::stream<int>& data_channel1, hls::stream<int>& data_channel2){
  int i;
  int tmp;
  for(i = 0; i < 10; i++){
    tmp = A.read();
    data_channel1.write(tmp); 
  }
  for(i = 0; i < 10; i++){
    data_channel2.write(tmp); 
  }
}

void proc_1_2(hls::stream<int>& B, hls::stream<int>& C, hls::stream<int>& data_channel1, hls::stream<int>& data_channel2){
  int i;
  int tmp;
  
  for(i = 0; i < 10; i++){
    tmp = data_channel2.read() + data_channel1.read();
    B.write(tmp);
  }
  for(i = 0; i < 10; i++){
    C.write(tmp); 
  }
}

void proc_2(hls::stream<int>& A, hls::stream<int>& B, hls::stream<int>& C){
#pragma HLS dataflow
    hls::stream<int> data_channel1;
    hls::stream<int> data_channel2;

    proc_2_1(A, B, data_channel1, data_channel2);
    proc_2_2(C, data_channel1, data_channel2);
}

void proc_2_1(hls::stream<int>& A, hls::stream<int>& B, hls::stream<int>& data_channel1, hls::stream<int>& data_channel2){
  int i;
  int tmp;
  for(i = 0; i < 10; i++){
    tmp = A.read() + B.read();
    data_channel1.write(tmp); 
  }
  for(i = 0; i < 10; i++){
    data_channel2.write(tmp); 
  }
}

void proc_2_2(hls::stream<int>& C, hls::stream<int>& data_channel1, hls::stream<int>& data_channel2){
  int i;
  int tmp;
  for(i = 0; i < 10; i++){
    tmp = data_channel2.read() + data_channel1.read();
    C.write(tmp);
  }
}

与原示例相比，去掉了“&”符号。

#pragma HLS INTERFACE ap_fifo port=&A
#pragma HLS INTERFACE ap_fifo port=&B

以上 kernel 的功能框图：

2.2 查看接口报告

对于顶层文件，可以查看 example_csynth.rpt，观察顶层接口：

================================================================
== Interface
================================================================
* Summary: 
+-----------+-----+-----+------------+--------------+--------------+
| RTL Ports | Dir | Bits|  Protocol  | Source Object|    C Type    |
+-----------+-----+-----+------------+--------------+--------------+
|A_dout     |   in|   32|     ap_fifo|             A|       pointer|
|A_empty_n  |   in|    1|     ap_fifo|             A|       pointer|
|A_read     |  out|    1|     ap_fifo|             A|       pointer|
|B_din      |  out|   32|     ap_fifo|             B|       pointer|
|B_full_n   |   in|    1|     ap_fifo|             B|       pointer|
|B_write    |  out|    1|     ap_fifo|             B|       pointer|
|ap_clk     |   in|    1|  ap_ctrl_hs|       example|  return value|
|ap_rst     |   in|    1|  ap_ctrl_hs|       example|  return value|
|ap_start   |   in|    1|  ap_ctrl_hs|       example|  return value|
|ap_done    |  out|    1|  ap_ctrl_hs|       example|  return value|
|ap_ready   |  out|    1|  ap_ctrl_hs|       example|  return value|
|ap_idle    |  out|    1|  ap_ctrl_hs|       example|  return value|
+-----------+-----+-----+------------+--------------+--------------+

 针对 Dataflow 区域的每个函数体，均有对应的 Interface：

================================================================
== Interface
================================================================
* Summary: 
+-------------------------------+-----+-----+------------+----------------+--------------+
|           RTL Ports           | Dir | Bits|  Protocol  |  Source Object |    C Type    |
+-------------------------------+-----+-----+------------+----------------+--------------+
|ap_clk                         |   in|    1|  ap_ctrl_hs|        proc_1_1|  return value|
|ap_rst                         |   in|    1|  ap_ctrl_hs|        proc_1_1|  return value|
|ap_start                       |   in|    1|  ap_ctrl_hs|        proc_1_1|  return value|
|start_full_n                   |   in|    1|  ap_ctrl_hs|        proc_1_1|  return value|
|ap_done                        |  out|    1|  ap_ctrl_hs|        proc_1_1|  return value|
|ap_continue                    |   in|    1|  ap_ctrl_hs|        proc_1_1|  return value|
|ap_idle                        |  out|    1|  ap_ctrl_hs|        proc_1_1|  return value|
|ap_ready                       |  out|    1|  ap_ctrl_hs|        proc_1_1|  return value|
|start_out                      |  out|    1|  ap_ctrl_hs|        proc_1_1|  return value|
|start_write                    |  out|    1|  ap_ctrl_hs|        proc_1_1|  return value|
|A_dout                         |   in|   32|     ap_fifo|               A|       pointer|
|A_empty_n                      |   in|    1|     ap_fifo|               A|       pointer|
|A_read                         |  out|    1|     ap_fifo|               A|       pointer|
|data_channel12_din             |  out|   32|     ap_fifo|  data_channel12|       pointer|
|data_channel12_num_data_valid  |   in|    2|     ap_fifo|  data_channel12|       pointer|
|data_channel12_fifo_cap        |   in|    2|     ap_fifo|  data_channel12|       pointer|
|data_channel12_full_n          |   in|    1|     ap_fifo|  data_channel12|       pointer|
|data_channel12_write           |  out|    1|     ap_fifo|  data_channel12|       pointer|
|data_channel23_din             |  out|   32|     ap_fifo|  data_channel23|       pointer|
|data_channel23_num_data_valid  |   in|    2|     ap_fifo|  data_channel23|       pointer|
|data_channel23_fifo_cap        |   in|    2|     ap_fifo|  data_channel23|       pointer|
|data_channel23_full_n          |   in|    1|     ap_fifo|  data_channel23|       pointer|
|data_channel23_write           |  out|    1|     ap_fifo|  data_channel23|       pointer|
+-------------------------------+-----+-----+------------+----------------+--------------+

上述报告 Source  Object 所在列:

  • A - > hls::stream<int>& A, C type 为 pointer
  • data_channel12 -> hls::stream<int>& data_channel1, C type 为 pointer
  • data_channel23 -> hls::stream<int>& data_channel2, C type 为 pointer
​
void proc_1_1(hls::stream<int>& A, hls::stream<int>& data_channel1, hls::stream<int>& data_channel2){
  int i;
  int tmp;
  for(i = 0; i < 10; i++){
    tmp = A.read();
    data_channel1.write(tmp);
  }
  for(i = 0; i < 10; i++){
    data_channel2.write(tmp);
  }
}

2.3 TestBench

#include <stdio.h>
#include "hls_stream.h"

#define SIZE 10
extern void example(hls::stream<int>& A, hls::stream<int>& B);

int main()
{
  int i;
  hls::stream<int> A;
  hls::stream<int> B;
  
  int time = 0;
  for   (time = 0 ; time < 4; time ++) {
      for(i=0; i < SIZE; i++){
        A << (i + time);
      }
      example(A,B);
  }
  return 0;
}

2.4 Dataflow 报告

运行 C Synthesis 后，可以查看 Dataflow 报告，如下图，没有问题。

在运行 C/RTL Cosimulation 后，同样在 Dataflow 报告中可以看到错误。

3. Takeaways

总结而言，Dataflow查看器实现了以下吞吐量分析任务：

图表展示了 DATAFLOW 区域的整体拓扑结构，并显示了在 DATAFLOW 区域中任务之间用于通信的通道类型（FIFO/PIPO）。通过分析每个通道和进程，可以有效地解决死锁或由于FIFO大小不当导致的吞吐量不足等问题。

协同仿真数据通过在仿真过程中跟踪FIFO的最大使用量，为解决FIFO大小设置问题提供了参考依据，从而帮助用户调整FIFO大小。此外，运行协同仿真时的自动死锁检测功能能够突出显示涉及死锁的进程和通道，使用户能够快速定位并解决这些问题。

除了 FIFO 大小的调整，协同仿真后的数据还能按每个进程和通道报告因等待输入或输出而导致的停滞时间。这些图表帮助用户理解并解决这些问题，同时管理通道大小以满足慢速生产者与快速消费者之间的需求，或者相反。此外，图表还揭示了在DATAFLOW区域中途读取输入如何影响整体性能，这是一个常见的场景，可能会对性能产生重大影响。

4. 总结

在数据流优化中，通道类型、握手机制、FIFO大小和死锁避免都是关键因素。通过Dataflow查看器和协同仿真数据，您可以有效地优化设计，提高性能并避免潜在问题。

hi94
关注
  • 38
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c-ug1399-vitis-hls c-ug1399-vitis-hls
11-02
c_ug1399-vitis-hls
c_ug1391-vitis-hls-migration-guide.pdf
10-12
中文版 vitis HLS开发手册ug1391
Vitis HLS 学习笔记--理解串流Stream(1)
hi94的博客
05-07 659
在Vitis HLS中，hls::stream是一个关键的数据结构，用于处理数据流。它类似于C++标准库中的std::stream，但专门设计用于硬件描述语言。hls::stream具有类似无限深度的FIFO的行为，支持顺序读写操作，并可灵活定义数据类型和FIFO深度。通过示例代码和综合报告，我们了解到hls::stream在硬件设计中的重要作用，以及如何根据需求配置不同的接口实现。这使得在设计硬件加速器时更加灵活、可控。
Vitis HLS 学习笔记--控制驱动TLP - Dataflow视图
hi94的博客
05-23 1266
Dataflow视图是一种强大的性能分析工具，通过展示数据流结构和通道信息，帮助用户深入了解设计的性能特征。其功能包括源代码浏览、进程和通道详细表、自动交叉探测等，为设计调试提供了有力支持。与流水线优化相比，数据流优化更注重动态性和并行性，能够根据输入数据的可用性灵活调度执行顺序，提升系统性能。然而，需要注意的是，在未执行RTL协同仿真前，数据流视图可能缺乏关键性能数据，需添加DATAFLOW编译指令以补充信息。 Dataflow视图的应用有助于设计优化和性能调试，提升系统的整体效率与性能。
Vitis HLS 学习笔记--控制驱动任务示例
hi94的博客
05-21 1193
本文对《Vitis HLS 学习笔记--抽象并行编程模型-控制驱动与数据驱动-CSDN博客》中的控制驱动任务示例进行了详细解析，重点分析了 kernel 代码的并行处理机制及各模块的实现。通过查看综合报告、Schedule Viewer 和 Dataflow Viewer，确认了 funcB 和 funcC 的并行执行和 vecOut 的 FIFO 设置。并介绍了 Vitis IDE 的关键设置，包括数据文件加载、Flow Target 配置及 FIFO 深度调整。
Vitis HLS 学习笔记--HLS入门示例集合-目录
hi94的博客
04-25 1248
本示例集对如下内容做记录： Interface（接口）：展示各种模式和接口协议使用的常见示例 Pipelining（流水线）：展示循环和函数的流水线pragma使用的常见示例 Task_Level_Parallelism（任务级并行）：展示任务级并行编程模型和拓扑结构示例 Modeling（建模）：数学和DSP示例以及其他常见使用模型/算法 Misc（其他）：例如C++中的RTL黑盒等其他示例
Vitis HLS 学习笔记--控制驱动与数据驱动混合编程
hi94的博客
05-31 595
在Vitis HLS中，控制驱动（Control-driven）和数据驱动（Data-driven）的并行性是高效硬件设计的两个关键组成部分。控制驱动并行性通过#pragma HLS dataflow指令实现，允许不同函数在数据准备好时即刻并行执行，从而优化整体性能。数据驱动并行性则通过hls::task类实现，它将函数封装为可并行执行的任务。这两种技术的结合，使得设计者能够充分利用硬件资源，实现复杂算法的高效执行。
Vitis HLS 学习笔记--S_AXILITE 寄存器及驱动
hi94的博客
04-28 1030
使用 Vitis HLS 工具进行硬件设计带来了额外的“隐式”优势，即在驱动程序的自动生成方面。本文详解 S_AXILITE Registers 寄存器及其驱动过程。通过对 s_axilite 协议下生成的寄存器进行解释，我们了解了这些寄存器的作用和每个寄存器位的含义。
Vitis HLS 学习笔记--抽象并行编程模型-控制驱动与数据驱动
hi94的博客
05-20 1240
任务级并行度（TLP）通过同时执行多个任务提升应用效率和性能。Vitis HLS 提供了数据驱动和控制驱动两种 TLP 模型。数据驱动模型像自动化流水线，适用于无外部存储器交互且函数间无数据依赖的应用；控制驱动模型则更像一个指挥官，适合不同部分需相互通信的应用。数据驱动模型中，任务通过 hls::task 声明，通道通过 hls::stream 模拟，注意避免死锁。控制驱动模型使用 C++ 顺序语义创建并行处理流水线，任务级并行执行函数，需使用 DATAFLOW 编译指示。两者结合，实现高效并行计算。
Vitis HLS 学习笔记--AXI4 主接口
hi94的博客
04-28 1398
本文介绍了在使用 Vitis HLS 进行高层次综合时，利用 AXI4 存储器映射 (m_axi) 接口进行数据传输的方法和优势。首先，对于 MAXI 接口的认识和概述进行了阐述，MAXI 接口作为主动、全局、存储器级别的接口，提供了在 FPGA 内部和外部存储器之间高效传输数据的能力。接着，通过代码示例详细展示了如何在函数接口中使用 MAXI 接口进行数据传输，以及如何利用突发模式提高数据传输效率。
Vitis HLS 学习笔记--IDE软件高效操作指引
hi94的博客
04-27 1495
本文持续更新，分享一些实用操作指引，为提高使用Vitis HLS IDE效率。
ug1399-vitis-hls_HLS_
09-30
关于xilinx的vivado中的hls的学习资料
Vitis Vision - 利用Vitis HLS tcl shell 一键跑通视觉加速例程
03-18
Vitis Vision - 利用Vitis HLS tcl shell 一键跑通视觉加速例程
D1-05 Introduction to Vitis HLS-Frederic Rivoallon-region
11-02
D1_05 Introduction to Vitis HLS_Frederic Rivoallon_region
十大成长型思维：定位思维、商业思维、时间管理思维、学习成长思维、精力管理思维、逻辑表达思维、聚焦思维、金字塔原理、目标思维、反思思维
最新发布
limengshi138392的博客
06-15 606
十大成长型思维：定位思维、商业思维、时间管理思维、学习成长思维、精力管理思维、逻辑表达思维、聚焦思维、金字塔原理、目标思维、反思思维
如何学习Golang语言!
FengyangCoder的博客
06-09 404
起源与设计哲学：Go语言由Robert Griesemer、Rob Pike和Ken Thompson三位Google工程师设计，旨在解决现代编程中的一些常见问题，如编译速度、运行效率和并发编程。主要特点：Go语言的语法简单、编译速度快、运行效率高，支持静态类型和内存安全，具有垃圾回收功能，并且原生支持并发编程。
STM学习记录（四）———中断及NVIC
qq_63556165的博客
06-14 492
一个学习32单片机的小白~ 有问题评论或私信指出~提示：以下是本篇文章正文内容，下面案例可供参考在主程序运行过程中，出现了特定的中断触发条件（中断源），使得CPU暂停当前正在运行的程序，转去处理中断程序，处理完成后又返回被暂停的位置继续执行。1.中断就相当于我们人在处理事情时会先选择重要的事情去做处理完之后回到被打断的事情继续执行。
vitis hls vitis 区别
05-12
Vitis HLS和Vitis是Xilinx公司的两个软件产品，有一些不同之处。 Vitis HLS是一种高级综合工具，它能够将C、C++等高级语言的代码转换成硬件描述语言（如Verilog或VHDL）。使用Vitis HLS，开发人员可以通过高层次的语言进行开发，而无需直接编写硬件描述语言代码。这样可以提高开发效率，同时也可以降低硬件设计门槛。Vitis HLS主要用于FPGA应用程序的开发。 Vitis则是Xilinx公司的一个可编程开发环境，它提供了一个统一的软件平台来开发各种应用程序，包括FPGA加速器、SoC嵌入式系统等。Vitis包含了Vivado、Vitis HLS和PetaLinux三个主要工具，使得开发人员能够方便地进行从算法设计到硬件实现再到软件编程的全流程开发。Vitis可以在多种计算架构上运行，包括FPGA、GPU和CPU等。 总体来说，Vitis HLS和Vitis都是Xilinx公司的开发工具，但它们的使用场景和功能略有不同。Vitis HLS主要用于FPGA应用程序的开发，而Vitis则是一个更为综合的开发环境，用于各种应用程序的开发。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值