can not create plugin namespace about tensorrt HOT 4 CLOSED

#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;
};

#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;
};

#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);