From 710cb54db36d3b3223f0a14d7e79bd1f26f46f4b Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 5 Jun 2021 22:12:15 +0530 Subject: [PATCH 01/32] Centernet fix for windows --- Issues.md | 1 - src/CenternetDetection.cpp | 8 ++++---- 2 files changed, 4 insertions(+), 5 deletions(-) delete mode 100644 Issues.md diff --git a/Issues.md b/Issues.md deleted file mode 100644 index 4875b13..0000000 --- a/Issues.md +++ /dev/null @@ -1 +0,0 @@ -1)error C2131 @ Yolo3Detection.cpp(97) -> expression doesnt evaluate to a constant caused to read of variable outside its lifetime \ No newline at end of file diff --git a/src/CenternetDetection.cpp b/src/CenternetDetection.cpp index 46757f4..bd09005 100644 --- a/src/CenternetDetection.cpp +++ b/src/CenternetDetection.cpp @@ -347,21 +347,21 @@ void CenternetDetection::postprocess(const int bi, const bool mAP){ new_pt1.at(0,0)=static_cast(trans2.at(0,0))*bbx0[i] + static_cast(trans2.at(0,1))*bby0[i] + static_cast(trans2.at(0,2))*1.0; - new_pt1.at(0,1)=static_cast(trans2.at(1,0))*bbx0[i] + + new_pt1.at(1,0)=static_cast(trans2.at(1,0))*bbx0[i] + static_cast(trans2.at(1,1))*bby0[i] + static_cast(trans2.at(1,2))*1.0; new_pt2.at(0,0)=static_cast(trans2.at(0,0))*bbx1[i] + static_cast(trans2.at(0,1))*bby1[i] + static_cast(trans2.at(0,2))*1.0; - new_pt2.at(0,1)=static_cast(trans2.at(1,0))*bbx1[i] + + new_pt2.at(1,0)=static_cast(trans2.at(1,0))*bbx1[i] + static_cast(trans2.at(1,1))*bby1[i] + static_cast(trans2.at(1,2))*1.0; target_coords[i*4] = new_pt1.at(0,0); - target_coords[i*4+1] = new_pt1.at(0,1); + target_coords[i*4+1] = new_pt1.at(1,0); target_coords[i*4+2] = new_pt2.at(0,0); - target_coords[i*4+3] = new_pt2.at(0,1); + target_coords[i*4+3] = new_pt2.at(1,0); } detected.clear(); -- 2.52.0 From 1412aa66c442f0e0f5eb23ec7441151282d3d9f6 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 24 Jul 2021 08:51:44 -0700 Subject: [PATCH 02/32] minor fixes for windows ,for release v0.6 --- demo/demo/seg_demo.cpp | 2 ++ include/tkDNN/CenterTrack.h | 5 +++++ include/tkDNN/CenternetDetection3D.h | 5 +++++ include/tkDNN/Layer.h | 4 ++-- include/tkDNN/SegmentationNN.h | 2 ++ include/tkDNN/demo_utils.h | 3 ++- src/CenterTrack.cpp | 23 +++++++++++++---------- 7 files changed, 31 insertions(+), 13 deletions(-) diff --git a/demo/demo/seg_demo.cpp b/demo/demo/seg_demo.cpp index 2b491d8..f22e5c2 100644 --- a/demo/demo/seg_demo.cpp +++ b/demo/demo/seg_demo.cpp @@ -1,7 +1,9 @@ #include #include #include /* srand, rand */ +#ifdef __linux__ #include +#endif #include #include "SegmentationNN.h" diff --git a/include/tkDNN/CenterTrack.h b/include/tkDNN/CenterTrack.h index 783a44e..aa573fa 100644 --- a/include/tkDNN/CenterTrack.h +++ b/include/tkDNN/CenterTrack.h @@ -13,6 +13,11 @@ #include "TrackingNN.h" +#ifdef _WIN32 +#define _USE_MATH_DEFINES +#include +#endif + #include "kernelsThrust.h" diff --git a/include/tkDNN/CenternetDetection3D.h b/include/tkDNN/CenternetDetection3D.h index f9c918f..9f2b214 100644 --- a/include/tkDNN/CenternetDetection3D.h +++ b/include/tkDNN/CenternetDetection3D.h @@ -9,6 +9,11 @@ #include // std::iota #include // std::sort +#ifdef _WIN32 +#define _USE_MATH_DEFINES +#include +#endif + #include "DetectionNN3D.h" #include "kernelsThrust.h" diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index d1234a5..0c1c5ca 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -56,8 +56,8 @@ public: int id = 0; bool final; //if the layer is the final one - uint n_params = 0; - uint feature_map_size = 0; + unsigned int n_params = 0; + unsigned int feature_map_size = 0; long unsigned MACC = 0; diff --git a/include/tkDNN/SegmentationNN.h b/include/tkDNN/SegmentationNN.h index b691cbc..ad21d74 100644 --- a/include/tkDNN/SegmentationNN.h +++ b/include/tkDNN/SegmentationNN.h @@ -4,7 +4,9 @@ #include #include #include +#ifdef __linux__ #include +#endif #include #include "utils.h" diff --git a/include/tkDNN/demo_utils.h b/include/tkDNN/demo_utils.h index 06a8970..c39e704 100644 --- a/include/tkDNN/demo_utils.h +++ b/include/tkDNN/demo_utils.h @@ -9,12 +9,13 @@ #ifdef __linux__ #include +#endif + #include #include #include #include -#endif void readCalibrationMatrix(const std::string& path, cv::Mat& calib_mat); diff --git a/src/CenterTrack.cpp b/src/CenterTrack.cpp index dc15823..7931488 100644 --- a/src/CenterTrack.cpp +++ b/src/CenterTrack.cpp @@ -17,6 +17,7 @@ bool CenterTrack::init(const std::string& tensor_path, const int n_classes, cons init_pre_inf(); init_postprocessing(); init_visualization(n_classes); + return true; } bool CenterTrack::init_preprocessing(){ @@ -274,6 +275,8 @@ bool CenterTrack::init_visualization(const int n_classes){ faceId.push_back({3,0,4,7}); faceId.push_back({2,3,7,6}); // ([[0,1,5,4], [1,2,6, 5], [2,3,7,6], [3,0,4,7]]); + + return true; } void CenterTrack::_get_additional_inputs(){ @@ -413,9 +416,9 @@ cv::Mat CenterTrack::transform_preds_with_trans(float x1, float x2){ } void CenterTrack::tracking(const int bi) { - float item_size[countDet]; - int item_cl[countDet]; - float dets[2*countDet]; + std::vector item_size(countDet); + std::vector item_cl(countDet); + std::vector dets(2*countDet); for(int i=0; i(0,0) - detRes[i].bb0.at(0,0)) * (detRes[i].bb1.at(0,1) - detRes[i].bb0.at(0,1)); @@ -424,9 +427,9 @@ void CenterTrack::tracking(const int bi) { dets[i*2+1] = detRes[i].ct.at(0,1); } - float track_size[countTr[bi]]; - int track_cl[countTr[bi]]; - float tracks[2*countTr[bi]]; + std::vector track_size(countTr[bi]); + std::vector track_cl(countTr[bi]); + std::vector tracks(2*countTr[bi]); for(int i=0; i(0,0) - trRes[bi][i].det_res.bb0.at(0,0)) * (trRes[bi][i].det_res.bb1.at(0,1) - trRes[bi][i].det_res.bb0.at(0,1)); @@ -434,7 +437,7 @@ void CenterTrack::tracking(const int bi) { tracks[i*2] = trRes[bi][i].det_res.ct.at(0,0); tracks[i*2+1] = trRes[bi][i].det_res.ct.at(0,1); } - float dist[countTr[bi]*countDet]; + std::vector dist(countTr[bi]*countDet); bool invalid; for(int i=0; i matched_indices(2*countTr[bi]); float min_tr; int min_idtr = -1; for(int i=0; i unmatched_dets(countDet); for(int i=0; i unmatched_tracks(countTr[bi]); for(int i=0; i Date: Sun, 25 Jul 2021 23:53:30 +0530 Subject: [PATCH 03/32] fix for downloading weights(utils.cpp) when using docker --- src/utils.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/utils.cpp b/src/utils.cpp index 71dcce6..510b778 100644 --- a/src/utils.cpp +++ b/src/utils.cpp @@ -23,7 +23,7 @@ bool fileExist(const char *fname) { void downloadWeightsifDoNotExist(const std::string& input_bin, const std::string& test_folder, const std::string& weights_url){ if(!fileExist(input_bin.c_str())){ std::string mkdir_cmd = "mkdir " + test_folder; - std::string wget_cmd = "curl " + weights_url + " --output " + test_folder + "/weights.zip"; + std::string wget_cmd = "curl -tlsv1 -C - " + weights_url + " --output " + test_folder + "/weights.zip --user user:pass -O --retry 999 --retry-max-time 0"; #ifdef __linux__ std::string unzip_cmd = "unzip " + test_folder + "/weights.zip -d" + test_folder; std::string rm_cmd = "rm " + test_folder + "/weights.zip"; -- 2.52.0 From d2ce966c46877495a1d9fa83edab45620173ec4e Mon Sep 17 00:00:00 2001 From: perseusdg Date: Wed, 4 Aug 2021 12:37:58 +0530 Subject: [PATCH 04/32] fix return type for bool functions --- include/tkDNN/SegmentationNN.h | 1 + src/CenterTrack.cpp | 4 +++- src/CenternetDetection.cpp | 1 + src/CenternetDetection3D.cpp | 1 + 4 files changed, 6 insertions(+), 1 deletion(-) diff --git a/include/tkDNN/SegmentationNN.h b/include/tkDNN/SegmentationNN.h index ad21d74..403bc28 100644 --- a/include/tkDNN/SegmentationNN.h +++ b/include/tkDNN/SegmentationNN.h @@ -183,6 +183,7 @@ class SegmentationNN { checkCuda(cudaMemcpyAsync(mean_d, mean.data(), mean.size() * sizeof(float), cudaMemcpyHostToDevice, netRT->stream)); checkCuda(cudaMemcpyAsync(stddev_d, stddev.data(), stddev.size() * sizeof(float), cudaMemcpyHostToDevice, netRT->stream)); + return true; } diff --git a/src/CenterTrack.cpp b/src/CenterTrack.cpp index 7931488..55bf82f 100644 --- a/src/CenterTrack.cpp +++ b/src/CenterTrack.cpp @@ -60,6 +60,7 @@ bool CenterTrack::init_preprocessing(){ checkCuda( cudaMalloc(&input_d, sizeof(dnnType)*netRT->input_dim.tot() * nBatches)); checkCuda( cudaMalloc(&input_pre_inf_d, sizeof(dnnType)*dim.tot())); checkCuda( cudaMalloc(&d_ptrs, dim.tot() * sizeof(float)) ); + return true; } bool CenterTrack::init_pre_inf(){ @@ -203,6 +204,7 @@ bool CenterTrack::init_postprocessing(){ trRes.resize(nBatches); countTr.resize(nBatches, 0); trackId.resize(nBatches, 0); + return true; } bool CenterTrack::init_visualization(const int n_classes){ @@ -311,7 +313,7 @@ void CenterTrack::preprocess(cv::Mat &frame, const int bi){ } float c[] = {new_width / 2.0f, new_height /2.0f}; - float s[] = {dim.w, dim.h}; + float s[] = {static_cast(dim.w), static_cast(dim.h)}; // float s = new_width >= new_height ? new_width : new_height; // ----------- get_affine_transform // rot_rad = pi * 0 / 100 --> 0 diff --git a/src/CenternetDetection.cpp b/src/CenternetDetection.cpp index bd09005..a06bc11 100644 --- a/src/CenternetDetection.cpp +++ b/src/CenternetDetection.cpp @@ -118,6 +118,7 @@ bool CenternetDetection::init(const std::string& tensor_path, const int n_classe dst2.at(2,0)=dst2.at(1,0) + (-dst2.at(0,1)+dst2.at(1,1) ); dst2.at(2,1)=dst2.at(1,1) + (dst2.at(0,0)-dst2.at(1,0) ); + return true; } diff --git a/src/CenternetDetection3D.cpp b/src/CenternetDetection3D.cpp index 653624b..fd09132 100644 --- a/src/CenternetDetection3D.cpp +++ b/src/CenternetDetection3D.cpp @@ -167,6 +167,7 @@ bool CenternetDetection3D::init(const std::string& tensor_path, const int n_clas faceId.push_back({2,3,7,6}); faceId.push_back({3,0,4,7}); // ([[0,1,5,4], [1,2,6, 5], [2,3,7,6], [3,0,4,7]]); + return true; } void CenternetDetection3D::preprocess(cv::Mat &frame, const int bi){ -- 2.52.0 From eba78e7e78093e534938b2dc32a3cfd2a16ee9e4 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Mon, 16 Aug 2021 13:59:19 +0530 Subject: [PATCH 05/32] Updates to build libkernel.so under TensorRT 8 --- CMakeLists.txt | 2 +- include/tkDNN/Int8BatchStream.h | 4 +- include/tkDNN/Int8Calibrator.h | 8 +- include/tkDNN/NetworkRT.h | 7 +- include/tkDNN/pluginsRT/ActivationLeakyRT.h | 168 ++++++--- .../tkDNN/pluginsRT/ActivationLogisticRT.h | 107 +++++- include/tkDNN/pluginsRT/ActivationMishRT.h | 159 +++++--- .../tkDNN/pluginsRT/ActivationReLUCeilingRT.h | 172 ++++++--- include/tkDNN/pluginsRT/DeformableConvRT.h | 203 +++++++++- include/tkDNN/pluginsRT/FlattenConcatRT.h | 119 +++++- .../tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h | 139 ++++++- include/tkDNN/pluginsRT/RegionRT.h | 125 ++++++- include/tkDNN/pluginsRT/ReorgRT.h | 115 +++++- include/tkDNN/pluginsRT/ReshapeRT.h | 122 +++++- include/tkDNN/pluginsRT/ResizeLayerRT.h | 129 ++++++- include/tkDNN/pluginsRT/RouteRT.h | 127 +++++-- include/tkDNN/pluginsRT/ShortcutRT.h | 137 +++++-- include/tkDNN/pluginsRT/UpsampleRT.h | 123 +++++-- include/tkDNN/pluginsRT/YoloRT.h | 347 ++++++++++++------ include/tkDNN/utils.h | 10 + src/Int8Calibrator.cpp | 2 +- 21 files changed, 1878 insertions(+), 447 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index b366416..3e823dc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.15) project (tkDNN) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) if(UNIX) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fPIC -Wno-deprecated-declarations -Wno-unused-variable ") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations -Wno-unused-variable ") endif() if(WIN32) set(CMAKE_CXX_STANDARD 11) diff --git a/include/tkDNN/Int8BatchStream.h b/include/tkDNN/Int8BatchStream.h index c39a11c..028f75d 100644 --- a/include/tkDNN/Int8BatchStream.h +++ b/include/tkDNN/Int8BatchStream.h @@ -39,7 +39,7 @@ public: float *getLabels() { return mLabels.data(); } int getBatchesRead() const { return mBatchCount; } int getBatchSize() const { return mBatchSize; } - nvinfer1::DimsNCHW getDims() const { return mDims; } + nvinfer1::Dims4 getDims() const { return mDims; } float* getFileBatch() { return &mFileBatch[0]; } float* getFileLabels() { return &mFileLabels[0]; } void readInListFile(const std::string& dataFilePath, std::vector& mListIn); @@ -55,7 +55,7 @@ private: int mFileBatchPos{ 0 }; int mImageSize{ 0 }; - nvinfer1::DimsNCHW mDims; + nvinfer1::Dims4 mDims; std::vector mBatch; std::vector mLabels; std::vector mFileBatch; diff --git a/include/tkDNN/Int8Calibrator.h b/include/tkDNN/Int8Calibrator.h index 4a0ea47..c7a7d97 100644 --- a/include/tkDNN/Int8Calibrator.h +++ b/include/tkDNN/Int8Calibrator.h @@ -30,10 +30,10 @@ public: Int8EntropyCalibrator(BatchStream& stream, int firstBatch, const std::string& calibTableFilePath, const std::string& inputBlobName, bool readCache = true); virtual ~Int8EntropyCalibrator() { checkCuda(cudaFree(mDeviceInput)); } - int getBatchSize() const override { return mStream.getBatchSize(); } - bool getBatch(void* bindings[], const char* names[], int nbBindings) override; - const void* readCalibrationCache(size_t& length) override; - void writeCalibrationCache(const void* cache, size_t length) override; + int getBatchSize() const NOEXCEPT override { return mStream.getBatchSize(); } + bool getBatch(void* bindings[], const char* names[], int nbBindings) NOEXCEPT override; + const void* readCalibrationCache(size_t& length) NOEXCEPT override; + void writeCalibrationCache(const void* cache, size_t length) NOEXCEPT override; private: BatchStream mStream; diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 9892a24..53d8d91 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -40,14 +40,16 @@ using namespace nvinfer1; #include "pluginsRT/ReshapeRT.h" #include "pluginsRT/MaxPoolingFixedSizeRT.h" -class PluginFactory : IPluginFactory +/* +class PluginFactory : IPlugin { public: YoloRT *yolos[16]; int n_yolos; virtual IPlugin* createPlugin(const char* layerName, const void* serialData, size_t serialLength); -}; +};*/ + @@ -74,7 +76,6 @@ public: dnnType *output; cudaStream_t stream; - PluginFactory *pluginFactory; NetworkRT(Network *net, const char *name); virtual ~NetworkRT(); diff --git a/include/tkDNN/pluginsRT/ActivationLeakyRT.h b/include/tkDNN/pluginsRT/ActivationLeakyRT.h index 330ed37..6005013 100644 --- a/include/tkDNN/pluginsRT/ActivationLeakyRT.h +++ b/include/tkDNN/pluginsRT/ActivationLeakyRT.h @@ -1,61 +1,147 @@ -#include #include "../kernels.h" +#include -class ActivationLeakyRT : public IPlugin { +class ActivationLeakyRT : public IPluginV2 { public: - ActivationLeakyRT(float s) { - slope = s; - } + ActivationLeakyRT(float s) { slope = s; } - ~ActivationLeakyRT(){ + ActivationLeakyRT(const void *data, size_t length) + { + const char* buf = reinterpret_cast(data),*bufCheck = buf; + slope = readBUF(buf); + size = readBUF(buf); + assert(buf == bufCheck + length); - } + } - int getNbOutputs() const override { - return 1; - } + ~ActivationLeakyRT() {} - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } + int getNbOutputs() const NOEXCEPT override { return 1; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - size = 1; - for(int i=0; i(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, slope, + stream); + return 0; + } - activationLEAKYForward((dnnType*)reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), batchSize*size, slope, stream); - return 0; - } + virtual size_t getSerializationSize() const NOEXCEPT override { + return 1 * sizeof(int) + 1 * sizeof(float); + } + virtual void serialize(void *buffer) const NOEXCEPT override { + char *buf = reinterpret_cast(buffer), *a = buf; + tk::dnn::writeBUF(buf, size); + assert(buf == a + getSerializationSize()); + } - virtual size_t getSerializationSize() override { - return 1*sizeof(int) + 1*sizeof(float); - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); + } - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, size); - assert(buf == a + getSerializationSize()); - } + const char *getPluginType() const NOEXCEPT override { + return "ActivationLeakyRT_tkDNN"; + } - int size; - float slope; + const char *getPluginVersion() const NOEXCEPT override { + return "1"; + } + + void destroy() NOEXCEPT override { delete this; } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { + mPluginNamespace = pluginNamespace; + } + + IPluginV2* clone() const NOEXCEPT override { + ActivationLeakyRT *p = new ActivationLeakyRT(slope); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + + int size; + float slope; + +private: + std::string mPluginNamespace; }; + +class ActivationLeakyRTPluginCreator : public IPluginCreator { +public: + ActivationLeakyRTPluginCreator() { + mPluginAttributes.emplace_back( + PluginField("slope", nullptr, PluginFieldType::kFLOAT32, 1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override { + ActivationLeakyRT *pluginObj = new ActivationLeakyRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 1); + assert(fields[0].type == PluginFieldType::kFLOAT32); + float slope = *(static_cast(fields[0].data)); + ActivationLeakyRT *pluginObj = new ActivationLeakyRT(slope); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ActivationLeakyRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(ActivationLeakyRTPluginCreator); \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ActivationLogisticRT.h b/include/tkDNN/pluginsRT/ActivationLogisticRT.h index 063931f..bf4bcfd 100644 --- a/include/tkDNN/pluginsRT/ActivationLogisticRT.h +++ b/include/tkDNN/pluginsRT/ActivationLogisticRT.h @@ -1,11 +1,18 @@ #include #include "../kernels.h" -class ActivationLogisticRT : public IPlugin { +class ActivationLogisticRT : public IPluginV2 { public: ActivationLogisticRT() { + } + + ActivationLogisticRT(const void *data, size_t length) + { + const char* buf = reinterpret_cast(data),*bufCheck = buf; + size = readBUF(buf); + assert(buf == bufCheck + length); } @@ -13,33 +20,33 @@ public: } - int getNbOutputs() const override { + int getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { return inputs[0]; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { size = 1; for(int i=0; i(inputs[0]), reinterpret_cast(outputs[0]), batchSize*size, stream); @@ -47,14 +54,94 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 1*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer); tk::dnn::writeBUF(buf, size); } + const char *getPluginType() const NOEXCEPT override { + return "ActivationLogisticRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override { + return "1"; + } + + void destroy() NOEXCEPT override { delete this; } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { + mPluginNamespace = pluginNamespace; + } + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + //todo assert; + } + + IPluginV2 *clone() const NOEXCEPT override{ + ActivationLogisticRT *p = new ActivationLogisticRT(); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int size; + +private: + std::string mPluginNamespace; }; + +class ActivationLogisticRTPluginCreator : public IPluginCreator{ +public: + ActivationLogisticRTPluginCreator(){ + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override { + ActivationLogisticRT *pluginObj = new ActivationLogisticRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override { + ActivationLogisticRT *pluginObj = new ActivationLogisticRT(); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ActivationLogisticRT_tkDNN"; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(ActivationLogisticRTPluginCreator); \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ActivationMishRT.h b/include/tkDNN/pluginsRT/ActivationMishRT.h index 5d660af..a34418b 100644 --- a/include/tkDNN/pluginsRT/ActivationMishRT.h +++ b/include/tkDNN/pluginsRT/ActivationMishRT.h @@ -1,61 +1,134 @@ #include #include "../kernels.h" -class ActivationMishRT : public IPlugin { +class ActivationMishRT : public IPluginV2 { public: - ActivationMishRT() { + ActivationMishRT() {} + + ~ActivationMishRT() {} + + ActivationMishRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data), *bufCheck = buf; + size = readBUF(buf); + assert(buf == bufCheck + length); + } - } + int getNbOutputs() const NOEXCEPT override { return 1; } - ~ActivationMishRT(){ + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override { return inputs[0]; } - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override { + assert(format == PluginFormat::kLINEAR); + size = 1; + for (int i = 0; i < outputDims[0].nbDims; i++) + size *= outputDims[0].d[i]; + } - int getNbOutputs() const override { - return 1; - } + int initialize() NOEXCEPT override { return 0; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } + virtual void terminate() NOEXCEPT override {} - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - size = 1; - for(int i=0; i(inputs[0]), - reinterpret_cast(outputs[0]), batchSize*size, stream); - return 0; - } + virtual int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override { + activationMishForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, stream); + return 0; + } - virtual size_t getSerializationSize() override { - return 1*sizeof(int); - } + virtual size_t getSerializationSize() const NOEXCEPT override { + return 1 * sizeof(int); + } - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, size); - assert(buf == a + getSerializationSize()); - } + virtual void serialize(void *buffer) const NOEXCEPT override { + char *buf = reinterpret_cast(buffer), *a = buf; + tk::dnn::writeBUF(buf, size); + assert(buf == a + getSerializationSize()); + } - int size; + const char *getPluginType() const NOEXCEPT override { + return "ActivationMishRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override { + return "1"; + } + + void destroy() NOEXCEPT override { delete this; } + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *plguinNamespace) NOEXCEPT override { + mPluginNamespace = plguinNamespace; + } + + IPluginV2 *clone() const NOEXCEPT override { + ActivationMishRT *p = new ActivationMishRT(); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + + int size; +private: + std::string mPluginNamespace; }; + +class ActivationMishRTPluginCreator : public IPluginCreator { +public: + ActivationMishRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { + mPluginNamespace = pluginNamespace; + } + + const char* getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ + ActivationMishRT *pluginObj = new ActivationMishRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + ActivationMishRT *pluginObj = new ActivationMishRT(); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ActivationMishRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(ActivationMishRTPluginCreator); \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h index 50ceb81..4d2652e 100644 --- a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h +++ b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h @@ -1,63 +1,149 @@ #include #include "../kernels.h" -class ActivationReLUCeiling : public IPlugin { + +class ActivationReLUCeiling : public IPluginV2 { public: - ActivationReLUCeiling(const float ceiling) { - this->ceiling = ceiling; - } + ActivationReLUCeiling(const float ceiling) { + this->ceiling = ceiling; + } - ~ActivationReLUCeiling(){ + ~ActivationReLUCeiling() { - } + } - int getNbOutputs() const override { - return 1; - } + ActivationReLUCeiling(const void *data, size_t length) { + const char *buf = reinterpret_cast(data), *bufCheck = buf; + ceiling = readBUF(buf); + size = readBUF(buf); + assert(buf == bufCheck + length); + } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } + int getNbOutputs() const NOEXCEPT override { + return 1; + } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - size = 1; - for(int i=0; i(inputs[0]), - reinterpret_cast(outputs[0]), batchSize*size, ceiling, stream); - return 0; - } + virtual int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override { + activationReLUCeilingForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, ceiling, stream); + return 0; + } - virtual size_t getSerializationSize() override { - return 1*sizeof(int) + 1*sizeof(float); - } + virtual size_t getSerializationSize() const NOEXCEPT override { + return 1 * sizeof(int) + 1 * sizeof(float); + } - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, ceiling); - tk::dnn::writeBUF(buf, size); - assert(buf = a + getSerializationSize()); - - } + virtual void serialize(void *buffer) const NOEXCEPT override { + char *buf = reinterpret_cast(buffer), *a = buf; + tk::dnn::writeBUF(buf, ceiling); + tk::dnn::writeBUF(buf, size); + assert(buf = a + getSerializationSize()); - int size; - float ceiling; + } + + IPluginV2 *clone() const NOEXCEPT override { + ActivationReLUCeiling *p = new ActivationReLUCeiling(ceiling); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); + } + + void destroy() NOEXCEPT override { delete this; }; + + const char *getPluginType() const NOEXCEPT override { + return "ActivationReLUCeilingRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override { + return "1"; + } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { + mPluginNamespace = pluginNamespace; + } + + int size; + float ceiling; +private: + std::string mPluginNamespace; }; + +class ActivationReLUCeilingPluginCreator : public IPluginCreator { +public: + ActivationReLUCeilingPluginCreator() { + mPluginAttributes.emplace_back(PluginField("ceiling", nullptr, PluginFieldType::kFLOAT32, 1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override { + ActivationReLUCeiling *pluginObj = new ActivationReLUCeiling(serialData, serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + float ceiling = *(static_cast(fields[0].data)); + ActivationReLUCeiling *pluginObj = new ActivationReLUCeiling(ceiling); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ActivationReLUCeilingRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(ActivationReLUCeilingPluginCreator); diff --git a/include/tkDNN/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h index 711198f..46aa9e7 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -1,8 +1,7 @@ #include #include "../kernels.h" - -class DeformableConvRT : public IPlugin { +class DeformableConvRT : public IPluginV2 { @@ -27,6 +26,8 @@ public: this->o_c = o_c; this->o_h = o_h; this->o_w = o_w; + this->defRT = deformable; + height_ones = (i_h + 2 * ph - (1 * (kh - 1) + 1)) / sh + 1; width_ones = (i_w + 2 * pw - (1 * (kw - 1) + 1)) / sw + 1; dim_ones = i_c * kh * kw * 1 * height_ones * width_ones; @@ -38,7 +39,6 @@ public: checkCuda( cudaMalloc(&mask, chunk_dim*sizeof(dnnType))); checkCuda( cudaMalloc(&ones_d2, dim_ones*sizeof(dnnType))); if(deformable != nullptr) { - this->defRT = deformable; checkCuda( cudaMemcpy(data_d, deformable->data_d, sizeof(dnnType)*i_c * o_c * kh * kw * 1, cudaMemcpyDeviceToDevice) ); checkCuda( cudaMemcpy(bias2_d, deformable->bias2_d, sizeof(dnnType)*o_c, cudaMemcpyDeviceToDevice) ); checkCuda( cudaMemcpy(ones_d1, deformable->ones_d1, sizeof(dnnType)*height_ones*width_ones, cudaMemcpyDeviceToDevice) ); @@ -61,27 +61,78 @@ public: cublasDestroy(handle); } - int getNbOutputs() const override { - return 1; + DeformableConvRT(const void *data,size_t length){ + const char* buf = reinterpret_cast(data),*bufCheck = buf; + chunk_dim = readBUF(buf); + kh = readBUF(buf); + kw = readBUF(buf); + sh = readBUF(buf); + sw = readBUF(buf); + ph = readBUF(buf); + pw = readBUF(buf); + deformableGroup = readBUF(buf); + i_n = readBUF(buf); + i_c = readBUF(buf); + i_h = readBUF(buf); + i_w = readBUF(buf); + o_n = readBUF(buf); + o_c = readBUF(buf); + o_h = readBUF(buf); + o_w = readBUF(buf); + dnnType *aus = new dnnType[chunk_dim*2]; + for(int i=0;i(buf); + checkCuda(cudaMemcpy(offset,aus,sizeof(dnnType)*2*chunk_dim,cudaMemcpyHostToDevice)); + free(aus); + + aus = new dnnType[chunk_dim]; + for(int i=0;i(buf); + checkCuda(cudaMemcpy(mask,aus,sizeof(dnnType)*chunk_dim,cudaMemcpyHostToDevice)); + free(aus); + + aus = new dnnType[i_c*o_c*kh*kw*1]; + for(int i=0;i<(i_c*o_c*kh*kw*1);i++) + aus[i] = readBUF(buf); + checkCuda(cudaMemcpy(data_d,aus,sizeof(dnnType)*(i_c*o_c*kh*kw*1),cudaMemcpyHostToDevice)); + free(aus); + + aus = new dnnType[o_c]; + for(int i=0; i < o_c; i++) + aus[i] = readBUF(buf); + checkCuda( cudaMemcpy(bias2_d, aus, sizeof(dnnType)*o_c, cudaMemcpyHostToDevice) ); + free(aus); + + aus = new dnnType[height_ones * width_ones]; + for(int i=0; i(buf); + checkCuda( cudaMemcpy(ones_d1, aus, sizeof(dnnType)*height_ones * width_ones, cudaMemcpyHostToDevice) ); + free(aus); + + aus = new dnnType[dim_ones]; + for(int i=0; i(buf); + checkCuda( cudaMemcpy(ones_d2, aus, sizeof(dnnType)*dim_ones, cudaMemcpyHostToDevice) ); + free(aus); + + assert(buf == bufCheck + length); } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{defRT->output_dim.c, defRT->output_dim.h, defRT->output_dim.w}; + int getNbOutputs() const NOEXCEPT override {return 1;} + + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{defRT->output_dim.c, defRT->output_dim.h, defRT->output_dim.w}; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { } + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { } - int initialize() override { - return 0; - } + int initialize() NOEXCEPT override {return 0;} - virtual void terminate() override { } + virtual void terminate() NOEXCEPT override { } - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *output_conv = (dnnType*)reinterpret_cast(inputs[1]); @@ -109,13 +160,12 @@ public: return 0; } - - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 16 * sizeof(int) + chunk_dim * 3 * sizeof(dnnType) + (i_c * o_c * kh * kw * 1 ) * sizeof(dnnType) + o_c * sizeof(dnnType) + height_ones * width_ones * sizeof(dnnType) + dim_ones * sizeof(dnnType); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, chunk_dim); tk::dnn::writeBUF(buf, kh); @@ -166,6 +216,35 @@ public: assert(buf == a + getSerializationSize()); } + void destroy() NOEXCEPT override {delete this;} + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + //todo assert + } + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginType() const NOEXCEPT override{ + return "DeformableConvRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + IPluginV2* clone() const NOEXCEPT override{ + DeformableConvRT *p = new DeformableConvRT(chunk_dim,kh,kw,sh,sw,ph,pw,deformableGroup,i_n,i_c,i_h,i_w,o_n,o_c,o_h,o_w,defRT); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + + cublasStatus_t stat; cublasHandle_t handle; int i_n, i_c, i_h, i_w; @@ -193,4 +272,90 @@ public: tk::dnn::DeformConv2d *defRT; + +private: + std::string mPluginNamespace; }; + +class DeformableConvRTPluginCreator : public IPluginCreator{ +public: + DeformableConvRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("chunk_dim",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kh",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kw",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sh",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sw",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("ph",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("pw",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("deformableGroup",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_n",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_n",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("defRT",nullptr,PluginFieldType::kUNKNOWN,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ + DeformableConvRT *pluginObj = new DeformableConvRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + int chunk_dim = *(static_cast(fields[0].data)); + int kh = *(static_cast(fields[1].data)); + int kw = *(static_cast(fields[2].data)); + int sh = *(static_cast(fields[3].data)); + int sw = *(static_cast(fields[4].data)); + int ph = *(static_cast(fields[5].data)); + int pw = *(static_cast(fields[6].data)); + int deformableGroup = *(static_cast(fields[7].data)); + int i_n = *(static_cast(fields[8].data)); + int i_c = *(static_cast(fields[9].data)); + int i_h = *(static_cast(fields[10].data)); + int i_w = *(static_cast(fields[11].data)); + int o_n = *(static_cast(fields[12].data)); + int o_c = *(static_cast(fields[13].data)); + int o_h = *(static_cast(fields[14].data)); + int o_w = *(static_cast(fields[14].data)); + DeformConv2d *defRT = const_cast(static_cast(fields[15].data)); + DeformableConvRT *pluginObj = new DeformableConvRT(chunk_dim,kh,kw,sh,sw,ph,pw,deformableGroup,i_n,i_c,i_h,i_w,o_n,o_c,o_h,o_w,defRT); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "DeformableConvRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(DeformableConvRTPluginCreator); + diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index 51aa1ab..c8b6c0f 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -1,6 +1,6 @@ #include -class FlattenConcatRT : public IPlugin { +class FlattenConcatRT : public IPluginV2 { public: FlattenConcatRT() { @@ -11,19 +11,29 @@ public: } } + FlattenConcatRT(const void *data,size_t length){ + const char *buf = reinterpret_cast(data),*bufCheck=buf; + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + rows = readBUF(buf); + cols = readBUF(buf); + assert(buf == bufCheck + length); + } + ~FlattenConcatRT(){ } - int getNbOutputs() const override { + int getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{ inputs[0].d[0] * inputs[0].d[1] * inputs[0].d[2], 1, 1}; + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{ inputs[0].d[0] * inputs[0].d[1] * inputs[0].d[2], 1, 1}; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { assert(nbOutputs == 1 && nbInputs ==1); rows = inputDims[0].d[0]; cols = inputDims[0].d[1] * inputDims[0].d[2]; @@ -32,19 +42,13 @@ public: w = 1; } - int initialize() override { - return 0; - } + int initialize() NOEXCEPT override {return 0;} - virtual void terminate() override { - checkERROR(cublasDestroy(handle)); - } + virtual void terminate() NOEXCEPT override { checkERROR(cublasDestroy(handle));} - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override {return 0;} - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *dstData = reinterpret_cast(outputs[0]); checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*rows*cols*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); @@ -59,12 +63,11 @@ public: return 0; } - - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 5*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a = buf; tk::dnn::writeBUF(buf, c); tk::dnn::writeBUF(buf, h); @@ -74,8 +77,86 @@ public: assert(buf == a + getSerializationSize()); } + void destroy() NOEXCEPT override{delete this;} + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + } + + const char *getPluginType() const NOEXCEPT override{ + return "FlattenConcatRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2 *clone() const NOEXCEPT override { + FlattenConcatRT *p = new FlattenConcatRT(); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int c, h, w; int rows, cols; cublasStatus_t stat; - cublasHandle_t handle; + cublasHandle_t handle; +private: + std::string mPluginNamespace; }; + +class FlattenConcatRTPluginCreator : public IPluginCreator{ +public: + FlattenConcatRTPluginCreator(){ + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ + FlattenConcatRT *pluginObj = new FlattenConcatRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ + FlattenConcatRT *pluginObj = new FlattenConcatRT(); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "FlattenConcatRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(FlattenConcatRTPluginCreator); \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h index 0899a34..53fdd4e 100644 --- a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h +++ b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h @@ -1,7 +1,8 @@ #include #include "../kernels.h" -class MaxPoolFixedSizeRT : public IPlugin { + +class MaxPoolFixedSizeRT : public IPluginV2 { public: MaxPoolFixedSizeRT(int c, int h, int w, int n, int strideH, int strideW, int winSize, int padding) { @@ -15,32 +16,40 @@ public: this->padding = padding; } + MaxPoolFixedSizeRT(const void *data,size_t length){ + const char *buf = reinterpret_cast(data),*bufCheck = buf; + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + n = readBUF(buf); + stride_H = readBUF(buf); + stride_W = readBUF(buf); + winSize = readBUF(buf); + padding = readBUF(buf); + assert(buf == bufCheck + length); + } + ~MaxPoolFixedSizeRT(){ } - int getNbOutputs() const override { + int getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{this->c, this->h, this->w}; + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{this->c, this->h, this->w}; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { } - int initialize() override { - return 0; - } + int initialize() NOEXCEPT override {return 0;} - virtual void terminate() override { - } + virtual void terminate() NOEXCEPT override {} - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { //std::cout<n<<" "<c<<" "<h<<" "<w<<" "<stride_H<<" "<stride_W<<" "<winSize<<" "<padding<(inputs[0]); @@ -50,11 +59,11 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 8*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, this->c); @@ -68,8 +77,106 @@ public: assert(buf == a + getSerializationSize()); } + void destroy() NOEXCEPT override{delete this;} + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + //todo assert + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + const char *getPluginType() const NOEXCEPT override{ + return "MaxPoolingFixedSizeRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + IPluginV2 *clone() const NOEXCEPT override{ + MaxPoolFixedSizeRT *p = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + + int n, c, h, w; int stride_H, stride_W; int winSize; int padding; + +private: + std::string mPluginNamespace; }; + +class MaxPoolFixedSizeRTPluginCreator : public IPluginCreator{ +public: + MaxPoolFixedSizeRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("stride_H",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("stride_W",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("winSize",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padding",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ + MaxPoolFixedSizeRT *pluginObj = new MaxPoolFixedSizeRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + //todo assert + int c = *(static_cast(fields[0].data)); + int h = *(static_cast(fields[1].data)); + int w = *(static_cast(fields[2].data)); + int n = *(static_cast(fields[3].data)); + int stride_H = *(static_cast(fields[4].data)); + int stride_W = *(static_cast(fields[5].data)); + int winSize = *(static_cast(fields[6].data)); + int padding = *(static_cast(fields[7].data)); + MaxPoolFixedSizeRT *pluginObj = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "MaxPoolingFixedSizeRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + +}; + +REGISTER_TENSORRT_PLUGIN(MaxPoolFixedSizeRTPluginCreator); diff --git a/include/tkDNN/pluginsRT/RegionRT.h b/include/tkDNN/pluginsRT/RegionRT.h index 8487652..8e1c2d2 100644 --- a/include/tkDNN/pluginsRT/RegionRT.h +++ b/include/tkDNN/pluginsRT/RegionRT.h @@ -1,11 +1,10 @@ #include #include "../kernels.h" -class RegionRT : public IPlugin { +class RegionRT : public IPluginV2 { public: RegionRT(int classes, int coords, int num) { - this->classes = classes; this->coords = coords; this->num = num; @@ -15,33 +14,39 @@ public: } - int getNbOutputs() const override { + RegionRT(const void *data,size_t length){ + const char *buf = reinterpret_cast(data),*bufCheck=buf; + classes = readBUF(buf); + coords = readBUF(buf); + num = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck+length); + } + + int getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { return inputs[0]; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { c = inputDims[0].d[0]; h = inputDims[0].d[1]; w = inputDims[0].d[2]; } - int initialize() override { + int initialize() NOEXCEPT override { return 0; } - return 0; - } - virtual void terminate() override { - } + virtual void terminate() NOEXCEPT override { } - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0; } - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *dstData = reinterpret_cast(outputs[0]); @@ -68,11 +73,11 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 6*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, classes); tk::dnn::writeBUF(buf, coords); @@ -83,6 +88,34 @@ public: assert(buf == a + getSerializationSize()); } + const char *getPluginType() const NOEXCEPT override{ + return "RegionRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + void destroy() NOEXCEPT override {delete this;} + + const char* getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + } + + IPluginV2* clone() const NOEXCEPT override{ + RegionRT *p = new RegionRT(classes,coords,num); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int c, h, w; int classes, coords, num; @@ -92,4 +125,64 @@ public: return batch*c*h*w + n*w*h*(coords+classes+1) + entry*w*h + loc; } +private: + std::string mPluginNamespace; }; + +class RegionRTPluginCreator : public IPluginCreator{ +public: + RegionRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("coords",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + IPluginV2 *deserializePlugin(const char* name,const void *serialData,size_t serialLength) NOEXCEPT override{ + RegionRT *pluginObj = new RegionRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + assert(fc->nbFields == 3); + assert(fields[0].type == PluginFieldType::kINT32); + assert(fields[1].type == PluginFieldType::kINT32); + assert(fields[2].type == PluginFieldType::kINT32); + int classes = *(static_cast(fields[0].data)); + int coords = *(static_cast(fields[1].data)); + int num = *(static_cast(fields[2].data)); + RegionRT *pluginObj = new RegionRT(classes,coords,num); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + + } + + const char *getPluginName() const NOEXCEPT override{ + return "RegionRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(RegionRTPluginCreator); + diff --git a/include/tkDNN/pluginsRT/ReorgRT.h b/include/tkDNN/pluginsRT/ReorgRT.h index c1b529a..01e5468 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -1,7 +1,7 @@ #include #include "../kernels.h" -class ReorgRT : public IPlugin { +class ReorgRT : public IPluginV2 { public: ReorgRT(int stride) { @@ -12,33 +12,34 @@ public: } - int getNbOutputs() const override { - return 1; + ReorgRT(const void* data,size_t length){ + const char* buf = reinterpret_cast(data),*bufCheck = buf; + stride = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{inputs[0].d[0]*stride*stride, inputs[0].d[1]/stride, inputs[0].d[2]/stride}; + int getNbOutputs() const NOEXCEPT override {return 1;} + + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{inputs[0].d[0]*stride*stride, inputs[0].d[1]/stride, inputs[0].d[2]/stride}; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { c = inputDims[0].d[0]; h = inputDims[0].d[1]; w = inputDims[0].d[2]; } - int initialize() override { + int initialize() NOEXCEPT override { return 0;} - return 0; - } + virtual void terminate() NOEXCEPT override {} - virtual void terminate() override { - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } - - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { reorgForward((dnnType*)reinterpret_cast(inputs[0]), reinterpret_cast(outputs[0]), @@ -47,11 +48,11 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 4*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, stride); tk::dnn::writeBUF(buf, c); @@ -59,6 +60,84 @@ public: tk::dnn::writeBUF(buf, w); assert(buf == a + getSerializationSize()); } + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{return true;} + + const char *getPluginType() const NOEXCEPT override{ + return "ReorgRT_tkDNN"; + } + + const char* getPluginVersion() const NOEXCEPT override{ + return "1"; + } + void destroy() NOEXCEPT override{ delete this;} + + const char* getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2* clone() const NOEXCEPT override{ + ReorgRT *p = new ReorgRT(stride); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } int c, h, w, stride; +private: + std::string mPluginNamespace; }; + +class ReorgRTPluginCreator : public IPluginCreator{ +public: + ReorgRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char* getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2* deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ + ReorgRT *pluginObj = new ReorgRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection* fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + assert(fc->nbFields == 1); + assert(fields[0].type == PluginFieldType::kINT32); + int stride = *(static_cast(fields[0].data)); + ReorgRT *pluginObj = new ReorgRT(stride); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ReorgRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(ReorgRTPluginCreator); + diff --git a/include/tkDNN/pluginsRT/ReshapeRT.h b/include/tkDNN/pluginsRT/ReshapeRT.h index 37017c7..fd74c61 100644 --- a/include/tkDNN/pluginsRT/ReshapeRT.h +++ b/include/tkDNN/pluginsRT/ReshapeRT.h @@ -1,42 +1,47 @@ #include -class ReshapeRT : public IPlugin { +class ReshapeRT : public IPluginV2 { public: - ReshapeRT(dataDim_t new_dim) { + ReshapeRT(dataDim_t newDim) { + new_dim = newDim; n = new_dim.n; c = new_dim.c; h = new_dim.h; w = new_dim.w; } + ReshapeRT(const void *data,size_t length){ + const char *buf = reinterpret_cast(data),*bufCheck = buf; + new_dim.n = readBUF(buf); + new_dim.c = readBUF(buf); + new_dim.h = readBUF(buf); + new_dim.w = readBUF(buf); + assert(buf == bufCheck + length); + } + ~ReshapeRT(){ } - int getNbOutputs() const override { + int getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{ c,h,w}; + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{ c,h,w}; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat (const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { } - int initialize() override { - return 0; - } + int initialize() NOEXCEPT override {return 0;} - virtual void terminate() override { - } + virtual void terminate() NOEXCEPT override {} - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *dstData = reinterpret_cast(outputs[0]); @@ -44,12 +49,11 @@ public: return 0; } - - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 4*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a = buf; tk::dnn::writeBUF(buf, n); tk::dnn::writeBUF(buf, c); @@ -58,5 +62,87 @@ public: assert(buf == a + getSerializationSize()); } + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + //todo assert + } + + const char *getPluginType() const NOEXCEPT override{ + return "1"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "ReshapeRT_tkDNN"; + } + + void destroy() NOEXCEPT override{delete this;} + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2 *clone() const NOEXCEPT override{ + ReshapeRT *p = new ReshapeRT(new_dim); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int n, c, h, w; + dataDim_t new_dim; +private: + std::string mPluginNamespace; }; + +class ReshapeRTPluginCreator : public IPluginCreator{ +public: + ReshapeRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("new_dim",nullptr,PluginFieldType::kUNKNOWN,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char* name,const void *serialData,size_t serialLength) NOEXCEPT override{ + ReshapeRT *pluginObj = new ReshapeRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + dataDim_t newDim = *(static_cast(fields[0].data)); + ReshapeRT *pluginObj = new ReshapeRT(newDim); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ReshapeRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(ReshapeRTPluginCreator); diff --git a/include/tkDNN/pluginsRT/ResizeLayerRT.h b/include/tkDNN/pluginsRT/ResizeLayerRT.h index cde52bf..9a982fd 100644 --- a/include/tkDNN/pluginsRT/ResizeLayerRT.h +++ b/include/tkDNN/pluginsRT/ResizeLayerRT.h @@ -1,7 +1,7 @@ #include #include "../kernels.h" -class ResizeLayerRT : public IPlugin { +class ResizeLayerRT : public IPluginV2 { public: ResizeLayerRT(int c, int h, int w) { @@ -10,35 +10,41 @@ public: o_w = w; } + ResizeLayerRT(const void *data,size_t length){ + const char *buf = reinterpret_cast(data),*bufCheck = buf; + o_c = readBUF(buf); + o_h = readBUF(buf); + o_w = readBUF(buf); + i_c = readBUF(buf); + i_h = readBUF(buf); + i_w = readBUF(buf); + assert(buf == bufCheck + length); + } + ~ResizeLayerRT(){ } - int getNbOutputs() const override { + int getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{o_c, o_h, o_w}; + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{o_c, o_h, o_w}; } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { i_c = inputDims[0].d[0]; i_h = inputDims[0].d[1]; i_w = inputDims[0].d[2]; } - int initialize() override { - return 0; - } + int initialize() NOEXCEPT override {return 0;} - virtual void terminate() override { - } + virtual void terminate() NOEXCEPT override {} - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { // printf("%d %d %d %d %d %d\n", i_c, i_w, i_h, o_c, o_w, o_h); resizeForward((dnnType*)reinterpret_cast(inputs[0]), reinterpret_cast(outputs[0]), @@ -47,11 +53,11 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 6*sizeof(int); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, o_c); @@ -64,5 +70,96 @@ public: assert(buf == a + getSerializationSize()); } + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + //todo assert + } + + const char *getPluginType() const NOEXCEPT override{ + return "ResizeLayerRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + void destroy() NOEXCEPT override{delete this;} + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + IPluginV2 *clone() const NOEXCEPT override{ + ResizeLayerRT *p = new ResizeLayerRT(o_c,o_h,o_w); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int i_c, i_h, i_w, o_c, o_h, o_w; + +private: + std::string mPluginNamespace; }; + +class ResizeLayerRTPluginCreator : public IPluginCreator{ +public: + ResizeLayerRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ + ResizeLayerRT *pluginObj = new ResizeLayerRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + assert(fc->nbFields == 3); + assert(fields[0].type == PluginFieldType::kINT32); + assert(fields[1].type == PluginFieldType::kINT32); + assert(fields[2].type == PluginFieldType::kINT32); + int oc = *(static_cast(fields[0].data)); + int oh = *(static_cast(fields[1].data)); + int ow = *(static_cast(fields[2].data)); + ResizeLayerRT *pluginObj = new ResizeLayerRT(oc,oh,ow); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ResizeLayerRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + +}; + +REGISTER_TENSORRT_PLUGIN(ResizeLayerRTPluginCreator); + diff --git a/include/tkDNN/pluginsRT/RouteRT.h b/include/tkDNN/pluginsRT/RouteRT.h index 5a8c170..635566c 100644 --- a/include/tkDNN/pluginsRT/RouteRT.h +++ b/include/tkDNN/pluginsRT/RouteRT.h @@ -1,7 +1,7 @@ #include #include "../kernels.h" -class RouteRT : public IPlugin { +class RouteRT : public IPluginV2 { /** THIS IS NOT USED ANYMORE @@ -17,17 +17,31 @@ public: } - int getNbOutputs() const override { + RouteRT(const void* data,size_t length){ + const char* buf = reinterpret_cast(data),*bufCheck = buf; + groups = readBUF(buf); + group_id = readBUF(buf); + in = readBUF(buf); + for(int i=0;i (buf); + } + c= readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); + } + + int getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { int out_c = 0; for(int i=0; i(outputs[0]); - for(int b=0; b(buffer),*a=buf; tk::dnn::writeBUF(buf, groups); tk::dnn::writeBUF(buf, group_id); @@ -88,9 +92,90 @@ public: assert(buf == a + getSerializationSize()); } + const char *getPluginType() const NOEXCEPT override{ + return "RouteRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + void destroy() NOEXCEPT override {delete this; } + + const char* getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override { return true;} + + IPluginV2* clone() const NOEXCEPT override{ + RouteRT *p = new RouteRT(groups,group_id); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } static const int MAX_INPUTS = 4; int in; int c_in[MAX_INPUTS]; int c, h, w; int groups, group_id; +private: + std::string mPluginNamespace; }; + +class RouteRTPluginCreator : public IPluginCreator{ +public: + RouteRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("groups",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("group_id",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ + RouteRT *pluginObj = new RouteRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + assert(fc->nbFields == 2); + assert(fields[0].type == PluginFieldType::kINT32); + assert(fields[1].type == PluginFieldType::kINT32); + int groups = *(static_cast(fields[0].data)); + int group_id = *(static_cast(fields[1].data)); + RouteRT *pluginObj = new RouteRT(groups,group_id); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "RouteRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(RouteRTPluginCreator); diff --git a/include/tkDNN/pluginsRT/ShortcutRT.h b/include/tkDNN/pluginsRT/ShortcutRT.h index 04091ac..f5b8219 100644 --- a/include/tkDNN/pluginsRT/ShortcutRT.h +++ b/include/tkDNN/pluginsRT/ShortcutRT.h @@ -1,47 +1,52 @@ #include #include "../kernels.h" -class ShortcutRT : public IPlugin { + +class ShortcutRT : public IPluginV2 { public: ShortcutRT(tk::dnn::dataDim_t bdim, bool mul) { - this->bc = bdim.c; - this->bh = bdim.h; - this->bw = bdim.w; + bDim = bdim; + this->bc = bDim.c; + this->bh = bDim.h; + this->bw = bDim.w; this->mul = mul; } - ~ShortcutRT(){ + ~ShortcutRT(){} + ShortcutRT(const void* data,size_t length){ + const char* buf =reinterpret_cast(data),*bufCheck = buf; + bDim.c = readBUF(buf); + bDim.h = readBUF(buf); + bDim.w = readBUF(buf); + bDim.l = 1; + mul = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); } - int getNbOutputs() const override { - return 1; + int getNbOutputs() const NOEXCEPT override {return 1;} + + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3{inputs[0].d[0], inputs[0].d[1], inputs[0].d[2]}; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW{inputs[0].d[0], inputs[0].d[1], inputs[0].d[2]}; - } - - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { c = inputDims[0].d[0]; h = inputDims[0].d[1]; w = inputDims[0].d[2]; } - int initialize() override { + int initialize() NOEXCEPT override {return 0;} - return 0; - } + virtual void terminate() NOEXCEPT override {} - virtual void terminate() override { - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } - - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *srcDataBack = (dnnType*)reinterpret_cast(inputs[1]); @@ -54,11 +59,11 @@ public: } - virtual size_t getSerializationSize() override { + virtual size_t getSerializationSize() const NOEXCEPT override { return 6*sizeof(int) + sizeof(bool); } - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, bc); tk::dnn::writeBUF(buf, bh); @@ -71,7 +76,91 @@ public: } + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + return true; + } + + const char* getPluginType() const NOEXCEPT override{ + return "1"; + } + + const char* getPluginVersion() const NOEXCEPT override{ + return "ShortcutRT_tkDNN"; + } + + void destroy() NOEXCEPT override{delete this;} + + const char* getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2 *clone() const NOEXCEPT override{ + ShortcutRT *p = new ShortcutRT(bDim,mul); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int c, h, w; int bc, bh, bw; bool mul; + tk::dnn::dataDim_t bDim; +private: + std::string mPluginNamespace; }; + + +class ShortcutRTPluginCreator : public IPluginCreator { +public: + ShortcutRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("bDim",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("mul",nullptr,PluginFieldType::kUNKNOWN,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ + ShortcutRT *pluginObj = new ShortcutRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + //todo assert + tk::dnn::dataDim_t bdim = *(static_cast(fields[0].data)); + bool mul = *(static_cast(fields[1].data)); + ShortcutRT *pluginObj = new ShortcutRT(bdim,mul); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "ShortcutRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(ShortcutRTPluginCreator); \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/UpsampleRT.h b/include/tkDNN/pluginsRT/UpsampleRT.h index a11d7b4..0a71c45 100644 --- a/include/tkDNN/pluginsRT/UpsampleRT.h +++ b/include/tkDNN/pluginsRT/UpsampleRT.h @@ -1,44 +1,47 @@ #include #include "../kernels.h" -class UpsampleRT : public IPlugin { + +class UpsampleRT : public IPluginV2 { public: UpsampleRT(int stride) { this->stride = stride; } - ~UpsampleRT(){ - + UpsampleRT(const void *data,size_t length){ + const char* buf = reinterpret_cast(data),*bufCheck=buf; + stride = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); } - int getNbOutputs() const override { + + ~UpsampleRT(){} + + int getNbOutputs() const NOEXCEPT override { return 1; } - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return DimsCHW(inputs[0].d[0], inputs[0].d[1]*stride, inputs[0].d[2]*stride); + Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { + return Dims3(inputs[0].d[0], inputs[0].d[1]*stride, inputs[0].d[2]*stride); } - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { + void configureWithFormat (const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { c = inputDims[0].d[0]; h = inputDims[0].d[1]; w = inputDims[0].d[2]; } - int initialize() override { + int initialize() NOEXCEPT override {return 0;} - return 0; - } + virtual void terminate() NOEXCEPT override {} - virtual void terminate() override { - } + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } - - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { + virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *dstData = reinterpret_cast(outputs[0]); @@ -49,11 +52,9 @@ public: } - virtual size_t getSerializationSize() override { - return 4*sizeof(int); - } + virtual size_t getSerializationSize() const NOEXCEPT override { return 4*sizeof(int);} - virtual void serialize(void* buffer) override { + virtual void serialize(void* buffer) const NOEXCEPT override { char *buf = reinterpret_cast(buffer),*a=buf; tk::dnn::writeBUF(buf, stride); tk::dnn::writeBUF(buf, c); @@ -62,5 +63,85 @@ public: assert(buf == a + getSerializationSize()); } + bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ + //todo assert + return true; + } + + const char *getPluginType() const NOEXCEPT override{ + return "1"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "UpsampleRT_tkDNN"; + } + + void destroy() NOEXCEPT override{delete this;} + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + IPluginV2* clone() const NOEXCEPT override{ + UpsampleRT *p = new UpsampleRT(stride); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + int c, h, w, stride; +private: + std::string mPluginNamespace; }; + +class UpsampleRTPluginCreator : public IPluginCreator{ +public: + UpsampleRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ + UpsampleRT *pluginObj = new UpsampleRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + int stride = *(static_cast(fields[0].data)); + UpsampleRT *pluginObj = new UpsampleRT(stride); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "UpsampleRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(UpsampleRTPluginCreator); diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index 5ffe39c..cc866c6 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -1,143 +1,268 @@ #include #include "../kernels.h" - #define YOLORT_CLASSNAME_W 256 -class YoloRT : public IPlugin { - - +class YoloRT : public IPluginV2 { public: - YoloRT(int classes, int num, tk::dnn::Yolo *yolo = nullptr, int n_masks=3, float scale_xy=1, float nms_thresh=0.45, int nms_kind=0, int new_coords=0) { - - this->classes = classes; - this->num = num; - this->n_masks = n_masks; - this->scaleXY = scale_xy; - this->nms_thresh = nms_thresh; - this->nms_kind = nms_kind; - this->new_coords = new_coords; + YoloRT(int classes, int num, tk::dnn::Yolo *Yolo = nullptr, int n_masks = 3, float scale_xy = 1, + float nms_thresh = 0.45, int nms_kind = 0, int new_coords = 0) { + this->yolo = Yolo; + this->classes = classes; + this->num = num; + this->n_masks = n_masks; + this->scaleXY = scale_xy; + this->nms_thresh = nms_thresh; + this->nms_kind = nms_kind; + this->new_coords = new_coords; mask = new dnnType[n_masks]; - bias = new dnnType[num*n_masks*2]; - if(yolo != nullptr) { - memcpy(mask, yolo->mask_h, sizeof(dnnType)*n_masks); - memcpy(bias, yolo->bias_h, sizeof(dnnType)*num*n_masks*2); - classesNames = yolo->classesNames; + bias = new dnnType[num * n_masks * 2]; + if (yolo != nullptr) { + memcpy(mask, yolo->mask_h, sizeof(dnnType) * n_masks); + memcpy(bias, yolo->bias_h, sizeof(dnnType) * num * n_masks * 2); + classesNames = yolo->classesNames; } - } + } - ~YoloRT(){ + YoloRT(const void *data,size_t length){ + const char* buf = reinterpret_cast(data),*bufCheck = buf; + classes = readBUF(buf); + num = readBUF(buf); + n_masks = readBUF(buf); + scaleXY = readBUF(buf); + nms_thresh = readBUF(buf); + nms_kind = readBUF(buf); + new_coords = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + for(int i=0;i(buf); + for(int i=0;i(buf); + classesNames.resize(classes); + for(int i=0;i(buf); + classesNames[1] = std::string(tmp); + } + assert(buf == bufCheck + length); + } - } + ~YoloRT() { - int getNbOutputs() const override { - return 1; - } - - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) override { - return inputs[0]; - } - - void configure(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, int maxBatchSize) override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } - - int initialize() override { - - return 0; - } - - virtual void terminate() override { - } - - virtual size_t getWorkspaceSize(int maxBatchSize) const override { - return 0; - } - - virtual int enqueue(int batchSize, const void*const * inputs, void** outputs, void* workspace, cudaStream_t stream) override { - - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); - - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + } - for (int b = 0; b < batchSize; ++b){ - for(int n = 0; n < n_masks; ++n){ - int index = entry_index(b, n*w*h, 0); - if (new_coords == 1){ - if (this->scaleXY != 1) scalAdd(dstData + index, 2 * w*h, this->scaleXY, -0.5*(this->scaleXY - 1), 1); - } - else{ - activationLOGISTICForward(srcData + index, dstData + index, 2*w*h, stream); //x,y + int getNbOutputs() const NOEXCEPT override { + return 1; + } - if (this->scaleXY != 1) scalAdd(dstData + index, 2 * w*h, this->scaleXY, -0.5*(this->scaleXY - 1), 1); + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override { + return inputs[0]; + } - index = entry_index(b, n*w*h, 4); - activationLOGISTICForward(srcData + index, dstData + index, (1+classes)*w*h, stream); + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override { + c = inputDims[0].d[0]; + h = inputDims[0].d[1]; + w = inputDims[0].d[2]; + } + + int initialize() NOEXCEPT override { + + return 0; + } + + virtual void terminate() NOEXCEPT override { + } + + virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { + return 0; + } + + virtual int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override { + + dnnType *srcData = (dnnType *) reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda(cudaMemcpyAsync(dstData, srcData, batchSize * c * h * w * sizeof(dnnType), cudaMemcpyDeviceToDevice, + stream)); + + + for (int b = 0; b < batchSize; ++b) { + for (int n = 0; n < n_masks; ++n) { + int index = entry_index(b, n * w * h, 0); + if (new_coords == 1) { + if (this->scaleXY != 1) + scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); + } else { + activationLOGISTICForward(srcData + index, dstData + index, 2 * w * h, stream); //x,y + + if (this->scaleXY != 1) + scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); + + index = entry_index(b, n * w * h, 4); + activationLOGISTICForward(srcData + index, dstData + index, (1 + classes) * w * h, stream); } } } - //std::cout<<"YOLO END\n"; - return 0; - } + //std::cout<<"YOLO END\n"; + return 0; + } - virtual size_t getSerializationSize() override { - return 8*sizeof(int) + 2*sizeof(float)+ n_masks*sizeof(dnnType) + num*n_masks*2*sizeof(dnnType) + YOLORT_CLASSNAME_W*classes*sizeof(char); - } + virtual size_t getSerializationSize() const NOEXCEPT override { + return 8 * sizeof(int) + 2 * sizeof(float) + n_masks * sizeof(dnnType) + num * n_masks * 2 * sizeof(dnnType) + + YOLORT_CLASSNAME_W * classes * sizeof(char); + } - virtual void serialize(void* buffer) override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, classes); //std::cout << "Classes :" << classes << std::endl; - tk::dnn::writeBUF(buf, num); //std::cout << "Num : " << num << std::endl; - tk::dnn::writeBUF(buf, n_masks); //std::cout << "N_Masks" << n_masks << std::endl; - tk::dnn::writeBUF(buf, scaleXY); //std::cout << "ScaleXY :" << scaleXY << std::endl; - tk::dnn::writeBUF(buf, nms_thresh); //std::cout << "nms_thresh :" << nms_thresh << std::endl; - tk::dnn::writeBUF(buf, nms_kind); //std::cout << "nms_kind : " << nms_kind << std::endl; - tk::dnn::writeBUF(buf, new_coords); //std::cout << "new_coords : " << new_coords << std::endl; - tk::dnn::writeBUF(buf, c); //std::cout << "C : " << c << std::endl; - tk::dnn::writeBUF(buf, h); //std::cout << "H : " << h << std::endl; - tk::dnn::writeBUF(buf, w); //std::cout << "C : " << c << std::endl; - for (int i = 0; i < n_masks; i++) - { - tk::dnn::writeBUF(buf, mask[i]); //std::cout << "mask[i] : " << mask[i] << std::endl; - } - for (int i = 0; i < n_masks * 2 * num; i++) - { - tk::dnn::writeBUF(buf, bias[i]); //std::cout << "bias[i] : " << bias[i] << std::endl; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override { + return true; //todo implement proper supportsFormat + } - // save classes names - for(int i=0; i(buffer), *a = buf; + tk::dnn::writeBUF(buf, classes); //std::cout << "Classes :" << classes << std::endl; + tk::dnn::writeBUF(buf, num); //std::cout << "Num : " << num << std::endl; + tk::dnn::writeBUF(buf, n_masks); //std::cout << "N_Masks" << n_masks << std::endl; + tk::dnn::writeBUF(buf, scaleXY); //std::cout << "ScaleXY :" << scaleXY << std::endl; + tk::dnn::writeBUF(buf, nms_thresh); //std::cout << "nms_thresh :" << nms_thresh << std::endl; + tk::dnn::writeBUF(buf, nms_kind); //std::cout << "nms_kind : " << nms_kind << std::endl; + tk::dnn::writeBUF(buf, new_coords); //std::cout << "new_coords : " << new_coords << std::endl; + tk::dnn::writeBUF(buf, c); //std::cout << "C : " << c << std::endl; + tk::dnn::writeBUF(buf, h); //std::cout << "H : " << h << std::endl; + tk::dnn::writeBUF(buf, w); //std::cout << "C : " << c << std::endl; + for (int i = 0; i < n_masks; i++) { + tk::dnn::writeBUF(buf, mask[i]); //std::cout << "mask[i] : " << mask[i] << std::endl; + } + for (int i = 0; i < n_masks * 2 * num; i++) { + tk::dnn::writeBUF(buf, bias[i]); //std::cout << "bias[i] : " << bias[i] << std::endl; + } - int c, h, w; + // save classes names + for (int i = 0; i < classes; i++) { + char tmp[YOLORT_CLASSNAME_W]; + strcpy(tmp, classesNames[i].c_str()); + for (int j = 0; j < YOLORT_CLASSNAME_W; j++) { + tk::dnn::writeBUF(buf, tmp[j]); + } + } + assert(buf == a + getSerializationSize()); + } + + const char *getPluginType() const NOEXCEPT override { + return "YoloRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override { + return "1"; + } + + void destroy() NOEXCEPT override { delete this; } + + const char *getPluginNamespace() const NOEXCEPT override { + return mPluginNamespace.c_str(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { + mPluginNamespace = pluginNamespace; + } + + IPluginV2 *clone() const NOEXCEPT override { + YoloRT *p = new YoloRT(classes, num,yolo, n_masks, scaleXY, nms_thresh, nms_kind, new_coords); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; + } + + Yolo *yolo; + int c, h, w; int classes, num, n_masks; - float scaleXY; - float nms_thresh; - int nms_kind; - int new_coords; - std::vector classesNames; + float scaleXY; + float nms_thresh; + int nms_kind; + int new_coords; + std::vector classesNames; dnnType *mask; dnnType *bias; - int entry_index(int batch, int location, int entry) { - int n = location / (w*h); - int loc = location % (w*h); - return batch*c*h*w + n*w*h*(4+classes+1) + entry*w*h + loc; - } + int entry_index(int batch, int location, int entry) { + int n = location / (w * h); + int loc = location % (w * h); + return batch * c * h * w + n * w * h * (4 + classes + 1) + entry * w * h + loc; + } + +private: + std::string mPluginNamespace; }; + +class YoloRTPluginCreator : public IPluginCreator{ +public: + YoloRTPluginCreator(){ + mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("yolo",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("numMasks",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("scaleXY",nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nmsThresh",nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nmsKind",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("newCoords",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + } + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ + mPluginNamespace = pluginNamespace; + } + + const char *getPluginNamespace() const NOEXCEPT override{ + return mPluginNamespace.c_str(); + } + + IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ + YoloRT *pluginObj = new YoloRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ + const PluginField *fields = fc->fields; + //todo assert + int classes = *(static_cast(fields[0].data)); + int num = *(static_cast(fields[1].data)); + Yolo *yoloTemp = const_cast(static_cast(fields[2].data)); + int numMasks = *(static_cast(fields[3].data)); + float scaleXY = *(static_cast(fields[4].data)); + float nmsThresh = *(static_cast(fields[5].data)); + int nmsKind = *(static_cast(fields[6].data)); + int newCoords = *(static_cast(fields[7].data)); + YoloRT *pluginObj = new YoloRT(classes,num,yoloTemp,numMasks,scaleXY,nmsThresh,nmsKind,newCoords); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; + } + + const char *getPluginName() const NOEXCEPT override{ + return "YoloRT_tkDNN"; + } + + const char *getPluginVersion() const NOEXCEPT override{ + return "1"; + } + + const PluginFieldCollection *getFieldNames() NOEXCEPT override{ + return &mFC; + } + +private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; +}; + +REGISTER_TENSORRT_PLUGIN(YoloRTPluginCreator); diff --git a/include/tkDNN/utils.h b/include/tkDNN/utils.h index 65375ba..8041f3b 100644 --- a/include/tkDNN/utils.h +++ b/include/tkDNN/utils.h @@ -11,6 +11,7 @@ #include "cuda_runtime_api.h" #include #include +#include #ifdef __linux__ @@ -22,6 +23,15 @@ #include + + +#if NV_TENSORRT_MAJOR > 7 +#define NOEXCEPT noexcept +#else +#define NOEXCEPT +#endif + + #define dnnType float diff --git a/src/Int8Calibrator.cpp b/src/Int8Calibrator.cpp index 773a9d8..9fab18f 100644 --- a/src/Int8Calibrator.cpp +++ b/src/Int8Calibrator.cpp @@ -8,7 +8,7 @@ Int8EntropyCalibrator::Int8EntropyCalibrator(BatchStream& stream, int firstBatch mCalibTableFilePath(calibTableFilePath), mInputBlobName(inputBlobName.c_str()), mReadCache(readCache) { - nvinfer1::DimsNCHW dims = mStream.getDims(); + nvinfer1::Dims4 dims = mStream.getDims(); mInputCount = mStream.getBatchSize() * dims.c() * dims.h() * dims.w(); checkCuda(cudaMalloc(&mDeviceInput, mInputCount * sizeof(float))); mStream.reset(firstBatch); -- 2.52.0 From 3d8b1ac49475d0e3a20432b2317a34a5d183e39b Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 21 Aug 2021 22:29:36 +0530 Subject: [PATCH 06/32] Yolo3Detection.cpp doesn't build yet,issues with dependecies of preprocessing and postprocessing on IPluginFactory --- include/tkDNN/pluginsRT/YoloRT.h | 4 ++ include/tkDNN/utils.h | 2 + src/Int8BatchStream.cpp | 20 ++++---- src/Int8Calibrator.cpp | 8 ++-- src/NetworkRT.cpp | 80 ++++++++++++++++---------------- src/Yolo3Detection.cpp | 1 + tests/mnist/test_mnistRT.cpp | 10 ++-- 7 files changed, 65 insertions(+), 60 deletions(-) diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index cc866c6..3511634 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -2,6 +2,7 @@ #include "../kernels.h" #define YOLORT_CLASSNAME_W 256 + class YoloRT : public IPluginV2 { public: @@ -49,6 +50,7 @@ public: classesNames[1] = std::string(tmp); } assert(buf == bufCheck + length); + } ~YoloRT() { @@ -56,6 +58,7 @@ public: } + int getNbOutputs() const NOEXCEPT override { return 1; } @@ -186,6 +189,7 @@ public: float nms_thresh; int nms_kind; int new_coords; + int NUM=0; std::vector classesNames; dnnType *mask; diff --git a/include/tkDNN/utils.h b/include/tkDNN/utils.h index 8041f3b..017cf1d 100644 --- a/include/tkDNN/utils.h +++ b/include/tkDNN/utils.h @@ -147,4 +147,6 @@ static inline bool isCudaPointer(void *data) { cudaPointerAttributes attr; return cudaPointerGetAttributes(&attr, data) == 0; } + + #endif //UTILS_H diff --git a/src/Int8BatchStream.cpp b/src/Int8BatchStream.cpp index fdc1db2..a211a65 100644 --- a/src/Int8BatchStream.cpp +++ b/src/Int8BatchStream.cpp @@ -8,14 +8,14 @@ BatchStream::BatchStream(tk::dnn::dataDim_t dim, int batchSize, int maxBatches, const std::string& fileimglist, const std::string& filelabellist) { mBatchSize = batchSize; mMaxBatches = maxBatches; - mDims = nvinfer1::DimsNCHW{ dim.n, dim.c, dim.h, dim.w }; + mDims = nvinfer1::Dims4{ dim.n, dim.c, dim.h, dim.w }; mHeight = dim.h; mWidth = dim.w; - mImageSize = mDims.c()*mDims.h()*mDims.w(); + mImageSize = mDims.d[1]*mDims.d[2]*mDims.d[3]; mBatch.resize(mBatchSize*mImageSize, 0); mLabels.resize(mBatchSize, 0); - mFileBatch.resize(mDims.n()*mImageSize, 0); - mFileLabels.resize(mDims.n(), 0); + mFileBatch.resize(mDims.d[0]*mImageSize, 0); + mFileLabels.resize(mDims.d[0], 0); mFileImgList = fileimglist; readInListFile(fileimglist, mListImg); mFileLabelList = filelabellist; @@ -27,7 +27,7 @@ BatchStream::BatchStream(tk::dnn::dataDim_t dim, int batchSize, int maxBatches, void BatchStream::reset(int firstBatch) { mBatchCount = 0; mFileCount = 0; - mFileBatchPos = mDims.n(); + mFileBatchPos = mDims.d[0]; skip(firstBatch); } @@ -37,11 +37,11 @@ bool BatchStream::next() { return false; for (int csize = 1, batchPos = 0; batchPos < mBatchSize; batchPos += csize, mFileBatchPos += csize) { - assert(mFileBatchPos > 0 && mFileBatchPos <= mDims.n()); - if (mFileBatchPos == mDims.n() && !update()) + assert(mFileBatchPos > 0 && mFileBatchPos <= mDims.d[0]); + if (mFileBatchPos == mDims.d[0] && !update()) return false; - csize = std::min(mBatchSize - batchPos, mDims.n() - mFileBatchPos); + csize = std::min(mBatchSize - batchPos, mDims.d[0] - mFileBatchPos); std::copy_n(getFileBatch() + mFileBatchPos * mImageSize, csize * mImageSize, getBatch() + batchPos * mImageSize); std::copy_n(getFileLabels() + mFileBatchPos, csize, getLabels() + batchPos); } @@ -50,8 +50,8 @@ bool BatchStream::next() { } void BatchStream::skip(int skipCount) { - if (mBatchSize >= mDims.n() && mBatchSize%mDims.n() == 0 && mFileBatchPos == mDims.n()) { - mFileCount += skipCount * mBatchSize / mDims.n(); + if (mBatchSize >= mDims.d[0] && mBatchSize%mDims.d[0] == 0 && mFileBatchPos == mDims.d[0]) { + mFileCount += skipCount * mBatchSize / mDims.d[0]; return; } diff --git a/src/Int8Calibrator.cpp b/src/Int8Calibrator.cpp index 9fab18f..691f847 100644 --- a/src/Int8Calibrator.cpp +++ b/src/Int8Calibrator.cpp @@ -9,12 +9,12 @@ Int8EntropyCalibrator::Int8EntropyCalibrator(BatchStream& stream, int firstBatch mInputBlobName(inputBlobName.c_str()), mReadCache(readCache) { nvinfer1::Dims4 dims = mStream.getDims(); - mInputCount = mStream.getBatchSize() * dims.c() * dims.h() * dims.w(); + mInputCount = mStream.getBatchSize() + dims.d[1]*dims.d[2]*dims.d[3]; checkCuda(cudaMalloc(&mDeviceInput, mInputCount * sizeof(float))); mStream.reset(firstBatch); } -bool Int8EntropyCalibrator::getBatch(void* bindings[], const char* names[], int nbBindings) { +bool Int8EntropyCalibrator::getBatch(void* bindings[], const char* names[], int nbBindings) NOEXCEPT { if (!mStream.next()) return false; @@ -24,7 +24,7 @@ bool Int8EntropyCalibrator::getBatch(void* bindings[], const char* names[], int return true; } -const void* Int8EntropyCalibrator::readCalibrationCache(size_t& length) { +const void* Int8EntropyCalibrator::readCalibrationCache(size_t& length) NOEXCEPT { mCalibrationCache.clear(); assert(!mCalibTableFilePath.empty()); std::ifstream input(mCalibTableFilePath, std::ios::binary); @@ -38,7 +38,7 @@ const void* Int8EntropyCalibrator::readCalibrationCache(size_t& length) { return length ? &mCalibrationCache[0] : nullptr; } -void Int8EntropyCalibrator::writeCalibrationCache(const void* cache, size_t length) { +void Int8EntropyCalibrator::writeCalibrationCache(const void* cache, size_t length) NOEXCEPT { assert(!mCalibTableFilePath.empty()); std::ofstream output(mCalibTableFilePath, std::ios::binary); output.write(reinterpret_cast(cache), length); diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 6ac7235..43ba4ba 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -15,7 +15,7 @@ using namespace nvinfer1; // Logger for info/warning/errors class Logger : public ILogger { - void log(Severity severity, const char* msg) override { + void log(Severity severity, const char* msg) NOEXCEPT override { #ifdef DEBUG std::cout <<"TENSORRT LOG: "<< msg << std::endl; #endif @@ -39,7 +39,7 @@ NetworkRT::NetworkRT(Network *net, const char *name) { #if NV_TENSORRT_MAJOR >= 5 std::cout<<"DLAs: "<getNbDLACores()<<"\n"; #endif - networkRT = builderRT->createNetwork(); + networkRT = builderRT->createNetworkV2(0U); #if NV_TENSORRT_MAJOR >= 6 configRT = builderRT->createBuilderConfig(); #endif @@ -59,22 +59,21 @@ NetworkRT::NetworkRT(Network *net, const char *name) { dtRT = DataType::kFLOAT; builderRT->setMaxBatchSize(net->maxBatchSize); - builderRT->setMaxWorkspaceSize(1 << 30); + configRT->setMaxWorkspaceSize(1 << 30); if(net->fp16 && builderRT->platformHasFastFp16()) { dtRT = DataType::kHALF; - builderRT->setHalf2Mode(true); -#if NV_TENSORRT_MAJOR >= 6 +#if NV_TENSORRT_MAJOR >= 6 configRT->setFlag(BuilderFlag::kFP16); #endif } #if NV_TENSORRT_MAJOR >= 5 if(net->dla && builderRT->getNbDLACores() > 0) { dtRT = DataType::kHALF; - builderRT->setFp16Mode(true); - builderRT->allowGPUFallback(true); - builderRT->setDefaultDeviceType(DeviceType::kDLA); - builderRT->setDLACore(0); + configRT->setFlag(BuilderFlag::kFP16); + configRT->setFlag(BuilderFlag::kGPU_FALLBACK); + configRT->setDefaultDeviceType(DeviceType::kDLA); + configRT->setDLACore(0); } #endif #if NV_TENSORRT_MAJOR >= 6 @@ -104,7 +103,7 @@ NetworkRT::NetworkRT(Network *net, const char *name) { // add input layer ITensor *input = networkRT->addInput("data", DataType::kFLOAT, - DimsCHW{ dim.c, dim.h, dim.w}); + Dims3{ dim.c, dim.h, dim.w}); checkNULL(input); //add other layers @@ -368,8 +367,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { if(l->pool_mode == tkdnnPoolingMode_t::POOLING_MAX_FIXEDSIZE) { - IPlugin *plugin = new MaxPoolFixedSizeRT(l->output_dim.c, l->output_dim.h, l->output_dim.w, l->output_dim.n, l->strideH, l->strideW, l->winH, l->winH-1); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new MaxPoolFixedSizeRT(l->output_dim.c, l->output_dim.h, l->output_dim.w, l->output_dim.n, l->strideH, l->strideW, l->winH, l->winH-1); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -413,20 +412,20 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { return lRT; } else if(l->act_mode == CUDNN_ACTIVATION_CLIPPED_RELU) { - IPlugin *plugin = new ActivationReLUCeiling(l->ceiling); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new ActivationReLUCeiling(l->ceiling); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } else if(l->act_mode == ACTIVATION_MISH) { - IPlugin *plugin = new ActivationMishRT(); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new ActivationMishRT(); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } else if(l->act_mode == ACTIVATION_LOGISTIC) { - IPlugin *plugin = new ActivationLogisticRT(); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new ActivationLogisticRT(); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -460,8 +459,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { } if(l->groups > 1){ - IPlugin *plugin = new RouteRT(l->groups, l->group_id); - IPluginLayer *lRT = networkRT->addPlugin(tens, l->layers_n, *plugin); + IPluginV2 *plugin = new RouteRT(l->groups, l->group_id); + IPluginV2Layer *lRT = networkRT->addPluginV2(tens, l->layers_n, *plugin); checkNULL(lRT); return lRT; } @@ -472,8 +471,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { ILayer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { - IPlugin *plugin = new FlattenConcatRT(); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new FlattenConcatRT(); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -481,8 +480,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { ILayer* NetworkRT::convert_layer(ITensor *input, Reshape *l) { // std::cout<<"convert Reshape\n"; - IPlugin *plugin = new ReshapeRT(l->output_dim); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new ReshapeRT(l->output_dim); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -494,7 +493,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Resize *l) { checkNULL(lRT); Dims d{}; lRT->setResizeMode(ResizeMode(l->mode)); - lRT->setOutputDimensions(DimsCHW{l->output_dim.c, l->output_dim.h, l->output_dim.w}); + lRT->setOutputDimensions(Dims3{l->output_dim.c, l->output_dim.h, l->output_dim.w}); return lRT; } @@ -502,8 +501,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Reorg *l) { //std::cout<<"convert Reorg\n"; //std::cout<<"New plugin REORG\n"; - IPlugin *plugin = new ReorgRT(l->stride); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new ReorgRT(l->stride); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -512,8 +511,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Region *l) { //std::cout<<"convert Region\n"; //std::cout<<"New plugin REGION\n"; - IPlugin *plugin = new RegionRT(l->classes, l->coords, l->num); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new RegionRT(l->classes, l->coords, l->num); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -534,11 +533,11 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Shortcut *l) { else { // plugin version - IPlugin *plugin = new ShortcutRT(l->backLayer->output_dim, l->mul); + IPluginV2 *plugin = new ShortcutRT(l->backLayer->output_dim, l->mul); ITensor **inputs = new ITensor*[2]; inputs[0] = input; inputs[1] = back_tens; - IPluginLayer *lRT = networkRT->addPlugin(inputs, 2, *plugin); + IPluginV2Layer *lRT = networkRT->addPluginV2(inputs, 2, *plugin); checkNULL(lRT); return lRT; } @@ -548,8 +547,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { //std::cout<<"convert Yolo\n"; //std::cout<<"New plugin YOLO\n"; - IPlugin *plugin = new YoloRT(l->classes, l->num, l, l->n_masks, l->scaleXY, l->nms_thresh, l->nsm_kind, l->new_coords); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new YoloRT(l->classes, l->num, l, l->n_masks, l->scaleXY, l->nms_thresh, l->nsm_kind, l->new_coords); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -558,8 +557,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { //std::cout<<"convert Upsample\n"; //std::cout<<"New plugin UPSAMPLE\n"; - IPlugin *plugin = new UpsampleRT(l->stride); - IPluginLayer *lRT = networkRT->addPlugin(&input, 1, *plugin); + IPluginV2 *plugin = new UpsampleRT(l->stride); + IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -574,10 +573,10 @@ ILayer* NetworkRT::convert_layer(ITensor *input, DeformConv2d *l) { inputs[1] = preconv->getOutput(0); //std::cout<<"New plugin DEFORMABLE\n"; - IPlugin *plugin = new DeformableConvRT(l->chunk_dim, l->kernelH, l->kernelW, l->strideH, l->strideW, l->paddingH, l->paddingW, + IPluginV2 *plugin = new DeformableConvRT(l->chunk_dim, l->kernelH, l->kernelW, l->strideH, l->strideW, l->paddingH, l->paddingW, l->deformableGroup, l->input_dim.n, l->input_dim.c, l->input_dim.h, l->input_dim.w, l->output_dim.n, l->output_dim.c, l->output_dim.h, l->output_dim.w, l); - IPluginLayer *lRT = networkRT->addPlugin(inputs, 2, *plugin); + IPluginV2Layer *lRT = networkRT->addPluginV2(inputs, 2, *plugin); checkNULL(lRT); lRT->setName( ("Deformable" + std::to_string(l->id)).c_str() ); delete[](inputs); @@ -646,16 +645,15 @@ bool NetworkRT::deserialize(const char *filename) { file.close(); } - pluginFactory = new PluginFactory(); runtimeRT = createInferRuntime(loggerRT); - engineRT = runtimeRT->deserializeCudaEngine(gieModelStream, size, (IPluginFactory *) pluginFactory); + engineRT = runtimeRT->deserializeCudaEngine(gieModelStream, size); //if (gieModelStream) delete [] gieModelStream; return true; } - +/* IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialData, size_t serialLength) { const char * buf = reinterpret_cast(serialData),*bufCheck = buf; @@ -897,5 +895,5 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa FatalError("Cant deserialize Plugin"); return NULL; } - +*/ }} diff --git a/src/Yolo3Detection.cpp b/src/Yolo3Detection.cpp index 0c638e6..9de35e2 100644 --- a/src/Yolo3Detection.cpp +++ b/src/Yolo3Detection.cpp @@ -14,6 +14,7 @@ bool Yolo3Detection::init(const std::string& tensor_path, const int n_classes, c tk::dnn::dataDim_t idim = netRT->input_dim; idim.n = nBatches; + if(netRT->pluginFactory->n_yolos < 2 ) { FatalError("this is not yolo3"); } diff --git a/tests/mnist/test_mnistRT.cpp b/tests/mnist/test_mnistRT.cpp index 1b4e9c3..fe25696 100644 --- a/tests/mnist/test_mnistRT.cpp +++ b/tests/mnist/test_mnistRT.cpp @@ -15,7 +15,7 @@ using namespace nvinfer1; // Logger for info/warning/errors class Logger : public ILogger { - void log(Severity severity, const char* msg) override + void log(Severity severity, const char* msg) NOEXCEPT override { // suppress info-level messages if (severity != Severity::kINFO) @@ -66,11 +66,11 @@ int main() { std::cout<<"\n==== TensorRT ====\n"; // create the builder IBuilder* builder = nvinfer1::createInferBuilder(gLogger); - INetworkDefinition* network = builder->createNetwork(); - + IBuilderConfig* config = builder->createBuilderConfig(); + INetworkDefinition* network = builder->createNetworkV2(0U); DataType dt = DataType::kFLOAT; // Create input of shape { 1, 1, 28, 28 } with name referenced by "data" - auto input = network->addInput("data", dt, DimsCHW{ 1, 28, 28}); + auto input = network->addInput("data", dt, Dims3{ 1, 28, 28}); assert(input != nullptr); tk::dnn::Conv2d *c0 = &l0; @@ -126,7 +126,7 @@ int main() { // Build the engine builder->setMaxBatchSize(1); - builder->setMaxWorkspaceSize(1 << 20); + config->setMaxWorkspaceSize(1 << 20); auto engine = builder->buildCudaEngine(*network); // we don't need the network any more -- 2.52.0 From 2ffe07057e550d2fd48588e72099ac8ecaa06ae3 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sun, 29 Aug 2021 03:18:58 +0530 Subject: [PATCH 07/32] Mnist works at the moment with trt8,others like yolo4tiny and mobilenet generate the engine files but crash after throwing nvifer1::CudaRuntimeError and when demo is being run ,it doesnt deserialize properly and crashes --- CMakeLists.txt | 3 +- demo/demo/demo.cpp | 49 +++++++---- include/tkDNN/DarknetParser.h | 3 + include/tkDNN/DetectionNN.h | 2 +- include/tkDNN/NetworkRT.h | 2 +- include/tkDNN/Yolo3Detection.h | 7 +- include/tkDNN/pluginsRT/ReorgRT.h | 2 +- include/tkDNN/pluginsRT/YoloRT.h | 1 + src/DarknetParser.cpp | 141 +++++++++++++++++++++++++++++- src/NetworkRT.cpp | 34 +++++++ src/Yolo3Detection.cpp | 51 +++++++---- tests/mnist/test_mnistRT.cpp | 2 +- 12 files changed, 255 insertions(+), 42 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 3e823dc..d88407e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,12 +33,13 @@ SET(CUDA_SEPARABLE_COMPILATION ON) #set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -arch=sm_30 --compiler-options '-fPIC'") set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) + find_package(CUDNN REQUIRED) include_directories(${CUDNN_INCLUDE_DIR}) # compile -file(GLOB tkdnn_CUSRC "src/kernels/*.cu" "src/sorting.cu") +file(GLOB tkdnn_CUSRC "src/kernels/*.cu" "src/sorting.cu" ) cuda_include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include ${CUDA_INCLUDE_DIRS} ${CUDNN_INCLUDE_DIRS}) cuda_add_library(kernels SHARED ${tkdnn_CUSRC}) target_link_libraries(kernels ${CUDA_CUBLAS_LIBRARIES}) diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index 317a574..6e1c2b4 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -23,6 +23,18 @@ int main(int argc, char *argv[]) { std::string net = "yolo4tiny_fp32.rt"; + #ifdef __linux__ + std::string cfgPath = "../tests/darknet/cfg/yolo4tiny.cfg"; + #elif _WIN32 + std::string cfgPath = "..\\tests\\darknet\\cfg\\yolo4tiny.cfg"; + #endif + + #ifdef __linux__ + std::string namePath = "../tests/darknet/names/coco.names"; + #elif _WIN32 + std::string namePath = "..\\tests\\darknet\\names\\coco.names"; + #endif + if(argc > 1) net = argv[1]; #ifdef __linux__ @@ -31,23 +43,28 @@ int main(int argc, char *argv[]) { std::string input = "..\\..\\..\\demo\\yolo_test.mp4"; #endif + if(argc > 2) - input = argv[2]; - char ntype = 'y'; + cfgPath = argv[2]; if(argc > 3) - ntype = argv[3][0]; - int n_classes = 80; + namePath = argv[3]; if(argc > 4) - n_classes = atoi(argv[4]); - int n_batch = 1; + input = argv[4]; + char ntype = 'y'; if(argc > 5) - n_batch = atoi(argv[5]); - bool show = true; + ntype = argv[5][0]; + int n_classes = 80; if(argc > 6) - show = atoi(argv[6]); - float conf_thresh=0.3; + n_classes = atoi(argv[6]); + int n_batch = 1; if(argc > 7) - conf_thresh = atof(argv[7]); + n_batch = atoi(argv[7]); + bool show = true; + if(argc > 8) + show = atoi(argv[8]); + float conf_thresh=0.3; + if(argc > 9) + conf_thresh = atof(argv[9]); if(n_batch < 1 || n_batch > 64) FatalError("Batch dim not supported"); @@ -56,8 +73,8 @@ int main(int argc, char *argv[]) { SAVE_RESULT = true; tk::dnn::Yolo3Detection yolo; - tk::dnn::CenternetDetection cnet; - tk::dnn::MobilenetDetection mbnet; + //tk::dnn::CenternetDetection cnet; + //tk::dnn::MobilenetDetection mbnet; tk::dnn::DetectionNN *detNN; @@ -67,17 +84,17 @@ int main(int argc, char *argv[]) { detNN = &yolo; break; case 'c': - detNN = &cnet; + //detNN = &cnet; break; case 'm': - detNN = &mbnet; + //detNN = &mbnet; n_classes++; break; default: FatalError("Network type not allowed (3rd parameter)\n"); } - detNN->init(net, n_classes, n_batch, conf_thresh); + detNN->init(net,cfgPath,namePath,n_classes,n_batch,conf_thresh); gRun = true; diff --git a/include/tkDNN/DarknetParser.h b/include/tkDNN/DarknetParser.h index 089c4d6..c6d2472 100644 --- a/include/tkDNN/DarknetParser.h +++ b/include/tkDNN/DarknetParser.h @@ -47,5 +47,8 @@ namespace tk { namespace dnn { std::vector &netLayers, const std::vector& names); std::vector darknetReadNames(const std::string& names_file); tk::dnn::Network* darknetParser(const std::string& cfg_file, const std::string& wgs_path, const std::string& names_file); + void loadYoloInfo(const std::string &cfg_file,int lineNo,std::vector &mask,std::vector &anchors,int &num,int &classes,float &nms_thresh,int &nms_kind,int &coords); + void loadYoloInitInfo(int &channels,int &width,int &height,const std::string &cfg_file); + std::vector noYolosLine(const std::string &cfg_file); }} diff --git a/include/tkDNN/DetectionNN.h b/include/tkDNN/DetectionNN.h index a8c81f7..3a757ef 100644 --- a/include/tkDNN/DetectionNN.h +++ b/include/tkDNN/DetectionNN.h @@ -87,7 +87,7 @@ class DetectionNN { * @param n_batches maximum number of batches to use in inference * @return true if everything is correct, false otherwise. */ - virtual bool init(const std::string& tensor_path, const int n_classes=80, const int n_batches=1, const float conf_thresh=0.3) = 0; + virtual bool init(const std::string& tensor_path,const std::string& cfg_path,const std::string& name_path, const int n_classes=80, const int n_batches=1, const float conf_thresh=0.3) = 0; /** * This method performs the whole detection of the NN. diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 53d8d91..4a0d5ff 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -7,6 +7,7 @@ #include "Layer.h" #include "NvInfer.h" #include +#include namespace tk { namespace dnn { @@ -52,7 +53,6 @@ public: - class NetworkRT { public: diff --git a/include/tkDNN/Yolo3Detection.h b/include/tkDNN/Yolo3Detection.h index 100a720..5a29d9c 100644 --- a/include/tkDNN/Yolo3Detection.h +++ b/include/tkDNN/Yolo3Detection.h @@ -4,9 +4,9 @@ #include "opencv2/opencv.hpp" #include "DetectionNN.h" +#include "DarknetParser.h" -namespace tk { namespace dnn { - +namespace tk { namespace dnn { class Yolo3Detection : public DetectionNN { private: @@ -19,12 +19,13 @@ private: tk::dnn::Yolo* getYoloLayer(int n=0); cv::Mat bgr_h; + std::vector noYolos; public: Yolo3Detection() {}; ~Yolo3Detection() {}; - bool init(const std::string& tensor_path, const int n_classes=80, const int n_batches=1, const float conf_thresh=0.3); + bool init(const std::string& tensor_path,const std::string& cfg_path,const std::string& name_path,const int n_classes=80, const int n_batches=1, const float conf_thresh=0.3); void preprocess(cv::Mat &frame, const int bi=0); void postprocess(const int bi=0,const bool mAP=false); }; diff --git a/include/tkDNN/pluginsRT/ReorgRT.h b/include/tkDNN/pluginsRT/ReorgRT.h index 01e5468..fa67d9c 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -41,7 +41,7 @@ public: virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { - reorgForward((dnnType*)reinterpret_cast(inputs[0]), + reorgForward((dnnType*)reinterpret_cast(inputs[0]), reinterpret_cast(outputs[0]), batchSize, c, h, w, stride, stream); return 0; diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index 3511634..d40cd5c 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -31,6 +31,7 @@ public: classes = readBUF(buf); num = readBUF(buf); n_masks = readBUF(buf); + std::cout<(buf); nms_thresh = readBUF(buf); nms_kind = readBUF(buf); diff --git a/src/DarknetParser.cpp b/src/DarknetParser.cpp index 69b6b29..a370b91 100644 --- a/src/DarknetParser.cpp +++ b/src/DarknetParser.cpp @@ -32,6 +32,16 @@ namespace tk { namespace dnn { return values; } + std::vector fromStringToFloatVec(const std::string& line, const char delimiter){ + std::stringstream linestream(line); + std::string value; + std::vector values; + + while(getline(linestream,value,delimiter)) + values.push_back(std::stof(value)); + return values; + } + bool darknetParseFields(const std::string& line, darknetFields_t& fields){ std::string name,value; @@ -268,7 +278,134 @@ namespace tk { namespace dnn { } return net; } - - + std::vector noYolosLine(const std::string &cfg_file){ + std::ifstream if_cfg(cfg_file); + if(!if_cfg.is_open()) + FatalError("cloud not open cfg file: " + cfg_file); + std::string line; + std::vector lineNo; + int count = 0; + while(std::getline(if_cfg,line)){ + std::size_t found = line.find("#"); + if ( found != std::string::npos ) { + line = line.substr(0, found); + } + // skip empty lines + if(line.empty()) + continue; + if(line == "[yolo]"){ + lineNo.push_back(count); + + + } + count++; + } + return lineNo; + } + void loadYoloInfo(const std::string &cfg_file,int lineNo,std::vector &mask,std::vector &anchors,int &num,int &classes,float &nms_thresh,int &nms_kind,int &coords){ + std::vector maskTemp,anchorsTemp; + int classesTemp,numTemp,nmsKindTemp; + int new_coordsTemp=0; + float nmsThreshTemp=0.45; + + std::ifstream if_cfg(cfg_file); + if(!if_cfg.is_open()) + FatalError("cloud not open cfg file: " + cfg_file); + std::string line; + int count = 0; + while(std::getline(if_cfg,line)){ + std::string name,value; + std::size_t found = line.find("#"); + if ( found != std::string::npos ) { + line = line.substr(0, found); + } + // skip empty lines + if(line.empty()) + continue; + if(count > lineNo && count <=20){ + divideNameAndValue(line,name,value); + if(name == "mask "){ + maskTemp = fromStringToFloatVec(value,','); + } + if(name == "anchors "){ + anchorsTemp = fromStringToFloatVec(value,','); + } + if(name == "classes"){ + classesTemp = std::stoi(value); + } + if(name == "num"){ + numTemp = std::stoi(value); + } + if(name == "nms_kind"){ + if(value == "greedynms"){ + nmsKindTemp = 0; + }else if(value == "diounms"){ + nmsKindTemp=1; + } + else{ + std::cout<<"NMS NOT SUPPORTED DEFAULTING TO GREEDYNMS"< tk::dnn::ActivationLeakyRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::ActivationReLUCeilingPluginCreator::mPluginAttributes; +std::vector tk::dnn::ActivationMishRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::ActivationLogisticRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::DeformableConvRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::RegionRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::ReorgRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::UpsampleRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::ShortcutRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::ReshapeRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::MaxPoolFixedSizeRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::ResizeLayerRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::YoloRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::RouteRTPluginCreator::mPluginAttributes; +std::vector tk::dnn::FlattenConcatRTPluginCreator::mPluginAttributes; + // Logger for info/warning/errors class Logger : public ILogger { void log(Severity severity, const char* msg) NOEXCEPT override { diff --git a/src/Yolo3Detection.cpp b/src/Yolo3Detection.cpp index 9de35e2..26da756 100644 --- a/src/Yolo3Detection.cpp +++ b/src/Yolo3Detection.cpp @@ -3,7 +3,7 @@ namespace tk { namespace dnn { -bool Yolo3Detection::init(const std::string& tensor_path, const int n_classes, const int n_batches, const float conf_thresh) { + bool Yolo3Detection::init(const std::string& tensor_path,const std::string& cfg_path,const std::string& name_path,const int n_classes, const int n_batches, const float conf_thresh) { //convert network to tensorRT std::cout<<(tensor_path).c_str()<<"\n"; @@ -14,28 +14,42 @@ bool Yolo3Detection::init(const std::string& tensor_path, const int n_classes, c tk::dnn::dataDim_t idim = netRT->input_dim; idim.n = nBatches; + std::vector yolosLine = noYolosLine(cfg_path); + noYolos = yolosLine; + int channels,height,width; + loadYoloInitInfo(channels,width,height,cfg_path); - if(netRT->pluginFactory->n_yolos < 2 ) { + + + if(yolosLine.size() < 2 ) { FatalError("this is not yolo3"); } - for(int i=0; ipluginFactory->n_yolos; i++) { - YoloRT *yRT = netRT->pluginFactory->yolos[i]; - classes = yRT->classes; - num = yRT->num; - nMasks = yRT->n_masks; + for(int i=0; i maskTemp,anchorsTemp; + std::vector classNamesTemp; + int classes,nms_kind,coords,numTemp; + float nmsthresh; + loadYoloInfo(cfg_path,yolosLine[i],maskTemp,anchorsTemp,numTemp,classes,nmsthresh,nms_kind,coords); + classNamesTemp = darknetReadNames(name_path); + num = numTemp/maskTemp.size(); + nMasks = maskTemp.size(); + dnnType* maskTempF; + dnnType* biasTempF; + maskTempF = maskTemp.data(); + biasTempF = anchorsTemp.data(); // make a yolo layer to interpret predictions yolo[i] = new tk::dnn::Yolo(nullptr, classes, nMasks, ""); // yolo without input and bias yolo[i]->mask_h = new dnnType[nMasks]; yolo[i]->bias_h = new dnnType[num*nMasks*2]; - memcpy(yolo[i]->mask_h, yRT->mask, sizeof(dnnType)*nMasks); - memcpy(yolo[i]->bias_h, yRT->bias, sizeof(dnnType)*num*nMasks*2); - yolo[i]->input_dim = yolo[i]->output_dim = tk::dnn::dataDim_t(1, yRT->c, yRT->h, yRT->w); - yolo[i]->classesNames = yRT->classesNames; - yolo[i]->nms_thresh = yRT->nms_thresh; - yolo[i]->nsm_kind = (tk::dnn::Yolo::nmsKind_t) yRT->nms_kind; - yolo[i]->new_coords = yRT->new_coords; + memcpy(yolo[i]->mask_h, maskTempF, sizeof(dnnType)*nMasks); + memcpy(yolo[i]->bias_h, biasTempF, sizeof(dnnType)*num*nMasks*2); + yolo[i]->input_dim = yolo[i]->output_dim = tk::dnn::dataDim_t(1, channels, height, width); + yolo[i]->classesNames = classNamesTemp; + yolo[i]->nms_thresh = nmsthresh; + yolo[i]->nsm_kind = (tk::dnn::Yolo::nmsKind_t) nms_kind; + yolo[i]->new_coords = coords; } dets = tk::dnn::Yolo::allocateDetections(tk::dnn::Yolo::MAX_DETECTIONS, classes); @@ -94,10 +108,15 @@ void Yolo3Detection::preprocess(cv::Mat &frame, const int bi){ void Yolo3Detection::postprocess(const int bi, const bool mAP){ + + //get yolo outputs + if(noYolos.size() < 2){ + FatalError("YOLOS WRONG!!"); + } std::vector rt_out; //dnnType *rt_out[netRT->pluginFactory->n_yolos]; - for(int i=0; ipluginFactory->n_yolos; i++) + for(int i=0; ibuffersRT[i+1] + netRT->buffersDIM[i+1].tot()*bi); float x_ratio = float(originalSize[bi].width) / float(netRT->input_dim.w); @@ -105,7 +124,7 @@ void Yolo3Detection::postprocess(const int bi, const bool mAP){ // compute dets nDets = 0; - for(int i=0; ipluginFactory->n_yolos; i++) { + for(int i=0; idstData = rt_out[i]; yolo[i]->computeDetections(dets, nDets, netRT->input_dim.w, netRT->input_dim.h, confThreshold, yolo[i]->new_coords); } diff --git a/tests/mnist/test_mnistRT.cpp b/tests/mnist/test_mnistRT.cpp index fe25696..2f6b7c4 100644 --- a/tests/mnist/test_mnistRT.cpp +++ b/tests/mnist/test_mnistRT.cpp @@ -128,7 +128,7 @@ int main() { builder->setMaxBatchSize(1); config->setMaxWorkspaceSize(1 << 20); - auto engine = builder->buildCudaEngine(*network); + auto engine = builder->buildEngineWithConfig(*network,*config); // we don't need the network any more network->destroy(); -- 2.52.0 From de83ae5d254fbfeeadbb2fdf7c0dc0eded5a749d Mon Sep 17 00:00:00 2001 From: perseusdg Date: Mon, 30 Aug 2021 19:04:26 +0530 Subject: [PATCH 08/32] update tensorrt8 branch --- CMakeLists.txt | 15 ++-- include/tkDNN/NetworkRT.h | 1 + include/tkDNN/pluginsRT/ActivationLeakyRT.h | 5 +- .../tkDNN/pluginsRT/ActivationLogisticRT.h | 4 +- include/tkDNN/pluginsRT/ActivationMishRT.h | 5 +- .../tkDNN/pluginsRT/ActivationReLUCeilingRT.h | 7 +- include/tkDNN/pluginsRT/DeformableConvRT.h | 5 +- include/tkDNN/pluginsRT/FlattenConcatRT.h | 4 +- .../tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h | 4 +- include/tkDNN/pluginsRT/RegionRT.h | 4 +- include/tkDNN/pluginsRT/ReorgRT.h | 4 +- include/tkDNN/pluginsRT/ReshapeRT.h | 4 +- include/tkDNN/pluginsRT/ResizeLayerRT.h | 4 +- include/tkDNN/pluginsRT/RouteRT.h | 4 +- include/tkDNN/pluginsRT/ShortcutRT.h | 6 +- include/tkDNN/pluginsRT/UpsampleRT.h | 11 ++- include/tkDNN/pluginsRT/YoloRT.h | 23 ++++-- src/NetworkRT.cpp | 74 +++++++------------ src/Yolo3Detection.cpp | 2 +- tests/darknet/yolo4tiny.cpp | 7 ++ 20 files changed, 96 insertions(+), 97 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index d88407e..9200b8c 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.15) project (tkDNN) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) if(UNIX) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations -Wno-unused-variable ") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations -Wno-unused-variable") endif() if(WIN32) set(CMAKE_CXX_STANDARD 11) @@ -31,7 +31,7 @@ endif() find_package(CUDA 9.0 REQUIRED) SET(CUDA_SEPARABLE_COMPILATION ON) #set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -arch=sm_30 --compiler-options '-fPIC'") -set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) +set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -G -g) find_package(CUDNN REQUIRED) @@ -41,8 +41,7 @@ include_directories(${CUDNN_INCLUDE_DIR}) # compile file(GLOB tkdnn_CUSRC "src/kernels/*.cu" "src/sorting.cu" ) cuda_include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include ${CUDA_INCLUDE_DIRS} ${CUDNN_INCLUDE_DIRS}) -cuda_add_library(kernels SHARED ${tkdnn_CUSRC}) -target_link_libraries(kernels ${CUDA_CUBLAS_LIBRARIES}) + #------------------------------------------------------------------------------- @@ -65,12 +64,12 @@ find_package(yaml-cpp REQUIRED) # Build Libraries #------------------------------------------------------------------------------- file(GLOB tkdnn_SRC "src/*.cpp") -set(tkdnn_LIBS kernels ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES} ${CUDNN_LIBRARIES} ${OpenCV_LIBS} yaml-cpp) +set(tkdnn_LIBS ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES} ${CUDNN_LIBRARIES} ${OpenCV_LIBS} yaml-cpp) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include ${CUDA_INCLUDE_DIRS} ${OPENCV_INCLUDE_DIRS} ${NVINFER_INCLUDES}) -add_library(tkDNN SHARED ${tkdnn_SRC}) -target_link_libraries(tkDNN ${tkdnn_LIBS}) +cuda_add_library(tkDNN SHARED ${tkdnn_SRC} ${tkdnn_CUSRC}) +target_link_libraries(tkDNN ${tkdnn_LIBS} ${CUDA_CUBLAS_LIBRAY}) #static #add_library(tkDNN_static STATIC ${tkdnn_SRC}) @@ -169,7 +168,7 @@ target_link_libraries(seg_demo tkDNN) #endif() message("install dir:" ${CMAKE_INSTALL_PREFIX}) install(DIRECTORY include/ DESTINATION include/) -install(TARGETS tkDNN kernels DESTINATION lib) +install(TARGETS tkDNN DESTINATION lib) install(TARGETS test_simple test_mnist test_mnistRT test_rtinference demo map_demo DESTINATION bin) install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/cmake/" # source directory DESTINATION "share/tkDNN/cmake/" # target directory diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 4a0d5ff..95ecb5e 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -119,6 +119,7 @@ public: bool serialize(const char *filename); bool deserialize(const char *filename); + void destroy(); diff --git a/include/tkDNN/pluginsRT/ActivationLeakyRT.h b/include/tkDNN/pluginsRT/ActivationLeakyRT.h index 6005013..e73ca2b 100644 --- a/include/tkDNN/pluginsRT/ActivationLeakyRT.h +++ b/include/tkDNN/pluginsRT/ActivationLeakyRT.h @@ -8,6 +8,7 @@ public: ActivationLeakyRT(const void *data, size_t length) { + std::cout<<"DESERIALIZE LEAKYRT"<(data),*bufCheck = buf; slope = readBUF(buf); size = readBUF(buf); @@ -139,8 +140,8 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ActivationLogisticRT.h b/include/tkDNN/pluginsRT/ActivationLogisticRT.h index bf4bcfd..e40e7b4 100644 --- a/include/tkDNN/pluginsRT/ActivationLogisticRT.h +++ b/include/tkDNN/pluginsRT/ActivationLogisticRT.h @@ -139,8 +139,8 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ActivationMishRT.h b/include/tkDNN/pluginsRT/ActivationMishRT.h index a34418b..65153d0 100644 --- a/include/tkDNN/pluginsRT/ActivationMishRT.h +++ b/include/tkDNN/pluginsRT/ActivationMishRT.h @@ -9,6 +9,7 @@ public: ~ActivationMishRT() {} ActivationMishRT(const void *data, size_t length) { + std::cout<<"DESERIALIZE MISH"<(data), *bufCheck = buf; size = readBUF(buf); assert(buf == bufCheck + length); @@ -126,8 +127,8 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h index 4d2652e..8d295df 100644 --- a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h +++ b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h @@ -14,6 +14,7 @@ public: } ActivationReLUCeiling(const void *data, size_t length) { + std::cout<<"RELU CEILING DESERIALIZE"<(data), *bufCheck = buf; ceiling = readBUF(buf); size = readBUF(buf); @@ -140,9 +141,9 @@ public: return &mFC; } -private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; +public: + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h index 46aa9e7..7076379 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -352,10 +352,9 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; -REGISTER_TENSORRT_PLUGIN(DeformableConvRTPluginCreator); diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index c8b6c0f..3c6f3ee 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -154,8 +154,8 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h index 53fdd4e..ef5a8f7 100644 --- a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h +++ b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h @@ -173,8 +173,8 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/RegionRT.h b/include/tkDNN/pluginsRT/RegionRT.h index 8e1c2d2..e187d6c 100644 --- a/include/tkDNN/pluginsRT/RegionRT.h +++ b/include/tkDNN/pluginsRT/RegionRT.h @@ -179,8 +179,8 @@ public: return &mFC; } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ReorgRT.h b/include/tkDNN/pluginsRT/ReorgRT.h index fa67d9c..7605fde 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -134,8 +134,8 @@ public: return &mFC; } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ReshapeRT.h b/include/tkDNN/pluginsRT/ReshapeRT.h index fd74c61..17037da 100644 --- a/include/tkDNN/pluginsRT/ReshapeRT.h +++ b/include/tkDNN/pluginsRT/ReshapeRT.h @@ -140,8 +140,8 @@ public: } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ResizeLayerRT.h b/include/tkDNN/pluginsRT/ResizeLayerRT.h index 9a982fd..374b7d8 100644 --- a/include/tkDNN/pluginsRT/ResizeLayerRT.h +++ b/include/tkDNN/pluginsRT/ResizeLayerRT.h @@ -155,8 +155,8 @@ public: private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/RouteRT.h b/include/tkDNN/pluginsRT/RouteRT.h index 635566c..2ceede3 100644 --- a/include/tkDNN/pluginsRT/RouteRT.h +++ b/include/tkDNN/pluginsRT/RouteRT.h @@ -173,8 +173,8 @@ public: return &mFC; } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/ShortcutRT.h b/include/tkDNN/pluginsRT/ShortcutRT.h index f5b8219..9f3d343 100644 --- a/include/tkDNN/pluginsRT/ShortcutRT.h +++ b/include/tkDNN/pluginsRT/ShortcutRT.h @@ -157,9 +157,9 @@ public: const PluginFieldCollection *getFieldNames() NOEXCEPT override{ return &mFC; } -private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; +public: + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/include/tkDNN/pluginsRT/UpsampleRT.h b/include/tkDNN/pluginsRT/UpsampleRT.h index 0a71c45..9d7a62c 100644 --- a/include/tkDNN/pluginsRT/UpsampleRT.h +++ b/include/tkDNN/pluginsRT/UpsampleRT.h @@ -73,7 +73,8 @@ public: } const char *getPluginVersion() const NOEXCEPT override{ - return "UpsampleRT_tkDNN"; + static const char* UPSAMPLE_RT_PLUGIN = "UpsampleRT_TRT"; + return UPSAMPLE_RT_PLUGIN; } void destroy() NOEXCEPT override{delete this;} @@ -128,7 +129,8 @@ public: } const char *getPluginName() const NOEXCEPT override{ - return "UpsampleRT_tkDNN"; + static const char* UPSAMPLE_RT_PLUGIN = "UpsampleRT_TRT"; + return UPSAMPLE_RT_PLUGIN; } const char *getPluginVersion() const NOEXCEPT override{ @@ -139,9 +141,10 @@ public: return &mFC; } private: - static PluginFieldCollection mFC; - static std::vector mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; REGISTER_TENSORRT_PLUGIN(UpsampleRTPluginCreator); + diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index d40cd5c..7ae7b35 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -1,4 +1,5 @@ #include +#include #include "../kernels.h" #define YOLORT_CLASSNAME_W 256 @@ -27,11 +28,12 @@ public: } YoloRT(const void *data,size_t length){ + std::vector maskTemp,biasTemp; + std::cout<<"LENGTH : "<(data),*bufCheck = buf; classes = readBUF(buf); num = readBUF(buf); n_masks = readBUF(buf); - std::cout<(buf); nms_thresh = readBUF(buf); nms_kind = readBUF(buf); @@ -39,10 +41,16 @@ public: c = readBUF(buf); h = readBUF(buf); w = readBUF(buf); - for(int i=0;i(buf); - for(int i=0;i(buf); + for(int i=0;i(buf)); + std::cout<(buf)); + std::cout<(buffer), *a = buf; tk::dnn::writeBUF(buf, classes); //std::cout << "Classes :" << classes << std::endl; tk::dnn::writeBUF(buf, num); //std::cout << "Num : " << num << std::endl; + std::cout< mPluginAttributes; + PluginFieldCollection mFC; + std::vector mPluginAttributes; std::string mPluginNamespace; }; diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 102562f..7f00cd6 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -8,45 +8,13 @@ #include "utils.h" #include "NvInfer.h" + #include "NetworkRT.h" #include "Int8Calibrator.h" using namespace nvinfer1; -PluginFieldCollection tk::dnn::ActivationLeakyRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ActivationReLUCeilingPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ActivationMishRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ActivationLogisticRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::DeformableConvRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::RegionRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ReorgRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::UpsampleRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ShortcutRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ReshapeRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::MaxPoolFixedSizeRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::ResizeLayerRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::YoloRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::RouteRTPluginCreator::mFC{}; -PluginFieldCollection tk::dnn::FlattenConcatRTPluginCreator::mFC{}; - - -std::vector tk::dnn::ActivationLeakyRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::ActivationReLUCeilingPluginCreator::mPluginAttributes; -std::vector tk::dnn::ActivationMishRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::ActivationLogisticRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::DeformableConvRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::RegionRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::ReorgRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::UpsampleRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::ShortcutRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::ReshapeRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::MaxPoolFixedSizeRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::ResizeLayerRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::YoloRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::RouteRTPluginCreator::mPluginAttributes; -std::vector tk::dnn::FlattenConcatRTPluginCreator::mPluginAttributes; - // Logger for info/warning/errors class Logger : public ILogger { void log(Severity severity, const char* msg) NOEXCEPT override { @@ -590,7 +558,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { ILayer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { //std::cout<<"convert Upsample\n"; - //std::cout<<"New plugin UPSAMPLE\n"; + std::cout<<"New plugin UPSAMPLE\n"; IPluginV2 *plugin = new UpsampleRT(l->stride); IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); @@ -681,11 +649,21 @@ bool NetworkRT::deserialize(const char *filename) { runtimeRT = createInferRuntime(loggerRT); engineRT = runtimeRT->deserializeCudaEngine(gieModelStream, size); + std::cout<destroy(); + configRT->destroy(); + engineRT->destroy(); + builderRT->destroy(); +} + + + /* IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialData, size_t serialLength) { @@ -735,7 +713,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->w = readBUF(buf); assert(buf == bufCheck + serialLength); return r; - } + } if(name.find("Reorg") == 0) { int strideTemp = readBUF(buf); @@ -745,7 +723,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->w = readBUF(buf); assert(buf == bufCheck + serialLength); return r; - } + } if(name.find("Shortcut") == 0) { tk::dnn::dataDim_t bdim; @@ -760,7 +738,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->w = readBUF(buf); return r; assert(buf == bufCheck + serialLength); - } + } if(name.find("Pooling") == 0) { int cTemp = readBUF(buf); @@ -788,10 +766,10 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->i_w = readBUF(buf); assert(buf == bufCheck + serialLength); return r; - } + } if(name.find("Flatten") == 0) { - FlattenConcatRT *r = new FlattenConcatRT(); + FlattenConcatRT *r = new FlattenConcatRT(); r->c = readBUF(buf); r->h = readBUF(buf); r->w = readBUF(buf); @@ -799,7 +777,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->cols = readBUF(buf); assert(buf == bufCheck + serialLength); return r; - } + } if(name.find("Reshape") == 0) { @@ -808,11 +786,11 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa new_dim.c = readBUF(buf); new_dim.h = readBUF(buf); new_dim.w = readBUF(buf); - ReshapeRT *r = new ReshapeRT(new_dim); + ReshapeRT *r = new ReshapeRT(new_dim); assert(buf == bufCheck + serialLength); - + return r; - } + } if(name.find("Yolo") == 0) { @@ -824,7 +802,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa int nms_kind_temp = readBUF(buf); int new_coords_temp = readBUF(buf); - YoloRT *r = new YoloRT(classes_temp,num_temp,nullptr,n_masks_temp,scale_xy_temp,nms_thresh_temp,nms_kind_temp,new_coords_temp); + YoloRT *r = new YoloRT(classes_temp,num_temp,nullptr,n_masks_temp,scale_xy_temp,nms_thresh_temp,nms_kind_temp,new_coords_temp); @@ -848,7 +826,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa yolos[n_yolos++] = r; return r; - } + } if(name.find("Upsample") == 0) { int strideTemp = readBUF(buf); UpsampleRT* r = new UpsampleRT(strideTemp); @@ -857,7 +835,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->w = readBUF(buf); assert(buf == bufCheck + serialLength); return r; - } + } if(name.find("Route") == 0) { int groupsTemp = readBUF(buf); @@ -871,7 +849,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa r->w = readBUF(buf); assert(buf == bufCheck + serialLength); return r; - } + } if(name.find("Deformable") == 0) { int chuck_dimTemp = readBUF(buf); @@ -924,7 +902,7 @@ IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialDa free(aus); assert(buf == bufCheck + serialLength); return r; - } + } FatalError("Cant deserialize Plugin"); return NULL; diff --git a/src/Yolo3Detection.cpp b/src/Yolo3Detection.cpp index 26da756..8d3d244 100644 --- a/src/Yolo3Detection.cpp +++ b/src/Yolo3Detection.cpp @@ -7,7 +7,7 @@ namespace tk { namespace dnn { //convert network to tensorRT std::cout<<(tensor_path).c_str()<<"\n"; - netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str() ); + netRT = new tk::dnn::NetworkRT(nullptr, (tensor_path).c_str() ); nBatches = n_batches; confThreshold = conf_thresh; diff --git a/tests/darknet/yolo4tiny.cpp b/tests/darknet/yolo4tiny.cpp index 44fbac8..9a65f30 100644 --- a/tests/darknet/yolo4tiny.cpp +++ b/tests/darknet/yolo4tiny.cpp @@ -26,8 +26,15 @@ int main() { tk::dnn::NetworkRT *netRT = new tk::dnn::NetworkRT(net, net->getNetworkRTName(bin_path.c_str())); int ret = testInference(input_bins, output_bins, net, netRT); + std::cout<releaseLayers(); + std::cout<<"DELETING NET"<destroy(); delete netRT; + + std::cout<<"RETRUNING RET"< Date: Sun, 5 Sep 2021 01:06:56 +0530 Subject: [PATCH 09/32] tkDNN can now deserialize tensorrt-8 engine (both through test_* and trtexec) but demo has issues in yolo::computeDetections --- CMakeLists.txt | 10 +- include/tkDNN/NetworkRT.h | 53 +-- include/tkDNN/pluginsRT/ActivationLeakyRT.h | 162 ++----- .../tkDNN/pluginsRT/ActivationLogisticRT.h | 160 ++----- include/tkDNN/pluginsRT/ActivationMishRT.h | 148 ++---- .../tkDNN/pluginsRT/ActivationReLUCeilingRT.h | 166 ++----- include/tkDNN/pluginsRT/DeformableConvRT.h | 421 ++++-------------- include/tkDNN/pluginsRT/FlattenConcatRT.h | 181 +++----- .../tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h | 215 +++------ include/tkDNN/pluginsRT/RegionRT.h | 223 +++------- include/tkDNN/pluginsRT/ReorgRT.h | 178 +++----- include/tkDNN/pluginsRT/ReshapeRT.h | 183 +++----- include/tkDNN/pluginsRT/ResizeLayerRT.h | 206 +++------ include/tkDNN/pluginsRT/RouteRT.h | 215 +++------ include/tkDNN/pluginsRT/ShortcutRT.h | 204 +++------ include/tkDNN/pluginsRT/UpsampleRT.h | 189 +++----- include/tkDNN/pluginsRT/YoloRT.h | 323 ++++---------- include/tkDNN/utils.h | 13 + src/DarknetParser.cpp | 9 +- src/Yolo.cpp | 5 +- src/pluginsRT/ActivationLeakyRT.cpp | 138 ++++++ src/pluginsRT/ActivationLogisticRT.cpp | 126 ++++++ src/pluginsRT/ActivationMishRT.cpp | 121 +++++ src/pluginsRT/ActivationReLUCeilingRT.cpp | 129 ++++++ src/pluginsRT/DeformableConvRT.cpp | 331 ++++++++++++++ src/pluginsRT/FlattenConcatRT.cpp | 163 +++++++ src/pluginsRT/MaxPoolingSizeRT.cpp | 179 ++++++++ src/pluginsRT/RegionRT.cpp | 174 ++++++++ src/pluginsRT/ReorgRT.cpp | 151 +++++++ src/pluginsRT/ReshapeRT.cpp | 152 +++++++ src/pluginsRT/ResizeLayerRT.cpp | 163 +++++++ src/pluginsRT/RouteRT.cpp | 183 ++++++++ src/pluginsRT/ShortcutRT.cpp | 167 +++++++ src/pluginsRT/UpsampleRT.cpp | 155 +++++++ src/pluginsRT/YoloRT.cpp | 253 +++++++++++ 35 files changed, 3527 insertions(+), 2322 deletions(-) create mode 100644 src/pluginsRT/ActivationLeakyRT.cpp create mode 100644 src/pluginsRT/ActivationLogisticRT.cpp create mode 100644 src/pluginsRT/ActivationMishRT.cpp create mode 100644 src/pluginsRT/ActivationReLUCeilingRT.cpp create mode 100644 src/pluginsRT/DeformableConvRT.cpp create mode 100644 src/pluginsRT/FlattenConcatRT.cpp create mode 100644 src/pluginsRT/MaxPoolingSizeRT.cpp create mode 100644 src/pluginsRT/RegionRT.cpp create mode 100644 src/pluginsRT/ReorgRT.cpp create mode 100644 src/pluginsRT/ReshapeRT.cpp create mode 100644 src/pluginsRT/ResizeLayerRT.cpp create mode 100644 src/pluginsRT/RouteRT.cpp create mode 100644 src/pluginsRT/ShortcutRT.cpp create mode 100644 src/pluginsRT/UpsampleRT.cpp create mode 100644 src/pluginsRT/YoloRT.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 9200b8c..f3471e2 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -31,7 +31,7 @@ endif() find_package(CUDA 9.0 REQUIRED) SET(CUDA_SEPARABLE_COMPILATION ON) #set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -arch=sm_30 --compiler-options '-fPIC'") -set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -G -g) +set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) find_package(CUDNN REQUIRED) @@ -39,8 +39,10 @@ include_directories(${CUDNN_INCLUDE_DIR}) # compile -file(GLOB tkdnn_CUSRC "src/kernels/*.cu" "src/sorting.cu" ) +file(GLOB tkdnn_CUSRC "src/kernels/*.cu" "src/sorting.cu" "src/pluginsRT/*.cpp") cuda_include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include ${CUDA_INCLUDE_DIRS} ${CUDNN_INCLUDE_DIRS}) +cuda_add_library(kernels SHARED ${tkdnn_CUSRC}) +target_link_libraries(kernels ${CUDA_CUBLAS_LIBRAY} ${CUDA_LIBRARIES} ${CUDNN_LIBRARIES}) @@ -64,11 +66,11 @@ find_package(yaml-cpp REQUIRED) # Build Libraries #------------------------------------------------------------------------------- file(GLOB tkdnn_SRC "src/*.cpp") -set(tkdnn_LIBS ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES} ${CUDNN_LIBRARIES} ${OpenCV_LIBS} yaml-cpp) +set(tkdnn_LIBS kernels ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES} ${CUDNN_LIBRARIES} ${OpenCV_LIBS} yaml-cpp) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include ${CUDA_INCLUDE_DIRS} ${OPENCV_INCLUDE_DIRS} ${NVINFER_INCLUDES}) -cuda_add_library(tkDNN SHARED ${tkdnn_SRC} ${tkdnn_CUSRC}) +add_library(tkDNN SHARED ${tkdnn_SRC}) target_link_libraries(tkDNN ${tkdnn_LIBS} ${CUDA_CUBLAS_LIBRAY}) #static diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 95ecb5e..94a60f3 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -8,48 +8,25 @@ #include "NvInfer.h" #include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include namespace tk { namespace dnn { -template void writeBUF(char*& buffer, const T& val) -{ - *reinterpret_cast(buffer) = val; - buffer += sizeof(T); -} - -template T readBUF(const char*& buffer) -{ - T val = *reinterpret_cast(buffer); - buffer += sizeof(T); - return val; -} - using namespace nvinfer1; -#include "pluginsRT/ActivationLeakyRT.h" -#include "pluginsRT/ActivationLogisticRT.h" -#include "pluginsRT/ActivationReLUCeilingRT.h" -#include "pluginsRT/ActivationMishRT.h" -#include "pluginsRT/ReorgRT.h" -#include "pluginsRT/RegionRT.h" -#include "pluginsRT/RouteRT.h" -#include "pluginsRT/ShortcutRT.h" -#include "pluginsRT/YoloRT.h" -#include "pluginsRT/UpsampleRT.h" -#include "pluginsRT/ResizeLayerRT.h" -#include "pluginsRT/DeformableConvRT.h" -#include "pluginsRT/FlattenConcatRT.h" -#include "pluginsRT/ReshapeRT.h" -#include "pluginsRT/MaxPoolingFixedSizeRT.h" - -/* -class PluginFactory : IPlugin -{ -public: - YoloRT *yolos[16]; - int n_yolos; - - virtual IPlugin* createPlugin(const char* layerName, const void* serialData, size_t serialLength); -};*/ diff --git a/include/tkDNN/pluginsRT/ActivationLeakyRT.h b/include/tkDNN/pluginsRT/ActivationLeakyRT.h index e73ca2b..ae395ef 100644 --- a/include/tkDNN/pluginsRT/ActivationLeakyRT.h +++ b/include/tkDNN/pluginsRT/ActivationLeakyRT.h @@ -1,148 +1,84 @@ +#include "NvInfer.h" #include "../kernels.h" #include +#include -class ActivationLeakyRT : public IPluginV2 { +namespace nvinfer1 { + class ActivationLeakyRT : public IPluginV2 { -public: - ActivationLeakyRT(float s) { slope = s; } + public: + explicit ActivationLeakyRT(float s); - ActivationLeakyRT(const void *data, size_t length) - { - std::cout<<"DESERIALIZE LEAKYRT"<(data),*bufCheck = buf; - slope = readBUF(buf); - size = readBUF(buf); - assert(buf == bufCheck + length); + ActivationLeakyRT(const void *data, size_t length); - } + ~ActivationLeakyRT(); - ~ActivationLeakyRT() {} + int getNbOutputs() const NOEXCEPT override; - int getNbOutputs() const NOEXCEPT override { return 1; } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override { - return inputs[0]; - } + void + configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override - { - assert(type == DataType::kFLOAT && format == PluginFormat::kLINEAR); - size = 1; - for (int i = 0; i < outputDims[0].nbDims; i++) - size *= outputDims[0].d[i]; - } + int initialize() NOEXCEPT override; - int initialize() NOEXCEPT override { return 0; } + void terminate() NOEXCEPT override {} - virtual void terminate() NOEXCEPT override {} + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { - return 0; - } + int enqueue(int batchSize, void const *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; - virtual int enqueue(int batchSize, void const *const *inputs, void *const *outputs, void *workspace, - cudaStream_t stream) NOEXCEPT override { - activationLEAKYForward( - (dnnType *) reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), batchSize * size, slope, - stream); - return 0; - } + size_t getSerializationSize() const NOEXCEPT override; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 1 * sizeof(int) + 1 * sizeof(float); - } + void serialize(void *buffer) const NOEXCEPT override; - virtual void serialize(void *buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer), *a = buf; - tk::dnn::writeBUF(buf, size); - assert(buf == a + getSerializationSize()); - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; - bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override { - return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); - } + const char *getPluginType() const NOEXCEPT override; - const char *getPluginType() const NOEXCEPT override { - return "ActivationLeakyRT_tkDNN"; - } + const char *getPluginVersion() const NOEXCEPT override; - const char *getPluginVersion() const NOEXCEPT override { - return "1"; - } + void destroy() NOEXCEPT override; - void destroy() NOEXCEPT override { delete this; } + const char *getPluginNamespace() const NOEXCEPT override; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { - mPluginNamespace = pluginNamespace; - } + IPluginV2 *clone() const NOEXCEPT override; - IPluginV2* clone() const NOEXCEPT override { - ActivationLeakyRT *p = new ActivationLeakyRT(slope); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + int size; + float slope; - int size; - float slope; + private: + std::string mPluginNamespace; + }; -private: - std::string mPluginNamespace; -}; + class ActivationLeakyRTPluginCreator : public IPluginCreator { + public: + ActivationLeakyRTPluginCreator(); -class ActivationLeakyRTPluginCreator : public IPluginCreator { -public: - ActivationLeakyRTPluginCreator() { - mPluginAttributes.emplace_back( - PluginField("slope", nullptr, PluginFieldType::kFLOAT32, 1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override { - ActivationLeakyRT *pluginObj = new ActivationLeakyRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const char *getPluginNamespace() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override { - const PluginField *fields = fc->fields; - assert(fc->nbFields == 1); - assert(fields[0].type == PluginFieldType::kFLOAT32); - float slope = *(static_cast(fields[0].data)); - ActivationLeakyRT *pluginObj = new ActivationLeakyRT(slope); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const char *getPluginName() const NOEXCEPT override ; - const char *getPluginName() const NOEXCEPT override{ - return "ActivationLeakyRT_tkDNN"; - } + const char *getPluginVersion() const NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } + const PluginFieldCollection *getFieldNames() NOEXCEPT override; - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; -REGISTER_TENSORRT_PLUGIN(ActivationLeakyRTPluginCreator); \ No newline at end of file + REGISTER_TENSORRT_PLUGIN(ActivationLeakyRTPluginCreator); +}; \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ActivationLogisticRT.h b/include/tkDNN/pluginsRT/ActivationLogisticRT.h index e40e7b4..9646efc 100644 --- a/include/tkDNN/pluginsRT/ActivationLogisticRT.h +++ b/include/tkDNN/pluginsRT/ActivationLogisticRT.h @@ -1,147 +1,83 @@ #include #include "../kernels.h" +#include +#include +#include -class ActivationLogisticRT : public IPluginV2 { +namespace nvinfer1 { -public: - ActivationLogisticRT() { + class ActivationLogisticRT : public IPluginV2 { - } + public: + ActivationLogisticRT() ; - ActivationLogisticRT(const void *data, size_t length) - { - const char* buf = reinterpret_cast(data),*bufCheck = buf; - size = readBUF(buf); - assert(buf == bufCheck + length); + ActivationLogisticRT(const void *data, size_t length) ; - } + ~ActivationLogisticRT() ; - ~ActivationLogisticRT(){ + int getNbOutputs() const NOEXCEPT override ; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return inputs[0]; - } + int initialize() NOEXCEPT override ; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { - size = 1; - for(int i=0; i(inputs[0]), - reinterpret_cast(outputs[0]), batchSize*size, stream); - return 0; - } + const char *getPluginVersion() const NOEXCEPT override ; + void destroy() NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 1*sizeof(int); - } + const char *getPluginNamespace() const NOEXCEPT override ; - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer); - tk::dnn::writeBUF(buf, size); - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override { - return "ActivationLogisticRT_tkDNN"; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override { - return "1"; - } + IPluginV2 *clone() const NOEXCEPT override ; - void destroy() NOEXCEPT override { delete this; } + int size; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + private: + std::string mPluginNamespace; + }; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { - mPluginNamespace = pluginNamespace; - } + class ActivationLogisticRTPluginCreator : public IPluginCreator { + public: + ActivationLogisticRTPluginCreator() ; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - //todo assert; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override{ - ActivationLogisticRT *p = new ActivationLogisticRT(); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - int size; + const char *getPluginNamespace() const NOEXCEPT override ; -private: - std::string mPluginNamespace; -}; + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; -class ActivationLogisticRTPluginCreator : public IPluginCreator{ -public: - ActivationLogisticRTPluginCreator(){ - mPluginAttributes.clear(); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } + const char *getPluginVersion() const NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override { - ActivationLogisticRT *pluginObj = new ActivationLogisticRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const char *getPluginName() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override { - ActivationLogisticRT *pluginObj = new ActivationLogisticRT(); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - - const char *getPluginName() const NOEXCEPT override{ - return "ActivationLogisticRT_tkDNN"; - } - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(ActivationLogisticRTPluginCreator); \ No newline at end of file + REGISTER_TENSORRT_PLUGIN(ActivationLogisticRTPluginCreator); +}; \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ActivationMishRT.h b/include/tkDNN/pluginsRT/ActivationMishRT.h index 65153d0..3c9f15a 100644 --- a/include/tkDNN/pluginsRT/ActivationMishRT.h +++ b/include/tkDNN/pluginsRT/ActivationMishRT.h @@ -1,135 +1,79 @@ #include #include "../kernels.h" +#include +#include -class ActivationMishRT : public IPluginV2 { +namespace nvinfer1 { + class ActivationMishRT : public IPluginV2 { -public: - ActivationMishRT() {} + public: + ActivationMishRT() ; - ~ActivationMishRT() {} + ~ActivationMishRT() ; - ActivationMishRT(const void *data, size_t length) { - std::cout<<"DESERIALIZE MISH"<(data), *bufCheck = buf; - size = readBUF(buf); - assert(buf == bufCheck + length); - } + ActivationMishRT(const void *data, size_t length) ; - int getNbOutputs() const NOEXCEPT override { return 1; } + int getNbOutputs() const NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override { return inputs[0]; } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override { - assert(format == PluginFormat::kLINEAR); - size = 1; - for (int i = 0; i < outputDims[0].nbDims; i++) - size *= outputDims[0].d[i]; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - int initialize() NOEXCEPT override { return 0; } + int initialize() NOEXCEPT override ; - virtual void terminate() NOEXCEPT override {} + void terminate() NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0; } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, - cudaStream_t stream) NOEXCEPT override { - activationMishForward((dnnType *) reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), batchSize * size, stream); - return 0; - } + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT override ; + size_t getSerializationSize() const NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 1 * sizeof(int); - } + void serialize(void *buffer) const NOEXCEPT override ; - virtual void serialize(void *buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer), *a = buf; - tk::dnn::writeBUF(buf, size); - assert(buf == a + getSerializationSize()); - } + const char *getPluginType() const NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override { - return "ActivationMishRT_tkDNN"; - } + const char *getPluginVersion() const NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override { - return "1"; - } + void destroy() NOEXCEPT override { delete this; } - void destroy() NOEXCEPT override { delete this; } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - } + const char *getPluginNamespace() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + void setPluginNamespace(const char *plguinNamespace) NOEXCEPT override ; - void setPluginNamespace(const char *plguinNamespace) NOEXCEPT override { - mPluginNamespace = plguinNamespace; - } + IPluginV2 *clone() const NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override { - ActivationMishRT *p = new ActivationMishRT(); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + int size; + private: + std::string mPluginNamespace; + }; - int size; -private: - std::string mPluginNamespace; -}; + class ActivationMishRTPluginCreator : public IPluginCreator { + public: + ActivationMishRTPluginCreator() ; -class ActivationMishRTPluginCreator : public IPluginCreator { -public: - ActivationMishRTPluginCreator() { - mPluginAttributes.clear(); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + const char *getPluginNamespace() const NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { - mPluginNamespace = pluginNamespace; - } + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - const char* getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ - ActivationMishRT *pluginObj = new ActivationMishRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const char *getPluginName() const NOEXCEPT override ; - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - ActivationMishRT *pluginObj = new ActivationMishRT(); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const char *getPluginVersion() const NOEXCEPT override ; - const char *getPluginName() const NOEXCEPT override{ - return "ActivationMishRT_tkDNN"; - } + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(ActivationMishRTPluginCreator); \ No newline at end of file + REGISTER_TENSORRT_PLUGIN(ActivationMishRTPluginCreator); +}; \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h index 8d295df..b5c186c 100644 --- a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h +++ b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h @@ -1,150 +1,78 @@ #include #include "../kernels.h" +#include +#include +#include +namespace nvinfer1 { + class ActivationReLUCeiling : public IPluginV2 { -class ActivationReLUCeiling : public IPluginV2 { + public: + explicit ActivationReLUCeiling(const float ceiling) ; -public: - ActivationReLUCeiling(const float ceiling) { - this->ceiling = ceiling; - } + ~ActivationReLUCeiling() ; - ~ActivationReLUCeiling() { + ActivationReLUCeiling(const void *data, size_t length) ; - } + int getNbOutputs() const NOEXCEPT override ; - ActivationReLUCeiling(const void *data, size_t length) { - std::cout<<"RELU CEILING DESERIALIZE"<(data), *bufCheck = buf; - ceiling = readBUF(buf); - size = readBUF(buf); - assert(buf == bufCheck + length); - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override { - return inputs[0]; - } + int initialize() NOEXCEPT override ; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override { - assert(type == DataType::kFLOAT && format == PluginFormat::kLINEAR); - size = 1; - for (int i = 0; i < outputDims[0].nbDims; i++) - size *= outputDims[0].d[i]; - } + void terminate() NOEXCEPT override ; - int initialize() NOEXCEPT override { return 0; } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual void terminate() NOEXCEPT override {} + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { - return 0; - } + size_t getSerializationSize() const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, - cudaStream_t stream) NOEXCEPT override { - activationReLUCeilingForward((dnnType *) reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), batchSize * size, ceiling, stream); - return 0; - } + void serialize(void *buffer) const NOEXCEPT override ; + IPluginV2 *clone() const NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 1 * sizeof(int) + 1 * sizeof(float); - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - virtual void serialize(void *buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer), *a = buf; - tk::dnn::writeBUF(buf, ceiling); - tk::dnn::writeBUF(buf, size); - assert(buf = a + getSerializationSize()); + void destroy() NOEXCEPT override ; - } + const char *getPluginType() const NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override { - ActivationReLUCeiling *p = new ActivationReLUCeiling(ceiling); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + const char *getPluginVersion() const NOEXCEPT override ; - bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override { - return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); - } + const char *getPluginNamespace() const NOEXCEPT override ; - void destroy() NOEXCEPT override { delete this; }; + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + int size; + float ceiling; + private: + std::string mPluginNamespace; + }; - const char *getPluginType() const NOEXCEPT override { - return "ActivationReLUCeilingRT_tkDNN"; - } + class ActivationReLUCeilingPluginCreator : public IPluginCreator { + public: + ActivationReLUCeilingPluginCreator() ; - const char *getPluginVersion() const NOEXCEPT override { - return "1"; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + const char *getPluginNamespace() const NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { - mPluginNamespace = pluginNamespace; - } + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - int size; - float ceiling; -private: - std::string mPluginNamespace; -}; + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; -class ActivationReLUCeilingPluginCreator : public IPluginCreator { -public: - ActivationReLUCeilingPluginCreator() { - mPluginAttributes.emplace_back(PluginField("ceiling", nullptr, PluginFieldType::kFLOAT32, 1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } + const char *getPluginName() const NOEXCEPT override ; + const char *getPluginVersion() const NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override { - mPluginNamespace = pluginNamespace; - } + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } + public: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override { - ActivationReLUCeiling *pluginObj = new ActivationReLUCeiling(serialData, serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - float ceiling = *(static_cast(fields[0].data)); - ActivationReLUCeiling *pluginObj = new ActivationReLUCeiling(ceiling); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "ActivationReLUCeilingRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -public: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(ActivationReLUCeilingPluginCreator); + REGISTER_TENSORRT_PLUGIN(ActivationReLUCeilingPluginCreator); +}; \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h index 7076379..adc5554 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -1,360 +1,115 @@ +#ifndef _DEFORMABLECONVRT_PLUGIN_H +#define _DEFORMABLECONVRT_PLUGIN_H + +#include +#include #include #include "../kernels.h" +#include -class DeformableConvRT : public IPluginV2 { +namespace nvinfer1 { + class DeformableConvRT : public IPluginV2 { + public: + DeformableConvRT(int chunk_dim, int kh, int kw, int sh, int sw, int ph, int pw, + int deformableGroup, int i_n, int i_c, int i_h, int i_w, + int o_n, int o_c, int o_h, int o_w, + tk::dnn::DeformConv2d *deformable = nullptr); -public: - DeformableConvRT(int chunk_dim, int kh, int kw, int sh, int sw, int ph, int pw, - int deformableGroup, int i_n, int i_c, int i_h, int i_w, - int o_n, int o_c, int o_h, int o_w, - tk::dnn::DeformConv2d *deformable = nullptr) { - this->chunk_dim = chunk_dim; - this->kh = kh; - this->kw = kw; - this->sh = sh; - this->sw = sw; - this->ph = ph; - this->pw = pw; - this->deformableGroup = deformableGroup; - this->i_n = i_n; - this->i_c = i_c; - this->i_h = i_h; - this->i_w = i_w; - this->o_n = o_n; - this->o_c = o_c; - this->o_h = o_h; - this->o_w = o_w; - this->defRT = deformable; + ~DeformableConvRT(); - height_ones = (i_h + 2 * ph - (1 * (kh - 1) + 1)) / sh + 1; - width_ones = (i_w + 2 * pw - (1 * (kw - 1) + 1)) / sw + 1; - dim_ones = i_c * kh * kw * 1 * height_ones * width_ones; - - checkCuda( cudaMalloc(&data_d, i_c * o_c * kh * kw * 1 * sizeof(dnnType))); - checkCuda( cudaMalloc(&bias2_d, o_c*sizeof(dnnType))); - checkCuda( cudaMalloc(&ones_d1, height_ones * width_ones * sizeof(dnnType))); - checkCuda( cudaMalloc(&offset, 2*chunk_dim*sizeof(dnnType))); - checkCuda( cudaMalloc(&mask, chunk_dim*sizeof(dnnType))); - checkCuda( cudaMalloc(&ones_d2, dim_ones*sizeof(dnnType))); - if(deformable != nullptr) { - checkCuda( cudaMemcpy(data_d, deformable->data_d, sizeof(dnnType)*i_c * o_c * kh * kw * 1, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(bias2_d, deformable->bias2_d, sizeof(dnnType)*o_c, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(ones_d1, deformable->ones_d1, sizeof(dnnType)*height_ones*width_ones, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(offset, deformable->offset, sizeof(dnnType)*2*chunk_dim, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(mask, deformable->mask, sizeof(dnnType)*chunk_dim, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(ones_d2, deformable->ones_d2, sizeof(dnnType)*dim_ones, cudaMemcpyDeviceToDevice) ); - } - stat = cublasCreate(&handle); - if (stat != CUBLAS_STATUS_SUCCESS) - FatalError("CUBLAS initialization failed\n"); - } + DeformableConvRT(const void *data, size_t length) ; - ~DeformableConvRT() { - checkCuda( cudaFree(data_d) ); - checkCuda( cudaFree(bias2_d) ); - checkCuda( cudaFree(ones_d1) ); - checkCuda( cudaFree(offset) ); - checkCuda( cudaFree(mask) ); - checkCuda( cudaFree(ones_d2) ); - cublasDestroy(handle); - } + int getNbOutputs() const NOEXCEPT override ; - DeformableConvRT(const void *data,size_t length){ - const char* buf = reinterpret_cast(data),*bufCheck = buf; - chunk_dim = readBUF(buf); - kh = readBUF(buf); - kw = readBUF(buf); - sh = readBUF(buf); - sw = readBUF(buf); - ph = readBUF(buf); - pw = readBUF(buf); - deformableGroup = readBUF(buf); - i_n = readBUF(buf); - i_c = readBUF(buf); - i_h = readBUF(buf); - i_w = readBUF(buf); - o_n = readBUF(buf); - o_c = readBUF(buf); - o_h = readBUF(buf); - o_w = readBUF(buf); - dnnType *aus = new dnnType[chunk_dim*2]; - for(int i=0;i(buf); - checkCuda(cudaMemcpy(offset,aus,sizeof(dnnType)*2*chunk_dim,cudaMemcpyHostToDevice)); - free(aus); + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - aus = new dnnType[chunk_dim]; - for(int i=0;i(buf); - checkCuda(cudaMemcpy(mask,aus,sizeof(dnnType)*chunk_dim,cudaMemcpyHostToDevice)); - free(aus); + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - aus = new dnnType[i_c*o_c*kh*kw*1]; - for(int i=0;i<(i_c*o_c*kh*kw*1);i++) - aus[i] = readBUF(buf); - checkCuda(cudaMemcpy(data_d,aus,sizeof(dnnType)*(i_c*o_c*kh*kw*1),cudaMemcpyHostToDevice)); - free(aus); + int initialize() NOEXCEPT override ; - aus = new dnnType[o_c]; - for(int i=0; i < o_c; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(bias2_d, aus, sizeof(dnnType)*o_c, cudaMemcpyHostToDevice) ); - free(aus); + void terminate() NOEXCEPT override ; - aus = new dnnType[height_ones * width_ones]; - for(int i=0; i(buf); - checkCuda( cudaMemcpy(ones_d1, aus, sizeof(dnnType)*height_ones * width_ones, cudaMemcpyHostToDevice) ); - free(aus); + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - aus = new dnnType[dim_ones]; - for(int i=0; i(buf); - checkCuda( cudaMemcpy(ones_d2, aus, sizeof(dnnType)*dim_ones, cudaMemcpyHostToDevice) ); - free(aus); + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; - assert(buf == bufCheck + length); - } + size_t getSerializationSize() const NOEXCEPT override ; - int getNbOutputs() const NOEXCEPT override {return 1;} + void serialize(void *buffer) const NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{defRT->output_dim.c, defRT->output_dim.h, defRT->output_dim.w}; - } + void destroy() NOEXCEPT override ; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - int initialize() NOEXCEPT override {return 0;} + const char *getPluginNamespace() const NOEXCEPT override ; - virtual void terminate() NOEXCEPT override { } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} + const char *getPluginType() const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *output_conv = (dnnType*)reinterpret_cast(inputs[1]); + const char *getPluginVersion() const NOEXCEPT override ; - // split conv2d outputs into offset to mask - for(int b=0; b(outputs[0]), ones_d2, - kh, kw, - sh, sw, - ph, pw, - 1, 1, - deformableGroup, b, - i_n, i_c, i_h, i_w, - o_n, o_c, o_h, o_w, - chunk_dim); - } - return 0; - } - - virtual size_t getSerializationSize() const NOEXCEPT override { - return 16 * sizeof(int) + chunk_dim * 3 * sizeof(dnnType) + (i_c * o_c * kh * kw * 1 ) * sizeof(dnnType) + - o_c * sizeof(dnnType) + height_ones * width_ones * sizeof(dnnType) + dim_ones * sizeof(dnnType); - } - - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, chunk_dim); - tk::dnn::writeBUF(buf, kh); - tk::dnn::writeBUF(buf, kw); - tk::dnn::writeBUF(buf, sh); - tk::dnn::writeBUF(buf, sw); - tk::dnn::writeBUF(buf, ph); - tk::dnn::writeBUF(buf, pw); - tk::dnn::writeBUF(buf, deformableGroup); - tk::dnn::writeBUF(buf, i_n); - tk::dnn::writeBUF(buf, i_c); - tk::dnn::writeBUF(buf, i_h); - tk::dnn::writeBUF(buf, i_w); - tk::dnn::writeBUF(buf, o_n); - tk::dnn::writeBUF(buf, o_c); - tk::dnn::writeBUF(buf, o_h); - tk::dnn::writeBUF(buf, o_w); - dnnType *aus = new dnnType[chunk_dim*2]; - checkCuda( cudaMemcpy(aus, offset, sizeof(dnnType)*2*chunk_dim, cudaMemcpyDeviceToHost) ); - for(int i=0; isetPluginNamespace(mPluginNamespace.c_str()); - return p; - } + IPluginV2 *clone() const NOEXCEPT override ; - cublasStatus_t stat; - cublasHandle_t handle; - int i_n, i_c, i_h, i_w; - int o_n, o_c, o_h, o_w; - int size; - int chunk_dim; - int kh, kw; - int sh, sw; - int ph, pw; - int deformableGroup; - int height_ones; - int width_ones; - int dim_ones; - - dnnType *data_d; - dnnType *bias2_d; - dnnType *ones_d1; - dnnType * offset; - dnnType * mask; - dnnType *ones_d2; - // dnnType *input_n; - // dnnType *offset_n; - // dnnType *mask_n; - // dnnType *output_n; - - - tk::dnn::DeformConv2d *defRT; + cublasStatus_t stat; + cublasHandle_t handle; + int i_n, i_c, i_h, i_w; + int o_n, o_c, o_h, o_w; + int size; + int chunk_dim; + int kh, kw; + int sh, sw; + int ph, pw; + int deformableGroup; + int height_ones; + int width_ones; + int dim_ones; + + dnnType *data_d; + dnnType *bias2_d; + dnnType *ones_d1; + dnnType *offset; + dnnType *mask; + dnnType *ones_d2; + // dnnType *input_n; + // dnnType *offset_n; + // dnnType *mask_n; + // dnnType *output_n; + + + tk::dnn::DeformConv2d *defRT; + + private: + std::string mPluginNamespace; + }; + + class DeformableConvRTPluginCreator : public IPluginCreator { + public: + DeformableConvRTPluginCreator(); + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; -private: - std::string mPluginNamespace; }; - -class DeformableConvRTPluginCreator : public IPluginCreator{ -public: - DeformableConvRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("chunk_dim",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("kh",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("kw",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("sh",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("sw",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("ph",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("pw",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("deformableGroup",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_n",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_w",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_n",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("defRT",nullptr,PluginFieldType::kUNKNOWN,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override { - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ - DeformableConvRT *pluginObj = new DeformableConvRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - int chunk_dim = *(static_cast(fields[0].data)); - int kh = *(static_cast(fields[1].data)); - int kw = *(static_cast(fields[2].data)); - int sh = *(static_cast(fields[3].data)); - int sw = *(static_cast(fields[4].data)); - int ph = *(static_cast(fields[5].data)); - int pw = *(static_cast(fields[6].data)); - int deformableGroup = *(static_cast(fields[7].data)); - int i_n = *(static_cast(fields[8].data)); - int i_c = *(static_cast(fields[9].data)); - int i_h = *(static_cast(fields[10].data)); - int i_w = *(static_cast(fields[11].data)); - int o_n = *(static_cast(fields[12].data)); - int o_c = *(static_cast(fields[13].data)); - int o_h = *(static_cast(fields[14].data)); - int o_w = *(static_cast(fields[14].data)); - DeformConv2d *defRT = const_cast(static_cast(fields[15].data)); - DeformableConvRT *pluginObj = new DeformableConvRT(chunk_dim,kh,kw,sh,sw,ph,pw,deformableGroup,i_n,i_c,i_h,i_w,o_n,o_c,o_h,o_w,defRT); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "DeformableConvRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - - +#endif diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index 3c6f3ee..7d655d3 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -1,162 +1,81 @@ #include +#include +#include +#include +namespace nvinfer1 { + class FlattenConcatRT : public IPluginV2 { -class FlattenConcatRT : public IPluginV2 { + public: + FlattenConcatRT() ; -public: - FlattenConcatRT() { - stat = cublasCreate(&handle); - if (stat != CUBLAS_STATUS_SUCCESS) { - printf ("CUBLAS initialization failed\n"); - return; - } - } + FlattenConcatRT(const void *data, size_t length) ; - FlattenConcatRT(const void *data,size_t length){ - const char *buf = reinterpret_cast(data),*bufCheck=buf; - c = readBUF(buf); - h = readBUF(buf); - w = readBUF(buf); - rows = readBUF(buf); - cols = readBUF(buf); - assert(buf == bufCheck + length); - } + ~FlattenConcatRT() ; - ~FlattenConcatRT(){ + int getNbOutputs() const NOEXCEPT override ; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{ inputs[0].d[0] * inputs[0].d[1] * inputs[0].d[2], 1, 1}; - } + int initialize() NOEXCEPT override ; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { - assert(nbOutputs == 1 && nbInputs ==1); - rows = inputDims[0].d[0]; - cols = inputDims[0].d[1] * inputDims[0].d[2]; - c = inputDims[0].d[0] * inputDims[0].d[1] * inputDims[0].d[2]; - h = 1; - w = 1; - } + void terminate() NOEXCEPT override ; - int initialize() NOEXCEPT override {return 0;} + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual void terminate() NOEXCEPT override { checkERROR(cublasDestroy(handle));} + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override {return 0;} + size_t getSerializationSize() const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*rows*cols*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + void serialize(void *buffer) const NOEXCEPT override ; - checkERROR( cublasSetStream(handle, stream) ); - for(int i=0; i(buffer),*a = buf; - tk::dnn::writeBUF(buf, c); - tk::dnn::writeBUF(buf, h); - tk::dnn::writeBUF(buf, w); - tk::dnn::writeBUF(buf, rows); - tk::dnn::writeBUF(buf, cols); - assert(buf == a + getSerializationSize()); - } + const char *getPluginType() const NOEXCEPT override ; - void destroy() NOEXCEPT override{delete this;} + const char *getPluginVersion() const NOEXCEPT override; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - } + const char *getPluginNamespace() const NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override{ - return "FlattenConcatRT_tkDNN"; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } + IPluginV2 *clone() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + int c, h, w; + int rows, cols; + cublasStatus_t stat; + cublasHandle_t handle; + private: + std::string mPluginNamespace; + }; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + class FlattenConcatRTPluginCreator : public IPluginCreator { + public: + FlattenConcatRTPluginCreator() ; - IPluginV2 *clone() const NOEXCEPT override { - FlattenConcatRT *p = new FlattenConcatRT(); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - int c, h, w; - int rows, cols; - cublasStatus_t stat; - cublasHandle_t handle; -private: - std::string mPluginNamespace; -}; + const char *getPluginNamespace() const NOEXCEPT override ; -class FlattenConcatRTPluginCreator : public IPluginCreator{ -public: - FlattenConcatRTPluginCreator(){ - mPluginAttributes.clear(); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + const char *getPluginName() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ - FlattenConcatRT *pluginObj = new FlattenConcatRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const char *getPluginVersion() const NOEXCEPT override; - IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ - FlattenConcatRT *pluginObj = new FlattenConcatRT(); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; - const char *getPluginName() const NOEXCEPT override{ - return "FlattenConcatRT_tkDNN"; - } + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(FlattenConcatRTPluginCreator); \ No newline at end of file + REGISTER_TENSORRT_PLUGIN(FlattenConcatRTPluginCreator); +}; \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h index ef5a8f7..14f714e 100644 --- a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h +++ b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h @@ -1,182 +1,89 @@ #include #include "../kernels.h" +#include +#include +#include -class MaxPoolFixedSizeRT : public IPluginV2 { +namespace nvinfer1 { + class MaxPoolFixedSizeRT : public IPluginV2 { -public: - MaxPoolFixedSizeRT(int c, int h, int w, int n, int strideH, int strideW, int winSize, int padding) { - this->c = c; - this->h = h; - this->w = w; - this->n = n; - this->stride_H = strideH; - this->stride_W = strideW; - this->winSize = winSize; - this->padding = padding; - } + public: + MaxPoolFixedSizeRT(int c, int h, int w, int n, int strideH, int strideW, int winSize, int padding) ; - MaxPoolFixedSizeRT(const void *data,size_t length){ - const char *buf = reinterpret_cast(data),*bufCheck = buf; - c = readBUF(buf); - h = readBUF(buf); - w = readBUF(buf); - n = readBUF(buf); - stride_H = readBUF(buf); - stride_W = readBUF(buf); - winSize = readBUF(buf); - padding = readBUF(buf); - assert(buf == bufCheck + length); - } + MaxPoolFixedSizeRT(const void *data, size_t length) ; - ~MaxPoolFixedSizeRT(){ - } + ~MaxPoolFixedSizeRT() ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + int getNbOutputs() const NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{this->c, this->h, this->w}; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - int initialize() NOEXCEPT override {return 0;} + int initialize() NOEXCEPT override ; - virtual void terminate() NOEXCEPT override {} + void terminate() NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { - - //std::cout<n<<" "<c<<" "<h<<" "<w<<" "<stride_H<<" "<stride_W<<" "<winSize<<" "<padding<(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); - MaxPoolingForward(srcData, dstData, batchSize, this->c, this->h, this->w, this->stride_H, this->stride_W, this->winSize, this->padding, stream); - return 0; - } + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 8*sizeof(int); - } + size_t getSerializationSize() const NOEXCEPT override ; - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer),*a=buf; + void serialize(void *buffer) const NOEXCEPT override ; - tk::dnn::writeBUF(buf, this->c); - tk::dnn::writeBUF(buf, this->h); - tk::dnn::writeBUF(buf, this->w); - tk::dnn::writeBUF(buf, this->n); - tk::dnn::writeBUF(buf, this->stride_H); - tk::dnn::writeBUF(buf, this->stride_W); - tk::dnn::writeBUF(buf, this->winSize); - tk::dnn::writeBUF(buf, this->padding); - assert(buf == a + getSerializationSize()); - } + void destroy() NOEXCEPT override ; - void destroy() NOEXCEPT override{delete this;} + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - //todo assert - } + const char *getPluginNamespace() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - const char *getPluginType() const NOEXCEPT override{ - return "MaxPoolingFixedSizeRT_tkDNN"; - } + const char *getPluginType() const NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } + const char *getPluginVersion() const NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override{ - MaxPoolFixedSizeRT *p = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + IPluginV2 *clone() const NOEXCEPT override ; - int n, c, h, w; - int stride_H, stride_W; - int winSize; - int padding; + int n, c, h, w; + int stride_H, stride_W; + int winSize; + int padding; -private: - std::string mPluginNamespace; + private: + std::string mPluginNamespace; + }; + + class MaxPoolFixedSizeRTPluginCreator : public IPluginCreator { + public: + MaxPoolFixedSizeRTPluginCreator() ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + + }; + + REGISTER_TENSORRT_PLUGIN(MaxPoolFixedSizeRTPluginCreator); }; - -class MaxPoolFixedSizeRTPluginCreator : public IPluginCreator{ -public: - MaxPoolFixedSizeRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("n",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("stride_H",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("stride_W",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("winSize",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("padding",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ - MaxPoolFixedSizeRT *pluginObj = new MaxPoolFixedSizeRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - //todo assert - int c = *(static_cast(fields[0].data)); - int h = *(static_cast(fields[1].data)); - int w = *(static_cast(fields[2].data)); - int n = *(static_cast(fields[3].data)); - int stride_H = *(static_cast(fields[4].data)); - int stride_W = *(static_cast(fields[5].data)); - int winSize = *(static_cast(fields[6].data)); - int padding = *(static_cast(fields[7].data)); - MaxPoolFixedSizeRT *pluginObj = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "MaxPoolingFixedSizeRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; - -}; - -REGISTER_TENSORRT_PLUGIN(MaxPoolFixedSizeRTPluginCreator); diff --git a/include/tkDNN/pluginsRT/RegionRT.h b/include/tkDNN/pluginsRT/RegionRT.h index e187d6c..cdcb515 100644 --- a/include/tkDNN/pluginsRT/RegionRT.h +++ b/include/tkDNN/pluginsRT/RegionRT.h @@ -1,188 +1,95 @@ +#ifndef _REGIONRT_PLUGIN_H +#define _REGIONRT_PLUGIN_H #include #include "../kernels.h" +#include +#include +#include -class RegionRT : public IPluginV2 { +namespace nvinfer1 { + class RegionRT : public IPluginV2 { -public: - RegionRT(int classes, int coords, int num) { - this->classes = classes; - this->coords = coords; - this->num = num; - } + public: + RegionRT(int classes, int coords, int num); - ~RegionRT(){ + ~RegionRT() ; - } + RegionRT(const void *data, size_t length) ; - RegionRT(const void *data,size_t length){ - const char *buf = reinterpret_cast(data),*bufCheck=buf; - classes = readBUF(buf); - coords = readBUF(buf); - num = readBUF(buf); - c = readBUF(buf); - h = readBUF(buf); - w = readBUF(buf); - assert(buf == bufCheck+length); - } + int getNbOutputs() const NOEXCEPT override ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return inputs[0]; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } - - int initialize() NOEXCEPT override { return 0; } + int initialize() NOEXCEPT override ; - virtual void terminate() NOEXCEPT override { } + void terminate() NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0; } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { - - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); - - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); - - for (int b = 0; b < batchSize; ++b){ - for(int n = 0; n < num; ++n){ - int index = entry_index(b, n*w*h, 0); - activationLOGISTICForward(srcData + index, dstData + index, 2*w*h, stream); - - index = entry_index(b, n*w*h, coords); - activationLOGISTICForward(srcData + index, dstData + index, w*h, stream); - } - } - - //softmax start - int index = entry_index(0, 0, coords + 1); - softmaxForward( srcData + index, classes, batchSize*num, - (c*h*w)/num, - w*h, 1, w*h, 1, dstData + index, stream); - - return 0; - } + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 6*sizeof(int); - } + size_t getSerializationSize() const NOEXCEPT override ; - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, classes); - tk::dnn::writeBUF(buf, coords); - tk::dnn::writeBUF(buf, num); - tk::dnn::writeBUF(buf, c); - tk::dnn::writeBUF(buf, h); - tk::dnn::writeBUF(buf, w); - assert(buf == a + getSerializationSize()); - } + void serialize(void *buffer) const NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override{ - return "RegionRT_tkDNN"; - } + const char *getPluginType() const NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } + const char *getPluginVersion() const NOEXCEPT override ; - void destroy() NOEXCEPT override {delete this;} + void destroy() NOEXCEPT override ; - const char* getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + const char *getPluginNamespace() const NOEXCEPT override ; - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - IPluginV2* clone() const NOEXCEPT override{ - RegionRT *p = new RegionRT(classes,coords,num); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + IPluginV2 *clone() const NOEXCEPT override ; + int c, h, w; + int classes, coords, num; - int c, h, w; - int classes, coords, num; + int entry_index(int batch, int location, int entry) { + int n = location / (w * h); + int loc = location % (w * h); + return batch * c * h * w + n * w * h * (coords + classes + 1) + entry * w * h + loc; + } - int entry_index(int batch, int location, int entry) { - int n = location / (w*h); - int loc = location % (w*h); - return batch*c*h*w + n*w*h*(coords+classes+1) + entry*w*h + loc; - } + private: + std::string mPluginNamespace; + }; -private: - std::string mPluginNamespace; + class RegionRTPluginCreator : public IPluginCreator { + public: + RegionRTPluginCreator(); + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(RegionRTPluginCreator); }; -class RegionRTPluginCreator : public IPluginCreator{ -public: - RegionRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("coords",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - IPluginV2 *deserializePlugin(const char* name,const void *serialData,size_t serialLength) NOEXCEPT override{ - RegionRT *pluginObj = new RegionRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - assert(fc->nbFields == 3); - assert(fields[0].type == PluginFieldType::kINT32); - assert(fields[1].type == PluginFieldType::kINT32); - assert(fields[2].type == PluginFieldType::kINT32); - int classes = *(static_cast(fields[0].data)); - int coords = *(static_cast(fields[1].data)); - int num = *(static_cast(fields[2].data)); - RegionRT *pluginObj = new RegionRT(classes,coords,num); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - - } - - const char *getPluginName() const NOEXCEPT override{ - return "RegionRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(RegionRTPluginCreator); +#endif diff --git a/include/tkDNN/pluginsRT/ReorgRT.h b/include/tkDNN/pluginsRT/ReorgRT.h index 7605fde..a780615 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -1,143 +1,83 @@ #include #include "../kernels.h" +#include +#include -class ReorgRT : public IPluginV2 { +namespace nvinfer1 { + class ReorgRT : public IPluginV2 { -public: - ReorgRT(int stride) { - this->stride = stride; - } + public: + ReorgRT(int stride); - ~ReorgRT(){ + ~ReorgRT(); - } + ReorgRT(const void *data, size_t length); - ReorgRT(const void* data,size_t length){ - const char* buf = reinterpret_cast(data),*bufCheck = buf; - stride = readBUF(buf); - c = readBUF(buf); - h = readBUF(buf); - w = readBUF(buf); - assert(buf == bufCheck + length); - } + int getNbOutputs() const NOEXCEPT override; - int getNbOutputs() const NOEXCEPT override {return 1;} + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{inputs[0].d[0]*stride*stride, inputs[0].d[1]/stride, inputs[0].d[2]/stride}; - } + void + configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } + int initialize() NOEXCEPT override; - int initialize() NOEXCEPT override { return 0;} + void terminate() NOEXCEPT override; - virtual void terminate() NOEXCEPT override {} + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { - - reorgForward((dnnType*)reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), - batchSize, c, h, w, stride, stream); - return 0; - } + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 4*sizeof(int); - } + size_t getSerializationSize() const NOEXCEPT override; - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, stride); - tk::dnn::writeBUF(buf, c); - tk::dnn::writeBUF(buf, h); - tk::dnn::writeBUF(buf, w); - assert(buf == a + getSerializationSize()); - } - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{return true;} + void serialize(void *buffer) const NOEXCEPT override; - const char *getPluginType() const NOEXCEPT override{ - return "ReorgRT_tkDNN"; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; - const char* getPluginVersion() const NOEXCEPT override{ - return "1"; - } - void destroy() NOEXCEPT override{ delete this;} + const char *getPluginType() const NOEXCEPT override; - const char* getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + const char *getPluginVersion() const NOEXCEPT override; - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + void destroy() NOEXCEPT override; - IPluginV2* clone() const NOEXCEPT override{ - ReorgRT *p = new ReorgRT(stride); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + const char *getPluginNamespace() const NOEXCEPT override; - int c, h, w, stride; -private: - std::string mPluginNamespace; + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + IPluginV2 *clone() const NOEXCEPT override; + + int c, h, w, stride; + private: + std::string mPluginNamespace; + }; + + class ReorgRTPluginCreator : public IPluginCreator { + public: + ReorgRTPluginCreator(); + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + + const char *getPluginName() const NOEXCEPT override; + + const char *getPluginVersion() const NOEXCEPT override; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(ReorgRTPluginCreator); }; -class ReorgRTPluginCreator : public IPluginCreator{ -public: - ReorgRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char* getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2* deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ - ReorgRT *pluginObj = new ReorgRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection* fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - assert(fc->nbFields == 1); - assert(fields[0].type == PluginFieldType::kINT32); - int stride = *(static_cast(fields[0].data)); - ReorgRT *pluginObj = new ReorgRT(stride); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "ReorgRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(ReorgRTPluginCreator); - diff --git a/include/tkDNN/pluginsRT/ReshapeRT.h b/include/tkDNN/pluginsRT/ReshapeRT.h index 17037da..8d3fdb5 100644 --- a/include/tkDNN/pluginsRT/ReshapeRT.h +++ b/include/tkDNN/pluginsRT/ReshapeRT.h @@ -1,148 +1,85 @@ +#ifndef _RESHAPERT_PLUGIN_H +#define _RESHAPERT_PLUGIN_H + #include +#include +#include +#include +using namespace tk::dnn; -class ReshapeRT : public IPluginV2 { -public: - ReshapeRT(dataDim_t newDim) { - new_dim = newDim; - n = new_dim.n; - c = new_dim.c; - h = new_dim.h; - w = new_dim.w; - } +namespace nvinfer1 { + class ReshapeRT : public IPluginV2 { - ReshapeRT(const void *data,size_t length){ - const char *buf = reinterpret_cast(data),*bufCheck = buf; - new_dim.n = readBUF(buf); - new_dim.c = readBUF(buf); - new_dim.h = readBUF(buf); - new_dim.w = readBUF(buf); - assert(buf == bufCheck + length); - } + public: + explicit ReshapeRT(dataDim_t newDim) ; - ~ReshapeRT(){ + ReshapeRT(const void *data, size_t length) ; - } + ~ReshapeRT() ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + int getNbOutputs() const NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{ c,h,w}; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - void configureWithFormat (const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs, DataType type,PluginFormat format, int maxBatchSize) NOEXCEPT override { - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - int initialize() NOEXCEPT override {return 0;} + int initialize() NOEXCEPT override ; - virtual void terminate() NOEXCEPT override {} + void terminate() NOEXCEPT override ; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); - return 0; - } + size_t getSerializationSize() const NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 4*sizeof(int); - } + void serialize(void *buffer) const NOEXCEPT override ; - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer),*a = buf; - tk::dnn::writeBUF(buf, n); - tk::dnn::writeBUF(buf, c); - tk::dnn::writeBUF(buf, h); - tk::dnn::writeBUF(buf, w); - assert(buf == a + getSerializationSize()); - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - //todo assert - } + const char *getPluginType() const NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override{ - return "1"; - } + const char *getPluginVersion() const NOEXCEPT override ; - const char *getPluginVersion() const NOEXCEPT override{ - return "ReshapeRT_tkDNN"; - } + void destroy() NOEXCEPT override ; - void destroy() NOEXCEPT override{delete this;} + const char *getPluginNamespace() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + IPluginV2 *clone() const NOEXCEPT override ; + int n, c, h, w; + dataDim_t new_dim; + private: + std::string mPluginNamespace; + }; - IPluginV2 *clone() const NOEXCEPT override{ - ReshapeRT *p = new ReshapeRT(new_dim); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + class ReshapeRTPluginCreator : public IPluginCreator { + public: + ReshapeRTPluginCreator() ; - int n, c, h, w; - dataDim_t new_dim; -private: - std::string mPluginNamespace; + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(ReshapeRTPluginCreator); }; - -class ReshapeRTPluginCreator : public IPluginCreator{ -public: - ReshapeRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("new_dim",nullptr,PluginFieldType::kUNKNOWN,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char* name,const void *serialData,size_t serialLength) NOEXCEPT override{ - ReshapeRT *pluginObj = new ReshapeRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - dataDim_t newDim = *(static_cast(fields[0].data)); - ReshapeRT *pluginObj = new ReshapeRT(newDim); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "ReshapeRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(ReshapeRTPluginCreator); +#endif \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/ResizeLayerRT.h b/include/tkDNN/pluginsRT/ResizeLayerRT.h index 374b7d8..7316048 100644 --- a/include/tkDNN/pluginsRT/ResizeLayerRT.h +++ b/include/tkDNN/pluginsRT/ResizeLayerRT.h @@ -1,165 +1,87 @@ #include #include "../kernels.h" +#include +#include +#include -class ResizeLayerRT : public IPluginV2 { +namespace nvinfer1 { -public: - ResizeLayerRT(int c, int h, int w) { - o_c = c; - o_h = h; - o_w = w; - } + class ResizeLayerRT : public IPluginV2 { - ResizeLayerRT(const void *data,size_t length){ - const char *buf = reinterpret_cast(data),*bufCheck = buf; - o_c = readBUF(buf); - o_h = readBUF(buf); - o_w = readBUF(buf); - i_c = readBUF(buf); - i_h = readBUF(buf); - i_w = readBUF(buf); - assert(buf == bufCheck + length); - } + public: + ResizeLayerRT(int c, int h, int w) ; - ~ResizeLayerRT(){ - } + ResizeLayerRT(const void *data, size_t length) ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + ~ResizeLayerRT() ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{o_c, o_h, o_w}; - } + int getNbOutputs() const NOEXCEPT override ; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { - i_c = inputDims[0].d[0]; - i_h = inputDims[0].d[1]; - i_w = inputDims[0].d[2]; - } - - int initialize() NOEXCEPT override {return 0;} - - virtual void terminate() NOEXCEPT override {} - - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} - - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { - // printf("%d %d %d %d %d %d\n", i_c, i_w, i_h, o_c, o_w, o_h); - resizeForward((dnnType*)reinterpret_cast(inputs[0]), - reinterpret_cast(outputs[0]), - batchSize, i_c, i_h, i_w, o_c, o_h, o_w, stream); - return 0; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 6*sizeof(int); - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override ; - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer),*a=buf; + int initialize() NOEXCEPT override ; - tk::dnn::writeBUF(buf, o_c); - tk::dnn::writeBUF(buf, o_h); - tk::dnn::writeBUF(buf, o_w); + void terminate() NOEXCEPT override ; - tk::dnn::writeBUF(buf, i_c); - tk::dnn::writeBUF(buf, i_h); - tk::dnn::writeBUF(buf, i_w); - assert(buf == a + getSerializationSize()); - } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - //todo assert - } + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override{ - return "ResizeLayerRT_tkDNN"; - } - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - void destroy() NOEXCEPT override{delete this;} + size_t getSerializationSize() const NOEXCEPT override ; - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + void serialize(void *buffer) const NOEXCEPT override ; - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - IPluginV2 *clone() const NOEXCEPT override{ - ResizeLayerRT *p = new ResizeLayerRT(o_c,o_h,o_w); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - int i_c, i_h, i_w, o_c, o_h, o_w; + const char *getPluginType() const NOEXCEPT override ; -private: - std::string mPluginNamespace; + const char *getPluginVersion() const NOEXCEPT override ; + + void destroy() NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + IPluginV2 *clone() const NOEXCEPT override ; + + int i_c, i_h, i_w, o_c, o_h, o_w; + + private: + std::string mPluginNamespace; + }; + + class ResizeLayerRTPluginCreator : public IPluginCreator { + public: + ResizeLayerRTPluginCreator() ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + + }; + + REGISTER_TENSORRT_PLUGIN(ResizeLayerRTPluginCreator); }; -class ResizeLayerRTPluginCreator : public IPluginCreator{ -public: - ResizeLayerRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ - ResizeLayerRT *pluginObj = new ResizeLayerRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - assert(fc->nbFields == 3); - assert(fields[0].type == PluginFieldType::kINT32); - assert(fields[1].type == PluginFieldType::kINT32); - assert(fields[2].type == PluginFieldType::kINT32); - int oc = *(static_cast(fields[0].data)); - int oh = *(static_cast(fields[1].data)); - int ow = *(static_cast(fields[2].data)); - ResizeLayerRT *pluginObj = new ResizeLayerRT(oc,oh,ow); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "ResizeLayerRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; - -}; - -REGISTER_TENSORRT_PLUGIN(ResizeLayerRTPluginCreator); - diff --git a/include/tkDNN/pluginsRT/RouteRT.h b/include/tkDNN/pluginsRT/RouteRT.h index 2ceede3..2b9bc67 100644 --- a/include/tkDNN/pluginsRT/RouteRT.h +++ b/include/tkDNN/pluginsRT/RouteRT.h @@ -1,181 +1,86 @@ #include #include "../kernels.h" +#include +#include -class RouteRT : public IPluginV2 { +namespace nvinfer1 { + class RouteRT : public IPluginV2 { - /** - THIS IS NOT USED ANYMORE - */ + /** + THIS IS NOT USED ANYMORE + */ -public: - RouteRT(int groups, int group_id) { - this->groups = groups; - this->group_id = group_id; - } + public: + RouteRT(int groups, int group_id) ; - ~RouteRT(){ + ~RouteRT() ; - } + RouteRT(const void *data, size_t length) ; - RouteRT(const void* data,size_t length){ - const char* buf = reinterpret_cast(data),*bufCheck = buf; - groups = readBUF(buf); - group_id = readBUF(buf); - in = readBUF(buf); - for(int i=0;i (buf); - } - c= readBUF(buf); - h = readBUF(buf); - w = readBUF(buf); - assert(buf == bufCheck + length); - } + int getNbOutputs() const NOEXCEPT override ; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - int out_c = 0; - for(int i=0; i(outputs[0]); - for(int b=0; b(inputs[i]); - int in_dim = c_in[i]*h*w; - int part_in_dim = in_dim / this->groups; - checkCuda( cudaMemcpyAsync(dstData + b*c*w*h + offset, input + b*c*w*h*groups + this->group_id*part_in_dim, part_in_dim*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream) ); - offset += part_in_dim; - } - } - return 0; - } + size_t getSerializationSize() const NOEXCEPT override ; - virtual size_t getSerializationSize() const NOEXCEPT override { - return (6+MAX_INPUTS)*sizeof(int); - } + void serialize(void *buffer) const NOEXCEPT override ; - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, groups); - tk::dnn::writeBUF(buf, group_id); - tk::dnn::writeBUF(buf, in); - for(int i=0; isetPluginNamespace(mPluginNamespace.c_str()); - return p; - } - static const int MAX_INPUTS = 4; - int in; - int c_in[MAX_INPUTS]; - int c, h, w; - int groups, group_id; -private: - std::string mPluginNamespace; + class RouteRTPluginCreator : public IPluginCreator { + public: + RouteRTPluginCreator() ; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; + + const char *getPluginNamespace() const NOEXCEPT override ; + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + + const char *getPluginName() const NOEXCEPT override ; + + const char *getPluginVersion() const NOEXCEPT override ; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(RouteRTPluginCreator); }; - -class RouteRTPluginCreator : public IPluginCreator{ -public: - RouteRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("groups",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("group_id",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ - RouteRT *pluginObj = new RouteRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - assert(fc->nbFields == 2); - assert(fields[0].type == PluginFieldType::kINT32); - assert(fields[1].type == PluginFieldType::kINT32); - int groups = *(static_cast(fields[0].data)); - int group_id = *(static_cast(fields[1].data)); - RouteRT *pluginObj = new RouteRT(groups,group_id); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "RouteRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(RouteRTPluginCreator); diff --git a/include/tkDNN/pluginsRT/ShortcutRT.h b/include/tkDNN/pluginsRT/ShortcutRT.h index 9f3d343..7069180 100644 --- a/include/tkDNN/pluginsRT/ShortcutRT.h +++ b/include/tkDNN/pluginsRT/ShortcutRT.h @@ -1,166 +1,94 @@ +#ifndef _SHORTCUTRT_PLUGIN_H +#define _SHORTCUTRT_PLUGIN_H + #include #include "../kernels.h" +#include +#include +#include -class ShortcutRT : public IPluginV2 { +namespace nvinfer1 { -public: - ShortcutRT(tk::dnn::dataDim_t bdim, bool mul) { - bDim = bdim; - this->bc = bDim.c; - this->bh = bDim.h; - this->bw = bDim.w; - this->mul = mul; - } + class ShortcutRT : public IPluginV2 { - ~ShortcutRT(){} + public: + ShortcutRT(tk::dnn::dataDim_t bdim, bool mul); - ShortcutRT(const void* data,size_t length){ - const char* buf =reinterpret_cast(data),*bufCheck = buf; - bDim.c = readBUF(buf); - bDim.h = readBUF(buf); - bDim.w = readBUF(buf); - bDim.l = 1; - mul = readBUF(buf); - c = readBUF(buf); - h = readBUF(buf); - w = readBUF(buf); - assert(buf == bufCheck + length); - } + ~ShortcutRT(); - int getNbOutputs() const NOEXCEPT override {return 1;} + ShortcutRT(const void *data, size_t length); - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3{inputs[0].d[0], inputs[0].d[1], inputs[0].d[2]}; - } + int getNbOutputs() const NOEXCEPT override; - void configureWithFormat(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - int initialize() NOEXCEPT override {return 0;} + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override; - virtual void terminate() NOEXCEPT override {} + int initialize() NOEXCEPT override; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} + void terminate() NOEXCEPT override; - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *srcDataBack = (dnnType*)reinterpret_cast(inputs[1]); - dnnType *dstData = reinterpret_cast(outputs[0]); - - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); - shortcutForward(srcDataBack, dstData, batchSize, c, h, w, 1, batchSize, bc, bh, bw, 1, mul, stream); - - return 0; - } + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 6*sizeof(int) + sizeof(bool); - } + size_t getSerializationSize() const NOEXCEPT override; - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, bc); - tk::dnn::writeBUF(buf, bh); - tk::dnn::writeBUF(buf, bw); - tk::dnn::writeBUF(buf, mul); - tk::dnn::writeBUF(buf, c); - tk::dnn::writeBUF(buf, h); - tk::dnn::writeBUF(buf, w); - assert(buf == a + getSerializationSize()); - - } + void serialize(void *buffer) const NOEXCEPT override; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - return true; - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; - const char* getPluginType() const NOEXCEPT override{ - return "1"; - } + const char *getPluginType() const NOEXCEPT override; - const char* getPluginVersion() const NOEXCEPT override{ - return "ShortcutRT_tkDNN"; - } + const char *getPluginVersion() const NOEXCEPT override; - void destroy() NOEXCEPT override{delete this;} + void destroy() NOEXCEPT override; - const char* getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } + const char *getPluginNamespace() const NOEXCEPT override; - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - IPluginV2 *clone() const NOEXCEPT override{ - ShortcutRT *p = new ShortcutRT(bDim,mul); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } + IPluginV2 *clone() const NOEXCEPT override; + + int c, h, w; + int bc, bh, bw; + bool mul; + tk::dnn::dataDim_t bDim; + private: + std::string mPluginNamespace; + }; + + + class ShortcutRTPluginCreator : public IPluginCreator { + public: + ShortcutRTPluginCreator(); + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + + const char *getPluginName() const NOEXCEPT override; + + const char *getPluginVersion() const NOEXCEPT override; + + const PluginFieldCollection *getFieldNames() NOEXCEPT override; + + public: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + + REGISTER_TENSORRT_PLUGIN(ShortcutRTPluginCreator); - int c, h, w; - int bc, bh, bw; - bool mul; - tk::dnn::dataDim_t bDim; -private: - std::string mPluginNamespace; }; - -class ShortcutRTPluginCreator : public IPluginCreator { -public: - ShortcutRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("bDim",nullptr,PluginFieldType::kUNKNOWN,1)); - mPluginAttributes.emplace_back(PluginField("mul",nullptr,PluginFieldType::kUNKNOWN,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ - ShortcutRT *pluginObj = new ShortcutRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char *name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - //todo assert - tk::dnn::dataDim_t bdim = *(static_cast(fields[0].data)); - bool mul = *(static_cast(fields[1].data)); - ShortcutRT *pluginObj = new ShortcutRT(bdim,mul); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "ShortcutRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } -public: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(ShortcutRTPluginCreator); \ No newline at end of file +#endif \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/UpsampleRT.h b/include/tkDNN/pluginsRT/UpsampleRT.h index 9d7a62c..030fe5a 100644 --- a/include/tkDNN/pluginsRT/UpsampleRT.h +++ b/include/tkDNN/pluginsRT/UpsampleRT.h @@ -1,150 +1,87 @@ +#ifndef _UPSAMPLERT_PLUGIN_H +#define _UPSAMPLERT_PLUGIN_H + #include #include "../kernels.h" +#include +#include + +namespace nvinfer1 { + + class UpsampleRT : public IPluginV2 { + + public: + explicit UpsampleRT(int stride); + + UpsampleRT(const void *data, size_t length); + + ~UpsampleRT(); + + int getNbOutputs() const NOEXCEPT override; + + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; + + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override; + + int initialize() NOEXCEPT override; + + void terminate() NOEXCEPT override; + + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; + + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; -class UpsampleRT : public IPluginV2 { + size_t getSerializationSize() const NOEXCEPT override; -public: - UpsampleRT(int stride) { - this->stride = stride; - } + void serialize(void *buffer) const NOEXCEPT override; - UpsampleRT(const void *data,size_t length){ - const char* buf = reinterpret_cast(data),*bufCheck=buf; - stride = readBUF(buf); - c = readBUF(buf); - h = readBUF(buf); - w = readBUF(buf); - assert(buf == bufCheck + length); - } + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; + const char *getPluginType() const NOEXCEPT override; - ~UpsampleRT(){} + const char *getPluginVersion() const NOEXCEPT override; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + void destroy() NOEXCEPT override; - Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) NOEXCEPT override { - return Dims3(inputs[0].d[0], inputs[0].d[1]*stride, inputs[0].d[2]*stride); - } + const char *getPluginNamespace() const NOEXCEPT override; - void configureWithFormat (const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,DataType type,PluginFormat format,int maxBatchSize) NOEXCEPT override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - int initialize() NOEXCEPT override {return 0;} + IPluginV2 *clone() const NOEXCEPT override ; - virtual void terminate() NOEXCEPT override {} + int c, h, w, stride; + private: + std::string mPluginNamespace; + }; - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { return 0;} + class UpsampleRTPluginCreator : public IPluginCreator { + public: + UpsampleRTPluginCreator(); - virtual int enqueue(int batchSize, const void*const * inputs, void* const* outputs, void* workspace, cudaStream_t stream) NOEXCEPT override { + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); - - fill(dstData, batchSize*c*h*w*stride*stride, 0.0, stream); - upsampleForward(srcData, dstData, batchSize, c, h, w, stride, 1, 1, stream); - return 0; - } + const char *getPluginNamespace() const NOEXCEPT override; + IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - virtual size_t getSerializationSize() const NOEXCEPT override { return 4*sizeof(int);} + IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; - virtual void serialize(void* buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer),*a=buf; - tk::dnn::writeBUF(buf, stride); - tk::dnn::writeBUF(buf, c); - tk::dnn::writeBUF(buf, h); - tk::dnn::writeBUF(buf, w); - assert(buf == a + getSerializationSize()); - } + const char *getPluginName() const NOEXCEPT override; - bool supportsFormat(DataType type,PluginFormat format) const NOEXCEPT override{ - //todo assert - return true; - } + const char *getPluginVersion() const NOEXCEPT override; - const char *getPluginType() const NOEXCEPT override{ - return "1"; - } + const PluginFieldCollection *getFieldNames() NOEXCEPT override; - const char *getPluginVersion() const NOEXCEPT override{ - static const char* UPSAMPLE_RT_PLUGIN = "UpsampleRT_TRT"; - return UPSAMPLE_RT_PLUGIN; - } + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; - void destroy() NOEXCEPT override{delete this;} - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - IPluginV2* clone() const NOEXCEPT override{ - UpsampleRT *p = new UpsampleRT(stride); - p->setPluginNamespace(mPluginNamespace.c_str()); - return p; - } - - int c, h, w, stride; -private: - std::string mPluginNamespace; -}; - -class UpsampleRTPluginCreator : public IPluginCreator{ -public: - UpsampleRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char* pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char* name,const void* serialData,size_t serialLength) NOEXCEPT override{ - UpsampleRT *pluginObj = new UpsampleRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - int stride = *(static_cast(fields[0].data)); - UpsampleRT *pluginObj = new UpsampleRT(stride); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - static const char* UPSAMPLE_RT_PLUGIN = "UpsampleRT_TRT"; - return UPSAMPLE_RT_PLUGIN; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(UpsampleRTPluginCreator); + REGISTER_TENSORRT_PLUGIN(UpsampleRTPluginCreator); + }; +#endif \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index 7ae7b35..0d895e0 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -1,282 +1,109 @@ +#ifndef _YOLORT_PLUGIN_H +#define _YOLORT_PLUGIN_H + #include #include #include "../kernels.h" +#include +#include + #define YOLORT_CLASSNAME_W 256 +namespace nvinfer1 { + class YoloRT : public IPluginV2 { -class YoloRT : public IPluginV2 { + public: + YoloRT(int classes, int num, tk::dnn::Yolo *Yolo = nullptr, int n_masks = 3, float scale_xy = 1, + float nms_thresh = 0.45, int nms_kind = 0, int new_coords = 0); -public: - YoloRT(int classes, int num, tk::dnn::Yolo *Yolo = nullptr, int n_masks = 3, float scale_xy = 1, - float nms_thresh = 0.45, int nms_kind = 0, int new_coords = 0) { - this->yolo = Yolo; - this->classes = classes; - this->num = num; - this->n_masks = n_masks; - this->scaleXY = scale_xy; - this->nms_thresh = nms_thresh; - this->nms_kind = nms_kind; - this->new_coords = new_coords; + YoloRT(const void *data, size_t length); - mask = new dnnType[n_masks]; - bias = new dnnType[num * n_masks * 2]; - if (yolo != nullptr) { - memcpy(mask, yolo->mask_h, sizeof(dnnType) * n_masks); - memcpy(bias, yolo->bias_h, sizeof(dnnType) * num * n_masks * 2); - classesNames = yolo->classesNames; - } - } - - YoloRT(const void *data,size_t length){ - std::vector maskTemp,biasTemp; - std::cout<<"LENGTH : "<(data),*bufCheck = buf; - classes = readBUF(buf); - num = readBUF(buf); - n_masks = readBUF(buf); - scaleXY = readBUF(buf); - nms_thresh = readBUF(buf); - nms_kind = readBUF(buf); - new_coords = readBUF(buf); - c = readBUF(buf); - h = readBUF(buf); - w = readBUF(buf); - for(int i=0;i(buf)); - std::cout<(buf)); - std::cout<(buf); - classesNames[1] = std::string(tmp); - } - assert(buf == bufCheck + length); - - } - - ~YoloRT() { - - } + ~YoloRT(); + int getNbOutputs() const NOEXCEPT override; - int getNbOutputs() const NOEXCEPT override { - return 1; - } + Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override { - return inputs[0]; - } + void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT override; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; - } + int initialize() NOEXCEPT override; - int initialize() NOEXCEPT override { + void terminate() NOEXCEPT override; - return 0; - } + size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; - virtual void terminate() NOEXCEPT override { - } - - virtual size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override { - return 0; - } - - virtual int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, - cudaStream_t stream) NOEXCEPT override { - - dnnType *srcData = (dnnType *) reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); - - checkCuda(cudaMemcpyAsync(dstData, srcData, batchSize * c * h * w * sizeof(dnnType), cudaMemcpyDeviceToDevice, - stream)); + int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT override; - for (int b = 0; b < batchSize; ++b) { - for (int n = 0; n < n_masks; ++n) { - int index = entry_index(b, n * w * h, 0); - if (new_coords == 1) { - if (this->scaleXY != 1) - scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); - } else { - activationLOGISTICForward(srcData + index, dstData + index, 2 * w * h, stream); //x,y + size_t getSerializationSize() const NOEXCEPT override; - if (this->scaleXY != 1) - scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); + bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override; - index = entry_index(b, n * w * h, 4); - activationLOGISTICForward(srcData + index, dstData + index, (1 + classes) * w * h, stream); - } - } + void serialize(void *buffer) const NOEXCEPT override; + + const char *getPluginType() const NOEXCEPT override; + + const char *getPluginVersion() const NOEXCEPT override; + + void destroy() NOEXCEPT override; + + const char *getPluginNamespace() const NOEXCEPT override; + + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; + + IPluginV2 *clone() const NOEXCEPT override; + + tk::dnn::Yolo *yolo; + int c, h, w; + int classes, num, n_masks; + float scaleXY; + float nms_thresh; + int nms_kind; + int new_coords; + int NUM = 0; + std::vector classesNames; + + dnnType *mask; + dnnType *bias; + + int entry_index(int batch, int location, int entry) { + int n = location / (w * h); + int loc = location % (w * h); + return batch * c * h * w + n * w * h * (4 + classes + 1) + entry * w * h + loc; } - //std::cout<<"YOLO END\n"; - return 0; - } + private: + std::string mPluginNamespace; + }; - virtual size_t getSerializationSize() const NOEXCEPT override { - return 8 * sizeof(int) + 2 * sizeof(float) + n_masks * sizeof(dnnType) + num * n_masks * 2 * sizeof(dnnType) + - YOLORT_CLASSNAME_W * classes * sizeof(char); - } + class YoloRTPluginCreator : public IPluginCreator { + public: + YoloRTPluginCreator(); - bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override { - return true; //todo implement proper supportsFormat - } + void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - virtual void serialize(void *buffer) const NOEXCEPT override { - char *buf = reinterpret_cast(buffer), *a = buf; - tk::dnn::writeBUF(buf, classes); //std::cout << "Classes :" << classes << std::endl; - tk::dnn::writeBUF(buf, num); //std::cout << "Num : " << num << std::endl; - std::cout<setPluginNamespace(mPluginNamespace.c_str()); - return p; - } - - Yolo *yolo; - int c, h, w; - int classes, num, n_masks; - float scaleXY; - float nms_thresh; - int nms_kind; - int new_coords; - int NUM=0; - std::vector classesNames; - - dnnType *mask; - dnnType *bias; - - int entry_index(int batch, int location, int entry) { - int n = location / (w * h); - int loc = location % (w * h); - return batch * c * h * w + n * w * h * (4 + classes + 1) + entry * w * h + loc; - } - -private: - std::string mPluginNamespace; + private: + static PluginFieldCollection mFC; + static std::vector mPluginAttributes; + std::string mPluginNamespace; + }; + REGISTER_TENSORRT_PLUGIN(YoloRTPluginCreator); }; - -class YoloRTPluginCreator : public IPluginCreator{ -public: - YoloRTPluginCreator(){ - mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("yolo",nullptr,PluginFieldType::kUNKNOWN,1)); - mPluginAttributes.emplace_back(PluginField("numMasks",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("scaleXY",nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("nmsThresh",nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("nmsKind",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("newCoords",nullptr,PluginFieldType::kINT32,1)); - mFC.nbFields = mPluginAttributes.size(); - mFC.fields = mPluginAttributes.data(); - } - - void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override{ - mPluginNamespace = pluginNamespace; - } - - const char *getPluginNamespace() const NOEXCEPT override{ - return mPluginNamespace.c_str(); - } - - IPluginV2 *deserializePlugin(const char *name,const void *serialData,size_t serialLength) NOEXCEPT override{ - YoloRT *pluginObj = new YoloRT(serialData,serialLength); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - IPluginV2 *createPlugin(const char* name,const PluginFieldCollection *fc) NOEXCEPT override{ - const PluginField *fields = fc->fields; - //todo assert - int classes = *(static_cast(fields[0].data)); - int num = *(static_cast(fields[1].data)); - Yolo *yoloTemp = const_cast(static_cast(fields[2].data)); - int numMasks = *(static_cast(fields[3].data)); - float scaleXY = *(static_cast(fields[4].data)); - float nmsThresh = *(static_cast(fields[5].data)); - int nmsKind = *(static_cast(fields[6].data)); - int newCoords = *(static_cast(fields[7].data)); - YoloRT *pluginObj = new YoloRT(classes,num,yoloTemp,numMasks,scaleXY,nmsThresh,nmsKind,newCoords); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); - return pluginObj; - } - - const char *getPluginName() const NOEXCEPT override{ - return "YoloRT_tkDNN"; - } - - const char *getPluginVersion() const NOEXCEPT override{ - return "1"; - } - - const PluginFieldCollection *getFieldNames() NOEXCEPT override{ - return &mFC; - } - -private: - PluginFieldCollection mFC; - std::vector mPluginAttributes; - std::string mPluginNamespace; -}; - -REGISTER_TENSORRT_PLUGIN(YoloRTPluginCreator); +#endif \ No newline at end of file diff --git a/include/tkDNN/utils.h b/include/tkDNN/utils.h index 017cf1d..1219ec3 100644 --- a/include/tkDNN/utils.h +++ b/include/tkDNN/utils.h @@ -34,6 +34,19 @@ #define dnnType float +template void writeBUF(char*& buffer, const T& val) +{ + *reinterpret_cast(buffer) = val; + buffer += sizeof(T); +} + +template T readBUF(const char*& buffer) +{ + T val = *reinterpret_cast(buffer); + buffer += sizeof(T); + return val; +} + // Colored output #define COL_END "\033[0m" diff --git a/src/DarknetParser.cpp b/src/DarknetParser.cpp index a370b91..3333afd 100644 --- a/src/DarknetParser.cpp +++ b/src/DarknetParser.cpp @@ -17,8 +17,8 @@ namespace tk { namespace dnn { if(sep == std::string::npos) return false; - name = line.substr(0, sep); - value = line.substr(sep+1, line.size() - (sep+1)); + name = line.substr(0, sep); + value = line.substr(sep+1, line.size() - (sep+1)); return true; } @@ -322,7 +322,7 @@ namespace tk { namespace dnn { // skip empty lines if(line.empty()) continue; - if(count > lineNo && count <=20){ + if(count > lineNo && count <=lineNo+30){ divideNameAndValue(line,name,value); if(name == "mask "){ maskTemp = fromStringToFloatVec(value,','); @@ -353,9 +353,8 @@ namespace tk { namespace dnn { if(name == "beta_nms"){ nmsThreshTemp = std::stof(value); } - - count++; } + count++; } mask = maskTemp; anchors = anchorsTemp; diff --git a/src/Yolo.cpp b/src/Yolo.cpp index deffbeb..35abb19 100644 --- a/src/Yolo.cpp +++ b/src/Yolo.cpp @@ -133,10 +133,11 @@ void correct_yolo_boxes(Yolo::detection *dets, int n, int w, int h, int netw, in } } -int Yolo::computeDetections(Yolo::detection *dets, int &ndets, int netw, int neth, float thresh, int new_coords) { +int Yolo::computeDetections(Yolo::detection *dets, int &ndets, int netw, int neth, float thresh, int newCoords) { if(predictions == nullptr) predictions = new dnnType[output_dim.tot()]; + checkCuda(cudaDeviceSynchronize()); checkCuda( cudaMemcpy(predictions, dstData, output_dim.tot()*sizeof(dnnType), cudaMemcpyDeviceToHost)); int lw = output_dim.w; @@ -157,7 +158,7 @@ int Yolo::computeDetections(Yolo::detection *dets, int &ndets, int netw, int net if(objectness <= thresh) continue; int box_index = entry_index(0, n*lw*lh + i, 0, classes, input_dim, output_dim); - dets[count].bbox = get_yolo_box(predictions, bias_h, mask_h[n], box_index, col, row, lw, lh, netw, neth, lw*lh, new_coords); + dets[count].bbox = get_yolo_box(predictions, bias_h, mask_h[n], box_index, col, row, lw, lh, netw, neth, lw*lh, newCoords); dets[count].objectness = objectness; dets[count].classes = classes; for(j = 0; j < classes; ++j){ diff --git a/src/pluginsRT/ActivationLeakyRT.cpp b/src/pluginsRT/ActivationLeakyRT.cpp new file mode 100644 index 0000000..77063f6 --- /dev/null +++ b/src/pluginsRT/ActivationLeakyRT.cpp @@ -0,0 +1,138 @@ +#include +using namespace nvinfer1; + + +std::vector ActivationLeakyRTPluginCreator::mPluginAttributes; +PluginFieldCollection ActivationLeakyRTPluginCreator::mFC{}; + +ActivationLeakyRT::ActivationLeakyRT(float s) { + slope = s; +} + +ActivationLeakyRT::ActivationLeakyRT(const void *data, size_t length) { + std::cout << "DESERIALIZE LEAKYRT" << std::endl; + const char *buf = reinterpret_cast(data), *bufCheck = buf; + slope = readBUF(buf); + size = readBUF(buf); + assert(buf == bufCheck + length); +} + +ActivationLeakyRT::~ActivationLeakyRT() {} + +int ActivationLeakyRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ActivationLeakyRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return inputs[0]; +} + +void ActivationLeakyRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, + DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + assert(type == DataType::kFLOAT && format == PluginFormat::kLINEAR); + size = 1; + for (int i = 0; i < outputDims[0].nbDims; i++) + size *= outputDims[0].d[i]; +} +int ActivationLeakyRT::initialize() NOEXCEPT { + return 0; +} + +size_t ActivationLeakyRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +int ActivationLeakyRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + activationLEAKYForward( + (dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, slope, + stream); + return 0; + +} + +size_t ActivationLeakyRT::getSerializationSize() const NOEXCEPT { + return 1 * sizeof(int) + 1 * sizeof(float); +} + +void ActivationLeakyRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer), *a = buf; + writeBUF(buf, size); + assert(buf == a + getSerializationSize()); +} + +bool ActivationLeakyRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +const char *ActivationLeakyRT::getPluginType() const NOEXCEPT { + return "ActivationLeakyRT_tkDNN"; +} + +const char *ActivationLeakyRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +void ActivationLeakyRT::destroy() NOEXCEPT { + delete this; +} + +const char *ActivationLeakyRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); + +} + +void ActivationLeakyRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2* ActivationLeakyRT::clone() const NOEXCEPT { + auto *p = new ActivationLeakyRT(slope); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +ActivationLeakyRTPluginCreator::ActivationLeakyRTPluginCreator() { + mPluginAttributes.emplace_back( + PluginField("slope", nullptr, PluginFieldType::kFLOAT32, 1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ActivationLeakyRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2* ActivationLeakyRTPluginCreator::deserializePlugin(const char *name, const void *serialData,size_t serialLength) NOEXCEPT { + auto *pluginObj = new ActivationLeakyRT(serialData, serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char* ActivationLeakyRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2* ActivationLeakyRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 1); + assert(fields[0].type == PluginFieldType::kFLOAT32); + float slope = *(static_cast(fields[0].data)); + auto *pluginObj = new ActivationLeakyRT(slope); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char* ActivationLeakyRTPluginCreator::getPluginName() const NOEXCEPT { + return "ActivationLeakyRT_tkDNN"; +} + +const char* ActivationLeakyRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection* ActivationLeakyRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + diff --git a/src/pluginsRT/ActivationLogisticRT.cpp b/src/pluginsRT/ActivationLogisticRT.cpp new file mode 100644 index 0000000..9966708 --- /dev/null +++ b/src/pluginsRT/ActivationLogisticRT.cpp @@ -0,0 +1,126 @@ +#include +using namespace nvinfer1; +std::vector ActivationLogisticRTPluginCreator::mPluginAttributes; +PluginFieldCollection ActivationLogisticRTPluginCreator::mFC{}; + +ActivationLogisticRT::ActivationLogisticRT() {} + +ActivationLogisticRT::ActivationLogisticRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data), *bufCheck = buf; + size = readBUF(buf); + assert(buf == bufCheck + length); +} + +ActivationLogisticRT::~ActivationLogisticRT() {} + +int ActivationLogisticRT::getNbOutputs() const NOEXCEPT { +return 1; +} + +Dims ActivationLogisticRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return inputs[0]; +} + +void ActivationLogisticRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, + int nbOutputs, DataType type, PluginFormat format, + int maxBatchSize) NOEXCEPT { + size = 1; + for (int i = 0; i < outputDims[0].nbDims; i++) + size *= outputDims[0].d[i]; +} + +int ActivationLogisticRT::initialize() NOEXCEPT { + return 0; +} + +void ActivationLogisticRT::terminate() NOEXCEPT {} + +size_t ActivationLogisticRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +int ActivationLogisticRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + activationLOGISTICForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, stream); + return 0; +} + +size_t ActivationLogisticRT::getSerializationSize() const NOEXCEPT { + return 1 * sizeof(int); +} + +void ActivationLogisticRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer); + writeBUF(buf, size); +} + +const char* ActivationLogisticRT::getPluginType() const NOEXCEPT { + return "ActivationLogisticRT_tkDNN"; +} + +const char* ActivationLogisticRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +void ActivationLogisticRT::destroy() NOEXCEPT { + delete this; +} + +const char* ActivationLogisticRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ActivationLogisticRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +bool ActivationLogisticRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; + //todo assert +} + +IPluginV2* ActivationLogisticRT::clone() const NOEXCEPT { + auto *p = new ActivationLogisticRT(); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +ActivationLogisticRTPluginCreator::ActivationLogisticRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ActivationLogisticRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2* ActivationLogisticRTPluginCreator::deserializePlugin(const char *name, const void *serialData, + size_t serialLength) NOEXCEPT { + auto *pluginObj = new ActivationLogisticRT(serialData, serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char* ActivationLogisticRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2* ActivationLogisticRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + auto *pluginObj = new ActivationLogisticRT(); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char* ActivationLogisticRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection* ActivationLogisticRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + +const char *ActivationLogisticRTPluginCreator::getPluginName() const NOEXCEPT { + return "ActivationLogisticRT_tkDNN"; +} \ No newline at end of file diff --git a/src/pluginsRT/ActivationMishRT.cpp b/src/pluginsRT/ActivationMishRT.cpp new file mode 100644 index 0000000..7797df9 --- /dev/null +++ b/src/pluginsRT/ActivationMishRT.cpp @@ -0,0 +1,121 @@ +// +// Created by perseusdg on 9/4/21. +// +#include +using namespace nvinfer1; +std::vector ActivationMishRTPluginCreator::mPluginAttributes; +PluginFieldCollection ActivationMishRTPluginCreator::mFC{}; + +ActivationMishRT::ActivationMishRT() { + +} + +ActivationMishRT::~ActivationMishRT() { + +} + +ActivationMishRT::ActivationMishRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data), *bufCheck = buf; + size = readBUF(buf); + assert(buf == bufCheck + length); +} + +int ActivationMishRT::getNbOutputs() const NOEXCEPT { return 1; } + +Dims ActivationMishRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { return inputs[0]; } + +void ActivationMishRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT { +assert(format == PluginFormat::kLINEAR); +size = 1; +for (int i = 0; i < outputDims[0].nbDims; i++) +size *= outputDims[0].d[i]; +} + +int ActivationMishRT::initialize() NOEXCEPT { return 0; } + +void ActivationMishRT::terminate() NOEXCEPT {} + +size_t ActivationMishRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } + +int ActivationMishRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + activationMishForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, stream); + return 0; +} +size_t ActivationMishRT::getSerializationSize() const NOEXCEPT { + return 1 * sizeof(int); +} + +void ActivationMishRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer), *a = buf; + writeBUF(buf, size); + assert(buf == a + getSerializationSize()); +} + +const char* ActivationMishRT::getPluginType() const NOEXCEPT { + return "ActivationMishRT_tkDNN"; +} + +const char *ActivationMishRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +bool ActivationMishRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; +} + +const char *ActivationMishRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ActivationMishRT::setPluginNamespace(const char *plguinNamespace) NOEXCEPT { + mPluginNamespace = plguinNamespace; +} + +IPluginV2 *ActivationMishRT::clone() const NOEXCEPT { + auto *p = new ActivationMishRT(); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +ActivationMishRTPluginCreator::ActivationMishRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ActivationMishRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ActivationMishRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *ActivationMishRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new ActivationMishRT(serialData, serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *ActivationMishRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + auto *pluginObj = new ActivationMishRT(); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ActivationMishRTPluginCreator::getPluginName() const NOEXCEPT { + return "ActivationMishRT_tkDNN"; +} + +const char *ActivationMishRTPluginCreator::getPluginVersion() const NOEXCEPT{ + return "1"; +} + +const PluginFieldCollection *ActivationMishRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + diff --git a/src/pluginsRT/ActivationReLUCeilingRT.cpp b/src/pluginsRT/ActivationReLUCeilingRT.cpp new file mode 100644 index 0000000..80b5a74 --- /dev/null +++ b/src/pluginsRT/ActivationReLUCeilingRT.cpp @@ -0,0 +1,129 @@ +#include +using namespace nvinfer1; + +std::vector ActivationReLUCeilingPluginCreator::mPluginAttributes; +PluginFieldCollection ActivationReLUCeilingPluginCreator::mFC{}; + +ActivationReLUCeiling::ActivationReLUCeiling(const float ceiling) { + this->ceiling = ceiling; +} + +ActivationReLUCeiling::~ActivationReLUCeiling() { + +} + +ActivationReLUCeiling::ActivationReLUCeiling(const void *data, size_t length) { + const char *buf = reinterpret_cast(data), *bufCheck = buf; + ceiling = readBUF(buf); + size = readBUF(buf); + assert(buf == bufCheck + length); +} + +int ActivationReLUCeiling::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ActivationReLUCeiling::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { return inputs[0]; } + +void ActivationReLUCeiling::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + assert(type == DataType::kFLOAT && format == PluginFormat::kLINEAR); + size = 1; + for (int i = 0; i < outputDims[0].nbDims; i++) + size *= outputDims[0].d[i]; +} + +int ActivationReLUCeiling::initialize() NOEXCEPT { return 0; } + +void ActivationReLUCeiling::terminate() NOEXCEPT {} + +size_t ActivationReLUCeiling::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +int ActivationReLUCeiling::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT { + activationReLUCeilingForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, ceiling, stream); + return 0; +} + +size_t ActivationReLUCeiling::getSerializationSize() const NOEXCEPT { + return 1 * sizeof(int) + 1 * sizeof(float); +} + +void ActivationReLUCeiling::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer), *a = buf; + writeBUF(buf, ceiling); + writeBUF(buf, size); + assert(buf = a + getSerializationSize()); +} + +IPluginV2 *ActivationReLUCeiling::clone() const NOEXCEPT { + auto *p = new ActivationReLUCeiling(ceiling); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + +bool ActivationReLUCeiling::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); +} + +void ActivationReLUCeiling::destroy() NOEXCEPT { delete this; } + +const char *ActivationReLUCeiling::getPluginType() const NOEXCEPT { + return "ActivationReLUCeilingRT_tkDNN"; +} + +const char *ActivationReLUCeiling::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const char *ActivationReLUCeiling::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ActivationReLUCeiling::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +ActivationReLUCeilingPluginCreator::ActivationReLUCeilingPluginCreator() { + mPluginAttributes.emplace_back(PluginField("ceiling", nullptr, PluginFieldType::kFLOAT32, 1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ActivationReLUCeilingPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ActivationReLUCeilingPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *ActivationReLUCeilingPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new ActivationReLUCeiling(serialData, serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *ActivationReLUCeilingPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + float ceiling = *(static_cast(fields[0].data)); + auto *pluginObj = new ActivationReLUCeiling(ceiling); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ActivationReLUCeilingPluginCreator::getPluginName() const NOEXCEPT { + return "ActivationReLUCeilingRT_tkDNN"; +} + +const char *ActivationReLUCeilingPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *ActivationReLUCeilingPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + diff --git a/src/pluginsRT/DeformableConvRT.cpp b/src/pluginsRT/DeformableConvRT.cpp new file mode 100644 index 0000000..417af8e --- /dev/null +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -0,0 +1,331 @@ +#include +using namespace nvinfer1; +using namespace tk::dnn; + +std::vector DeformableConvRTPluginCreator::mPluginAttributes; +PluginFieldCollection DeformableConvRTPluginCreator::mFC{}; + + +DeformableConvRT::DeformableConvRT(int chunk_dim, int kh, int kw, int sh, int sw, int ph, int pw, int deformableGroup, + int i_n, int i_c, int i_h, int i_w, int o_n, int o_c, int o_h, int o_w, + tk::dnn::DeformConv2d *deformable) { + this->chunk_dim = chunk_dim; + this->kh = kh; + this->kw = kw; + this->sh = sh; + this->sw = sw; + this->ph = ph; + this->pw = pw; + this->deformableGroup = deformableGroup; + this->i_n = i_n; + this->i_c = i_c; + this->i_h = i_h; + this->i_w = i_w; + this->o_n = o_n; + this->o_c = o_c; + this->o_h = o_h; + this->o_w = o_w; + this->defRT = deformable; + + height_ones = (i_h + 2 * ph - (1 * (kh - 1) + 1)) / sh + 1; + width_ones = (i_w + 2 * pw - (1 * (kw - 1) + 1)) / sw + 1; + dim_ones = i_c * kh * kw * 1 * height_ones * width_ones; + + checkCuda( cudaMalloc(&data_d, i_c * o_c * kh * kw * 1 * sizeof(dnnType))); + checkCuda( cudaMalloc(&bias2_d, o_c*sizeof(dnnType))); + checkCuda( cudaMalloc(&ones_d1, height_ones * width_ones * sizeof(dnnType))); + checkCuda( cudaMalloc(&offset, 2*chunk_dim*sizeof(dnnType))); + checkCuda( cudaMalloc(&mask, chunk_dim*sizeof(dnnType))); + checkCuda( cudaMalloc(&ones_d2, dim_ones*sizeof(dnnType))); + if(deformable != nullptr) { + checkCuda( cudaMemcpy(data_d, deformable->data_d, sizeof(dnnType)*i_c * o_c * kh * kw * 1, cudaMemcpyDeviceToDevice) ); + checkCuda( cudaMemcpy(bias2_d, deformable->bias2_d, sizeof(dnnType)*o_c, cudaMemcpyDeviceToDevice) ); + checkCuda( cudaMemcpy(ones_d1, deformable->ones_d1, sizeof(dnnType)*height_ones*width_ones, cudaMemcpyDeviceToDevice) ); + checkCuda( cudaMemcpy(offset, deformable->offset, sizeof(dnnType)*2*chunk_dim, cudaMemcpyDeviceToDevice) ); + checkCuda( cudaMemcpy(mask, deformable->mask, sizeof(dnnType)*chunk_dim, cudaMemcpyDeviceToDevice) ); + checkCuda( cudaMemcpy(ones_d2, deformable->ones_d2, sizeof(dnnType)*dim_ones, cudaMemcpyDeviceToDevice) ); + } + stat = cublasCreate(&handle); + if (stat != CUBLAS_STATUS_SUCCESS) + FatalError("CUBLAS initialization failed\n"); + +} + +DeformableConvRT::~DeformableConvRT() { + checkCuda( cudaFree(data_d) ); + checkCuda( cudaFree(bias2_d) ); + checkCuda( cudaFree(ones_d1) ); + checkCuda( cudaFree(offset) ); + checkCuda( cudaFree(mask) ); + checkCuda( cudaFree(ones_d2) ); + cublasDestroy(handle); +} + +DeformableConvRT::DeformableConvRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufCheck = buf; + chunk_dim = readBUF(buf); + kh = readBUF(buf); + kw = readBUF(buf); + sh = readBUF(buf); + sw = readBUF(buf); + ph = readBUF(buf); + pw = readBUF(buf); + deformableGroup = readBUF(buf); + i_n = readBUF(buf); + i_c = readBUF(buf); + i_h = readBUF(buf); + i_w = readBUF(buf); + o_n = readBUF(buf); + o_c = readBUF(buf); + o_h = readBUF(buf); + o_w = readBUF(buf); + dnnType *aus = new dnnType[chunk_dim*2]; + for(int i=0;i(buf); + checkCuda(cudaMemcpy(offset,aus,sizeof(dnnType)*2*chunk_dim,cudaMemcpyHostToDevice)); + free(aus); + + aus = new dnnType[chunk_dim]; + for(int i=0;i(buf); + checkCuda(cudaMemcpy(mask,aus,sizeof(dnnType)*chunk_dim,cudaMemcpyHostToDevice)); + free(aus); + + aus = new dnnType[i_c*o_c*kh*kw*1]; + for(int i=0;i<(i_c*o_c*kh*kw*1);i++) + aus[i] = readBUF(buf); + checkCuda(cudaMemcpy(data_d,aus,sizeof(dnnType)*(i_c*o_c*kh*kw*1),cudaMemcpyHostToDevice)); + free(aus); + + aus = new dnnType[o_c]; + for(int i=0; i < o_c; i++) + aus[i] = readBUF(buf); + checkCuda( cudaMemcpy(bias2_d, aus, sizeof(dnnType)*o_c, cudaMemcpyHostToDevice) ); + free(aus); + + aus = new dnnType[height_ones * width_ones]; + for(int i=0; i(buf); + checkCuda( cudaMemcpy(ones_d1, aus, sizeof(dnnType)*height_ones * width_ones, cudaMemcpyHostToDevice) ); + free(aus); + + aus = new dnnType[dim_ones]; + for(int i=0; i(buf); + checkCuda( cudaMemcpy(ones_d2, aus, sizeof(dnnType)*dim_ones, cudaMemcpyHostToDevice) ); + free(aus); + + assert(buf == bufCheck + length); + +} + +int DeformableConvRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims DeformableConvRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{defRT->output_dim.c, defRT->output_dim.h, defRT->output_dim.w}; +} + +void DeformableConvRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT {} + +int DeformableConvRT::initialize() NOEXCEPT { + return 0; +} + +void DeformableConvRT::terminate() NOEXCEPT {} + +size_t DeformableConvRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT {return 0;} + +int DeformableConvRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *output_conv = (dnnType*)reinterpret_cast(inputs[1]); + + // split conv2d outputs into offset to mask + for(int b=0; b(outputs[0]), ones_d2, + kh, kw, + sh, sw, + ph, pw, + 1, 1, + deformableGroup, b, + i_n, i_c, i_h, i_w, + o_n, o_c, o_h, o_w, + chunk_dim); + } + return 0; +} + +size_t DeformableConvRT::getSerializationSize() const NOEXCEPT { + return 16 * sizeof(int) + chunk_dim * 3 * sizeof(dnnType) + (i_c * o_c * kh * kw * 1 ) * sizeof(dnnType) + + o_c * sizeof(dnnType) + height_ones * width_ones * sizeof(dnnType) + dim_ones * sizeof(dnnType); +} + +void DeformableConvRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, chunk_dim); + writeBUF(buf, kh); + writeBUF(buf, kw); + writeBUF(buf, sh); + writeBUF(buf, sw); + writeBUF(buf, ph); + writeBUF(buf, pw); + writeBUF(buf, deformableGroup); + writeBUF(buf, i_n); + writeBUF(buf, i_c); + writeBUF(buf, i_h); + writeBUF(buf, i_w); + writeBUF(buf, o_n); + writeBUF(buf, o_c); + writeBUF(buf, o_h); + writeBUF(buf, o_w); + dnnType *aus = new dnnType[chunk_dim*2]; + checkCuda( cudaMemcpy(aus, offset, sizeof(dnnType)*2*chunk_dim, cudaMemcpyDeviceToHost) ); + for(int i=0; isetPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +DeformableConvRTPluginCreator::DeformableConvRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("chunk_dim",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kh",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kw",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sh",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sw",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("ph",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("pw",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("deformableGroup",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_n",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_n",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("defRT",nullptr,PluginFieldType::kUNKNOWN,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void DeformableConvRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *DeformableConvRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *DeformableConvRTPluginCreator::deserializePlugin(const char *name, const void *serialData, + size_t serialLength) NOEXCEPT { + auto *pluginObj = new DeformableConvRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *DeformableConvRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + int chunk_dim = *(static_cast(fields[0].data)); + int kh = *(static_cast(fields[1].data)); + int kw = *(static_cast(fields[2].data)); + int sh = *(static_cast(fields[3].data)); + int sw = *(static_cast(fields[4].data)); + int ph = *(static_cast(fields[5].data)); + int pw = *(static_cast(fields[6].data)); + int deformableGroup = *(static_cast(fields[7].data)); + int i_n = *(static_cast(fields[8].data)); + int i_c = *(static_cast(fields[9].data)); + int i_h = *(static_cast(fields[10].data)); + int i_w = *(static_cast(fields[11].data)); + int o_n = *(static_cast(fields[12].data)); + int o_c = *(static_cast(fields[13].data)); + int o_h = *(static_cast(fields[14].data)); + int o_w = *(static_cast(fields[14].data)); + auto *defRT = const_cast(static_cast(fields[15].data)); + auto *pluginObj = new DeformableConvRT(chunk_dim,kh,kw,sh,sw,ph,pw,deformableGroup,i_n,i_c,i_h,i_w,o_n,o_c,o_h,o_w,defRT); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *DeformableConvRTPluginCreator::getPluginName() const NOEXCEPT { + return "DeformableConvRT_tkDNN"; +} + +const char *DeformableConvRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *DeformableConvRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + diff --git a/src/pluginsRT/FlattenConcatRT.cpp b/src/pluginsRT/FlattenConcatRT.cpp new file mode 100644 index 0000000..51cebc5 --- /dev/null +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -0,0 +1,163 @@ +#include +using namespace nvinfer1; + +std::vector FlattenConcatRTPluginCreator::mPluginAttributes; +PluginFieldCollection FlattenConcatRTPluginCreator::mFC{}; + +FlattenConcatRT::FlattenConcatRT() { + stat = cublasCreate(&handle); + if (stat != CUBLAS_STATUS_SUCCESS) { + printf ("CUBLAS initialization failed\n"); + return; + } +} + +FlattenConcatRT::FlattenConcatRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data),*bufCheck=buf; + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + rows = readBUF(buf); + cols = readBUF(buf); + assert(buf == bufCheck + length); +} + +FlattenConcatRT::~FlattenConcatRT() {} + +int FlattenConcatRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims FlattenConcatRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{ inputs[0].d[0] * inputs[0].d[1] * inputs[0].d[2], 1, 1}; +} + +void FlattenConcatRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, + DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + assert(nbOutputs == 1 && nbInputs ==1); + rows = inputDims[0].d[0]; + cols = inputDims[0].d[1] * inputDims[0].d[2]; + c = inputDims[0].d[0] * inputDims[0].d[1] * inputDims[0].d[2]; + h = 1; + w = 1; +} + +int FlattenConcatRT::initialize() NOEXCEPT { + return 0; +} + +void FlattenConcatRT::terminate() NOEXCEPT { + checkERROR(cublasDestroy(handle)); +} + +size_t FlattenConcatRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +int FlattenConcatRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*rows*cols*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + + checkERROR( cublasSetStream(handle, stream) ); + for(int i=0; i(buffer),*a = buf; + writeBUF(buf, c); + writeBUF(buf, h); + writeBUF(buf, w); + writeBUF(buf, rows); + writeBUF(buf, cols); + assert(buf == a + getSerializationSize()); +} + +void FlattenConcatRT::destroy() NOEXCEPT { + delete this; +} + +bool FlattenConcatRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; +} + +const char *FlattenConcatRT::getPluginType() const NOEXCEPT { + return "FlattenConcatRT_tkDNN"; +} + +const char *FlattenConcatRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const char *FlattenConcatRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void FlattenConcatRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2 *FlattenConcatRT::clone() const NOEXCEPT { + auto *p = new FlattenConcatRT(); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +FlattenConcatRTPluginCreator::FlattenConcatRTPluginCreator() { + mPluginAttributes.clear(); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void FlattenConcatRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *FlattenConcatRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *FlattenConcatRTPluginCreator::deserializePlugin(const char *name, const void *serialData, + size_t serialLength) NOEXCEPT { + auto *pluginObj = new FlattenConcatRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *FlattenConcatRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + auto *pluginObj = new FlattenConcatRT(); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *FlattenConcatRTPluginCreator::getPluginName() const NOEXCEPT { + return "FlattenConcatRT_tkDNN"; +} + +const char *FlattenConcatRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *FlattenConcatRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + diff --git a/src/pluginsRT/MaxPoolingSizeRT.cpp b/src/pluginsRT/MaxPoolingSizeRT.cpp new file mode 100644 index 0000000..4b95d7f --- /dev/null +++ b/src/pluginsRT/MaxPoolingSizeRT.cpp @@ -0,0 +1,179 @@ +#include +using namespace nvinfer1; + +std::vector MaxPoolFixedSizeRTPluginCreator::mPluginAttributes; +PluginFieldCollection MaxPoolFixedSizeRTPluginCreator::mFC{}; + +MaxPoolFixedSizeRT::MaxPoolFixedSizeRT(int c, int h, int w, int n, int strideH, int strideW, int winSize, int padding){ + this->c = c; + this->h = h; + this->w = w; + this->n = n; + this->stride_H = strideH; + this->stride_W = strideW; + this->winSize = winSize; + this->padding = padding; +} + +MaxPoolFixedSizeRT::MaxPoolFixedSizeRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data),*bufCheck = buf; + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + n = readBUF(buf); + stride_H = readBUF(buf); + stride_W = readBUF(buf); + winSize = readBUF(buf); + padding = readBUF(buf); + assert(buf == bufCheck + length); +} + +MaxPoolFixedSizeRT::~MaxPoolFixedSizeRT() { + +} + +int MaxPoolFixedSizeRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims MaxPoolFixedSizeRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{this->c, this->h, this->w}; +} + +void MaxPoolFixedSizeRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT {} + +int MaxPoolFixedSizeRT::initialize() NOEXCEPT { + return 0; +} + +void MaxPoolFixedSizeRT::terminate() NOEXCEPT { + +} + +size_t MaxPoolFixedSizeRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +int MaxPoolFixedSizeRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + MaxPoolingForward(srcData, dstData, batchSize, this->c, this->h, this->w, this->stride_H, this->stride_W, this->winSize, this->padding, stream); + return 0; +} + +size_t MaxPoolFixedSizeRT::getSerializationSize() const NOEXCEPT { + return 8*sizeof(int); +} + +void MaxPoolFixedSizeRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, this->c); + writeBUF(buf, this->h); + writeBUF(buf, this->w); + writeBUF(buf, this->n); + writeBUF(buf, this->stride_H); + writeBUF(buf, this->stride_W); + writeBUF(buf, this->winSize); + writeBUF(buf, this->padding); + assert(buf == a + getSerializationSize()); +} + +void MaxPoolFixedSizeRT::destroy() NOEXCEPT { +delete this; +} + +bool MaxPoolFixedSizeRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; + //todo assert +} + +const char *MaxPoolFixedSizeRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void MaxPoolFixedSizeRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *MaxPoolFixedSizeRT::getPluginType() const NOEXCEPT { + return "MaxPoolingFixedSizeRT_tkDNN"; +} + +const char *MaxPoolFixedSizeRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +IPluginV2 *MaxPoolFixedSizeRT::clone() const NOEXCEPT { + auto *p = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +MaxPoolFixedSizeRTPluginCreator::MaxPoolFixedSizeRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("stride_H",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("stride_W",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("winSize",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padding",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void MaxPoolFixedSizeRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *MaxPoolFixedSizeRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *MaxPoolFixedSizeRTPluginCreator::deserializePlugin(const char *name, const void *serialData,size_t serialLength) NOEXCEPT { + auto *pluginObj = new MaxPoolFixedSizeRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *MaxPoolFixedSizeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + //todo assert + int c = *(static_cast(fields[0].data)); + int h = *(static_cast(fields[1].data)); + int w = *(static_cast(fields[2].data)); + int n = *(static_cast(fields[3].data)); + int stride_H = *(static_cast(fields[4].data)); + int stride_W = *(static_cast(fields[5].data)); + int winSize = *(static_cast(fields[6].data)); + int padding = *(static_cast(fields[7].data)); + auto *pluginObj = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *MaxPoolFixedSizeRTPluginCreator::getPluginName() const NOEXCEPT { + return "MaxPoolingFixedSizeRT_tkDNN"; +} + +const char *MaxPoolFixedSizeRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *MaxPoolFixedSizeRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + diff --git a/src/pluginsRT/RegionRT.cpp b/src/pluginsRT/RegionRT.cpp new file mode 100644 index 0000000..de1dd3b --- /dev/null +++ b/src/pluginsRT/RegionRT.cpp @@ -0,0 +1,174 @@ +#include +using namespace nvinfer1; +std::vector RegionRTPluginCreator::mPluginAttributes; +PluginFieldCollection RegionRTPluginCreator::mFC{}; + +RegionRT::RegionRT(int classes, int coords, int num) { + this->classes = classes; + this->coords = coords; + this->num = num; +} + +RegionRT::~RegionRT() {} + +RegionRT::RegionRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data),*bufCheck=buf; + classes = readBUF(buf); + coords = readBUF(buf); + num = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck+length); +} + +int RegionRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims RegionRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return inputs[0]; +} + +void RegionRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT { + c = inputDims[0].d[0]; + h = inputDims[0].d[1]; + w = inputDims[0].d[2]; +} + +int RegionRT::initialize() NOEXCEPT {return 0;} + +void RegionRT::terminate() NOEXCEPT {} + +size_t RegionRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } + +int RegionRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + + for (int b = 0; b < batchSize; ++b){ + for(int n = 0; n < num; ++n){ + int index = entry_index(b, n*w*h, 0); + activationLOGISTICForward(srcData + index, dstData + index, 2*w*h, stream); + + index = entry_index(b, n*w*h, coords); + activationLOGISTICForward(srcData + index, dstData + index, w*h, stream); + } + } + + //softmax start + int index = entry_index(0, 0, coords + 1); + softmaxForward( srcData + index, classes, batchSize*num, + (c*h*w)/num, + w*h, 1, w*h, 1, dstData + index, stream); + + return 0; +} + +size_t RegionRT::getSerializationSize() const NOEXCEPT { + return 6*sizeof(int); +} + +void RegionRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, classes); + writeBUF(buf, coords); + writeBUF(buf, num); + writeBUF(buf, c); + writeBUF(buf, h); + writeBUF(buf, w); + assert(buf == a + getSerializationSize()); +} + +const char *RegionRT::getPluginType() const NOEXCEPT { + return "RegionRT_tkDNN"; +} + +const char *RegionRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +void RegionRT::destroy() NOEXCEPT { delete this; } + +const char *RegionRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void RegionRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +bool RegionRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; +} + +IPluginV2 *RegionRT::clone() const NOEXCEPT { + auto *p = new RegionRT(classes,coords,num); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +RegionRTPluginCreator::RegionRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("coords",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void RegionRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *RegionRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *RegionRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new RegionRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *RegionRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 3); + assert(fields[0].type == PluginFieldType::kINT32); + assert(fields[1].type == PluginFieldType::kINT32); + assert(fields[2].type == PluginFieldType::kINT32); + int classes = *(static_cast(fields[0].data)); + int coords = *(static_cast(fields[1].data)); + int num = *(static_cast(fields[2].data)); + RegionRT *pluginObj = new RegionRT(classes,coords,num); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *RegionRTPluginCreator::getPluginName() const NOEXCEPT { + return "RegionRT_tkDNN"; +} + +const char *RegionRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *RegionRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + diff --git a/src/pluginsRT/ReorgRT.cpp b/src/pluginsRT/ReorgRT.cpp new file mode 100644 index 0000000..d3dd12a --- /dev/null +++ b/src/pluginsRT/ReorgRT.cpp @@ -0,0 +1,151 @@ +#include +using namespace nvinfer1; + +std::vector ReorgRTPluginCreator::mPluginAttributes; +PluginFieldCollection ReorgRTPluginCreator::mFC{}; + +ReorgRT::ReorgRT(int stride) { + this->stride = stride; +} + +ReorgRT::~ReorgRT() {} + +ReorgRT::ReorgRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufCheck = buf; + stride = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); +} + +int ReorgRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ReorgRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{inputs[0].d[0]*stride*stride, inputs[0].d[1]/stride, inputs[0].d[2]/stride}; +} + +void ReorgRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + c = inputDims[0].d[0]; + h = inputDims[0].d[1]; + w = inputDims[0].d[2]; +} + +int ReorgRT::initialize() NOEXCEPT { + return 0; +} + +void ReorgRT::terminate() NOEXCEPT {} + +size_t ReorgRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +int ReorgRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT { + reorgForward((dnnType*)reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), + batchSize, c, h, w, stride, stream); + return 0; +} + +size_t ReorgRT::getSerializationSize() const NOEXCEPT { + return 4*sizeof(int); +} + +void ReorgRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, stride); + writeBUF(buf, c); + writeBUF(buf, h); + writeBUF(buf, w); + assert(buf == a + getSerializationSize()); +} + +bool ReorgRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; +} + +const char *ReorgRT::getPluginType() const NOEXCEPT { + return "ReorgRT_tkDNN"; +} + +const char *ReorgRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +void ReorgRT::destroy() NOEXCEPT { + delete this; +} + +const char *ReorgRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ReorgRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2 *ReorgRT::clone() const NOEXCEPT { + auto *p = new ReorgRT(stride); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +ReorgRTPluginCreator::ReorgRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ReorgRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ReorgRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *ReorgRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new ReorgRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *ReorgRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 1); + assert(fields[0].type == PluginFieldType::kINT32); + int stride = *(static_cast(fields[0].data)); + auto *pluginObj = new ReorgRT(stride); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ReorgRTPluginCreator::getPluginName() const NOEXCEPT { + return "ReorgRT_tkDNN"; +} + +const char *ReorgRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *ReorgRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + + + diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp new file mode 100644 index 0000000..5e23ab3 --- /dev/null +++ b/src/pluginsRT/ReshapeRT.cpp @@ -0,0 +1,152 @@ +#include +using namespace nvinfer1; + +std::vector ReshapeRTPluginCreator::mPluginAttributes; +PluginFieldCollection ReshapeRTPluginCreator::mFC{}; + +ReshapeRT::ReshapeRT(dataDim_t newDim) { + new_dim = newDim; + n = new_dim.n; + c = new_dim.c; + h = new_dim.h; + w = new_dim.w; +} + +ReshapeRT::ReshapeRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data),*bufCheck = buf; + new_dim.n = readBUF(buf); + new_dim.c = readBUF(buf); + new_dim.h = readBUF(buf); + new_dim.w = readBUF(buf); + assert(buf == bufCheck + length); +} + +ReshapeRT::~ReshapeRT() {} + +int ReshapeRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ReshapeRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{ c,h,w} ; +} + +void ReshapeRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT {} + +int ReshapeRT::initialize() NOEXCEPT { + return 0; +} + +void ReshapeRT::terminate() NOEXCEPT {} + +size_t ReshapeRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +int ReshapeRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + return 0; +} + +size_t ReshapeRT::getSerializationSize() const NOEXCEPT { + return 4*sizeof(int); +} + +void ReshapeRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a = buf; + writeBUF(buf, n); + writeBUF(buf, c); + writeBUF(buf, h); + writeBUF(buf, w); + assert(buf == a + getSerializationSize()); +} + +bool ReshapeRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; + //todo assert +} + +const char *ReshapeRT::getPluginType() const NOEXCEPT { + return "ReshapeRT_tkDNN"; +} + +const char *ReshapeRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +void ReshapeRT::destroy() NOEXCEPT { + delete this; +} + +const char *ReshapeRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ReshapeRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2 *ReshapeRT::clone() const NOEXCEPT { + auto *p = new ReshapeRT(new_dim); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +ReshapeRTPluginCreator::ReshapeRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("new_dim",nullptr,PluginFieldType::kUNKNOWN,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ReshapeRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ReshapeRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *ReshapeRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new ReshapeRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *ReshapeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + dataDim_t newDim = *(static_cast(fields[0].data)); + ReshapeRT *pluginObj = new ReshapeRT(newDim); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ReshapeRTPluginCreator::getPluginName() const NOEXCEPT { + return "ReshapeRT_tkDNN"; +} + +const char *ReshapeRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *ReshapeRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + + + diff --git a/src/pluginsRT/ResizeLayerRT.cpp b/src/pluginsRT/ResizeLayerRT.cpp new file mode 100644 index 0000000..12a3ff9 --- /dev/null +++ b/src/pluginsRT/ResizeLayerRT.cpp @@ -0,0 +1,163 @@ +#include +using namespace nvinfer1; + +std::vector ResizeLayerRTPluginCreator::mPluginAttributes; +PluginFieldCollection ResizeLayerRTPluginCreator::mFC{}; + + +ResizeLayerRT::ResizeLayerRT(int c, int h, int w) { + o_c = c; + o_h = h; + o_w = w; +} + +ResizeLayerRT::ResizeLayerRT(const void *data, size_t length) { + const char *buf = reinterpret_cast(data),*bufCheck = buf; + o_c = readBUF(buf); + o_h = readBUF(buf); + o_w = readBUF(buf); + i_c = readBUF(buf); + i_h = readBUF(buf); + i_w = readBUF(buf); + assert(buf == bufCheck + length); +} + +ResizeLayerRT::~ResizeLayerRT() {} + +int ResizeLayerRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ResizeLayerRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{o_c, o_h, o_w}; +} + +void ResizeLayerRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, + DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + i_c = inputDims[0].d[0]; + i_h = inputDims[0].d[1]; + i_w = inputDims[0].d[2]; +} + +int ResizeLayerRT::initialize() NOEXCEPT { + return 0; +} + +void ResizeLayerRT::terminate() NOEXCEPT {} + +size_t ResizeLayerRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } + +int ResizeLayerRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + resizeForward((dnnType*)reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), + batchSize, i_c, i_h, i_w, o_c, o_h, o_w, stream); + return 0; +} + +size_t ResizeLayerRT::getSerializationSize() const NOEXCEPT { + return 6*sizeof(int); +} + +void ResizeLayerRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, o_c); + writeBUF(buf, o_h); + writeBUF(buf, o_w); + writeBUF(buf, i_c); + writeBUF(buf, i_h); + writeBUF(buf, i_w); + assert(buf == a + getSerializationSize()); +} + +bool ResizeLayerRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; + //todo assert +} + +const char *ResizeLayerRT::getPluginType() const NOEXCEPT { + return "ResizeLayerRT_tkDNN"; +} + +const char *ResizeLayerRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +void ResizeLayerRT::destroy() NOEXCEPT { + delete this; +} + +const char *ResizeLayerRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ResizeLayerRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2 *ResizeLayerRT::clone() const NOEXCEPT { + auto *p = new ResizeLayerRT(o_c,o_h,o_w); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +ResizeLayerRTPluginCreator::ResizeLayerRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ResizeLayerRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ResizeLayerRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *ResizeLayerRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new ResizeLayerRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *ResizeLayerRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 3); + assert(fields[0].type == PluginFieldType::kINT32); + assert(fields[1].type == PluginFieldType::kINT32); + assert(fields[2].type == PluginFieldType::kINT32); + int oc = *(static_cast(fields[0].data)); + int oh = *(static_cast(fields[1].data)); + int ow = *(static_cast(fields[2].data)); + auto *pluginObj = new ResizeLayerRT(oc,oh,ow); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ResizeLayerRTPluginCreator::getPluginName() const NOEXCEPT { + return "ResizeLayerRT_tkDNN"; +} + +const char *ResizeLayerRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *ResizeLayerRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + diff --git a/src/pluginsRT/RouteRT.cpp b/src/pluginsRT/RouteRT.cpp new file mode 100644 index 0000000..87233a5 --- /dev/null +++ b/src/pluginsRT/RouteRT.cpp @@ -0,0 +1,183 @@ +#include +using namespace nvinfer1; + +std::vector RouteRTPluginCreator::mPluginAttributes; +PluginFieldCollection RouteRTPluginCreator::mFC{}; + + +RouteRT::RouteRT(int groups, int group_id) { + this->groups = groups; + this->group_id = group_id; +} + +RouteRT::~RouteRT() {} + +RouteRT::RouteRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufCheck = buf; + groups = readBUF(buf); + group_id = readBUF(buf); + in = readBUF(buf); + for(int i=0;i (buf); + } + c= readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); +} + +int RouteRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims RouteRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + int out_c = 0; + for(int i=0; i(outputs[0]); + for(int b=0; b(inputs[i]); + int in_dim = c_in[i]*h*w; + int part_in_dim = in_dim / this->groups; + checkCuda( cudaMemcpyAsync(dstData + b*c*w*h + offset, input + b*c*w*h*groups + this->group_id*part_in_dim, part_in_dim*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream) ); + offset += part_in_dim; + } + } + return 0; +} + +size_t RouteRT::getSerializationSize() const NOEXCEPT { + return (6+MAX_INPUTS)*sizeof(int); +} + +void RouteRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, groups); + writeBUF(buf, group_id); + writeBUF(buf, in); + for(int i=0; isetPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +RouteRTPluginCreator::RouteRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("groups",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("group_id",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void RouteRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *RouteRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *RouteRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new RouteRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *RouteRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + assert(fc->nbFields == 2); + assert(fields[0].type == PluginFieldType::kINT32); + assert(fields[1].type == PluginFieldType::kINT32); + int groups = *(static_cast(fields[0].data)); + int group_id = *(static_cast(fields[1].data)); + RouteRT *pluginObj = new RouteRT(groups,group_id); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *RouteRTPluginCreator::getPluginName() const NOEXCEPT { + return "RouteRT_tkDNN"; +} + +const char *RouteRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *RouteRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + diff --git a/src/pluginsRT/ShortcutRT.cpp b/src/pluginsRT/ShortcutRT.cpp new file mode 100644 index 0000000..eb35bd6 --- /dev/null +++ b/src/pluginsRT/ShortcutRT.cpp @@ -0,0 +1,167 @@ +#include +using namespace nvinfer1; + +std::vector ShortcutRTPluginCreator::mPluginAttributes; +PluginFieldCollection ShortcutRTPluginCreator::mFC{}; + +ShortcutRT::ShortcutRT(tk::dnn::dataDim_t bdim, bool mul) { + bDim = bdim; + this->bc = bDim.c; + this->bh = bDim.h; + this->bw = bDim.w; + this->mul = mul; +} + +ShortcutRT::~ShortcutRT() {} + +ShortcutRT::ShortcutRT(const void *data, size_t length) { + const char* buf =reinterpret_cast(data),*bufCheck = buf; + bDim.c = readBUF(buf); + bDim.h = readBUF(buf); + bDim.w = readBUF(buf); + bDim.l = 1; + mul = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); +} + +int ShortcutRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims ShortcutRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3{inputs[0].d[0], inputs[0].d[1], inputs[0].d[2]}; +} + +void ShortcutRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, + DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + c = inputDims[0].d[0]; + h = inputDims[0].d[1]; + w = inputDims[0].d[2]; +} + +int ShortcutRT::initialize() NOEXCEPT { + return 0; +} + +void ShortcutRT::terminate() NOEXCEPT {} + +size_t ShortcutRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } + +int ShortcutRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *srcDataBack = (dnnType*)reinterpret_cast(inputs[1]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + shortcutForward(srcDataBack, dstData, batchSize, c, h, w, 1, batchSize, bc, bh, bw, 1, mul, stream); + + return 0; +} + +size_t ShortcutRT::getSerializationSize() const NOEXCEPT { + return 6*sizeof(int) + sizeof(bool); +} + +void ShortcutRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, bc); + writeBUF(buf, bh); + writeBUF(buf, bw); + writeBUF(buf, mul); + writeBUF(buf, c); + writeBUF(buf, h); + writeBUF(buf, w); + assert(buf == a + getSerializationSize()); +} + +bool ShortcutRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; +} + +const char *ShortcutRT::getPluginType() const NOEXCEPT { + return "ShortcutRT_tkDNN"; +} + +const char *ShortcutRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +void ShortcutRT::destroy() NOEXCEPT { + delete this; +} + +const char *ShortcutRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void ShortcutRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2 *ShortcutRT::clone() const NOEXCEPT { + auto *p = new ShortcutRT(bDim,mul); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +ShortcutRTPluginCreator::ShortcutRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("bDim",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("mul",nullptr,PluginFieldType::kUNKNOWN,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void ShortcutRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *ShortcutRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *ShortcutRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new ShortcutRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *ShortcutRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + //todo assert + tk::dnn::dataDim_t bdim = *(static_cast(fields[0].data)); + bool mul = *(static_cast(fields[1].data)); + auto *pluginObj = new ShortcutRT(bdim,mul); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *ShortcutRTPluginCreator::getPluginName() const NOEXCEPT { + return "ShortcutRT_tkDNN"; +} + +const char *ShortcutRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *ShortcutRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + + + diff --git a/src/pluginsRT/UpsampleRT.cpp b/src/pluginsRT/UpsampleRT.cpp new file mode 100644 index 0000000..044405b --- /dev/null +++ b/src/pluginsRT/UpsampleRT.cpp @@ -0,0 +1,155 @@ +#include +using namespace nvinfer1; + +std::vector UpsampleRTPluginCreator::mPluginAttributes; +PluginFieldCollection UpsampleRTPluginCreator::mFC{}; + +UpsampleRT::UpsampleRT(int stride) { + this->stride = stride; +} + +UpsampleRT::UpsampleRT(const void *data, size_t length) { + const char* buf = reinterpret_cast(data),*bufCheck=buf; + stride = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + assert(buf == bufCheck + length); +} + +UpsampleRT::~UpsampleRT() {} + +int UpsampleRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims UpsampleRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return Dims3(inputs[0].d[0], inputs[0].d[1]*stride, inputs[0].d[2]*stride); +} + +void UpsampleRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, + DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { + c = inputDims[0].d[0]; + h = inputDims[0].d[1]; + w = inputDims[0].d[2]; +} + +int UpsampleRT::initialize() NOEXCEPT { + return 0; +} + +void UpsampleRT::terminate() NOEXCEPT {} + +size_t UpsampleRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +int UpsampleRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + fill(dstData, batchSize*c*h*w*stride*stride, 0.0, stream); + upsampleForward(srcData, dstData, batchSize, c, h, w, stride, 1, 1, stream); + return 0; +} + +size_t UpsampleRT::getSerializationSize() const NOEXCEPT { + return 4*sizeof(int); +} + +void UpsampleRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer),*a=buf; + writeBUF(buf, stride); + writeBUF(buf, c); + writeBUF(buf, h); + writeBUF(buf, w); + assert(buf == a + getSerializationSize()); +} + +bool UpsampleRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; +} + +const char *UpsampleRT::getPluginType() const NOEXCEPT { + return "Upsample_tkDNN"; +} + +const char *UpsampleRT::getPluginVersion() const NOEXCEPT { + return "1"; +} + +void UpsampleRT::destroy() NOEXCEPT { + delete this; +} + +const char *UpsampleRT::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +void UpsampleRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +IPluginV2 *UpsampleRT::clone() const NOEXCEPT { + auto *p = new UpsampleRT(stride); + p->setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +UpsampleRTPluginCreator::UpsampleRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void UpsampleRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *UpsampleRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *UpsampleRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new UpsampleRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *UpsampleRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + int stride = *(static_cast(fields[0].data)); + auto *pluginObj = new UpsampleRT(stride); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *UpsampleRTPluginCreator::getPluginName() const NOEXCEPT { + return "Upsample_tkDNN"; +} + +const char *UpsampleRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *UpsampleRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + + + + + diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp new file mode 100644 index 0000000..7f615b4 --- /dev/null +++ b/src/pluginsRT/YoloRT.cpp @@ -0,0 +1,253 @@ +#include +using namespace nvinfer1; + +std::vector YoloRTPluginCreator::mPluginAttributes; +PluginFieldCollection YoloRTPluginCreator::mFC{}; + +YoloRT::YoloRT(int classes, int num, tk::dnn::Yolo *Yolo, int n_masks, float scale_xy, float nms_thresh, int nms_kind, + int new_coords) { + this->yolo = Yolo; + this->classes = classes; + this->num = num; + this->n_masks = n_masks; + this->scaleXY = scale_xy; + this->nms_thresh = nms_thresh; + this->nms_kind = nms_kind; + this->new_coords = new_coords; + + mask = new dnnType[n_masks]; + bias = new dnnType[num * n_masks * 2]; + if (yolo != nullptr) { + memcpy(mask, yolo->mask_h, sizeof(dnnType) * n_masks); + memcpy(bias, yolo->bias_h, sizeof(dnnType) * num * n_masks * 2); + classesNames = yolo->classesNames; + } +} + +YoloRT::YoloRT(const void *data, size_t length) { + std::vector maskTemp,biasTemp; + std::cout<<"LENGTH : "<(data),*bufCheck = buf; + classes = readBUF(buf); + num = readBUF(buf); + n_masks = readBUF(buf); + scaleXY = readBUF(buf); + nms_thresh = readBUF(buf); + nms_kind = readBUF(buf); + new_coords = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); + for(int i=0;i(buf)); + std::cout<(buf)); + std::cout<(buf); + classesNames[1] = std::string(tmp); + } + assert(buf == bufCheck + length); +} + +YoloRT::~YoloRT() {} + +int YoloRT::getNbOutputs() const NOEXCEPT { + return 1; +} + +Dims YoloRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { + return inputs[0]; +} + +void YoloRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, + PluginFormat format, int maxBatchSize) NOEXCEPT { + c = inputDims[0].d[0]; + h = inputDims[0].d[1]; + w = inputDims[0].d[2]; +} + +int YoloRT::initialize() NOEXCEPT { + return 0; +} + +void YoloRT::terminate() NOEXCEPT {} + +size_t YoloRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { + return 0; +} + +int YoloRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, + cudaStream_t stream) NOEXCEPT { + dnnType *srcData = (dnnType *) reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda(cudaMemcpyAsync(dstData, srcData, batchSize * c * h * w * sizeof(dnnType), cudaMemcpyDeviceToDevice, + stream)); + + + for (int b = 0; b < batchSize; ++b) { + for (int n = 0; n < n_masks; ++n) { + int index = entry_index(b, n * w * h, 0); + if (new_coords == 1) { + if (this->scaleXY != 1) + scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); + } else { + activationLOGISTICForward(srcData + index, dstData + index, 2 * w * h, stream); //x,y + + if (this->scaleXY != 1) + scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); + + index = entry_index(b, n * w * h, 4); + activationLOGISTICForward(srcData + index, dstData + index, (1 + classes) * w * h, stream); + } + } + } + + //std::cout<<"YOLO END\n"; + return 0; +} + +size_t YoloRT::getSerializationSize() const NOEXCEPT { + return 8 * sizeof(int) + 2 * sizeof(float) + n_masks * sizeof(dnnType) + num * n_masks * 2 * sizeof(dnnType) + + YOLORT_CLASSNAME_W * classes * sizeof(char); +} + +bool YoloRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; +} + +void YoloRT::serialize(void *buffer) const NOEXCEPT { + char *buf = reinterpret_cast(buffer), *a = buf; + writeBUF(buf, classes); //std::cout << "Classes :" << classes << std::endl; + writeBUF(buf, num); //std::cout << "Num : " << num << std::endl; + std::cout<setPluginNamespace(mPluginNamespace.c_str()); + return p; +} + + +YoloRTPluginCreator::YoloRTPluginCreator() { + mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("yolo",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("numMasks",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("scaleXY",nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nmsThresh",nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nmsKind",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("newCoords",nullptr,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); +} + +void YoloRTPluginCreator::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { + mPluginNamespace = pluginNamespace; +} + +const char *YoloRTPluginCreator::getPluginNamespace() const NOEXCEPT { + return mPluginNamespace.c_str(); +} + +IPluginV2 *YoloRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { + auto *pluginObj = new YoloRT(serialData,serialLength); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +IPluginV2 *YoloRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField *fields = fc->fields; + //todo assert + int classes = *(static_cast(fields[0].data)); + int num = *(static_cast(fields[1].data)); + Yolo *yoloTemp = const_cast(static_cast(fields[2].data)); + int numMasks = *(static_cast(fields[3].data)); + float scaleXY = *(static_cast(fields[4].data)); + float nmsThresh = *(static_cast(fields[5].data)); + int nmsKind = *(static_cast(fields[6].data)); + int newCoords = *(static_cast(fields[7].data)); + YoloRT *pluginObj = new YoloRT(classes,num,yoloTemp,numMasks,scaleXY,nmsThresh,nmsKind,newCoords); + pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + return pluginObj; +} + +const char *YoloRTPluginCreator::getPluginName() const NOEXCEPT { + return "YoloRT_tkDNN"; +} + +const char *YoloRTPluginCreator::getPluginVersion() const NOEXCEPT { + return "1"; +} + +const PluginFieldCollection *YoloRTPluginCreator::getFieldNames() NOEXCEPT { + return &mFC; +} + + + + + + + + + + + + + + -- 2.52.0 From 504dee5016bcedc104913a6214cba05fff18b34a Mon Sep 17 00:00:00 2001 From: perseusdg Date: Mon, 6 Sep 2021 15:35:57 +0530 Subject: [PATCH 10/32] test_yolo4 netRT->destroy() --- tests/darknet/yolo4.cpp | 1 + tests/darknet/yolo4tiny.cpp | 5 ----- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/tests/darknet/yolo4.cpp b/tests/darknet/yolo4.cpp index 8de8651..08e10a9 100644 --- a/tests/darknet/yolo4.cpp +++ b/tests/darknet/yolo4.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4tiny.cpp b/tests/darknet/yolo4tiny.cpp index 9a65f30..225433c 100644 --- a/tests/darknet/yolo4tiny.cpp +++ b/tests/darknet/yolo4tiny.cpp @@ -27,14 +27,9 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); std::cout<releaseLayers(); - std::cout<<"DELETING NET"<destroy(); delete netRT; - - std::cout<<"RETRUNING RET"< Date: Tue, 7 Sep 2021 07:20:46 +0530 Subject: [PATCH 11/32] tkdnn(trt8) runs now minus the detections ,[executionContext.cpp::enqueueInternal::312] Error Code 3: Internal Error (Parameter check failed at: runtime/api/executionContext.cpp::enqueueInternal::312, condition: mDeviceMemorySize == 0 || mExecutionResources->getDeviceMemory() != nullptr - is the error that causes it --- src/Yolo.cpp | 1 - src/Yolo3Detection.cpp | 3 ++- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Yolo.cpp b/src/Yolo.cpp index 35abb19..e6fb8ab 100644 --- a/src/Yolo.cpp +++ b/src/Yolo.cpp @@ -137,7 +137,6 @@ int Yolo::computeDetections(Yolo::detection *dets, int &ndets, int netw, int net if(predictions == nullptr) predictions = new dnnType[output_dim.tot()]; - checkCuda(cudaDeviceSynchronize()); checkCuda( cudaMemcpy(predictions, dstData, output_dim.tot()*sizeof(dnnType), cudaMemcpyDeviceToHost)); int lw = output_dim.w; diff --git a/src/Yolo3Detection.cpp b/src/Yolo3Detection.cpp index 8d3d244..48e9d5d 100644 --- a/src/Yolo3Detection.cpp +++ b/src/Yolo3Detection.cpp @@ -45,7 +45,8 @@ namespace tk { namespace dnn { yolo[i]->bias_h = new dnnType[num*nMasks*2]; memcpy(yolo[i]->mask_h, maskTempF, sizeof(dnnType)*nMasks); memcpy(yolo[i]->bias_h, biasTempF, sizeof(dnnType)*num*nMasks*2); - yolo[i]->input_dim = yolo[i]->output_dim = tk::dnn::dataDim_t(1, channels, height, width); + auto dim = netRT->engineRT->getBindingDimensions(i+1); + yolo[i]->input_dim = yolo[i]->output_dim = tk::dnn::dataDim_t(1, dim.d[0], dim.d[1], dim.d[2]); yolo[i]->classesNames = classNamesTemp; yolo[i]->nms_thresh = nmsthresh; yolo[i]->nsm_kind = (tk::dnn::Yolo::nmsKind_t) nms_kind; -- 2.52.0 From 03473743c4348490d86941efe8410ea6b5478d43 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Tue, 7 Sep 2021 22:00:28 +0530 Subject: [PATCH 12/32] tkDNN works with trt8!!,need to test int8 and mobilenet,dla_cnet (fps seems to be a bit low 350 on trt8 compared to 396 on trt7) --- CMakeLists.txt | 4 ++-- demo/demo/demo.cpp | 21 ++++++++++++------- include/tkDNN/CenternetDetection.h | 2 +- include/tkDNN/MobilenetDetection.h | 2 +- src/CenternetDetection.cpp | 2 +- src/MobilenetDetection.cpp | 2 +- src/NetworkRT.cpp | 2 +- src/Yolo3Detection.cpp | 2 +- tests/darknet/csresnext50-panet-spp.cpp | 1 + .../csresnext50-panet-spp_berkeley.cpp | 1 + tests/darknet/yolo2_voc.cpp | 1 + tests/darknet/yolo2tiny.cpp | 1 + tests/darknet/yolo3.cpp | 1 + tests/darknet/yolo3_512.cpp | 1 + tests/darknet/yolo3_berkeley.cpp | 1 + tests/darknet/yolo3_coco4.cpp | 1 + tests/darknet/yolo3_flir.cpp | 1 + tests/darknet/yolo3tiny.cpp | 1 + tests/darknet/yolo3tiny_512.cpp | 1 + tests/darknet/yolo4-csp.cpp | 1 + tests/darknet/yolo4_320.cpp | 1 + tests/darknet/yolo4_320_coco2.cpp | 1 + tests/darknet/yolo4_512.cpp | 1 + tests/darknet/yolo4_608.cpp | 1 + tests/darknet/yolo4_berkeley.cpp | 1 + tests/darknet/yolo4_berkeley_f1.cpp | 1 + tests/darknet/yolo4_mmr.cpp | 1 + tests/darknet/yolo4tiny_512.cpp | 1 + tests/darknet/yolo4x.cpp | 1 + .../bdd-mobilenetv2ssd/bdd-mobilenetv2ssd.cpp | 1 + 30 files changed, 43 insertions(+), 16 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f3471e2..9191adc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.15) project (tkDNN) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) if(UNIX) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations -Wno-unused-variable") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations -Wno-unused-variable -O3") endif() if(WIN32) set(CMAKE_CXX_STANDARD 11) @@ -31,7 +31,7 @@ endif() find_package(CUDA 9.0 REQUIRED) SET(CUDA_SEPARABLE_COMPILATION ON) #set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -arch=sm_30 --compiler-options '-fPIC'") -set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) +set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -arch=sm_61) find_package(CUDNN REQUIRED) diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index 6e1c2b4..d597da9 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -45,14 +45,14 @@ int main(int argc, char *argv[]) { if(argc > 2) - cfgPath = argv[2]; + cfgPath = argv[3]; if(argc > 3) - namePath = argv[3]; + namePath = argv[4]; if(argc > 4) - input = argv[4]; + input = argv[5]; char ntype = 'y'; if(argc > 5) - ntype = argv[5][0]; + ntype = argv[2][0]; int n_classes = 80; if(argc > 6) n_classes = atoi(argv[6]); @@ -72,9 +72,14 @@ int main(int argc, char *argv[]) { if(!show) SAVE_RESULT = true; + if(ntype == 'c' || ntype == 'm'){ + cfgPath = nullptr; + namePath = nullptr; + + } tk::dnn::Yolo3Detection yolo; - //tk::dnn::CenternetDetection cnet; - //tk::dnn::MobilenetDetection mbnet; + tk::dnn::CenternetDetection cnet; + tk::dnn::MobilenetDetection mbnet; tk::dnn::DetectionNN *detNN; @@ -84,10 +89,10 @@ int main(int argc, char *argv[]) { detNN = &yolo; break; case 'c': - //detNN = &cnet; + detNN = &cnet; break; case 'm': - //detNN = &mbnet; + detNN = &mbnet; n_classes++; break; default: diff --git a/include/tkDNN/CenternetDetection.h b/include/tkDNN/CenternetDetection.h index 3c8cfbb..07c80cd 100644 --- a/include/tkDNN/CenternetDetection.h +++ b/include/tkDNN/CenternetDetection.h @@ -73,7 +73,7 @@ public: CenternetDetection() {}; ~CenternetDetection() {}; - bool init(const std::string& tensor_path, const int n_classes=80, const int n_batches=1, const float conf_thresh=0.3); + bool init(const std::string& tensor_path,const std::string& cfg_path,const std::string& name_path, const int n_classes=80, const int n_batches=1, const float conf_thresh=0.3); void preprocess(cv::Mat &frame, const int bi=0); void postprocess(const int bi=0,const bool mAP=false); }; diff --git a/include/tkDNN/MobilenetDetection.h b/include/tkDNN/MobilenetDetection.h index 9a5fedc..ec35b20 100644 --- a/include/tkDNN/MobilenetDetection.h +++ b/include/tkDNN/MobilenetDetection.h @@ -65,7 +65,7 @@ public: MobilenetDetection() {}; ~MobilenetDetection() {}; - bool init(const std::string& tensor_path, const int n_classes, const int n_batches=1, const float conf_thresh=0.3); + bool init(const std::string& tensor_path, const std::string& cfg_path,const std::string& name_path,const int n_classes, const int n_batches=1, const float conf_thresh=0.3); void preprocess(cv::Mat &frame, const int bi=0); void postprocess(const int bi=0,const bool mAP=false); }; diff --git a/src/CenternetDetection.cpp b/src/CenternetDetection.cpp index a06bc11..133c682 100644 --- a/src/CenternetDetection.cpp +++ b/src/CenternetDetection.cpp @@ -3,7 +3,7 @@ namespace tk { namespace dnn { -bool CenternetDetection::init(const std::string& tensor_path, const int n_classes, const int n_batches, const float conf_thresh){ +bool CenternetDetection::init(const std::string& tensor_path, const std::string& cfg_path,const std::string& name_path,const int n_classes, const int n_batches, const float conf_thresh){ std::cout<<(tensor_path).c_str()<<"\n"; netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str() ); classes = n_classes; diff --git a/src/MobilenetDetection.cpp b/src/MobilenetDetection.cpp index 3c54e28..1d3832d 100644 --- a/src/MobilenetDetection.cpp +++ b/src/MobilenetDetection.cpp @@ -126,7 +126,7 @@ float MobilenetDetection::iou(const tk::dnn::box &a, const tk::dnn::box &b){ return iou; } -bool MobilenetDetection::init(const std::string& tensor_path, const int n_classes, const int n_batches, const float conf_thresh){ +bool MobilenetDetection::init(const std::string& tensor_path, const std::string& cfg_path,const std::string& name_path,const int n_classes, const int n_batches, const float conf_thresh){ std::cout<<(tensor_path).c_str()<<"\n"; netRT = new tk::dnn::NetworkRT(NULL, (tensor_path).c_str()); imageSize = netRT->input_dim.h; diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 7f00cd6..4b3d532 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -657,8 +657,8 @@ bool NetworkRT::deserialize(const char *filename) { void NetworkRT::destroy() { contextRT->destroy(); - configRT->destroy(); engineRT->destroy(); + configRT->destroy(); builderRT->destroy(); } diff --git a/src/Yolo3Detection.cpp b/src/Yolo3Detection.cpp index 48e9d5d..bda206a 100644 --- a/src/Yolo3Detection.cpp +++ b/src/Yolo3Detection.cpp @@ -29,7 +29,7 @@ namespace tk { namespace dnn { for(int i=0; i maskTemp,anchorsTemp; std::vector classNamesTemp; - int classes,nms_kind,coords,numTemp; + int nms_kind,coords,numTemp; float nmsthresh; loadYoloInfo(cfg_path,yolosLine[i],maskTemp,anchorsTemp,numTemp,classes,nmsthresh,nms_kind,coords); classNamesTemp = darknetReadNames(name_path); diff --git a/tests/darknet/csresnext50-panet-spp.cpp b/tests/darknet/csresnext50-panet-spp.cpp index a366e14..5413e52 100644 --- a/tests/darknet/csresnext50-panet-spp.cpp +++ b/tests/darknet/csresnext50-panet-spp.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/csresnext50-panet-spp_berkeley.cpp b/tests/darknet/csresnext50-panet-spp_berkeley.cpp index a8ba59f..1f52716 100644 --- a/tests/darknet/csresnext50-panet-spp_berkeley.cpp +++ b/tests/darknet/csresnext50-panet-spp_berkeley.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo2_voc.cpp b/tests/darknet/yolo2_voc.cpp index 94111e6..964c9f7 100644 --- a/tests/darknet/yolo2_voc.cpp +++ b/tests/darknet/yolo2_voc.cpp @@ -27,6 +27,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo2tiny.cpp b/tests/darknet/yolo2tiny.cpp index cc12109..f391a6f 100644 --- a/tests/darknet/yolo2tiny.cpp +++ b/tests/darknet/yolo2tiny.cpp @@ -28,6 +28,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo3.cpp b/tests/darknet/yolo3.cpp index d9a684b..d61cf19 100644 --- a/tests/darknet/yolo3.cpp +++ b/tests/darknet/yolo3.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } \ No newline at end of file diff --git a/tests/darknet/yolo3_512.cpp b/tests/darknet/yolo3_512.cpp index c24550b..e4a6316 100644 --- a/tests/darknet/yolo3_512.cpp +++ b/tests/darknet/yolo3_512.cpp @@ -41,6 +41,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo3_berkeley.cpp b/tests/darknet/yolo3_berkeley.cpp index 016a8a2..620692a 100644 --- a/tests/darknet/yolo3_berkeley.cpp +++ b/tests/darknet/yolo3_berkeley.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo3_coco4.cpp b/tests/darknet/yolo3_coco4.cpp index eaf9bd8..89a1616 100644 --- a/tests/darknet/yolo3_coco4.cpp +++ b/tests/darknet/yolo3_coco4.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo3_flir.cpp b/tests/darknet/yolo3_flir.cpp index 24aac7f..557a4ca 100644 --- a/tests/darknet/yolo3_flir.cpp +++ b/tests/darknet/yolo3_flir.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo3tiny.cpp b/tests/darknet/yolo3tiny.cpp index c33f7a8..c18a60c 100644 --- a/tests/darknet/yolo3tiny.cpp +++ b/tests/darknet/yolo3tiny.cpp @@ -28,6 +28,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo3tiny_512.cpp b/tests/darknet/yolo3tiny_512.cpp index 8460416..f8aae61 100644 --- a/tests/darknet/yolo3tiny_512.cpp +++ b/tests/darknet/yolo3tiny_512.cpp @@ -41,6 +41,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4-csp.cpp b/tests/darknet/yolo4-csp.cpp index 8ad8aef..f354a48 100644 --- a/tests/darknet/yolo4-csp.cpp +++ b/tests/darknet/yolo4-csp.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } \ No newline at end of file diff --git a/tests/darknet/yolo4_320.cpp b/tests/darknet/yolo4_320.cpp index 0e623e0..db03024 100644 --- a/tests/darknet/yolo4_320.cpp +++ b/tests/darknet/yolo4_320.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_320_coco2.cpp b/tests/darknet/yolo4_320_coco2.cpp index 877e604..b8fd3bf 100644 --- a/tests/darknet/yolo4_320_coco2.cpp +++ b/tests/darknet/yolo4_320_coco2.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_512.cpp b/tests/darknet/yolo4_512.cpp index 9d4c389..b5e3975 100644 --- a/tests/darknet/yolo4_512.cpp +++ b/tests/darknet/yolo4_512.cpp @@ -42,6 +42,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_608.cpp b/tests/darknet/yolo4_608.cpp index dda084f..762f83a 100644 --- a/tests/darknet/yolo4_608.cpp +++ b/tests/darknet/yolo4_608.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_berkeley.cpp b/tests/darknet/yolo4_berkeley.cpp index 89e9f04..70dee4b 100644 --- a/tests/darknet/yolo4_berkeley.cpp +++ b/tests/darknet/yolo4_berkeley.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_berkeley_f1.cpp b/tests/darknet/yolo4_berkeley_f1.cpp index 6dfbc63..f6f4e62 100644 --- a/tests/darknet/yolo4_berkeley_f1.cpp +++ b/tests/darknet/yolo4_berkeley_f1.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4_mmr.cpp b/tests/darknet/yolo4_mmr.cpp index 85649b2..e22f662 100644 --- a/tests/darknet/yolo4_mmr.cpp +++ b/tests/darknet/yolo4_mmr.cpp @@ -29,6 +29,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4tiny_512.cpp b/tests/darknet/yolo4tiny_512.cpp index fd15aea..1b53ed3 100644 --- a/tests/darknet/yolo4tiny_512.cpp +++ b/tests/darknet/yolo4tiny_512.cpp @@ -40,6 +40,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/darknet/yolo4x.cpp b/tests/darknet/yolo4x.cpp index 8df1aef..7f793f7 100644 --- a/tests/darknet/yolo4x.cpp +++ b/tests/darknet/yolo4x.cpp @@ -31,6 +31,7 @@ int main() { int ret = testInference(input_bins, output_bins, net, netRT); net->releaseLayers(); delete net; + netRT->destroy(); delete netRT; return ret; } diff --git a/tests/mobilenet/bdd-mobilenetv2ssd/bdd-mobilenetv2ssd.cpp b/tests/mobilenet/bdd-mobilenetv2ssd/bdd-mobilenetv2ssd.cpp index c3c6472..46064de 100644 --- a/tests/mobilenet/bdd-mobilenetv2ssd/bdd-mobilenetv2ssd.cpp +++ b/tests/mobilenet/bdd-mobilenetv2ssd/bdd-mobilenetv2ssd.cpp @@ -542,5 +542,6 @@ int main() ret_cudnn_tensorrt |= checkResult(conf->output_dim.tot(), conf->dstData, rt_out3) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; ret_cudnn_tensorrt |= checkResult(loc->output_dim.tot(), loc->dstData, rt_out4) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } -- 2.52.0 From 18cc6abbb65f8ce17ac062f66447422003d0576b Mon Sep 17 00:00:00 2001 From: perseusdg Date: Tue, 7 Sep 2021 23:57:52 +0530 Subject: [PATCH 13/32] DeformableConvRT.h fixes ,cmake cuda arch auto detection --- .gitignore | 3 +- CMakeLists.txt | 68 +++++++++++++++++++--- cmake/getCudaArch.cu | 20 +++++++ include/tkDNN/pluginsRT/DeformableConvRT.h | 2 +- 4 files changed, 82 insertions(+), 11 deletions(-) create mode 100644 cmake/getCudaArch.cu diff --git a/.gitignore b/.gitignore index c1d362c..683834c 100644 --- a/.gitignore +++ b/.gitignore @@ -19,4 +19,5 @@ demo/BDD100K_val cmake-build-minsizerel/* scripts/COCO_val2017/* scripts/COCO_val2017.zip -scripts/all_labels.txt \ No newline at end of file +scripts/all_labels.txt +/cmake/cuda_script diff --git a/CMakeLists.txt b/CMakeLists.txt index 9191adc..c10f6ac 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,15 +1,67 @@ cmake_minimum_required(VERSION 3.15) - -project (tkDNN) +project(tkDNN) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) -if(UNIX) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -fPIC -Wno-deprecated-declarations -Wno-unused-variable -O3") +set(CMAKE_CXX_STANDARD 14) + +find_package(CUDA 9.0 REQUIRED) +if (CUDA_FOUND) + #Get CUDA compute capability + set(OUTPUTFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/cuda_script) # No suffix required + set(CUDAFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/getCudaArch.cu) + execute_process(COMMAND nvcc -lcuda ${CUDAFILE} -o ${OUTPUTFILE}) + execute_process(COMMAND ${OUTPUTFILE} + RESULT_VARIABLE CUDA_RETURN_CODE + OUTPUT_VARIABLE ARCH) + + if(${CUDA_RETURN_CODE} EQUAL 0) + set(CUDA_SUCCESS "TRUE") + else() + set(CUDA_SUCCESS "FALSE") + endif() + + if (${CUDA_SUCCESS}) + message(STATUS "CUDA Architecture: ${ARCH}") + message(STATUS "CUDA Version: ${CUDA_VERSION_STRING}") + message(STATUS "CUDA Path: ${CUDA_TOOLKIT_ROOT_DIR}") + message(STATUS "CUDA Libararies: ${CUDA_LIBRARIES}") + message(STATUS "CUDA Performance Primitives: ${CUDA_npp_LIBRARY}") + + set(CUDA_NVCC_FLAGS "${ARCH}") + add_definitions(-DGPU) #You may not require this + + else() + message(WARNING ${ARCH}) + endif() endif() + +SET(CUDA_SEPARABLE_COMPILATION ON) + + +if(UNIX) + if(CMAKE_BUILD_TYPE MATCHES Release) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -Wno-deprecated-declarations -Wno-unused-variable -O3") + set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) + endif() + + if(CMAKE_BUILD_TYPE MATCHES Debug) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -Wno-deprecated-declarations -Wno-unused-variable -g3") + set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -G -g) + endif() +endif() + if(WIN32) -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc") + if(CMAKE_BUILD_TYPE MATCHES Release) + set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc") + set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -arch=sm_61) + endif() + + if(CMAKE_BUILD_TYPE MATCHES Debug) + set(CMAKE_CXX_FLAGS "/Od /FS /EHsc") + set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -arch=sm_61 -G -g) + endif() set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON) endif(WIN32) + include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include/tkDNN) # project specific flags @@ -28,10 +80,8 @@ endif() #------------------------------------------------------------------------------- # CUDA #------------------------------------------------------------------------------- -find_package(CUDA 9.0 REQUIRED) -SET(CUDA_SEPARABLE_COMPILATION ON) + #set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} -arch=sm_30 --compiler-options '-fPIC'") -set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -arch=sm_61) find_package(CUDNN REQUIRED) diff --git a/cmake/getCudaArch.cu b/cmake/getCudaArch.cu new file mode 100644 index 0000000..1d66199 --- /dev/null +++ b/cmake/getCudaArch.cu @@ -0,0 +1,20 @@ +#include + +int main(int argc, char **argv){ + cudaDeviceProp dP; + float min_cc = 5.0; + + int rc = cudaGetDeviceProperties(&dP, 0); + if(rc != cudaSuccess) { + cudaError_t error = cudaGetLastError(); + printf("CUDA error: %s", cudaGetErrorString(error)); + return rc; /* Failure */ + } + if((dP.major+(dP.minor/10)) < min_cc) { + printf("Min Compute Capability of %2.1f required: %d.%d found\n Not Building CUDA Code", min_cc, dP.major, dP.minor); + return 1; /* Failure */ + } else { + printf("-arch=sm_%d%d", dP.major, dP.minor); + return 0; /* Success */ + } +} \ No newline at end of file diff --git a/include/tkDNN/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h index adc5554..1cbf55d 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -110,6 +110,6 @@ namespace nvinfer1 { static std::vector mPluginAttributes; std::string mPluginNamespace; }; - + REGISTER_TENSORRT_PLUGIN(DeformableConvRTPluginCreator); }; #endif -- 2.52.0 From eca10ac0a85339c97877de30416ac806280229f4 Mon Sep 17 00:00:00 2001 From: Micaela Verucchi Date: Sun, 19 Sep 2021 00:16:31 +0200 Subject: [PATCH 14/32] Update weights Signed-off-by: Micaela Verucchi --- tests/darknet/yolo4_berkeley_f1.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/darknet/yolo4_berkeley_f1.cpp b/tests/darknet/yolo4_berkeley_f1.cpp index 6dfbc63..b2f1139 100644 --- a/tests/darknet/yolo4_berkeley_f1.cpp +++ b/tests/darknet/yolo4_berkeley_f1.cpp @@ -17,7 +17,7 @@ int main() { std::string wgs_path = bin_path + "/layers"; std::string cfg_path = std::string(TKDNN_PATH) + "/tests/darknet/cfg/yolo4_berkeley.cfg"; std::string name_path = std::string(TKDNN_PATH) + "/tests/darknet/names/berkeley.names"; - downloadWeightsifDoNotExist(input_bins[0], bin_path, "https://cloud.hipert.unimore.it/s/M7WJdGoGDaDACnN/download"); + downloadWeightsifDoNotExist(input_bins[0], bin_path, "https://cloud.hipert.unimore.it/s/q9dwoqQ5YQqEi7s/download"); // parse darknet network tk::dnn::Network *net = tk::dnn::darknetParser(cfg_path, wgs_path, name_path); -- 2.52.0 From 54e7af11edfbcdc8751e9818841cee93f4e0c9ae Mon Sep 17 00:00:00 2001 From: perseusdg Date: Mon, 18 Oct 2021 18:07:57 +0530 Subject: [PATCH 15/32] tensorrt7 support for ipluginv2 --- include/tkDNN/pluginsRT/ActivationLeakyRT.h | 4 ++ .../tkDNN/pluginsRT/ActivationLogisticRT.h | 5 ++ include/tkDNN/pluginsRT/ActivationMishRT.h | 5 +- .../tkDNN/pluginsRT/ActivationReLUCeilingRT.h | 5 +- include/tkDNN/pluginsRT/DeformableConvRT.h | 5 +- include/tkDNN/pluginsRT/FlattenConcatRT.h | 4 ++ .../tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h | 4 ++ include/tkDNN/pluginsRT/RegionRT.h | 4 ++ include/tkDNN/pluginsRT/ReorgRT.h | 4 ++ include/tkDNN/pluginsRT/ReshapeRT.h | 4 ++ include/tkDNN/pluginsRT/ResizeLayerRT.h | 5 ++ include/tkDNN/pluginsRT/RouteRT.h | 4 ++ include/tkDNN/pluginsRT/ShortcutRT.h | 4 ++ include/tkDNN/pluginsRT/UpsampleRT.h | 4 ++ include/tkDNN/pluginsRT/YoloRT.h | 5 ++ src/pluginsRT/ActivationLeakyRT.cpp | 15 +++++- src/pluginsRT/ActivationLogisticRT.cpp | 10 +++- src/pluginsRT/ActivationMishRT.cpp | 12 +++++ src/pluginsRT/ActivationReLUCeilingRT.cpp | 11 +++- src/pluginsRT/DeformableConvRT.cpp | 50 ++++++++++++------- src/pluginsRT/FlattenConcatRT.cpp | 20 +++++++- src/pluginsRT/MaxPoolingSizeRT.cpp | 21 ++++---- src/pluginsRT/RegionRT.cpp | 32 ++++++++++-- src/pluginsRT/ReorgRT.cpp | 13 ++++- src/pluginsRT/ReshapeRT.cpp | 14 +++++- src/pluginsRT/ResizeLayerRT.cpp | 15 ++++-- src/pluginsRT/RouteRT.cpp | 21 ++++++-- src/pluginsRT/ShortcutRT.cpp | 19 +++++-- src/pluginsRT/UpsampleRT.cpp | 15 +++++- src/pluginsRT/YoloRT.cpp | 43 ++++++++++++---- 30 files changed, 313 insertions(+), 64 deletions(-) diff --git a/include/tkDNN/pluginsRT/ActivationLeakyRT.h b/include/tkDNN/pluginsRT/ActivationLeakyRT.h index ae395ef..1d98a59 100644 --- a/include/tkDNN/pluginsRT/ActivationLeakyRT.h +++ b/include/tkDNN/pluginsRT/ActivationLeakyRT.h @@ -27,8 +27,12 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, void const *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override; diff --git a/include/tkDNN/pluginsRT/ActivationLogisticRT.h b/include/tkDNN/pluginsRT/ActivationLogisticRT.h index 9646efc..d972752 100644 --- a/include/tkDNN/pluginsRT/ActivationLogisticRT.h +++ b/include/tkDNN/pluginsRT/ActivationLogisticRT.h @@ -28,8 +28,13 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif + size_t getSerializationSize() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/ActivationMishRT.h b/include/tkDNN/pluginsRT/ActivationMishRT.h index 3c9f15a..5b966cd 100644 --- a/include/tkDNN/pluginsRT/ActivationMishRT.h +++ b/include/tkDNN/pluginsRT/ActivationMishRT.h @@ -26,8 +26,11 @@ namespace nvinfer1 { void terminate() NOEXCEPT override ; size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h index b5c186c..1830945 100644 --- a/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h +++ b/include/tkDNN/pluginsRT/ActivationReLUCeilingRT.h @@ -25,8 +25,11 @@ namespace nvinfer1 { void terminate() NOEXCEPT override ; size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h index 1cbf55d..e0541ef 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -33,9 +33,12 @@ namespace nvinfer1 { void terminate() NOEXCEPT override ; size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; - +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index 7d655d3..b1e5327 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -25,7 +25,11 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h index 14f714e..723bed6 100644 --- a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h +++ b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h @@ -28,8 +28,12 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/RegionRT.h b/include/tkDNN/pluginsRT/RegionRT.h index cdcb515..400f2f0 100644 --- a/include/tkDNN/pluginsRT/RegionRT.h +++ b/include/tkDNN/pluginsRT/RegionRT.h @@ -30,8 +30,12 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/ReorgRT.h b/include/tkDNN/pluginsRT/ReorgRT.h index a780615..ced6b9c 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -27,8 +27,12 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override; diff --git a/include/tkDNN/pluginsRT/ReshapeRT.h b/include/tkDNN/pluginsRT/ReshapeRT.h index 8d3fdb5..a0cc718 100644 --- a/include/tkDNN/pluginsRT/ReshapeRT.h +++ b/include/tkDNN/pluginsRT/ReshapeRT.h @@ -31,7 +31,11 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/ResizeLayerRT.h b/include/tkDNN/pluginsRT/ResizeLayerRT.h index 7316048..a446698 100644 --- a/include/tkDNN/pluginsRT/ResizeLayerRT.h +++ b/include/tkDNN/pluginsRT/ResizeLayerRT.h @@ -29,8 +29,13 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif + size_t getSerializationSize() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/RouteRT.h b/include/tkDNN/pluginsRT/RouteRT.h index 2b9bc67..499b9da 100644 --- a/include/tkDNN/pluginsRT/RouteRT.h +++ b/include/tkDNN/pluginsRT/RouteRT.h @@ -29,7 +29,11 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override ; +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT override ; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/ShortcutRT.h b/include/tkDNN/pluginsRT/ShortcutRT.h index 7069180..29afc85 100644 --- a/include/tkDNN/pluginsRT/ShortcutRT.h +++ b/include/tkDNN/pluginsRT/ShortcutRT.h @@ -32,8 +32,12 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override; diff --git a/include/tkDNN/pluginsRT/UpsampleRT.h b/include/tkDNN/pluginsRT/UpsampleRT.h index 030fe5a..09f3547 100644 --- a/include/tkDNN/pluginsRT/UpsampleRT.h +++ b/include/tkDNN/pluginsRT/UpsampleRT.h @@ -30,8 +30,12 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override; diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index 0d895e0..9479f9f 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -34,8 +34,13 @@ namespace nvinfer1 { size_t getWorkspaceSize(int maxBatchSize) const NOEXCEPT override; + +#if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override; +#elif NV_TENSORRT_MAJOR == 7 + int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; +#endif size_t getSerializationSize() const NOEXCEPT override; diff --git a/src/pluginsRT/ActivationLeakyRT.cpp b/src/pluginsRT/ActivationLeakyRT.cpp index 77063f6..2a9bf33 100644 --- a/src/pluginsRT/ActivationLeakyRT.cpp +++ b/src/pluginsRT/ActivationLeakyRT.cpp @@ -42,6 +42,7 @@ size_t ActivationLeakyRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } +#if NV_TENSORRT_MAJOR > 7 int ActivationLeakyRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { activationLEAKYForward( @@ -51,6 +52,17 @@ int ActivationLeakyRT::enqueue(int batchSize, const void *const *inputs, void *c return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t ActivationLeakyRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + activationLEAKYForward( + (dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, slope, + stream); + return 0; +} +#endif + size_t ActivationLeakyRT::getSerializationSize() const NOEXCEPT { return 1 * sizeof(int) + 1 * sizeof(float); @@ -94,8 +106,7 @@ IPluginV2* ActivationLeakyRT::clone() const NOEXCEPT { } ActivationLeakyRTPluginCreator::ActivationLeakyRTPluginCreator() { - mPluginAttributes.emplace_back( - PluginField("slope", nullptr, PluginFieldType::kFLOAT32, 1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ActivationLogisticRT.cpp b/src/pluginsRT/ActivationLogisticRT.cpp index 9966708..a3c4ae7 100644 --- a/src/pluginsRT/ActivationLogisticRT.cpp +++ b/src/pluginsRT/ActivationLogisticRT.cpp @@ -38,13 +38,21 @@ void ActivationLogisticRT::terminate() NOEXCEPT {} size_t ActivationLogisticRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } - +#if NV_TENSORRT_MAJOR > 7 int ActivationLogisticRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { activationLOGISTICForward((dnnType *) reinterpret_cast(inputs[0]), reinterpret_cast(outputs[0]), batchSize * size, stream); return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t ActivationLogisticRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + activationLOGISTICForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, stream); + return 0; +} +#endif size_t ActivationLogisticRT::getSerializationSize() const NOEXCEPT { return 1 * sizeof(int); diff --git a/src/pluginsRT/ActivationMishRT.cpp b/src/pluginsRT/ActivationMishRT.cpp index 7797df9..d42b90a 100644 --- a/src/pluginsRT/ActivationMishRT.cpp +++ b/src/pluginsRT/ActivationMishRT.cpp @@ -38,12 +38,22 @@ void ActivationMishRT::terminate() NOEXCEPT {} size_t ActivationMishRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } +#if NV_TENSORRT_MAJOR > 7 int ActivationMishRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { activationMishForward((dnnType *) reinterpret_cast(inputs[0]), reinterpret_cast(outputs[0]), batchSize * size, stream); return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t ActivationMishRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + activationMishForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, stream); + return 0; +} +#endif + size_t ActivationMishRT::getSerializationSize() const NOEXCEPT { return 1 * sizeof(int); } @@ -80,6 +90,8 @@ IPluginV2 *ActivationMishRT::clone() const NOEXCEPT { return p; } + + ActivationMishRTPluginCreator::ActivationMishRTPluginCreator() { mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); diff --git a/src/pluginsRT/ActivationReLUCeilingRT.cpp b/src/pluginsRT/ActivationReLUCeilingRT.cpp index 80b5a74..c97d4ec 100644 --- a/src/pluginsRT/ActivationReLUCeilingRT.cpp +++ b/src/pluginsRT/ActivationReLUCeilingRT.cpp @@ -40,11 +40,20 @@ size_t ActivationReLUCeiling::getWorkspaceSize(int maxBatchSize) const NOEXCEPT return 0; } +#if NV_TENSORRT_MAJOR > 7 int ActivationReLUCeiling::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT { activationReLUCeilingForward((dnnType *) reinterpret_cast(inputs[0]), reinterpret_cast(outputs[0]), batchSize * size, ceiling, stream); return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t ActivationReLUCeiling::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + activationReLUCeilingForward((dnnType *) reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), batchSize * size, ceiling, stream); + return 0; +} +#endif size_t ActivationReLUCeiling::getSerializationSize() const NOEXCEPT { return 1 * sizeof(int) + 1 * sizeof(float); @@ -86,7 +95,7 @@ void ActivationReLUCeiling::setPluginNamespace(const char *pluginNamespace) NOEX } ActivationReLUCeilingPluginCreator::ActivationReLUCeilingPluginCreator() { - mPluginAttributes.emplace_back(PluginField("ceiling", nullptr, PluginFieldType::kFLOAT32, 1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/DeformableConvRT.cpp b/src/pluginsRT/DeformableConvRT.cpp index 417af8e..62f7555 100644 --- a/src/pluginsRT/DeformableConvRT.cpp +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -137,6 +137,7 @@ void DeformableConvRT::terminate() NOEXCEPT {} size_t DeformableConvRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT {return 0;} +#if NV_TENSORRT_MAJOR > 7 int DeformableConvRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -165,6 +166,36 @@ int DeformableConvRT::enqueue(int batchSize, const void *const *inputs, void *co } return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t DeformableConvRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *output_conv = (dnnType*)reinterpret_cast(inputs[1]); + + // split conv2d outputs into offset to mask + for(int b=0; b(outputs[0]), ones_d2, + kh, kw, + sh, sw, + ph, pw, + 1, 1, + deformableGroup, b, + i_n, i_c, i_h, i_w, + o_n, o_c, o_h, o_w, + chunk_dim); + } + return 0; +} +#endif size_t DeformableConvRT::getSerializationSize() const NOEXCEPT { return 16 * sizeof(int) + chunk_dim * 3 * sizeof(dnnType) + (i_c * o_c * kh * kw * 1 ) * sizeof(dnnType) + @@ -251,25 +282,8 @@ IPluginV2 *DeformableConvRT::clone() const NOEXCEPT { return p; } - DeformableConvRTPluginCreator::DeformableConvRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("chunk_dim",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("kh",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("kw",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("sh",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("sw",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("ph",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("pw",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("deformableGroup",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_n",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_w",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_n",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("defRT",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/FlattenConcatRT.cpp b/src/pluginsRT/FlattenConcatRT.cpp index 51cebc5..6687b58 100644 --- a/src/pluginsRT/FlattenConcatRT.cpp +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -54,6 +54,7 @@ size_t FlattenConcatRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } +#if NV_TENSORRT_MAJOR > 7 int FlattenConcatRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -69,6 +70,24 @@ int FlattenConcatRT::enqueue(int batchSize, const void *const *inputs, void *con } return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t FlattenConcatRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*rows*cols*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + + checkERROR( cublasSetStream(handle, stream) ); + for(int i=0; i 7 int MaxPoolFixedSizeRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -61,6 +62,16 @@ int MaxPoolFixedSizeRT::enqueue(int batchSize, const void *const *inputs, void * MaxPoolingForward(srcData, dstData, batchSize, this->c, this->h, this->w, this->stride_H, this->stride_W, this->winSize, this->padding, stream); return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t MaxPoolFixedSizeRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + MaxPoolingForward(srcData, dstData, batchSize, this->c, this->h, this->w, this->stride_H, this->stride_W, this->winSize, this->padding, stream); + return 0; +} +#endif + size_t MaxPoolFixedSizeRT::getSerializationSize() const NOEXCEPT { return 8*sizeof(int); @@ -110,16 +121,8 @@ IPluginV2 *MaxPoolFixedSizeRT::clone() const NOEXCEPT { return p; } - MaxPoolFixedSizeRTPluginCreator::MaxPoolFixedSizeRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("n",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("stride_H",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("stride_W",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("winSize",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("padding",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/RegionRT.cpp b/src/pluginsRT/RegionRT.cpp index de1dd3b..552db3e 100644 --- a/src/pluginsRT/RegionRT.cpp +++ b/src/pluginsRT/RegionRT.cpp @@ -43,6 +43,7 @@ void RegionRT::terminate() NOEXCEPT {} size_t RegionRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } +#if NV_TENSORRT_MAJOR > 7 int RegionRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -68,6 +69,32 @@ int RegionRT::enqueue(int batchSize, const void *const *inputs, void *const *out return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t RegionRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + + for (int b = 0; b < batchSize; ++b){ + for(int n = 0; n < num; ++n){ + int index = entry_index(b, n*w*h, 0); + activationLOGISTICForward(srcData + index, dstData + index, 2*w*h, stream); + + index = entry_index(b, n*w*h, coords); + activationLOGISTICForward(srcData + index, dstData + index, w*h, stream); + } + } + + //softmax start + int index = entry_index(0, 0, coords + 1); + softmaxForward( srcData + index, classes, batchSize*num, + (c*h*w)/num, + w*h, 1, w*h, 1, dstData + index, stream); + + return 0; +} +#endif size_t RegionRT::getSerializationSize() const NOEXCEPT { return 6*sizeof(int); @@ -112,11 +139,8 @@ IPluginV2 *RegionRT::clone() const NOEXCEPT { return p; } - RegionRTPluginCreator::RegionRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("coords",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ReorgRT.cpp b/src/pluginsRT/ReorgRT.cpp index d3dd12a..c2b0083 100644 --- a/src/pluginsRT/ReorgRT.cpp +++ b/src/pluginsRT/ReorgRT.cpp @@ -43,12 +43,22 @@ size_t ReorgRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } +#if NV_TENSORRT_MAJOR > 7 int ReorgRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace,cudaStream_t stream) NOEXCEPT { reorgForward((dnnType*)reinterpret_cast(inputs[0]), reinterpret_cast(outputs[0]), batchSize, c, h, w, stride, stream); return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t ReorgRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + reorgForward((dnnType*)reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), + batchSize, c, h, w, stride, stream); + return 0; +} +#endif + size_t ReorgRT::getSerializationSize() const NOEXCEPT { return 4*sizeof(int); @@ -93,9 +103,8 @@ IPluginV2 *ReorgRT::clone() const NOEXCEPT { return p; } - ReorgRTPluginCreator::ReorgRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp index 5e23ab3..127e244 100644 --- a/src/pluginsRT/ReshapeRT.cpp +++ b/src/pluginsRT/ReshapeRT.cpp @@ -43,6 +43,7 @@ size_t ReshapeRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } +#if NV_TENSORRT_MAJOR > 7 int ReshapeRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -51,6 +52,16 @@ int ReshapeRT::enqueue(int batchSize, const void *const *inputs, void *const *ou checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t ReshapeRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + return 0; +} +#endif + size_t ReshapeRT::getSerializationSize() const NOEXCEPT { return 4*sizeof(int); @@ -96,9 +107,8 @@ IPluginV2 *ReshapeRT::clone() const NOEXCEPT { return p; } - ReshapeRTPluginCreator::ReshapeRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("new_dim",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ResizeLayerRT.cpp b/src/pluginsRT/ResizeLayerRT.cpp index 12a3ff9..dd8c912 100644 --- a/src/pluginsRT/ResizeLayerRT.cpp +++ b/src/pluginsRT/ResizeLayerRT.cpp @@ -47,6 +47,7 @@ void ResizeLayerRT::terminate() NOEXCEPT {} size_t ResizeLayerRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } +#if NV_TENSORRT_MAJOR > 7 int ResizeLayerRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { resizeForward((dnnType*)reinterpret_cast(inputs[0]), @@ -54,6 +55,15 @@ int ResizeLayerRT::enqueue(int batchSize, const void *const *inputs, void *const batchSize, i_c, i_h, i_w, o_c, o_h, o_w, stream); return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t ResizeLayerRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + resizeForward((dnnType*)reinterpret_cast(inputs[0]), + reinterpret_cast(outputs[0]), + batchSize, i_c, i_h, i_w, o_c, o_h, o_w, stream); + return 0; +} +#endif size_t ResizeLayerRT::getSerializationSize() const NOEXCEPT { return 6*sizeof(int); @@ -101,11 +111,8 @@ IPluginV2 *ResizeLayerRT::clone() const NOEXCEPT { return p; } - ResizeLayerRTPluginCreator::ResizeLayerRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("o_c",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_h",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_w",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/RouteRT.cpp b/src/pluginsRT/RouteRT.cpp index 87233a5..3218622 100644 --- a/src/pluginsRT/RouteRT.cpp +++ b/src/pluginsRT/RouteRT.cpp @@ -60,6 +60,7 @@ size_t RouteRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } +#if NV_TENSORRT_MAJOR > 7 int RouteRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { dnnType *dstData = reinterpret_cast(outputs[0]); @@ -75,6 +76,22 @@ int RouteRT::enqueue(int batchSize, const void *const *inputs, void *const *outp } return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t RouteRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + dnnType *dstData = reinterpret_cast(outputs[0]); + for(int b=0; b(inputs[i]); + int in_dim = c_in[i]*h*w; + int part_in_dim = in_dim / this->groups; + checkCuda( cudaMemcpyAsync(dstData + b*c*w*h + offset, input + b*c*w*h*groups + this->group_id*part_in_dim, part_in_dim*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream) ); + offset += part_in_dim; + } + } + return 0; +} +#endif size_t RouteRT::getSerializationSize() const NOEXCEPT { return (6+MAX_INPUTS)*sizeof(int); @@ -124,10 +141,8 @@ IPluginV2 *RouteRT::clone() const NOEXCEPT { return p; } - RouteRTPluginCreator::RouteRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("groups",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("group_id",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ShortcutRT.cpp b/src/pluginsRT/ShortcutRT.cpp index eb35bd6..3cedffa 100644 --- a/src/pluginsRT/ShortcutRT.cpp +++ b/src/pluginsRT/ShortcutRT.cpp @@ -50,6 +50,7 @@ void ShortcutRT::terminate() NOEXCEPT {} size_t ShortcutRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } +#if NV_TENSORRT_MAJOR > 7 int ShortcutRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -61,6 +62,20 @@ int ShortcutRT::enqueue(int batchSize, const void *const *inputs, void *const *o return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t ShortcutRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *srcDataBack = (dnnType*)reinterpret_cast(inputs[1]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + shortcutForward(srcDataBack, dstData, batchSize, c, h, w, 1, batchSize, bc, bh, bw, 1, mul, stream); + + return 0; +} +#endif + size_t ShortcutRT::getSerializationSize() const NOEXCEPT { return 6*sizeof(int) + sizeof(bool); @@ -108,10 +123,8 @@ IPluginV2 *ShortcutRT::clone() const NOEXCEPT { return p; } - ShortcutRTPluginCreator::ShortcutRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("bDim",nullptr,PluginFieldType::kUNKNOWN,1)); - mPluginAttributes.emplace_back(PluginField("mul",nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/UpsampleRT.cpp b/src/pluginsRT/UpsampleRT.cpp index 044405b..d08a3ca 100644 --- a/src/pluginsRT/UpsampleRT.cpp +++ b/src/pluginsRT/UpsampleRT.cpp @@ -44,6 +44,7 @@ size_t UpsampleRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } +#if NV_TENSORRT_MAJOR > 7 int UpsampleRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -53,6 +54,17 @@ int UpsampleRT::enqueue(int batchSize, const void *const *inputs, void *const *o upsampleForward(srcData, dstData, batchSize, c, h, w, stride, 1, 1, stream); return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t UpsampleRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, + cudaStream_t stream) { + dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + fill(dstData, batchSize*c*h*w*stride*stride, 0.0, stream); + upsampleForward(srcData, dstData, batchSize, c, h, w, stride, 1, 1, stream); + return 0; +} +#endif size_t UpsampleRT::getSerializationSize() const NOEXCEPT { return 4*sizeof(int); @@ -97,9 +109,8 @@ IPluginV2 *UpsampleRT::clone() const NOEXCEPT { return p; } - UpsampleRTPluginCreator::UpsampleRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("stride",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp index 7f615b4..c191afd 100644 --- a/src/pluginsRT/YoloRT.cpp +++ b/src/pluginsRT/YoloRT.cpp @@ -85,6 +85,7 @@ size_t YoloRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { return 0; } +#if NV_TENSORRT_MAJOR > 7 int YoloRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { dnnType *srcData = (dnnType *) reinterpret_cast(inputs[0]); @@ -115,6 +116,38 @@ int YoloRT::enqueue(int batchSize, const void *const *inputs, void *const *outpu //std::cout<<"YOLO END\n"; return 0; } +#elif NV_TENSORRT_MAJOR == 7 +int32_t YoloRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + dnnType *srcData = (dnnType *) reinterpret_cast(inputs[0]); + dnnType *dstData = reinterpret_cast(outputs[0]); + + checkCuda(cudaMemcpyAsync(dstData, srcData, batchSize * c * h * w * sizeof(dnnType), cudaMemcpyDeviceToDevice, + stream)); + + + for (int b = 0; b < batchSize; ++b) { + for (int n = 0; n < n_masks; ++n) { + int index = entry_index(b, n * w * h, 0); + if (new_coords == 1) { + if (this->scaleXY != 1) + scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); + } else { + activationLOGISTICForward(srcData + index, dstData + index, 2 * w * h, stream); //x,y + + if (this->scaleXY != 1) + scalAdd(dstData + index, 2 * w * h, this->scaleXY, -0.5 * (this->scaleXY - 1), 1); + + index = entry_index(b, n * w * h, 4); + activationLOGISTICForward(srcData + index, dstData + index, (1 + classes) * w * h, stream); + } + } + } + + //std::cout<<"YOLO END\n"; + return 0; +} +#endif + size_t YoloRT::getSerializationSize() const NOEXCEPT { return 8 * sizeof(int) + 2 * sizeof(float) + n_masks * sizeof(dnnType) + num * n_masks * 2 * sizeof(dnnType) + @@ -182,16 +215,8 @@ IPluginV2 *YoloRT::clone() const NOEXCEPT { return p; } - YoloRTPluginCreator::YoloRTPluginCreator() { - mPluginAttributes.emplace_back(PluginField("classes",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("num",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("yolo",nullptr,PluginFieldType::kUNKNOWN,1)); - mPluginAttributes.emplace_back(PluginField("numMasks",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("scaleXY",nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("nmsThresh",nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("nmsKind",nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("newCoords",nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } -- 2.52.0 From 8c36dd04316af051438090dd78f517c23e071973 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Wed, 27 Oct 2021 18:00:33 +0530 Subject: [PATCH 16/32] mobilenet works with trt7(IPluginV2IOExt) ,need to test it with trt8 --- CMakeLists.txt | 12 ++-- include/tkDNN/Layer.h | 2 + include/tkDNN/pluginsRT/FlattenConcatRT.h | 29 ++++++---- src/Flatten.cpp | 5 ++ src/NetworkRT.cpp | 6 +- src/pluginsRT/FlattenConcatRT.cpp | 69 ++++++++++++++++------- src/pluginsRT/ReshapeRT.cpp | 5 +- 7 files changed, 88 insertions(+), 40 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index c10f6ac..bfdb426 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -51,13 +51,13 @@ endif() if(WIN32) if(CMAKE_BUILD_TYPE MATCHES Release) - set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc") - set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -arch=sm_61) + set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc /Md") + set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) endif() if(CMAKE_BUILD_TYPE MATCHES Debug) - set(CMAKE_CXX_FLAGS "/Od /FS /EHsc") - set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -arch=sm_61 -G -g) + set(CMAKE_CXX_FLAGS "/Od /FS /EHsc /MDd") + set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32 -G -g) endif() set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON) endif(WIN32) @@ -92,7 +92,7 @@ include_directories(${CUDNN_INCLUDE_DIR}) file(GLOB tkdnn_CUSRC "src/kernels/*.cu" "src/sorting.cu" "src/pluginsRT/*.cpp") cuda_include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include ${CUDA_INCLUDE_DIRS} ${CUDNN_INCLUDE_DIRS}) cuda_add_library(kernels SHARED ${tkdnn_CUSRC}) -target_link_libraries(kernels ${CUDA_CUBLAS_LIBRAY} ${CUDA_LIBRARIES} ${CUDNN_LIBRARIES}) +target_link_libraries(kernels ${CUDA_CUBLAS_LIBRARIES} ${CUDA_LIBRARIES} ${CUDNN_LIBRARIES}) @@ -121,7 +121,7 @@ set(tkdnn_LIBS kernels ${CUDA_LIBRARIES} ${CUDA_CUBLAS_LIBRARIES} ${CUDNN_LIBRAR set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include ${CUDA_INCLUDE_DIRS} ${OPENCV_INCLUDE_DIRS} ${NVINFER_INCLUDES}) add_library(tkDNN SHARED ${tkdnn_SRC}) -target_link_libraries(tkDNN ${tkdnn_LIBS} ${CUDA_CUBLAS_LIBRAY}) +target_link_libraries(tkDNN ${tkdnn_LIBS} ${CUDA_CUBLAS_LIBRARIES}) #static #add_library(tkDNN_static STATIC ${tkdnn_SRC}) diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index 0c1c5ca..d08e517 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -423,6 +423,8 @@ public: virtual layerType_t getLayerType() { return LAYER_FLATTEN; }; virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); + + int c, h, w, rows, cols; }; /** diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index b1e5327..aa8f078 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -3,10 +3,10 @@ #include #include namespace nvinfer1 { - class FlattenConcatRT : public IPluginV2 { + class FlattenConcatRT : public IPluginV2IOExt { public: - FlattenConcatRT() ; + FlattenConcatRT(int c,int h,int w,int rows,int cols) ; FlattenConcatRT(const void *data, size_t length) ; @@ -16,9 +16,6 @@ namespace nvinfer1 { Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override ; - int initialize() NOEXCEPT override ; void terminate() NOEXCEPT override ; @@ -37,8 +34,6 @@ namespace nvinfer1 { void destroy() NOEXCEPT override ; - bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - const char *getPluginType() const NOEXCEPT override ; const char *getPluginVersion() const NOEXCEPT override; @@ -47,7 +42,21 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override ; + IPluginV2IOExt *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void configurePlugin(const PluginTensorDesc* in, int nbInput, const PluginTensorDesc* out, int nbOutput) NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + bool supportsFormatCombination(int pos, const PluginTensorDesc* inOut, int nbInputs, int nbOutputs) const NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; int c, h, w; int rows, cols; @@ -65,9 +74,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2IOExt *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2IOExt *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; diff --git a/src/Flatten.cpp b/src/Flatten.cpp index 8906c88..0eb690c 100644 --- a/src/Flatten.cpp +++ b/src/Flatten.cpp @@ -15,6 +15,11 @@ Flatten::Flatten(Network *net) : Layer(net) { output_dim.w = 1; output_dim.l = 1; + this->h = 1; + this->w = 1; + this->rows = input_dim.w; + this->cols = input_dim.h * input_dim.c; + this->c = input_dim.w * input_dim.h * input_dim.c; } Flatten::~Flatten() { diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 4b3d532..0537e6a 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -18,9 +18,9 @@ using namespace nvinfer1; // Logger for info/warning/errors class Logger : public ILogger { void log(Severity severity, const char* msg) NOEXCEPT override { -#ifdef DEBUG +//#ifdef DEBUG std::cout <<"TENSORRT LOG: "<< msg << std::endl; -#endif +//#endif } } loggerRT; @@ -473,7 +473,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { ILayer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { - IPluginV2 *plugin = new FlattenConcatRT(); + IPluginV2IOExt *plugin = new FlattenConcatRT(l->c,l->h,l->w,l->rows,l->cols); IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; diff --git a/src/pluginsRT/FlattenConcatRT.cpp b/src/pluginsRT/FlattenConcatRT.cpp index 6687b58..6c54e47 100644 --- a/src/pluginsRT/FlattenConcatRT.cpp +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -4,12 +4,17 @@ using namespace nvinfer1; std::vector FlattenConcatRTPluginCreator::mPluginAttributes; PluginFieldCollection FlattenConcatRTPluginCreator::mFC{}; -FlattenConcatRT::FlattenConcatRT() { +FlattenConcatRT::FlattenConcatRT(int c, int h, int w, int rows, int cols) { stat = cublasCreate(&handle); if (stat != CUBLAS_STATUS_SUCCESS) { printf ("CUBLAS initialization failed\n"); return; } + this->c = c; + this->h = h; + this->w = w; + this->rows = rows; + this->cols = cols; } FlattenConcatRT::FlattenConcatRT(const void *data, size_t length) { @@ -32,16 +37,6 @@ Dims FlattenConcatRT::getOutputDimensions(int index, const Dims *inputs, int nbI return Dims3{ inputs[0].d[0] * inputs[0].d[1] * inputs[0].d[2], 1, 1}; } -void FlattenConcatRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, - DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { - assert(nbOutputs == 1 && nbInputs ==1); - rows = inputDims[0].d[0]; - cols = inputDims[0].d[1] * inputDims[0].d[2]; - c = inputDims[0].d[0] * inputDims[0].d[1] * inputDims[0].d[2]; - h = 1; - w = 1; -} - int FlattenConcatRT::initialize() NOEXCEPT { return 0; } @@ -107,9 +102,7 @@ void FlattenConcatRT::destroy() NOEXCEPT { delete this; } -bool FlattenConcatRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; -} + const char *FlattenConcatRT::getPluginType() const NOEXCEPT { return "FlattenConcatRT_tkDNN"; @@ -127,12 +120,44 @@ void FlattenConcatRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2 *FlattenConcatRT::clone() const NOEXCEPT { - auto *p = new FlattenConcatRT(); +IPluginV2IOExt *FlattenConcatRT::clone() const NOEXCEPT { + auto* p = new FlattenConcatRT(c, h, w, rows, cols); p->setPluginNamespace(mPluginNamespace.c_str()); return p; } +DataType FlattenConcatRT::getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT +{ + return DataType::kFLOAT; +} + +void FlattenConcatRT::configurePlugin(const PluginTensorDesc* in, int nbInput, const PluginTensorDesc* out, int nbOutput) NOEXCEPT +{ +} + +void FlattenConcatRT::attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT +{ +} + +bool FlattenConcatRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT +{ + return false; +} + +bool FlattenConcatRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT +{ + return false; +} + +bool FlattenConcatRT::supportsFormatCombination(int pos, const PluginTensorDesc* inOut, int nbInputs, int nbOutputs) const NOEXCEPT +{ + return true; +} + +void FlattenConcatRT::detachFromContext() NOEXCEPT +{ +} + FlattenConcatRTPluginCreator::FlattenConcatRTPluginCreator() { mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); @@ -147,15 +172,21 @@ const char *FlattenConcatRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *FlattenConcatRTPluginCreator::deserializePlugin(const char *name, const void *serialData, +IPluginV2IOExt *FlattenConcatRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { auto *pluginObj = new FlattenConcatRT(serialData,serialLength); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } -IPluginV2 *FlattenConcatRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { - auto *pluginObj = new FlattenConcatRT(); +IPluginV2IOExt *FlattenConcatRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { + const PluginField* fields = fc->fields; + int c = *(static_cast(fields[0].data)); + int h = *(static_cast(fields[1].data)); + int w = *(static_cast(fields[2].data)); + int rows = *(static_cast(fields[3].data)); + int cols = *(static_cast(fields[4].data)); + auto* pluginObj = new FlattenConcatRT(c, h, w, rows, cols); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp index 127e244..f364ab0 100644 --- a/src/pluginsRT/ReshapeRT.cpp +++ b/src/pluginsRT/ReshapeRT.cpp @@ -54,10 +54,11 @@ int ReshapeRT::enqueue(int batchSize, const void *const *inputs, void *const *ou } #elif NV_TENSORRT_MAJOR == 7 int32_t ReshapeRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { + std::cout << new_dim.c << ":" << new_dim.h << std::endl; dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *dstData = reinterpret_cast(outputs[0]); - - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + std::cout << "C : " << c << "H : " << h << "w :" << w << std::endl; + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*new_dim.c*new_dim.h*new_dim.w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); return 0; } #endif -- 2.52.0 From c5e66c6bf637fe6eb8199fb02c49c8c8e750b242 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Thu, 28 Oct 2021 23:35:37 +0530 Subject: [PATCH 17/32] TRT8 works with almost every nerual network now!!!!(including demo3d) --- demo/demo/demo.cpp | 23 +- demo/demo/map.cpp | 21 +- include/tkDNN/Layer.h | 5 + include/tkDNN/pluginsRT/DeformableConvRT.h | 51 ++- include/tkDNN/pluginsRT/FlattenConcatRT.h | 22 +- .../tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h | 28 +- include/tkDNN/pluginsRT/RegionRT.h | 31 +- include/tkDNN/pluginsRT/ReorgRT.h | 29 +- include/tkDNN/pluginsRT/ReshapeRT.h | 29 +- include/tkDNN/pluginsRT/ResizeLayerRT.h | 36 +- include/tkDNN/pluginsRT/ShortcutRT.h | 27 +- include/tkDNN/pluginsRT/UpsampleRT.h | 36 +- include/tkDNN/pluginsRT/YoloRT.h | 35 +- src/Flatten.cpp | 4 +- src/NetworkRT.cpp | 416 ++++++------------ src/Region.cpp | 1 - src/Reshape.cpp | 5 +- src/Shortcut.cpp | 3 + src/Upsample.cpp | 3 + src/pluginsRT/DeformableConvRT.cpp | 234 ++++++---- src/pluginsRT/FlattenConcatRT.cpp | 50 ++- src/pluginsRT/MaxPoolingSizeRT.cpp | 42 +- src/pluginsRT/RegionRT.cpp | 79 +++- src/pluginsRT/ReorgRT.cpp | 74 +++- src/pluginsRT/ReshapeRT.cpp | 88 +++- src/pluginsRT/ResizeLayerRT.cpp | 71 ++- src/pluginsRT/ShortcutRT.cpp | 96 ++-- src/pluginsRT/UpsampleRT.cpp | 73 ++- src/pluginsRT/YoloRT.cpp | 117 +++-- tests/centernet/dla34_cnet/dla34_cnet.cpp | 1 + tests/centernet/dla34_cnet3d/dla34_cnet3d.cpp | 1 + .../resnet101_cnet/resnet101_cnet.cpp | 1 + .../mobilenetv2ssd/mobilenetv2ssd.cpp | 2 +- .../mobilenetv2ssd512/mobilenetv2ssd512.cpp | 2 +- tests/shelfnet/shelfnet.cpp | 2 +- tests/shelfnet/shelfnet_berkeley.cpp | 2 +- tests/shelfnet/shelfnet_mapillary.cpp | 2 +- 37 files changed, 1042 insertions(+), 700 deletions(-) diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index d597da9..fbfbb6f 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -43,19 +43,18 @@ int main(int argc, char *argv[]) { std::string input = "..\\..\\..\\demo\\yolo_test.mp4"; #endif - - if(argc > 2) - cfgPath = argv[3]; - if(argc > 3) - namePath = argv[4]; - if(argc > 4) - input = argv[5]; char ntype = 'y'; - if(argc > 5) + if(argc > 2) ntype = argv[2][0]; int n_classes = 80; + if(argc > 3) + n_classes = atoi(argv[3]); + if(argc > 4) + cfgPath = argv[4]; + if(argc > 5) + namePath = argv[5]; if(argc > 6) - n_classes = atoi(argv[6]); + input = argv[6]; int n_batch = 1; if(argc > 7) n_batch = atoi(argv[7]); @@ -63,7 +62,7 @@ int main(int argc, char *argv[]) { if(argc > 8) show = atoi(argv[8]); float conf_thresh=0.3; - if(argc > 9) + if(argc >= 9) conf_thresh = atof(argv[9]); if(n_batch < 1 || n_batch > 64) @@ -73,8 +72,8 @@ int main(int argc, char *argv[]) { SAVE_RESULT = true; if(ntype == 'c' || ntype == 'm'){ - cfgPath = nullptr; - namePath = nullptr; + cfgPath = ""; + namePath = ""; } tk::dnn::Yolo3Detection yolo; diff --git a/demo/demo/map.cpp b/demo/demo/map.cpp index 8486202..70bab07 100644 --- a/demo/demo/map.cpp +++ b/demo/demo/map.cpp @@ -32,7 +32,7 @@ int main(int argc, char *argv[]) { char ntype = 'y'; const char *config_filename = "../demo/config.yaml"; - const char * net = "yolo3.rt"; + const char * net = "yolo4tiny_fp32.rt"; const char * labels_path = "../demo/COCO_val2017/all_labels.txt"; int n_batches = 1; float confidence_thresh = 0.3; @@ -45,7 +45,8 @@ int main(int argc, char *argv[]) bool verbose; int classes, map_points, map_levels; float map_step, IoU_thresh, conf_thresh; - + std::string cfg_path = "../tests/darknet/cfg/yolo4tiny.cfg"; + std::string name_path = "../tests/darknet/names/coco.names"; double vm_total = 0, rss_total = 0; double vm, rss; @@ -53,15 +54,19 @@ int main(int argc, char *argv[]) if(argc > 1) net = argv[1]; if(argc > 2) - ntype = argv[2][0]; + ntype = argv[2][0]; if(argc > 3) - labels_path = argv[3]; + cfg_path = argv[3]; if(argc > 4) - config_filename = argv[4]; + name_path = argv[4]; if(argc > 5) - n_batches = atoi(argv[5]); + labels_path = argv[5]; if(argc > 6) - confidence_thresh = atof(argv[6]); + config_filename = argv[6]; + if(argc > 7) + n_batches = atoi(argv[7]); + if(argc > 8) + confidence_thresh = atof(argv[8]); std::cout<<"conf t: "<init(net, n_classes, 1, conf_thresh); + detNN->init(net,cfg_path,name_path,n_classes, 1, conf_thresh); //read images std::ifstream all_labels(labels_path); diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index d08e517..e09e5fa 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -438,6 +438,7 @@ public: virtual layerType_t getLayerType() { return LAYER_RESHAPE; }; virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); + int n,c,h,w; }; @@ -584,6 +585,8 @@ public: virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); + int c,h,w; + public: Layer *backLayer; bool mul = false; @@ -604,6 +607,7 @@ public: int stride; bool reverse; + int c,h,w; }; struct box { @@ -687,6 +691,7 @@ public: virtual layerType_t getLayerType() { return LAYER_REGION; }; int classes, coords, num; + int c,h,w; virtual dnnType* infer(dataDim_t &dim, dnnType* srcData); }; diff --git a/include/tkDNN/pluginsRT/DeformableConvRT.h b/include/tkDNN/pluginsRT/DeformableConvRT.h index e0541ef..9170e15 100644 --- a/include/tkDNN/pluginsRT/DeformableConvRT.h +++ b/include/tkDNN/pluginsRT/DeformableConvRT.h @@ -8,14 +8,15 @@ #include namespace nvinfer1 { - class DeformableConvRT : public IPluginV2 { + class DeformableConvRT : public IPluginV2Ext { public: DeformableConvRT(int chunk_dim, int kh, int kw, int sh, int sw, int ph, int pw, int deformableGroup, int i_n, int i_c, int i_h, int i_w, - int o_n, int o_c, int o_h, int o_w, - tk::dnn::DeformConv2d *deformable = nullptr); + int o_n, int o_c, int o_h, int o_w,std::vector data_H,std::vector bias2_H, + std::vector ones_d1_h,std::vector ones_d2_h,std::vector offsetH,std::vector maskH,int height_ones, + int width_ones,int dim_ones); ~DeformableConvRT(); @@ -25,9 +26,6 @@ namespace nvinfer1 { Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override ; - int initialize() NOEXCEPT override ; void terminate() NOEXCEPT override ; @@ -56,11 +54,26 @@ namespace nvinfer1 { const char *getPluginVersion() const NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override ; + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; cublasStatus_t stat; - cublasHandle_t handle; + cublasHandle_t handle{nullptr}; int i_n, i_c, i_h, i_w; int o_n, o_c, o_h, o_w; int size; @@ -73,12 +86,18 @@ namespace nvinfer1 { int width_ones; int dim_ones; - dnnType *data_d; - dnnType *bias2_d; - dnnType *ones_d1; - dnnType *offset; - dnnType *mask; - dnnType *ones_d2; + std::vector data_d_v; + std::vector bias2_d_v; + std::vector ones_d1_v; + std::vector offset_v; + std::vector mask_v; + std::vector ones_d2_v; + dnnType* data_d; + dnnType* bias2_d; + dnnType* ones_d1; + dnnType* offset; + dnnType* mask; + dnnType* ones_d2; // dnnType *input_n; // dnnType *offset_n; // dnnType *mask_n; @@ -99,9 +118,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/FlattenConcatRT.h b/include/tkDNN/pluginsRT/FlattenConcatRT.h index aa8f078..02ff596 100644 --- a/include/tkDNN/pluginsRT/FlattenConcatRT.h +++ b/include/tkDNN/pluginsRT/FlattenConcatRT.h @@ -3,7 +3,7 @@ #include #include namespace nvinfer1 { - class FlattenConcatRT : public IPluginV2IOExt { + class FlattenConcatRT : public IPluginV2Ext { public: FlattenConcatRT(int c,int h,int w,int rows,int cols) ; @@ -24,7 +24,7 @@ namespace nvinfer1 { #if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; -#elif NV_TENSORRT_MAJOR == 7 +#elif NV_TENSORRT_MAJOR <= 7 int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; #endif @@ -42,26 +42,28 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - IPluginV2IOExt *clone() const NOEXCEPT override ; + IPluginV2Ext *clone() const NOEXCEPT override ; DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; - void configurePlugin(const PluginTensorDesc* in, int nbInput, const PluginTensorDesc* out, int nbOutput) NOEXCEPT override; - void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; - bool supportsFormatCombination(int pos, const PluginTensorDesc* inOut, int nbInputs, int nbOutputs) const NOEXCEPT override; + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; void detachFromContext() NOEXCEPT override; + bool supportsFormat (DataType type, PluginFormat format) const NOEXCEPT override; + int c, h, w; int rows, cols; - cublasStatus_t stat; - cublasHandle_t handle; + cublasHandle_t handle{nullptr}; private: std::string mPluginNamespace; }; @@ -74,9 +76,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2IOExt *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2IOExt *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h index 723bed6..95e15f4 100644 --- a/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h +++ b/include/tkDNN/pluginsRT/MaxPoolingFixedSizeRT.h @@ -6,7 +6,7 @@ namespace nvinfer1 { - class MaxPoolFixedSizeRT : public IPluginV2 { + class MaxPoolFixedSizeRT : public IPluginV2Ext { public: MaxPoolFixedSizeRT(int c, int h, int w, int n, int strideH, int strideW, int winSize, int padding) ; @@ -19,9 +19,6 @@ namespace nvinfer1 { Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override ; - int initialize() NOEXCEPT override ; void terminate() NOEXCEPT override ; @@ -31,7 +28,7 @@ namespace nvinfer1 { #if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; -#elif NV_TENSORRT_MAJOR == 7 +#elif NV_TENSORRT_MAJOR <= 7 int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; #endif @@ -52,7 +49,22 @@ namespace nvinfer1 { const char *getPluginVersion() const NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override ; + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; int n, c, h, w; @@ -72,9 +84,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/RegionRT.h b/include/tkDNN/pluginsRT/RegionRT.h index 400f2f0..7f7157c 100644 --- a/include/tkDNN/pluginsRT/RegionRT.h +++ b/include/tkDNN/pluginsRT/RegionRT.h @@ -7,10 +7,10 @@ #include namespace nvinfer1 { - class RegionRT : public IPluginV2 { + class RegionRT : public IPluginV2Ext { public: - RegionRT(int classes, int coords, int num); + RegionRT(int classes, int coords, int num,int c,int h,int w); ~RegionRT() ; @@ -20,9 +20,6 @@ namespace nvinfer1 { Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override ; - int initialize() NOEXCEPT override ; @@ -32,7 +29,7 @@ namespace nvinfer1 { #if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, - cudaStream_t stream) NOEXCEPT override ; + cudaStream_t stream) NOEXCEPT override ; #elif NV_TENSORRT_MAJOR == 7 int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; #endif @@ -54,7 +51,22 @@ namespace nvinfer1 { bool supportsFormat(DataType type, PluginFormat format) const NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override ; + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + + IPluginV2Ext *clone() const NOEXCEPT override ; int c, h, w; int classes, coords, num; @@ -76,9 +88,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; @@ -96,4 +108,3 @@ namespace nvinfer1 { }; #endif - diff --git a/include/tkDNN/pluginsRT/ReorgRT.h b/include/tkDNN/pluginsRT/ReorgRT.h index ced6b9c..be163a5 100644 --- a/include/tkDNN/pluginsRT/ReorgRT.h +++ b/include/tkDNN/pluginsRT/ReorgRT.h @@ -4,10 +4,10 @@ #include namespace nvinfer1 { - class ReorgRT : public IPluginV2 { + class ReorgRT : public IPluginV2Ext { public: - ReorgRT(int stride); + ReorgRT(int stride,int c,int h,int w); ~ReorgRT(); @@ -17,10 +17,6 @@ namespace nvinfer1 { Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - void - configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override; - int initialize() NOEXCEPT override; void terminate() NOEXCEPT override; @@ -51,7 +47,22 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - IPluginV2 *clone() const NOEXCEPT override; + IPluginV2Ext *clone() const NOEXCEPT override; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; int c, h, w, stride; private: @@ -66,9 +77,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; const char *getPluginName() const NOEXCEPT override; diff --git a/include/tkDNN/pluginsRT/ReshapeRT.h b/include/tkDNN/pluginsRT/ReshapeRT.h index a0cc718..e56c79c 100644 --- a/include/tkDNN/pluginsRT/ReshapeRT.h +++ b/include/tkDNN/pluginsRT/ReshapeRT.h @@ -9,10 +9,10 @@ using namespace tk::dnn; namespace nvinfer1 { - class ReshapeRT : public IPluginV2 { + class ReshapeRT : public IPluginV2Ext { public: - explicit ReshapeRT(dataDim_t newDim) ; + ReshapeRT(int n,int c,int h,int w) ; ReshapeRT(const void *data, size_t length) ; @@ -22,8 +22,6 @@ namespace nvinfer1 { Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override ; int initialize() NOEXCEPT override ; @@ -53,9 +51,24 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override ; + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + int n, c, h, w; - dataDim_t new_dim; private: std::string mPluginNamespace; }; @@ -68,9 +81,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; diff --git a/include/tkDNN/pluginsRT/ResizeLayerRT.h b/include/tkDNN/pluginsRT/ResizeLayerRT.h index a446698..750057e 100644 --- a/include/tkDNN/pluginsRT/ResizeLayerRT.h +++ b/include/tkDNN/pluginsRT/ResizeLayerRT.h @@ -6,10 +6,10 @@ namespace nvinfer1 { - class ResizeLayerRT : public IPluginV2 { + class ResizeLayerRT : public IPluginV2Ext { public: - ResizeLayerRT(int c, int h, int w) ; + ResizeLayerRT(int oc, int oh, int ow,int ic,int ih,int iw) ; ResizeLayerRT(const void *data, size_t length) ; @@ -19,10 +19,6 @@ namespace nvinfer1 { Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override ; - - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override ; - int initialize() NOEXCEPT override ; void terminate() NOEXCEPT override ; @@ -32,12 +28,10 @@ namespace nvinfer1 { #if NV_TENSORRT_MAJOR > 7 int enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT override ; -#elif NV_TENSORRT_MAJOR == 7 +#elif NV_TENSORRT_MAJOR <= 7 int32_t enqueue (int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override; #endif - - size_t getSerializationSize() const NOEXCEPT override ; void serialize(void *buffer) const NOEXCEPT override ; @@ -54,7 +48,22 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override ; - IPluginV2 *clone() const NOEXCEPT override ; + IPluginV2Ext *clone() const NOEXCEPT override ; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; int i_c, i_h, i_w, o_c, o_h, o_w; @@ -70,9 +79,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override ; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override ; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override ; const char *getPluginName() const NOEXCEPT override ; @@ -80,6 +89,9 @@ namespace nvinfer1 { const PluginFieldCollection *getFieldNames() NOEXCEPT override ; + + + private: static PluginFieldCollection mFC; static std::vector mPluginAttributes; diff --git a/include/tkDNN/pluginsRT/ShortcutRT.h b/include/tkDNN/pluginsRT/ShortcutRT.h index 29afc85..0c01b9d 100644 --- a/include/tkDNN/pluginsRT/ShortcutRT.h +++ b/include/tkDNN/pluginsRT/ShortcutRT.h @@ -10,10 +10,10 @@ namespace nvinfer1 { - class ShortcutRT : public IPluginV2 { + class ShortcutRT : public IPluginV2Ext { public: - ShortcutRT(tk::dnn::dataDim_t bdim, bool mul); + ShortcutRT(int bc,int bh,int bw,int c,int h,int w ,bool mul); ~ShortcutRT(); @@ -23,8 +23,19 @@ namespace nvinfer1 { Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override; + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, int32_t nbOutputs, + DataType const *inputTypes, DataType const *outputTypes, bool const *inputIsBroadcast, + bool const *outputIsBroadcast, PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch (int32_t outputIndex, bool const *inputIsBroadcasted, int32_t nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch (int32_t inputIndex) const NOEXCEPT override; + + void attachToContext (cudnnContext *, cublasContext *, IGpuAllocator *) NOEXCEPT override; + + void detachFromContext () NOEXCEPT override; + + DataType getOutputDataType(int32_t index, nvinfer1::DataType const *inputTypes, int32_t nbInputs) const NOEXCEPT override; int initialize() NOEXCEPT override; @@ -56,10 +67,10 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - IPluginV2 *clone() const NOEXCEPT override; + IPluginV2Ext *clone() const NOEXCEPT override; int c, h, w; - int bc, bh, bw; + int bc, bh, bw,bl; bool mul; tk::dnn::dataDim_t bDim; private: @@ -75,9 +86,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; const char *getPluginName() const NOEXCEPT override; diff --git a/include/tkDNN/pluginsRT/UpsampleRT.h b/include/tkDNN/pluginsRT/UpsampleRT.h index 09f3547..4379ee7 100644 --- a/include/tkDNN/pluginsRT/UpsampleRT.h +++ b/include/tkDNN/pluginsRT/UpsampleRT.h @@ -8,10 +8,10 @@ namespace nvinfer1 { - class UpsampleRT : public IPluginV2 { + class UpsampleRT : public IPluginV2Ext { public: - explicit UpsampleRT(int stride); + UpsampleRT(int stride,int c,int h,int w); UpsampleRT(const void *data, size_t length); @@ -21,9 +21,6 @@ namespace nvinfer1 { Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override; - int initialize() NOEXCEPT override; void terminate() NOEXCEPT override; @@ -54,12 +51,27 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - IPluginV2 *clone() const NOEXCEPT override ; + IPluginV2Ext *clone() const NOEXCEPT override ; - int c, h, w, stride; - private: - std::string mPluginNamespace; - }; + bool isOutputBroadcastAcrossBatch (int32_t outputIndex, bool const *inputIsBroadcasted, int32_t nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch (int32_t inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, int32_t nbOutputs, + DataType const *inputTypes, DataType const *outputTypes, bool const *inputIsBroadcast, + bool const *outputIsBroadcast, PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT override; + + void attachToContext (cudnnContext *, cublasContext *, IGpuAllocator *) NOEXCEPT override; + + void detachFromContext () NOEXCEPT override; + + DataType getOutputDataType (int32_t index, nvinfer1::DataType const *inputTypes, int32_t nbInputs) const NOEXCEPT override; + + + int c, h, w, stride; + private: + std::string mPluginNamespace; + }; class UpsampleRTPluginCreator : public IPluginCreator { public: @@ -69,9 +81,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; const char *getPluginName() const NOEXCEPT override; diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index 9479f9f..42ebcc7 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -10,10 +10,11 @@ #define YOLORT_CLASSNAME_W 256 namespace nvinfer1 { - class YoloRT : public IPluginV2 { + class YoloRT : public IPluginV2Ext { public: - YoloRT(int classes, int num, tk::dnn::Yolo *Yolo = nullptr, int n_masks = 3, float scale_xy = 1, + YoloRT(int classes, int num,int c,int h,int w,std::vector classNames, + std::vector masks_v,std::vector bias_v, int n_masks = 3, float scale_xy = 1, float nms_thresh = 0.45, int nms_kind = 0, int new_coords = 0); YoloRT(const void *data, size_t length); @@ -25,9 +26,6 @@ namespace nvinfer1 { Dims getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT override; - void configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT override; - int initialize() NOEXCEPT override; void terminate() NOEXCEPT override; @@ -59,9 +57,24 @@ namespace nvinfer1 { void setPluginNamespace(const char *pluginNamespace) NOEXCEPT override; - IPluginV2 *clone() const NOEXCEPT override; + IPluginV2Ext *clone() const NOEXCEPT override; + + DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const NOEXCEPT override; + + void attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT override; + + bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT override; + + bool canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT override; + + void configurePlugin (Dims const *inputDims, int32_t nbInputs, Dims const *outputDims, + int32_t nbOutputs, DataType const *inputTypes, DataType const *outputTypes, + bool const *inputIsBroadcast, bool const *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT override; + + void detachFromContext() NOEXCEPT override; + - tk::dnn::Yolo *yolo; int c, h, w; int classes, num, n_masks; float scaleXY; @@ -71,8 +84,8 @@ namespace nvinfer1 { int NUM = 0; std::vector classesNames; - dnnType *mask; - dnnType *bias; + std::vector mask; + std::vector bias; int entry_index(int batch, int location, int entry) { int n = location / (w * h); @@ -93,9 +106,9 @@ namespace nvinfer1 { const char *getPluginNamespace() const NOEXCEPT override; - IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; + IPluginV2Ext *deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT override; - IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; + IPluginV2Ext *createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT override; const char *getPluginName() const NOEXCEPT override; diff --git a/src/Flatten.cpp b/src/Flatten.cpp index 0eb690c..17e3a56 100644 --- a/src/Flatten.cpp +++ b/src/Flatten.cpp @@ -17,8 +17,8 @@ Flatten::Flatten(Network *net) : Layer(net) { this->h = 1; this->w = 1; - this->rows = input_dim.w; - this->cols = input_dim.h * input_dim.c; + this->rows = input_dim.c; + this->cols = input_dim.h * input_dim.w; this->c = input_dim.w * input_dim.h * input_dim.c; } diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 0537e6a..dc2e337 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -18,9 +18,9 @@ using namespace nvinfer1; // Logger for info/warning/errors class Logger : public ILogger { void log(Severity severity, const char* msg) NOEXCEPT override { -//#ifdef DEBUG +#ifdef DEBUG std::cout <<"TENSORRT LOG: "<< msg << std::endl; -//#endif +#endif } } loggerRT; @@ -472,18 +472,36 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { } ILayer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { + auto creator = getPluginRegistry()->getPluginCreator("FlattenConcatRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("c",&l->c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("rows",&l->rows,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("cols",&l->cols,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); - IPluginV2IOExt *plugin = new FlattenConcatRT(l->c,l->h,l->w,l->rows,l->cols); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } ILayer* NetworkRT::convert_layer(ITensor *input, Reshape *l) { // std::cout<<"convert Reshape\n"; - - IPluginV2 *plugin = new ReshapeRT(l->output_dim); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + auto creator = getPluginRegistry()->getPluginCreator("ReshapeRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("n",&l->n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->w,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -503,8 +521,17 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Reorg *l) { //std::cout<<"convert Reorg\n"; //std::cout<<"New plugin REORG\n"; - IPluginV2 *plugin = new ReorgRT(l->stride); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + auto creator = getPluginRegistry()->getPluginCreator("ReorgRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("stride",&l->stride,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->input_dim.w,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -513,8 +540,19 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Region *l) { //std::cout<<"convert Region\n"; //std::cout<<"New plugin REGION\n"; - IPluginV2 *plugin = new RegionRT(l->classes, l->coords, l->num); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + auto creator = getPluginRegistry()->getPluginCreator("RegionRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("classes",&l->classes,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("coords",&l->coords,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("nums",&l->num,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->input_dim.w,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -535,22 +573,52 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Shortcut *l) { else { // plugin version - IPluginV2 *plugin = new ShortcutRT(l->backLayer->output_dim, l->mul); - ITensor **inputs = new ITensor*[2]; + auto creator = getPluginRegistry()->getPluginCreator("ShortcutRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("bc",&l->backLayer->output_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("bh",&l->backLayer->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("bw",&l->backLayer->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("mul",&l->mul,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->w,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto **inputs = new ITensor*[2]; inputs[0] = input; inputs[1] = back_tens; - IPluginV2Layer *lRT = networkRT->addPluginV2(inputs, 2, *plugin); + auto *lRT = networkRT->addPluginV2(inputs, 2, *plugin); checkNULL(lRT); return lRT; } } ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { - //std::cout<<"convert Yolo\n"; - //std::cout<<"New plugin YOLO\n"; - IPluginV2 *plugin = new YoloRT(l->classes, l->num, l, l->n_masks, l->scaleXY, l->nms_thresh, l->nsm_kind, l->new_coords); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + std::vector mask_h(l->mask_h,l->mask_h+sizeof(dnnType)*l->n_masks); + std::vector bias_h(l->bias_h,l->bias_h+sizeof(dnnType)*2*l->n_masks*l->num); + auto creator = getPluginRegistry()->getPluginCreator("YoloRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("classes",&l->classes,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num",&l->num,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->input_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("classNames",&l->classesNames[0],PluginFieldType::kUNKNOWN,l->classesNames.size())); + mPluginAttributes.emplace_back(PluginField("mask_v",&mask_h[0],PluginFieldType::kFLOAT32,mask_h.size())); + mPluginAttributes.emplace_back(PluginField("bias_v",&bias_h[0],PluginFieldType::kFLOAT32,bias_h.size())); + mPluginAttributes.emplace_back(PluginField("n_masks",&l->n_masks,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("scale_xy",&l->scaleXY,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nms_thresh",&l->nms_thresh,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nms_kins",&l->nsm_kind,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("new_coords",&l->new_coords,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -558,9 +626,17 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { ILayer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { //std::cout<<"convert Upsample\n"; - std::cout<<"New plugin UPSAMPLE\n"; - IPluginV2 *plugin = new UpsampleRT(l->stride); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + auto creator = getPluginRegistry()->getPluginCreator("UpSample_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("stride",&l->stride,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c",&l->c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->w,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } @@ -575,10 +651,53 @@ ILayer* NetworkRT::convert_layer(ITensor *input, DeformConv2d *l) { inputs[1] = preconv->getOutput(0); //std::cout<<"New plugin DEFORMABLE\n"; - IPluginV2 *plugin = new DeformableConvRT(l->chunk_dim, l->kernelH, l->kernelW, l->strideH, l->strideW, l->paddingH, l->paddingW, - l->deformableGroup, l->input_dim.n, l->input_dim.c, l->input_dim.h, l->input_dim.w, - l->output_dim.n, l->output_dim.c, l->output_dim.h, l->output_dim.w, l); - IPluginV2Layer *lRT = networkRT->addPluginV2(inputs, 2, *plugin); + int height_ones = (l->input_dim.h + 2 * l->paddingH - (1 * (l->kernelH - 1) + 1)) / l->strideH + 1; + int width_ones = (l->input_dim.w + 2 * l->paddingW - (1 * (l->kernelW - 1) + 1)) / l->strideW + 1; + int dim_ones = l->input_dim.c * l->kernelH * l->kernelW * 1 * height_ones * width_ones; + std::vector offsetV(2*l->chunk_dim); + std::vector maskV(l->chunk_dim); + std::vector dataV(l->input_dim.c*l->output_dim.c*l->kernelW*l->kernelH*1); + std::vector bias2DV(l->output_dim.c); + std::vector onesD1V(height_ones*width_ones); + std::vector onesD2V(dim_ones); + checkCuda(cudaMemcpy(offsetV.data(),l->offset,offsetV.size()*sizeof(dnnType),cudaMemcpyDeviceToHost)); + checkCuda(cudaMemcpy(maskV.data(),l->mask,sizeof(dnnType)*maskV.size(),cudaMemcpyDeviceToHost)); + checkCuda(cudaMemcpy(dataV.data(),l->data_d,sizeof(dnnType)*dataV.size(),cudaMemcpyDeviceToHost)); + checkCuda(cudaMemcpy(bias2DV.data(),l->bias2_d,sizeof(dnnType)*bias2DV.size(),cudaMemcpyDeviceToHost)); + checkCuda(cudaMemcpy(onesD1V.data(),l->ones_d1,sizeof(dnnType)*onesD1V.size(),cudaMemcpyDeviceToHost)); + checkCuda(cudaMemcpy(onesD2V.data(),l->ones_d2,sizeof(dnnType)*onesD2V.size(),cudaMemcpyDeviceToHost)); + auto creator = getPluginRegistry()->getPluginCreator("DeformableConvRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("chunk_dum",&l->chunk_dim,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kh",&l->kernelH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kw",&l->kernelW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sh",&l->strideH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sw",&l->strideW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("ph",&l->paddingH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("pw",&l->paddingW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("deformable_group",&l->deformableGroup,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_n",&l->input_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_c",&l->input_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_h",&l->input_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_w",&l->input_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_n",&l->output_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_c",&l->output_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_h",&l->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_w",&l->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("mask_v",&maskV[0],PluginFieldType::kFLOAT32,maskV.size())); + mPluginAttributes.emplace_back(PluginField("offset_v",&offsetV[0],PluginFieldType::kFLOAT32,offsetV.size())); + mPluginAttributes.emplace_back(PluginField("ones_d2_v",&onesD2V[0],PluginFieldType::kFLOAT32,onesD2V.size())); + mPluginAttributes.emplace_back(PluginField("ones_d1_v",&onesD1V[0],PluginFieldType::kFLOAT32,onesD1V.size())); + mPluginAttributes.emplace_back(PluginField("data_d_v",&dataV[0],PluginFieldType::kFLOAT32,dataV.size())); + mPluginAttributes.emplace_back(PluginField("bias2_d_v",&bias2DV[0],PluginFieldType::kFLOAT32,bias2DV.size())); + mPluginAttributes.emplace_back(PluginField("height_ones",&height_ones,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("width_ones",&width_ones,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("dim_ones",&dim_ones,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(inputs, 2, *plugin); checkNULL(lRT); lRT->setName( ("Deformable" + std::to_string(l->id)).c_str() ); delete[](inputs); @@ -658,254 +777,7 @@ bool NetworkRT::deserialize(const char *filename) { void NetworkRT::destroy() { contextRT->destroy(); engineRT->destroy(); - configRT->destroy(); builderRT->destroy(); } - - - -/* -IPlugin* PluginFactory::createPlugin(const char* layerName, const void* serialData, size_t serialLength) { - const char * buf = reinterpret_cast(serialData),*bufCheck = buf; - - std::string name(layerName); - //std::cout<(buf)); - a->size = readBUF(buf); - assert(buf == bufCheck + serialLength); - return a; - } - if(name.find("ActivationMish") == 0) { - ActivationMishRT *a = new ActivationMishRT(); - a->size = readBUF(buf); - assert(buf == bufCheck + serialLength); - return a; - } - if(name.find("ActivationLogistic") == 0) { - ActivationLogisticRT *a = new ActivationLogisticRT(); - a->size = readBUF(buf); - return a; - } - if(name.find("ActivationLogistic") == 0) { - ActivationLogisticRT *a = new ActivationLogisticRT(); - a->size = readBUF(buf); - return a; - } - if(name.find("ActivationCReLU") == 0) { - float activationReluTemp = readBUF(buf); - ActivationReLUCeiling* a = new ActivationReLUCeiling(activationReluTemp); - a->size = readBUF(buf); - assert(buf == bufCheck + serialLength); - return a; - } - - if(name.find("Region") == 0) { - int classesTemp = readBUF(buf); - int coordsTemp = readBUF(buf); - int numTemp = readBUF(buf); - RegionRT* r = new RegionRT(classesTemp, coordsTemp, numTemp); - - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Reorg") == 0) { - int strideTemp = readBUF(buf); - ReorgRT *r = new ReorgRT(strideTemp); - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Shortcut") == 0) { - tk::dnn::dataDim_t bdim; - bdim.c = readBUF(buf); - bdim.h = readBUF(buf); - bdim.w = readBUF(buf); - bdim.l = 1; - - ShortcutRT *r = new ShortcutRT(bdim, readBUF(buf)); - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - return r; - assert(buf == bufCheck + serialLength); - } - - if(name.find("Pooling") == 0) { - int cTemp = readBUF(buf); - int hTemp = readBUF(buf); - int wTemp = readBUF(buf); - int nTemp = readBUF(buf); - int strideHTemp = readBUF(buf); - int strideWTemp = readBUF(buf); - int winSizeTemp = readBUF(buf); - int paddingTemp = readBUF(buf); - - MaxPoolFixedSizeRT* r = new MaxPoolFixedSizeRT(cTemp, hTemp, wTemp, nTemp, strideHTemp, strideWTemp, winSizeTemp, paddingTemp); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Resize") == 0) { - int o_cTemp = readBUF(buf); - int o_hTemp = readBUF(buf); - int o_wTemp = readBUF(buf); - ResizeLayerRT* r = new ResizeLayerRT(o_cTemp, o_hTemp, o_wTemp); - - r->i_c = readBUF(buf); - r->i_h = readBUF(buf); - r->i_w = readBUF(buf); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Flatten") == 0) { - FlattenConcatRT *r = new FlattenConcatRT(); - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - r->rows = readBUF(buf); - r->cols = readBUF(buf); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Reshape") == 0) { - - dataDim_t new_dim; - new_dim.n = readBUF(buf); - new_dim.c = readBUF(buf); - new_dim.h = readBUF(buf); - new_dim.w = readBUF(buf); - ReshapeRT *r = new ReshapeRT(new_dim); - assert(buf == bufCheck + serialLength); - - return r; - } - - if(name.find("Yolo") == 0) { - - int classes_temp = readBUF(buf); - int num_temp = readBUF(buf); - int n_masks_temp = readBUF(buf); - float scale_xy_temp = readBUF(buf); - float nms_thresh_temp = readBUF(buf); - int nms_kind_temp = readBUF(buf); - int new_coords_temp = readBUF(buf); - - YoloRT *r = new YoloRT(classes_temp,num_temp,nullptr,n_masks_temp,scale_xy_temp,nms_thresh_temp,nms_kind_temp,new_coords_temp); - - - - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - for(int i=0; in_masks; i++) - r->mask[i] = readBUF(buf); - for(int i=0; in_masks*2*r->num; i++) - r->bias[i] = readBUF(buf); - - // save classes names - r->classesNames.resize(r->classes); - for(int i=0; iclasses; i++) { - char tmp[YOLORT_CLASSNAME_W]; - for(int j=0; j(buf); - r->classesNames[i] = std::string(tmp); - } - assert(buf == bufCheck + serialLength); - - yolos[n_yolos++] = r; - return r; - } - if(name.find("Upsample") == 0) { - int strideTemp = readBUF(buf); - UpsampleRT* r = new UpsampleRT(strideTemp); - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Route") == 0) { - int groupsTemp = readBUF(buf); - int group_idTemp = readBUF(buf); - RouteRT* r = new RouteRT(groupsTemp, group_idTemp); - r->in = readBUF(buf); - for(int i=0; ic_in[i] = readBUF(buf); - r->c = readBUF(buf); - r->h = readBUF(buf); - r->w = readBUF(buf); - assert(buf == bufCheck + serialLength); - return r; - } - - if(name.find("Deformable") == 0) { - int chuck_dimTemp = readBUF(buf); - int khTemp = readBUF(buf); - int kwTemp = readBUF(buf); - int shTemp = readBUF(buf); - int swTemp = readBUF(buf); - int phTemp = readBUF(buf); - int pwTemp = readBUF(buf); - int deformableGroupTemp = readBUF(buf); - int i_nTemp = readBUF(buf); - int i_cTemp = readBUF(buf); - int i_hTemp = readBUF(buf); - int i_wTemp = readBUF(buf); - int o_nTemp = readBUF(buf); - int o_cTemp = readBUF(buf); - int o_hTemp = readBUF(buf); - int o_wTemp = readBUF(buf); - - DeformableConvRT* r = new DeformableConvRT(chuck_dimTemp, khTemp, kwTemp, shTemp, swTemp, phTemp, pwTemp, deformableGroupTemp, i_nTemp, i_cTemp, i_hTemp, i_wTemp, o_nTemp, o_cTemp, o_hTemp, o_wTemp, nullptr); - dnnType *aus = new dnnType[r->chunk_dim*2]; - for(int i=0; ichunk_dim*2; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(r->offset, aus, sizeof(dnnType)*2*r->chunk_dim, cudaMemcpyHostToDevice) ); - free(aus); - aus = new dnnType[r->chunk_dim]; - for(int i=0; ichunk_dim; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(r->mask, aus, sizeof(dnnType)*r->chunk_dim, cudaMemcpyHostToDevice) ); - free(aus); - aus = new dnnType[(r->i_c * r->o_c * r->kh * r->kw * 1 )]; - for(int i=0; i<(r->i_c * r->o_c * r->kh * r->kw * 1 ); i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(r->data_d, aus, sizeof(dnnType)*(r->i_c * r->o_c * r->kh * r->kw * 1 ), cudaMemcpyHostToDevice) ); - free(aus); - aus = new dnnType[r->o_c]; - for(int i=0; i < r->o_c; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(r->bias2_d, aus, sizeof(dnnType)*r->o_c, cudaMemcpyHostToDevice) ); - free(aus); - aus = new dnnType[r->height_ones * r->width_ones]; - for(int i=0; iheight_ones * r->width_ones; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(r->ones_d1, aus, sizeof(dnnType)*r->height_ones * r->width_ones, cudaMemcpyHostToDevice) ); - free(aus); - aus = new dnnType[r->dim_ones]; - for(int i=0; idim_ones; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(r->ones_d2, aus, sizeof(dnnType)*r->dim_ones, cudaMemcpyHostToDevice) ); - free(aus); - assert(buf == bufCheck + serialLength); - return r; - } - - FatalError("Cant deserialize Plugin"); - return NULL; -} -*/ }} diff --git a/src/Region.cpp b/src/Region.cpp index 7c26208..46e0cff 100644 --- a/src/Region.cpp +++ b/src/Region.cpp @@ -16,7 +16,6 @@ Region::Region(Network *net, int classes, int coords, int num) : this->classes = classes; this->coords = coords; this->num = num; - // same output_dim.n = input_dim.n; output_dim.c = input_dim.c; diff --git a/src/Reshape.cpp b/src/Reshape.cpp index f43c4ee..f966b27 100644 --- a/src/Reshape.cpp +++ b/src/Reshape.cpp @@ -8,7 +8,10 @@ namespace tk { namespace dnn { Reshape::Reshape(Network *net, dataDim_t new_dim) : Layer(net) { checkCuda( cudaMalloc(&dstData, input_dim.tot()*sizeof(dnnType)) ); - + this->n = new_dim.n; + this->c = new_dim.c; + this->h = new_dim.h; + this->w = new_dim.w; output_dim.n = new_dim.n; output_dim.c = new_dim.c; output_dim.h = new_dim.h; diff --git a/src/Shortcut.cpp b/src/Shortcut.cpp index b1053c8..0488487 100644 --- a/src/Shortcut.cpp +++ b/src/Shortcut.cpp @@ -9,6 +9,9 @@ Shortcut::Shortcut(Network *net, Layer *backLayer, bool mul) : Layer(net) { this->backLayer = backLayer; this->mul = mul; + this->c = input_dim.c; + this->h = input_dim.h; + this->w = input_dim.w; checkCuda( cudaMalloc(&dstData, output_dim.tot()*sizeof(dnnType)) ); if( ( backLayer->output_dim.c != input_dim.c && mul ) || diff --git a/src/Upsample.cpp b/src/Upsample.cpp index 943cb2b..4f35d0f 100644 --- a/src/Upsample.cpp +++ b/src/Upsample.cpp @@ -14,6 +14,9 @@ Upsample::Upsample(Network *net, int stride) : Layer(net) { output_dim.h = input_dim.h*stride; output_dim.w = input_dim.w*stride; output_dim.l = input_dim.l; + this->c = input_dim.c; + this->h = input_dim.h; + this->w = input_dim.w; checkCuda( cudaMalloc(&dstData, output_dim.tot()*sizeof(dnnType)) ); } diff --git a/src/pluginsRT/DeformableConvRT.cpp b/src/pluginsRT/DeformableConvRT.cpp index 62f7555..1dc4d1a 100644 --- a/src/pluginsRT/DeformableConvRT.cpp +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -1,14 +1,19 @@ #include + +#include using namespace nvinfer1; using namespace tk::dnn; std::vector DeformableConvRTPluginCreator::mPluginAttributes; PluginFieldCollection DeformableConvRTPluginCreator::mFC{}; +static const char* DEFORMABLECONVRT_PLUGIN_VERSION{"1"}; +static const char* DEFORMABLECONVRT_PLUGIN_NAME{"DeformableConvRT_tkDNN"}; + DeformableConvRT::DeformableConvRT(int chunk_dim, int kh, int kw, int sh, int sw, int ph, int pw, int deformableGroup, - int i_n, int i_c, int i_h, int i_w, int o_n, int o_c, int o_h, int o_w, - tk::dnn::DeformConv2d *deformable) { + int i_n, int i_c, int i_h, int i_w, int o_n, int o_c, int o_h, int o_w,std::vector data_H,std::vector bias2_H, + std::vector ones_d1_h,std::vector ones_d2_h,std::vector offsetH,std::vector maskH,int height_ones,int width_ones,int dim_ones) { this->chunk_dim = chunk_dim; this->kh = kh; this->kw = kw; @@ -25,11 +30,15 @@ DeformableConvRT::DeformableConvRT(int chunk_dim, int kh, int kw, int sh, int sw this->o_c = o_c; this->o_h = o_h; this->o_w = o_w; - this->defRT = deformable; - - height_ones = (i_h + 2 * ph - (1 * (kh - 1) + 1)) / sh + 1; - width_ones = (i_w + 2 * pw - (1 * (kw - 1) + 1)) / sw + 1; - dim_ones = i_c * kh * kw * 1 * height_ones * width_ones; + this->mask_v = std::move(maskH); + this->offset_v = std::move(offsetH); + this->ones_d2_v = std::move(ones_d2_h); + this->ones_d1_v = std::move(ones_d1_h); + this->data_d_v = std::move(data_H); + this->bias2_d_v = std::move(bias2_H); + this->height_ones = height_ones; + this->width_ones = width_ones; + this->dim_ones = dim_ones; checkCuda( cudaMalloc(&data_d, i_c * o_c * kh * kw * 1 * sizeof(dnnType))); checkCuda( cudaMalloc(&bias2_d, o_c*sizeof(dnnType))); @@ -37,17 +46,15 @@ DeformableConvRT::DeformableConvRT(int chunk_dim, int kh, int kw, int sh, int sw checkCuda( cudaMalloc(&offset, 2*chunk_dim*sizeof(dnnType))); checkCuda( cudaMalloc(&mask, chunk_dim*sizeof(dnnType))); checkCuda( cudaMalloc(&ones_d2, dim_ones*sizeof(dnnType))); - if(deformable != nullptr) { - checkCuda( cudaMemcpy(data_d, deformable->data_d, sizeof(dnnType)*i_c * o_c * kh * kw * 1, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(bias2_d, deformable->bias2_d, sizeof(dnnType)*o_c, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(ones_d1, deformable->ones_d1, sizeof(dnnType)*height_ones*width_ones, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(offset, deformable->offset, sizeof(dnnType)*2*chunk_dim, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(mask, deformable->mask, sizeof(dnnType)*chunk_dim, cudaMemcpyDeviceToDevice) ); - checkCuda( cudaMemcpy(ones_d2, deformable->ones_d2, sizeof(dnnType)*dim_ones, cudaMemcpyDeviceToDevice) ); + if(!data_d_v.empty() && !bias2_d_v.empty() && !ones_d1_v.empty() && !ones_d2_v.empty() && !mask_v.empty() && !offset_v.empty()) { + checkCuda(cudaMemcpy(data_d, data_d_v.data(), sizeof(dnnType) * data_d_v.size(), cudaMemcpyHostToDevice)); + checkCuda(cudaMemcpy(bias2_d, bias2_d_v.data(), sizeof(dnnType) * bias2_d_v.size(), cudaMemcpyHostToDevice)); + checkCuda(cudaMemcpy(ones_d1, ones_d1_v.data(), sizeof(dnnType) * ones_d1_v.size(), cudaMemcpyHostToDevice)); + checkCuda(cudaMemcpy(offset, offset_v.data(), sizeof(dnnType) * offset_v.size(), cudaMemcpyHostToDevice)); + checkCuda(cudaMemcpy(mask, mask_v.data(), sizeof(dnnType) * mask_v.size(), cudaMemcpyHostToDevice)); + checkCuda(cudaMemcpy(ones_d2, ones_d2_v.data(), sizeof(dnnType) * ones_d2_v.size(), cudaMemcpyHostToDevice)); } - stat = cublasCreate(&handle); - if (stat != CUBLAS_STATUS_SUCCESS) - FatalError("CUBLAS initialization failed\n"); + } @@ -79,42 +86,27 @@ DeformableConvRT::DeformableConvRT(const void *data, size_t length) { o_c = readBUF(buf); o_h = readBUF(buf); o_w = readBUF(buf); - dnnType *aus = new dnnType[chunk_dim*2]; + height_ones = readBUF(buf); + width_ones = readBUF(buf); + dim_ones = readBUF(buf); + offset_v.resize(chunk_dim*2); for(int i=0;i(buf); - checkCuda(cudaMemcpy(offset,aus,sizeof(dnnType)*2*chunk_dim,cudaMemcpyHostToDevice)); - free(aus); - - aus = new dnnType[chunk_dim]; + offset_v[i] = readBUF(buf); + mask_v.resize(chunk_dim); for(int i=0;i(buf); - checkCuda(cudaMemcpy(mask,aus,sizeof(dnnType)*chunk_dim,cudaMemcpyHostToDevice)); - free(aus); - - aus = new dnnType[i_c*o_c*kh*kw*1]; + mask_v[i] = readBUF(buf); + data_d_v.resize(i_c*o_c*kh*kw*1); for(int i=0;i<(i_c*o_c*kh*kw*1);i++) - aus[i] = readBUF(buf); - checkCuda(cudaMemcpy(data_d,aus,sizeof(dnnType)*(i_c*o_c*kh*kw*1),cudaMemcpyHostToDevice)); - free(aus); - - aus = new dnnType[o_c]; + data_d_v[i] = readBUF(buf); + bias2_d_v.resize(o_c); for(int i=0; i < o_c; i++) - aus[i] = readBUF(buf); - checkCuda( cudaMemcpy(bias2_d, aus, sizeof(dnnType)*o_c, cudaMemcpyHostToDevice) ); - free(aus); - - aus = new dnnType[height_ones * width_ones]; + bias2_d_v[i] = readBUF(buf); + ones_d1_v.resize(height_ones*width_ones); for(int i=0; i(buf); - checkCuda( cudaMemcpy(ones_d1, aus, sizeof(dnnType)*height_ones * width_ones, cudaMemcpyHostToDevice) ); - free(aus); - - aus = new dnnType[dim_ones]; + ones_d1_v[i] = readBUF(buf); + ones_d2_v.resize(dim_ones); for(int i=0; i(buf); - checkCuda( cudaMemcpy(ones_d2, aus, sizeof(dnnType)*dim_ones, cudaMemcpyHostToDevice) ); - free(aus); - + ones_d2_v[i] = readBUF(buf); assert(buf == bufCheck + length); } @@ -124,11 +116,9 @@ int DeformableConvRT::getNbOutputs() const NOEXCEPT { } Dims DeformableConvRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims) NOEXCEPT { - return Dims3{defRT->output_dim.c, defRT->output_dim.h, defRT->output_dim.w}; + return Dims3{o_c, o_h, o_w}; } -void DeformableConvRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT {} - int DeformableConvRT::initialize() NOEXCEPT { return 0; } @@ -166,7 +156,7 @@ int DeformableConvRT::enqueue(int batchSize, const void *const *inputs, void *co } return 0; } -#elif NV_TENSORRT_MAJOR == 7 +#elif NV_TENSORRT_MAJOR <= 7 int32_t DeformableConvRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -198,7 +188,7 @@ int32_t DeformableConvRT::enqueue(int32_t batchSize, const void *const *inputs, #endif size_t DeformableConvRT::getSerializationSize() const NOEXCEPT { - return 16 * sizeof(int) + chunk_dim * 3 * sizeof(dnnType) + (i_c * o_c * kh * kw * 1 ) * sizeof(dnnType) + + return 19 * sizeof(int) + chunk_dim * 3 * sizeof(dnnType) + (i_c * o_c * kh * kw * 1 ) * sizeof(dnnType) + o_c * sizeof(dnnType) + height_ones * width_ones * sizeof(dnnType) + dim_ones * sizeof(dnnType); } @@ -220,45 +210,27 @@ void DeformableConvRT::serialize(void *buffer) const NOEXCEPT { writeBUF(buf, o_c); writeBUF(buf, o_h); writeBUF(buf, o_w); - dnnType *aus = new dnnType[chunk_dim*2]; - checkCuda( cudaMemcpy(aus, offset, sizeof(dnnType)*2*chunk_dim, cudaMemcpyDeviceToHost) ); - for(int i=0; isetPluginNamespace(mPluginNamespace.c_str()); return p; } +DataType +DeformableConvRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void DeformableConvRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + handle = cublasContext; + +} + +bool DeformableConvRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, + int nbInputs) const NOEXCEPT { + return false; +} + +bool DeformableConvRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void DeformableConvRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT { + +} + +void DeformableConvRT::detachFromContext() NOEXCEPT { + +} + +bool DeformableConvRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; +} + DeformableConvRTPluginCreator::DeformableConvRTPluginCreator() { mPluginAttributes.clear(); + mPluginAttributes.emplace_back(PluginField("chunk_dim", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kh", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("kw", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sh", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("sw", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("ph", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("pw", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("deformable_group", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_n", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("i_w", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_n", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("o_w", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("mask_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("offset_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("ones_d2_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("ones_d1_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("data_d_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("bias2_d_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("height_ones", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("width_ones", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("dim_ones", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -296,14 +328,14 @@ const char *DeformableConvRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *DeformableConvRTPluginCreator::deserializePlugin(const char *name, const void *serialData, +IPluginV2Ext *DeformableConvRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { auto *pluginObj = new DeformableConvRT(serialData,serialLength); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } -IPluginV2 *DeformableConvRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *DeformableConvRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; int chunk_dim = *(static_cast(fields[0].data)); int kh = *(static_cast(fields[1].data)); @@ -320,19 +352,27 @@ IPluginV2 *DeformableConvRTPluginCreator::createPlugin(const char *name, const P int o_n = *(static_cast(fields[12].data)); int o_c = *(static_cast(fields[13].data)); int o_h = *(static_cast(fields[14].data)); - int o_w = *(static_cast(fields[14].data)); - auto *defRT = const_cast(static_cast(fields[15].data)); - auto *pluginObj = new DeformableConvRT(chunk_dim,kh,kw,sh,sw,ph,pw,deformableGroup,i_n,i_c,i_h,i_w,o_n,o_c,o_h,o_w,defRT); + int o_w = *(static_cast(fields[15].data)); + std::vector mask_v(static_cast(fields[16].data),static_cast(fields[16].data)+fields[16].length); + std::vector offset_v(static_cast(fields[17].data),static_cast(fields[17].data)+fields[17].length); + std::vector ones_d2_v(static_cast(fields[18].data),static_cast(fields[18].data)+fields[18].length); + std::vector ones_d1_v(static_cast(fields[19].data),static_cast(fields[19].data)+fields[19].length); + std::vector data_d_v(static_cast(fields[20].data),static_cast(fields[20].data)+fields[20].length); + std::vector bias2_d_v(static_cast(fields[21].data),static_cast(fields[21].data)+fields[21].length); + int height_ones = *(static_cast(fields[22].data)); + int width_ones = *(static_cast(fields[23].data)); + int dim_ones = *(static_cast(fields[24].data)); + auto *pluginObj = new DeformableConvRT(chunk_dim,kh,kw,sh,sw,ph,pw,deformableGroup,i_n,i_c,i_h,i_w,o_n,o_c,o_h,o_w,data_d_v,bias2_d_v,ones_d1_v,ones_d2_v,offset_v,mask_v,height_ones,width_ones,dim_ones); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } const char *DeformableConvRTPluginCreator::getPluginName() const NOEXCEPT { - return "DeformableConvRT_tkDNN"; + return DEFORMABLECONVRT_PLUGIN_NAME; } const char *DeformableConvRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return DEFORMABLECONVRT_PLUGIN_VERSION; } const PluginFieldCollection *DeformableConvRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/src/pluginsRT/FlattenConcatRT.cpp b/src/pluginsRT/FlattenConcatRT.cpp index 6c54e47..c281579 100644 --- a/src/pluginsRT/FlattenConcatRT.cpp +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -4,12 +4,10 @@ using namespace nvinfer1; std::vector FlattenConcatRTPluginCreator::mPluginAttributes; PluginFieldCollection FlattenConcatRTPluginCreator::mFC{}; +static const char* FLATTENCONCATRT_PLUGIN_VERSION{"1"}; +static const char* FLATTENCONCATRT_PLUGIN_NAME{"FlattenConcatRT_tkDNN"}; + FlattenConcatRT::FlattenConcatRT(int c, int h, int w, int rows, int cols) { - stat = cublasCreate(&handle); - if (stat != CUBLAS_STATUS_SUCCESS) { - printf ("CUBLAS initialization failed\n"); - return; - } this->c = c; this->h = h; this->w = w; @@ -42,7 +40,7 @@ int FlattenConcatRT::initialize() NOEXCEPT { } void FlattenConcatRT::terminate() NOEXCEPT { - checkERROR(cublasDestroy(handle)); + } size_t FlattenConcatRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { @@ -105,11 +103,11 @@ void FlattenConcatRT::destroy() NOEXCEPT { const char *FlattenConcatRT::getPluginType() const NOEXCEPT { - return "FlattenConcatRT_tkDNN"; + return FLATTENCONCATRT_PLUGIN_NAME; } const char *FlattenConcatRT::getPluginVersion() const NOEXCEPT { - return "1"; + return FLATTENCONCATRT_PLUGIN_VERSION; } const char *FlattenConcatRT::getPluginNamespace() const NOEXCEPT { @@ -120,7 +118,7 @@ void FlattenConcatRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2IOExt *FlattenConcatRT::clone() const NOEXCEPT { +IPluginV2Ext *FlattenConcatRT::clone() const NOEXCEPT { auto* p = new FlattenConcatRT(c, h, w, rows, cols); p->setPluginNamespace(mPluginNamespace.c_str()); return p; @@ -131,12 +129,10 @@ DataType FlattenConcatRT::getOutputDataType(int index, const nvinfer1::DataType* return DataType::kFLOAT; } -void FlattenConcatRT::configurePlugin(const PluginTensorDesc* in, int nbInput, const PluginTensorDesc* out, int nbOutput) NOEXCEPT -{ -} void FlattenConcatRT::attachToContext(cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator) NOEXCEPT { + handle = cublasContext; } bool FlattenConcatRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const NOEXCEPT @@ -149,17 +145,29 @@ bool FlattenConcatRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEP return false; } -bool FlattenConcatRT::supportsFormatCombination(int pos, const PluginTensorDesc* inOut, int nbInputs, int nbOutputs) const NOEXCEPT -{ - return true; -} - void FlattenConcatRT::detachFromContext() NOEXCEPT { } +void +FlattenConcatRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT { + +} + +bool FlattenConcatRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { + return true; +} + FlattenConcatRTPluginCreator::FlattenConcatRTPluginCreator() { mPluginAttributes.clear(); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("rows", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("cols", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -172,14 +180,14 @@ const char *FlattenConcatRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2IOExt *FlattenConcatRTPluginCreator::deserializePlugin(const char *name, const void *serialData, +IPluginV2Ext *FlattenConcatRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { auto *pluginObj = new FlattenConcatRT(serialData,serialLength); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } -IPluginV2IOExt *FlattenConcatRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *FlattenConcatRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField* fields = fc->fields; int c = *(static_cast(fields[0].data)); int h = *(static_cast(fields[1].data)); @@ -192,11 +200,11 @@ IPluginV2IOExt *FlattenConcatRTPluginCreator::createPlugin(const char *name, con } const char *FlattenConcatRTPluginCreator::getPluginName() const NOEXCEPT { - return "FlattenConcatRT_tkDNN"; + return FLATTENCONCATRT_PLUGIN_NAME; } const char *FlattenConcatRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return FLATTENCONCATRT_PLUGIN_VERSION; } const PluginFieldCollection *FlattenConcatRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/src/pluginsRT/MaxPoolingSizeRT.cpp b/src/pluginsRT/MaxPoolingSizeRT.cpp index 33316b7..5f36ae3 100644 --- a/src/pluginsRT/MaxPoolingSizeRT.cpp +++ b/src/pluginsRT/MaxPoolingSizeRT.cpp @@ -40,8 +40,6 @@ Dims MaxPoolFixedSizeRT::getOutputDimensions(int index, const Dims *inputs, int return Dims3{this->c, this->h, this->w}; } -void MaxPoolFixedSizeRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT {} - int MaxPoolFixedSizeRT::initialize() NOEXCEPT { return 0; } @@ -62,7 +60,7 @@ int MaxPoolFixedSizeRT::enqueue(int batchSize, const void *const *inputs, void * MaxPoolingForward(srcData, dstData, batchSize, this->c, this->h, this->w, this->stride_H, this->stride_W, this->winSize, this->padding, stream); return 0; } -#elif NV_TENSORRT_MAJOR == 7 +#elif NV_TENSORRT_MAJOR <= 7 int32_t MaxPoolFixedSizeRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -115,12 +113,43 @@ const char *MaxPoolFixedSizeRT::getPluginVersion() const NOEXCEPT { return "1"; } -IPluginV2 *MaxPoolFixedSizeRT::clone() const NOEXCEPT { +IPluginV2Ext *MaxPoolFixedSizeRT::clone() const NOEXCEPT { auto *p = new MaxPoolFixedSizeRT(c,h,w,n,stride_H,stride_W,winSize,padding); p->setPluginNamespace(mPluginNamespace.c_str()); return p; } +DataType +MaxPoolFixedSizeRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void MaxPoolFixedSizeRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool MaxPoolFixedSizeRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, + int nbInputs) const NOEXCEPT { + return false; +} + +bool MaxPoolFixedSizeRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void +MaxPoolFixedSizeRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, + const bool *inputIsBroadcast, const bool *outputIsBroadcast, + PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void MaxPoolFixedSizeRT::detachFromContext() NOEXCEPT { + IPluginV2Ext::detachFromContext(); +} + MaxPoolFixedSizeRTPluginCreator::MaxPoolFixedSizeRTPluginCreator() { mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); @@ -135,15 +164,14 @@ const char *MaxPoolFixedSizeRTPluginCreator::getPluginNamespace() const NOEXCEPT return mPluginNamespace.c_str(); } -IPluginV2 *MaxPoolFixedSizeRTPluginCreator::deserializePlugin(const char *name, const void *serialData,size_t serialLength) NOEXCEPT { +IPluginV2Ext *MaxPoolFixedSizeRTPluginCreator::deserializePlugin(const char *name, const void *serialData,size_t serialLength) NOEXCEPT { auto *pluginObj = new MaxPoolFixedSizeRT(serialData,serialLength); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } -IPluginV2 *MaxPoolFixedSizeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *MaxPoolFixedSizeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - //todo assert int c = *(static_cast(fields[0].data)); int h = *(static_cast(fields[1].data)); int w = *(static_cast(fields[2].data)); diff --git a/src/pluginsRT/RegionRT.cpp b/src/pluginsRT/RegionRT.cpp index 552db3e..2d9899c 100644 --- a/src/pluginsRT/RegionRT.cpp +++ b/src/pluginsRT/RegionRT.cpp @@ -1,12 +1,19 @@ #include using namespace nvinfer1; + std::vector RegionRTPluginCreator::mPluginAttributes; PluginFieldCollection RegionRTPluginCreator::mFC{}; -RegionRT::RegionRT(int classes, int coords, int num) { +static const char* REGIONRT_PLUGIN_VERSION{"1"}; +static const char* REGIONRT_PLUGIN_NAME{"RegionRT_tkDNN"}; + +RegionRT::RegionRT(int classes, int coords, int num,int c,int h,int w) { this->classes = classes; this->coords = coords; this->num = num; + this->c = c; + this->h = h; + this->w = w; } RegionRT::~RegionRT() {} @@ -30,12 +37,6 @@ Dims RegionRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDim return inputs[0]; } -void RegionRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, - PluginFormat format, int maxBatchSize) NOEXCEPT { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; -} int RegionRT::initialize() NOEXCEPT {return 0;} @@ -112,11 +113,11 @@ void RegionRT::serialize(void *buffer) const NOEXCEPT { } const char *RegionRT::getPluginType() const NOEXCEPT { - return "RegionRT_tkDNN"; + return REGIONRT_PLUGIN_NAME; } const char *RegionRT::getPluginVersion() const NOEXCEPT { - return "1"; + return REGIONRT_PLUGIN_VERSION; } void RegionRT::destroy() NOEXCEPT { delete this; } @@ -133,14 +134,48 @@ bool RegionRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT return true; } -IPluginV2 *RegionRT::clone() const NOEXCEPT { - auto *p = new RegionRT(classes,coords,num); +IPluginV2Ext *RegionRT::clone() const NOEXCEPT { + auto *p = new RegionRT(classes,coords,num,c,h,w); p->setPluginNamespace(mPluginNamespace.c_str()); return p; } +DataType RegionRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void RegionRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool RegionRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, int nbInputs) const NOEXCEPT { + return false; +} + +bool RegionRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void RegionRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void RegionRT::detachFromContext() NOEXCEPT { + +} + + RegionRTPluginCreator::RegionRTPluginCreator() { mPluginAttributes.clear(); + mPluginAttributes.emplace_back(PluginField("classes", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("coords", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -153,32 +188,35 @@ const char *RegionRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *RegionRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +IPluginV2Ext *RegionRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { auto *pluginObj = new RegionRT(serialData,serialLength); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } -IPluginV2 *RegionRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *RegionRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - assert(fc->nbFields == 3); - assert(fields[0].type == PluginFieldType::kINT32); - assert(fields[1].type == PluginFieldType::kINT32); - assert(fields[2].type == PluginFieldType::kINT32); + assert(fc->nbFields == 6); + for(int i=0;i<6;i++){ + assert(fields[i].type == PluginFieldType::kINT32); + } int classes = *(static_cast(fields[0].data)); int coords = *(static_cast(fields[1].data)); int num = *(static_cast(fields[2].data)); - RegionRT *pluginObj = new RegionRT(classes,coords,num); + int c = *(static_cast(fields[3].data)); + int h = *(static_cast(fields[4].data)); + int w = *(static_cast(fields[5].data)); + auto *pluginObj = new RegionRT(classes,coords,num,c,h,w); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } const char *RegionRTPluginCreator::getPluginName() const NOEXCEPT { - return "RegionRT_tkDNN"; + return REGIONRT_PLUGIN_NAME; } const char *RegionRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return REGIONRT_PLUGIN_VERSION; } const PluginFieldCollection *RegionRTPluginCreator::getFieldNames() NOEXCEPT { @@ -195,4 +233,3 @@ const PluginFieldCollection *RegionRTPluginCreator::getFieldNames() NOEXCEPT { - diff --git a/src/pluginsRT/ReorgRT.cpp b/src/pluginsRT/ReorgRT.cpp index c2b0083..b1e7b1f 100644 --- a/src/pluginsRT/ReorgRT.cpp +++ b/src/pluginsRT/ReorgRT.cpp @@ -4,8 +4,14 @@ using namespace nvinfer1; std::vector ReorgRTPluginCreator::mPluginAttributes; PluginFieldCollection ReorgRTPluginCreator::mFC{}; -ReorgRT::ReorgRT(int stride) { +static const char* REORGRT_PLUGIN_VERSION{"1"}; +static const char* REORGRT_PLUGIN_NAME{"ReorgRT_tkDNN"}; + +ReorgRT::ReorgRT(int stride,int c,int h,int w) { this->stride = stride; + this->c = c; + this->h = h; + this->w = w; } ReorgRT::~ReorgRT() {} @@ -27,11 +33,6 @@ Dims ReorgRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDims return Dims3{inputs[0].d[0]*stride*stride, inputs[0].d[1]/stride, inputs[0].d[2]/stride}; } -void ReorgRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; -} int ReorgRT::initialize() NOEXCEPT { return 0; @@ -50,7 +51,7 @@ int ReorgRT::enqueue(int batchSize, const void *const *inputs, void *const *outp batchSize, c, h, w, stride, stream); return 0; } -#elif NV_TENSORRT_MAJOR == 7 +#elif NV_TENSORRT_MAJOR <= 7 int32_t ReorgRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { reorgForward((dnnType*)reinterpret_cast(inputs[0]), reinterpret_cast(outputs[0]), @@ -78,11 +79,11 @@ bool ReorgRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT } const char *ReorgRT::getPluginType() const NOEXCEPT { - return "ReorgRT_tkDNN"; + return REORGRT_PLUGIN_NAME; } const char *ReorgRT::getPluginVersion() const NOEXCEPT { - return "1"; + return REORGRT_PLUGIN_VERSION; } void ReorgRT::destroy() NOEXCEPT { @@ -97,14 +98,45 @@ void ReorgRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2 *ReorgRT::clone() const NOEXCEPT { - auto *p = new ReorgRT(stride); +IPluginV2Ext *ReorgRT::clone() const NOEXCEPT { + auto *p = new ReorgRT(stride,c,h,w); p->setPluginNamespace(mPluginNamespace.c_str()); return p; } +DataType ReorgRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void ReorgRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool ReorgRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, int nbInputs) const NOEXCEPT { + return false; +} + +bool ReorgRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void ReorgRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void ReorgRT::detachFromContext() NOEXCEPT { + +} + ReorgRTPluginCreator::ReorgRTPluginCreator() { mPluginAttributes.clear(); + mPluginAttributes.emplace_back(PluginField("stride", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -117,28 +149,34 @@ const char *ReorgRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *ReorgRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +IPluginV2Ext *ReorgRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { auto *pluginObj = new ReorgRT(serialData,serialLength); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } -IPluginV2 *ReorgRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *ReorgRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - assert(fc->nbFields == 1); - assert(fields[0].type == PluginFieldType::kINT32); + assert(fc->nbFields == 4); + for(int i=0;i<4;i++){ + assert(fields[1].type == PluginFieldType::kINT32); + } int stride = *(static_cast(fields[0].data)); - auto *pluginObj = new ReorgRT(stride); + int c = *(static_cast(fields[1].data)); + int h = *(static_cast(fields[2].data)); + int w = *(static_cast(fields[3].data)); + + auto *pluginObj = new ReorgRT(stride,c,h,w); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } const char *ReorgRTPluginCreator::getPluginName() const NOEXCEPT { - return "ReorgRT_tkDNN"; + return REORGRT_PLUGIN_NAME; } const char *ReorgRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return REORGRT_PLUGIN_VERSION; } const PluginFieldCollection *ReorgRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp index f364ab0..dbe59c0 100644 --- a/src/pluginsRT/ReshapeRT.cpp +++ b/src/pluginsRT/ReshapeRT.cpp @@ -4,20 +4,22 @@ using namespace nvinfer1; std::vector ReshapeRTPluginCreator::mPluginAttributes; PluginFieldCollection ReshapeRTPluginCreator::mFC{}; -ReshapeRT::ReshapeRT(dataDim_t newDim) { - new_dim = newDim; - n = new_dim.n; - c = new_dim.c; - h = new_dim.h; - w = new_dim.w; +static const char* RESHAPERT_PLUGIN_VERSION{"1"}; +static const char* RESHAPERT_PLUGIN_NAME{"ReshapeRT_tkDNN"}; + +ReshapeRT::ReshapeRT(int n,int c,int h,int w) { + this->n = n; + this->c = c; + this->h = h; + this->w = w; } ReshapeRT::ReshapeRT(const void *data, size_t length) { const char *buf = reinterpret_cast(data),*bufCheck = buf; - new_dim.n = readBUF(buf); - new_dim.c = readBUF(buf); - new_dim.h = readBUF(buf); - new_dim.w = readBUF(buf); + n = readBUF(buf); + c = readBUF(buf); + h = readBUF(buf); + w = readBUF(buf); assert(buf == bufCheck + length); } @@ -31,8 +33,6 @@ Dims ReshapeRT::getOutputDimensions(int index, const Dims *inputs, int nbInputDi return Dims3{ c,h,w} ; } -void ReshapeRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs,DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT {} - int ReshapeRT::initialize() NOEXCEPT { return 0; } @@ -48,11 +48,10 @@ int ReshapeRT::enqueue(int batchSize, const void *const *inputs, void *const *ou cudaStream_t stream) NOEXCEPT { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *dstData = reinterpret_cast(outputs[0]); - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); return 0; } -#elif NV_TENSORRT_MAJOR == 7 +#elif NV_TENSORRT_MAJOR <= 7 int32_t ReshapeRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { std::cout << new_dim.c << ":" << new_dim.h << std::endl; dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -83,11 +82,11 @@ bool ReshapeRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEP } const char *ReshapeRT::getPluginType() const NOEXCEPT { - return "ReshapeRT_tkDNN"; + return RESHAPERT_PLUGIN_NAME; } const char *ReshapeRT::getPluginVersion() const NOEXCEPT { - return "1"; + return RESHAPERT_PLUGIN_VERSION; } void ReshapeRT::destroy() NOEXCEPT { @@ -102,14 +101,47 @@ void ReshapeRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2 *ReshapeRT::clone() const NOEXCEPT { - auto *p = new ReshapeRT(new_dim); +IPluginV2Ext *ReshapeRT::clone() const NOEXCEPT { + auto *p = new ReshapeRT(n,c,h,w); p->setPluginNamespace(mPluginNamespace.c_str()); return p; } +DataType ReshapeRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void ReshapeRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool +ReshapeRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, int nbInputs) const NOEXCEPT { + return false; +} + +bool ReshapeRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void ReshapeRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT { + +} + +void ReshapeRT::detachFromContext() NOEXCEPT { + +} + ReshapeRTPluginCreator::ReshapeRTPluginCreator() { mPluginAttributes.clear(); + mPluginAttributes.emplace_back(PluginField("n", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -122,26 +154,34 @@ const char *ReshapeRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *ReshapeRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +IPluginV2Ext *ReshapeRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { auto *pluginObj = new ReshapeRT(serialData,serialLength); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } -IPluginV2 *ReshapeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *ReshapeRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - dataDim_t newDim = *(static_cast(fields[0].data)); - ReshapeRT *pluginObj = new ReshapeRT(newDim); + assert(fc->nbFields == 4); + for(int i=0;i<4;i++){ + assert(fields[1].type == PluginFieldType::kINT32); + } + int n = *(static_cast(fields[0].data)); + int c = *(static_cast(fields[1].data)); + int h = *(static_cast(fields[2].data)); + int w = *(static_cast(fields[3].data)); + + auto *pluginObj = new ReshapeRT(n,c,h,w); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } const char *ReshapeRTPluginCreator::getPluginName() const NOEXCEPT { - return "ReshapeRT_tkDNN"; + return RESHAPERT_PLUGIN_NAME; } const char *ReshapeRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return RESHAPERT_PLUGIN_VERSION; } const PluginFieldCollection *ReshapeRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/src/pluginsRT/ResizeLayerRT.cpp b/src/pluginsRT/ResizeLayerRT.cpp index dd8c912..db98326 100644 --- a/src/pluginsRT/ResizeLayerRT.cpp +++ b/src/pluginsRT/ResizeLayerRT.cpp @@ -5,10 +5,13 @@ std::vector ResizeLayerRTPluginCreator::mPluginAttributes; PluginFieldCollection ResizeLayerRTPluginCreator::mFC{}; -ResizeLayerRT::ResizeLayerRT(int c, int h, int w) { - o_c = c; - o_h = h; - o_w = w; +ResizeLayerRT::ResizeLayerRT(int oc, int oh, int ow,int ic,int ih,int iw) { + this->o_c = oc; + this->o_h = oh; + this->o_w = ow; + this->i_c = ic; + this->i_h = ih; + this->i_w = iw; } ResizeLayerRT::ResizeLayerRT(const void *data, size_t length) { @@ -32,13 +35,6 @@ Dims ResizeLayerRT::getOutputDimensions(int index, const Dims *inputs, int nbInp return Dims3{o_c, o_h, o_w}; } -void ResizeLayerRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, - DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { - i_c = inputDims[0].d[0]; - i_h = inputDims[0].d[1]; - i_w = inputDims[0].d[2]; -} - int ResizeLayerRT::initialize() NOEXCEPT { return 0; } @@ -55,7 +51,7 @@ int ResizeLayerRT::enqueue(int batchSize, const void *const *inputs, void *const batchSize, i_c, i_h, i_w, o_c, o_h, o_w, stream); return 0; } -#elif NV_TENSORRT_MAJOR == 7 +#elif NV_TENSORRT_MAJOR <= 7 int32_t ResizeLayerRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { resizeForward((dnnType*)reinterpret_cast(inputs[0]), @@ -105,12 +101,42 @@ void ResizeLayerRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2 *ResizeLayerRT::clone() const NOEXCEPT { - auto *p = new ResizeLayerRT(o_c,o_h,o_w); +IPluginV2Ext *ResizeLayerRT::clone() const NOEXCEPT { + auto *p = new ResizeLayerRT(o_c,o_h,o_w,i_c,i_h,i_w); p->setPluginNamespace(mPluginNamespace.c_str()); return p; } +DataType +ResizeLayerRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void ResizeLayerRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +bool ResizeLayerRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, + int nbInputs) const NOEXCEPT { + return false; +} + +bool ResizeLayerRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void ResizeLayerRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, + const bool *inputIsBroadcast, const bool *outputIsBroadcast, + PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +void ResizeLayerRT::detachFromContext() NOEXCEPT { + +} + ResizeLayerRTPluginCreator::ResizeLayerRTPluginCreator() { mPluginAttributes.clear(); mFC.nbFields = mPluginAttributes.size(); @@ -125,22 +151,25 @@ const char *ResizeLayerRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *ResizeLayerRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +IPluginV2Ext *ResizeLayerRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { auto *pluginObj = new ResizeLayerRT(serialData,serialLength); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } -IPluginV2 *ResizeLayerRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *ResizeLayerRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - assert(fc->nbFields == 3); - assert(fields[0].type == PluginFieldType::kINT32); - assert(fields[1].type == PluginFieldType::kINT32); - assert(fields[2].type == PluginFieldType::kINT32); + assert(fc->nbFields == 6); + for(int i=0;i<6;i++){ + assert(fields[i].type == PluginFieldType::kINT32); + } int oc = *(static_cast(fields[0].data)); int oh = *(static_cast(fields[1].data)); int ow = *(static_cast(fields[2].data)); - auto *pluginObj = new ResizeLayerRT(oc,oh,ow); + int ic = *(static_cast(fields[3].data)); + int ih = *(static_cast(fields[4].data)); + int iw = *(static_cast(fields[5].data)); + auto *pluginObj = new ResizeLayerRT(oc,oh,ow,ic,ih,iw); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } diff --git a/src/pluginsRT/ShortcutRT.cpp b/src/pluginsRT/ShortcutRT.cpp index 3cedffa..ea18b0e 100644 --- a/src/pluginsRT/ShortcutRT.cpp +++ b/src/pluginsRT/ShortcutRT.cpp @@ -4,22 +4,26 @@ using namespace nvinfer1; std::vector ShortcutRTPluginCreator::mPluginAttributes; PluginFieldCollection ShortcutRTPluginCreator::mFC{}; -ShortcutRT::ShortcutRT(tk::dnn::dataDim_t bdim, bool mul) { - bDim = bdim; - this->bc = bDim.c; - this->bh = bDim.h; - this->bw = bDim.w; +static const char* SHORTCUTRT_PLUGIN_VERSION{"1"}; +static const char* SHORTCUTRT_PLUGIN_NAME{"ShortcutRT_tkDNN"}; + +ShortcutRT::ShortcutRT(int bc,int bh,int bw,int c,int h,int w,bool mul) { + this->bc = bc; + this->bh = bh; + this->bw = bw; this->mul = mul; + this->c = c; + this->h = h; + this->w = w; } ShortcutRT::~ShortcutRT() {} ShortcutRT::ShortcutRT(const void *data, size_t length) { const char* buf =reinterpret_cast(data),*bufCheck = buf; - bDim.c = readBUF(buf); - bDim.h = readBUF(buf); - bDim.w = readBUF(buf); - bDim.l = 1; + bc = readBUF(buf); + bh = readBUF(buf); + bw = readBUF(buf); mul = readBUF(buf); c = readBUF(buf); h = readBUF(buf); @@ -35,13 +39,6 @@ Dims ShortcutRT::getOutputDimensions(int index, const Dims *inputs, int nbInputD return Dims3{inputs[0].d[0], inputs[0].d[1], inputs[0].d[2]}; } -void ShortcutRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, - DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; -} - int ShortcutRT::initialize() NOEXCEPT { return 0; } @@ -62,7 +59,7 @@ int ShortcutRT::enqueue(int batchSize, const void *const *inputs, void *const *o return 0; } -#elif NV_TENSORRT_MAJOR == 7 +#elif NV_TENSORRT_MAJOR <= 7 int32_t ShortcutRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -98,11 +95,11 @@ bool ShortcutRT::supportsFormat(DataType type, PluginFormat format) const NOEXCE } const char *ShortcutRT::getPluginType() const NOEXCEPT { - return "ShortcutRT_tkDNN"; + return SHORTCUTRT_PLUGIN_NAME; } const char *ShortcutRT::getPluginVersion() const NOEXCEPT { - return "1"; + return SHORTCUTRT_PLUGIN_VERSION; } void ShortcutRT::destroy() NOEXCEPT { @@ -117,14 +114,50 @@ void ShortcutRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2 *ShortcutRT::clone() const NOEXCEPT { - auto *p = new ShortcutRT(bDim,mul); +IPluginV2Ext *ShortcutRT::clone() const NOEXCEPT { + auto *p = new ShortcutRT(bc,bh,bw,c,h,w,mul); p->setPluginNamespace(mPluginNamespace.c_str()); return p; } +void ShortcutRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT { + +} + +bool ShortcutRT::isOutputBroadcastAcrossBatch(int32_t outputIndex, const bool *inputIsBroadcasted, + int32_t nbInputs) const NOEXCEPT { + return false; +} + +bool ShortcutRT::canBroadcastInputAcrossBatch(int32_t inputIndex) const NOEXCEPT { + return false; +} + +void ShortcutRT::attachToContext(cudnnContext *, cublasContext *, IGpuAllocator *) NOEXCEPT { + +} + +void ShortcutRT::detachFromContext() NOEXCEPT { + +} + +DataType ShortcutRT::getOutputDataType(int32_t index, const nvinfer1::DataType *inputTypes, int32_t nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + + ShortcutRTPluginCreator::ShortcutRTPluginCreator() { mPluginAttributes.clear(); + mPluginAttributes.emplace_back(PluginField("bc", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("bh", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("bw", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("mul", nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -137,28 +170,33 @@ const char *ShortcutRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *ShortcutRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +IPluginV2Ext *ShortcutRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { auto *pluginObj = new ShortcutRT(serialData,serialLength); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } -IPluginV2 *ShortcutRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *ShortcutRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - //todo assert - tk::dnn::dataDim_t bdim = *(static_cast(fields[0].data)); - bool mul = *(static_cast(fields[1].data)); - auto *pluginObj = new ShortcutRT(bdim,mul); + assert(fc->nbFields == 7); + int bc = *(static_cast(fields[0].data)); + int bh = *(static_cast(fields[1].data)); + int bw = *(static_cast(fields[2].data)); + bool mul = *(static_cast(fields[3].data)); + int c = *(static_cast(fields[4].data)); + int h = *(static_cast(fields[5].data)); + int w = *(static_cast(fields[6].data)); + auto *pluginObj = new ShortcutRT(bc,bh,bw,c,h,w,mul); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } const char *ShortcutRTPluginCreator::getPluginName() const NOEXCEPT { - return "ShortcutRT_tkDNN"; + return SHORTCUTRT_PLUGIN_NAME; } const char *ShortcutRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return SHORTCUTRT_PLUGIN_VERSION; } const PluginFieldCollection *ShortcutRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/src/pluginsRT/UpsampleRT.cpp b/src/pluginsRT/UpsampleRT.cpp index d08a3ca..6859984 100644 --- a/src/pluginsRT/UpsampleRT.cpp +++ b/src/pluginsRT/UpsampleRT.cpp @@ -4,8 +4,14 @@ using namespace nvinfer1; std::vector UpsampleRTPluginCreator::mPluginAttributes; PluginFieldCollection UpsampleRTPluginCreator::mFC{}; -UpsampleRT::UpsampleRT(int stride) { +static const char* UPSAMPLERT_PLUGIN_VERSION{"1"}; +static const char* UPSAMPLERT_PLUGIN_NAME{"UpSample_tkDNN"}; + +UpsampleRT::UpsampleRT(int stride,int c,int h,int w) { this->stride = stride; + this->h = h; + this->c = c; + this->w = w; } UpsampleRT::UpsampleRT(const void *data, size_t length) { @@ -27,12 +33,7 @@ Dims UpsampleRT::getOutputDimensions(int index, const Dims *inputs, int nbInputD return Dims3(inputs[0].d[0], inputs[0].d[1]*stride, inputs[0].d[2]*stride); } -void UpsampleRT::configureWithFormat(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, - DataType type, PluginFormat format, int maxBatchSize) NOEXCEPT { - c = inputDims[0].d[0]; - h = inputDims[0].d[1]; - w = inputDims[0].d[2]; -} + int UpsampleRT::initialize() NOEXCEPT { return 0; @@ -47,14 +48,14 @@ size_t UpsampleRT::getWorkspaceSize(int maxBatchSize) const NOEXCEPT { #if NV_TENSORRT_MAJOR > 7 int UpsampleRT::enqueue(int batchSize, const void *const *inputs, void *const *outputs, void *workspace, cudaStream_t stream) NOEXCEPT { - dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); - dnnType *dstData = reinterpret_cast(outputs[0]); + auto *srcData = (dnnType*)reinterpret_cast(inputs[0]); + auto *dstData = reinterpret_cast(outputs[0]); fill(dstData, batchSize*c*h*w*stride*stride, 0.0, stream); upsampleForward(srcData, dstData, batchSize, c, h, w, stride, 1, 1, stream); return 0; } -#elif NV_TENSORRT_MAJOR == 7 +#elif NV_TENSORRT_MAJOR <= 7 int32_t UpsampleRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); @@ -84,11 +85,11 @@ bool UpsampleRT::supportsFormat(DataType type, PluginFormat format) const NOEXCE } const char *UpsampleRT::getPluginType() const NOEXCEPT { - return "Upsample_tkDNN"; + return UPSAMPLERT_PLUGIN_NAME; } const char *UpsampleRT::getPluginVersion() const NOEXCEPT { - return "1"; + return UPSAMPLERT_PLUGIN_VERSION; } void UpsampleRT::destroy() NOEXCEPT { @@ -103,14 +104,45 @@ void UpsampleRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { mPluginNamespace = pluginNamespace; } -IPluginV2 *UpsampleRT::clone() const NOEXCEPT { - auto *p = new UpsampleRT(stride); +IPluginV2Ext *UpsampleRT::clone() const NOEXCEPT { + auto *p = new UpsampleRT(stride,c,h,w); p->setPluginNamespace(mPluginNamespace.c_str()); return p; } +bool UpsampleRT::isOutputBroadcastAcrossBatch(int32_t outputIndex, const bool *inputIsBroadcasted, + int32_t nbInputs) const NOEXCEPT { + return false; +} + +bool UpsampleRT::canBroadcastInputAcrossBatch(int32_t inputIndex) const NOEXCEPT { + return false; +} + +void UpsampleRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, + int32_t maxBatchSize) NOEXCEPT { + +} + +void UpsampleRT::attachToContext(cudnnContext *, cublasContext *, IGpuAllocator *) NOEXCEPT { +} + +void UpsampleRT::detachFromContext() NOEXCEPT { + +} + +DataType UpsampleRT::getOutputDataType(int32_t index, const nvinfer1::DataType *inputTypes, int32_t nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + UpsampleRTPluginCreator::UpsampleRTPluginCreator() { mPluginAttributes.clear(); + mPluginAttributes.emplace_back(PluginField("stride", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -123,26 +155,29 @@ const char *UpsampleRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *UpsampleRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +IPluginV2Ext *UpsampleRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { auto *pluginObj = new UpsampleRT(serialData,serialLength); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } -IPluginV2 *UpsampleRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *UpsampleRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; int stride = *(static_cast(fields[0].data)); - auto *pluginObj = new UpsampleRT(stride); + int c = *(static_cast(fields[1].data)); + int h = *(static_cast(fields[2].data)); + int w = *(static_cast(fields[3].data)); + auto *pluginObj = new UpsampleRT(stride,c,h,w); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } const char *UpsampleRTPluginCreator::getPluginName() const NOEXCEPT { - return "Upsample_tkDNN"; + return UPSAMPLERT_PLUGIN_NAME; } const char *UpsampleRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return UPSAMPLERT_PLUGIN_VERSION; } const PluginFieldCollection *UpsampleRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp index c191afd..aa99415 100644 --- a/src/pluginsRT/YoloRT.cpp +++ b/src/pluginsRT/YoloRT.cpp @@ -1,12 +1,21 @@ #include + +#include using namespace nvinfer1; std::vector YoloRTPluginCreator::mPluginAttributes; PluginFieldCollection YoloRTPluginCreator::mFC{}; -YoloRT::YoloRT(int classes, int num, tk::dnn::Yolo *Yolo, int n_masks, float scale_xy, float nms_thresh, int nms_kind, +static const char* YOLORT_PLUGIN_VERSION{"1"}; +static const char* YOLORT_PLUGIN_NAME{"YoloRT_tkDNN"}; + +YoloRT::YoloRT(int classes, int num, int c,int h,int w,std::vector classNames, + std::vector masks_v,std::vector bias_v,int n_masks, float scale_xy, + float nms_thresh, int nms_kind, int new_coords) { - this->yolo = Yolo; + this->c = c; + this->h = h; + this->w = w; this->classes = classes; this->num = num; this->n_masks = n_masks; @@ -14,14 +23,10 @@ YoloRT::YoloRT(int classes, int num, tk::dnn::Yolo *Yolo, int n_masks, float sca this->nms_thresh = nms_thresh; this->nms_kind = nms_kind; this->new_coords = new_coords; + this->classesNames = std::move(classNames); + this->mask = std::move(masks_v); + this->bias = std::move(bias_v); - mask = new dnnType[n_masks]; - bias = new dnnType[num * n_masks * 2]; - if (yolo != nullptr) { - memcpy(mask, yolo->mask_h, sizeof(dnnType) * n_masks); - memcpy(bias, yolo->bias_h, sizeof(dnnType) * num * n_masks * 2); - classesNames = yolo->classesNames; - } } YoloRT::YoloRT(const void *data, size_t length) { @@ -38,16 +43,14 @@ YoloRT::YoloRT(const void *data, size_t length) { c = readBUF(buf); h = readBUF(buf); w = readBUF(buf); + mask.resize(n_masks); for(int i=0;i(buf)); - std::cout<(buf); } + bias.resize(n_masks*2*num); for(int i=0;i(buf)); - std::cout<(buf); } - mask = maskTemp.data(); - bias = biasTemp.data(); classesNames.resize(classes); for(int i=0;isetPluginNamespace(mPluginNamespace.c_str()); return p; } +DataType YoloRT::getOutputDataType(int index, const nvinfer1::DataType *inputTypes, int nbInputs) const NOEXCEPT { + return DataType::kFLOAT; +} + +void YoloRT::attachToContext(cudnnContext *cudnnContext, cublasContext *cublasContext, + IGpuAllocator *gpuAllocator) NOEXCEPT { + +} + +void YoloRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const Dims *outputDims, int32_t nbOutputs, + const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, + const bool *outputIsBroadcast, PluginFormat floatFormat, int32_t maxBatchSize) NOEXCEPT { + +} + +bool YoloRT::isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, int nbInputs) const NOEXCEPT { + return false; +} + +bool YoloRT::canBroadcastInputAcrossBatch(int inputIndex) const NOEXCEPT { + return false; +} + +void YoloRT::detachFromContext() NOEXCEPT { + +} + YoloRTPluginCreator::YoloRTPluginCreator() { mPluginAttributes.clear(); + mPluginAttributes.emplace_back(PluginField("classes", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("num", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("classNames", nullptr,PluginFieldType::kUNKNOWN,1)); + mPluginAttributes.emplace_back(PluginField("mask_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("bias_v", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("n_masks", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("scaleXy", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nms_thresh", nullptr,PluginFieldType::kFLOAT32,1)); + mPluginAttributes.emplace_back(PluginField("nms_kind", nullptr,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("new_coords", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } @@ -229,34 +267,37 @@ const char *YoloRTPluginCreator::getPluginNamespace() const NOEXCEPT { return mPluginNamespace.c_str(); } -IPluginV2 *YoloRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { +IPluginV2Ext *YoloRTPluginCreator::deserializePlugin(const char *name, const void *serialData, size_t serialLength) NOEXCEPT { auto *pluginObj = new YoloRT(serialData,serialLength); pluginObj->setPluginNamespace(mPluginNamespace.c_str()); return pluginObj; } -IPluginV2 *YoloRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { +IPluginV2Ext *YoloRTPluginCreator::createPlugin(const char *name, const PluginFieldCollection *fc) NOEXCEPT { const PluginField *fields = fc->fields; - //todo assert int classes = *(static_cast(fields[0].data)); int num = *(static_cast(fields[1].data)); - Yolo *yoloTemp = const_cast(static_cast(fields[2].data)); - int numMasks = *(static_cast(fields[3].data)); - float scaleXY = *(static_cast(fields[4].data)); - float nmsThresh = *(static_cast(fields[5].data)); - int nmsKind = *(static_cast(fields[6].data)); - int newCoords = *(static_cast(fields[7].data)); - YoloRT *pluginObj = new YoloRT(classes,num,yoloTemp,numMasks,scaleXY,nmsThresh,nmsKind,newCoords); - pluginObj->setPluginNamespace(mPluginNamespace.c_str()); + int c = *(static_cast(fields[2].data)); + int h = *(static_cast(fields[3].data)); + int w = *(static_cast(fields[4].data)); + std::vector classNames(static_cast(fields[5].data),static_cast(fields[5].data) + fields[5].length); + std::vector mask_v(static_cast(fields[6].data),static_cast(fields[6].data) + fields[6].length); + std::vector bias_v(static_cast(fields[7].data),static_cast(fields[7].data) + fields[7].length); + int n_masks = *(static_cast(fields[8].data)); + dnnType scaleXY = *(static_cast(fields[9].data)); + dnnType nmsThresh = *(static_cast(fields[10].data)); + int nms_kind = *(static_cast(fields[11].data)); + int new_coords = *(static_cast(fields[12].data)); + auto *pluginObj = new YoloRT(classes,num,c,h,w,classNames,mask_v,bias_v,n_masks,scaleXY,nmsThresh,nms_kind,new_coords); return pluginObj; } const char *YoloRTPluginCreator::getPluginName() const NOEXCEPT { - return "YoloRT_tkDNN"; + return YOLORT_PLUGIN_NAME; } const char *YoloRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return YOLORT_PLUGIN_VERSION; } const PluginFieldCollection *YoloRTPluginCreator::getFieldNames() NOEXCEPT { diff --git a/tests/centernet/dla34_cnet/dla34_cnet.cpp b/tests/centernet/dla34_cnet/dla34_cnet.cpp index 97a5b2a..303c30a 100644 --- a/tests/centernet/dla34_cnet/dla34_cnet.cpp +++ b/tests/centernet/dla34_cnet/dla34_cnet.cpp @@ -540,5 +540,6 @@ int main() std::cout<<"CUDNN vs TRT "; ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; } + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/centernet/dla34_cnet3d/dla34_cnet3d.cpp b/tests/centernet/dla34_cnet3d/dla34_cnet3d.cpp index 939d4c5..3e6c02f 100644 --- a/tests/centernet/dla34_cnet3d/dla34_cnet3d.cpp +++ b/tests/centernet/dla34_cnet3d/dla34_cnet3d.cpp @@ -558,5 +558,6 @@ int main() std::cout<<"CUDNN vs TRT "; ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; } + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/centernet/resnet101_cnet/resnet101_cnet.cpp b/tests/centernet/resnet101_cnet/resnet101_cnet.cpp index 787422c..df1ae93 100644 --- a/tests/centernet/resnet101_cnet/resnet101_cnet.cpp +++ b/tests/centernet/resnet101_cnet/resnet101_cnet.cpp @@ -421,5 +421,6 @@ int main() std::cout<<"CUDNN vs TRT "; ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; } + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/mobilenet/mobilenetv2ssd/mobilenetv2ssd.cpp b/tests/mobilenet/mobilenetv2ssd/mobilenetv2ssd.cpp index 58463a4..e10737e 100644 --- a/tests/mobilenet/mobilenetv2ssd/mobilenetv2ssd.cpp +++ b/tests/mobilenet/mobilenetv2ssd/mobilenetv2ssd.cpp @@ -541,6 +541,6 @@ int main() std::cout << "CUDNN vs TRT " << std::endl; ret_cudnn_tensorrt |= checkResult(conf->output_dim.tot(), conf->dstData, rt_out3) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; ret_cudnn_tensorrt |= checkResult(loc->output_dim.tot(), loc->dstData, rt_out4) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; - + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/mobilenet/mobilenetv2ssd512/mobilenetv2ssd512.cpp b/tests/mobilenet/mobilenetv2ssd512/mobilenetv2ssd512.cpp index 0a817c1..b6c8593 100644 --- a/tests/mobilenet/mobilenetv2ssd512/mobilenetv2ssd512.cpp +++ b/tests/mobilenet/mobilenetv2ssd512/mobilenetv2ssd512.cpp @@ -553,6 +553,6 @@ int main() std::cout << "CUDNN vs TRT " << std::endl; ret_cudnn_tensorrt |= checkResult(conf->output_dim.tot(), conf->dstData, rt_out3) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; ret_cudnn_tensorrt |= checkResult(loc->output_dim.tot(), loc->dstData, rt_out4) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; - + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/shelfnet/shelfnet.cpp b/tests/shelfnet/shelfnet.cpp index 48cad04..07c7f6e 100644 --- a/tests/shelfnet/shelfnet.cpp +++ b/tests/shelfnet/shelfnet.cpp @@ -290,6 +290,6 @@ int main() cv::Mat viz = vizLayer2Mat(&net, net.num_layers-1); cv::imwrite("test.png", viz); - + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/shelfnet/shelfnet_berkeley.cpp b/tests/shelfnet/shelfnet_berkeley.cpp index 5ee21df..bacb507 100644 --- a/tests/shelfnet/shelfnet_berkeley.cpp +++ b/tests/shelfnet/shelfnet_berkeley.cpp @@ -290,6 +290,6 @@ int main() cv::Mat viz = vizLayer2Mat(&net, net.num_layers-1); cv::imwrite("test.png", viz); - + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/shelfnet/shelfnet_mapillary.cpp b/tests/shelfnet/shelfnet_mapillary.cpp index fd92305..6c8b0ce 100644 --- a/tests/shelfnet/shelfnet_mapillary.cpp +++ b/tests/shelfnet/shelfnet_mapillary.cpp @@ -292,6 +292,6 @@ int main() cv::Mat viz = vizLayer2Mat(&net, net.num_layers-1); cv::imwrite("test.png", viz); - + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } -- 2.52.0 From 7a89a4a5738e4d5b76d0d95cc2dfbcc45bd637ee Mon Sep 17 00:00:00 2001 From: perseusdg Date: Thu, 28 Oct 2021 23:43:12 +0530 Subject: [PATCH 18/32] ReshapeRT.cpp fix --- src/pluginsRT/ReshapeRT.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp index dbe59c0..43cf8af 100644 --- a/src/pluginsRT/ReshapeRT.cpp +++ b/src/pluginsRT/ReshapeRT.cpp @@ -53,11 +53,10 @@ int ReshapeRT::enqueue(int batchSize, const void *const *inputs, void *const *ou } #elif NV_TENSORRT_MAJOR <= 7 int32_t ReshapeRT::enqueue(int32_t batchSize, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) { - std::cout << new_dim.c << ":" << new_dim.h << std::endl; dnnType *srcData = (dnnType*)reinterpret_cast(inputs[0]); dnnType *dstData = reinterpret_cast(outputs[0]); std::cout << "C : " << c << "H : " << h << "w :" << w << std::endl; - checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*new_dim.c*new_dim.h*new_dim.w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); + checkCuda( cudaMemcpyAsync(dstData, srcData, batchSize*c*h*w*sizeof(dnnType), cudaMemcpyDeviceToDevice, stream)); return 0; } #endif -- 2.52.0 From 802c01bd8f75fa67b51173f8668c8b518a09b421 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 30 Oct 2021 19:29:21 +0530 Subject: [PATCH 19/32] windows debug fix --- CMakeLists.txt | 2 +- demo/demo/demo.cpp | 2 +- src/pluginsRT/DeformableConvRT.cpp | 25 ------------------------- src/pluginsRT/FlattenConcatRT.cpp | 5 ----- src/pluginsRT/RegionRT.cpp | 6 ------ src/pluginsRT/ReorgRT.cpp | 4 ---- src/pluginsRT/ReshapeRT.cpp | 4 ---- src/pluginsRT/ShortcutRT.cpp | 7 ------- src/pluginsRT/UpsampleRT.cpp | 4 ---- src/pluginsRT/YoloRT.cpp | 13 ------------- 10 files changed, 2 insertions(+), 70 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index bfdb426..a574fe5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,7 +8,7 @@ if (CUDA_FOUND) #Get CUDA compute capability set(OUTPUTFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/cuda_script) # No suffix required set(CUDAFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/getCudaArch.cu) - execute_process(COMMAND nvcc -lcuda ${CUDAFILE} -o ${OUTPUTFILE}) + execute_process(COMMAND ${CUDA_NVCC_EXECUTABLE} -lcuda ${CUDAFILE} -o ${OUTPUTFILE}) execute_process(COMMAND ${OUTPUTFILE} RESULT_VARIABLE CUDA_RETURN_CODE OUTPUT_VARIABLE ARCH) diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index fbfbb6f..c3afcda 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -40,7 +40,7 @@ int main(int argc, char *argv[]) { #ifdef __linux__ std::string input = "../demo/yolo_test.mp4"; #elif _WIN32 - std::string input = "..\\..\\..\\demo\\yolo_test.mp4"; + std::string input = "..\\demo\\yolo_test.mp4"; #endif char ntype = 'y'; diff --git a/src/pluginsRT/DeformableConvRT.cpp b/src/pluginsRT/DeformableConvRT.cpp index 1dc4d1a..1c1df84 100644 --- a/src/pluginsRT/DeformableConvRT.cpp +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -291,31 +291,6 @@ bool DeformableConvRT::supportsFormat(DataType type, PluginFormat format) const DeformableConvRTPluginCreator::DeformableConvRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("chunk_dim", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("kh", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("kw", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("sh", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("sw", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("ph", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("pw", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("deformable_group", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_n", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("i_w", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_n", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("o_w", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("mask_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("offset_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("ones_d2_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("ones_d1_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("data_d_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("bias2_d_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("height_ones", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("width_ones", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("dim_ones", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/FlattenConcatRT.cpp b/src/pluginsRT/FlattenConcatRT.cpp index c281579..53036ff 100644 --- a/src/pluginsRT/FlattenConcatRT.cpp +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -163,11 +163,6 @@ bool FlattenConcatRT::supportsFormat(DataType type, PluginFormat format) const N FlattenConcatRTPluginCreator::FlattenConcatRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("rows", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("cols", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/RegionRT.cpp b/src/pluginsRT/RegionRT.cpp index 2d9899c..249c48a 100644 --- a/src/pluginsRT/RegionRT.cpp +++ b/src/pluginsRT/RegionRT.cpp @@ -170,12 +170,6 @@ void RegionRT::detachFromContext() NOEXCEPT { RegionRTPluginCreator::RegionRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("classes", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("coords", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("num", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ReorgRT.cpp b/src/pluginsRT/ReorgRT.cpp index b1e7b1f..e3a18df 100644 --- a/src/pluginsRT/ReorgRT.cpp +++ b/src/pluginsRT/ReorgRT.cpp @@ -133,10 +133,6 @@ void ReorgRT::detachFromContext() NOEXCEPT { ReorgRTPluginCreator::ReorgRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("stride", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp index 43cf8af..f026d3a 100644 --- a/src/pluginsRT/ReshapeRT.cpp +++ b/src/pluginsRT/ReshapeRT.cpp @@ -137,10 +137,6 @@ void ReshapeRT::detachFromContext() NOEXCEPT { ReshapeRTPluginCreator::ReshapeRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("n", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/ShortcutRT.cpp b/src/pluginsRT/ShortcutRT.cpp index ea18b0e..2a126bb 100644 --- a/src/pluginsRT/ShortcutRT.cpp +++ b/src/pluginsRT/ShortcutRT.cpp @@ -151,13 +151,6 @@ DataType ShortcutRT::getOutputDataType(int32_t index, const nvinfer1::DataType * ShortcutRTPluginCreator::ShortcutRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("bc", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("bh", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("bw", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("mul", nullptr,PluginFieldType::kUNKNOWN,1)); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/UpsampleRT.cpp b/src/pluginsRT/UpsampleRT.cpp index 6859984..21ee95a 100644 --- a/src/pluginsRT/UpsampleRT.cpp +++ b/src/pluginsRT/UpsampleRT.cpp @@ -139,10 +139,6 @@ DataType UpsampleRT::getOutputDataType(int32_t index, const nvinfer1::DataType * UpsampleRTPluginCreator::UpsampleRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("stride", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp index aa99415..3612c4e 100644 --- a/src/pluginsRT/YoloRT.cpp +++ b/src/pluginsRT/YoloRT.cpp @@ -242,19 +242,6 @@ void YoloRT::detachFromContext() NOEXCEPT { YoloRTPluginCreator::YoloRTPluginCreator() { mPluginAttributes.clear(); - mPluginAttributes.emplace_back(PluginField("classes", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("num", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("c", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("h", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("w", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("classNames", nullptr,PluginFieldType::kUNKNOWN,1)); - mPluginAttributes.emplace_back(PluginField("mask_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("bias_v", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("n_masks", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("scaleXy", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("nms_thresh", nullptr,PluginFieldType::kFLOAT32,1)); - mPluginAttributes.emplace_back(PluginField("nms_kind", nullptr,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("new_coords", nullptr,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); } -- 2.52.0 From d6fb6c6af44498c19fd49c0870c75fbf648f28d2 Mon Sep 17 00:00:00 2001 From: Micaela Verucchi Date: Thu, 4 Nov 2021 19:28:55 +0100 Subject: [PATCH 20/32] Fix max elem (remove thrust) for segmentation Signed-off-by: Micaela Verucchi --- src/kernels/postprocessing.cu | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/kernels/postprocessing.cu b/src/kernels/postprocessing.cu index 63643eb..c175e1f 100644 --- a/src/kernels/postprocessing.cu +++ b/src/kernels/postprocessing.cu @@ -46,11 +46,16 @@ void maxElem_kernel(float *src_begin, float *dst_begin, const int n_classes, con if (i > size) return; - thrust::device_ptr dPbeg ( &src_begin[i*n_classes] ) ; - thrust::device_ptr dPend = dPbeg + n_classes; - thrust::device_ptr result = thrust::max_element(thrust::device,dPbeg, dPend); + float max = 0; + int max_idx = 0; + for( int j = i*n_classes; j < i*n_classes + n_classes; ++j ){ + if( src_begin[j] > max ){ + max = src_begin[j]; + max_idx = j; + } + } - dst_begin[i] = result - dPbeg; + dst_begin[i] = max_idx - i*n_classes; } void maxElem(dnnType *src_begin, dnnType *dst_begin, const int c, const int h, const int w){ -- 2.52.0 From d2d44e9e92a86849b4754b416d635a908c341290 Mon Sep 17 00:00:00 2001 From: Micaela Verucchi Date: Thu, 4 Nov 2021 19:28:55 +0100 Subject: [PATCH 21/32] Fix max elem (remove thrust) for segmentation Signed-off-by: Micaela Verucchi --- src/kernels/postprocessing.cu | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/src/kernels/postprocessing.cu b/src/kernels/postprocessing.cu index 63643eb..c175e1f 100644 --- a/src/kernels/postprocessing.cu +++ b/src/kernels/postprocessing.cu @@ -46,11 +46,16 @@ void maxElem_kernel(float *src_begin, float *dst_begin, const int n_classes, con if (i > size) return; - thrust::device_ptr dPbeg ( &src_begin[i*n_classes] ) ; - thrust::device_ptr dPend = dPbeg + n_classes; - thrust::device_ptr result = thrust::max_element(thrust::device,dPbeg, dPend); + float max = 0; + int max_idx = 0; + for( int j = i*n_classes; j < i*n_classes + n_classes; ++j ){ + if( src_begin[j] > max ){ + max = src_begin[j]; + max_idx = j; + } + } - dst_begin[i] = result - dPbeg; + dst_begin[i] = max_idx - i*n_classes; } void maxElem(dnnType *src_begin, dnnType *dst_begin, const int c, const int h, const int w){ -- 2.52.0 From 744396fb0e60e3873307ac1be1d1fc430bb9ee5c Mon Sep 17 00:00:00 2001 From: perseusdg Date: Tue, 9 Nov 2021 13:37:26 +0530 Subject: [PATCH 22/32] Update README.md,windows.md and demo.cpp Small fixes in DeformableConvRT.cpp --- CMakeLists.txt | 18 ++++++++++++------ README.md | 9 +++++---- demo/demo/demo.cpp | 12 ++++++------ docs/demo.md | 30 +++++++++++++++++++----------- docs/windows.md | 25 ++++++++++++++++--------- src/pluginsRT/DeformableConvRT.cpp | 5 +++-- 6 files changed, 61 insertions(+), 38 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index a574fe5..cbb2fb6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,10 +3,12 @@ project(tkDNN) set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake) set(CMAKE_CXX_STANDARD 14) +option(ENABLE_OPENCV_CUDA_CONTRIB "Enable OpenCV CUDA Contrib" OFF ) + find_package(CUDA 9.0 REQUIRED) if (CUDA_FOUND) - #Get CUDA compute capability set(OUTPUTFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/cuda_script) # No suffix required + execute_process(COMMAND "rm ${OUTPUTFILE}") set(CUDAFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/getCudaArch.cu) execute_process(COMMAND ${CUDA_NVCC_EXECUTABLE} -lcuda ${CUDAFILE} -o ${OUTPUTFILE}) execute_process(COMMAND ${OUTPUTFILE} @@ -25,10 +27,7 @@ if (CUDA_FOUND) message(STATUS "CUDA Path: ${CUDA_TOOLKIT_ROOT_DIR}") message(STATUS "CUDA Libararies: ${CUDA_LIBRARIES}") message(STATUS "CUDA Performance Primitives: ${CUDA_npp_LIBRARY}") - set(CUDA_NVCC_FLAGS "${ARCH}") - add_definitions(-DGPU) #You may not require this - else() message(WARNING ${ARCH}) endif() @@ -51,7 +50,7 @@ endif() if(WIN32) if(CMAKE_BUILD_TYPE MATCHES Release) - set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc /Md") + set(CMAKE_CXX_FLAGS "/O2 /FS /EHsc /MD") set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --maxrregcount=32) endif() @@ -70,7 +69,7 @@ if(DEBUG) endif() if(TKDNN_PATH) - message("SET TKDNN_PATH:"${TKDNN_PATH}) + message("SET TKDNN_PATH:" ${TKDNN_PATH}) add_definitions(-DTKDNN_PATH="${TKDNN_PATH}") else() add_definitions(-DTKDNN_PATH="${CMAKE_CURRENT_SOURCE_DIR}") @@ -105,6 +104,13 @@ include_directories(${EIGEN3_INCLUDE_DIR}) find_package(OpenCV REQUIRED) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DOPENCV") +if(ENABLE_OPENCV_CUDA_CONTRIB) + if (OpenCV_FOUND) + find_package(OpenCV COMPONENTS cudawarping cudaarithm) + add_compile_definitions(OPENCV_CUDACONTRIB) + message("OpenCV Cuda Contrib modules found") + endif() +endif() # if(OpenCV_CUDA_VERSION) # add_compile_definitions(OPENCV_CUDACONTRIB) # endif() diff --git a/README.md b/README.md index b630fec..2aea96a 100644 --- a/README.md +++ b/README.md @@ -104,14 +104,15 @@ bash scripts/install_OpenCV4.sh When using openCV not compiled with contrib, comment the definition of OPENCV_CUDACONTRIBCONTRIB in include/tkDNN/DetectionNN.h. When commented, the preprocessing of the networks is computed on the CPU, otherwise on the GPU. In the latter case some milliseconds are saved in the end-to-end latency. ## How to compile this repo -Build with cmake. If using Ubuntu 18.04 a new version of cmake is needed (3.15 or above). +Build with cmake. If using Ubuntu 18.04 a new version of cmake is needed (3.15 or above). +On both linux and windows ,the ```CMAKE_BUILD_TYPE``` variable needs to be defined as either ```Release``` or ```Debug```. ``` git clone https://github.com/ceccocats/tkDNN cd tkDNN mkdir build cd build -cmake .. -make +cmake -DCMAKE_BUILD_TYPE=Release -G"Ninja" .. +ninja ``` ## Workflow @@ -136,7 +137,7 @@ For specific details on how to run: ![demo](https://user-images.githubusercontent.com/11562617/72547657-540e7800-388d-11ea-83c6-49dfea2a0607.gif) -## tkDNN on Windows 10 (experimental) +## tkDNN on Windows 10/11 (experimental) For specific details on how to run tkDNN on Windows 10 see [HERE](./docs/windows.md). diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index c3afcda..967c996 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -45,16 +45,16 @@ int main(int argc, char *argv[]) { char ntype = 'y'; if(argc > 2) - ntype = argv[2][0]; - int n_classes = 80; + input = argv[2]; if(argc > 3) - n_classes = atoi(argv[3]); + ntype = argv[3][0]; + int n_classes = 80; if(argc > 4) - cfgPath = argv[4]; + n_classes = atoi(argv[4]); if(argc > 5) - namePath = argv[5]; + cfgPath = argv[5]; if(argc > 6) - input = argv[6]; + namePath = argv[6]; int n_batch = 1; if(argc > 7) n_batch = atoi(argv[7]); diff --git a/docs/demo.md b/docs/demo.md index cc93dd4..93f3691 100644 --- a/docs/demo.md +++ b/docs/demo.md @@ -26,27 +26,35 @@ rm yolo4_fp32.rt # be sure to delete(or move) old tensorRT files ``` If you get problems in the creation, try to check the error activating the debug of TensorRT in this way: ``` -cmake .. -DDEBUG=True +cmake .. -DCMAKE_BUILD_TYPE=Debug -DDEBUG=True make ``` -Once you have successfully created your rt file, run the demo: +Once you have successfully created your rt file, run the demo(yolo) : ``` -./demo yolo4_fp32.rt ../demo/yolo_test.mp4 y +./demo yolo4_fp32.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/cococ.names ``` + +To run demo for mobilenet and centernet for the created rt file : +``` +./demo mobilenetv2ssd_fp32.rt m 20 +``` + In general the demo program takes 7 parameters: ``` -./demo +./demo ``` where -* `````` is the rt file generated by a test -* ```<``` is the path to a video file or a camera input -* `````` is the type of network. Thee types are currently supported: ```y``` (YOLO family), ```c``` (CenterNet family) and ```m``` (MobileNet-SSD family) -* ``````is the number of classes the network is trained on -* `````` number of batches to use in inference (N.B. you should first export TKDNN_BATCHSIZE to the required n_batches and create again the rt file for the network). -* `````` if set to 0 the demo will not show the visualization but save the video into result.mp4 (if n-batches ==1) -* `````` confidence threshold for the detector. Only bounding boxes with threshold greater than conf-thresh will be displayed. +* `````` is the rt file generated by a test +* ```<``` is the path to a video file or a camera input +* `````` is the type of network. Thee types are currently supported: ```y``` (YOLO family), ```c``` (CenterNet family) and ```m``` (MobileNet-SSD family) +* ``````is the number of classes the network is trained on +* ``` ```is the relative path to the config file (only for darknet based networks) used to train the network +* ``````is the relative path to the names file (only for darknet based networks) used to train the network +* `````` number of batches to use in inference (N.B. you should first export TKDNN_BATCHSIZE to the required n_batches and create again the rt file for the network). +* `````` if set to 0 the demo will not show the visualization but save the video into result.mp4 (if n-batches ==1) +* `````` confidence threshold for the detector. Only bounding boxes with threshold greater than conf-thresh will be displayed. N.B. By default it is used FP32 inference diff --git a/docs/windows.md b/docs/windows.md index 60813c5..7ea52b1 100644 --- a/docs/windows.md +++ b/docs/windows.md @@ -7,17 +7,18 @@ - [Run the demo on Windows](#run-the-demo-on-windows) - [FP16 inference windows](#fp16-inference-windows) - [INT8 inference windows](#int8-inference-windows) + - [Run tkDNN on WSL2 with cuda](#tkdnn-on-cuda-wsl) - [Known issues with tkDNN on Windows](#known-issues-with-tkdnn-on-windows) ### Dependencies-Windows This branch should work on every NVIDIA GPU supported in windows with the following dependencies: * WINDOWS 10 1803 or HIGHER -* CUDA 10.0 (Recommended CUDA 11.2 ) -* CUDNN 7.6 (Recommended CUDNN 8.1.1 ) -* TENSORRT 6.0.1 (Recommended TENSORRT 7.2.3.4 ) -* OPENCV 3.4 (Recommended OPENCV 4.2.0 ) -* MSVC 16.7 +* CUDA 11.2 +* CUDNN 8.1.1 +* TENSORRT 7.2.3 +* OPENCV 4.2 +* MSVC 16.9+ * YAML-CPP * EIGEN3 * 7ZIP (ADD TO PATH) @@ -58,7 +59,7 @@ To run the object detection file create .rt file bu running: Once the rt file has been successfully create,run the demo using the following command: ``` -.\demo.exe yolo4tiny_fp32.rt ..\demo\yolo_test.mp4 y +.\demo.exe yolo4_fp32.rt ..\demo\yolo_test.mp4 y 80 ..\tests\darknet\cfg\yolo4.cfg ..\tests\darknet\names\cococ.names ``` For general info on more demo paramters,check Run the demo section on top To run the test_all_tests.sh on windows,use git bash or msys2 @@ -85,11 +86,17 @@ del /f yolo4tiny_int8.rt # be sure to delete(or move) old tensorRT files ``` +### Run tkDNN on WSL2 with cuda +tkDNN works on wsl2 with cuda,although not all networks (centernet,mobilenet) work properly. +If you encounter issues with running the network as a result of driver not found or cuda launch error,running the following command should solve the issue +```cp /usr/lib/wsl/lib/lib* /usr/lib/x86_64-linux-gnu/ ``` + + + ### Known issues with tkDNN on Windows -Mobilenet and Centernet demos work properly only when built with msvc 16.7 in Release Mode,when built in debug mode for the mentioned networks one might encounter opencv assert errors +In theory all models (centernet,mobilenet,darknet,centertrack,cnet3d and shelfnet) should work on Windows. -All Darknet models work properly with demo using MSVC version(16.7-16.9) +On pascal cards(sm 6x) ,nvidia cuda wsl driver 510.06 don't work well with tkDNN both on windows and cuda wsl , Nvidia drivers >465+ and < 500 are completely supported . -It is recommended to use Nvidia Driver(465+),Cuda unknown errors have been observed when using older drivers on pascal(SM 61) devices. diff --git a/src/pluginsRT/DeformableConvRT.cpp b/src/pluginsRT/DeformableConvRT.cpp index 1c1df84..9b7222d 100644 --- a/src/pluginsRT/DeformableConvRT.cpp +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -65,7 +65,6 @@ DeformableConvRT::~DeformableConvRT() { checkCuda( cudaFree(offset) ); checkCuda( cudaFree(mask) ); checkCuda( cudaFree(ones_d2) ); - cublasDestroy(handle); } DeformableConvRT::DeformableConvRT(const void *data, size_t length) { @@ -229,7 +228,9 @@ void DeformableConvRT::serialize(void *buffer) const NOEXCEPT { assert(buf == a + getSerializationSize()); } -void DeformableConvRT::destroy() NOEXCEPT { delete this; } +void DeformableConvRT::destroy() NOEXCEPT { + delete this; +} const char *DeformableConvRT::getPluginNamespace() const NOEXCEPT { -- 2.52.0 From c0e209739733b3b63ecbff79c03c9ce98b8eeda5 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Wed, 10 Nov 2021 12:30:57 +0530 Subject: [PATCH 23/32] - CMakeLists.txt opencv cuda contrib autodetect - Updated Docker to cuda-11.3+cudnn-8.2.1+TensorRT-8.0.34,Ubuntu to 20.04 and OpenCV to 4.5.4 - Updated OpenCV4 to 4.5.4 in install_OpenCV4.sh - Updated README.md --- CMakeLists.txt | 9 +++++-- README.md | 24 ++++++++--------- docker/Dockerfile.base | 32 +++++++++++------------ docs/demo.md | 14 +++++----- docs/windows.md | 2 +- scripts/install_OpenCV4.sh | 10 +++++-- tests/centernet/dla34_cnet/dla34_cnet.cpp | 8 +++--- 7 files changed, 55 insertions(+), 44 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index cbb2fb6..e90d975 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -107,8 +107,13 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DOPENCV") if(ENABLE_OPENCV_CUDA_CONTRIB) if (OpenCV_FOUND) find_package(OpenCV COMPONENTS cudawarping cudaarithm) - add_compile_definitions(OPENCV_CUDACONTRIB) - message("OpenCV Cuda Contrib modules found") + if(OpenCV_cudawarping_FOUND AND OpenCV_cudaarithm_FOUND) + add_compile_definitions(OPENCV_CUDACONTRIB) + message("OpenCV Cuda Contrib modules found") + else() + message("OpenCV Cuda Contrib modules not found") + set(ENABLE_OPENCV_CUDA_CONTRIB OFF) + endif() endif() endif() # if(OpenCV_CUDA_VERSION) diff --git a/README.md b/README.md index 2aea96a..d07ac42 100644 --- a/README.md +++ b/README.md @@ -17,10 +17,9 @@ If you use tkDNN in your research, please cite the [following paper](https://iee } ``` -### What's new (20 July 2021) -- [x] Support to sematic segmentation [README](docs/README_seg.md) -- [x] Support 2D/3D Object Detection and Tracking [README](docs/README_2d3dtracking.md) -- [ ] Support to TensorRT8 (WIP) +### What's new (November 2021) +- [x] Support to sematic segmentation on cuda 11+ [README](docs/README_seg.md) +- [x] Support to TensorRT8 ## FPS Results Inference FPS of yolov4 with tkDNN, average of 1200 images with the same dimension as the input size, on @@ -75,17 +74,17 @@ Results for COCO val 2017 (5k images), on RTX 2080Ti, with conf threshold=0.001 - [Workflow](#workflow) - [Exporting weights](#exporting-weights) - [Run the demos](#run-the-demos) - - [tkDNN on Windows 10 (experimental)](#tkdnn-on-windows-10-experimental) + - [tkDNN on Windows 10 or Windows 11](#tkdnn-on-windows-10-or-windows-11) - [Existing tests and supported networks](#existing-tests-and-supported-networks) - [References](#references) ## Dependencies This branch works on every NVIDIA GPU that supports the following (latest tested) dependencies: -* CUDA 11.0 (or >= 10) [the segmentation only works with CUDA 10 for now] -* cuDNN 8.0.4 (or >= 7.3) -* TensorRT 7.2.0 (or >=5) -* OpenCV 4.5.2 (or >=4) +* CUDA 11.3 (or >= 10.2) [the segmentation only works with CUDA 10 for now] +* cuDNN 8.2.1 (or >= 8.0.4) +* TensorRT 8.0.3 (or >=7.2) +* OpenCV 4.5.4 (or >=4) * cmake 3.21 (or >= 3.15) * yaml-cpp 0.5.2 * eigen3 3.3.4 @@ -101,7 +100,8 @@ To compile and install OpenCV4 with contrib us the script ```install_OpenCV4.sh` ``` bash scripts/install_OpenCV4.sh ``` -When using openCV not compiled with contrib, comment the definition of OPENCV_CUDACONTRIBCONTRIB in include/tkDNN/DetectionNN.h. When commented, the preprocessing of the networks is computed on the CPU, otherwise on the GPU. In the latter case some milliseconds are saved in the end-to-end latency. +If you have OpenCV compiled with cuda and contrib and want to use it with tkDNN pass ```ENABLE_OPENCV_CUDA_CONTRIB=ON``` flag when compiling tkDBB +. If the flag is not passed,the preprocessing of the networks is computed on the CPU, otherwise on the GPU. In the latter case some milliseconds are saved in the end-to-end latency. ## How to compile this repo Build with cmake. If using Ubuntu 18.04 a new version of cmake is needed (3.15 or above). @@ -137,9 +137,9 @@ For specific details on how to run: ![demo](https://user-images.githubusercontent.com/11562617/72547657-540e7800-388d-11ea-83c6-49dfea2a0607.gif) -## tkDNN on Windows 10/11 (experimental) +## tkDNN on Windows 10 or Windows 11 -For specific details on how to run tkDNN on Windows 10 see [HERE](./docs/windows.md). +For specific details on how to run tkDNN on Windows 10/11 see [HERE](./docs/windows.md). ## Existing tests and supported networks diff --git a/docker/Dockerfile.base b/docker/Dockerfile.base index e61b0d3..8abb594 100644 --- a/docker/Dockerfile.base +++ b/docker/Dockerfile.base @@ -1,16 +1,14 @@ -FROM nvidia/cuda:10.2-cudnn7-devel-ubuntu18.04 +FROM nvidia/cuda:11.3.1-devel-ubuntu20.04 LABEL maintainer "Francesco Gatti" - -ADD nv-tensorrt-repo-ubuntu1804-cuda10.2-trt7.0.0.11-ga-20191216_1-1_amd64.deb /tmp/trt.deb -RUN apt-get update && dpkg -i /tmp/trt.deb && rm /tmp/trt.deb && apt-get update -RUN apt install -y libnvinfer7=7.0.0-1+cuda10.2 libnvinfer-dev=7.0.0-1+cuda10.2 -RUN DEBIAN_FRONTEND=noninteractive apt install -y git wget libeigen3-dev libyaml-cpp-dev +ENV DEBIAN_FRONTEND=noninteractive +RUN apt-get update && apt-get install libcudnn8-dev=8.2.1.32-1+cuda11.3 libcudnn8=8.2.1.32-1+cuda11.3 libnvinfer-dev=8.0.3-1+cuda11.3 libnvinfer8=8.0.3-1+cuda11.3 +RUN DEBIAN_FRONTEND=noninteractive apt-get update && apt install -y git wget libeigen3-dev libyaml-cpp-dev gcc-9 g++-9 libopengl-dev libgl-dev RUN cd /tmp && \ - wget https://github.com/Kitware/CMake/releases/download/v3.17.3/cmake-3.17.3-Linux-x86_64.sh && \ - chmod +x cmake-3.17.3-Linux-x86_64.sh && \ - ./cmake-3.17.3-Linux-x86_64.sh --prefix=/usr/local --exclude-subdir --skip-license && \ - rm ./cmake-3.17.3-Linux-x86_64.sh - + wget https://github.com/Kitware/CMake/releases/download/v3.21.4/cmake-3.21.4-Linux-x86_64.sh && \ + chmod +x cmake-3.21.4-Linux-x86_64.sh && \ + ./cmake-3.21.4-Linux-x86_64.sh --prefix=/usr/local --exclude-subdir --skip-license && \ + rm ./cmake-3.21.4-Linux-x86_64.sh +ENV NVIDIA_VISIBLE_DEVICES all RUN echo "INSTALL OPENCV" RUN apt-get install -y build-essential \ unzip \ @@ -26,20 +24,21 @@ RUN apt-get install -y build-essential \ libx264-dev \ libgtk-3-dev \ libatlas-base-dev \ - gfortran \ + gfortran-9 \ + libtbb-dev \ libgstreamer1.0-dev \ libgstreamer-plugins-base1.0-dev \ libdc1394-22-dev \ libavresample-dev -RUN cd && wget https://github.com/opencv/opencv/archive/4.3.0.tar.gz && tar -xf 4.3.0.tar.gz && rm *.tar.gz -RUN cd && wget https://github.com/opencv/opencv_contrib/archive/4.3.0.tar.gz && tar -xf 4.3.0.tar.gz && rm *.tar.gz +RUN cd && wget https://github.com/opencv/opencv/archive/4.5.4.tar.gz && tar -xf 4.5.4.tar.gz && rm *.tar.gz +RUN cd && wget https://github.com/opencv/opencv_contrib/archive/4.5.4.tar.gz && tar -xf 4.5.4.tar.gz && rm *.tar.gz RUN cd && \ - cd opencv-4.3.0 && mkdir build && cd build && \ + cd opencv-4.5.4 && mkdir build && cd build && \ cmake -D CMAKE_BUILD_TYPE=RELEASE \ -D CMAKE_INSTALL_PREFIX=/usr/local \ -D INSTALL_PYTHON_EXAMPLES=OFF \ -D INSTALL_C_EXAMPLES=OFF \ - -D OPENCV_EXTRA_MODULES_PATH='~/opencv_contrib-4.3.0/modules' \ + -D OPENCV_EXTRA_MODULES_PATH='~/opencv_contrib-4.5.4/modules' \ -D BUILD_EXAMPLES=OFF \ -D WITH_CUDA=ON \ -D CUDA_ARCH_BIN=7.2 \ @@ -47,6 +46,7 @@ RUN cd && \ -D ENABLE_FAST_MATH=ON \ -D CUDA_FAST_MATH=ON \ -D WITH_CUBLAS=ON \ + -D WITH_OPENMP=ON \ -D WITH_LIBV4L=ON \ -D WITH_GSTREAMER=ON \ -D WITH_GSTREAMER_0_10=OFF \ diff --git a/docs/demo.md b/docs/demo.md index 93f3691..b14baf7 100644 --- a/docs/demo.md +++ b/docs/demo.md @@ -32,7 +32,7 @@ make Once you have successfully created your rt file, run the demo(yolo) : ``` -./demo yolo4_fp32.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/cococ.names +./demo yolo4_fp32.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/coco.names ``` To run demo for mobilenet and centernet for the created rt file : @@ -67,9 +67,9 @@ N.B. By default it is used FP32 inference To run the demo with FP16 inference follow these steps (example with yolov3): ``` export TKDNN_MODE=FP16 # set the half floating point optimization -rm yolo3_fp16.rt # be sure to delete(or move) old tensorRT files -./test_yolo3 # run the yolo test (is slow) -./demo yolo3_fp16.rt ../demo/yolo_test.mp4 y +rm yolo4_fp16.rt # be sure to delete(or move) old tensorRT files +./test_yolo4 # run the yolo test (is slow) +./demo yolo4_fp16.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/coco.names ``` N.B. Using FP16 inference will lead to some errors in the results (first or second decimal). @@ -92,9 +92,9 @@ Then a complete example using yolo3 and COCO dataset would be: export TKDNN_MODE=INT8 export TKDNN_CALIB_LABEL_PATH=../demo/COCO_val2017/all_labels.txt export TKDNN_CALIB_IMG_PATH=../demo/COCO_val2017/all_images.txt -rm yolo3_int8.rt # be sure to delete(or move) old tensorRT files -./test_yolo3 # run the yolo test (is slow) -./demo yolo3_int8.rt ../demo/yolo_test.mp4 y +rm yolo4_int8.rt # be sure to delete(or move) old tensorRT files +./test_yolo4 # run the yolo test (is slow) +./demo yolo4_int8.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/coco.names ``` N.B. diff --git a/docs/windows.md b/docs/windows.md index 7ea52b1..fced442 100644 --- a/docs/windows.md +++ b/docs/windows.md @@ -13,7 +13,7 @@ ### Dependencies-Windows This branch should work on every NVIDIA GPU supported in windows with the following dependencies: -* WINDOWS 10 1803 or HIGHER +* WINDOWS 10 1803/WINDOWS 11 or HIGHER * CUDA 11.2 * CUDNN 8.1.1 * TENSORRT 7.2.3 diff --git a/scripts/install_OpenCV4.sh b/scripts/install_OpenCV4.sh index f57c87b..0871fa3 100644 --- a/scripts/install_OpenCV4.sh +++ b/scripts/install_OpenCV4.sh @@ -27,17 +27,21 @@ sudo apt-get install -y build-essential \ libgstreamer1.0-dev \ libgstreamer-plugins-base1.0-dev \ libdc1394-22-dev \ - libavresample-dev + libavresample-dev \ + libtbb-dev \ git clone https://github.com/opencv/opencv.git +cd opencv && git checkout 4.5.4 && cd .. git clone https://github.com/opencv/opencv_contrib.git +cd opencv_contrib && git checkout 4.5.4 && cd .. + python3 -m venv opencv4 source opencv4/bin/activate pip install wheel pip install numpy -cd opencv && mkdir build && cd build +cd opencv && mkdir build && cd build cmake -D CMAKE_BUILD_TYPE=RELEASE \ -D CMAKE_INSTALL_PREFIX=/usr/local \ @@ -56,6 +60,8 @@ cmake -D CMAKE_BUILD_TYPE=RELEASE \ -D WITH_GSTREAMER=ON \ -D WITH_GSTREAMER_0_10=OFF \ -D WITH_TBB=ON \ + -D WITH_OPENGL=ON \ + -D WITH_VULKAN=ON \ ../ make -j4 diff --git a/tests/centernet/dla34_cnet/dla34_cnet.cpp b/tests/centernet/dla34_cnet/dla34_cnet.cpp index 303c30a..3763f0f 100644 --- a/tests/centernet/dla34_cnet/dla34_cnet.cpp +++ b/tests/centernet/dla34_cnet/dla34_cnet.cpp @@ -492,7 +492,7 @@ int main() // } //convert network to tensorRT - tk::dnn::NetworkRT netRT(&net, net.getNetworkRTName("dla34_cnet")); + tk::dnn::NetworkRT *netRT = new tk::dnn::NetworkRT(&net, net.getNetworkRTName("dla34_cnet")); tk::dnn::dataDim_t dim1 = dim; //input dim printCenteredTitle(" CUDNN inference ", '=', 30); @@ -509,7 +509,7 @@ int main() { dim2.print(); TKDNN_TSTART - netRT.infer(dim2, data); + netRT->infer(dim2, data); TKDNN_TSTOP dim2.print(); } @@ -528,7 +528,7 @@ int main() dnnType *cudnn_out, *rt_out; cudnn_out = outs[i]->dstData; - rt_out = (dnnType *)netRT.buffersRT[i+out_count]; + rt_out = (dnnType *)netRT->buffersRT[i+out_count]; // there is the maxpool. It isn't an output but it is necessary for the process section if(i==0) out_count ++; @@ -540,6 +540,6 @@ int main() std::cout<<"CUDNN vs TRT "; ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; } - netRT.destroy(); + netRT->destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } -- 2.52.0 From 936b680f2fed527a67c313abc17a2c3e4dd1ed3e Mon Sep 17 00:00:00 2001 From: perseusdg Date: Wed, 10 Nov 2021 13:45:44 +0530 Subject: [PATCH 24/32] Remove debug prints --- src/pluginsRT/YoloRT.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp index 3612c4e..4ef62b7 100644 --- a/src/pluginsRT/YoloRT.cpp +++ b/src/pluginsRT/YoloRT.cpp @@ -31,7 +31,6 @@ YoloRT::YoloRT(int classes, int num, int c,int h,int w,std::vector YoloRT::YoloRT(const void *data, size_t length) { std::vector maskTemp,biasTemp; - std::cout<<"LENGTH : "<(data),*bufCheck = buf; classes = readBUF(buf); num = readBUF(buf); @@ -160,7 +159,6 @@ void YoloRT::serialize(void *buffer) const NOEXCEPT { char *buf = reinterpret_cast(buffer), *a = buf; writeBUF(buf, classes); //std::cout << "Classes :" << classes << std::endl; writeBUF(buf, num); //std::cout << "Num : " << num << std::endl; - std::cout< Date: Wed, 10 Nov 2021 14:37:16 +0530 Subject: [PATCH 25/32] added assert for supportsFormat in plugins --- src/pluginsRT/ActivationMishRT.cpp | 2 +- src/pluginsRT/DeformableConvRT.cpp | 2 +- src/pluginsRT/FlattenConcatRT.cpp | 2 +- src/pluginsRT/MaxPoolingSizeRT.cpp | 3 +-- src/pluginsRT/RegionRT.cpp | 2 +- src/pluginsRT/ReorgRT.cpp | 2 +- src/pluginsRT/ReshapeRT.cpp | 3 +-- src/pluginsRT/ResizeLayerRT.cpp | 3 +-- src/pluginsRT/RouteRT.cpp | 3 +-- src/pluginsRT/ShortcutRT.cpp | 2 +- src/pluginsRT/UpsampleRT.cpp | 2 +- src/pluginsRT/YoloRT.cpp | 2 +- 12 files changed, 12 insertions(+), 16 deletions(-) diff --git a/src/pluginsRT/ActivationMishRT.cpp b/src/pluginsRT/ActivationMishRT.cpp index d42b90a..f92629b 100644 --- a/src/pluginsRT/ActivationMishRT.cpp +++ b/src/pluginsRT/ActivationMishRT.cpp @@ -73,7 +73,7 @@ const char *ActivationMishRT::getPluginVersion() const NOEXCEPT { } bool ActivationMishRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *ActivationMishRT::getPluginNamespace() const NOEXCEPT { diff --git a/src/pluginsRT/DeformableConvRT.cpp b/src/pluginsRT/DeformableConvRT.cpp index 9b7222d..6af3587 100644 --- a/src/pluginsRT/DeformableConvRT.cpp +++ b/src/pluginsRT/DeformableConvRT.cpp @@ -287,7 +287,7 @@ void DeformableConvRT::detachFromContext() NOEXCEPT { } bool DeformableConvRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } DeformableConvRTPluginCreator::DeformableConvRTPluginCreator() { diff --git a/src/pluginsRT/FlattenConcatRT.cpp b/src/pluginsRT/FlattenConcatRT.cpp index 53036ff..0e500b3 100644 --- a/src/pluginsRT/FlattenConcatRT.cpp +++ b/src/pluginsRT/FlattenConcatRT.cpp @@ -158,7 +158,7 @@ FlattenConcatRT::configurePlugin(const Dims *inputDims, int32_t nbInputs, const } bool FlattenConcatRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } FlattenConcatRTPluginCreator::FlattenConcatRTPluginCreator() { diff --git a/src/pluginsRT/MaxPoolingSizeRT.cpp b/src/pluginsRT/MaxPoolingSizeRT.cpp index 5f36ae3..c45eae3 100644 --- a/src/pluginsRT/MaxPoolingSizeRT.cpp +++ b/src/pluginsRT/MaxPoolingSizeRT.cpp @@ -93,8 +93,7 @@ delete this; } bool MaxPoolFixedSizeRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; - //todo assert + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *MaxPoolFixedSizeRT::getPluginNamespace() const NOEXCEPT { diff --git a/src/pluginsRT/RegionRT.cpp b/src/pluginsRT/RegionRT.cpp index 249c48a..c31bbe6 100644 --- a/src/pluginsRT/RegionRT.cpp +++ b/src/pluginsRT/RegionRT.cpp @@ -131,7 +131,7 @@ void RegionRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { } bool RegionRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } IPluginV2Ext *RegionRT::clone() const NOEXCEPT { diff --git a/src/pluginsRT/ReorgRT.cpp b/src/pluginsRT/ReorgRT.cpp index e3a18df..8f0fa12 100644 --- a/src/pluginsRT/ReorgRT.cpp +++ b/src/pluginsRT/ReorgRT.cpp @@ -75,7 +75,7 @@ void ReorgRT::serialize(void *buffer) const NOEXCEPT { } bool ReorgRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *ReorgRT::getPluginType() const NOEXCEPT { diff --git a/src/pluginsRT/ReshapeRT.cpp b/src/pluginsRT/ReshapeRT.cpp index f026d3a..8d81a8d 100644 --- a/src/pluginsRT/ReshapeRT.cpp +++ b/src/pluginsRT/ReshapeRT.cpp @@ -76,8 +76,7 @@ void ReshapeRT::serialize(void *buffer) const NOEXCEPT { } bool ReshapeRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; - //todo assert + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *ReshapeRT::getPluginType() const NOEXCEPT { diff --git a/src/pluginsRT/ResizeLayerRT.cpp b/src/pluginsRT/ResizeLayerRT.cpp index db98326..1068f60 100644 --- a/src/pluginsRT/ResizeLayerRT.cpp +++ b/src/pluginsRT/ResizeLayerRT.cpp @@ -77,8 +77,7 @@ void ResizeLayerRT::serialize(void *buffer) const NOEXCEPT { } bool ResizeLayerRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; - //todo assert + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *ResizeLayerRT::getPluginType() const NOEXCEPT { diff --git a/src/pluginsRT/RouteRT.cpp b/src/pluginsRT/RouteRT.cpp index 3218622..3c3ca79 100644 --- a/src/pluginsRT/RouteRT.cpp +++ b/src/pluginsRT/RouteRT.cpp @@ -131,8 +131,7 @@ void RouteRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { } bool RouteRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; - //todo assert + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } IPluginV2 *RouteRT::clone() const NOEXCEPT { diff --git a/src/pluginsRT/ShortcutRT.cpp b/src/pluginsRT/ShortcutRT.cpp index 2a126bb..606f66e 100644 --- a/src/pluginsRT/ShortcutRT.cpp +++ b/src/pluginsRT/ShortcutRT.cpp @@ -91,7 +91,7 @@ void ShortcutRT::serialize(void *buffer) const NOEXCEPT { } bool ShortcutRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *ShortcutRT::getPluginType() const NOEXCEPT { diff --git a/src/pluginsRT/UpsampleRT.cpp b/src/pluginsRT/UpsampleRT.cpp index 21ee95a..af21bc0 100644 --- a/src/pluginsRT/UpsampleRT.cpp +++ b/src/pluginsRT/UpsampleRT.cpp @@ -81,7 +81,7 @@ void UpsampleRT::serialize(void *buffer) const NOEXCEPT { } bool UpsampleRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } const char *UpsampleRT::getPluginType() const NOEXCEPT { diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp index 4ef62b7..9585754 100644 --- a/src/pluginsRT/YoloRT.cpp +++ b/src/pluginsRT/YoloRT.cpp @@ -152,7 +152,7 @@ size_t YoloRT::getSerializationSize() const NOEXCEPT { } bool YoloRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { - return true; + return (type == DataType::kFLOAT && format == PluginFormat::kLINEAR); } void YoloRT::serialize(void *buffer) const NOEXCEPT { -- 2.52.0 From 9e328c0daa159de69d744ea71e0b61d053c363c5 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Wed, 10 Nov 2021 20:09:57 +0530 Subject: [PATCH 26/32] Migrate tkDNN max pooling plugin creation to pluginRegistry from the default method --- include/tkDNN/Layer.h | 1 + src/NetworkRT.cpp | 17 +++++++++++++++-- src/Pooling.cpp | 1 + src/pluginsRT/MaxPoolingSizeRT.cpp | 11 +++++++---- 4 files changed, 24 insertions(+), 6 deletions(-) diff --git a/include/tkDNN/Layer.h b/include/tkDNN/Layer.h index e09e5fa..5273c83 100644 --- a/include/tkDNN/Layer.h +++ b/include/tkDNN/Layer.h @@ -500,6 +500,7 @@ public: int winH, winW; int strideH, strideW; int paddingH, paddingW; + int padding; bool size; tkdnnPoolingMode_t pool_mode; diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index dc2e337..472b5dd 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -369,8 +369,21 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { if(l->pool_mode == tkdnnPoolingMode_t::POOLING_MAX_FIXEDSIZE) { - IPluginV2 *plugin = new MaxPoolFixedSizeRT(l->output_dim.c, l->output_dim.h, l->output_dim.w, l->output_dim.n, l->strideH, l->strideW, l->winH, l->winH-1); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + auto creator = getPluginRegistry()->getPluginCreator("MaxPoolingFixedSizeRT_tkDNN","1"); + std::vector mPluginAttributes; + PluginFieldCollection mFC{}; + mPluginAttributes.emplace_back(PluginField("c",&l->output_dim.c,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("h",&l->output_dim.h,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("w",&l->output_dim.w,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("n",&l->output_dim.n,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("strideH",&l->strideH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("strideW",&l->strideW,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("winSize",&l->winH,PluginFieldType::kINT32,1)); + mPluginAttributes.emplace_back(PluginField("padding",&l->padding,PluginFieldType::kINT32,1)); + mFC.nbFields = mPluginAttributes.size(); + mFC.fields = mPluginAttributes.data(); + auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); + auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } diff --git a/src/Pooling.cpp b/src/Pooling.cpp index 0838806..2cea2f6 100644 --- a/src/Pooling.cpp +++ b/src/Pooling.cpp @@ -17,6 +17,7 @@ Pooling::Pooling( Network *net, int winH, int winW, int strideH, int strideW, this->pool_mode = pool_mode; this->paddingH = paddingH; this->paddingW = paddingW; + this->padding = winH -1; checkCUDNN( cudnnCreatePoolingDescriptor(&poolingDesc) ); diff --git a/src/pluginsRT/MaxPoolingSizeRT.cpp b/src/pluginsRT/MaxPoolingSizeRT.cpp index c45eae3..4254ac5 100644 --- a/src/pluginsRT/MaxPoolingSizeRT.cpp +++ b/src/pluginsRT/MaxPoolingSizeRT.cpp @@ -4,6 +4,9 @@ using namespace nvinfer1; std::vector MaxPoolFixedSizeRTPluginCreator::mPluginAttributes; PluginFieldCollection MaxPoolFixedSizeRTPluginCreator::mFC{}; +static const char* MAXPOOLFIXEDSIZERT_PLUGIN_VERSION{"1"}; +static const char* MAXPOOLFIXEDSIZERT_PLUGIN_NAME{"MaxPoolingFixedSizeRT_tkDNN"}; + MaxPoolFixedSizeRT::MaxPoolFixedSizeRT(int c, int h, int w, int n, int strideH, int strideW, int winSize, int padding){ this->c = c; this->h = h; @@ -105,11 +108,11 @@ void MaxPoolFixedSizeRT::setPluginNamespace(const char *pluginNamespace) NOEXCEP } const char *MaxPoolFixedSizeRT::getPluginType() const NOEXCEPT { - return "MaxPoolingFixedSizeRT_tkDNN"; + return MAXPOOLFIXEDSIZERT_PLUGIN_NAME; } const char *MaxPoolFixedSizeRT::getPluginVersion() const NOEXCEPT { - return "1"; + return MAXPOOLFIXEDSIZERT_PLUGIN_VERSION; } IPluginV2Ext *MaxPoolFixedSizeRT::clone() const NOEXCEPT { @@ -185,11 +188,11 @@ IPluginV2Ext *MaxPoolFixedSizeRTPluginCreator::createPlugin(const char *name, co } const char *MaxPoolFixedSizeRTPluginCreator::getPluginName() const NOEXCEPT { - return "MaxPoolingFixedSizeRT_tkDNN"; + return MAXPOOLFIXEDSIZERT_PLUGIN_NAME; } const char *MaxPoolFixedSizeRTPluginCreator::getPluginVersion() const NOEXCEPT { - return "1"; + return MAXPOOLFIXEDSIZERT_PLUGIN_VERSION; } const PluginFieldCollection *MaxPoolFixedSizeRTPluginCreator::getFieldNames() NOEXCEPT { -- 2.52.0 From ee5000ccca696371f1a09c4c2979548a9375c7a5 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 13 Nov 2021 02:00:49 +0530 Subject: [PATCH 27/32] bug fixes for dla networks and ported optimization from different pull request --- CMakeLists.txt | 27 ---- include/tkDNN/NetworkRT.h | 14 +- include/tkDNN/pluginsRT/YoloRT.h | 5 +- src/NetworkRT.cpp | 41 +++--- src/pluginsRT/YoloRT.cpp | 57 ++------ tests/centernet/dla34_cnet/dla34_cnet.cpp | 8 +- tests/shelfnet/shelfnet_berkeley.cpp | 162 +++++++++++----------- 7 files changed, 122 insertions(+), 192 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index e90d975..be3be48 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,36 +6,9 @@ set(CMAKE_CXX_STANDARD 14) option(ENABLE_OPENCV_CUDA_CONTRIB "Enable OpenCV CUDA Contrib" OFF ) find_package(CUDA 9.0 REQUIRED) -if (CUDA_FOUND) - set(OUTPUTFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/cuda_script) # No suffix required - execute_process(COMMAND "rm ${OUTPUTFILE}") - set(CUDAFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/getCudaArch.cu) - execute_process(COMMAND ${CUDA_NVCC_EXECUTABLE} -lcuda ${CUDAFILE} -o ${OUTPUTFILE}) - execute_process(COMMAND ${OUTPUTFILE} - RESULT_VARIABLE CUDA_RETURN_CODE - OUTPUT_VARIABLE ARCH) - - if(${CUDA_RETURN_CODE} EQUAL 0) - set(CUDA_SUCCESS "TRUE") - else() - set(CUDA_SUCCESS "FALSE") - endif() - - if (${CUDA_SUCCESS}) - message(STATUS "CUDA Architecture: ${ARCH}") - message(STATUS "CUDA Version: ${CUDA_VERSION_STRING}") - message(STATUS "CUDA Path: ${CUDA_TOOLKIT_ROOT_DIR}") - message(STATUS "CUDA Libararies: ${CUDA_LIBRARIES}") - message(STATUS "CUDA Performance Primitives: ${CUDA_npp_LIBRARY}") - set(CUDA_NVCC_FLAGS "${ARCH}") - else() - message(WARNING ${ARCH}) - endif() -endif() SET(CUDA_SEPARABLE_COMPILATION ON) - if(UNIX) if(CMAKE_BUILD_TYPE MATCHES Release) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC -Wno-deprecated-declarations -Wno-unused-variable -O3") diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index 94a60f3..cd297ab 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -48,7 +48,7 @@ public: void* buffersRT[MAX_BUFFERS_RT]; dataDim_t buffersDIM[MAX_BUFFERS_RT]; int buf_input_idx, buf_output_idx; - + bool builderActive = false; dataDim_t input_dim, output_dim; dnnType *output; cudaStream_t stream; @@ -84,14 +84,14 @@ public: nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Pooling *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Softmax *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Route *l); - nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Flatten *l); - nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Reshape *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Flatten *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Reshape *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Resize *l); - nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Reorg *l); - nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Region *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Reorg *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Region *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Shortcut *l); - nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Yolo *l); - nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, Upsample *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Yolo *l); + nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Upsample *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, DeformConv2d *l); bool serialize(const char *filename); diff --git a/include/tkDNN/pluginsRT/YoloRT.h b/include/tkDNN/pluginsRT/YoloRT.h index 42ebcc7..352a0cb 100644 --- a/include/tkDNN/pluginsRT/YoloRT.h +++ b/include/tkDNN/pluginsRT/YoloRT.h @@ -13,8 +13,7 @@ namespace nvinfer1 { class YoloRT : public IPluginV2Ext { public: - YoloRT(int classes, int num,int c,int h,int w,std::vector classNames, - std::vector masks_v,std::vector bias_v, int n_masks = 3, float scale_xy = 1, + YoloRT(int classes, int num,int c,int h,int w, int n_masks = 3, float scale_xy = 1, float nms_thresh = 0.45, int nms_kind = 0, int new_coords = 0); YoloRT(const void *data, size_t length); @@ -84,8 +83,6 @@ namespace nvinfer1 { int NUM = 0; std::vector classesNames; - std::vector mask; - std::vector bias; int entry_index(int batch, int location, int entry) { int n = location / (w * h); diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 472b5dd..6de297a 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -148,8 +148,10 @@ NetworkRT::NetworkRT(Network *net, const char *name) { // we don't need the network any more //networkRT->destroy(); std::cout<<"serialize net\n"; + builderActive = true; serialize(name); } else { + builderActive = false; deserialize(name); } @@ -386,6 +388,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; + } else { @@ -433,14 +436,15 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { return lRT; } else if(l->act_mode == ACTIVATION_MISH) { - IPluginV2 *plugin = new ActivationMishRT(); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); - checkNULL(lRT); - return lRT; + IActivationLayer *lRT1 = networkRT->addActivation(*input, ActivationType::kSOFTPLUS); + lRT1->setAlpha(1); + lRT1->setBeta(1); + IActivationLayer *lRT2 = networkRT->addActivation(*lRT1->getOutput(0), ActivationType::kTANH); + IElementWiseLayer *lRT3 = networkRT->addElementWise(*input, *lRT2->getOutput(0), ElementWiseOperation::kPROD); + return lRT3; } else if(l->act_mode == ACTIVATION_LOGISTIC) { - IPluginV2 *plugin = new ActivationLogisticRT(); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + IActivationLayer *lRT = networkRT->addActivation(*input,ActivationType::kSIGMOID); checkNULL(lRT); return lRT; } @@ -484,7 +488,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Route *l) { return lRT; } -ILayer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { auto creator = getPluginRegistry()->getPluginCreator("FlattenConcatRT_tkDNN","1"); std::vector mPluginAttributes; PluginFieldCollection mFC{}; @@ -495,14 +499,13 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Flatten *l) { mPluginAttributes.emplace_back(PluginField("cols",&l->cols,PluginFieldType::kINT32,1)); mFC.nbFields = mPluginAttributes.size(); mFC.fields = mPluginAttributes.data(); - auto *plugin = creator->createPlugin(l->getLayerName().c_str(),&mFC); auto *lRT = networkRT->addPluginV2(&input, 1, *plugin); checkNULL(lRT); return lRT; } -ILayer* NetworkRT::convert_layer(ITensor *input, Reshape *l) { +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Reshape *l) { // std::cout<<"convert Reshape\n"; auto creator = getPluginRegistry()->getPluginCreator("ReshapeRT_tkDNN","1"); std::vector mPluginAttributes; @@ -530,7 +533,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Resize *l) { return lRT; } -ILayer* NetworkRT::convert_layer(ITensor *input, Reorg *l) { +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Reorg *l) { //std::cout<<"convert Reorg\n"; //std::cout<<"New plugin REORG\n"; @@ -549,7 +552,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Reorg *l) { return lRT; } -ILayer* NetworkRT::convert_layer(ITensor *input, Region *l) { +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Region *l) { //std::cout<<"convert Region\n"; //std::cout<<"New plugin REGION\n"; @@ -608,10 +611,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Shortcut *l) { } } -ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { - std::vector mask_h(l->mask_h,l->mask_h+sizeof(dnnType)*l->n_masks); - std::vector bias_h(l->bias_h,l->bias_h+sizeof(dnnType)*2*l->n_masks*l->num); auto creator = getPluginRegistry()->getPluginCreator("YoloRT_tkDNN","1"); std::vector mPluginAttributes; PluginFieldCollection mFC{}; @@ -620,9 +621,6 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { mPluginAttributes.emplace_back(PluginField("c",&l->input_dim.c,PluginFieldType::kINT32,1)); mPluginAttributes.emplace_back(PluginField("h",&l->input_dim.h,PluginFieldType::kINT32,1)); mPluginAttributes.emplace_back(PluginField("w",&l->input_dim.w,PluginFieldType::kINT32,1)); - mPluginAttributes.emplace_back(PluginField("classNames",&l->classesNames[0],PluginFieldType::kUNKNOWN,l->classesNames.size())); - mPluginAttributes.emplace_back(PluginField("mask_v",&mask_h[0],PluginFieldType::kFLOAT32,mask_h.size())); - mPluginAttributes.emplace_back(PluginField("bias_v",&bias_h[0],PluginFieldType::kFLOAT32,bias_h.size())); mPluginAttributes.emplace_back(PluginField("n_masks",&l->n_masks,PluginFieldType::kINT32,1)); mPluginAttributes.emplace_back(PluginField("scale_xy",&l->scaleXY,PluginFieldType::kFLOAT32,1)); mPluginAttributes.emplace_back(PluginField("nms_thresh",&l->nms_thresh,PluginFieldType::kFLOAT32,1)); @@ -636,9 +634,8 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Yolo *l) { return lRT; } -ILayer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { +IPluginV2Layer* NetworkRT::convert_layer(ITensor *input, Upsample *l) { //std::cout<<"convert Upsample\n"; - auto creator = getPluginRegistry()->getPluginCreator("UpSample_tkDNN","1"); std::vector mPluginAttributes; PluginFieldCollection mFC{}; @@ -789,8 +786,10 @@ bool NetworkRT::deserialize(const char *filename) { void NetworkRT::destroy() { contextRT->destroy(); - engineRT->destroy(); - builderRT->destroy(); + if(builderActive) { + engineRT->destroy(); + builderRT->destroy(); + } } }} diff --git a/src/pluginsRT/YoloRT.cpp b/src/pluginsRT/YoloRT.cpp index 9585754..55cb462 100644 --- a/src/pluginsRT/YoloRT.cpp +++ b/src/pluginsRT/YoloRT.cpp @@ -9,8 +9,7 @@ PluginFieldCollection YoloRTPluginCreator::mFC{}; static const char* YOLORT_PLUGIN_VERSION{"1"}; static const char* YOLORT_PLUGIN_NAME{"YoloRT_tkDNN"}; -YoloRT::YoloRT(int classes, int num, int c,int h,int w,std::vector classNames, - std::vector masks_v,std::vector bias_v,int n_masks, float scale_xy, +YoloRT::YoloRT(int classes, int num, int c,int h,int w,int n_masks, float scale_xy, float nms_thresh, int nms_kind, int new_coords) { this->c = c; @@ -23,14 +22,9 @@ YoloRT::YoloRT(int classes, int num, int c,int h,int w,std::vector this->nms_thresh = nms_thresh; this->nms_kind = nms_kind; this->new_coords = new_coords; - this->classesNames = std::move(classNames); - this->mask = std::move(masks_v); - this->bias = std::move(bias_v); - } YoloRT::YoloRT(const void *data, size_t length) { - std::vector maskTemp,biasTemp; const char* buf = reinterpret_cast(data),*bufCheck = buf; classes = readBUF(buf); num = readBUF(buf); @@ -42,21 +36,6 @@ YoloRT::YoloRT(const void *data, size_t length) { c = readBUF(buf); h = readBUF(buf); w = readBUF(buf); - mask.resize(n_masks); - for(int i=0;i(buf); - } - bias.resize(n_masks*2*num); - for(int i=0;i(buf); - } - classesNames.resize(classes); - for(int i=0;i(buf); - classesNames[1] = std::string(tmp); - } assert(buf == bufCheck + length); } @@ -147,8 +126,7 @@ int32_t YoloRT::enqueue(int32_t batchSize, const void *const *inputs, void **out size_t YoloRT::getSerializationSize() const NOEXCEPT { - return 8 * sizeof(int) + 2 * sizeof(float) + n_masks * sizeof(dnnType) + num * n_masks * 2 * sizeof(dnnType) + - YOLORT_CLASSNAME_W * classes * sizeof(char); + return 8 * sizeof(int) + 2 * sizeof(float) ; } bool YoloRT::supportsFormat(DataType type, PluginFormat format) const NOEXCEPT { @@ -167,21 +145,7 @@ void YoloRT::serialize(void *buffer) const NOEXCEPT { writeBUF(buf, c); //std::cout << "C : " << c << std::endl; writeBUF(buf, h); //std::cout << "H : " << h << std::endl; writeBUF(buf, w); //std::cout << "C : " << c << std::endl; - for (int i = 0; i < n_masks; i++) { - writeBUF(buf, mask[i]); //std::cout << "mask[i] : " << mask[i] << std::endl; - } - for (int i = 0; i < n_masks * 2 * num; i++) { - writeBUF(buf, bias[i]); //std::cout << "bias[i] : " << bias[i] << std::endl; - } - // save classes names - for (int i = 0; i < classes; i++) { - char tmp[YOLORT_CLASSNAME_W]; - strcpy(tmp, classesNames[i].c_str()); - for (int j = 0; j < YOLORT_CLASSNAME_W; j++) { - writeBUF(buf, tmp[j]); - } - } assert(buf == a + getSerializationSize()); } @@ -206,7 +170,7 @@ void YoloRT::setPluginNamespace(const char *pluginNamespace) NOEXCEPT { } IPluginV2Ext *YoloRT::clone() const NOEXCEPT { - auto *p = new YoloRT(classes, num,c,h,w,classesNames,mask,bias, n_masks, scaleXY, nms_thresh, nms_kind, new_coords); + auto *p = new YoloRT(classes, num,c,h,w,n_masks, scaleXY, nms_thresh, nms_kind, new_coords); p->setPluginNamespace(mPluginNamespace.c_str()); return p; } @@ -265,15 +229,12 @@ IPluginV2Ext *YoloRTPluginCreator::createPlugin(const char *name, const PluginFi int c = *(static_cast(fields[2].data)); int h = *(static_cast(fields[3].data)); int w = *(static_cast(fields[4].data)); - std::vector classNames(static_cast(fields[5].data),static_cast(fields[5].data) + fields[5].length); - std::vector mask_v(static_cast(fields[6].data),static_cast(fields[6].data) + fields[6].length); - std::vector bias_v(static_cast(fields[7].data),static_cast(fields[7].data) + fields[7].length); - int n_masks = *(static_cast(fields[8].data)); - dnnType scaleXY = *(static_cast(fields[9].data)); - dnnType nmsThresh = *(static_cast(fields[10].data)); - int nms_kind = *(static_cast(fields[11].data)); - int new_coords = *(static_cast(fields[12].data)); - auto *pluginObj = new YoloRT(classes,num,c,h,w,classNames,mask_v,bias_v,n_masks,scaleXY,nmsThresh,nms_kind,new_coords); + int n_masks = *(static_cast(fields[5].data)); + dnnType scaleXY = *(static_cast(fields[6].data)); + dnnType nmsThresh = *(static_cast(fields[7].data)); + int nms_kind = *(static_cast(fields[8].data)); + int new_coords = *(static_cast(fields[9].data)); + auto *pluginObj = new YoloRT(classes,num,c,h,w,n_masks,scaleXY,nmsThresh,nms_kind,new_coords); return pluginObj; } diff --git a/tests/centernet/dla34_cnet/dla34_cnet.cpp b/tests/centernet/dla34_cnet/dla34_cnet.cpp index 3763f0f..303c30a 100644 --- a/tests/centernet/dla34_cnet/dla34_cnet.cpp +++ b/tests/centernet/dla34_cnet/dla34_cnet.cpp @@ -492,7 +492,7 @@ int main() // } //convert network to tensorRT - tk::dnn::NetworkRT *netRT = new tk::dnn::NetworkRT(&net, net.getNetworkRTName("dla34_cnet")); + tk::dnn::NetworkRT netRT(&net, net.getNetworkRTName("dla34_cnet")); tk::dnn::dataDim_t dim1 = dim; //input dim printCenteredTitle(" CUDNN inference ", '=', 30); @@ -509,7 +509,7 @@ int main() { dim2.print(); TKDNN_TSTART - netRT->infer(dim2, data); + netRT.infer(dim2, data); TKDNN_TSTOP dim2.print(); } @@ -528,7 +528,7 @@ int main() dnnType *cudnn_out, *rt_out; cudnn_out = outs[i]->dstData; - rt_out = (dnnType *)netRT->buffersRT[i+out_count]; + rt_out = (dnnType *)netRT.buffersRT[i+out_count]; // there is the maxpool. It isn't an output but it is necessary for the process section if(i==0) out_count ++; @@ -540,6 +540,6 @@ int main() std::cout<<"CUDNN vs TRT "; ret_cudnn_tensorrt |= checkResult(odim, cudnn_out, rt_out) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; } - netRT->destroy(); + netRT.destroy(); return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; } diff --git a/tests/shelfnet/shelfnet_berkeley.cpp b/tests/shelfnet/shelfnet_berkeley.cpp index bacb507..88f16a5 100644 --- a/tests/shelfnet/shelfnet_berkeley.cpp +++ b/tests/shelfnet/shelfnet_berkeley.cpp @@ -9,77 +9,77 @@ const char *input_bin = "shelfnet_berkeley/debug/input.bin"; const char *backbone[] = { - "shelfnet_berkeley/layers/backbone-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer1-0-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer1-0-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer1-1-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer1-1-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer2-0-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer2-0-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer2-0-downsample-0.bin", - "shelfnet_berkeley/layers/backbone-layer2-1-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer2-1-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer3-0-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer3-0-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer3-0-downsample-0.bin", - "shelfnet_berkeley/layers/backbone-layer3-1-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer3-1-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer4-0-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer4-0-conv2.bin", - "shelfnet_berkeley/layers/backbone-layer4-0-downsample-0.bin", - "shelfnet_berkeley/layers/backbone-layer4-1-conv1.bin", - "shelfnet_berkeley/layers/backbone-layer4-1-conv2.bin"}; + "shelfnet_berkeley/layers/backbone-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer1-0-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer1-0-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer1-1-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer1-1-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer2-0-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer2-0-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer2-0-downsample-0.bin", + "shelfnet_berkeley/layers/backbone-layer2-1-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer2-1-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer3-0-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer3-0-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer3-0-downsample-0.bin", + "shelfnet_berkeley/layers/backbone-layer3-1-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer3-1-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer4-0-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer4-0-conv2.bin", + "shelfnet_berkeley/layers/backbone-layer4-0-downsample-0.bin", + "shelfnet_berkeley/layers/backbone-layer4-1-conv1.bin", + "shelfnet_berkeley/layers/backbone-layer4-1-conv2.bin"}; const char *conv_out[] = { - "shelfnet_berkeley/layers/conv_out-conv-conv.bin", - "shelfnet_berkeley/layers/conv_out-conv_out.bin", - "shelfnet_berkeley/layers/conv_out16-conv-conv.bin", - "shelfnet_berkeley/layers/conv_out16-conv_out.bin", - "shelfnet_berkeley/layers/conv_out32-conv-conv.bin", - "shelfnet_berkeley/layers/conv_out32-conv_out.bin" - }; + "shelfnet_berkeley/layers/conv_out-conv-conv.bin", + "shelfnet_berkeley/layers/conv_out-conv_out.bin", + "shelfnet_berkeley/layers/conv_out16-conv-conv.bin", + "shelfnet_berkeley/layers/conv_out16-conv_out.bin", + "shelfnet_berkeley/layers/conv_out32-conv-conv.bin", + "shelfnet_berkeley/layers/conv_out32-conv_out.bin" +}; const char *decoder[] = { - "shelfnet_berkeley/layers/decoder-bottom-conv1.bin", - "shelfnet_berkeley/layers/decoder-bottom-conv12.bin", - "shelfnet_berkeley/layers/decoder-up_conv_list-0-conv-conv.bin", - "shelfnet_berkeley/layers/decoder-up_conv_list-0-conv_atten.bin", - "shelfnet_berkeley/layers/decoder-up_dense_list-0-conv.bin", - "shelfnet_berkeley/layers/decoder-up_conv_list-1-conv-conv.bin", - "shelfnet_berkeley/layers/decoder-up_conv_list-1-conv_atten.bin", - "shelfnet_berkeley/layers/decoder-up_dense_list-1-conv.bin" - }; + "shelfnet_berkeley/layers/decoder-bottom-conv1.bin", + "shelfnet_berkeley/layers/decoder-bottom-conv12.bin", + "shelfnet_berkeley/layers/decoder-up_conv_list-0-conv-conv.bin", + "shelfnet_berkeley/layers/decoder-up_conv_list-0-conv_atten.bin", + "shelfnet_berkeley/layers/decoder-up_dense_list-0-conv.bin", + "shelfnet_berkeley/layers/decoder-up_conv_list-1-conv-conv.bin", + "shelfnet_berkeley/layers/decoder-up_conv_list-1-conv_atten.bin", + "shelfnet_berkeley/layers/decoder-up_dense_list-1-conv.bin" +}; + - const char *ladder[] = { - "shelfnet_berkeley/layers/ladder-inconv-conv1.bin", - "shelfnet_berkeley/layers/ladder-inconv-conv12.bin", - "shelfnet_berkeley/layers/ladder-down_module_list-0-conv1.bin", - "shelfnet_berkeley/layers/ladder-down_module_list-0-conv12.bin", - "shelfnet_berkeley/layers/ladder-down_conv_list-0.bin", + "shelfnet_berkeley/layers/ladder-inconv-conv1.bin", + "shelfnet_berkeley/layers/ladder-inconv-conv12.bin", + "shelfnet_berkeley/layers/ladder-down_module_list-0-conv1.bin", + "shelfnet_berkeley/layers/ladder-down_module_list-0-conv12.bin", + "shelfnet_berkeley/layers/ladder-down_conv_list-0.bin", - "shelfnet_berkeley/layers/ladder-down_module_list-1-conv1.bin", - "shelfnet_berkeley/layers/ladder-down_module_list-1-conv12.bin", - "shelfnet_berkeley/layers/ladder-down_conv_list-1.bin", + "shelfnet_berkeley/layers/ladder-down_module_list-1-conv1.bin", + "shelfnet_berkeley/layers/ladder-down_module_list-1-conv12.bin", + "shelfnet_berkeley/layers/ladder-down_conv_list-1.bin", - "shelfnet_berkeley/layers/ladder-bottom-conv1.bin", - "shelfnet_berkeley/layers/ladder-bottom-conv12.bin", - - - - "shelfnet_berkeley/layers/ladder-up_conv_list-0-conv-conv.bin", - "shelfnet_berkeley/layers/ladder-up_conv_list-0-conv_atten.bin", - "shelfnet_berkeley/layers/ladder-up_dense_list-0-conv.bin", + "shelfnet_berkeley/layers/ladder-bottom-conv1.bin", + "shelfnet_berkeley/layers/ladder-bottom-conv12.bin", - - "shelfnet_berkeley/layers/ladder-up_conv_list-1-conv-conv.bin", - "shelfnet_berkeley/layers/ladder-up_conv_list-1-conv_atten.bin", - "shelfnet_berkeley/layers/ladder-up_dense_list-1-conv.bin"}; + + + "shelfnet_berkeley/layers/ladder-up_conv_list-0-conv-conv.bin", + "shelfnet_berkeley/layers/ladder-up_conv_list-0-conv_atten.bin", + "shelfnet_berkeley/layers/ladder-up_dense_list-0-conv.bin", + + + "shelfnet_berkeley/layers/ladder-up_conv_list-1-conv-conv.bin", + "shelfnet_berkeley/layers/ladder-up_conv_list-1-conv_atten.bin", + "shelfnet_berkeley/layers/ladder-up_dense_list-1-conv.bin"}; const char *trans[] = { - "shelfnet_berkeley/layers/trans1-conv.bin", - "shelfnet_berkeley/layers/trans2-conv.bin", - "shelfnet_berkeley/layers/trans3-conv.bin"}; + "shelfnet_berkeley/layers/trans1-conv.bin", + "shelfnet_berkeley/layers/trans2-conv.bin", + "shelfnet_berkeley/layers/trans3-conv.bin"}; int main() { @@ -87,7 +87,7 @@ int main() int classes = 20; - // Network layout + // Network layout tk::dnn::dataDim_t dim(1, 3, 736, 1280, 1); tk::dnn::Network net(dim); @@ -97,7 +97,7 @@ int main() tk::dnn::Layer* last = new tk::dnn::Pooling (&net, 3, 3, 2, 2, 1, 1, tk::dnn::POOLING_MAX); - + for(int i=0; i<2; ++i){ new tk::dnn::Conv2d (&net, 64, 3, 3, 1, 1, 1, 1, backbone[bi++], true); new tk::dnn::Activation (&net, tk::dnn::ACTIVATION_LEAKY, 0.0f, 0.01); @@ -121,7 +121,7 @@ int main() new tk::dnn::Conv2d (&net, out_channel, 3, 3, 1, 1, 1, 1, backbone[bi++], true); new tk::dnn::Activation (&net, tk::dnn::ACTIVATION_LEAKY, 0.0f, 0.01); new tk::dnn::Conv2d (&net, out_channel, 3, 3, 1, 1, 1, 1, backbone[bi++], true); - + new tk::dnn::Shortcut(&net, last); last = new tk::dnn::Activation (&net, CUDNN_ACTIVATION_RELU); features.push_back(last); @@ -135,7 +135,7 @@ int main() } //DECODER - + last = features[2]; std::vector up_out; //bottom @@ -152,10 +152,10 @@ int main() std::cout<output_dim.w, last->output_dim.h, last->output_dim.w, last->output_dim.h, 0, 0, tk::dnn::POOLING_AVERAGE); new tk::dnn::Conv2d (&net, out_channel, 1, 1, 1, 1, 0, 0, decoder[di++], true); - + tk::dnn::Layer* act = new tk::dnn::Activation (&net, CUDNN_ACTIVATION_SIGMOID); new tk::dnn::Route(&net, &last, 1); new tk::dnn::Shortcut(&net, act, true); @@ -178,11 +178,11 @@ int main() new tk::dnn::Conv2d (&net, 64, 3, 3, 1, 1, 1, 1, ladder[li++], true, false, 1, true); new tk::dnn::Shortcut(&net, last); new tk::dnn::Activation (&net, CUDNN_ACTIVATION_RELU); - + for(int i=0; i<2;++i){ int out_channel = pow(2,6+i); tk::dnn::Layer* l_last = new tk::dnn::Shortcut(&net, up_out[2-i]); - + new tk::dnn::Conv2d (&net, out_channel, 3, 3, 1, 1, 1, 1, ladder[li++], true, false, 1, true); new tk::dnn::Activation (&net, tk::dnn::ACTIVATION_LEAKY, 0.0f, 0.01); new tk::dnn::Conv2d (&net, out_channel, 3, 3, 1, 1, 1, 1, ladder[li++], true, false, 1, true); @@ -207,10 +207,10 @@ int main() //up-conv new tk::dnn::Conv2d (&net, out_channel, 3, 3, 1, 1, 1, 1, ladder[li++], true); last = new tk::dnn::Activation (&net, tk::dnn::ACTIVATION_LEAKY, 0.0f, 0.01); - + new tk::dnn::Pooling(&net, last->output_dim.w, last->output_dim.h, last->output_dim.w, last->output_dim.h, 0, 0, tk::dnn::POOLING_AVERAGE); new tk::dnn::Conv2d (&net, out_channel, 1, 1, 1, 1, 0, 0, ladder[li++], true); - + tk::dnn::Layer* act = new tk::dnn::Activation (&net, CUDNN_ACTIVATION_SIGMOID); new tk::dnn::Route(&net, &last, 1); new tk::dnn::Shortcut(&net, act, true); @@ -227,17 +227,17 @@ int main() // for(int i=2;i>=0;--i){ - // new tk::dnn::Route(&net, &up_out[i], 1); - new tk::dnn::Conv2d (&net, 64, 3, 3, 1, 1, 1, 1, conv_out[ci++], true); - new tk::dnn::Activation (&net, tk::dnn::ACTIVATION_LEAKY, 0.0f, 0.01); - new tk::dnn::Conv2d (&net, classes, 3, 3, 1, 1, 1, 1, conv_out[ci++], false); - /*up_out[i] =*/ new tk::dnn::Resize(&net, classes, net.input_dim.h, net.input_dim.w, true, tk::dnn::ResizeMode_t::LINEAR); + // new tk::dnn::Route(&net, &up_out[i], 1); + new tk::dnn::Conv2d (&net, 64, 3, 3, 1, 1, 1, 1, conv_out[ci++], true); + new tk::dnn::Activation (&net, tk::dnn::ACTIVATION_LEAKY, 0.0f, 0.01); + new tk::dnn::Conv2d (&net, classes, 3, 3, 1, 1, 1, 1, conv_out[ci++], false); + /*up_out[i] =*/ new tk::dnn::Resize(&net, classes, net.input_dim.h, net.input_dim.w, true, tk::dnn::ResizeMode_t::LINEAR); // } new tk::dnn::Softmax(&net); - + const char *output_bin = "shelfnet_berkeley/debug/softmax.bin"; - + // Load input dnnType *data; dnnType *input_h; @@ -278,7 +278,7 @@ int main() int odim1 = dim1.tot(); readBinaryFile(output_bin, odim1, &out1_h, &out1); - int ret_cudnn = 0, ret_tensorrt = 0, ret_cudnn_tensorrt = 0; + int ret_cudnn = 0, ret_tensorrt = 0, ret_cudnn_tensorrt = 0; std::cout << "CUDNN vs correct" << std::endl; ret_cudnn |= checkResult(odim1, cudnn_out, out1, true, 20) == 0 ? 0 : ERROR_CUDNN; @@ -287,9 +287,9 @@ int main() std::cout << "CUDNN vs TRT " << std::endl; ret_cudnn_tensorrt |= checkResult(odim1, cudnn_out, rt_out1) == 0 ? 0 : ERROR_CUDNNvsTENSORRT; - + cv::Mat viz = vizLayer2Mat(&net, net.num_layers-1); cv::imwrite("test.png", viz); - netRT.destroy(); + return ret_cudnn | ret_tensorrt | ret_cudnn_tensorrt; -} +} \ No newline at end of file -- 2.52.0 From d488c3bd1780e9df228a22b0babc89fb4a6019a4 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 13 Nov 2021 02:12:50 +0530 Subject: [PATCH 28/32] remove duplicated lines --- src/NetworkRT.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 6de297a..743f536 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -55,13 +55,13 @@ NetworkRT::NetworkRT(Network *net, const char *name) { configRT->setMinTimingIterations(1); configRT->setMaxWorkspaceSize(1 << 30); configRT->setFlag(BuilderFlag::kDEBUG); + #endif //input and dataType dataDim_t dim = net->layers[0]->input_dim; dtRT = DataType::kFLOAT; builderRT->setMaxBatchSize(net->maxBatchSize); - configRT->setMaxWorkspaceSize(1 << 30); if(net->fp16 && builderRT->platformHasFastFp16()) { dtRT = DataType::kHALF; -- 2.52.0 From 367061fea22736101e08eeb42fe2e28c505b5a65 Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sat, 13 Nov 2021 18:11:46 +0530 Subject: [PATCH 29/32] fps fix --- src/NetworkRT.cpp | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 743f536..709b9b2 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -430,9 +430,13 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Activation *l) { return lRT; } else if(l->act_mode == CUDNN_ACTIVATION_CLIPPED_RELU) { - IPluginV2 *plugin = new ActivationReLUCeiling(l->ceiling); - IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + IActivationLayer *lRT = networkRT->addActivation(*input,ActivationType::kCLIP); + //IPluginV2 *plugin = new ActivationReLUCeiling(l->ceiling); + lRT->setAlpha(0); + lRT->setBeta(l->ceiling); checkNULL(lRT); + //IPluginV2Layer *lRT = networkRT->addPluginV2(&input, 1, *plugin); + //checkNULL(lRT); return lRT; } else if(l->act_mode == ACTIVATION_MISH) { -- 2.52.0 From 6f936096aeac6188fc3f51a372e0d76792124e2a Mon Sep 17 00:00:00 2001 From: perseusdg Date: Sun, 14 Nov 2021 07:13:42 +0530 Subject: [PATCH 30/32] Added num of layers in net and netRT,suggestions from pull request 270 on main repo --- CMakeLists.txt | 26 ++++++++++++++++++++++++++ include/tkDNN/NetworkRT.h | 2 ++ src/NetworkRT.cpp | 6 +++++- 3 files changed, 33 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index be3be48..7cc9e33 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -6,6 +6,32 @@ set(CMAKE_CXX_STANDARD 14) option(ENABLE_OPENCV_CUDA_CONTRIB "Enable OpenCV CUDA Contrib" OFF ) find_package(CUDA 9.0 REQUIRED) +if (CUDA_FOUND) + set(OUTPUTFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/cuda_script) # No suffix required + execute_process(COMMAND "rm ${OUTPUTFILE}") + set(CUDAFILE ${CMAKE_CURRENT_SOURCE_DIR}/cmake/getCudaArch.cu) + execute_process(COMMAND ${CUDA_NVCC_EXECUTABLE} -lcuda ${CUDAFILE} -o ${OUTPUTFILE}) + execute_process(COMMAND ${OUTPUTFILE} + RESULT_VARIABLE CUDA_RETURN_CODE + OUTPUT_VARIABLE ARCH) + + if(${CUDA_RETURN_CODE} EQUAL 0) + set(CUDA_SUCCESS "TRUE") + else() + set(CUDA_SUCCESS "FALSE") + endif() + + if (${CUDA_SUCCESS}) + message(STATUS "CUDA Architecture: ${ARCH}") + message(STATUS "CUDA Version: ${CUDA_VERSION_STRING}") + message(STATUS "CUDA Path: ${CUDA_TOOLKIT_ROOT_DIR}") + message(STATUS "CUDA Libararies: ${CUDA_LIBRARIES}") + message(STATUS "CUDA Performance Primitives: ${CUDA_npp_LIBRARY}") + set(CUDA_NVCC_FLAGS "${ARCH}") + else() + message(WARNING ${ARCH}) + endif() +endif() SET(CUDA_SEPARABLE_COMPILATION ON) diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index cd297ab..ddd3d9f 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -24,6 +24,8 @@ #include #include + + namespace tk { namespace dnn { using namespace nvinfer1; diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 709b9b2..2e9eb6e 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -183,7 +183,11 @@ NetworkRT::NetworkRT(Network *net, const char *name) { output_dim.h = oDim.d[1]; output_dim.w = oDim.d[2]; output_dim.print(); - + if(builderActive){ + std::cout<<"NUMBER OF LAYERS IN NETWORK : "<getNbLayers()<getNbLayers()<getNbBindings(); i++) { Dims dim = engineRT->getBindingDimensions(i); -- 2.52.0 From a8c98e3c3101cb7446648eee93a99f6ff4810855 Mon Sep 17 00:00:00 2001 From: perseusdg <43143075+perseusdg@users.noreply.github.com> Date: Fri, 19 Nov 2021 22:40:52 +0530 Subject: [PATCH 31/32] Signed-off-by: perseusdg <43143075+perseusdg@users.noreply.github.com> removed all TRT8_DEPRACTED functions --- include/tkDNN/NetworkRT.h | 5 +++ src/NetworkRT.cpp | 74 ++++++++++++++++++++++++++++++++++++--- 2 files changed, 74 insertions(+), 5 deletions(-) diff --git a/include/tkDNN/NetworkRT.h b/include/tkDNN/NetworkRT.h index ddd3d9f..cd9f649 100644 --- a/include/tkDNN/NetworkRT.h +++ b/include/tkDNN/NetworkRT.h @@ -96,7 +96,12 @@ public: nvinfer1::IPluginV2Layer* convert_layer(nvinfer1::ITensor *input, Upsample *l); nvinfer1::ILayer* convert_layer(nvinfer1::ITensor *input, DeformConv2d *l); +#if NV_TENSORRT_MAJOR > 5 && NV_TENSORRT_MAJOR < 8 bool serialize(const char *filename); +#else + bool serialize(const char *filename,nvinfer1::IHostMemory *ptr); +#endif + bool deserialize(const char *filename); void destroy(); diff --git a/src/NetworkRT.cpp b/src/NetworkRT.cpp index 2e9eb6e..76c3205 100644 --- a/src/NetworkRT.cpp +++ b/src/NetworkRT.cpp @@ -137,12 +137,16 @@ NetworkRT::NetworkRT(Network *net, const char *name) { std::cout<<"Selected maxBatchSize: "<getMaxBatchSize()<<"\n"; printCudaMemUsage(); std::cout<<"Building tensorRT cuda engine...\n"; -#if NV_TENSORRT_MAJOR >= 6 +#if NV_TENSORRT_MAJOR >= 6 && NV_TENSORRT_MAJOR <=7 engineRT = builderRT->buildEngineWithConfig(*networkRT, *configRT); -#else +#elif NV_TENSORRT_MAJOR < 6 engineRT = builderRT->buildCudaEngine(*networkRT); //engineRT = std::shared_ptr(builderRT->buildCudaEngine(*networkRT)); +#elif NV_TENSORRT_MAJOR >=8 + IHostMemory *serializedEngineRT = builderRT->buildSerializedNetwork(*networkRT,*configRT); + #endif +#if NV_TENSORRT_MAJOR > 5 && NV_TENSORRT_MAJOR < 8 if(engineRT == nullptr) FatalError("cloud not build cuda engine") // we don't need the network any more @@ -150,6 +154,19 @@ NetworkRT::NetworkRT(Network *net, const char *name) { std::cout<<"serialize net\n"; builderActive = true; serialize(name); +#else + if(serializedEngineRT == nullptr){ + FatalError("could not build cuda engine"); + } + std::cout<<"saving serialized network to file"<= 8 + deserialize(name); +#endif + +#endif } else { builderActive = false; deserialize(name); @@ -321,6 +338,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { } ILayer *lRT = nullptr; +#if NV_TENSORRT_MAJOR < 8 if(!l->deConv) { IConvolutionLayer *lRTconv = networkRT->addConvolution(*input, l->outputs, DimsHW{l->kernelH, l->kernelW}, w, b); @@ -341,6 +359,28 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Conv2d *l) { Dims d = lRTconv->getOutput(0)->getDimensions(); //std::cout<<"DECONV: "<deConv) { + IConvolutionLayer *lRTconv = networkRT->addConvolutionNd(*input, + l->outputs, Dims2{l->kernelH, l->kernelW}, w, b); + checkNULL(lRTconv); + lRTconv->setStrideNd(Dims2{l->strideH, l->strideW}); + lRTconv->setPaddingNd(Dims2{l->paddingH, l->paddingW}); + lRTconv->setNbGroups(l->groups); + lRT = (ILayer*) lRTconv; + } else { + IDeconvolutionLayer *lRTconv = networkRT->addDeconvolutionNd(*input, + l->outputs, Dims2{l->kernelH, l->kernelW}, w, b); + checkNULL(lRTconv); + lRTconv->setStrideNd(Dims2{l->strideH, l->strideW}); + lRTconv->setPaddingNd(Dims2{l->paddingH, l->paddingW}); + lRTconv->setNbGroups(l->groups); + lRT = (ILayer*) lRTconv; + + Dims d = lRTconv->getOutput(0)->getDimensions(); + //std::cout<<"DECONV: "<batchnorm) { @@ -396,12 +436,20 @@ ILayer* NetworkRT::convert_layer(ITensor *input, Pooling *l) { } else { +#if NV_TENSORRT_MAJOR < 8 IPoolingLayer *lRT = networkRT->addPooling(*input, ptype, DimsHW{l->winH, l->winW}); checkNULL(lRT); lRT->setPadding(DimsHW{l->paddingH, l->paddingW}); lRT->setStride(DimsHW{l->strideH, l->strideW}); return lRT; +#else + IPoolingLayer *lRT = networkRT->addPoolingNd(*input,ptype,Dims2{l->winH,l->winW}); + checkNULL(lRT); + lRT->setPaddingNd(Dims2{l->paddingH,l->paddingW}); + lRT->setStrideNd(Dims2{l->strideH,l->strideW}); + return lRT; +#endif } } @@ -753,6 +801,7 @@ ILayer* NetworkRT::convert_layer(ITensor *input, DeformConv2d *l) { return lRT3; } +#if NV_TENSORRT_MAJOR > 5 && NV_TENSORRT_MAJOR < 8 bool NetworkRT::serialize(const char *filename) { std::ofstream p(filename, std::ios::binary); @@ -769,6 +818,21 @@ bool NetworkRT::serialize(const char *filename) { ptr->destroy(); return true; } +#else +bool NetworkRT::serialize(const char *filename,nvinfer1::IHostMemory *ptr){ + std::ofstream p(filename, std::ios::binary); + if (!p) { + FatalError("could not open plan output file"); + return false; + } + + if(ptr == nullptr) + FatalError("Cant serialize network"); + + p.write(reinterpret_cast(ptr->data()), ptr->size()); + return true; +} +#endif bool NetworkRT::deserialize(const char *filename) { @@ -793,10 +857,10 @@ bool NetworkRT::deserialize(const char *filename) { } void NetworkRT::destroy() { - contextRT->destroy(); + delete contextRT; if(builderActive) { - engineRT->destroy(); - builderRT->destroy(); + delete engineRT; + delete builderRT; } } -- 2.52.0 From 9cecc5051ae3e768da08962d44cc7ad7c0d2e26a Mon Sep 17 00:00:00 2001 From: perseusdg <43143075+perseusdg@users.noreply.github.com> Date: Wed, 24 Nov 2021 03:39:57 +0530 Subject: [PATCH 32/32] -Modified Dockerfile.base to cudagl -Changed demo to take in input from demoConfig.yaml file -Readme changes for demo.md --- .gitignore | 1 + demo/demo/demo.cpp | 112 +++++++++++---------- demo/demoConfig.yaml | 22 +++++ docker/Dockerfile.base | 159 +++++++++++++++++++++++------- docker/README.md | 5 +- docker/assets/entrypoint_setup.sh | 123 +++++++++++++++++++++++ docker/assets/terminator_config | 18 ++++ docker/docker_launch.sh | 9 ++ docs/demo.md | 43 ++++---- include/tkDNN/utils.h | 17 +++- scripts/checkExecTimes.py | 37 +++++++ 11 files changed, 422 insertions(+), 124 deletions(-) create mode 100644 demo/demoConfig.yaml create mode 100755 docker/assets/entrypoint_setup.sh create mode 100644 docker/assets/terminator_config create mode 100755 docker/docker_launch.sh create mode 100644 scripts/checkExecTimes.py diff --git a/.gitignore b/.gitignore index 683834c..22f7f94 100644 --- a/.gitignore +++ b/.gitignore @@ -21,3 +21,4 @@ scripts/COCO_val2017/* scripts/COCO_val2017.zip scripts/all_labels.txt /cmake/cuda_script +/cmake-build-debug/ diff --git a/demo/demo/demo.cpp b/demo/demo/demo.cpp index 967c996..b1cf574 100644 --- a/demo/demo/demo.cpp +++ b/demo/demo/demo.cpp @@ -18,64 +18,57 @@ void sig_handler(int signo) { int main(int argc, char *argv[]) { - std::cout<<"detection\n"; signal(SIGINT, sig_handler); +#ifdef __linux__ + std::string config_file = "../demo/demoConfig.yaml"; +#elif _WIN32 + std::string config_file = "..\\..\\..\\demo\\demoConfig.yaml"; +#endif - std::string net = "yolo4tiny_fp32.rt"; - #ifdef __linux__ - std::string cfgPath = "../tests/darknet/cfg/yolo4tiny.cfg"; - #elif _WIN32 - std::string cfgPath = "..\\tests\\darknet\\cfg\\yolo4tiny.cfg"; - #endif - - #ifdef __linux__ - std::string namePath = "../tests/darknet/names/coco.names"; - #elif _WIN32 - std::string namePath = "..\\tests\\darknet\\names\\coco.names"; - #endif - - if(argc > 1) - net = argv[1]; - #ifdef __linux__ - std::string input = "../demo/yolo_test.mp4"; - #elif _WIN32 - std::string input = "..\\demo\\yolo_test.mp4"; - #endif - - char ntype = 'y'; - if(argc > 2) - input = argv[2]; - if(argc > 3) - ntype = argv[3][0]; - int n_classes = 80; - if(argc > 4) - n_classes = atoi(argv[4]); - if(argc > 5) - cfgPath = argv[5]; - if(argc > 6) - namePath = argv[6]; - int n_batch = 1; - if(argc > 7) - n_batch = atoi(argv[7]); - bool show = true; - if(argc > 8) - show = atoi(argv[8]); - float conf_thresh=0.3; - if(argc >= 9) - conf_thresh = atof(argv[9]); - - if(n_batch < 1 || n_batch > 64) - FatalError("Batch dim not supported"); - - if(!show) - SAVE_RESULT = true; - - if(ntype == 'c' || ntype == 'm'){ - cfgPath = ""; - namePath = ""; - + if(argc > 1){ + config_file = argv[1]; } + + YAML::Node conf = YAMLloadConf(config_file); + if(!conf){ + FatalError("Problem with config file"); + } + + + std::string net = YAMLgetConf(conf,"net","yolo4tiny_fp32.rt"); + if(!fileExist(net.c_str())) { + FatalError("The given network does not exist. Create the rt first."); + } + +#ifdef __linux__ + std::string input = YAMLgetConf(conf, "input", "../demo/yolo_test.mp4"); + std::string cfgPath = YAMLgetConf(conf,"cfg_input", "../tests/darknet/cfg/yolo4tiny.cfg"); + std::string namePath = YAMLgetConf(conf,"name_input","../tests/darknet/names/coco.names"); +#elif _WIN32 + std::string input = YAMLgetConf(conf, "win_input", "..\\..\\..\\demo\\yolo_test.mp4"); + std::string cfgPath = YAMLgetConf(conf,"cfg_win_input","..\\..\\..\\tests\\darknet\\cfg\\yolo4tiny.cfg"); + std::string namePath = YAMLgetConf(conf,"name_win_input","..\\..\\..\\tests\\darknet\\names\\coco.names"); +#endif + if(!fileExist(input.c_str())) + FatalError("The given input video does not exist."); + + char ntype = YAMLgetConf(conf, "ntype", 'y'); + int n_classes = YAMLgetConf(conf, "n_classes", 80); + int n_batch = YAMLgetConf(conf, "n_batch", 1); + if(n_batch < 1 || n_batch > 64) + FatalError("Batch dim not supported"); + float conf_thresh = YAMLgetConf(conf, "conf_thresh", 0.3); + bool show = YAMLgetConf(conf, "show", true); + bool save = YAMLgetConf(conf, "save", false); + + + + + + + + tk::dnn::Yolo3Detection yolo; tk::dnn::CenternetDetection cnet; tk::dnn::MobilenetDetection mbnet; @@ -98,6 +91,11 @@ int main(int argc, char *argv[]) { FatalError("Network type not allowed (3rd parameter)\n"); } + if(ntype == 'c' || ntype == 'm'){ + cfgPath = ""; + namePath = ""; + } + detNN->init(net,cfgPath,namePath,n_classes,n_batch,conf_thresh); gRun = true; @@ -109,7 +107,7 @@ int main(int argc, char *argv[]) { std::cout<<"camera started\n"; cv::VideoWriter resultVideo; - if(SAVE_RESULT) { + if(save) { int w = cap.get(cv::CAP_PROP_FRAME_WIDTH); int h = cap.get(cv::CAP_PROP_FRAME_HEIGHT); resultVideo.open("result.mp4", cv::VideoWriter::fourcc('M','P','4','V'), 30, cv::Size(w, h)); @@ -149,7 +147,7 @@ int main(int argc, char *argv[]) { cv::waitKey(1); } } - if(n_batch == 1 && SAVE_RESULT) + if(n_batch == 1 && save) resultVideo << frame; } @@ -157,7 +155,7 @@ int main(int argc, char *argv[]) { double mean = 0; std::cout<stats.begin(), detNN->stats.end())/n_batch<<" ms\n"; + std::cout<<"Min: "<<*std::min_element(detNN->stats.begin(), detNN->stats.end())/n_batch<<" ms\n"; std::cout<<"Max: "<<*std::max_element(detNN->stats.begin(), detNN->stats.end())/n_batch<<" ms\n"; for(int i=0; istats.size(); i++) mean += detNN->stats[i]; mean /= detNN->stats.size(); std::cout<<"Avg: "<> /etc/ld.so.conf.d/nvidia.conf && \ + echo "/usr/local/nvidia/lib64" >> /etc/ld.so.conf.d/nvidia.conf && \ + echo "/usr/local/cuda/lib64" >> /etc/ld.so.conf.d/nvidia.conf + + +ENV PATH /usr/local/nvidia/bin:/usr/local/cuda/bin:${PATH} +ENV LD_LIBRARY_PATH /usr/local/nvidia/lib:/usr/local/nvidia/lib64:/usr/local/cuda/lib64:/usr/lib:/usr/lib/x86_64-linux-gnu:/usr/local/lib:${LD_LIBRARY_PATH} ENV NVIDIA_VISIBLE_DEVICES all -RUN echo "INSTALL OPENCV" -RUN apt-get install -y build-essential \ - unzip \ - pkg-config \ - libjpeg-dev \ - libpng-dev \ - libtiff-dev \ - libavcodec-dev \ - libavformat-dev \ - libswscale-dev \ - libv4l-dev \ - libxvidcore-dev \ - libx264-dev \ - libgtk-3-dev \ - libatlas-base-dev \ - gfortran-9 \ - libtbb-dev \ - libgstreamer1.0-dev \ - libgstreamer-plugins-base1.0-dev \ - libdc1394-22-dev \ - libavresample-dev -RUN cd && wget https://github.com/opencv/opencv/archive/4.5.4.tar.gz && tar -xf 4.5.4.tar.gz && rm *.tar.gz -RUN cd && wget https://github.com/opencv/opencv_contrib/archive/4.5.4.tar.gz && tar -xf 4.5.4.tar.gz && rm *.tar.gz -RUN cd && \ +ENV NVIDIA_DRIVER_CAPABILITIES compute,utility,graphics + + + +RUN cd ~/build && wget https://github.com/opencv/opencv/archive/4.5.4.tar.gz && tar -xf 4.5.4.tar.gz && rm 4.5.4.tar.gz +RUN cd ~/build && wget https://github.com/opencv/opencv_contrib/archive/4.5.4.tar.gz && tar -xf 4.5.4.tar.gz && rm 4.5.4.tar.gz +RUN cd ~/build && \ cd opencv-4.5.4 && mkdir build && cd build && \ cmake -D CMAKE_BUILD_TYPE=RELEASE \ -D CMAKE_INSTALL_PREFIX=/usr/local \ -D INSTALL_PYTHON_EXAMPLES=OFF \ -D INSTALL_C_EXAMPLES=OFF \ - -D OPENCV_EXTRA_MODULES_PATH='~/opencv_contrib-4.5.4/modules' \ + -D OPENCV_EXTRA_MODULES_PATH='~/build/opencv_contrib-4.5.4/modules' \ -D BUILD_EXAMPLES=OFF \ + -D BUILD_TESTS=OFF \ + -D BUILD_PERF_TESTS=OFF \ + -D BUILD_DOCS=OFF \ -D WITH_CUDA=ON \ + -D WITH_OPENGL=ON \ + -D WITH_NVCUVID=ON \ -D CUDA_ARCH_BIN=7.2 \ - -D CUDA_ARCH_PTX="" \ + -D CUDA_ARCH_PTX=7.2 \ -D ENABLE_FAST_MATH=ON \ -D CUDA_FAST_MATH=ON \ -D WITH_CUBLAS=ON \ + -D WITH_CUDNN=ON \ -D WITH_OPENMP=ON \ + -D WITH_NONFREE=ON \ -D WITH_LIBV4L=ON \ -D WITH_GSTREAMER=ON \ -D WITH_GSTREAMER_0_10=OFF \ -D WITH_TBB=ON \ - ../ && make -j12 && make install -RUN apt clean + ../ && make -j12 && make install && ldconfig +RUN cd ~ && rm -rf build +RUN cd ~ && mkdir Development && cd Development && \ +git clone https://github.com/ceccocats/tkDNN.git && cd tkDNN && \ +mkdir build && cd build && \ +cmake -DCMAKE_BUILD_TYPE=Release .. && \ +make -j6 + +RUN apt-get clean && rm -rf /var/lib/apt/lists/* +COPY assets/entrypoint_setup.sh / +ENTRYPOINT ["/entrypoint_setup.sh"] +CMD ["terminator"] \ No newline at end of file diff --git a/docker/README.md b/docker/README.md index aec202a..15f3987 100644 --- a/docker/README.md +++ b/docker/README.md @@ -9,13 +9,10 @@ docker build -t tkdnn:build -f Dockerfile . # make nvidia docker working # follow this guide: https://github.com/NVIDIA/nvidia-docker -# dowload tensorrt -# from: https://developer.nvidia.com/compute/machine-learning/tensorrt/secure/7.0/7.0.0.11/local_repo/nv-tensorrt-repo-ubuntu1804-cuda10.2-trt7.0.0.11-ga-20191216_1-1_amd64.deb - # build image docker build -t ceccocats/tkdnn:latest -f Dockerfile.base . # run image -docker run -ti --gpus all --rm ceccocats/tkdnn:latest bash +./docker_launch.sh ``` diff --git a/docker/assets/entrypoint_setup.sh b/docker/assets/entrypoint_setup.sh new file mode 100755 index 0000000..348a4f5 --- /dev/null +++ b/docker/assets/entrypoint_setup.sh @@ -0,0 +1,123 @@ +#! /bin/bash + +CMD= + +# Functions +# TOOD: Check if we can use: getent passwd $USER to extract all variables +# TODO: Check for valid inputs, cause now it will go through even with bad inputs +check_envs () { + DOCKER_CUSTOM_USER_OK=true; + if [ -z ${DOCKER_USER_NAME+x} ]; then + DOCKER_CUSTOM_USER_OK=false; + return; + fi + + if [ -z ${DOCKER_USER_ID+x} ]; then + DOCKER_CUSTOM_USER_OK=false; + return; + else + if ! [ -z "${DOCKER_USER_ID##[0-9]*}" ]; then + echo -e "\033[1;33mWarning: User-ID should be a number. Falling back to defaults.\033[0m" + DOCKER_CUSTOM_USER_OK=false; + return; + fi + fi + + if [ -z ${DOCKER_USER_GROUP_NAME+x} ]; then + DOCKER_CUSTOM_USER_OK=false; + return; + fi + + if [ -z ${DOCKER_USER_GROUP_ID+x} ]; then + DOCKER_CUSTOM_USER_OK=false; + return; + else + if ! [ -z "${DOCKER_USER_GROUP_ID##[0-9]*}" ]; then + echo -e "\033[1;33mWarning: Group-ID should be a number. Falling back to defaults.\033[0m" + DOCKER_CUSTOM_USER_OK=false; + return; + fi + fi +} + +setup_env_user () { + USER=$1 + USER_ID=$2 + GROUP=$3 + GROUP_ID=$4 + + ## Create user + useradd -m $USER + + ## Copy zsh/sh configs + cp /root/.profile /home/$USER/ + cp /root/.bashrc /home/$USER/ + cp /root/.zshrc /home/$USER/ + ## Copy terminator configs + mkdir -p /home/$USER/.config/terminator + cp /root/.config/terminator/config /home/$USER/.config/terminator/config + cp /root/.config/terminator/background.png /home/$USER/.config/terminator/background.png + cp -rf /root/.oh-my-zsh /home/$USER/ + cp -rf /root/tkDNN /home/$USER/ + rm -rf /home/$USER/.oh-my-zsh/custom/pure.zsh-theme /home/$USER/.oh-my-zsh/custom/async.zsh + ln -s /home/$USER/.oh-my-zsh/custom/pure/pure.zsh-theme /home/$USER/.oh-my-zsh/custom/ + ln -s /home/$USER/.oh-my-zsh/custom/pure/async.zsh /home/$USER/.oh-my-zsh/custom/ + sed -i -e 's@ZSH=\"/root@ZSH=\"/home/$USER@g' /home/$USER/.zshrc + # Copy SSH keys & fix owner + if [ -d "/root/.ssh" ]; then + cp -rf /root/.ssh /home/$USER/ + chown -R $USER:$GROUP /home/$USER/.ssh + fi + + ## Fix owner + chown $USER:$GROUP /home/$USER + chown -R $USER:$GROUP /home/$USER/.config + chown $USER:$GROUP /home/$USER/.profile + chown $USER:$GROUP /home/$USER/.bashrc + chown $USER:$GROUP /home/$USER/.zshrc + chown -R $USER:$GROUP /home/$USER/.oh-my-zsh + chown -R $USER:$GROUP /home/$USER/tkDNN + + ## This a trick to keep the evnironmental variables of root which is important! + echo "if ! [ \"$DOCKER_USER_NAME\" = \"$(id -un)\" ]; then" >> /root/.bashrc + echo " cd /home/$DOCKER_USER_NAME" >> /root/.bashrc + echo " su $DOCKER_USER_NAME" >> /root/.bashrc + echo "fi" >> /root/.bashrc + + echo "if ! [ \"$DOCKER_USER_NAME\" = \"$(id -un)\" ]; then" >> /root/.zshrc + echo " cd /home/$DOCKER_USER_NAME" >> /root/.zshrc + echo " su $DOCKER_USER_NAME" >> /root/.zshrc + echo "fi" >> /root/.zshrc + + ## Setup Password-file + PASSWDCONTENTS=$(grep -v "^${USER}:" /etc/passwd) + GROUPCONTENTS=$(grep -v -e "^${GROUP}:" -e "^docker:" /etc/group) + + (echo "${PASSWDCONTENTS}" && echo "${USER}:x:$USER_ID:$GROUP_ID::/home/$USER:/bin/bash") > /etc/passwd + (echo "${GROUPCONTENTS}" && echo "${GROUP}:x:${GROUP_ID}:") > /etc/group + (if test -f /etc/sudoers ; then echo "${USER} ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers ; fi) +} + + +# ---Main--- + +# Create new user +## Check Inputs +check_envs + +## Determine user & Setup Environment +if [ $DOCKER_CUSTOM_USER_OK == true ]; then + echo " -->DOCKER_USER Input is set to '$DOCKER_USER_NAME:$DOCKER_USER_ID:$DOCKER_USER_GROUP_NAME:$DOCKER_USER_GROUP_ID'"; + echo -e "\033[0;32mSetting up environment for user=$DOCKER_USER_NAME\033[0m" + setup_env_user $DOCKER_USER_NAME $DOCKER_USER_ID $DOCKER_USER_GROUP_NAME $DOCKER_USER_GROUP_ID +else + echo " -->DOCKER_USER* variables not set. Using 'root'."; + echo -e "\033[0;32mSetting up environment for user=root\033[0m" + DOCKER_USER_NAME="root" +fi + +# Change shell to zsh +chsh -s /usr/bin/zsh $DOCKER_USER_NAME + +# Run CMD from Docker +"$@" \ No newline at end of file diff --git a/docker/assets/terminator_config b/docker/assets/terminator_config new file mode 100644 index 0000000..d65a1b3 --- /dev/null +++ b/docker/assets/terminator_config @@ -0,0 +1,18 @@ +[global_config] + title_transmit_bg_color = "#2e3436" +[keybindings] +[layouts] + [[default]] + [[[child1]]] + parent = window0 + type = Terminal + [[[window0]]] + parent = "" + type = Window +[plugins] +[profiles] + [[default]] + background_color = "#282828" + cursor_color = "#aaaaaa" + foreground_color = "#f3f3f3" + palette = "#000000:#aa0000:#00aa00:#c4a000:#3465a4:#75507b:#06989a:#d3d7cf:#88807c:#f15d22:#73c48f:#ffce51:#48b9c7:#ad7fa8:#34e2e2:#eeeeec" diff --git a/docker/docker_launch.sh b/docker/docker_launch.sh new file mode 100755 index 0000000..24adb53 --- /dev/null +++ b/docker/docker_launch.sh @@ -0,0 +1,9 @@ +xhost local:root +docker run --rm -it --runtime=nvidia --privileged --net=host --cap-add sys_ptrace -d --ipc=host \ +-v /tmp/.X11-unix:/tmp/.X11-unix -e DISPLAY=$DISPLAY \ +-v $HOME/.Xauthority:/home/$(id -un)/.Xauthority -e XAUTHORITY=/home/$(id -un)/.Xauthority \ +-e DOCKER_USER_NAME=$(id -un) \ +-e DOCKER_USER_ID=$(id -u) \ +-e DOCKER_USER_GROUP_NAME=$(id -gn) \ +-e DOCKER_USER_GROUP_ID=$(id -g) \ +-v $HOME/.ssh:/home/$(id -un)/.ssh ceccocats/tkdnn diff --git a/docs/demo.md b/docs/demo.md index b14baf7..bf6b79d 100644 --- a/docs/demo.md +++ b/docs/demo.md @@ -30,31 +30,24 @@ cmake .. -DCMAKE_BUILD_TYPE=Debug -DDEBUG=True make ``` -Once you have successfully created your rt file, run the demo(yolo) : +Once you have successfully created your rt file, run the demo: ``` -./demo yolo4_fp32.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/coco.names +./ demo ``` +In general the demo program takes 1 parameter, the `````` that is the path to che configuration file. The parameter is optional and its default value is ```"../demo/demoConfig.yaml"```. -To run demo for mobilenet and centernet for the created rt file : -``` -./demo mobilenetv2ssd_fp32.rt m 20 -``` - -In general the demo program takes 7 parameters: -``` -./demo -``` -where - -* `````` is the rt file generated by a test -* ```<``` is the path to a video file or a camera input -* `````` is the type of network. Thee types are currently supported: ```y``` (YOLO family), ```c``` (CenterNet family) and ```m``` (MobileNet-SSD family) -* ``````is the number of classes the network is trained on -* ``` ```is the relative path to the config file (only for darknet based networks) used to train the network -* ``````is the relative path to the names file (only for darknet based networks) used to train the network -* `````` number of batches to use in inference (N.B. you should first export TKDNN_BATCHSIZE to the required n_batches and create again the rt file for the network). -* `````` if set to 0 the demo will not show the visualization but save the video into result.mp4 (if n-batches ==1) -* `````` confidence threshold for the detector. Only bounding boxes with threshold greater than conf-thresh will be displayed. +The config file is a yaml file with the following attributes: +* ```net``` is the rt file generated by a test +* ```input``` is the path to a video file or a camera input (on Linux) +* ```win_input``` is the path to a video file or a camera input (on Windows) +* ```ntype``` is the type of network. Thee types are currently supported: ```y``` (YOLO family), ```c``` (CenterNet family) and ```m``` (MobileNet-SSD family) +* ```n_classes``` is the number of classes the network is trained on +* ```n_batch``` number of batches to use in inference (N.B. you should first export TKDNN_BATCHSIZE to the required n_batches and create again the rt file for the network). +* ```conf_thresh``` confidence threshold for the detector. Only bounding boxes with threshold greater than conf-thresh will be displayed. +* ```show``` if set to 0 the demo will not show the visualization (if n-batches ==1) +* ```save``` if set to 1 the demo will save the video of the demo into result.mp4 (if n-batches ==1) +* ```cfg_input``` (for linux) \ ```cfg_win_input``` (for windows) is the location of the cfg path of the network for mobilenet and centernet networks use ```" "``` +* ```name_input``` (for linux) \ ```name_win_input``` (for windows) is the location of the name path of the network for mobilenet and centernet networks use ```" "``` N.B. By default it is used FP32 inference @@ -69,7 +62,8 @@ To run the demo with FP16 inference follow these steps (example with yolov3): export TKDNN_MODE=FP16 # set the half floating point optimization rm yolo4_fp16.rt # be sure to delete(or move) old tensorRT files ./test_yolo4 # run the yolo test (is slow) -./demo yolo4_fp16.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/coco.names +#set net: yolo4_fp16.rt in the config file +./demo ``` N.B. Using FP16 inference will lead to some errors in the results (first or second decimal). @@ -94,7 +88,8 @@ export TKDNN_CALIB_LABEL_PATH=../demo/COCO_val2017/all_labels.txt export TKDNN_CALIB_IMG_PATH=../demo/COCO_val2017/all_images.txt rm yolo4_int8.rt # be sure to delete(or move) old tensorRT files ./test_yolo4 # run the yolo test (is slow) -./demo yolo4_int8.rt ../demo/yolo_test.mp4 y 80 ../tests/darknet/cfg/yolo4.cfg ../tests/darknet/names/coco.names +#set net: yolo4_int8.rt in the config file +./demo ``` N.B. diff --git a/include/tkDNN/utils.h b/include/tkDNN/utils.h index 1219ec3..a1a1f1c 100644 --- a/include/tkDNN/utils.h +++ b/include/tkDNN/utils.h @@ -6,6 +6,8 @@ #include #include #include +#include + #include "cuda.h" #include "cuda_runtime_api.h" @@ -16,7 +18,6 @@ #ifdef __linux__ #include - #endif #include @@ -161,5 +162,19 @@ static inline bool isCudaPointer(void *data) { return cudaPointerGetAttributes(&attr, data) == 0; } +inline YAML::Node YAMLloadConf(const std::string& conf_file) { + std::cerr<<"Loading YAML: "< +inline T YAMLgetConf(YAML::Node conf, std::string key, T defaultVal) { + T val = defaultVal; + if(conf && conf[key]) { + val = conf[key].as(); + } + return val; +} + #endif //UTILS_H diff --git a/scripts/checkExecTimes.py b/scripts/checkExecTimes.py new file mode 100644 index 0000000..c3e1b0b --- /dev/null +++ b/scripts/checkExecTimes.py @@ -0,0 +1,37 @@ +import sys +import pandas as pd + +if len(sys.argv) < 3: + print("Error: two csv files are needed, old first new second") + exit(1) + +old_perf_file = str(sys.argv[1]) +new_perf_file = str(sys.argv[2]) + +verbose = False +if len(sys.argv) == 4: + verbose = bool(sys.argv[3]) + +print("Comparing {} vs {}".format(old_perf_file, new_perf_file)) + +df_old = pd.read_csv (old_perf_file, sep=';', header=None, index_col=0) +df_new = pd.read_csv (new_perf_file, sep=';', header=None, index_col=0) + +for index, row in df_new.iterrows(): + if index in df_old.index: + if verbose: + print("New: ",row[1], row[2], row[3]) + print("Old: ",df_old.loc[index][1], df_old.loc[index][2], df_old.loc[index][3]) + + print(index, end=': ') + if abs(row[1] - df_old.loc[index][1]) < df_old.loc[index][1]*0.1: + print("similar performance") + elif (row[1] < df_old.loc[index][1]): + print('\x1b[3;30;42m' + 'faster' + '\x1b[0m') + elif (row[1] > df_old.loc[index][1]): + if row[1] > df_old.loc[index][1] + df_old.loc[index][1] * 0.5 : + print('\x1b[3;30;41m' + 'WAY SLOWER' + '\x1b[0m') + else: + print('\x1b[3;30;41m' + 'slower' + '\x1b[0m') + + -- 2.52.0