Cross-Compilation Targeting aarch64

Overview

This sample shows how to build your applications in a x86_64 host, targeting Jetson devices that use aarch64 architecture. It uses several features first made available in cmake-3.5. The sample application itself creates an input image, applies a box filter to it and save the result to disk.

Instructions

JetPack's installer already set up the cross-compilation toolchain using gcc, but if some reason it isn't available, install it manually with:

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

Now cmake can be instructed to create a cross-compiling build tree by calling it as follows in the samples directory:

cmake . -DCMAKE_TOOLCHAIN_FILE=Toolchain_aarch64_l4t.cmake

The file Toolchain_aarch64_l4t.cmake is included in the samples directory and defines the cross-compiler that will be used, among other configurations. In particular, it also allows cross-compilation of CUDA applications, provided that the CUDA aarch64 cross-compilation libraries are correctly installed on host.

Note

This sample can also be compiled targeting the host. Just omit the CMAKE_TOOLCHAIN_FILE parameter during cmake invocation.

The usage is:

./vpi_sample_08_cross_aarch64_l4t <backend>

where

• backend: either cpu, cuda or pva; it defines the backend that will perform the processing.

Source Code

For convenience, here's the code that is also installed in the samples directory.

Language: 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 VPIImageData with the, well, image data...
            VPIImageData imgData;
            memset(&imgData, 0, sizeof(imgData));
            imgData.format               = VPI_IMAGE_FORMAT_U8;
            imgData.numPlanes            = 1;
            imgData.planes[0].width      = 512;
            imgData.planes[0].height     = 512;
            imgData.planes[0].pitchBytes = 512;
            imgData.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(vpiImageCreateHostMemWrapper(&imgData, 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(vpiImageLock(blurred, VPI_LOCK_READ, &outData));
 
            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 *>(outData.planes[0].data) + outData.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;
}
 
// vim: ts=8:sw=4:sts=4:et:ai

Here is the cmake toolchain file that is being used.

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)
 
# Configure cmake to look for libraries, include directories and
# packages inside the target root prefix.
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}")
 
# needed to avoid doing some more strict compiler checks that
# are failing when cross-compiling
set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
 
# specify the toolchain programs
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 "Can't find suitable C/C++ cross compiler for ${target_arch}")
endif()
 
set(CMAKE_AR ${target_arch}-ar CACHE FILEPATH "" FORCE)
set(CMAKE_RANLIB ${target_arch}-ranlib)
set(CMAKE_LINKER ${target_arch}-ld)
 
# Not all shared libraries dependencies are instaled in host machine.
# Make sure linker doesn't complain.
set(CMAKE_EXE_LINKER_FLAGS_INIT -Wl,--allow-shlib-undefined)
 
# instruct nvcc to use our cross-compiler
set(CMAKE_CUDA_FLAGS "-ccbin ${CMAKE_CXX_COMPILER} -Xcompiler -fPIC" CACHE STRING "" FORCE)
 
# vim: ts=8:sw=4:sts=4:et:ai

And finally the accompanying CMakeLists.txt. Note that it is just a plain simple CMakeLists.txt. Everything related to cross-compilation is defined in the toolchain file above.

cmake_minimum_required(VERSION 3.5)
 
# To cross-compile for aarch64-l4t target from x86,
# pass -DCMAKE_TOOLCHAIN_FILE=Toolchain_aarch64_l4t.cmake
# to cmake when creating build tree.
 
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)
 
# vim: ts=8:sw=4:sts=4:et:ai