-
Notifications
You must be signed in to change notification settings - Fork 2.1k
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
can not create plugin namespace #47
Comments
Can you please attach the sample code? |
a common head file TRTPlugin.h, i use a macro REGISTER_ZNZTENSORRT_PLUGIN that register ConvFixLayerCreator with namespace "ZNZPLGUIN" TRTPlugin.h #pragma once
#include "NvInfer.h"
#include "NvInferPlugin.h"
#include "cuda.h"
#include <cstring>
#include <iostream>
#include <sstream>
#include <vector>
#include <assert.h>
#include <string>
#define ZNZPLUGINNAMEPLAGIN "ZNZPLGUIN"
template <typename T>
class ZNZPluginRegisterer
{
public:
ZNZPluginRegisterer() {
bool status = getPluginRegistry()->registerCreator(instance, ZNZPLUGINNAMEPLAGIN);
if (!status) {
printf("can not register plugin %s in %s", typeid(T).name(), ZNZPLUGINNAMEPLAGIN);
}
}
private:
T instance{};
};
#define REGISTER_ZNZTENSORRT_PLUGIN(name) \
static ZNZPluginRegisterer<name> ZNZPluginRegisterer##name {}
using namespace nvinfer1;
class BasePlugin : public IPluginV2Ext
{
public:
void setPluginNamespace(const char* pluginNamespace) override
{
m_PluginNameSpace.assign(pluginNamespace);
}
const char* getPluginNamespace() const override
{
return m_PluginNameSpace.c_str();
}
protected:
std::string m_PluginNameSpace;
};
class BasePluginCreator : public IPluginCreator
{
public:
void setPluginNamespace(const char* pluginNamespace) override
{
m_PluginNameSpace.assign(pluginNamespace);
}
const char* getPluginNamespace() const override
{
return m_PluginNameSpace.c_str();
}
protected:
std::string m_PluginNameSpace;
}; ConvFixLayer.h #pragma once
#include "TRTPlugin.h"
class ConvFixLayer : public BasePlugin
{
private:
int m_ic, m_ih, m_iw;
std::string m_LayerName;
public:
ConvFixLayer(const char* name, int ic, int ih, int iw) :m_LayerName(name), m_ic(ic), m_iw(iw), m_ih(ih) {
assert(ic % 4 == 0);
}
ConvFixLayer(const char* name, const void* data, size_t length);
int getNbOutputs() const { return 1; }
int initialize() { return 0; }
void terminate() {
//nothing to do
}
Dims getOutputDimensions(int index, const Dims* inputs, int nbInputDims) {
assert(nbInputDims == 1);
assert(index == 0);
return DimsCHW(inputs->d[0], inputs[0].d[1], inputs[0].d[2]);
}
size_t getWorkspaceSize(int maxBatchSize) const {
return m_ic * m_iw * m_ih * sizeof(float);
}
int enqueue(int batchSize, const void* const* inputs, void** outputs, void* workspace, cudaStream_t stream);
size_t getSerializationSize() const {
return sizeof(int) * m_ic * sizeof(int)*m_iw * sizeof(int)*m_ih;
}
void serialize(void * buff) const;
bool supportsFormat(DataType type, PluginFormat format) const {
return (type == DataType::kFLOAT && format == PluginFormat::kNCHW);
}
const char* getPluginType() const;
// Get the plugin version
const char* getPluginVersion() const;
void destroy()
{
delete this;
}
// Cloning the plugin
IPluginV2Ext* clone() const
{
// Create a new instance
IPluginV2Ext* plugin = new ConvFixLayer(m_LayerName.c_str(), m_ic, m_ih, m_iw);
// Set the namespace
plugin->setPluginNamespace(m_PluginNameSpace.c_str());
return plugin;
}
// Set plugin namespace
// Return the DataType of the plugin output at the requested index.
DataType getOutputDataType(int index, const nvinfer1::DataType* inputTypes, int nbInputs) const
{
assert(index == 0);
return DataType::kFLOAT;
}
// Return true if output tensor is broadcast across a batch.
bool isOutputBroadcastAcrossBatch(int outputIndex, const bool* inputIsBroadcasted, int nbInputs) const
{
return false;
}
// Return true if plugin can use input that is broadcast across batch without replication.
bool canBroadcastInputAcrossBatch(int inputIndex) const
{
return false;
}
// Configure the layer with input and output data types.
// inutDims: input Dimensions for the plugin layer
// nInputs : Number of inputs to the plugin layer
// outputDims: output Dimensions from the plugin layer
// nOutputs: number of outputs from the plugin layer
// type: DataType configuration for the plugin layer
// format: format NCHW, NHWC etc
// maxbatchSize: maximum batch size for the plugin layer
void configurePlugin(const Dims* inputDims, int nbInputs, const Dims* outputDims, int nbOutputs,
const DataType* inputTypes, const DataType* outputTypes, const bool* inputIsBroadcast,
const bool* outputIsBroadcast, PluginFormat floatFormat, int maxBatchSize)
{
assert(nbInputs == 1);
assert(nbOutputs == 1);
}
// Attach the plugin object to an execution context and grant the plugin the access to some context resource.
void attachToContext(
cudnnContext* cudnnContext, cublasContext* cublasContext, IGpuAllocator* gpuAllocator)
{
}
// Detach the plugin object from its execution context.
void detachFromContext() {}
};
class ConvFixLayerCreator : public BasePluginCreator
{
public:
ConvFixLayerCreator() {
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();
}
~ConvFixLayerCreator() override = default;
// Returns the plugin name
const char* getPluginName() const;
// Returns the plugin version
const char* getPluginVersion() const;
// Returns the plugin field names
const PluginFieldCollection* getFieldNames()
{
return &mFC;
}
// Creates the NMS plugin
IPluginV2Ext* createPlugin(const char* name, const PluginFieldCollection* fc)
{
const PluginField* fields = fc->fields;
int ic, ih, iw;
for (int i = 0; i < fc->nbFields; ++i)
{
const char* attrName = fields[i].name;
if (!strcmp(attrName, "C"))
{
assert(fields[i].type == PluginFieldType::kINT32);
ic = static_cast<int>(*(static_cast<const int*>(fields[i].data)));
}
else if (!strcmp(attrName, "H"))
{
assert(fields[i].type == PluginFieldType::kINT32);
ih = static_cast<int>(*(static_cast<const int*>(fields[i].data)));
}
else if (!strcmp(attrName, "W"))
{
assert(fields[i].type == PluginFieldType::kINT32);
iw = static_cast<int>(*(static_cast<const int*>(fields[i].data)));
}
}
ConvFixLayer* obj = new ConvFixLayer(name, ic, ih, iw);
obj->setPluginNamespace(m_PluginNameSpace.c_str());
return obj;
}
IPluginV2Ext* deserializePlugin(const char* name, const void* serialData, size_t serialLength)
{
// This object will be deleted when the network is destroyed, which will
// call NMS::destroy()
ConvFixLayer* obj = new ConvFixLayer(name, serialData, serialLength);
obj->setPluginNamespace(m_PluginNameSpace.c_str());
return obj;
}
private:
static PluginFieldCollection mFC;
static std::vector<PluginField> mPluginAttributes;
}; ConvFixLayer.cpp #include "ConvFixLayer.h"
#include <cuda_runtime_api.h>
namespace
{
const char* CONVFIX_PLUGIN_VERSION{ "1" };
const char* CONVFIX_PLUGIN_NAME{ "CONVFIX_ZNZP" };
}
PluginFieldCollection ConvFixLayerCreator::mFC{};
std::vector<PluginField> ConvFixLayerCreator::mPluginAttributes;
// Helper function for serializing plugin
template <typename T>
void writeToBuffer(char*& buffer, const T& val)
{
*reinterpret_cast<T*>(buffer) = val;
buffer += sizeof(T);
}
// Helper function for deserializing plugin
template <typename T>
T readFromBuffer(const char*& buffer)
{
T val = *reinterpret_cast<const T*>(buffer);
buffer += sizeof(T);
return val;
}
ConvFixLayer::ConvFixLayer(const char* name, const void* data, size_t length) : m_LayerName(name)
{
const char* d = reinterpret_cast<const char*>(data);
const char* a = d;
m_ic = readFromBuffer<int>(a);
m_ih = readFromBuffer<size_t>(a);
m_iw = readFromBuffer<size_t>(a);
}
int ConvFixLayer::enqueue(int batchSize, const void* const* inputs, void** outputs, void* workspace, cudaStream_t stream)
{
const void* inputData = inputs[0];
void* outputData = outputs[0];
return 0;
}
void ConvFixLayer::serialize(void * buff) const
{
char* d = reinterpret_cast<char*>(buff);
char* a = d;
writeToBuffer<int>(a, m_ic);
writeToBuffer<int>(a, m_ih);
writeToBuffer<int>(a, m_iw);
assert(a == d + getSerializationSize());
}
const char* ConvFixLayer::getPluginType() const
{
return CONVFIX_PLUGIN_NAME;
}
const char* ConvFixLayer::getPluginVersion() const
{
return CONVFIX_PLUGIN_VERSION;
}
const char* ConvFixLayerCreator::getPluginName() const
{
return CONVFIX_PLUGIN_NAME;
}
const char* ConvFixLayerCreator::getPluginVersion() const
{
return CONVFIX_PLUGIN_VERSION;
}
REGISTER_ZNZTENSORRT_PLUGIN(ConvFixLayerCreator); |
Hi @VirtualEarth, Can you see if this works in TensorRT 7? Also assuming this commit may have been related: 5e289e9 |
Closing since no response |
i create a pulgin name "testPlugin" and use REGISTER_TENSORRT_PLUGIN to register testPluginCreator class.
if namespace assigns a string , i get a nullptr from getPluginCreator("testPlugin", "1")
The text was updated successfully, but these errors were encountered: