<think>我们要求写一段可以在Vivado HLS
2023.2中运行的HLS代码。由于HLS代码通常用于硬件加速，我们可以选择一个常见的例子：向量加法。
我们将编写一个简单的向量加法函数，并
添加必要的指令（如接口协议）以便在硬件中实现。
同时，为了确保代码可以在HLS中运行，我们还需要一个测试台（test bench）。但是，根据要求，我们只写HLS代码（即要被综合的函数），测试台可以另外要求。
不过，为了完整，我们可以同时提供函数和简单的测试台代码，但注意用户要求是“HLS代码”，通常指的是硬件函数部分。但为了运行，测试台也是必要的。因此，我们分开写。
由于用户没有指定具体功能，我们实现一个向量加法器：
void vector_add
(int *a, int *b, int *c, int length
)
其中，a和b是输入向量，c是输出向量，length是向量的长度。
我们将使用HLS中常用的优化指令，比如设置接口为AXI4-Stream或者使用pipeline等。但为了简单，我们先实现一个基础版本，然后
添加一些基本指令。
注意：在Vivado HLS中，我们需要使用特定的编译指示（pragmas）来指定硬件接口和优化。
我们假设使用AXI4-Lite接口控制，使用AXI4-Stream传输数据。但为了简单，我们也可以使用简单的RAM接口（即指针）。根据要求，我们可以选择：
方案1：使用简单的指针接口（默认是RAM接口）。
方案
2：使用AXI4-Stream接口（需要包含hls_stream
.h）。
这里我们先用方案1，因为简单。
但是，用户要求是
2023.2版本，所以我们可以使用最新的语法。
另外，我们还需要注意，在HLS中，循环的优化非常重要，因此我们会
添加一些循环优化指令。
下面我们给出代码：
1
. 硬件函数（vector_add
.h和vector_add
.cpp）的代码
2. 测试台代码（test_vector_add
.cpp）
但是，由于用户只要求写一段HLS代码，我们主要提供硬件函数部分，测试台可以另外提供。但为了运行，我们一并给出。
根据HLS项目结构，通常包括：
- 顶层函数（在
.cpp文件中）
-
头文件（
.h文件）
- 测试台文件（_test
.cpp）
我们这里将分别写出来。
注意：在Vivado HLS
2023.2中，我们可以使用C++或C。这里使用C++，因为更容易使用流等高级特性（虽然我们这里不用流）。
下面我们写一个简单的向量加法，使用双精度浮点数（也可以改成整数，但为了通用性，我们用整数）。我们假设使用int类型。
步骤：
1
. 头文件定义函数
2. 源文件实现函数，并
添加必要的编译指示
3
. 测试台代码
但是，由于用户要求只写一段代码，我们可以将函数和测试台放在一起？通常不推荐，但为了简洁，我们可以先写函数，再写测试台，并说明如何分离。
不过，我们按照HLS项目的要求分开写两段代码：设计代码和测试代码。
设计代码（综合用）：
```cpp
// 文件名：vector_add
.h
#ifndef VECTOR_ADD_H_
#define VECTOR_ADD_H_
#
include <ap_int
.h> // 如果需要使用固定位宽整数，可以包含，这里我们用int
#define N 10
24 // 可以定义向量长度，或者通过参数传入
void vector_add
(int a[N], int b[N], int c[N]
);
#endif
```
```cpp
// 文件名：vector_add
.cpp
#
include "vector_add
.h"
void vector_add
(int a[N], int b[N], int c[N]
) {
#pragma HLS INTERFACE s_axilite port=return bundle=CONTROL_BUS
#pragma HLS INTERFACE s_axilite port=a bundle=CONTROL_BUS
#pragma HLS INTERFACE s_axilite port=b bundle=CONTROL_BUS
#pragma HLS INTERFACE s_axilite port=c bundle=CONTROL_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=a offset=slave bundle=DATA_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=b offset=slave bundle=DATA_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=c offset=slave bundle=DATA_BUS
for
(int i = 0; i < N; i++
) {
#pragma HLS PIPELINE
c[i] = a[i] + b[i];
}
}
```
但是，上面的接口设置比较复杂，我们也可以使用默认的RAM接口，而不使用AXI4接口。对于初学者，我们可以简化接口：
我们可以使用以下编译指示来设置接口为AXI4-Lite（用于控制）和AXI4（用于数据）的混合。但注意，如果数据量较大，我们通常使用AXI4主接口（m_axi）来传输数据，而控制信号用AXI4-Lite。
然而，我们也可以使用更简单的方式：使用bram接口（即默认的ram接口），但这样在IP集成时需要连接BRAM控制器。
为了简单，我们只使用最简单的接口：使用ap_fixed端口，但这里我们不用。我们使用默认的接口，不
添加任何编译指示，那么接口将是ap_hs（握手协议）或ap_vld（有效信号）等，这取决于数组参数。
但是，为了能够在Zynq上使用，我们通常需要AXI接口。因此，我们使用上述的编译指示来设置AXI接口。
然而，上面的编译指示可能过于复杂，我们也可以只使用：
```cpp
#pragma HLS INTERFACE s_axilite port=return
#pragma HLS INTERFACE s_axilite port=a
#pragma HLS INTERFACE s_axilite port=b
#pragma HLS INTERFACE s_axilite port=c
```
这样，数组a、b、c将被视为AXI4-Lite接口上的寄存器。但注意，AXI4-Lite适合小数据量（因为每个地址对应3
2位，且只能顺序访问，而且数据量不能太大）。对于大数据，我们使用m_axi接口。
因此，我们修改为：
使用AXI4-Lite控制信号，使用AXI4主接口传输数据。所以，我们使用两个接口：一个AXI4-Lite用于控制（包括函数返回和标量参数），一个AXI4主接口用于传输数组。
但是，我们如何将同一个数组参数同时映射到两个接口？实际上，在HLS中，我们通常将数组放在主存（如DDR）中，通过AXI4主接口访问，而控制信号（如启动、完成等）通过AXI4-Lite。
因此，我们需要将数组参数设置为m_axi，而将length设置为s_axilite（如果length是参数的话）。但这里我们固定了长度N，所以没有length参数。
修改后的代码：
```cpp
// vector_add
.cpp
#
include "vector_add
.h"
void vector_add
(int *a, int *b, int *c
) {
#pragma HLS INTERFACE s_axilite port=return bundle=CONTROL_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=a offset=slave bundle=DATA_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=b offset=slave bundle=DATA_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=c offset=slave bundle=DATA_BUS
int local_a[N];
int local_b[N];
int local_c[N];
// 从全局内存读取数据到本地
memcpy
(local_a, a, N * sizeof
(int
));
memcpy
(local_b, b, N * sizeof
(int
));
for
(int i = 0; i < N; i++
) {
#pragma HLS PIPELINE
local_c[i] = local_a[i] + local_b[i];
}
// 将结果写回全局内存
memcpy
(c, local_c, N * sizeof
(int
));
}
```
但是，使用本地数组需要消耗大量的BRAM资源（每个数组10
24个int，即4KB，三个数组共1
2KB）。我们可以不用本地数组，而是通过优化访问：
我们可以通过循环，每次从a和b中读取一个数，然后相加，再写入c。这样，我们可以使用流水线，并且不需要本地数组：
```cpp
void vector_add
(int *a, int *b, int *c
) {
#pragma HLS INTERFACE s_axilite port=return bundle=CONTROL_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=a offset=slave bundle=DATA_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=b offset=slave bundle=DATA_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=c offset=slave bundle=DATA_BUS
for
(int i = 0; i < N; i++
) {
#pragma HLS PIPELINE
// 从a和b中读取数据
int a_val = a[i];
int b_val = b[i];
c[i] = a_val + b_val;
}
}
```
但是，由于m_axi接口的延迟，直接这样访问可能会造成性能问题。通常，我们会使用突发传输（burst transfer）来优化，而HLS在循环中访问数组时会自动优化为突发传输，前提是访问是顺序的。
所以，上面的代码是可行的。
现在，我们提供完整的代码（包括测试台）。
注意：由于我们使用了指针，测试台需要分配内存并初始化。
设计代码（综合用）：
```cpp
// vector_add
.h
#ifndef VECTOR_ADD_H_
#define VECTOR_ADD_H_
#
include <ap_fixed
.h> // 这里我们不需要，但为了后续扩展可以包含
const int N = 10
24; // 注意：在
头文件中定义常量，以便测试台使用
void vector_add
(int *a, int *b, int *c
);
#endif
```
```cpp
// vector_add
.cpp
#
include "vector_add
.h"
void vector_add
(int *a, int *b, int *c
) {
// 设置接口
#pragma HLS INTERFACE s_axilite port=return bundle=CONTROL_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=a offset=slave bundle=DATA_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=b offset=slave bundle=DATA_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=c offset=slave bundle=DATA_BUS
for
(int i = 0; i < N; i++
) {
#pragma HLS PIPELINE II=1
// 读取数据
int a_val = a[i];
int b_val = b[i];
c[i] = a_val + b_val;
}
}
```
测试台代码：
```cpp
// test_vector_add
.cpp
#
include <iostream>
#
include "vector_add
.h"
int main
() {
int a[N], b[N], c[N], expected[N];
// 初始化数据
for
(int i = 0; i < N; i++
) {
a[i] = i;
b[i] = i *
2;
expected[i] = a[i] + b[i];
}
// 调用被测函数
vector_add
(a, b, c
);
// 检查结果
int errors = 0;
for
(int i = 0; i < N; i++
) {
if
(c[i] != expected[i]
) {
errors++;
std::cout << "Error at index " << i << ": expected " << expected[i] << ", got " << c[i] << std::endl;
}
}
if
(errors == 0
) {
std::cout << "Test passed!" << std::endl;
return 0;
} else {
std::cout << "Test failed with " << errors << " errors
." << std::endl;
return 1;
}
}
```
在Vivado HLS
2023.2中创建项目：
-
添加源文件：vector_add
.cpp
-
添加头文件：vector_add
.h
-
添加测试台：test_vector_add
.cpp
然后运行C仿真、综合等。
注意：上面的代码中，我们在
头文件中定义了N，这样测试台和设计代码使用相同的N。
但是，在综合时，我们可能需要将N作为参数传入，而不是固定为10
24。我们可以修改代码，将N作为参数传入，但需要是常量。或者使用模板参数，但HLS支持C++模板。
由于用户要求简单，我们使用固定长度。
另外，上面的接口编译指示中，我们使用了`bundle=CONTROL_BUS`和`bundle=DATA_BUS`，这样相同bundle的信号会被分组到同一个接口。如果不指定，则每个端口都会生成单独的接口。
在Vivado HLS中，我们也可以不指定bundle，那么会生成多个接口，但为了在Zynq中集成方便，通常分组到同一个接口。
因此，我们这样写。
最后，我们提供完整的代码，并确保在Vivado HLS
2023.2中可以运行。
注意：由于我们使用的是m_axi接口，在测试台环境中，数组a、b、c必须分配在可被DMA访问的内存中。在测试台中，我们使用普通数组，在C仿真中是可以的。但在实际硬件测试时，需要确保这些数组位于FPGA可以访问的物理内存中。
现在，我们给出最终代码。
但是，用户要求只写一段代码，我们可以将设计代码和测试台代码分开描述。但这里我们只写设计代码（即硬件函数）和
头文件，测试台另外提供。
因此，我们只提供设计代码（vector_add
.h和vector_add
.cpp）的内容。
由于在回答中，我们可以将两段代码合并展示，但为了清晰，我们分开。
头文件：
```cpp
#ifndef VECTOR_ADD_H_
#define VECTOR_ADD_H_
const int N = 10
24;
void vector_add
(int *a, int *b, int *c
);
#endif
```
源文件（设计代码）：
```cpp
#
include "vector_add
.h"
void vector_add
(int *a, int *b, int *c
) {
#pragma HLS INTERFACE s_axilite port=return bundle=CONTROL_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=a offset=slave bundle=DATA_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=b offset=slave bundle=DATA_BUS
#pragma HLS INTERFACE m_axi depth=10
24 port=c offset=slave bundle=DATA_BUS
for
(int i = 0; i < N; i++
) {
#pragma HLS PIPELINE II=1
int a_val = a[i];
int b_val = b[i];
c[i] = a_val + b_val;
}
}
```
测试台代码（供参考，不包含在用户要求的“HLS代码”中，但为了运行需要）已经在上面提供。
注意：在Vivado HLS中，我们可能需要指定目标设备，但代码本身不依赖。
现在，我们完成了。
注意：在Vivado HLS
2023.2中，如果运行C仿真，测试台应该输出“Test passed!”。
如果遇到问题，请检查编译指示是否正确，以及测试台是否包含正确的
头文件。
最后，我们按照要求，在最后提出相关问题。</think>以下是一个可以在 Vivado HLS
2023.2 中运行的完整 HLS 示例代码，实现了一个简单的向量加法功能，并包含测试台验证：
### 向量加法 HLS 设计
####
头文件 (`vector_add
.h`
)
```cpp
#ifndef VECTOR_ADD_H_
#define VECTOR_ADD_H_
#
include <ap_int
.h>
#
include <hls_stream
.h>
// 使用模板支持不同数据类型
template <typename T, int N>
void vector_add
(T a[N], T b[N], T c[N]
) {
#pragma HLS INTERFACE s_axilite port=return bundle=control
#pragma HLS INTERFACE s_axilite port=a bundle=control
#pragma HLS INTERFACE s_axilite port=b bundle=control
#pragma HLS INTERFACE s_axilite port=c bundle=control
#pragma HLS INTERFACE m_axi depth=N port=a offset=slave bundle=gmem
#pragma HLS INTERFACE m_axi depth=N port=b offset=slave bundle=gmem
#pragma HLS INTERFACE m_axi depth=N port=c offset=slave bundle=gmem
for
(int i = 0; i < N; i++
) {
#pragma HLS PIPELINE II=1
c[i] = a[i] + b[i];
}
}
// 使用AXI Stream接口的版本
template <typename T, int N>
void vector_add_stream
(
hls::stream<T> &a_stream,
hls::stream<T> &b_stream,
hls::stream<T> &c_stream
) {
for
(int i = 0; i < N; i++
) {
#pragma HLS PIPELINE II=1
T a_val = a_stream
.read
();
T b_val = b_stream
.read
();
c_stream
.write
(a_val + b_val
);
}
}
#endif
```
#### 设计实现
(`vector_add
.cpp`
)
```cpp
#
include "vector_add
.h"
// 显式实例化模板（支持不同数据类型和长度）
template void vector_add<int, 10
24>
(int a[10
24], int b[10
24], int c[10
24]
);
template void vector_add<float, 51
2>
(float a[51
2], float b[51
2], float c[51
2]
);
template void vector_add_stream<int, 10
24>
(
hls::stream<int> &a_stream,
hls::stream<int> &b_stream,
hls::stream<int> &c_stream
);
```
#### 测试台
(`test_vector_add
.cpp`
)
```cpp
#
include <iostream>
#
include <cstdlib>
#
include "vector_add
.h"
#define TEST_SIZE 10
24
int main
() {
// 内存接口测试
int a_mem[TEST_SIZE];
int b_mem[TEST_SIZE];
int c_mem[TEST_SIZE];
int expected_mem[TEST_SIZE];
// 初始化测试数据
for
(int i = 0; i < TEST_SIZE; i++
) {
a_mem[i] = i;
b_mem[i] = i *
2;
expected_mem[i] = a_mem[i] + b_mem[i];
}
// 调用设计函数
vector_add<int, TEST_SIZE>
(a_mem, b_mem, c_mem
);
// 验证结果
int errors = 0;
for
(int i = 0; i < TEST_SIZE; i++
) {
if
(c_mem[i] != expected_mem[i]
) {
std::cerr << "Error at index " << i
<< ": expected " << expected_mem[i]
<< ", got " << c_mem[i] << std::endl;
errors++;
}
}
// AXI Stream接口测试
hls::stream<int> a_stream, b_stream, c_stream;
// 填充流数据
for
(int i = 0; i < TEST_SIZE; i++
) {
a_stream
.write
(i
);
b_stream
.write
(i * 3
);
}
// 调用流版本函数
vector_add_stream<int, TEST_SIZE>
(a_stream, b_stream, c_stream
);
// 验证流结果
for
(int i = 0; i < TEST_SIZE; i++
) {
int result = c_stream
.read
();
int expected = i +
(i * 3
);
if
(result != expected
) {
std::cerr << "Stream error at index " << i
<< ": expected " << expected
<< ", got " << result << std::endl;
errors++;
}
}
// 测试总结
if
(errors == 0
) {
std::cout << "Test passed successfully!" << std::endl;
return 0;
} else {
std::cerr << "Test failed with " << errors << " errors" << std::endl;
return 1;
}
}
```
### 代码解释
1
. **接口定义**：
- `#pragma HLS INTERFACE`：定义硬件接口协议
- `s_axilite`：用于控制信号的AXI-Lite接口
- `m_axi`：用于大数据传输的AXI4主接口
- `hls::stream`：用于流式数据传输
2. **优化指令**：
- `#pragma HLS PIPELINE II=1`：实现流水线操作，每周期处理一个元素
- `#pragma HLS INTERFACE bundle`：将信号分组到同一接口
3
. **模板设计**：
- 支持不同数据类型（int/float）和向量长度
- 显式实例化避免链接错误
4
. **测试功能**：
- 同时测试内存接口和流接口版本
- 自动验证结果并输出错误信息
- 返回0表示成功，1表示失败
### Vivado HLS 使用步骤
1
. 创建新项目：
- 选择目标设备（如 xc7z0
20clg400-1）
-
添加源文件（vector_add
.h, vector_add
.cpp）
-
添加测试台（test_vector_add
.cpp）
2. 运行C仿真：
```bash
vitis_hls -f run_hls
.tcl
```
3
. 综合与实现：
- 在GUI中点击"C Synthesis"
- 完成后点击"Export RTL"
### 注意事项
1
. 接口协议：
- 使用AXI-Lite用于控制信号
- 使用AXI4主接口用于大数据传输
- 流接口适合顺序数据访问
2. 资源优化：
- 使用`#pragma HLS PIPELINE`提高吞吐量
- 使用`#pragma HLS ARRAY_PARTITION`可分割大数组
- 使用`#pragma HLS DATAFLOW`实现任务级并行
3
. 数据对齐：
- 确保数据地址对齐到64位边界
- 使用`memalign
(64
)`分配内存
扫一扫
6277
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
