Raspberry Pi 4B+ IoT板上的并行计算变得简单

描述

我们的目标...

该项目提供了有用的指南、技巧和教程，用于在 C++17/2x0 中构建现代并行代码，使用 CL/SYCL 编程模型实现，并在下一代 Raspberry Pi 4B IoT 板上运行它，基于创新ARM Cortex-A72，四核，64 位 RISC-V CPU。

读者将了解如何设置开箱即用的 Raspberry 4B IoT 板，并将其用于并行计算，使用 Khronos CL/triSYCL 和 Aksel Alpay 提供 C++17 并行代码hipSYCL 项目的开源发行版，安装和配置 GNU 的编译器集合 (GCC) 和 LLVM/Clang-9.xx Arm/Aarch64-工具链，用于构建并行代码的可执行文件并在 Raspbian Buster 10.6 OS 中运行。

Raspberry PI 4B+ 物联网板概述

下一代创新的 Raspberry Pi 4B+ IoT 板基于强大的 ARM 多核对称 64 位 RISC-V CPU，提供了释放的性能，从而实现并行计算的终极生产力。使用最新的 Raspberry Pi 板可以显着提高边缘计算过程的实际性能加速，例如在将数据交付到数据中心进行处理之前实时收集和预处理数据，例如-规模。这些流程的并行运行显着提高了这些基于云的解决方案的效率，为数十亿的客户请求提供服务或提供数据分析和其他推理。

在我们开始讨论在 C++17 中构建和运行并行代码之前，使用 CL/SYCL 异构编程模型规范为具有 Arm/Aarch64 架构的 Raspberry Pi 板设计，让我们花点时间花点时间浏览下一代 Raspberry Pi 4B+ 板及其技术规格：

Raspberry Pi 4B+ IoT 板基于创新的 Broadcom BCM2711B0 (SoC) 芯片制造，配备最新的 ARM 四核 Cortex-A72 @ 1.5GHz 64 位 RISC-V CPU，提供终极性能和可扩展性，同时利用它用于边缘的并行计算。

Raspberry Pi 以“可靠”和“快速”的微型纳米计算机而闻名，专为数据挖掘和并行计算而设计。ARM 的多核对称 64 位 RISC-V CPU 的主要新硬件架构特性，如 DSP、SIMD、VFPv4 和硬件虚拟化支持，能够显着提高性能、加速速度和可扩展性。物联网集群，在边缘大规模处理数据。

具体来说，最新的 Raspberry Pi 4B+ 板最重要的优势之一是具有 2、4 或 8 GiB RAM 容量选择的薄型 LPDDR4 内存，以 3200Mhz 运行并提供典型的大内存事务带宽，对性能产生积极影响一般来说，并行计算。强烈推荐安装 4 GiB 或更高 RAM 的板卡用于数据挖掘和并行计算。此外，BCM2711B0 SoC 芯片与各种集成设备和外围设备捆绑在一起，例如 Broadcom VideoCore VI @ 500Mhz GPU、PCI-Ex 千兆以太网适配器等。

为了在 C++17 中构建和运行特定的并行现代代码，使用 CL/SYCL 异构编程模型实现，我们真正需要的第一个是安装和配置最新 Raspbian Buster 10.6 OS 的 Raspberry Pi 4B+ IoT 板第一次使用。

以下是必须事先满足的硬件和软件要求的简要清单：

硬件：

• 树莓派 4 型号 B0，4GB 物联网板；
• 用于 Raspbian 操作系统和数据存储的 16GB 微型 SD 卡；
• 直流电源：5.0V/2-3A，通过 USB Type-C 连接器（最低 3A - 用于数据挖掘和并行计算）；

软件：

• Raspbian Buster 10.6.0 完整操作系统；
• Raspbian Imager 1.4；
• MobaXterm 20.3 build 4396 或任何其他 SSH 客户端；

因为，我们有一个 Raspberry Pi 4B+ IoT 板，现在，我们可以继续打开它并进行设置，开箱即用。

设置 Raspberry Pi 4B 物联网板

在开始之前，我们必须从官方 Raspberry Pi 存储库下载最新版本的 Raspbian Buster 10.6.0 Full OS 映像。要将 Raspbian OS 映像安装到 SD 卡，我们还需要下载并使用 Raspbian Imager 1.4 应用程序，该应用程序可用于各种平台，例如 Windows、Linux 或 macOS：

• 树莓派克星 10.6.0
• Raspbian Imager 1.4

