面向 aarch64 的交叉编译

概述

本示例展示了如何在 x86_64 主机中构建应用程序，目标设备为使用 aarch64 架构的 Jetson 设备。它使用了 cmake-3.5 中首次提供的几个特性。示例应用程序本身会创建一个输入图像，对其应用盒状滤波器，并将结果保存到磁盘。

说明

JetPack 的安装程序已经使用 gcc 设置了交叉编译工具链，但如果由于某些原因它不可用，请使用以下命令手动安装：

apt-get install gcc-aarch64-linux-gnu g++-aarch64-linux-gnu

现在可以指示 cmake 通过在 samples 目录中调用以下命令来创建交叉编译构建树

cmake . -DCMAKE_TOOLCHAIN_FILE=Toolchain_aarch64_l4t.cmake

文件 Toolchain_aarch64_l4t.cmake 包含在 samples 目录中，并定义了将要使用的交叉编译器以及其他配置。特别是，它还允许 CUDA 应用程序的交叉编译，前提是 CUDA aarch64 交叉编译库已正确安装在主机上。

注意

此示例也可以编译为目标主机。只需在 cmake 调用期间省略 CMAKE_TOOLCHAIN_FILE 参数即可。

用法是

./vpi_sample_08_cross_aarch64_l4t <后端>

其中

• backend：cpu、cuda 或 pva 之一；它定义了将执行处理的后端。

源代码

为了方便起见，这里提供了也安装在 samples 目录中的代码。

语言 C++

#include <vpi/Image.h>
#include <vpi/Status.h>
#include <vpi/Stream.h>
#include <vpi/algo/BoxFilter.h>

#include <cstring> // for memset
#include <fstream>
#include <iostream>
#include <sstream>

#define CHECK_STATUS(STMT) \
 do \
 { \
 VPIStatus status = (STMT); \
 if (status != VPI_SUCCESS) \
 { \
 char buffer[VPI_MAX_STATUS_MESSAGE_LENGTH]; \
 vpiGetLastStatusMessage(buffer, sizeof(buffer)); \
 std::ostringstream ss; \
 ss << vpiStatusGetName(status) << ": " << buffer; \
 throw std::runtime_error(ss.str()); \
 } \
 } while (0);

int main(int argc, char *argv[])
{
 // VPI objects that will be used
 VPIImage image = NULL;
 VPIImage blurred = NULL;
 VPIStream stream = NULL;

 int retval = 0;

 try
 {
 if (argc != 2)
 {
 throw std::runtime_error(std::string("Usage: ") + argv[0] + " <cpu|pva|cuda>");
 }

 std::string strBackend = argv[1];

 // Now parse the backend
 VPIBackend backend;

 if (strBackend == "cpu")
 {
 backend = VPI_BACKEND_CPU;
 }
 else if (strBackend == "cuda")
 {
 backend = VPI_BACKEND_CUDA;
 }
 else if (strBackend == "pva")
 {
 backend = VPI_BACKEND_PVA;
 }
 else
 {
 throw std::runtime_error("Backend '" + strBackend +
 "' not recognized, it must be either cpu, cuda or pva.");
 }

 // Create the stream for the given backend.
 CHECK_STATUS(vpiStreamCreate(backend, &stream));

 char imgContents[512][512];
 for (int i = 0; i < 512; ++i)
 {
 for (int j = 0; j < 512; ++j)
 {
 imgContents[i][j] = i * 512 + j + i;
 }
 }

 // We now wrap the loaded image into a VPIImage object to be used by VPI.
 {
 // First fill VPIImageBufferPitchLinear with the, well, image data...
 VPIImageData imgData;
 memset(&imgData, 0, sizeof(imgData));
 imgData.bufferType = VPI_IMAGE_BUFFER_HOST_PITCH_LINEAR;
 imgData.buffer.pitch.format = VPI_IMAGE_FORMAT_U8;
 imgData.buffer.pitch.numPlanes = 1;
 imgData.buffer.pitch.planes[0].width = 512;
 imgData.buffer.pitch.planes[0].height = 512;
 imgData.buffer.pitch.planes[0].pitchBytes = 512;
 imgData.buffer.pitch.planes[0].data = imgContents[0];

 // Wrap it into a VPIImage. VPI won't make a copy of it, so the original
 // image must be in scope at all times.
 CHECK_STATUS(vpiImageCreateWrapper(&imgData, nullptr, 0, &image));
 }

 // Now create the output image, single unsigned 8-bit channel.
 CHECK_STATUS(vpiImageCreate(512, 512, VPI_IMAGE_FORMAT_U8, 0, &blurred));

 // Submit it for processing passing the image to be blurred and the result image
 CHECK_STATUS(vpiSubmitBoxFilter(stream, backend, image, blurred, 3, 3, VPI_BORDER_ZERO));

 // Wait until the algorithm finishes processing
 CHECK_STATUS(vpiStreamSync(stream));

 // Now let's retrieve the output image contents and output it to disk
 {
 // Lock output image to retrieve its data on cpu memory
 VPIImageData outData;
 CHECK_STATUS(vpiImageLockData(blurred, VPI_LOCK_READ, VPI_IMAGE_BUFFER_HOST_PITCH_LINEAR, &outData));

 assert(outData.bufferType == VPI_IMAGE_BUFFER_HOST_PITCH_LINEAR);
 VPIImageBufferPitchLinear &outPitch = outData.buffer.pitch;

 std::ofstream fd(("boxfiltered_" + strBackend + ".pgm").c_str());

 fd << "P5\n512 512 255\n";
 for (int i = 0; i < 512; ++i)
 {
 fd.write(reinterpret_cast<const char *>(outPitch.planes[0].data) + outPitch.planes[0].pitchBytes * i,
 512);
 }
 fd.close();

 // Done handling output image, don't forget to unlock it.
 CHECK_STATUS(vpiImageUnlock(blurred));
 }
 }
 catch (std::exception &e)
 {
 std::cerr << e.what() << std::endl;
 retval = 1;
 }

 // Clean up

 // Make sure stream is synchronized before destroying the objects
 // that might still be in use.
 if (stream != NULL)
 {
 vpiStreamSync(stream);
 }

 vpiImageDestroy(image);
 vpiImageDestroy(blurred);
 vpiStreamDestroy(stream);

 return retval;
}

