Add UNIFIED_BUILDER code for safety samples (NVIDIA#4704) (NVIDIA#4706)

Signed-off-by: Kevin Chen <kevinch@nvidia.com>

Author: kevinch-nv

CMakeLists.txt

@@ -204,6 +204,9 @@ if(BUILD_SAFE_SAMPLES OR TRT_SAFETY_INFERENCE_ONLY)
         target_link_options(TRTSAFE::nvinfer_safe_shared INTERFACE LINKER:--unresolved-symbols=ignore-in-shared-libs)
         target_link_options(TRTSAFE::nvinfer_safe_debug INTERFACE LINKER:--unresolved-symbols=ignore-in-shared-libs)
     endif()
+
+    # Enable unified builder safety features when building safety samples or in inference-only mode.
+    add_compile_definitions(ENABLE_UNIFIED_BUILDER=1)
 endif()
 
 # OSS safety inference-only mode: require safety samples and disable enterprise
@@ -330,6 +333,15 @@ else()
         set(CMAKE_CUDA_RUNTIME_LIBRARY "shared")
     endif()
 
+    # SafeCUDA (QNX-Safe) does not ship libcudadevrt. When CMAKE_CUDA_RUNTIME_LIBRARY
+    # is "shared" or "static", CMake automatically links -lcudadevrt for targets with
+    # CUDA sources, which breaks QNX-Safe cross-compilation. Setting it to "None"
+    # disables automatic CUDA runtime linking; cudart is still linked manually via
+    # trt_global_definitions.
+    if(TRT_SAFETY_INFERENCE_ONLY AND CMAKE_SYSTEM_NAME STREQUAL "QNX")
+        set(CMAKE_CUDA_RUNTIME_LIBRARY "None")
+    endif()
+
     find_library(CUDART_LIB ${CUDART_LIB_NAME} HINTS ${CUDA_TOOLKIT_ROOT_DIR} PATH_SUFFIXES lib lib/x64 lib64)
 endif()
 

cmake/toolchains/cmake_qnx_safe.toolchain

@@ -110,7 +110,9 @@ endif()
 # We need to set a couple additional flags to compile with SafeCUDA.
 # 1. SafeCUDA does not contain cudadevrt, so we need to disable it by setting --cudadevrt=none
 # 2. SafeCUDA depends on the QNX Slogger2 library, which must be linked via -lslog2. It is a system library for QNX-Safe.
-set(CMAKE_CUDA_FLAGS_INIT "${CMAKE_CUDA_FLAGS_INIT} --cudadevrt=none -lslog2")
+# 3. Use --target-directory to tell nvcc to use aarch64-qnx-safe instead of aarch64-qnx
+#    This is critical to override nvcc's internal _TARGET_DIR_ variable
+set(CMAKE_CUDA_FLAGS_INIT "${CMAKE_CUDA_FLAGS_INIT} --cudadevrt=none -lslog2 --target-directory aarch64-qnx-safe")
 
 # We need to explicitly populate `CMAKE_CUDA_FLAGS` with the initial flags so they propagate to the CMake Compiler Identification phase.
 # Otherwise, they will only be initialized afterwards, which will cause the identification to fail.

samples/common/sampleEngines.cpp

@@ -39,6 +39,10 @@
 #include "sampleOptions.h"
 #include "sampleUtils.h"
 
+#if ENABLE_UNIFIED_BUILDER
+#include "NvInferConsistency.h"
+#include "safeErrorRecorder.h"
+#endif
 
 // cspell:ignore calib CUFILE nvonnxparser
 
@@ -1373,6 +1377,11 @@ bool networkToSerializedEngine(
         if (build.safe && build.consistency)
         {
             std::vector<std::string> pluginBuildLibPaths;
+#if ENABLE_UNIFIED_BUILDER
+            pluginBuildLibPaths.reserve(sys.safetyPlugins.size());
+            std::transform(sys.safetyPlugins.begin(), sys.safetyPlugins.end(), std::back_inserter(pluginBuildLibPaths),
+                [](auto const& sp) { return sp.libraryName; });
+#endif
             if (!checkSafeEngine(serializedEngine->data(), serializedEngine->size(), pluginBuildLibPaths))
             {
                 return false;
@@ -1534,6 +1543,11 @@ bool loadEngineToBuildEnv(std::string const& filepath, BuildEnvironment& env, st
     if (enableConsistency)
     {
         std::vector<std::string> pluginBuildLibPaths;
+#if ENABLE_UNIFIED_BUILDER
+        pluginBuildLibPaths.reserve(sys.safetyPlugins.size());
+        std::transform(sys.safetyPlugins.begin(), sys.safetyPlugins.end(), std::back_inserter(pluginBuildLibPaths),
+            [](auto const& sp) { return sp.libraryName; });
+#endif
         if (!checkSafeEngine(engineBlob.data(), fsize, pluginBuildLibPaths))
         {
             sample::gLogError << "Consistency validation is not enabled." << std::endl;
@@ -1987,6 +2001,39 @@ static constexpr auto kCONSISTENCY_CHECKER_LIBRARY = nullptr;
 
 } // namespace
 
+#if ENABLE_UNIFIED_BUILDER
+
+std::unique_ptr<nvinfer2::safe::consistency::IConsistencyChecker> createConsistencyChecker(
+    sample::SampleSafeRecorder& recorder, void const* serializedEngine, int32_t const engineSize,
+    std::vector<std::string> const& pluginBuildLibPath) noexcept
+{
+
+    if (serializedEngine == nullptr || engineSize == 0)
+    {
+        return nullptr;
+    }
+
+#if !defined(_WIN32)
+    if (hasSafeRuntime())
+    {
+        constexpr char symbolName[] = "createConsistencyChecker";
+        using CreateCheckerFn = ErrorCode (*)(nvinfer2::safe::consistency::IConsistencyChecker*& checker,
+            sample::SampleSafeRecorder& recorder, void const* data, size_t size,
+            std::vector<std::string> const& pluginBuildLibPath);
+        if (auto const createFn
+            = reinterpret_cast<CreateCheckerFn>(dlsym(kCONSISTENCY_CHECKER_LIBRARY.get(), symbolName)))
+        {
+            if (nvinfer2::safe::consistency::IConsistencyChecker * checker{nullptr};
+                ErrorCode::kSUCCESS == createFn(checker, recorder, serializedEngine, engineSize, pluginBuildLibPath))
+            {
+                return std::unique_ptr<nvinfer2::safe::consistency::IConsistencyChecker>{checker};
+            }
+        }
+    }
+#endif
+    return nullptr;
+}
+#endif
 
 bool hasSafeRuntime()
 {
@@ -2001,7 +2048,32 @@ bool hasConsistencyChecker()
 bool checkSafeEngine(
     void const* serializedEngine, int64_t const engineSize, std::vector<std::string> const& pluginBuildLibPath)
 {
+#if !ENABLE_UNIFIED_BUILDER
     return false;
+#else
+    if (!hasConsistencyChecker())
+    {
+        sample::gLogError << "Cannot perform consistency check because the checker is not loaded." << std::endl;
+        return false;
+    }
+
+    sample::SampleSafeRecorder recorder{nvinfer2::safe::Severity::kINFO};
+    std::unique_ptr<nvinfer2::safe::consistency::IConsistencyChecker> checker
+        = createConsistencyChecker(recorder, serializedEngine, engineSize, pluginBuildLibPath);
+    if (checker == nullptr)
+    {
+        sample::gLogError << "Failed to create consistency checker." << std::endl;
+        return false;
+    }
+    sample::gLogInfo << "Start consistency checking." << std::endl;
+    if (!checker->validate())
+    {
+        sample::gLogError << "Consistency validation failed." << std::endl;
+        return false;
+    }
+    sample::gLogInfo << "Consistency validation passed." << std::endl;
+    return true;
+#endif
 }
 
 } // namespace sample