此外，我们还必须下载并安装 MobaXterm 应用程序，以通过 SSH 或 FTP 协议远程建立与 Raspberry Pi 板的连接：

• MobaXterm 20.3

由于 Raspbian Buster OS 和 Imager 应用程序已成功下载并安装，我们将使用 Imager 应用程序执行以下操作：

1. 擦除SD卡，默认格式化为FAT32文件系统；

2. 将预装的 Raspbian Buster OS 镜像 (*.img) 解压到 SD 卡中；

由于上述步骤已成功完成，只需从读卡器中取出 SD 卡并将其插入树莓派板的 SD 卡插槽即可。然后，连接 micro-HDMI 和以太网电缆。最后，插入直流电源线的连接器，然后打开电路板。最后，系统将使用安装到 SD 卡的 Raspbian Buster OS 启动，提示执行几个安装后步骤来配置它以供首次使用。

由于开发板已上电，请确保已完成以下所有安装后步骤：

1. 打开 bash 控制台并设置“root”密码：

pi@raspberrypi4:~ $ sudo passwd root

2. 使用“root”权限登录 Raspbian bash 控制台：

pi@raspberrypi4:~ $ sudo -s

3. 使用以下命令升级 Raspbian 的 Linux 基础系统和固件：

root@raspberrypi4:~# sudo apt update
root@raspberrypi4:~# sudo apt full-upgrade
root@raspberrypi4:~# sudo rpi-update

4. 重新启动系统，第一次：

root@raspberrypi4:~# sudo shutdown -r now

5. 安装最新的 Raspbian 的引导程序并重新启动系统，再次：

root@raspberrypi4:~# sudo rpi-eeprom-update -d -a
root@raspberrypi4:~# sudo shutdown -r now

6. 启动“raspi-config”设置工具：

root@raspberrypi4:~# sudo raspi-config

7. 使用“raspi-config”工具完成以下步骤：

* 更新 'raspi-config' 工具：

* 在启动时禁用 Raspbian 的桌面 GUI：

系统选项>>引导/自动登录>>控制台自动登录：

* 扩展 SD 卡上的根 '/' 分区大小：

执行 Raspbian 安装后配置后，最后重新启动系统。重新启动后，系统会提示您登录。使用之前设置的“root”用户名和密码，以 root 权限登录 bash 控制台。

由于您已成功登录，请在 bash-console 中使用以下命令从 APT-repositories 安装包的数量：

root@raspberrypi4:~# sudo apt install -y net-tools openssh-server

这两个软件包是配置 Raspberry Pi 的网络接口或 OpenSSH 服务器以使用 MobaXterm 通过 SSH 协议远程连接到开发板所必需的。

通过修改 /etc/network/interfaces 来配置板子的网络接口 'eth0'，例如：

auto eth0
iface eth0 inet static
address 192.168.87.100
netmask 255.255.255.0
broadcast 192.168.87.255
gateway 192.168.87.254
nameserver 192.168.87.254

在网络接口旁边，通过取消注释/etc/ssh/sshd_config中的这些行来执行 OpenSSH 服务器的基本配置：

PermitRootLogin yes
StrictModes no

PasswordAuthentication yes
PermitEmptyPasswords yes

这将启用“root”登录，通过 SSH 协议进入 bash 控制台，而无需输入密码。

最后，尝试通过网络连接开发板，使用 MobaXterm 应用程序并打开与 IP 地址为：192.168.87.100 的主机的远程 SSH 会话。您还必须能够使用先前设置的凭据成功登录到 Raspbian 的 bash 控制台：

使用 CL/SYCL-Model 在 C++17 中开发并行代码

2020 年，Khronos Group、英特尔公司和其他供应商宣布推出革命性的新型异构并行计算平台 (XPU)，能够将“繁重”数据处理工作负载的执行卸载到广泛的硬件加速（例如 GPGPU 或FPGAs) 目标，而不是主机 CPU。从概念上讲，使用 XPU 平台的并行代码开发完全基于 Khronos CL/SYCL 编程模型规范——OpenCL 2.0 库的抽象层。

这是一个小例子，展示了 C++17 中的代码，使用 CL/SYCL 模型抽象层实现：

#include <CL/sycl.hpp>

using namespace cl::sycl;

constexpr std::uint32_t N = 1000;

cl::sycl::queue q{};

