wehub-resource-sync
743 lines
35 KiB
C++
743 lines
35 KiB
C++
#include "QNNConvertor.hpp"
|
|
#include "core/MNNFileUtils.h"
|
|
#include <cctype>
|
|
|
|
#define APPEND_VECTOR(vec1, vec2) (vec1.insert(vec1.end(), std::make_move_iterator(vec2.begin()), std::make_move_iterator(vec2.end())))
|
|
#define TENSOR_NAME_SYMBOL(cName) ("tensor_" + std::string(cName))
|
|
#define PARAM_NAME_SYMBOL(cName) ("param_" + std::string(cName) + "_" + nodeName)
|
|
|
|
namespace MNN {
|
|
namespace QNN {
|
|
#ifdef ENABLE_QNN_ONLINE_FINALIZE
|
|
|
|
std::string QNNConvertor::OutputDir = "";
|
|
std::string QNNTranslator::GraphNameSymbol = "";
|
|
FILE * QNNConvertor::CppFilePointer = nullptr;
|
|
std::string QNNConvertor::CppBuffer = "";
|
|
const uint32_t QNNConvertor::CppBufferSize = 4096; // 4KB
|
|
|
|
std::string GetLastDirName(const std::string& path) {
|
|
if (path.empty()) {
|
|
MNN_ERROR("MNN_QNN: Invalid output dir for QNNConvertor. original path: %s\n", path.c_str());
|
|
return "";
|
|
}
|
|
|
|
std::string result = path;
|
|
|
|
// Remove '/' and '\\' at the end.
|
|
while (!result.empty() && (result.back() == '/' || result.back() == '\\')) {
|
|
result.pop_back();
|
|
}
|
|
if (result.empty()) {
|
|
MNN_ERROR("MNN_QNN: Invalid output dir for QNNConvertor. result path: %s\n", result.c_str());
|
|
return "";
|
|
}
|
|
|
|
size_t lastSeparator = result.find_last_of("/\\");
|
|
// No '/' and '\\' in the path.
|
|
if (lastSeparator != std::string::npos) {
|
|
result = result.substr(lastSeparator + 1);
|
|
}
|
|
|
|
// Check whether result is a legal cpp symbol.
|
|
if (std::isdigit(result[0])) {
|
|
MNN_ERROR("MNN_QNN: Invalid cache path. result path: %s\n", result.c_str());
|
|
return "";
|
|
}
|
|
for (size_t i = 0; i < result.size(); ++i) {
|
|
if (!(std::isalpha(result[i]) || std::isdigit(result[i]) || result[i] == '_')) {
|
|
MNN_ERROR("MNN_QNN: Invalid cache path. result path: %s\n", result.c_str());
|
|
return "";
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void QNNConvertor::RecordBegin(const char* graphName) {
|
|
MNN_ASSERT(!(QNNConvertor::OutputDir.empty()));
|
|
QNNTranslator::GraphNameSymbol = GetLastDirName(QNNConvertor::OutputDir);
|
|
MNN_ASSERT(!(QNNTranslator::GraphNameSymbol.empty()));
|
|
|
|
QNNConvertor::CppBuffer.reserve(QNNConvertor::CppBufferSize);
|
|
|
|
std::string cppFilePath = MNNFilePathConcat(QNNConvertor::OutputDir, QNNTranslator::GraphNameSymbol + ".cpp");
|
|
QNNConvertor::CppFilePointer = std::fopen(cppFilePath.c_str(), "w");
|
|
if (!QNNConvertor::CppFilePointer) {
|
|
MNN_ERROR("MNN_QNN: Failed to open file %s.\n", cppFilePath.c_str());
|
|
return;
|
|
}
|
|
|
|
QNNCommand cmd = {};
|
|
cmd.type = QNNCommandTypeBegin;
|
|
|
|
QNNConvertor::Translate(cmd);
|
|
|
|
return;
|
|
}
|
|
|
|
void QNNConvertor::RecordTensor(const Qnn_Tensor_t * tensor) {
|
|
QNNCommand cmd;
|
|
|
|
cmd.type = QNNCommandTypeTensor;
|
|
|
|
const Qnn_TensorV1_t & t = tensor->v1;
|
|
cmd.commandTensor.name = t.name;
|
|
switch (t.type) {
|
|
case QNN_TENSOR_TYPE_APP_WRITE:
|
|
cmd.commandTensor.type = TENSOR_INPUT;
|
|
break;
|
|
case QNN_TENSOR_TYPE_APP_READ:
|
|
cmd.commandTensor.type = TENSOR_OUTPUT;
|
|
break;
|
|
case QNN_TENSOR_TYPE_NATIVE:
|
|
cmd.commandTensor.type = TENSOR_NATIVE;
|
|
break;
|
|
case QNN_TENSOR_TYPE_STATIC: {
|
|
std::string sname(t.name);
|
|
bool isParam = false;
|
|
if (sname.size() >= 5) {
|
|
isParam = (sname.compare(sname.size() - 5, 5, gParamMarker) == 0);
|
|
}
|
|
cmd.commandTensor.type = isParam ? TENSOR_PARAM : TENSOR_STATIC;
|
|
break;
|
|
}
|
|
default:
|
|
MNN_ERROR("MNN_QNN: Unknown Qnn_Convertor_Tensor_t.\n");
|
|
return;
|
|
}
|
|
cmd.commandTensor.dataType = t.dataType;
|
|
cmd.commandTensor.quantizeParams = t.quantizeParams;
|
|
cmd.commandTensor.rank = t.rank;
|
|
cmd.commandTensor.dimensions = t.dimensions;
|
|
cmd.commandTensor.clientBuf = t.clientBuf;
|
|
|
|
QNNConvertor::Translate(cmd);
|
|
|
|
if (cmd.commandTensor.type == Qnn_Convertor_Tensor_t::TENSOR_STATIC) {
|
|
QNNConvertor::DumpBuffer(cmd.commandTensor.name, cmd.commandTensor.clientBuf.data, cmd.commandTensor.clientBuf.dataSize);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void QNNConvertor::RecordNode(const Qnn_OpConfig_t & opConfig) {
|
|
QNNCommand cmd;
|
|
|
|
cmd.type = QNNCommandTypeNode;
|
|
|
|
const Qnn_OpConfigV1_t & op = opConfig.v1;
|
|
|
|
cmd.commandNode.name = op.name;
|
|
cmd.commandNode.packageName = op.packageName;
|
|
cmd.commandNode.typeName = op.typeName;
|
|
cmd.commandNode.numOfParams = op.numOfParams;
|
|
cmd.commandNode.params = op.params;
|
|
cmd.commandNode.numOfInputs = op.numOfInputs;
|
|
cmd.commandNode.inputTensors = op.inputTensors;
|
|
cmd.commandNode.numOfOutputs = op.numOfOutputs;
|
|
cmd.commandNode.outputTensors = op.outputTensors;
|
|
|
|
QNNConvertor::Translate(cmd);
|
|
|
|
return;
|
|
}
|
|
|
|
void QNNConvertor::RecordEnd() {
|
|
QNNCommand cmd = {};
|
|
cmd.type = QNNCommandTypeEnd;
|
|
|
|
QNNConvertor::Translate(cmd);
|
|
|
|
if (std::fclose(QNNConvertor::CppFilePointer) != 0) {
|
|
MNN_ERROR("MNN_QNN: Failed to close the cpp file for QNNConvertor.\n");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void QNNConvertor::Translate(const QNNCommand & cmd) {
|
|
std::vector<std::string> cppLines = QNNTranslator::TranslateCommand(cmd);
|
|
for (const std::string& line : cppLines) {
|
|
QNNConvertor::CppBuffer.append(line);
|
|
QNNConvertor::CppBuffer.push_back('\n');
|
|
}
|
|
size_t written = std::fwrite(QNNConvertor::CppBuffer.data(), 1, QNNConvertor::CppBuffer.size(), QNNConvertor::CppFilePointer);
|
|
if (written != QNNConvertor::CppBuffer.size()) {
|
|
MNN_ERROR("MNN_QNN: Failed to write to the Cpp File of QNNConvertor.\n");
|
|
}
|
|
QNNConvertor::CppBuffer.clear();
|
|
return;
|
|
}
|
|
|
|
void QNNConvertor::DumpBuffer(const char * name, const void * buffer, size_t size) {
|
|
std::string dataPath = MNNFilePathConcat(QNNConvertor::OutputDir, std::string(name) + ".raw");
|
|
|
|
FILE* fp = std::fopen(dataPath.c_str(), "wb");
|
|
if (!fp) {
|
|
MNN_ERROR("MNN_QNN: Failed to open file %s.\n", dataPath.c_str());
|
|
return;
|
|
}
|
|
|
|
size_t written = std::fwrite(buffer, 1, size, fp);
|
|
if (written != size) {
|
|
MNN_ERROR("MNN_QNN: Failed to write to file %s. Written: %zu, Expected: %zu\n", dataPath.c_str(), written, size);
|
|
}
|
|
|
|
int code = std::fclose(fp);
|
|
if (code != 0) {
|
|
MNN_ERROR("MNN_QNN: Failed to close file %s.\n", dataPath.c_str());
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
std::vector<std::string> QNNTranslator::TranslateCommand(const QNNCommand & cmd) {
|
|
switch (cmd.type) {
|
|
case QNNCommandTypeBegin:
|
|
return QNNTranslator::TranslateBegin();
|
|
case QNNCommandTypeTensor:
|
|
return QNNTranslator::TranslateTensor(cmd.commandTensor);
|
|
case QNNCommandTypeNode:
|
|
return QNNTranslator::TranslateNode(cmd.commandNode);
|
|
case QNNCommandTypeEnd:
|
|
return QNNTranslator::TranslateEnd();
|
|
default:
|
|
MNN_PRINT("MNN_QNN: Unknown QNNCommandType.\n");
|
|
return {};
|
|
}
|
|
}
|
|
|
|
std::vector<std::string> QNNTranslator::TranslateBegin() {
|
|
std::vector<std::string> result;
|
|
|
|
result.push_back("#include \"QnnModel.hpp\"");
|
|
result.push_back("#include \"QnnOpDef.h\"");
|
|
result.push_back("");
|
|
result.push_back("// Flag to determine if Backend should node validation for each opNode added");
|
|
result.push_back("#define DO_GRAPH_NODE_VALIDATIONS 1");
|
|
result.push_back("");
|
|
result.push_back("using namespace qnn_wrapper_api;");
|
|
result.push_back("extern \"C\" {");
|
|
result.push_back("QNN_API");
|
|
result.push_back("ModelError_t QnnModel_composeGraphs(Qnn_BackendHandle_t backendHandle,");
|
|
result.push_back(" QNN_INTERFACE_VER_TYPE interface,");
|
|
result.push_back(" Qnn_ContextHandle_t contextHandle,");
|
|
result.push_back(" const GraphConfigInfo_t** graphsConfigInfo,");
|
|
result.push_back(" const uint32_t numGraphsConfigInfo,");
|
|
result.push_back(" GraphInfoPtr_t** graphsInfo,");
|
|
result.push_back(" uint32_t* numGraphsInfo,");
|
|
result.push_back(" bool debug,");
|
|
result.push_back(" QnnLog_Callback_t logCallback,");
|
|
result.push_back(" QnnLog_Level_t maxLogLevel) {");
|
|
result.push_back(" ModelError_t err = MODEL_NO_ERROR;");
|
|
result.push_back("");
|
|
result.push_back(" /* model/graph for " + QNNTranslator::GraphNameSymbol + "*/");
|
|
result.push_back(" QnnModel " + QNNTranslator::GraphNameSymbol + ";");
|
|
result.push_back(" const QnnGraph_Config_t** graphConfigs = nullptr;");
|
|
result.push_back(" VALIDATE(getQnnGraphConfigFromInfo(");
|
|
result.push_back(" \"" + QNNTranslator::GraphNameSymbol + "\", graphsConfigInfo, numGraphsConfigInfo, graphConfigs),");
|
|
result.push_back(" err);");
|
|
result.push_back(" VALIDATE(" + QNNTranslator::GraphNameSymbol + ".initialize(backendHandle,");
|
|
result.push_back(" interface,");
|
|
result.push_back(" contextHandle,");
|
|
result.push_back(" \"" + QNNTranslator::GraphNameSymbol + "\",");
|
|
result.push_back(" debug,");
|
|
result.push_back(" DO_GRAPH_NODE_VALIDATIONS,");
|
|
result.push_back(" graphConfigs),");
|
|
result.push_back(" err);");
|
|
result.push_back("");
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::string> QNNTranslator::TranslateTensor(const QNNCommandTensor& cmdT) {
|
|
std::string sName = cmdT.name;
|
|
std::string tensorNameSymbol = TENSOR_NAME_SYMBOL(cmdT.name);
|
|
std::string dimensionsNameSymbol = "dimensions_" + sName;
|
|
std::string dataNameSymbol = "data_" + sName;
|
|
|
|
bool isParam = (cmdT.type == Qnn_Convertor_Tensor_t::TENSOR_PARAM) ? true : false;
|
|
bool hasClientBuf = (cmdT.clientBuf.data != nullptr) ? true : false;
|
|
bool hasQuant = (cmdT.quantizeParams.encodingDefinition == QNN_DEFINITION_DEFINED) ? true : false;
|
|
bool shouldBeAdded = (cmdT.type == Qnn_Convertor_Tensor_t::TENSOR_INPUT) || (cmdT.type == Qnn_Convertor_Tensor_t::TENSOR_STATIC);
|
|
|
|
std::vector<std::string> result;
|
|
|
|
result.push_back("");
|
|
result.push_back(" // Adding Tensor for " + sName + ".");
|
|
result.push_back(QNNTranslator::TranslateDimensionsArray(dimensionsNameSymbol, cmdT.rank, cmdT.dimensions));
|
|
if (isParam) {
|
|
result.push_back(QNNTranslator::TranslateParamDataArray(dataNameSymbol, cmdT.dataType, cmdT.clientBuf));
|
|
}
|
|
if(hasQuant){
|
|
std::vector<std::string> linesQuantScaleOffset = TranslateQuantizeScaleOffsetDataArray(tensorNameSymbol, cmdT.quantizeParams, cmdT.rank, cmdT.dimensions);
|
|
APPEND_VECTOR(result, linesQuantScaleOffset);
|
|
}
|
|
result.push_back(" Qnn_Tensor_t " + tensorNameSymbol + " = QNN_TENSOR_INIT;");
|
|
result.push_back(" {");
|
|
result.push_back(" " + tensorNameSymbol + ".version = QNN_TENSOR_VERSION_1;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.id = 0;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.name = \"" + sName +"\";");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.type = " + QNNTranslator::MapTensorType(cmdT.type) + ";");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.dataFormat = QNN_TENSOR_DATA_FORMAT_FLAT_BUFFER;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.dataType = " + QNNTranslator::MapDataType(cmdT.dataType) + ";");
|
|
std::vector<std::string> linesQuant = QNNTranslator::TranslateTensorQuantizeParams(tensorNameSymbol, cmdT.quantizeParams);
|
|
APPEND_VECTOR(result, linesQuant);
|
|
result.push_back(" " + tensorNameSymbol + ".v1.rank = " + std::to_string(cmdT.rank) + ";");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.dimensions = " + dimensionsNameSymbol + ";");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.memType = QNN_TENSORMEMTYPE_RAW;");
|
|
std::vector<std::string> linesClientBuf = QNNTranslator::TranslateTensorClientBuf(tensorNameSymbol, dataNameSymbol, sName, cmdT.clientBuf, hasClientBuf, isParam);
|
|
APPEND_VECTOR(result, linesClientBuf);
|
|
result.push_back(" }");
|
|
|
|
if (shouldBeAdded) {
|
|
result.push_back(" VALIDATE(" + QNNTranslator::GraphNameSymbol + ".addTensor(\"" + sName + "\", " + tensorNameSymbol + "), err);");
|
|
}
|
|
|
|
result.push_back("");
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::string> QNNTranslator::TranslateNode(const QNNCommandNode& cmdN) {
|
|
std::string sName = cmdN.name;
|
|
std::string paramArraySymbol = "params_" + sName;
|
|
std::string inputArraySymbol = "inputs_" + sName;
|
|
std::string outputArraySymbol = "outputs_" + sName;
|
|
|
|
std::vector<std::string> result;
|
|
|
|
result.push_back("");
|
|
result.push_back(" // Adding Node for " + sName + ".");
|
|
|
|
std::vector<std::string> linesParamArray = QNNTranslator::TranslateNodeParamArray(sName, paramArraySymbol, cmdN.numOfParams, cmdN.params);
|
|
APPEND_VECTOR(result, linesParamArray);
|
|
std::vector<std::string> linesInputArray = QNNTranslator::TranslateNodeInputArray(inputArraySymbol, cmdN.numOfInputs, cmdN.inputTensors);
|
|
APPEND_VECTOR(result, linesInputArray);
|
|
std::vector<std::string> linesOutputArray = QNNTranslator::TranslateNodeOutputArray(outputArraySymbol, cmdN.numOfOutputs, cmdN.outputTensors);
|
|
APPEND_VECTOR(result, linesOutputArray);
|
|
result.push_back(" VALIDATE(" + QNNTranslator::GraphNameSymbol + ".addNode(QNN_OPCONFIG_VERSION_1, \"" + sName + "\", \"" + std::string(cmdN.packageName) + "\", \"" + std::string(cmdN.typeName) + "\",");
|
|
result.push_back(" " + paramArraySymbol + ", " + std::to_string(cmdN.numOfParams) + ",");
|
|
result.push_back(" " + inputArraySymbol + ", " + std::to_string(cmdN.numOfInputs) + ",");
|
|
result.push_back(" " + outputArraySymbol + ", " + std::to_string(cmdN.numOfOutputs) + "),");
|
|
result.push_back(" err);");
|
|
|
|
result.push_back("");
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::string> QNNTranslator::TranslateEnd() {
|
|
std::vector<std::string> result;
|
|
|
|
result.push_back(" // Add all models to array to get graphsInfo");
|
|
result.push_back(" QnnModel* models[] = {&" + GraphNameSymbol + "};");
|
|
result.push_back(" uint32_t numModels = 1;");
|
|
result.push_back("");
|
|
result.push_back(" // Populate the constructed graphs in provided output variables");
|
|
result.push_back(" VALIDATE(getGraphInfoFromModels(*models, numModels, graphsInfo), err);");
|
|
result.push_back(" *numGraphsInfo = numModels;");
|
|
result.push_back("");
|
|
result.push_back(" return err;");
|
|
result.push_back("");
|
|
result.push_back("} // PREPARE_GRAPHS");
|
|
result.push_back("");
|
|
result.push_back("QNN_API");
|
|
result.push_back("ModelError_t QnnModel_freeGraphsInfo(GraphInfoPtr_t** graphs, uint32_t numGraphsInfo) {");
|
|
result.push_back(" return qnn_wrapper_api::freeGraphsInfo(graphs, numGraphsInfo);");
|
|
result.push_back("} // FREEGRAPHINFO");
|
|
result.push_back("}");
|
|
|
|
return result;
|
|
}
|
|
|
|
std::string QNNTranslator::MapTensorType(Qnn_Convertor_Tensor_t type) {
|
|
switch (type) {
|
|
case TENSOR_INPUT: return "QNN_TENSOR_TYPE_APP_WRITE";
|
|
case TENSOR_STATIC: return "QNN_TENSOR_TYPE_STATIC";
|
|
case TENSOR_PARAM: return "QNN_TENSOR_TYPE_STATIC";
|
|
case TENSOR_NATIVE: return "QNN_TENSOR_TYPE_NATIVE";
|
|
case TENSOR_OUTPUT: return "QNN_TENSOR_TYPE_APP_READ";
|
|
default: return "UNKNOWN_QNN_TENSOR_TYPE_T";
|
|
}
|
|
}
|
|
|
|
std::string QNNTranslator::MapDataType(Qnn_DataType_t dataType) {
|
|
switch (dataType) {
|
|
case QNN_DATATYPE_INT_8: return "QNN_DATATYPE_INT_8";
|
|
case QNN_DATATYPE_INT_16: return "QNN_DATATYPE_INT_16";
|
|
case QNN_DATATYPE_INT_32: return "QNN_DATATYPE_INT_32";
|
|
case QNN_DATATYPE_INT_64: return "QNN_DATATYPE_INT_64";
|
|
case QNN_DATATYPE_UINT_8: return "QNN_DATATYPE_UINT_8";
|
|
case QNN_DATATYPE_UINT_16: return "QNN_DATATYPE_UINT_16";
|
|
case QNN_DATATYPE_UINT_32: return "QNN_DATATYPE_UINT_32";
|
|
case QNN_DATATYPE_UINT_64: return "QNN_DATATYPE_UINT_64";
|
|
case QNN_DATATYPE_FLOAT_16: return "QNN_DATATYPE_FLOAT_16";
|
|
case QNN_DATATYPE_FLOAT_32: return "QNN_DATATYPE_FLOAT_32";
|
|
case QNN_DATATYPE_FLOAT_64: return "QNN_DATATYPE_FLOAT_64";
|
|
case QNN_DATATYPE_SFIXED_POINT_4: return "QNN_DATATYPE_SFIXED_POINT_4";
|
|
case QNN_DATATYPE_SFIXED_POINT_8: return "QNN_DATATYPE_SFIXED_POINT_8";
|
|
case QNN_DATATYPE_SFIXED_POINT_16: return "QNN_DATATYPE_SFIXED_POINT_16";
|
|
case QNN_DATATYPE_SFIXED_POINT_32: return "QNN_DATATYPE_SFIXED_POINT_32";
|
|
case QNN_DATATYPE_UFIXED_POINT_4: return "QNN_DATATYPE_UFIXED_POINT_4";
|
|
case QNN_DATATYPE_UFIXED_POINT_8: return "QNN_DATATYPE_UFIXED_POINT_8";
|
|
case QNN_DATATYPE_UFIXED_POINT_16: return "QNN_DATATYPE_UFIXED_POINT_16";
|
|
case QNN_DATATYPE_UFIXED_POINT_32: return "QNN_DATATYPE_UFIXED_POINT_32";
|
|
case QNN_DATATYPE_BOOL_8: return "QNN_DATATYPE_BOOL_8";
|
|
case QNN_DATATYPE_STRING: return "QNN_DATATYPE_STRING";
|
|
case QNN_DATATYPE_UNDEFINED: return "QNN_DATATYPE_UNDEFINED";
|
|
default:
|
|
MNN_ERROR("MNN_QNN: Unknown data type.\n");
|
|
return "";
|
|
}
|
|
}
|
|
|
|
std::string QNNTranslator::TranslateDimensionsArray(const std::string & dimensionsNameSymbol, uint32_t rank, const uint32_t * dimensions) {
|
|
std::string result = " uint32_t ";
|
|
result += dimensionsNameSymbol;
|
|
result += "[] = {";
|
|
for (uint32_t i = 0; i < rank; ++i) {
|
|
result += std::to_string(dimensions[i]);
|
|
if (i + 1 < rank) {
|
|
result += ", ";
|
|
}
|
|
}
|
|
result += "};";
|
|
return result;
|
|
}
|
|
|
|
std::string QNNTranslator::TranslateParamDataArray(const std::string & dataNameSymbol, Qnn_DataType_t dataType, const Qnn_ClientBuffer_t & clientBuf) {
|
|
std::string result = " ";
|
|
|
|
std::string dataTypeSymbol;
|
|
switch (dataType) {
|
|
case QNN_DATATYPE_UINT_32:
|
|
dataTypeSymbol = "uint32_t";
|
|
break;
|
|
case QNN_DATATYPE_INT_32:
|
|
dataTypeSymbol = "int";
|
|
break;
|
|
default:
|
|
MNN_ERROR("MNN_QNN: Unknown data type for param tensor.\n");
|
|
return "";
|
|
}
|
|
result += dataTypeSymbol;
|
|
|
|
result += " ";
|
|
result += dataNameSymbol;
|
|
result += "[] = {";
|
|
|
|
switch (dataType) {
|
|
case QNN_DATATYPE_UINT_32: {
|
|
const uint32_t * source = (const uint32_t *)clientBuf.data;
|
|
uint32_t numEle = clientBuf.dataSize / sizeof(uint32_t);
|
|
for (uint32_t i = 0; i < numEle; i++) {
|
|
result += std::to_string(source[i]);
|
|
if (i < numEle - 1) {
|
|
result += ", ";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case QNN_DATATYPE_INT_32: {
|
|
const int * source = (const int *)clientBuf.data;
|
|
uint32_t numEle = clientBuf.dataSize / sizeof(int);
|
|
for (uint32_t i = 0; i < numEle; i++) {
|
|
result += std::to_string(source[i]);
|
|
if (i < numEle - 1) {
|
|
result += ", ";
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
MNN_ERROR("MNN_QNN: Unknown data type for param tensor.\n");
|
|
return "";
|
|
}
|
|
|
|
result += "};";
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::string> QNNTranslator::TranslateQuantizeScaleOffsetDataArray(const std::string & tensorNameSymbol, const Qnn_QuantizeParams_t & quantizeParams, uint32_t rank, const uint32_t * dimensions){
|
|
std::vector<std::string> result;
|
|
if(quantizeParams.encodingDefinition == QNN_DEFINITION_DEFINED && quantizeParams.quantizationEncoding == QNN_QUANTIZATION_ENCODING_AXIS_SCALE_OFFSET){
|
|
result.push_back(" Qnn_ScaleOffset_t " + tensorNameSymbol + "_axis_scale_offset[] = {");
|
|
int totalnum = (quantizeParams.axisScaleOffsetEncoding.numScaleOffsets + 3) / 4;
|
|
for(int i = 0; i < totalnum; ++i){
|
|
std::string line = " ";
|
|
for(int j = 0; j < 4; ++j){
|
|
int index = i * 4 + j;
|
|
if(index >= quantizeParams.axisScaleOffsetEncoding.numScaleOffsets)
|
|
break;
|
|
line += "{.scale= " + std::to_string(quantizeParams.axisScaleOffsetEncoding.scaleOffset[index].scale) + ", .offset= " + std::to_string(quantizeParams.axisScaleOffsetEncoding.scaleOffset[index].offset) + "}, ";
|
|
}
|
|
result.push_back(line);
|
|
}
|
|
result.push_back(" };");
|
|
}
|
|
|
|
if(quantizeParams.encodingDefinition == QNN_DEFINITION_DEFINED && quantizeParams.quantizationEncoding == QNN_QUANTIZATION_ENCODING_BW_AXIS_SCALE_OFFSET){
|
|
result.push_back(" float " + tensorNameSymbol + "_bwaxis_scale[] = {");
|
|
int totalnum = (quantizeParams.bwAxisScaleOffsetEncoding.numElements + 3) / 4;
|
|
for(int i = 0; i < totalnum; ++i){
|
|
std::string line = " ";
|
|
for(int j = 0; j < 4; ++j){
|
|
int index = i * 4 + j;
|
|
if(index >= quantizeParams.bwAxisScaleOffsetEncoding.numElements)
|
|
break;
|
|
line += std::to_string(quantizeParams.bwAxisScaleOffsetEncoding.scales[index]) + ", ";
|
|
}
|
|
result.push_back(line);
|
|
}
|
|
result.push_back(" };");
|
|
if(quantizeParams.bwAxisScaleOffsetEncoding.offsets != nullptr){
|
|
result.push_back(" int32_t " + tensorNameSymbol + "_bwaxis_offset[] = {");
|
|
for(int i = 0; i < totalnum; ++i){
|
|
std::string line = " ";
|
|
for(int j = 0; j < 4; ++j){
|
|
int index = i * 4 + j;
|
|
if(index >= quantizeParams.bwAxisScaleOffsetEncoding.numElements)
|
|
break;
|
|
line += std::to_string(quantizeParams.bwAxisScaleOffsetEncoding.offsets[index]) + ", ";
|
|
}
|
|
result.push_back(line);
|
|
}
|
|
result.push_back(" };");
|
|
}
|
|
}
|
|
|
|
if(quantizeParams.encodingDefinition == QNN_DEFINITION_DEFINED && quantizeParams.quantizationEncoding == QNN_QUANTIZATION_ENCODING_BLOCKWISE_EXPANSION){
|
|
int axis = quantizeParams.blockwiseExpansion->axis;
|
|
int oc = dimensions[axis];
|
|
int blockSize = quantizeParams.blockwiseExpansion->numBlocksPerAxis;
|
|
result.push_back(" Qnn_BlockwiseExpansion_t " + tensorNameSymbol + "_blockwiseExpansion = QNN_BLOCKWISE_EXPANSION_INIT;");
|
|
|
|
result.push_back(" Qnn_ScaleOffset_t " + tensorNameSymbol + "_blockwiseExpansionScaleOffset[] = {");
|
|
int totalnum = (oc + 3) / 4;
|
|
for(int i = 0; i < totalnum; ++i){
|
|
std::string line = " ";
|
|
for(int j = 0; j < 4; ++j){
|
|
int index = i * 4 + j;
|
|
if(index >= oc)
|
|
break;
|
|
line += "{.scale= " + std::to_string(quantizeParams.blockwiseExpansion->scaleOffsets[index].scale) + ", .offset= " + std::to_string(quantizeParams.blockwiseExpansion->scaleOffsets[index].offset) + "}, ";
|
|
}
|
|
result.push_back(line);
|
|
}
|
|
result.push_back(" };");
|
|
if(quantizeParams.blockwiseExpansion->blockScaleStorageType == QNN_BLOCKWISE_EXPANSION_BITWIDTH_SCALE_STORAGE_8){
|
|
result.push_back(" uint8_t " + tensorNameSymbol + "_blockwiseExpansionBlockScale[] = {");
|
|
totalnum = (oc * blockSize + 3) / 4;
|
|
for(int i = 0; i < totalnum; ++i){
|
|
std::string line = " ";
|
|
for(int j = 0; j < 4; ++j){
|
|
int index = i * 4 + j;
|
|
if(index >= oc * blockSize)
|
|
break;
|
|
line += std::to_string(quantizeParams.blockwiseExpansion->blocksScale8[index]) + ", ";
|
|
}
|
|
result.push_back(line);
|
|
}
|
|
result.push_back(" };");
|
|
}else{
|
|
result.push_back(" uint16_t " + tensorNameSymbol + "_blockwiseExpansionBlockScale[] = {");
|
|
totalnum = (oc * blockSize + 3) / 4;
|
|
for(int i = 0; i < totalnum; ++i){
|
|
std::string line = " ";
|
|
for(int j = 0; j < 4; ++j){
|
|
int index = i * 4 + j;
|
|
if(index >= oc * blockSize)
|
|
break;
|
|
line += std::to_string(quantizeParams.blockwiseExpansion->blocksScale16[index]) + ", ";
|
|
}
|
|
result.push_back(line);
|
|
}
|
|
result.push_back(" };");
|
|
}
|
|
result.push_back(" " + tensorNameSymbol + "_blockwiseExpansion.axis = " + std::to_string(quantizeParams.blockwiseExpansion->axis) + ";");
|
|
result.push_back(" " + tensorNameSymbol + "_blockwiseExpansion.scaleOffsets = " + tensorNameSymbol + "_blockwiseExpansionScaleOffset;");
|
|
result.push_back(" " + tensorNameSymbol + "_blockwiseExpansion.numBlocksPerAxis = " + std::to_string(quantizeParams.blockwiseExpansion->numBlocksPerAxis) + ";");
|
|
result.push_back(" " + tensorNameSymbol + "_blockwiseExpansion.blockScaleBitwidth = " + std::to_string(quantizeParams.blockwiseExpansion->blockScaleBitwidth) + ";");
|
|
if(quantizeParams.blockwiseExpansion->blockScaleStorageType == QNN_BLOCKWISE_EXPANSION_BITWIDTH_SCALE_STORAGE_8){
|
|
result.push_back(" " + tensorNameSymbol + "_blockwiseExpansion.blockScaleStorageType = QNN_BLOCKWISE_EXPANSION_BITWIDTH_SCALE_STORAGE_8;");
|
|
result.push_back(" " + tensorNameSymbol + "_blockwiseExpansion.blocksScale8 = " + tensorNameSymbol + "_blockwiseExpansionBlockScale;");
|
|
}else{
|
|
result.push_back(" " + tensorNameSymbol + "_blockwiseExpansion.blockScaleStorageType = QNN_BLOCKWISE_EXPANSION_BITWIDTH_SCALE_STORAGE_16;");
|
|
result.push_back(" " + tensorNameSymbol + "_blockwiseExpansion.blocksScale16 = " + tensorNameSymbol + "_blockwiseExpansionBlockScale;");
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Currently, only support QNN_QUANTIZATION_ENCODING_UNDEFINED, QNN_QUANTIZATION_ENCODING_SCALE_OFFSET.
|
|
std::vector<std::string> QNNTranslator::TranslateTensorQuantizeParams(const std::string tensorNameSymbol, const Qnn_QuantizeParams_t & quantizeParams) {
|
|
std::vector<std::string> result;
|
|
|
|
if (quantizeParams.encodingDefinition == QNN_DEFINITION_UNDEFINED) {
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.encodingDefinition = QNN_DEFINITION_UNDEFINED;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.quantizationEncoding = QNN_QUANTIZATION_ENCODING_UNDEFINED;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.scaleOffsetEncoding.scale = 0.0f;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.scaleOffsetEncoding.offset = 0;");
|
|
return result;
|
|
}
|
|
|
|
if (quantizeParams.encodingDefinition == QNN_DEFINITION_DEFINED && quantizeParams.quantizationEncoding == QNN_QUANTIZATION_ENCODING_SCALE_OFFSET) {
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.encodingDefinition = QNN_DEFINITION_DEFINED;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.quantizationEncoding = QNN_QUANTIZATION_ENCODING_SCALE_OFFSET;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.scaleOffsetEncoding.scale = " + std::to_string(quantizeParams.scaleOffsetEncoding.scale) + ";");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.scaleOffsetEncoding.offset = " + std::to_string(quantizeParams.scaleOffsetEncoding.offset) + ";");
|
|
return result;
|
|
}
|
|
|
|
if(quantizeParams.encodingDefinition == QNN_DEFINITION_DEFINED && quantizeParams.quantizationEncoding == QNN_QUANTIZATION_ENCODING_AXIS_SCALE_OFFSET){
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.encodingDefinition = QNN_DEFINITION_DEFINED;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.quantizationEncoding = QNN_QUANTIZATION_ENCODING_AXIS_SCALE_OFFSET;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.axisScaleOffsetEncoding.axis = " + std::to_string(quantizeParams.axisScaleOffsetEncoding.axis) + ";");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.axisScaleOffsetEncoding.numScaleOffsets = " + std::to_string(quantizeParams.axisScaleOffsetEncoding.numScaleOffsets) + ";");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.axisScaleOffsetEncoding.scaleOffset = " + tensorNameSymbol + "_axis_scale_offset;");
|
|
return result;
|
|
}
|
|
|
|
if(quantizeParams.encodingDefinition == QNN_DEFINITION_DEFINED && quantizeParams.quantizationEncoding == QNN_QUANTIZATION_ENCODING_BW_AXIS_SCALE_OFFSET){
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.encodingDefinition = QNN_DEFINITION_DEFINED;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.quantizationEncoding = QNN_QUANTIZATION_ENCODING_BW_AXIS_SCALE_OFFSET;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.bwAxisScaleOffsetEncoding.axis = " + std::to_string(quantizeParams.bwAxisScaleOffsetEncoding.axis) + ";");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.bwAxisScaleOffsetEncoding.bitwidth = " + std::to_string(quantizeParams.bwAxisScaleOffsetEncoding.bitwidth) + ";");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.bwAxisScaleOffsetEncoding.numElements = " + std::to_string(quantizeParams.bwAxisScaleOffsetEncoding.numElements) + ";");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.bwAxisScaleOffsetEncoding.scales = " + tensorNameSymbol + "_bwaxis_scale;");
|
|
if(quantizeParams.bwAxisScaleOffsetEncoding.offsets != nullptr)
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.bwAxisScaleOffsetEncoding.offset = " + tensorNameSymbol + "_bwaxis_offset;");
|
|
return result;
|
|
}
|
|
|
|
if(quantizeParams.encodingDefinition == QNN_DEFINITION_DEFINED && quantizeParams.quantizationEncoding == QNN_QUANTIZATION_ENCODING_BLOCKWISE_EXPANSION){
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.encodingDefinition = QNN_DEFINITION_DEFINED;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.quantizationEncoding = QNN_QUANTIZATION_ENCODING_BLOCKWISE_EXPANSION;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.quantizeParams.blockwiseExpansion = &" + tensorNameSymbol + "_blockwiseExpansion;");
|
|
return result;
|
|
}
|
|
|
|
|
|
MNN_ERROR("MNN_QNN: Unknown QuantizeParams.\n");
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::string> QNNTranslator::TranslateTensorClientBuf(const std::string & tensorNameSymbol, const std::string & dataNameSymbol, const std::string & sname, const Qnn_ClientBuffer_t & clientBuf, bool hasClientBuf, bool isParam) {
|
|
std::vector<std::string> result;
|
|
|
|
if (!hasClientBuf) {
|
|
result.push_back(" " + tensorNameSymbol + ".v1.clientBuf.data = nullptr;");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.clientBuf.dataSize = 0;");
|
|
return result;
|
|
}
|
|
|
|
if (isParam) {
|
|
result.push_back(" " + tensorNameSymbol + ".v1.clientBuf.data = " + dataNameSymbol + ";");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.clientBuf.dataSize = " + std::to_string(clientBuf.dataSize) + ";");
|
|
return result;
|
|
}
|
|
|
|
if (hasClientBuf && (!isParam)) {
|
|
result.push_back(" " + tensorNameSymbol + ".v1.clientBuf.data = BINVARSTART(" + sname + ");");
|
|
result.push_back(" " + tensorNameSymbol + ".v1.clientBuf.dataSize = BINLEN(" + sname + ");");
|
|
return result;
|
|
}
|
|
|
|
MNN_ERROR("MNN_QNN: Illegal ClientBuf setting.\n");
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::string> QNNTranslator::TranslateNodeParamArray(const std::string & nodeName, const std::string & paramArraySymbol, uint32_t numOfParams, const Qnn_Param_t * params) {
|
|
std::vector<std::string> result;
|
|
|
|
for (uint32_t i = 0; i < numOfParams; i++) {
|
|
Qnn_Param_t param = params[i];
|
|
std::string paramNameSymbol = PARAM_NAME_SYMBOL(param.name);
|
|
result.push_back(" Qnn_Param_t " + paramNameSymbol + " = QNN_PARAM_INIT;");
|
|
result.push_back(" {");
|
|
if (param.paramType == QNN_PARAMTYPE_SCALAR) {
|
|
result.push_back(" " + paramNameSymbol + ".paramType = QNN_PARAMTYPE_SCALAR;");
|
|
result.push_back(" " + paramNameSymbol + ".name = \"" + std::string(param.name) + "\";");
|
|
result.push_back(" " + paramNameSymbol + ".scalarParam.dataType = " + MapDataType(param.scalarParam.dataType) + ";");
|
|
switch (param.scalarParam.dataType) {
|
|
case QNN_DATATYPE_BOOL_8:
|
|
result.push_back(" " + paramNameSymbol + ".scalarParam.bool8Value = " + std::to_string(param.scalarParam.bool8Value) + ";");
|
|
break;
|
|
case QNN_DATATYPE_UINT_32:
|
|
result.push_back(" " + paramNameSymbol + ".scalarParam.uint32Value = " + std::to_string(param.scalarParam.uint32Value) + ";");
|
|
break;
|
|
case QNN_DATATYPE_INT_32:
|
|
result.push_back(" " + paramNameSymbol + ".scalarParam.int32Value = " + std::to_string(param.scalarParam.int32Value) + ";");
|
|
break;
|
|
case QNN_DATATYPE_FLOAT_32:
|
|
result.push_back(" " + paramNameSymbol + ".scalarParam.floatValue = " + std::to_string(param.scalarParam.floatValue) + ";");
|
|
break;
|
|
default:
|
|
MNN_ERROR("MNN_QNN: Unkown dataType.\n");
|
|
return {};
|
|
}
|
|
} else {
|
|
result.push_back(" " + paramNameSymbol + ".paramType = QNN_PARAMTYPE_TENSOR;");
|
|
result.push_back(" " + paramNameSymbol + ".name = \"" + std::string(param.name) + "\";");
|
|
result.push_back(" " + paramNameSymbol + ".tensorParam = " + TENSOR_NAME_SYMBOL(param.tensorParam.v1.name) + ";");
|
|
}
|
|
result.push_back(" }");
|
|
}
|
|
|
|
std::string str = " Qnn_Param_t " + paramArraySymbol + "[] = {";
|
|
for (uint32_t i = 0; i < numOfParams; i++) {
|
|
str += PARAM_NAME_SYMBOL(params[i].name);
|
|
if (i < numOfParams - 1) {
|
|
str += ", ";
|
|
}
|
|
}
|
|
str += "};";
|
|
result.push_back(str);
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::string> QNNTranslator::TranslateNodeInputArray(const std::string & inputArraySymbol, uint32_t numOfInputs, const Qnn_Tensor_t * inputs) {
|
|
std::vector<std::string> result;
|
|
|
|
std::string str = " const char * " + inputArraySymbol + "[] = {";
|
|
for (uint32_t i = 0; i < numOfInputs; i++) {
|
|
str += "\"";
|
|
str += std::string(inputs[i].v1.name);
|
|
str += "\"";
|
|
if (i < numOfInputs - 1) {
|
|
str += ", ";
|
|
}
|
|
}
|
|
str += "};";
|
|
|
|
result.push_back(str);
|
|
|
|
return result;
|
|
}
|
|
|
|
std::vector<std::string> QNNTranslator::TranslateNodeOutputArray(const std::string & outputArraySymbol, uint32_t numOfOutputs, const Qnn_Tensor_t * outputs) {
|
|
std::vector<std::string> result;
|
|
|
|
std::string str = " Qnn_Tensor_t " + outputArraySymbol + "[] = {";
|
|
for (uint32_t i = 0; i < numOfOutputs; i++) {
|
|
str += TENSOR_NAME_SYMBOL(outputs[i].v1.name);
|
|
if (i < numOfOutputs - 1) {
|
|
str +=", ";
|
|
}
|
|
}
|
|
str += "};";
|
|
|
|
result.push_back(str);
|
|
|
|
return result;
|
|
}
|
|
#endif
|
|
} // end namespace MNN
|
|
} // end namespace QNN
|