sources/libs/nvdsinferserver/infer_common.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2020-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef __NVDSINFERSERVER_COMMON_H__
#define __NVDSINFERSERVER_COMMON_H__
 
#include <dlfcn.h>
#include <inttypes.h>
#include <pthread.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>
 
#include <algorithm>
#include <cassert>
#include <condition_variable>
#include <future>
#include <map>
#include <mutex>
#include <set>
#include <shared_mutex>
#include <sstream>
#include <stdexcept>
#include <string>
#include <thread>
#include <unordered_map>
 
#include <infer_datatypes.h>
#include <infer_defines.h>
 
namespace nvdsinferserver {
 
class BaseBatchBuffer;
class BaseBatchArray;
class RefBatchBuffer;
 
class SysMem;
class CudaStream;
class CudaEvent;
class CudaTensorBuf;
 
class IPreprocessor;
class IPostprocessor;
class IBackend;
class BasePreprocessor;
class BasePostprocessor;
class BaseBackend;
 
class TrtISBackend;
 
using SharedBatchBuf = std::shared_ptr<BaseBatchBuffer>;
using UniqBatchBuf = std::unique_ptr<BaseBatchBuffer>;
using SharedOptions = std::shared_ptr<IOptions>;
 
using SharedBatchArray = std::shared_ptr<BaseBatchArray>;
using UniqBatchArray = std::unique_ptr<BaseBatchArray>;
using SharedRefBatchBuf = std::shared_ptr<RefBatchBuffer>;
using SharedCuStream = std::shared_ptr<CudaStream>;
using UniqCuStream = std::unique_ptr<CudaStream>;
using SharedCuEvent = std::shared_ptr<CudaEvent>;
using UniqCuEvent = std::unique_ptr<CudaEvent>;
using SharedSysMem = std::shared_ptr<SysMem>;
using UniqSysMem = std::unique_ptr<SysMem>;
using UniqCudaTensorBuf = std::unique_ptr<CudaTensorBuf>;
using SharedCudaTensorBuf = std::shared_ptr<CudaTensorBuf>;
using UniqPostprocessor = std::unique_ptr<BasePostprocessor>;
using UniqPreprocessor = std::unique_ptr<BasePreprocessor>;
 
using UniqTrtISBackend = std::unique_ptr<TrtISBackend>;
using UniqLock = std::unique_lock<std::mutex>;
 
class DlLibHandle;
using SharedDllHandle = std::shared_ptr<DlLibHandle>;
 
template <typename T>
using UniqTritonT = std::unique_ptr<T, std::function<void(T*)>>;
 
template <typename T>
using ShrTritonT = std::shared_ptr<T>;
 
class TrtISServer;
class TrtServerAllocator;
using TrtServerPtr = std::shared_ptr<TrtISServer>;
 
using UniqTritonAllocator = std::unique_ptr<TrtServerAllocator>;
using ShrTritonAllocator = std::shared_ptr<TrtServerAllocator>;
using WeakTritonAllocator = std::weak_ptr<TrtServerAllocator>;
 
class LstmController;
using UniqLstmController = std::unique_ptr<LstmController>;
 
class StreamManager;
using UniqStreamManager = std::unique_ptr<StreamManager>;
class InferExtraProcessor;
using UniqInferExtraProcessor = std::unique_ptr<InferExtraProcessor>;
class IInferCustomProcessor;
using InferCustomProcessorPtr = std::shared_ptr<IInferCustomProcessor>;
}  // namespace nvdsinferserver
 
#endif