q.submit([&](cl::sycl::handler &cgh) {
    cgh.parallel_for<class Kernel>(cl::sycl::range<1>{N}, \
       [=](cl::sycl::id<1> idx) {
           // Do some work in parallel
       });
});

q.wait();

上面显示的 C++17 中的代码片段完全基于使用 CL/SYCL 编程模型交付。它使用默认参数初始化器列表实例化一个 cl::sycl::queue{} 对象，用于提交 SYCL 内核、执行、主机 CPU 加速目标，默认使用。接下来，它调用 cl::sycl::submit(...) 方法，具有 cl::sycl::handler{} 对象的单个参数，用于访问提供基本内核功能的方法，基于各种并行算法，包括 cl::sycl::handler::parallel_for(...) 方法。

以下方法用于实现紧密的并行循环，从正在运行的内核中产生。此循环的每次迭代都由其自己的线程并行执行。cl::sycl::handler::parallel_for(...) 接受 cl::sycl::range<>{} 对象的两个主要参数和在每次循环迭代期间调用的特定 lamda 函数。cl::sycl::range<>{} 对象基本上为每个特定维度定义了并行循环迭代的数量，以防多个嵌套循环被折叠，同时处理多维数据。

在上面的代码中，cl::sycl::range<1>(N) 对象用于在一维中调度并行循环的 N 次迭代。parallel_for(...) 方法的 lambda 函数接受另一个 cl::sycl::id<>{} 对象的单个参数。与 cl::sycl::range<>{} 一样，该对象实现了一个向量容器，其中每个元素分别是并行循环的每个维度和每次迭代的索引值。作为参数传递给 lamda 函数范围内的代码，以下对象用于检索特定索引值。lamda 函数的主体包含一个代码，它可以并行执行一些数据处理。

在将特定内核提交到队列并生成执行后，以下代码会调用不带参数的 cl::sycl::wait() 方法来设置屏障同步，以确保到目前为止不会执行任何代码，直到生成的内核完成其并行工作。

CL/SYCL异构编程模型效率高，可用于广泛的应用。

但是，英特尔公司和 CodePlay 软件公司很快就弃用了对 x86_64 以外的硬件架构的 CL/SYCL 支持。这使得使用特定 CL/SYCL 库、针对 Arm/Aarch64 和其他架构的并行 C++ 代码变得不可能。

目前有大量的CL/SYCL开源库项目，由广大开发者和爱好者开发，提供对更多硬件架构的支持，而不仅仅是x86_64。

