Method getSafe

samples/common/sampleEngines.cpp:160–192

}

nvinfer1::safe::ICudaEngine* LazilyDeserializedEngine::getSafe()
{
    SMP_RETVAL_IF_FALSE(
        mIsSafe, "Safe mode is not enabled, but trying to get safe engine!", nullptr, sample::gLogError);

    ASSERT(sample::hasSafeRuntime());
    if (mSafeEngine == nullptr)
    {
        SMP_RETVAL_IF_FALSE(
            !mEngineBlob.empty(), "Engine blob is empty. Nothing to deserialize!", nullptr, sample::gLogError);

        SMP_RETVAL_IF_FALSE(
            mDLACore == -1, "Safe DLA engine built with kDLA_STANDALONE should not be deserialized in TRT!", nullptr,
            sample::gLogError);

        using time_point = std::chrono::time_point<std::chrono::high_resolution_clock>;
        using duration = std::chrono::duration<float>;
        time_point const deserializeStartTime{std::chrono::high_resolution_clock::now()};

        std::unique_ptr<safe::IRuntime> safeRuntime{sample::createSafeInferRuntime(sample::gLogger.getTRTLogger())};
        SMP_RETVAL_IF_FALSE(safeRuntime != nullptr, "SafeRuntime creation failed", nullptr, sample::gLogError);
        safeRuntime->setErrorRecorder(&gRecorder);
        mSafeEngine.reset(
            safeRuntime->deserializeCudaEngine(mEngineBlob.data(), mEngineBlob.size()));
        SMP_RETVAL_IF_FALSE(mSafeEngine != nullptr, "SafeEngine deserialization failed", nullptr, sample::gLogError);

        time_point const deserializeEndTime{std::chrono::high_resolution_clock::now()};
        sample::gLogInfo << "SafeEngine deserialized in "
                            << duration(deserializeEndTime - deserializeStartTime).count() << " sec." << std::endl;
    }

    return mSafeEngine.get();
}

void setTensorScalesFromCalibration(nvinfer1::INetworkDefinition& network, std::vector<IOFormat> const& inputFormats,
    std::vector<IOFormat> const& outputFormats, std::string const& calibrationFile)