wehub-resource-sync
559 lines
23 KiB
C++
559 lines
23 KiB
C++
#include <MNN/expr/Module.hpp>
|
|
#include <MNN/expr/ExprCreator.hpp>
|
|
#include <MNN/expr/ExecutorScope.hpp>
|
|
#include "core/OpCommonUtils.hpp"
|
|
#include "MNN_generated.h"
|
|
#include <cstdlib>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include <rapidjson/document.h>
|
|
#include "rapidjson/prettywriter.h"
|
|
#include "rapidjson/stringbuffer.h"
|
|
#include "core/MNNFileUtils.h"
|
|
#ifndef _WIN32
|
|
#include <sys/utsname.h>
|
|
#endif
|
|
|
|
using namespace rapidjson;
|
|
|
|
using namespace MNN::Express;
|
|
using namespace MNN;
|
|
|
|
static bool generateConfigFile(const std::string & qnnSDKPath, int socID, int dspArch, const std::vector<std::string> & graphNameVec, const std::string & outputDir, std::string & configPath, std::string & subConfigPath) {
|
|
configPath = MNNFilePathConcat(outputDir, "context_config.json");
|
|
subConfigPath = MNNFilePathConcat(outputDir, "htp_backend_extensions.json");
|
|
|
|
// Write context_config.json
|
|
rapidjson::Document contextConfigDoc;
|
|
contextConfigDoc.SetObject();
|
|
rapidjson::Document::AllocatorType& contextAllocator = contextConfigDoc.GetAllocator();
|
|
rapidjson::Value backendExtensions(rapidjson::kObjectType);
|
|
std::string htpBackendExtPath = MNNFilePathConcat(qnnSDKPath, "lib/x86_64-linux-clang/libQnnHtpNetRunExtensions.so");
|
|
backendExtensions.AddMember("shared_library_path", rapidjson::Value(htpBackendExtPath.c_str(), contextAllocator).Move(), contextAllocator);
|
|
backendExtensions.AddMember("config_file_path", rapidjson::Value(subConfigPath.c_str(), contextAllocator).Move(), contextAllocator);
|
|
contextConfigDoc.AddMember("backend_extensions", backendExtensions, contextAllocator);
|
|
rapidjson::StringBuffer contextBuffer;
|
|
rapidjson::PrettyWriter<rapidjson::StringBuffer> contextWriter(contextBuffer);
|
|
contextConfigDoc.Accept(contextWriter);
|
|
std::ofstream contextConfigOut(configPath);
|
|
contextConfigOut << contextBuffer.GetString();
|
|
contextConfigOut.close();
|
|
|
|
// Write htp_backend_extensions.json
|
|
rapidjson::Document htpConfigDoc;
|
|
htpConfigDoc.SetObject();
|
|
rapidjson::Document::AllocatorType& htpConfigAllocator = htpConfigDoc.GetAllocator();
|
|
|
|
// "graphs" section
|
|
rapidjson::Value graphs(rapidjson::kArrayType);
|
|
rapidjson::Value graphObj(rapidjson::kObjectType);
|
|
graphObj.AddMember("vtcm_mb", 8, htpConfigAllocator);
|
|
rapidjson::Value names(rapidjson::kArrayType);
|
|
for (const auto& name : graphNameVec) {
|
|
names.PushBack(rapidjson::Value(name.c_str(), contextAllocator).Move(), htpConfigAllocator);
|
|
}
|
|
graphObj.AddMember("graph_names", names, htpConfigAllocator);
|
|
graphObj.AddMember("O", 3.0, htpConfigAllocator);
|
|
graphObj.AddMember("fp16_relaxed_precision", 1, htpConfigAllocator);
|
|
graphObj.AddMember("weights_packing", true, htpConfigAllocator);
|
|
graphObj.AddMember("hvx_threads", 4, htpConfigAllocator);
|
|
graphs.PushBack(graphObj, htpConfigAllocator);
|
|
htpConfigDoc.AddMember("graphs", graphs, htpConfigAllocator);
|
|
|
|
// "devices" section
|
|
rapidjson::Value devices(rapidjson::kArrayType);
|
|
rapidjson::Value deviceObj(rapidjson::kObjectType);
|
|
deviceObj.AddMember("soc_id", socID, htpConfigAllocator);
|
|
std::string hexagonArchStr = "v" + std::to_string(dspArch);
|
|
deviceObj.AddMember("dsp_arch", rapidjson::Value(hexagonArchStr.c_str(), contextAllocator).Move(), htpConfigAllocator);
|
|
rapidjson::Value cores(rapidjson::kArrayType);
|
|
rapidjson::Value coreObj(rapidjson::kObjectType);
|
|
coreObj.AddMember("core_id", 0, htpConfigAllocator);
|
|
coreObj.AddMember("perf_profile", "burst", htpConfigAllocator);
|
|
coreObj.AddMember("rpc_control_latency", 100, htpConfigAllocator);
|
|
cores.PushBack(coreObj, htpConfigAllocator);
|
|
deviceObj.AddMember("cores", cores, htpConfigAllocator);
|
|
devices.PushBack(deviceObj, htpConfigAllocator);
|
|
htpConfigDoc.AddMember("devices", devices, htpConfigAllocator);
|
|
|
|
// "context" section
|
|
rapidjson::Value contextObj(rapidjson::kObjectType);
|
|
contextObj.AddMember("weight_sharing_enabled", true, htpConfigAllocator);
|
|
htpConfigDoc.AddMember("context", contextObj, htpConfigAllocator);
|
|
|
|
rapidjson::StringBuffer htpConfigBuffer;
|
|
rapidjson::PrettyWriter<rapidjson::StringBuffer> htpConfigWriter(htpConfigBuffer);
|
|
htpConfigDoc.Accept(htpConfigWriter);
|
|
std::ofstream htpConfigOut(subConfigPath);
|
|
htpConfigOut << htpConfigBuffer.GetString();
|
|
htpConfigOut.close();
|
|
return true;
|
|
}
|
|
|
|
static bool parseDims(const std::string& s, std::vector<std::vector<int>>& out) {
|
|
auto isLegal = [](char c) {
|
|
return c == 'x' || c == '_' || (c >= '0' && c <= '9');
|
|
};
|
|
bool allLegal = std::all_of(s.begin(), s.end(), isLegal);
|
|
if(!allLegal) {
|
|
return false;
|
|
}
|
|
|
|
out.clear();
|
|
std::stringstream ss(s);
|
|
std::string segment;
|
|
MNN_PRINT("param dims: %s\n", s.c_str());
|
|
while (std::getline(ss, segment, '_')) {
|
|
if (segment.empty()) {
|
|
MNN_ERROR("%s parse error, format should be like 1x3x512x512_1x256\n", s.c_str());
|
|
return false;
|
|
}
|
|
std::vector<int> dims;
|
|
std::stringstream inner(segment);
|
|
std::string token;
|
|
|
|
while (std::getline(inner, token, 'x')) {
|
|
if (token.empty()) {
|
|
MNN_ERROR("%s parse error, format should be like 1x3x512x512_1x256\n", s.c_str());
|
|
return false;
|
|
}
|
|
int val = std::stoi(token);
|
|
dims.push_back(val);
|
|
}
|
|
if (dims.empty()) {
|
|
MNN_ERROR("%s parse error, format should be like 1x3x512x512_1x256\n", s.c_str());
|
|
return false;
|
|
}
|
|
out.push_back(dims);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static bool checkSystem() {
|
|
#ifdef _WIN32
|
|
// On Windows, skip the system check as this tool is primarily for Linux
|
|
// but we allow it to compile on Windows for development purposes
|
|
MNN_PRINT("Warning: This tool is designed for x86_64 Linux systems. Running on Windows may have limitations.\n");
|
|
return true;
|
|
#else
|
|
struct utsname buf;
|
|
if (uname(&buf) != 0) {
|
|
MNN_ERROR("uname error\n");
|
|
return false;
|
|
}
|
|
if (std::string(buf.sysname) == "Linux" && std::string(buf.machine) == "x86_64") {
|
|
return true;
|
|
}
|
|
MNN_ERROR("This program must be run on a x86_64 Linux system. Current system: %s %s\n", buf.sysname, buf.machine);
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
int main(int argc, const char* argv[]) {
|
|
if (argc < 6) {
|
|
MNN_PRINT("This tool generates offline caches for the QNN backend.");
|
|
MNN_PRINT("Usage: %s <qnnSDKPath> <socId> <hexagonArch> <srcMNNPath> <outputDir> [totalShapeNum] [inputShape1] [inputShape2] ...\n", argv[0]);
|
|
MNN_PRINT(" <qnnSDKPath> : Path to the QNN SDK directory.\n");
|
|
MNN_PRINT(" <socId> : Target SoC ID.\n");
|
|
MNN_PRINT(" Common SoCs: 8Gen2 -> 43, 8Gen3 -> 57, 8 Elite -> 69. For others, please refer to Qualcomm's documentation.\n");
|
|
MNN_PRINT(" <hexagonArch> : Hexagon architecture version. This tool requires v73 or higher for weight sharing.\n");
|
|
MNN_PRINT(" Common Archs: 8Gen2 -> 73, 8Gen3 -> 75, 8 Elite -> 79. For others, please refer to Qualcomm's documentation.\n");
|
|
MNN_PRINT(" <srcMNNPath> : Path to the source MNN model file.\n");
|
|
MNN_PRINT(" <outputDir> : Directory to save the generated files, including a MNN model file with the suffix '.mnn' and a QNN serialized artifact with the suffix '.bin'.\n");
|
|
MNN_PRINT(" [<totalShapeNum>] : Optional. Number of dynamic input shape configurations.\n");
|
|
MNN_PRINT(" [<inputShapeN>] : Optional. Input shape configuration. Can be a shape string or a path to a .mnn file.\n");
|
|
MNN_PRINT(" Shape string format for multiple inputs: dim1xdim2_dim3xdim4. Example: 1x3x512x512_1x256\n");
|
|
MNN_PRINT("Examples:\n");
|
|
MNN_PRINT(" 1. Use default shape from the MNN model:\n");
|
|
MNN_PRINT(" %s /path/to/qnn/sdk 57 75 /path/to/model.mnn /path/to/output\n", argv[0]);
|
|
MNN_PRINT(" 2. Specify two dynamic input shapes:\n");
|
|
MNN_PRINT(" %s /path/to/qnn/sdk 57 75 /path/to/model.mnn /path/to/output 2 1x3x512x512_1x256 1x3x256x256_1x128\n", argv[0]);
|
|
MNN_PRINT(" %s /path/to/qnn/sdk 57 75 /path/to/model.mnn /path/to/output 2 input_0.mnn input_1.mnn\n", argv[0]);
|
|
|
|
return 1;
|
|
}
|
|
|
|
if (!checkSystem()) {
|
|
return -1;
|
|
}
|
|
|
|
std::string qnnSdkPath = argv[1];
|
|
int socId = std::stoi(std::string(argv[2]));
|
|
int hexagonArch = std::stoi(std::string(argv[3]));
|
|
const char* srcMNNPath = argv[4];
|
|
std::string modelBaseName = [](const std::string& path) {
|
|
std::string filename = path;
|
|
auto pos = path.find_last_of("/\\");
|
|
if (pos != std::string::npos) {
|
|
filename = path.substr(pos + 1);
|
|
}
|
|
pos = filename.find_last_of('.');
|
|
if (pos != std::string::npos) {
|
|
return filename.substr(0, pos);
|
|
}
|
|
return filename;
|
|
}(srcMNNPath);
|
|
std::string modelSignature = "_" + std::to_string(socId) + "_" + std::to_string(hexagonArch);
|
|
std::string outputDir = argv[5];
|
|
std::string dstMNNPath = MNNFilePathConcat(outputDir, modelBaseName + modelSignature + ".mnn");
|
|
|
|
std::vector<std::string> inputNames;
|
|
std::vector<std::string> outputNames;
|
|
std::vector<MNN::Express::VARP> inputs;
|
|
std::vector<MNN::Express::VARP> outputs;
|
|
std::vector<std::vector<std::vector<int>>> inputShapeLists;
|
|
bool hasInputsVarp = false;
|
|
std::vector<std::vector<MNN::Express::VARP>> inputsVarpList;
|
|
|
|
int totalShapeType = 1;
|
|
if(argc > 6) {
|
|
totalShapeType = std::stoi(argv[6]);
|
|
std::vector<std::vector<int>> temp;
|
|
if(parseDims(argv[7], temp)) {
|
|
inputShapeLists.resize(totalShapeType);
|
|
for(int i = 0; i < totalShapeType; i++) {
|
|
// Each inputs shape in model: 128x1x897_1x1x128x128_1x128
|
|
if(!parseDims(argv[7+i], inputShapeLists[i])) {
|
|
return -1;
|
|
}
|
|
}
|
|
} else {
|
|
inputsVarpList.resize(totalShapeType);
|
|
for(int i = 0; i < totalShapeType; i++) {
|
|
inputsVarpList[i] = MNN::Express::Variable::load(argv[7+i]);
|
|
}
|
|
inputs = MNN::Express::Variable::load(argv[7]);
|
|
for (int i=0; i<inputs.size(); ++i) {
|
|
inputNames.emplace_back(inputs[i]->name());
|
|
}
|
|
if(argc > 7+totalShapeType) {
|
|
outputs = MNN::Express::Variable::load(argv[7+totalShapeType]);
|
|
for (int i=0; i<outputs.size(); ++i) {
|
|
outputNames.emplace_back(outputs[i]->name());
|
|
}
|
|
}
|
|
hasInputsVarp = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
generate qnn .cpp and .bin
|
|
*/
|
|
std::string totalQnnSo;
|
|
std::vector<std::string> qnnGraphNames;
|
|
std::vector<std::vector<MNN::Express::Variable::Info>> outputInfos;
|
|
std::vector<std::string> qnnModelDirs;
|
|
std::vector<int> allInputShape;
|
|
|
|
MNN_PRINT("Total input shape type size:%d\n", totalShapeType);
|
|
for(int index = 0; index < totalShapeType; index++)
|
|
{
|
|
std::string curQnnModelName = modelBaseName + std::string("_") + std::to_string(index);
|
|
qnnGraphNames.emplace_back(curQnnModelName);
|
|
std::string curQnnModelDir = MNNFilePathConcat(outputDir, curQnnModelName);
|
|
MNN_PRINT("[Temp Product]: Qnn temp product generate at %s\n", curQnnModelDir.c_str());
|
|
MNNCreateDir(curQnnModelDir.c_str());
|
|
qnnModelDirs.push_back(curQnnModelDir);
|
|
if(index < totalShapeType-1) {
|
|
totalQnnSo += (curQnnModelDir + std::string("/lib/x86_64-linux-clang/lib") + \
|
|
curQnnModelName + std::string(".so,"));
|
|
} else {
|
|
totalQnnSo += (curQnnModelDir + std::string("/lib/x86_64-linux-clang/lib") + \
|
|
curQnnModelName + std::string(".so "));
|
|
}
|
|
|
|
MNN::ScheduleConfig config;
|
|
config.type = MNN_CONVERT_QNN;
|
|
std::shared_ptr<Executor::RuntimeManager> rtmgr(Executor::RuntimeManager::createRuntimeManager(config));
|
|
rtmgr->setCache(curQnnModelDir.c_str());
|
|
MNN::Express::Module::Config mConfig;
|
|
mConfig.shapeMutable = false;
|
|
std::shared_ptr<MNN::Express::Module> m(MNN::Express::Module::load(inputNames, outputNames, srcMNNPath, rtmgr, &mConfig), MNN::Express::Module::destroy);
|
|
auto minfo = m->getInfo();
|
|
if(outputNames.empty()) {
|
|
outputNames = minfo->outputNames;
|
|
}
|
|
if(inputNames.empty()) {
|
|
inputNames = minfo->inputNames;
|
|
}
|
|
|
|
if(!hasInputsVarp) {
|
|
inputs.resize(minfo->inputs.size());
|
|
for (int i=0; i<minfo->inputs.size(); ++i) {
|
|
auto info = minfo->inputs[i];
|
|
std::vector<int> inputDims = info.dim;
|
|
if(!inputShapeLists.empty()) {
|
|
inputDims = inputShapeLists[index][i];
|
|
}
|
|
MNN_PRINT("input %d shape:", i);
|
|
for(int d = 0; d < inputDims.size(); d++) {
|
|
MNN_PRINT("%d ", inputDims[d]);
|
|
}
|
|
MNN_PRINT("\n");
|
|
auto varp = MNN::Express::_Input(inputDims, info.order, info.type);
|
|
varp->writeMap<void>();
|
|
inputs[i] = varp;
|
|
inputs[i]->setName(inputNames[i]);
|
|
}
|
|
} else {
|
|
inputs = inputsVarpList[index];
|
|
}
|
|
outputs = m->onForward(inputs);
|
|
// sync
|
|
for(int i = 0; i < outputs.size(); i++) {
|
|
outputs[i]->readMap<void>();
|
|
}
|
|
|
|
// tar weight
|
|
std::string binPath = MNNFilePathConcat(curQnnModelDir, curQnnModelName + ".bin");
|
|
std::string command = "tar -cf " + binPath + " -C " + curQnnModelDir + " $(find " + curQnnModelDir + " -maxdepth 1 -name '*.raw' -printf '%f ') && rm " + curQnnModelDir + "/*.raw";
|
|
int ret = std::system(command.c_str());
|
|
if (ret != 0) {
|
|
MNN_ERROR("Failed to execute command: %s\n", command.c_str());
|
|
}
|
|
|
|
std::string modelLibCmd = qnnSdkPath + "/bin/x86_64-linux-clang/qnn-model-lib-generator" + \
|
|
" -c " + MNNFilePathConcat(curQnnModelDir, curQnnModelName + ".cpp") + \
|
|
" -b " + binPath + \
|
|
" -t x86_64-linux-clang " + \
|
|
" -o " + curQnnModelDir + "/lib";
|
|
ret = system(modelLibCmd.c_str());
|
|
if(ret) {
|
|
MNN_ERROR("[Error]: qnn-model-lib-generator error!\n");
|
|
return -1;
|
|
} else {
|
|
MNN_PRINT("[Pass]: qnn-model-lib-generator success!\n");
|
|
}
|
|
|
|
|
|
std::vector<MNN::Express::Variable::Info> inputInfos(inputs.size());
|
|
for (int i=0; i<inputInfos.size(); ++i) {
|
|
inputInfos[i] = *inputs[i]->getInfo();
|
|
}
|
|
std::vector<int> currInputShape;
|
|
for (int i = 0; i < inputInfos.size(); i++) {
|
|
for (int j = 0; j < inputInfos[i].dim.size(); j++) {
|
|
currInputShape.emplace_back(inputInfos[i].dim[j]);
|
|
}
|
|
}
|
|
allInputShape.insert(allInputShape.end(), currInputShape.begin(), currInputShape.end());
|
|
|
|
std::vector<MNN::Express::Variable::Info> outputInfo(outputs.size());
|
|
for (int i=0; i<outputInfo.size(); ++i) {
|
|
outputInfo[i] = *outputs[i]->getInfo();
|
|
}
|
|
outputInfos.emplace_back(outputInfo);
|
|
|
|
}
|
|
|
|
std::string npuArtifactName = modelBaseName + modelSignature + ".bin";
|
|
std::string npuArtifactPath = MNNFilePathConcat(outputDir, npuArtifactName);
|
|
{
|
|
std::string configPath, subConfigPath;
|
|
if (!generateConfigFile(qnnSdkPath, socId, hexagonArch, qnnGraphNames, outputDir, configPath, subConfigPath)) {
|
|
MNN_ERROR("[Error]: Failed to generate the config file!\n");
|
|
return -1;
|
|
}
|
|
|
|
std::string binaryGenCmd = qnnSdkPath + "/bin/x86_64-linux-clang/qnn-context-binary-generator" + \
|
|
" --model " + totalQnnSo + \
|
|
" --backend " + qnnSdkPath + "/lib/x86_64-linux-clang/libQnnHtp.so" + \
|
|
" --binary_file " + modelBaseName + modelSignature + \
|
|
" --config_file " + configPath + " " + \
|
|
" --output_dir " + outputDir;
|
|
auto res = system(binaryGenCmd.c_str());
|
|
if(res) {
|
|
MNN_ERROR("[Error]: qnn-context-binary-generator error!\n");
|
|
return -1;
|
|
} else {
|
|
MNN_PRINT("[Pass]: qnn-context-binary-generator success!\n");
|
|
}
|
|
|
|
// Remove intermediate files
|
|
MNNRemoveFile(configPath.c_str());
|
|
MNNRemoveFile(subConfigPath.c_str());
|
|
for (const auto& dir : qnnModelDirs) {
|
|
std::string cmd = "rm -rf " + dir;
|
|
int ret = system(cmd.c_str());
|
|
if (ret != 0) {
|
|
MNN_PRINT("[Warning]: failed to remove temp dir: %s\n", dir.c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<MNN::Express::Variable::Info> inputInfos(inputs.size());
|
|
for (int i=0; i<inputInfos.size(); ++i) {
|
|
inputInfos[i] = *inputs[i]->getInfo();
|
|
}
|
|
|
|
|
|
// Get inputs/outputs index in mnn model
|
|
std::vector<int> inputIndexes(inputNames.size());
|
|
std::vector<int> outputIndexes(outputNames.size());
|
|
{
|
|
std::shared_ptr<MNN::Interpreter> netC(MNN::Interpreter::createFromFile(srcMNNPath), MNN::Interpreter::destroy);
|
|
auto bufferPair = netC->getModelBuffer();
|
|
auto buffer = bufferPair.first;
|
|
auto length = bufferPair.second;
|
|
auto net = GetNet(buffer);
|
|
|
|
for (int i=0; i<net->tensorName()->size(); ++i) {
|
|
auto tname = net->tensorName()->GetAsString(i)->str();
|
|
for (int j=0; j<inputNames.size(); ++j) {
|
|
if (tname == inputNames[j]) {
|
|
inputIndexes[j] = i;
|
|
break;
|
|
}
|
|
}
|
|
for (int j=0; j<outputNames.size(); ++j) {
|
|
if (tname == outputNames[j]) {
|
|
outputIndexes[j] = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<MNN::NetT> dstNet(new NetT);
|
|
|
|
for (int i=0; i<inputInfos.size(); ++i) {
|
|
std::unique_ptr<OpT> input(new OpT);
|
|
input->type = OpType_Input;
|
|
auto param(new InputT);
|
|
param->dims = inputInfos[i].dim;
|
|
|
|
input->main.type = OpParameter_Input;
|
|
input->main.value = param;
|
|
input->name = inputNames[i];
|
|
input->outputIndexes.push_back(i);
|
|
dstNet->oplists.emplace_back(std::move(input));
|
|
}
|
|
|
|
/** Fuse to Op*/
|
|
std::unique_ptr<MNN::OpT> op(new OpT);
|
|
for(int i = 0; i < inputs.size(); i++) {
|
|
op->inputIndexes.push_back(i);
|
|
}
|
|
for(int i = 0; i < outputs.size(); i++) {
|
|
op->outputIndexes.push_back(inputs.size() + i);
|
|
}
|
|
op->name = "qnn/plugin/op";
|
|
op->main.Reset();
|
|
op->type = MNN::OpType_Plugin;
|
|
op->main.type = MNN::OpParameter_Plugin;
|
|
op->main.value = new MNN::PluginT;
|
|
auto extra = op->main.AsPlugin();
|
|
extra->type = "QNN";
|
|
std::unique_ptr<MNN::AttributeT> attr(new MNN::AttributeT);
|
|
|
|
|
|
dstNet->tensorName = inputNames;
|
|
dstNet->tensorName.insert(dstNet->tensorName.end(), outputNames.begin(), outputNames.end());
|
|
dstNet->tensorName.push_back(op->name);
|
|
dstNet->outputName = outputNames;
|
|
|
|
attr->key = "allInputShape";
|
|
attr->list.reset(new ListValueT);
|
|
attr->list->i.insert(attr->list->i.end(), allInputShape.begin(), allInputShape.end());
|
|
extra->attr.emplace_back(std::move(attr));
|
|
attr.reset(new MNN::AttributeT);
|
|
|
|
attr->key = "allGraphName";
|
|
attr->list.reset(new ListValueT);
|
|
attr->list->s.resize(qnnGraphNames.size());
|
|
for(int i = 0; i < qnnGraphNames.size(); i++) {
|
|
attr->list->s[i] = qnnGraphNames[i];
|
|
}
|
|
extra->attr.emplace_back(std::move(attr));
|
|
attr.reset(new MNN::AttributeT);
|
|
|
|
attr->key = "path";
|
|
attr->s = npuArtifactName;
|
|
extra->attr.emplace_back(std::move(attr));
|
|
attr.reset(new MNN::AttributeT);
|
|
|
|
attr->key = "offset";
|
|
attr->list.reset(new MNN::ListValueT);
|
|
attr->list->i.push_back(0);
|
|
attr->list->i.push_back(0);
|
|
extra->attr.emplace_back(std::move(attr));
|
|
attr.reset(new MNN::AttributeT);
|
|
|
|
file_t binaryFile = MNNOpenFile(npuArtifactPath.c_str(), MNN_FILE_READ);
|
|
size_t binarySize = MNNGetFileSize(binaryFile);
|
|
MNNCloseFile(binaryFile);
|
|
attr->key = "size";
|
|
attr->list.reset(new MNN::ListValueT);
|
|
uint32_t lowSrc = binarySize & 0xFFFFFFFF;
|
|
uint32_t highSrc = binarySize >> 32;
|
|
int32_t lowDst, highDst;
|
|
::memcpy(&lowDst, &lowSrc, sizeof(int32_t));
|
|
::memcpy(&highDst, &highSrc, sizeof(int32_t));
|
|
attr->list->i.push_back(lowDst);
|
|
attr->list->i.push_back(highDst);
|
|
extra->attr.emplace_back(std::move(attr));
|
|
attr.reset(new MNN::AttributeT);
|
|
|
|
attr->key = "inputs";
|
|
attr->list.reset(new ListValueT);
|
|
attr->list->s.resize(inputNames.size());
|
|
for (int i=0; i<inputNames.size(); ++i) {
|
|
// ::TODO
|
|
attr->list->s[i] = std::string("t") + std::to_string(inputIndexes[i]);
|
|
}
|
|
extra->attr.emplace_back(std::move(attr));
|
|
attr.reset(new MNN::AttributeT);
|
|
attr->key = "outputs";
|
|
attr->list.reset(new ListValueT);
|
|
attr->list->s.resize(outputNames.size());
|
|
for (int i=0; i<outputNames.size(); ++i) {
|
|
// ::TODO
|
|
attr->list->s[i] = std::string("t") + std::to_string(outputIndexes[i]);
|
|
}
|
|
extra->attr.emplace_back(std::move(attr));
|
|
|
|
|
|
for (int i=0; i<outputInfos.size(); ++i) {
|
|
attr.reset(new MNN::AttributeT);
|
|
for(int j = 0; j < outputInfos[i].size(); j++) {
|
|
attr->key = "o_" + std::to_string(i) + std::string("_") + std::to_string(j);
|
|
attr->tensor.reset(new BlobT);
|
|
attr->tensor->dataType = OpCommonUtils::convertDataType(outputInfos[i][j].type);
|
|
attr->tensor->dims = outputInfos[i][j].dim;
|
|
switch(outputInfos[i][j].order) {
|
|
case MNN::Express::NHWC:
|
|
attr->tensor->dataFormat = MNN_DATA_FORMAT_NHWC;
|
|
break;
|
|
case MNN::Express::NCHW:
|
|
attr->tensor->dataFormat = MNN_DATA_FORMAT_NCHW;
|
|
break;
|
|
case MNN::Express::NC4HW4:
|
|
attr->tensor->dataFormat = MNN_DATA_FORMAT_NC4HW4;
|
|
break;
|
|
default:
|
|
attr->tensor->dataFormat = MNN_DATA_FORMAT_NCHW;
|
|
break;
|
|
}
|
|
}
|
|
extra->attr.emplace_back(std::move(attr));
|
|
}
|
|
|
|
// Compile NPU Module
|
|
std::unique_ptr<OpT> npuOp;
|
|
npuOp = std::move(op);
|
|
|
|
// Merge to dst
|
|
dstNet->oplists.emplace_back(std::move(npuOp));
|
|
|
|
// Store
|
|
flatbuffers::FlatBufferBuilder builder;
|
|
builder.Finish(Net::Pack(builder, dstNet.get()));
|
|
std::ofstream outputOs(dstMNNPath.c_str(), std::ios::binary);
|
|
outputOs.write((const char*)builder.GetBufferPointer(), builder.GetSize());
|
|
outputOs.close();
|
|
|
|
MNN_PRINT("[All passed]\n");
|
|
return 0;
|
|
}
|