自 2016 年以来，Khronos Group, Inc. 发布了其 triSYCL 库开源项目 ( https://github.com/triSYCL/triSYCL) 的修订版，建议在评估最新的 CL/SYCL 编程模型层时将其用作测试平台规范并向 Khronos 和 ISO 委员会发送反馈。但是，以下库分发不是“稳定的”，只能用于演示目的，而不是用于在生产中构建 CL/SYCL 代码。此外，Khronos triSYCL 库发行版完全支持跨平台编译，在 x86_64 开发机器上，使用 GNU 的 Arm/Aarch64 跨平台工具链，而不是在 Raspberry 上使用 LLVM/Clang 编译器“本地”构建代码皮。

2019 年，海德堡大学（德国）的 Aksel Alpay 实现了最新的 CL/SYCL 编程模型层规范库，针对各种硬件架构，包括 Raspberry Pi 的 Arm/Aarch64 架构，并贡献了最“稳定”的版本将 hipSYCL 开源库分发到 GitHub ( https://github.com/illuhad/hipSYCL )。

此外，在这个故事中，我们将讨论安装和配置 GNU 的跨平台 GCC/G++-10.xx 和“本机”Arm/Aarch64 的 LLVM/Clang-9.xx 工具链，以及使用 triSYCL 和 hipSYCL 库发行版，用于在 C++17 中交付现代并行代码，基于使用库，正在讨论中。

在 Debian/Ubuntu 开发机 (x86_64) 和 Raspberry Pi IoT-Boards 上构建 CL/SYCL 代码

基本上有两种构建 CL/SYCL 代码的方法，在上面介绍的 C++17 中，使用 GNU 的 GCC/G++-10.xx 跨平台工具链和基于 x86_64 Debian/Ubuntu 的开发机器，或者， “本地”，在 Raspberry Pi IoT 板上，安装了用于 Arm/Aarch64 硬件架构的 LLVM/Clang-9.xx。

第一种方法的使用允许在基于 Debian/Ubuntu 的 x86_64 开发机器上使用 Khronos triSYCL 库和 GNU 的跨平台 Arm/Aarch64-toolchain 构建 C++17/2x0 代码源，之前在 Raspberry Pi 上运行它。

要部署 x86_64 开发机器，需要安装最新的 Debian Buster 10.6.0 或 Ubuntu 20.04 LTS：

• Debian 克星 10.6.0 x86_64
• Ubuntu 20.04 LTS x86_64

为了能够在运行 Microsoft Windows 10 的主机上使用开发机器，可以使用任何现有的（例如 Oracle VirtualBox 或 VMware Workstation）虚拟化环境，用于此目的：

• 适用于 Windows 10 64 位的 Oracle VirtualBox 6.1
• 适用于 Windows 10 64 位的 VMware Workstation 16

要开始部署开发机器，首先要做的是设置特定的虚拟化环境，创建虚拟机并启动 Debian 或 Ubuntu 安装。

既然已经创建了虚拟机，并且成功安装了 Debian/Ubuntu，我们可以继续进行几个步骤，安装和配置 GNU 的 GCC/G++-10.xx 跨平台编译器、开发工具和 Khronos triSYCL 库，构建代码所必需的，针对 Raspberry Pi 的 Arm/Aarch64 架构。

在安装和配置 GCC/G++ 编译器工具链和运行时库之前，请确保已完成以下先决步骤：

• 升级 Debian/Ubuntu 的 Linux 基础系统：

root@uarmhf64-dev:~# sudo apt update
root@uarmhf64-dev:~# sudo apt upgrade -y
root@uarmhf64-dev:~# sudo apt full-upgrade -y

需要完成此步骤，以确保在 x86_64 主机开发机器上运行的 Debian/Ubuntu 安装是最新的，并且安装了最新的内核和软件包。

• 从 APT-repository 安装 'net-tools' 和 OpenSSH-server 软件包：

root@uarmhf64-dev:~# sudo apt install -y net-tools openssh-server

安装“net-tools”和“openssh-server”是为了提供配置开发机器的网络接口并通过 SSH 和 FTP 协议远程连接到正在运行的开发机器的能力。

由于系统已经升级并安装了所有必需的软件包，我们可以继续安装和配置特定的编译器和工具链，然后。

安装和配置 GNU 的 GCC/G++-10.xx

1. 安装 GNU Compilers Collection (GCC) 的工具链，用于 x86_64 平台：

root@uarmhf64-dev:~# sudo apt install -y build-essential

2. 安装 GNU 的跨平台 Arm64/Armhf 工具链：

root@uarmhf64-dev:~# sudo apt install -y crossbuild-essential-arm64
root@uarmhf64-dev:~# sudo apt install -y crossbuild-essential-armhf

在 x86_64 开发机器上构建使用 triSYCL 库的 C++17 并行代码基本上需要安装用于 Arm64/Armhf 硬件架构的跨平台工具链。

3. 安装 GNU 的 GCC/G++、OpenMP 5.0、Boost、Range-v3、POSIX Threads、C/C++ 标准运行时库，需要：

root@uarmhf64-dev:~# sudo apt install -y g++-10 libomp-dev libomp5 libboost-all-dev librange-v3-dev libc++-dev libc++1 libc++abi-dev libc++abi1 libpthread-stubs0-dev libpthread-workqueue-dev

4. 安装 GNU 的 GCC/G++-10.xx 跨平台编译器，用于构建代码，针对 Arm64/Armhf 架构：

root@uarmhf64-dev:~# sudo apt install -y gcc-10-arm-linux-gnueabi g++-10-arm-linux-gnueabi gcc-10-arm-linux-gnueabihf g++-10-arm-linux-gnueabihf

5. 选择默认使用的 GCC/G++-10.xx “native” x86_64 编译器，更新备选方案：

sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-9 1
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-10 2
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-9 1
sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-10 2
sudo update-alternatives --install /usr/bin/cc cc /usr/bin/gcc 3
sudo update-alternatives --set cc /usr/bin/gcc
sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/g++ 3
sudo update-alternatives --set c++ /usr/bin/g++

6. 选择默认使用的 GCC/G++-10.xx 跨平台 Arm/Aarch64 编译器，更新备选方案：

sudo update-alternatives --install /usr/bin/arm-linux-gnueabihf-gcc arm-linux-gnueabihf-gcc /usr/bin/arm-linux-gnueabihf-gcc-9 1
sudo update-alternatives --install /usr/bin/arm-linux-gnueabihf-gcc arm-linux-gnueabihf-gcc /usr/bin/arm-linux-gnueabihf-gcc-10 2
sudo update-alternatives --install /usr/bin/arm-linux-gnueabihf-g++ arm-linux-gnueabihf-g++ /usr/bin/arm-linux-gnueabihf-g++-9 1
sudo update-alternatives --install /usr/bin/arm-linux-gnueabihf-g++ arm-linux-gnueabihf-g++ /usr/bin/arm-linux-gnueabihf-g++-10 2
sudo update-alternatives --install /usr/bin/arm-linux-gnueabihf-cc arm-linux-gnueabihf-cc /usr/bin/arm-linux-gnueabihf-gcc 3
sudo update-alternatives --set arm-linux-gnueabihf-cc /usr/bin/arm-linux-gnueabihf-gcc
sudo update-alternatives --install /usr/bin/arm-linux-gnueabihf-c++ arm-linux-gnueabihf-c++ /usr/bin/arm-linux-gnueabihf-g++ 3
sudo update-alternatives --set arm-linux-gnueabihf-c++ /usr/bin/arm-linux-gnueabihf-g++

7. 最后，检查是否安装了正确版本的 GNU 的“本机”和跨平台工具链：

root@uarmhf64-dev:~# gcc --version && g++ --version
root@uarmhf64-dev:~# arm-linux-gnueabihf-gcc --version
root@uarmhf64-dev:~# arm-linux-gnueabihf-g++ --version

8. 导航到 /opt 目录并从 GitHub 存储库克隆 Khronos triSYCL 库分发：

root@uarmhf64-dev:~# cd /opt
root@uarmhf64-dev:~# git clone --recurse-submodules https://github.com/triSYCL/triSYCL

以下命令将创建 /opt/triSYCL 子目录，其中包含 triSYCL 库分发的源代码。

9. 使用 'rsync' 命令将 triSYCL 库的 C++ 头文件从 /opt/triSYCL/include 目录复制到开发机器上的默认位置 /usr/include/c++/10/：

root@uarmhf64-dev:~# cd /opt/triSYCL
root@uarmhf64-dev:~# sudo rsync -r ./ include/ /usr/include/c++/10/

10. 设置环境变量，将 triSYCL 库与 GNU 的跨平台工具链一起使用所需的环境变量，之前已安装：

export CPLUS_INCLUDE_PATH=/usr/include/c++/10
env CPLUS_INCLUDE_PATH=/usr/include/c++/10
sudo echo "export CPLUS_INCLUDE_PATH=/usr/include/c++/10" >> /root/.bashrc

11. 通过删除 /opt/triSYCL 子目录执行简单的清理：

root@uarmhf64-dev:~# rm -rf /opt/triSYCL

12. 使用“本机”x86_64 GNU 的 GCC/G++ 编译器构建“hello.cpp”代码示例：

root@uarmhf64-dev:~# g++ -std=c++17 -o hello hello.cpp -lpthread -lstdc++

使用 Khronos triSYCL 库的 C++17/2x0 中的构建特定代码需要 POSIX 线程和 C++ 标准库运行时链接。

13. 使用 GNU 的跨平台 GCC/G++ 编译器构建“hello.cpp”代码示例：

root@uarmhf64-dev:~# arm-linux-gnueabihf-g++ -std=c++17 -o hello_rpi4b hello.cpp -lpthread -lstdc++

由于 Arm/Aarch64 架构的可执行代码已成功生成，请使用 MobaXterm 应用程序通过 FTP 或 SSH 协议从开发机器下载可执行文件。之后，使用另一个 SSH 会话将“hello_rpi4b”可执行文件上传到 Raspberry Pi 板。

要运行“hello_rpi4b”可执行文件，请在 Raspbian 的 bash 控制台中使用以下命令，例如：

root@uarmhf64-dev:~# chmod +rwx hello_rpi4b
root@uarmhf64-dev:~# ./hello_rpi4b > output.txt && cat output.txt

这将创建输出并将其附加到“output.txt”文件，将其内容打印到 bash 控制台：

Hello from triSYCL on Rasberry Pi 4B+!!!
Hello from triSYCL on Rasberry Pi 4B+!!!
Hello from triSYCL on Rasberry Pi 4B+!!!
Hello from triSYCL on Rasberry Pi 4B+!!!
Hello from triSYCL on Rasberry Pi 4B+!!!

注意：通常，第一种方法不需要从其源构建 Khronos triSYCL 库分发，除非您计划针对其他 HPC 库使用 triSYCL，例如 OpenCL、OpenMP 或 TBB。有关使用 triSYCL 以及其他库的更多信息，请参阅以下指南和文档https://github.com/triSYCL/triSYCL/blob/master/doc/cmake.rst

使用 Aksel Alpay 的 hipSYCL 开源库分发和 LLVM/Clang-9.xx “本机”编译器工具链，针对 Arm/Aarch64 架构，是第二种方法，允许在 C 中构建 CL/SYCL 代码++17/2x0，用于在 Raspberry Pi 板上运行它。只有在 LLVM/Clang-9.xx 工具链和 hipSYCL 库发行版都安装在 Raspberry Pi 板上而不是 x86_64 开发机器本身上的情况下，才能在本地构建特定代码。

此外，我们将讨论在 Raspberry Pi 板上安装和配置 LLVM/Clang-9.xx 编译器工具链以及从源代码构建 Aksel Alpay 的 hipSYCL 库所需了解的一切。

安装和配置 LLVM/Clang-9.xx

在使用 Aksel Alpay 的 hipSYCL 库项目的分发之前，必须正确安装和配置特定的 LLVM/Clang-9.xx 编译器和 Arm/Aarch64 工具链。为此，请确保您已完成下列步骤：

1. 更新 Raspbian 的 APT-repositories 并安装以下必备软件包：

root@raspberrypi4:~# sudo apt update
root@raspberrypi4:~# sudo apt install -y bison flex python python3 snap snapd git wget

上面的命令将安装一个替代的 'snap' 包管理器，安装正确版本的 cmake >= 3.18.0 实用程序，以及 'python'、'python3' 发行版和 'bison'、'flex ' 实用程序，需要使用“cmake”实用程序从“头开始”构建 hipSYCL 开源项目。

2. 使用 'snap' 包管理器安装 'cmake' >= 3.18.0 实用程序和 LLVM/Clang 守护程序：

root@raspberrypi4:~# sudo snap install cmake --classic
root@raspberrypi4:~# sudo snap install clangd --classic

安装 'cmake' 实用程序后，让我们使用以下命令检查它是否工作以及是否已从 'snap'-repository 安装了正确的版本：

root@raspberrypi4:~# sudo cmake --version

运行此命令后，您必须看到以下输出：

cmake version 3.18.4

CMake suite maintained and supported by Kitware (kitware.com/cmake).

3. 为 LLVM/Clang 工具链安装最新的 Boost、POSIX-Threads 和 C/C++ 标准运行时库：

root@raspberrypi4:~# sudo apt install -y libc++-dev libc++1 libc++abi-dev libc++abi1 libpthread-stubs0-dev libpthread-workqueue-dev

root@raspberrypi4:~# sudo apt install -y clang-format clang-tidy clang-tools clang libc++-dev libc++1 libc++abi-dev libc++abi1 libclang-dev libclang1 liblldb-dev libllvm-ocaml-dev libomp-dev libomp5 lld lldb llvm-dev llvm-runtime llvm python-clang libboost-all-dev

4. 下载并添加 LLVM/Clang 的 APT-repositories 安全密钥：

root@raspberrypi4:~# wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -

5. 将 LLVM/Clang 的存储库 URL 附加到 APT 的 sources.list：

root@raspberrypi4:~# echo "deb http://apt.llvm.org/buster/ llvm-toolchain-buster main" >> /etc/apt/sources.list.d/raspi.list

root@raspberrypi4:~# echo "deb-src http://apt.llvm.org/buster/ llvm-toolchain-buster main" >> /etc/apt/sources.list.d/raspi.list

必须完成前面的这两个步骤 4 和 5，才能从特定的 APT 存储库安装 LLVM/Clang-9.xx 编译器和特定工具链。

6. 删除先前安装的 LLVM/Clang 版本的现有符号链接：

root@raspberrypi4:~# cd /usr/bin && rm -f clang clang++

7. 再次更新 APT 存储库，并安装 LLVM/Clang 的编译器、调试器和链接器：

root@raspberrypi4:~# sudo apt update
root@raspberrypi4:~# sudo apt install -y clang-9 lldb-9 lld-9

8. 创建到 'clang-9' 和 'clang++-9' 编译器的相应符号链接，安装：

root@raspberrypi4:~# cd /usr/bin && ln -s clang-9 clang
root@raspberrypi4:~# cd /usr/bin && ln -s clang++-9 clang++

9. 最后，您必须能够在 bash-console 中使用“clang”和“clang++”命令：

root@raspberrypi4:~# clang --version && clang++ --version

在这里，让我们使用上面的命令检查已安装的 LLVM/Clang 的版本。

使用命令后，您必须看到以下输出：

clang version 9.0.1-6+rpi1~bpo10+1
Target: armv6k-unknown-linux-gnueabihf
Thread model: posix
InstalledDir: /usr/bin
clang version 9.0.1-6+rpi1~bpo10+1
Target: armv6k-unknown-linux-gnueabihf
Thread model: posix
InstalledDir: /usr/bin

下载和构建 hipSYCL 库分发

另一个重要步骤是从其源代码下载并构建开源 hipSYCL 库暂存发行版，并贡献给 GitHub。

这通常通过完成以下步骤来完成，如下所示：

1. 下载 hipSYCL 项目的发行版，从 GitHub 克隆它：

root@raspberrypi4:~# git clone https://github.com/llvm/llvm-project llvm-project
root@raspberrypi4:~# git clone --recurse-submodules https://github.com/illuhad/hipSYCL

Aksel Alpay 的 hipSYCL 项目的发行版有几个依赖于另一个 LLVM/Clang 的开源项目。这就是为什么，我们通常需要克隆这两个发行版，以便从“零开始”构建 hipSYCL 库运行时。

2. 使用“export”和“env”命令设置从源代码构建 hipSYCL 项目所需的环境变量数量，并将以下特定行附加到 .bashrc 配置文件脚本：

export LLVM_INSTALL_PREFIX=/usr
export LLVM_DIR=~/llvm-project/llvm
export CLANG_EXECUTABLE_PATH=/usr/bin/clang++
export CLANG_INCLUDE_PATH=$LLVM_INSTALL_PREFIX/include/clang/9.0.1/include

echo "export LLVM_INSTALL_PREFIX=/usr" >> /root/.bashrc
echo "export LLVM_DIR=~/llvm-project/llvm" >> /root/.bashrc
echo "export CLANG_EXECUTABLE_PATH=/usr/bin/clang++" >> /root/.bashrc
echo "export CLANG_INCLUDE_PATH=$LLVM_INSTALL_PREFIX/include/clang/9.0.1/include" >> /root/.bashrc

env LLVM_INSTALL_PREFIX=/usr
env LLVM_DIR=~/llvm-project/llvm
env CLANG_EXECUTABLE_PATH=/usr/bin/clang++
env CLANG_INCLUDE_PATH=$LLVM_INSTALL_PREFIX/include/clang/9.0.1/include

3. 创建并切换到 hipSYCL 项目主目录下的 ~/hipSYCL/build 子目录：

root@raspberrypi4:~# mkdir ~/hipSYCL/build && cd ~/hipSYCL/build

4. 使用“cmake”实用程序配置 hipSYCL 项目的源代码：

root@raspberrypi4:~# cmake -DCMAKE_INSTALL_PREFIX=/opt/hipSYCL ..

5. 使用 GNU 的“make”命令构建和安装 hipSYCL 运行时库：

root@raspberrypi4:~# make -j $(nproc) && make install -j $(nproc)

6. 将 libhipSYCL-rt.iso 运行时库复制到 Raspbian 的默认库位置：

root@raspberrypi4:~# cp /opt/hipSYCL/lib/libhipSYCL-rt.so /usr/lib/libhipSYCL-rt.so

7. 设置使用 hipSYCL 运行时库和 LLVM/Clang 编译器构建源代码所需的环境变量：

export PATH=$PATH:/opt/hipSYCL/bin
export C_INCLUDE_PATH=$C_INCLUDE_PATH:/opt/hipSYCL/include
export CPLUS_INCLUDE_PATH=$CPLUS_INCLUDE_PATH:/opt/hipSYCL/include
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/hipSYCL/lib

echo "export PATH=$PATH:/opt/hipSYCL/bin" >> /root/.bashrc
echo "export C_INCLUDE_PATH=$C_INCLUDE_PATH:/opt/hipSYCL/include" >> /root/.bashrc
echo "export CPLUS_INCLUDE_PATH=$CPLUS_INCLUDE_PATH:/opt/hipSYCL/include" >> /root/.bashrc
echo "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/hipSYCL/lib" >> /root/.bashrc

env PATH=$PATH:/opt/hipSYCL/bin
env C_INCLUDE_PATH=$C_INCLUDE_PATH:/opt/hipSYCL/include
env CPLUS_INCLUDE_PATH=$CPLUS_INCLUDE_PATH:/opt/hipSYCL/include
env LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/hipSYCL/lib

在 Raspberry Pi 4B+ 上以 C++17 运行并行 CL/SYCL 代码

因为，我们终于完成了安装和配置 LLVM/Clang 和 hipSYCL 库的准备工作，强烈建议构建和运行“matmul_hipsycl”示例的可执行文件，确保一切正常：

以下是从源代码构建以下示例的最常见步骤：

rm -rf ~/sources
mkdir ~/sources && cd ~/sources
cp ~/matmul_hipsycl.tar.gz ~/sources/matmul_hipsycl.tar.gz
tar -xvf matmul_hipsycl.tar.gz
rm -f matmul_hipsycl.tar.gz

上面的一组命令将创建 ~/source 子目录并从 matmul_hipsycl.tar.gz 档案中提取样本的源代码。

要构建示例的可执行文件，只需使用 GNU 的“make”命令：

root@raspberrypi4:~# make all

这将调用“clang++”命令来构建可执行文件：

syclcc-clang -O3 -std=c++17 -o matrix_mul_rpi4 src/matrix_mul_rpi4b.cpp -lstdc++

此命令将编译具有最高代码优化级别（例如 -O3）的特定 C++17 代码，启用并将其与 C++ 标准库运行时链接。

注意：除了库运行时，构建的 hipSYCL 项目还提供了“syclcc”和“syclcc-clang”工具，用于在 C++17 中构建并行代码，使用 hipSYCL 库实现。这些工具的使用与“clang”和“clang++”命令的常规使用略有不同。但是，仍然可以使用“syclcc”和“syclcc-clang”，指定与原始“clang”和“clang++”命令相同的编译器和链接器选项。

使用这些工具执行编译后，只需将执行权限授予编译器生成的“matrix_mul_rpi4”文件，使用以下命令：

root@raspberrypi4:~# chmod +rwx matrix_mul_rpi4

，并且，只需在 bash 控制台中运行可执行文件：

root@raspberrypi4:~# ./matrix_mul_rpi4

运行后，执行将得到以下输出：

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

Multiplication C = A x B:

Matrix C:

323 445 243 343 363 316 495 382 463 374
322 329 328 388 378 395 392 432 470 326
398 357 337 366 386 407 478 457 520 374
543 531 382 470 555 520 602 534 639 505
294 388 277 314 278 330 430 319 396 372
447 445 433 485 524 505 604 535 628 509
445 468 349 432 511 391 552 449 534 470
434 454 339 417 502 455 533 498 588 444
470 340 416 364 401 396 485 417 496 464
431 421 325 325 272 331 420 385 419 468


Execution time: 5 ms

或者，我们可以评估并行代码的性能，通过安装和使用以下实用程序来执行：

root@raspberrypi4:~# sudo apt install -y top htop

在运行并行代码可执行文件时，使用已安装的“htop”实用程序可视化 CPU 和系统内存利用率：

综上所述...

微型 FPGA 以及具有计算能力的袖珍型 GPGPU，通过 GPIO 或 USB 接口从外部连接到物联网板，是物联网并行计算的下一个巨大步骤。使用微型 FPGA 和 GPGPU 提供了一个机会，可以并行执行更复杂和“繁重”的计算，从而大大提高实际性能加速，同时实时处理大量大数据。

显然，物联网并行计算的另一个重要方面是继续开发特定的库和框架，提供 CL/SYCL 模型层规范，从而支持异构计算平台 (XPU)。目前，这些库的最新版本支持将并行代码执行卸载到主机 CPU 加速目标，只是因为尚未设计其他加速硬件，例如用于纳米计算机的小型 GPGPU 和 FPGA并由其供应商在此时制造。

事实上，使用 Raspberry Pi 和其他特定 IoT 板进行并行计算是软件开发人员和硬件技术人员的一个特殊兴趣点，对现有计算过程进行性能评估，同时与 IoT 并行运行。

总之，利用基于物联网的并行计算通常有利于基于云的解决方案的整体性能，旨在实时收集和大规模处理大数据，从而对机器学习的质量产生积极影响(ML) 和数据分析本身。