这是正在使用的 cmake 工具链文件。

set(CMAKE_SYSTEM_NAME Linux)
set(CMAKE_SYSTEM_PROCESSOR aarch64)

set(target_arch aarch64-linux-gnu)
set(CMAKE_LIBRARY_ARCHITECTURE ${target_arch} CACHE STRING "" FORCE)

# 配置 cmake 以查找库、包含目录和
# 目标根前缀内的软件包。
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
set(CMAKE_FIND_ROOT_PATH "/usr/${target_arch}")

# 需要避免执行一些更严格的编译器检查，这些检查在
# 交叉编译时会失败
set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)

# 指定工具链程序
find_program(CMAKE_C_COMPILER ${target_arch}-gcc)
find_program(CMAKE_CXX_COMPILER ${target_arch}-g++)
if(NOT CMAKE_C_COMPILER OR NOT CMAKE_CXX_COMPILER)
 message(FATAL_ERROR "找不到适用于 ${target_arch} 的合适的 C/C++ 交叉编译器")
endif()

set(CMAKE_AR ${target_arch}-ar CACHE FILEPATH "" FORCE)
set(CMAKE_RANLIB ${target_arch}-ranlib)
set(CMAKE_LINKER ${target_arch}-ld)

# 并非所有共享库依赖项都安装在主机上。
# 确保链接器不会报错。
set(CMAKE_EXE_LINKER_FLAGS_INIT -Wl,--allow-shlib-undefined)

# 指示 nvcc 使用我们的交叉编译器
set(CMAKE_CUDA_FLAGS "-ccbin ${CMAKE_CXX_COMPILER} -Xcompiler -fPIC" CACHE STRING "" FORCE)

最后是随附的 CMakeLists.txt。请注意，它只是一个简单的 CMakeLists.txt。与交叉编译相关的所有内容都在上面的工具链文件中定义。

cmake_minimum_required(VERSION 3.5)

# 要从 x86 为 aarch64-l4t 目标进行交叉编译，
# 请将 -DCMAKE_TOOLCHAIN_FILE=Toolchain_aarch64_l4t.cmake 传递给
# cmake 以创建构建树。

project(vpi_sample_08_cross_aarch64_l4t)

find_package(vpi ${vpi_API_VERSION} REQUIRED)

add_executable(${PROJECT_NAME} main.cpp)
target_link_libraries(${PROJECT_NAME} vpi)