Fix warnings in additional sample files built with TensorRT runtime

Fix warnings in 10 sample files that are only compiled when the real
TensorRT runtime libraries are available (not with stub libs):
- BatchStream.h: add virtual destructor, int64_t narrowing casts
- sampleCharRNN: shadow fix, size_t casts
- sampleDynamicReshape: unused param, double-promotion, conversion
- sampleINT8API: shadow fix, float/int casts
- sampleIOFormats: shadow fixes, unused params, sizeof casts
- sampleNamedDimensions: unused params, float literal fixes
- sampleNonZeroPlugin: unused params, int64_t/size_t casts
- sampleOnnxMNIST: unused param, exp() float cast
- sampleOnnxMnistCoordConvAC: float literal fixes, exp() cast
- sampleProgressMonitor: int-to-float cast, exp() cast, ptr diff cast

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Signed-off-by: Max Buckley <maxwbuckley@gmail.com>

Author: maxwbuckley

samples/common/BatchStream.h

@@ -26,6 +26,7 @@
 class IBatchStream
 {
 public:
+    virtual ~IBatchStream() = default;
     virtual void reset(int firstBatch) = 0;
     virtual bool next() = 0;
     virtual void skip(int skipCount) = 0;
@@ -173,7 +174,7 @@ class BatchStream : public IBatchStream
         mDims.d[3] = d[3]; // Width
         ASSERT(mDims.d[0] > 0 && mDims.d[1] > 0 && mDims.d[2] > 0 && mDims.d[3] > 0);
 
-        mImageSize = mDims.d[1] * mDims.d[2] * mDims.d[3];
+        mImageSize = static_cast<int>(mDims.d[1] * mDims.d[2] * mDims.d[3]);
         mBatch.resize(mBatchSize * mImageSize, 0);
         mLabels.resize(mBatchSize, 0);
         mFileBatch.resize(mDims.d[0] * mImageSize, 0);
@@ -193,7 +194,7 @@ class BatchStream : public IBatchStream
         , mListFile(listFile)
         , mDataDir(directories)
     {
-        mImageSize = mDims.d[1] * mDims.d[2] * mDims.d[3];
+        mImageSize = static_cast<int>(mDims.d[1] * mDims.d[2] * mDims.d[3]);
         mBatch.resize(mBatchSize * mImageSize, 0);
         mLabels.resize(mBatchSize, 0);
         mFileBatch.resize(mDims.d[0] * mImageSize, 0);
@@ -205,7 +206,7 @@ class BatchStream : public IBatchStream
     {
         mBatchCount = 0;
         mFileCount = 0;
-        mFileBatchPos = mDims.d[0];
+        mFileBatchPos = static_cast<int>(mDims.d[0]);
         skip(firstBatch);
     }
 
@@ -217,7 +218,7 @@ class BatchStream : public IBatchStream
             return false;
         }
 
-        for (int64_t csize = 1, batchPos = 0; batchPos < mBatchSize; batchPos += csize, mFileBatchPos += csize)
+        for (int64_t csize = 1, batchPos = 0; batchPos < mBatchSize; batchPos += csize, mFileBatchPos += static_cast<int>(csize))
         {
             ASSERT(mFileBatchPos > 0 && mFileBatchPos <= mDims.d[0]);
             if (mFileBatchPos == mDims.d[0] && !update())
@@ -238,9 +239,9 @@ class BatchStream : public IBatchStream
     // Skips the batches
     void skip(int skipCount) override
     {
-        if (mBatchSize >= mDims.d[0] && mBatchSize % mDims.d[0] == 0 && mFileBatchPos == mDims.d[0])
+        if (mBatchSize >= mDims.d[0] && mBatchSize % mDims.d[0] == 0 && mFileBatchPos == static_cast<int>(mDims.d[0]))
         {
-            mFileCount += skipCount * mBatchSize / mDims.d[0];
+            mFileCount += static_cast<int>(skipCount * mBatchSize / mDims.d[0]);
             return;
         }
 
@@ -269,7 +270,7 @@ class BatchStream : public IBatchStream
 
     int getBatchSize() const override
     {
-        return mBatchSize;
+        return static_cast<int>(mBatchSize);
     }
 
     nvinfer1::Dims getDims() const override
@@ -338,14 +339,14 @@ class BatchStream : public IBatchStream
             }
 
             std::vector<float> data(samplesCommon::volume(mDims));
-            const float scale = 2.0 / 255.0;
-            const float bias = 1.0;
-            long int volChl = mDims.d[2] * mDims.d[3];
+            const float scale = 2.0f / 255.0f;
+            const float bias = 1.0f;
+            long int volChl = static_cast<long int>(mDims.d[2] * mDims.d[3]);
 
             // Normalize input data
-            for (int i = 0, volImg = mDims.d[1] * mDims.d[2] * mDims.d[3]; i < mBatchSize; ++i)
+            for (int i = 0, volImg = static_cast<int>(mDims.d[1] * mDims.d[2] * mDims.d[3]); i < mBatchSize; ++i)
             {
-                for (int c = 0; c < mDims.d[1]; ++c)
+                for (int64_t c = 0; c < mDims.d[1]; ++c)
                 {
                     for (int j = 0; j < volChl; ++j)
                     {

samples/sampleCharRNN/sampleCharRNN.cpp

@@ -639,12 +639,12 @@ nvinfer1::ILayer* SampleCharRNNLoop::addLSTMLayers(std::unique_ptr<nvinfer1::INe
     nvinfer1::Dims dimB{1, {4 * mParams.hiddenSize}};
     nvinfer1::Dims dim0{1, {0}};
     auto extractWeights = [](nvinfer1::Weights weights, Dims start, Dims size) -> nvinfer1::Weights {
-        const char* data = static_cast<const char*>(weights.values);
+        const char* data_ = static_cast<const char*>(weights.values);
         int64_t shift = samplesCommon::volume(start);
-        const int bufferSize = samplesCommon::getNbBytes(weights.type, shift);
+        const int bufferSize = static_cast<int>(samplesCommon::getNbBytes(weights.type, shift));
         int64_t count = samplesCommon::volume(size);
         ASSERT(shift + count <= weights.count);
-        return nvinfer1::Weights{weights.type, data + bufferSize, count};
+        return nvinfer1::Weights{weights.type, data_ + bufferSize, count};
     };
     for (int i = 0; i < mParams.layerCount; ++i)
     {
@@ -667,7 +667,7 @@ nvinfer1::ILayer* SampleCharRNNLoop::addLSTMLayers(std::unique_ptr<nvinfer1::INe
     }
 
     auto addConcatenation = [&network](std::vector<nvinfer1::ITensor*> tensors) -> nvinfer1::ITensor* {
-        nvinfer1::IConcatenationLayer* concat = network->addConcatenation(tensors.data(), tensors.size());
+        nvinfer1::IConcatenationLayer* concat = network->addConcatenation(tensors.data(), static_cast<int>(tensors.size()));
         concat->setAxis(0);
         return concat->getOutput(0);
     };
@@ -776,7 +776,7 @@ bool SampleCharRNNBase::infer()
 
     // Select a random seed string.
     srand(unsigned(time(nullptr)));
-    int sentenceIndex = rand() % mParams.inputSentences.size();
+    int sentenceIndex = static_cast<int>(rand() % mParams.inputSentences.size());
     std::string inputSentence = mParams.inputSentences[sentenceIndex];
     std::string expected = mParams.outputSentences[sentenceIndex];
     std::string genstr;

samples/sampleDynamicReshape/sampleDynamicReshape.cpp

@@ -150,7 +150,7 @@ bool SampleDynamicReshape::build()
 //! \return false if error in build preprocessor engine.
 //!
 bool SampleDynamicReshape::buildPreprocessorEngine(
-    nvinfer1::IBuilder& builder, nvinfer1::IRuntime& runtime, cudaStream_t profileStream)
+    nvinfer1::IBuilder& builder, nvinfer1::IRuntime& runtime, cudaStream_t /*profileStream*/)
 {
     // Create the preprocessor engine using a network that supports full dimensions (createNetworkV2).
     auto preprocessorNetwork = std::unique_ptr<INetworkDefinition>(
@@ -437,7 +437,7 @@ Dims SampleDynamicReshape::loadPGMFile(const std::string& fileName)
     mInput.hostBuffer.resize(inputDims);
     float* hostDataBuffer = static_cast<float*>(mInput.hostBuffer.data());
     std::transform(fileData.begin(), fileData.end(), hostDataBuffer,
-        [](uint8_t x) { return 1.0 - static_cast<float>(x / 255.0); });
+        [](uint8_t x) { return 1.0f - static_cast<float>(x) / 255.0f; });
     return inputDims;
 }
 
@@ -459,7 +459,7 @@ bool SampleDynamicReshape::validateOutput(int digit)
         ++curIndex;
     }
 
-    int predictedDigit = std::max_element(prob.begin(), prob.end()) - prob.begin();
+    int predictedDigit = static_cast<int>(std::max_element(prob.begin(), prob.end()) - prob.begin());
     return digit == predictedDigit;
 }
 

samples/sampleINT8API/sampleINT8API.cpp

@@ -241,7 +241,6 @@ void SampleINT8API::setLayerPrecision(nvinfer1::INetworkDefinition const& networ
             std::string tensorName = layer->getOutput(j)->getName();
             if (mParams.verbose)
             {
-                std::string tensorName = layer->getOutput(j)->getName();
                 sample::gLogInfo << "Tensor: " << tensorName << ". OutputType: INT8" << std::endl;
             }
             // set output type of execution tensors and not shape tensors.
@@ -391,7 +390,7 @@ bool SampleINT8API::setDynamicRange(nvinfer1::INetworkDefinition& network)
                     max = std::max(max, std::abs(val));
                 }
 
-                if (!lyr->getOutput(j)->setDynamicRange(-max, max))
+                if (!lyr->getOutput(j)->setDynamicRange(static_cast<float>(-max), static_cast<float>(max)))
                 {
                     return false;
                 }
@@ -466,7 +465,7 @@ bool SampleINT8API::verifyOutput(samplesCommon::BufferManager const& buffers) co
 {
     // copy output host buffer data for further processing
     float const* probPtr = static_cast<float const*>(buffers.getHostBuffer(mInOut.at("output")));
-    std::vector<float> output(probPtr, probPtr + mOutputDims.d[1]);
+    std::vector<float> output(probPtr, probPtr + static_cast<int>(mOutputDims.d[1]));
 
     auto inds = samplesCommon::argMagnitudeSort(output.cbegin(), output.cend());
 

samples/sampleIOFormats/sampleIOFormats.cpp

@@ -74,32 +74,32 @@ class BufferDesc
 public:
     BufferDesc() = default;
 
-    BufferDesc(nvinfer1::Dims dims, int32_t dataWidth, TensorFormat format)
+    BufferDesc(nvinfer1::Dims dims_, int32_t dataWidth_, TensorFormat format)
     {
-        this->dataWidth = dataWidth;
+        this->dataWidth = dataWidth_;
         if (format == TensorFormat::kLINEAR)
         {
-            this->dims[0] = dims.d[0];
-            this->dims[1] = dims.d[1];
-            this->dims[2] = dims.d[2];
-            this->dims[3] = dims.d[3];
+            this->dims[0] = static_cast<int32_t>(dims_.d[0]);
+            this->dims[1] = static_cast<int32_t>(dims_.d[1]);
+            this->dims[2] = static_cast<int32_t>(dims_.d[2]);
+            this->dims[3] = static_cast<int32_t>(dims_.d[3]);
             this->dims[4] = 1;
         }
         else if (format == TensorFormat::kCHW32)
         {
-            this->dims[0] = dims.d[0];
-            this->dims[1] = divUp(dims.d[1], 32);
-            this->dims[2] = dims.d[2];
-            this->dims[3] = dims.d[3];
+            this->dims[0] = static_cast<int32_t>(dims_.d[0]);
+            this->dims[1] = divUp(static_cast<int32_t>(dims_.d[1]), 32);
+            this->dims[2] = static_cast<int32_t>(dims_.d[2]);
+            this->dims[3] = static_cast<int32_t>(dims_.d[3]);
             this->dims[4] = 32;
             this->scalarPerVector = 32;
         }
         else if (format == TensorFormat::kHWC)
         {
-            this->dims[0] = dims.d[0];
-            this->dims[1] = dims.d[2];
-            this->dims[2] = dims.d[3];
-            this->dims[3] = dims.d[1];
+            this->dims[0] = static_cast<int32_t>(dims_.d[0]);
+            this->dims[1] = static_cast<int32_t>(dims_.d[2]);
+            this->dims[2] = static_cast<int32_t>(dims_.d[3]);
+            this->dims[3] = static_cast<int32_t>(dims_.d[1]);
             this->dims[4] = 1;
             this->channelPivot = true;
         }
@@ -144,23 +144,23 @@ class SampleBuffer
         dims.d[3] = 1;
     }
 
-    SampleBuffer(nvinfer1::Dims dims, int32_t dataWidth, TensorFormat format, bool isInput)
-        : dims(dims)
-        , dataWidth(dataWidth)
-        , format(format)
-        , isInput(isInput)
+    SampleBuffer(nvinfer1::Dims dims_, int32_t dataWidth_, TensorFormat format_, bool isInput_)
+        : dims(dims_)
+        , dataWidth(dataWidth_)
+        , format(format_)
+        , isInput(isInput_)
     {
 
         // Output buffer is unsqueezed to 4D in order to reuse the BufferDesc class
-        if (isInput == false)
+        if (isInput_ == false)
         {
-            dims.d[2] = dims.d[0];
-            dims.d[3] = dims.d[1];
-            dims.d[0] = 1;
-            dims.d[1] = 1;
+            dims_.d[2] = dims_.d[0];
+            dims_.d[3] = dims_.d[1];
+            dims_.d[0] = 1;
+            dims_.d[1] = 1;
         }
 
-        desc = BufferDesc(dims, dataWidth, format);
+        desc = BufferDesc(dims_, dataWidth_, format_);
 
         if (nullptr == buffer)
         {
@@ -330,7 +330,7 @@ bool SampleIOFormats::verify(TypeSpec const& spec)
 //!
 //! \return true if the engine was created successfully and false otherwise
 //!
-bool SampleIOFormats::build(int32_t dataWidth)
+bool SampleIOFormats::build(int32_t /*dataWidth*/)
 {
     auto builder = std::unique_ptr<nvinfer1::IBuilder>(nvinfer1::createInferBuilder(sample::gLogger.getTRTLogger()));
     if (!builder)
@@ -436,7 +436,7 @@ bool SampleIOFormats::build(int32_t dataWidth)
 //! \param builder Pointer to the engine builder
 //!
 bool SampleIOFormats::constructNetwork(std::unique_ptr<nvinfer1::IBuilder>& builder,
-    std::unique_ptr<nvinfer1::INetworkDefinition>& network, std::unique_ptr<nvinfer1::IBuilderConfig>& config,
+    std::unique_ptr<nvinfer1::INetworkDefinition>& /*network*/, std::unique_ptr<nvinfer1::IBuilderConfig>& config,
     std::unique_ptr<nvonnxparser::IParser>& parser)
 {
     auto parsed = parser->parseFromFile(samplesCommon::locateFile(mParams.onnxFileName, mParams.dataDirs).c_str(),
@@ -548,7 +548,7 @@ void printHelpInfo()
 //! \brief Used to run the engine build and inference/reference functions
 //!
 template <typename T>
-bool process(SampleIOFormats& sample, sample::Logger::TestAtom const& sampleTest, SampleBuffer& inputBuf,
+bool process(SampleIOFormats& sample, sample::Logger::TestAtom const& /*sampleTest*/, SampleBuffer& inputBuf,
     SampleBuffer& outputBuf, TypeSpec& spec)
 {
     sample::gLogInfo << "Building and running a GPU inference engine with specified I/O formats." << std::endl;
@@ -562,8 +562,8 @@ bool process(SampleIOFormats& sample, sample::Logger::TestAtom const& sampleTest
         return false;
     }
 
-    inputBuf = SampleBuffer(sample.mInputDims, sizeof(T), sample.mTensorFormat, true);
-    outputBuf = SampleBuffer(sample.mOutputDims, sizeof(T), TensorFormat::kLINEAR, false);
+    inputBuf = SampleBuffer(sample.mInputDims, static_cast<int32_t>(sizeof(T)), sample.mTensorFormat, true);
+    outputBuf = SampleBuffer(sample.mOutputDims, static_cast<int32_t>(sizeof(T)), TensorFormat::kLINEAR, false);
 
     if (!sample.infer(inputBuf, outputBuf))
     {

samples/sampleNamedDimensions/sampleNamedDimensions.cpp

@@ -36,6 +36,7 @@
 #include <cuda_runtime_api.h>
 
 #include <algorithm>
+#include <cmath>
 #include <cstdlib>
 #include <fstream>
 #include <iostream>
@@ -223,8 +224,8 @@ bool SampleNamedDimensions::build()
 //!
 //! \brief Uses ONNX parser to create the ONNX Network and marks the output layers
 //!
-bool SampleNamedDimensions::constructNetwork(std::unique_ptr<nvinfer1::IBuilder>& builder,
-    std::unique_ptr<nvinfer1::INetworkDefinition>& network, std::unique_ptr<nvinfer1::IBuilderConfig>& config,
+bool SampleNamedDimensions::constructNetwork(std::unique_ptr<nvinfer1::IBuilder>& /*builder*/,
+    std::unique_ptr<nvinfer1::INetworkDefinition>& /*network*/, std::unique_ptr<nvinfer1::IBuilderConfig>& /*config*/,
     std::unique_ptr<nvonnxparser::IParser>& parser)
 {
     auto parsed = parser->parseFromFile(samplesCommon::locateFile(mParams.onnxFileName, mParams.dataDirs).c_str(),
@@ -314,15 +315,15 @@ bool SampleNamedDimensions::infer()
 bool SampleNamedDimensions::processInput(samplesCommon::BufferManager const& buffers)
 {
     int32_t const input0H = mNamedDimension;
-    int32_t const input0W = mInputDims[0].d[1];
+    int32_t const input0W = static_cast<int32_t>(mInputDims[0].d[1]);
     int32_t const input1H = mNamedDimension;
-    int32_t const input1W = mInputDims[1].d[1];
+    int32_t const input1W = static_cast<int32_t>(mInputDims[1].d[1]);
 
     // Generate random input
     mInput0.resize(input0H * input0W);
     mInput1.resize(input1H * input1W);
     std::default_random_engine generator(static_cast<uint32_t>(time(nullptr)));
-    std::uniform_real_distribution<float> unif_real_distr(-10., 10.);
+    std::uniform_real_distribution<float> unif_real_distr(-10.0f, 10.0f);
 
     sample::gLogInfo << "Input0:\n";
     for (int32_t i = 0; i < input0H * input0W; i++)
@@ -357,7 +358,7 @@ bool SampleNamedDimensions::processInput(samplesCommon::BufferManager const& buf
 bool SampleNamedDimensions::verifyOutput(samplesCommon::BufferManager const& buffers)
 {
     int32_t const outputH = 2 * mNamedDimension;
-    int32_t const outputW = mOutputDims[0].d[1];
+    int32_t const outputW = static_cast<int32_t>(mOutputDims[0].d[1]);
     int32_t const outputSize = outputH * outputW;
 
     auto* output = static_cast<float*>(buffers.getHostBuffer(mParams.outputTensorNames[0]));
@@ -374,7 +375,7 @@ bool SampleNamedDimensions::verifyOutput(samplesCommon::BufferManager const& buf
     for (int32_t i = 0; i < outputH * outputW; i++)
     {
         auto const reference_value = i > outputSize / 2 ? mInput1[i - outputSize / 2] : mInput0[i];
-        if (fabs(output[i] - reference_value) > std::numeric_limits<float>::epsilon())
+        if (std::abs(output[i] - reference_value) > std::numeric_limits<float>::epsilon())
         {
             return false;
         }