rename amexec

msame/build.sh

@@ -0,0 +1,9 @@
+g="$1"
+locate="$2"
+rm -rf build
+mkdir -p build/intermediates/host
+cd build/intermediates/host
+cmake ../../../src -DCMAKE_CXX_COMPILER=${g} -DCMAKE_SKIP_RPATH=TRUE
+make
+cd ../../../out
+mv main ${locate}/msame

msame/inc/model_process.h

@@ -0,0 +1,119 @@
+//Model_process.h
+ 
+/**
+* @file model_process.h
+*
+* Copyright (C) 2020. Huawei Technologies Co., Ltd. All rights reserved.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*/
+#pragma once
+#include "utils.h"
+#include "acl/acl.h"
+ 
+using namespace std;
+/**
+* ModelProcess
+*/
+class ModelProcess {
+public:
+    /**
+    * @brief Constructor
+    */
+    ModelProcess();
+ 
+    /**
+    * @brief Destructor
+    */
+    ~ModelProcess();
+ 
+    /**
+    * @brief load model from file with mem
+    * @param [in] modelPath: model path
+    * @return result
+    */
+    Result LoadModelFromFileWithMem(const char *modelPath);
+ 
+    /**
+    * @brief unload model
+    */
+    void Unload();
+ 
+    /**
+    * @brief create model desc
+    * @return result
+    */
+    Result CreateDesc();
+
+    /**
+    * @brief PrintDesc
+    */
+    Result PrintDesc();
+ 
+    /**
+    * @brief destroy desc
+    */
+    void DestroyDesc();
+ 
+    /**
+    * @brief create model input
+    * @param [in] inputDataBuffer: input buffer
+    * @param [in] bufferSize: input buffer size
+    * @return result
+    */
+    Result CreateInput(void *inputDataBuffer, size_t bufferSize);
+
+     /**
+    * @brief create model input
+    * @return result
+    */
+    Result CreateZeroInput();
+    
+    /**
+    * @brief destroy input resource
+    */
+    void DestroyInput();
+ 
+    /**
+    * @brief create output buffer
+    * @return result
+    */
+    Result CreateOutput();
+ 
+    /**
+    * @brief destroy output resource
+    */
+    void DestroyOutput();
+ 
+    /**
+    * @brief model execute
+    * @return result
+    */
+    Result Execute();
+ 
+    /**
+    * @brief dump model output result to file
+    */
+    void DumpModelOutputResult();
+ 
+    /**
+    * @brief get model output result
+    */
+    void OutputModelResult(std::string& s,std::string& modelName,size_t index);
+	
+ 
+private:
+    uint32_t modelId_;
+    size_t modelMemSize_;
+    size_t modelWeightSize_;
+    void *modelMemPtr_;
+    void *modelWeightPtr_;
+    bool loadFlag_; // model load flag
+    aclmdlDesc *modelDesc_;
+    aclmdlDataset *input_;
+    aclmdlDataset *output_;
+    size_t numInputs_;
+    size_t numOutputs_;
+};

msame/inc/sample_process.h

@@ -0,0 +1,51 @@
+//Sample_process.h
+ 
+/**
+* @file sample_process.h
+*
+* Copyright (C) 2020. Huawei Technologies Co., Ltd. All rights reserved.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*/
+#pragma once
+#include "utils.h"
+#include "acl/acl.h"
+#include <stdio.h>
+ 
+using namespace std;
+/**
+* SampleProcess
+*/
+class SampleProcess {
+public:
+    /**
+    * @brief Constructor
+    */
+    SampleProcess();
+ 
+    /**
+    * @brief Destructor
+    */
+    ~SampleProcess();
+ 
+    /**
+    * @brief init reousce
+    * @return result
+    */
+    Result InitResource();
+ 
+    /**
+    * @brief sample process
+    * @return result
+    */
+    Result Process(map<char,string>& params, vector<string>& inputs);
+ 
+private:
+    void DestroyResource();
+ 
+    int32_t deviceId_;
+    aclrtContext context_;
+    aclrtStream stream_;
+};

msame/inc/utils.h

@@ -0,0 +1,86 @@
+//Util.h
+ 
+/**
+* @file utils.h
+*
+* Copyright (C) 2020. Huawei Technologies Co., Ltd. All rights reserved.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*/
+#pragma once
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <cstring>
+#include <string>
+#include <map>
+#include <vector>
+#include <algorithm>
+#include <stdio.h>
+#include <time.h>
+#include <sys/time.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <cstddef>
+ 
+#define INFO_LOG(fmt, args...) fprintf(stdout, "[INFO] " fmt "\n", ##args)
+#define DEBUG_LOG(fmt, args...) fprintf(stdout, "[DEBUG] " fmt "\n", ##args)
+#define WARN_LOG(fmt, args...) fprintf(stdout, "[WARN] " fmt "\n", ##args)
+#define ERROR_LOG(fmt, args...) fprintf(stdout, "[ERROR] " fmt "\n", ##args)
+ 
+using namespace std;
+//static size_t loop = 1;
+typedef enum Result {
+    SUCCESS = 0,
+    FAILED = 1
+} Result;
+
+ 
+/**
+* Utils
+*/
+class Utils {
+public:
+    /**
+    * @brief create device buffer of file
+    * @param [in] fileName: file name
+    * @param [out] fileSize: size of file
+    * @return device buffer of file
+    */
+    static void *GetDeviceBufferOfFile(std::string fileName, uint32_t &fileSize);
+ 
+    /**
+    * @brief create buffer of file
+    * @param [in] fileName: file name
+    * @param [out] fileSize: size of file
+    * @return buffer of pic
+    */
+    static void* ReadBinFile(std::string fileName, uint32_t& fileSize);
+ 
+    static void SplitString(std::string& s, std::vector<std::string>& v, char c);
+        
+    static int str2num(char *str);
+	
+	static std::string modelName(string& s);
+	
+	static std::string TimeLine();
+	
+	static void printCurrentTime();
+	
+	static void printHelpLetter();	
+
+    static double printDiffTime(time_t begin, time_t end);
+	
+    static double InferenceTimeAverage(double *x, int len);
+	
+	static double InferenceTimeAverageWithoutFirst(double *x, int len);
+
+    static void ProfilerJson(bool isprof, map<char,string>& params);
+
+    static void DumpJson(bool isdump, map<char,string>& params);
+};
+ 
+#pragma once

msame/readMe.md

@@ -0,0 +1,79 @@
+# amexec工具为模型推理工具
+
+### 功能
+输入.om模型和模型所需要的输入bin文件，输出模型的输出数据文件，支持多次推理（指对同一输入数据进行推理）。
+
+模型必须是通过c7x版本的atc工具转换的om模型，输入bin文件需要符合模型的输入要求（支持模型多输入）。
+
+### 使用环境
+按照《驱动和开发环境安装指南》装好C7x环境。
+
+### 获取
+1. 下载压缩包方式获取。
+
+   将 https://gitee.com/ascend/tools 仓中的脚本下载至服务器的任意目录。
+
+   例如存放路径为：$HOME/AscendProjects/tools。
+
+2. 命令行使用git命令方式获取。
+
+   在命令行中：$HOME/AscendProjects目录下执行以下命令下载代码。
+
+   **git clone https://gitee.com/ascend/tools.git**
+
+
+### 使用方法
+#### a. 使用已编译好的工具直接运行。   
+
+ **环境要求：架构为arm、已安装c7x的运行环境。如环境不符，请使用方法b，进行源码编译。** 
+  
+进入amexec目录
+```
+cd $HOME/AscendProjects/tools/amexec/
+```
+进入out目录
+```
+cd out
+```
+工具就在out目录下
+
+
+工具为命令行的运行方式，例如
+```
+./amexec --model /home/HwHiAiUser/ljj/colorization.om --input /home/HwHiAiUser/ljj/colorization_input.bin --output /home/HwHiAiUser/ljj/AMEXEC/out/output1 --outfmt TXT --loop 2
+```
+如果有多个输入，需要用**英文逗号**隔开，注意逗号两边不能有空格。  
+其他参数详情可使用--help查询。
+
+
+#### b. 源码编译运行。
+ **环境要求：已安装c7x的开发运行环境，分设合设都可以。**   
+工具也支持源码编译，或者使用者需要添加或者修改代码，使用者重新编译
+进入amexec目录
+```
+cd $HOME/AscendProjects/tools/amexec/
+```
+运行编译脚本
+```
+./build.sh g++ $HOME/AscendProjects/tools/amexec/out
+```
+第一个参数指定编译器，由运行环境决定。  
+第二个参数指定工具生成的目录，填相对路径的话，是相对out目录。
+
+## 注意事项
+运行工具的用户在当前目录需要有创建目录以及执行工具的权限，使用前请自行检查。  
+dump、动态多batch功能暂不支持。
+
+## 参数说明
+
+| 参数名   | 说明                            |
+| -------- | ------------------------------- |
+| --model  | 需要进行推理的om模型            |
+| --input  | 模型需要的输入，若不填，会自动生成都为0的数据                  |
+| --output | 推理数据输出路径                |
+| --outfmt | 输出数据的格式，TXT或者BIN      |
+| --loop   | 推理次数 [1,100]，可选参数，默认1，profiler为true时，推荐为1 |
+| --debug   | 调试开关，可打印model的desc信息，true或者false，可选参数，默认fasle |
+| --profiler   | profiler开关，可选参数，默认false |
+| --device   | 指定运行设备 [0,255]，可选参数，默认0 |
+| --help   | 工具使用帮助信息                  |

msame/src/CMakeLists.txt

@@ -0,0 +1,59 @@
+# Copyright (c) Huawei Technologies Co., Ltd. 2019. All rights reserved.
+
+# CMake lowest version requirement
+cmake_minimum_required(VERSION 3.5.1)
+
+# project information
+project(AME)
+
+# Compile options
+add_compile_options(-std=c++11)
+
+add_definitions(-DENABLE_DVPP_INTERFACE)
+
+# Specify target generation path
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY  "../../../out")
+set(CMAKE_CXX_FLAGS_DEBUG "-fPIC -O0 -g -Wall")
+set(CMAKE_CXX_FLAGS_RELEASE "-fPIC -O2 -Wall")
+
+set(INC_PATH $ENV{DDK_PATH})
+
+if (NOT DEFINED ENV{DDK_PATH})
+    set(INC_PATH "/usr/local/Ascend")
+    message(STATUS "set default INC_PATH: ${INC_PATH}")
+else ()
+    message(STATUS "env INC_PATH: ${INC_PATH}")
+endif()
+
+set(LIB_PATH $ENV{NPU_HOST_LIB})
+
+if (NOT DEFINED ENV{NPU_HOST_LIB})
+    set(LIB_PATH "/usr/local/Ascend/acllib/lib64/stub/")
+    message(STATUS "set default LIB_PATH: ${LIB_PATH}")
+else ()
+    message(STATUS "env LIB_PATH: ${LIB_PATH}")
+endif()
+
+# Header path
+include_directories(
+    ${INC_PATH}/acllib/include/
+    ../inc/
+)
+
+# add host lib path
+link_directories(
+    ${LIB_PATH}
+)
+
+add_executable(main
+        utils.cpp
+       # dvpp_process.cpp
+        model_process.cpp
+       # singleOp_process.cpp
+        sample_process.cpp
+        main.cpp)
+
+target_link_libraries(main
+        ascendcl acl_cblas acl_dvpp stdc++)
+
+install(TARGETS main DESTINATION ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})

msame/src/acl.json

@@ -0,0 +1 @@
+{}

msame/src/main.cpp

@@ -0,0 +1,181 @@
+//main.cpp
+/**
+* @file main.cpp
+*
+* Copyright (C) 2020. Huawei Technologies Co., Ltd. All rights reserved.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*/
+#include "sample_process.h"
+#include "utils.h"
+#include<getopt.h>
+using namespace std;
+ 
+
+bool f_isTXT = false;
+bool g_isDevice = false;
+int loop = 1;
+int32_t device = 0;
+bool is_profi = false;
+bool is_dump = false;
+bool is_debug = false;
+string input_Ftype = ".bin";
+string model_Ftype = ".om";
+string check = "";
+
+void InitAndCheckParams(int argc, char* argv[], map<char,string>& params, vector<string>& inputs)
+//void InitAndCheckParams(int argc, char* argv[], vector<string>& params, vector<string>& inputs)
+{
+    const char *optstring="m::i::o::f::hd::p::l::y::e::g::";
+    int c,deb,index;
+    struct option opts[]={{"model",required_argument,NULL,'m'},
+                          {"input",required_argument,NULL,'i'},
+                          {"output",required_argument,NULL,'o'},
+                          {"outfmt",required_argument,NULL,'f'},
+                          {"help",no_argument,NULL,1},
+                          {"dump",required_argument,NULL,'d'},
+                          {"profiler",required_argument,NULL,'p'},        
+                          {"loop",required_argument,NULL,'l'},
+                          {"dymBatch",required_argument,NULL,'y'},
+                          {"device",required_argument,NULL,'e'}, 
+                          {"debug",required_argument,NULL,'g'},                                                     
+                          {0,0,0,0}};
+    while((c=getopt_long(argc,argv,optstring,opts,&index))!=-1)
+    {
+        switch(c)
+        {
+        case 'm':
+			check = optarg;
+			if (check.find(model_Ftype) != string::npos){
+//				params.push_back(optarg);
+                params['m'] = optarg;
+				break;
+			}
+			else {
+				printf("input model file type is not .om , please check your model type!\n");
+				exit(0);
+			}
+        case 'i':
+			check = optarg;
+			if (check.find(input_Ftype) == string::npos){
+				printf("input data file type is not .bin , please check your input file type!\n");
+				exit(0);
+			}
+//            params.push_back(optarg);
+            params['i'] = optarg;
+            Utils::SplitString(params['i'], inputs, ',');
+            break;
+        case 'o':
+//            params.push_back(optarg);
+            params['o'] = optarg;
+            break;
+        case 'f':
+//            params.push_back(optarg);
+            params['f'] = optarg;
+            break;
+        case '?':
+            printf("unknown paramenter\n");
+            printf("Execute sample failed.\n");
+            Utils::printHelpLetter();
+            exit(0);
+        case 'd':
+//			params.push_back(optarg);
+            params['d'] = optarg;
+            break;
+        case 'p':
+//            params.push_back(optarg);
+            params['p'] = optarg;
+            break;
+        case 'l':
+            loop = Utils::str2num(optarg);
+	        cout << "loop:" << loop << endl;
+			if (loop > 100 || loop < 1)
+			{
+				printf("loop must in 1 to 100\n");
+				exit(0);	
+			} 
+            break;
+        case 'y':
+//            params.push_back(optarg);
+            params['y'] = optarg;
+            break;
+        case 'e':
+            device = Utils::str2num(optarg);
+            cout << "device:" << device << endl;
+			if (device > 255 || device < 0)
+			{
+				printf("device id must in 0 to 255\n");
+				exit(0);	
+			} 
+            break;
+        case 'g':
+            params['g'] = optarg;
+            break;
+        case 1:
+            Utils::printHelpLetter();
+            exit(0);
+        default:
+            printf("unknown paramenter\n");
+            printf("Execute sample failed.\n");
+            Utils::printHelpLetter();
+            exit(0);
+        }
+    }
+}
+
+int main(int argc, char* argv[])
+{
+    map<char,string>params;
+//    vector<string> params;
+    vector<string> inputs;
+    InitAndCheckParams(argc, argv, params, inputs);
+    printf("******************************\n");
+    printf("Test Start!\n");
+ 
+
+    if (params.empty()) {
+        printf("Invalid params.\n");
+        printf("Execute sample failed.\n");
+        Utils::printHelpLetter();
+        return FAILED;
+    }
+
+    if (params['d'].compare("true") == 0) {
+        is_dump = true;
+    }
+    if (params['p'].compare("true") == 0) {
+        is_profi = true;
+    } 
+    if (params['g'].compare("true") == 0) {
+        is_debug = true;
+    }
+    if (is_profi && is_dump){
+        ERROR_LOG("dump and profiler can not both be true");
+        return FAILED;
+    }
+
+    Utils::ProfilerJson(is_profi, params);
+    Utils::DumpJson(is_dump, params);
+    
+    SampleProcess processSample;
+   
+    Result ret = processSample.InitResource();
+    if (ret != SUCCESS) {
+        ERROR_LOG("Sample init resource failed.");
+        return FAILED;
+    }
+
+    ret = processSample.Process(params, inputs);
+    if (ret != SUCCESS) {
+        ERROR_LOG("Sample process failed.");
+        return FAILED;
+    }
+
+    INFO_LOG("Execute sample success.");
+    printf("Test Finish!\n");
+    printf("******************************\n");
+   
+    return SUCCESS;
+}

msame/src/model_process.cpp

@@ -0,0 +1,720 @@
+//Model_procccess.cpp
+ 
+/**
+* @file model_process.cpp
+*
+* Copyright (C) 2020. Huawei Technologies Co., Ltd. All rights reserved.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*/
+#include "model_process.h"
+#include "utils.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <cstddef>
+ 
+using namespace std;
+extern bool g_isDevice;
+extern bool f_isTXT;
+ 
+ModelProcess::ModelProcess() :modelId_(0), modelMemSize_(0), modelWeightSize_(0), modelMemPtr_(nullptr),
+modelWeightPtr_(nullptr), loadFlag_(false), modelDesc_(nullptr), input_(nullptr), output_(nullptr), numInputs_(0),
+numOutputs_(0)
+{
+}
+ 
+ModelProcess::~ModelProcess()
+{
+    Unload();
+    DestroyDesc();
+    DestroyInput();
+    DestroyOutput();
+}
+ 
+Result ModelProcess::LoadModelFromFileWithMem(const char *modelPath)
+{
+    if (loadFlag_) {
+        ERROR_LOG("has already loaded a model");
+        return FAILED;
+    }
+ 
+    aclError ret = aclmdlQuerySize(modelPath, &modelMemSize_, &modelWeightSize_);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("query model failed, model file is %s", modelPath);
+        return FAILED;
+    }
+ 
+    ret = aclrtMalloc(&modelMemPtr_, modelMemSize_, ACL_MEM_MALLOC_NORMAL_ONLY);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("malloc buffer for mem failed, require size is %zu", modelMemSize_);
+        return FAILED;
+    }
+ 
+    ret = aclrtMalloc(&modelWeightPtr_, modelWeightSize_, ACL_MEM_MALLOC_NORMAL_ONLY);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("malloc buffer for weight failed, require size is %zu", modelWeightSize_);
+        return FAILED;
+    }
+ 
+    ret = aclmdlLoadFromFileWithMem(modelPath, &modelId_, modelMemPtr_,
+        modelMemSize_, modelWeightPtr_, modelWeightSize_);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("load model from file failed, model file is %s", modelPath);
+        return FAILED;
+   }
+ 
+    loadFlag_ = true;
+    INFO_LOG("load model %s success", modelPath);
+    return SUCCESS;
+}
+ 
+Result ModelProcess::CreateDesc()
+{
+    modelDesc_ = aclmdlCreateDesc();
+    if (modelDesc_ == nullptr) {
+        ERROR_LOG("create model description failed");
+        return FAILED;
+    }
+ 
+    aclError ret = aclmdlGetDesc(modelDesc_, modelId_);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("get model description failed");
+        return FAILED;
+    }
+ 
+    INFO_LOG("create model description success");
+ 
+    return SUCCESS;
+}
+
+Result ModelProcess::PrintDesc()
+{   aclError ret;
+    DEBUG_LOG("start print model description");
+    size_t numInputs = aclmdlGetNumInputs(modelDesc_);
+    size_t numOutputs = aclmdlGetNumOutputs(modelDesc_);
+    DEBUG_LOG("NumInputs: %zu", numInputs);
+    DEBUG_LOG("NumOutputs: %zu", numOutputs);
+
+    aclmdlIODims dimsInput;
+    aclmdlIODims dimsOutput;
+    aclmdlIODims dimsCurrentOutput;
+    for (size_t i = 0; i < numInputs; i++){
+        DEBUG_LOG("the size of %zu input: %zu", i, aclmdlGetInputSizeByIndex(modelDesc_, i));
+        ret = aclmdlGetInputDims(modelDesc_, i, &dimsInput);
+        DEBUG_LOG("the dims of %zu input:", i);
+        for (size_t j = 0; j < dimsInput.dimCount; j++){
+             cout << dimsInput.dims[j] << " ";
+        }
+        cout << endl;
+        DEBUG_LOG("the name of %zu input: %s", i, aclmdlGetInputNameByIndex(modelDesc_, i));
+        DEBUG_LOG("the Format of %zu input: %u", i, aclmdlGetInputFormat(modelDesc_, i));
+        DEBUG_LOG("the DataType of %zu input: %u", i, aclmdlGetInputFormat(modelDesc_, i));
+    }
+    for (size_t i = 0; i < numOutputs; i++){
+        DEBUG_LOG("the size of %zu output: %zu", i, aclmdlGetOutputSizeByIndex(modelDesc_, i));
+        ret = aclmdlGetOutputDims(modelDesc_, i, &dimsOutput);
+        DEBUG_LOG("the dims of %zu output:", i);
+        for (size_t j = 0; j < dimsOutput.dimCount; j++){
+             cout <<dimsOutput.dims[j] << " ";
+        }
+        cout << endl;
+        ret = aclmdlGetCurOutputDims(modelDesc_, i, &dimsCurrentOutput);
+        DEBUG_LOG("the dims of %zu current output:", i);
+        for (size_t j = 0; j < dimsCurrentOutput.dimCount; j++){
+            cout <<dimsCurrentOutput.dims[j] << " ";
+        }
+        cout << endl;
+        DEBUG_LOG("the name of %zu output: %s", i, aclmdlGetOutputNameByIndex(modelDesc_, i));
+        DEBUG_LOG("the Format of %zu output: %u", i, aclmdlGetOutputFormat(modelDesc_, i));
+        DEBUG_LOG("the DataType of %zu output: %u", i, aclmdlGetOutputFormat(modelDesc_, i));
+    }
+    aclmdlBatch batch_info;
+    ret = aclmdlGetDynamicBatch(modelDesc_, &batch_info);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("get DynamicBatch failed");
+        (void)aclmdlDestroyDesc(modelDesc_);
+        modelDesc_ = nullptr;
+        return FAILED;
+    }
+    if (batch_info.batchCount != 0) {
+        DEBUG_LOG("DynamicBatch:");
+        for (size_t i = 0; i < batch_info.batchCount; i++){
+            cout << batch_info.batch[i] << " ";
+        }
+        cout << endl;
+    }
+    aclmdlHW dynamicHW;
+    ret = aclmdlGetDynamicHW(modelDesc_, -1, &dynamicHW);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("get DynamicHW failed");
+        (void)aclmdlDestroyDesc(modelDesc_);
+        modelDesc_ = nullptr;
+        return FAILED;
+    }
+    if (dynamicHW.hwCount != 0) {
+        DEBUG_LOG("DynamicHW:");
+        for (size_t i = 0; i < dynamicHW.hwCount; i++) {
+            cout << dynamicHW.hw[i][0] << dynamicHW.hw[i][1] << " ";
+        }
+        cout << endl;
+    }
+    DEBUG_LOG("end print model description");
+    return SUCCESS;
+}
+
+
+
+void ModelProcess::DestroyDesc()
+{
+    if (modelDesc_ != nullptr) {
+        (void)aclmdlDestroyDesc(modelDesc_);
+        modelDesc_ = nullptr;
+    }
+}
+ 
+Result ModelProcess::CreateInput(void *inputDataBuffer, size_t bufferSize)
+{
+    if (input_ == nullptr) {
+        input_ = aclmdlCreateDataset();
+        if (input_ == nullptr) {
+            ERROR_LOG("can't create dataset, create input failed");
+            return FAILED;
+        }
+    }
+   
+    aclDataBuffer* inputData = aclCreateDataBuffer(inputDataBuffer, bufferSize);
+    if (inputData == nullptr) {
+        ERROR_LOG("can't create data buffer, create input failed");
+        return FAILED;
+    }
+ 
+    aclError ret = aclmdlAddDatasetBuffer(input_, inputData);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("add input dataset buffer failed");
+        aclDestroyDataBuffer(inputData);
+        inputData = nullptr;
+        return FAILED;
+    }
+    return SUCCESS;
+}
+ 
+ Result ModelProcess::CreateZeroInput(){
+    if (input_ == nullptr) {
+        input_ = aclmdlCreateDataset();
+        if (input_ == nullptr) {
+            ERROR_LOG("can't create dataset, create input failed");
+            return FAILED;
+        }
+    }
+    numInputs_ = aclmdlGetNumInputs(modelDesc_);
+    for (size_t i = 0; i < numInputs_; i++){
+        size_t buffer_size_zero = aclmdlGetInputSizeByIndex(modelDesc_, i);
+        void *inBufferDev = nullptr;
+        if (!g_isDevice) {
+            void* binFileBufferData = nullptr;
+            aclError ret = aclrtMallocHost(&binFileBufferData, buffer_size_zero);
+            if (ret != ACL_ERROR_NONE) {
+                ERROR_LOG("malloc host buffer failed. size is %zu", buffer_size_zero);
+                return FAILED;
+            }
+            memset(binFileBufferData,0,buffer_size_zero);
+            ret = aclrtMalloc(&inBufferDev, buffer_size_zero, ACL_MEM_MALLOC_NORMAL_ONLY);
+            if (ret != ACL_ERROR_NONE) {
+                ERROR_LOG("malloc device buffer failed. size is %zu", buffer_size_zero);
+                return FAILED;
+            }
+            ret = aclrtMemcpy(inBufferDev, buffer_size_zero, binFileBufferData, buffer_size_zero, ACL_MEMCPY_HOST_TO_DEVICE);
+            if (ret != ACL_ERROR_NONE) {
+                ERROR_LOG("memcpy failed. device buffer size is %zu, input host buffer size is %zu", buffer_size_zero, buffer_size_zero);
+                aclrtFree(inBufferDev);
+                aclrtFreeHost(binFileBufferData);
+                return FAILED;
+            }
+        }else{
+            aclError ret = aclrtMalloc(&inBufferDev, buffer_size_zero, ACL_MEM_MALLOC_NORMAL_ONLY);
+            if (ret != ACL_ERROR_NONE) {
+                ERROR_LOG("malloc device buffer failed. size is %zu", buffer_size_zero);
+                return FAILED;
+            }
+            memset(inBufferDev,0,buffer_size_zero);
+        }
+
+
+        aclDataBuffer* inputData = aclCreateDataBuffer(inBufferDev, buffer_size_zero);
+        if (inputData == nullptr) {
+            ERROR_LOG("can't create data buffer, create input failed");
+            aclrtFree(inBufferDev);
+            inBufferDev = nullptr;
+            return FAILED;
+        }
+        aclError ret = aclmdlAddDatasetBuffer(input_, inputData);
+        if (ret != ACL_ERROR_NONE) {
+            ERROR_LOG("add input dataset buffer failed");
+            aclrtFree(inBufferDev);
+            inBufferDev = nullptr;
+            aclDestroyDataBuffer(inputData);
+            inputData = nullptr;
+            return FAILED;
+        }
+    }
+     return SUCCESS;
+}
+
+void ModelProcess::DestroyInput()
+{
+    if (input_ == nullptr) {
+        return;
+    }
+ 
+    for (size_t i = 0; i < aclmdlGetDatasetNumBuffers(input_); ++i) {
+        aclDataBuffer* dataBuffer = aclmdlGetDatasetBuffer(input_, i);
+        aclDestroyDataBuffer(dataBuffer);
+    }
+    aclmdlDestroyDataset(input_);
+    input_ = nullptr;
+}
+ 
+Result ModelProcess::CreateOutput()
+{
+    if (modelDesc_ == nullptr) {
+        ERROR_LOG("no model description, create ouput failed");
+        return FAILED;
+    }
+ 
+    output_ = aclmdlCreateDataset();
+    if (output_ == nullptr) {
+        ERROR_LOG("can't create dataset, create output failed");
+        return FAILED;
+    }
+ 
+    size_t outputSize = aclmdlGetNumOutputs(modelDesc_);
+    for (size_t i = 0; i < outputSize; ++i) {
+        size_t buffer_size = aclmdlGetOutputSizeByIndex(modelDesc_, i);
+ 
+        void *outputBuffer = nullptr;
+        aclError ret = aclrtMalloc(&outputBuffer, buffer_size, ACL_MEM_MALLOC_NORMAL_ONLY);
+        if (ret != ACL_ERROR_NONE) {
+            ERROR_LOG("can't malloc buffer, size is %zu, create output failed", buffer_size);
+            return FAILED;
+        }
+ 
+        aclDataBuffer* outputData = aclCreateDataBuffer(outputBuffer, buffer_size);
+        if (ret != ACL_ERROR_NONE) {
+            ERROR_LOG("can't create data buffer, create output failed");
+            aclrtFree(outputBuffer);
+            return FAILED;
+        }
+ 
+        ret = aclmdlAddDatasetBuffer(output_, outputData);
+        if (ret != ACL_ERROR_NONE) {
+            ERROR_LOG("can't add data buffer, create output failed");
+            aclrtFree(outputBuffer);
+            aclDestroyDataBuffer(outputData);
+            return FAILED;
+        }
+    }
+ 
+    INFO_LOG("create model output success");
+    return SUCCESS;
+}
+ /*
+void ModelProcess::DumpModelOutputResult()
+{
+    stringstream ss;
+    size_t outputNum = aclmdlGetDatasetNumBuffers(output_);
+	static int executeNum = 0;
+    for (size_t i = 0; i < outputNum; ++i) {
+        ss << "output" << ++executeNum << "_" << i << ".bin";
+        string outputFileName = ss.str();
+        FILE *outputFile = fopen(outputFileName.c_str(), "wb");
+        if (outputFile) {
+            aclDataBuffer* dataBuffer = aclmdlGetDatasetBuffer(output_, i);
+            void* data = aclGetDataBufferAddr(dataBuffer);
+            uint32_t len = aclGetDataBufferSize(dataBuffer);
+ 
+            void* outHostData = NULL;
+            aclError ret = ACL_ERROR_NONE;
+            if (!g_isDevice) {
+                ret = aclrtMallocHost(&outHostData, len);
+                if (ret != ACL_ERROR_NONE) {
+                    ERROR_LOG("aclrtMallocHost failed, ret[%d]", ret);
+                    return;
+                }
+ 
+                ret = aclrtMemcpy(outHostData, len, data, len, ACL_MEMCPY_DEVICE_TO_HOST);
+                if (ret != ACL_ERROR_NONE) {
+                    ERROR_LOG("aclrtMemcpy failed, ret[%d]", ret);
+                    (void)aclrtFreeHost(outHostData);
+                    return;
+                }
+ 
+                fwrite(outHostData, len, sizeof(char), outputFile);
+ 
+                ret = aclrtFreeHost(outHostData);
+                if (ret != ACL_ERROR_NONE) {
+                    ERROR_LOG("aclrtFreeHost failed, ret[%d]", ret);
+                    return;
+                }
+            } else {
+                fwrite(data, len, sizeof(char), outputFile);
+            }
+            fclose(outputFile);
+            outputFile = nullptr;
+        } else {
+            ERROR_LOG("create output file [%s] failed", outputFileName.c_str());
+            return;
+        }
+    }
+ 
+    INFO_LOG("dump data success");
+    return;
+}
+ */
+void ModelProcess::OutputModelResult(std::string& s,std::string& modelName,size_t index)
+{
+    const char* temp_s = s.c_str();
+    if (NULL == opendir(temp_s)){
+        mkdir(temp_s,0775);
+    }
+	std::string T = Utils::TimeLine();
+	//std::string t = s.c_str()+"/"+T.c_str();
+	//const char* time = t.c_str();
+	string times = s+"/"+T+"_"+to_string(index);
+	const char* time = times.c_str();
+	cout << time <<endl;
+	mkdir(time,0775);
+    if (NULL == opendir(time))
+    {
+        ERROR_LOG("current user does not have permission");
+        exit(0);
+    }
+ 
+    for (size_t i = 0; i < aclmdlGetDatasetNumBuffers(output_); ++i) {
+        aclDataBuffer* dataBuffer = aclmdlGetDatasetBuffer(output_, i);
+        void* data = aclGetDataBufferAddr(dataBuffer);
+        uint32_t len = aclGetDataBufferSize(dataBuffer);
+        aclDataType datatype = aclmdlGetOutputDataType(modelDesc_, i);
+        void *dims = nullptr;
+        aclmdlIODims *dim = nullptr;
+        aclError ret = ACL_ERROR_NONE;
+        if (!g_isDevice) { 
+            ret = aclrtMallocHost(&dims, sizeof(aclmdlIODims));
+            if (ret != ACL_ERROR_NONE) {
+                ERROR_LOG("aclrtMallocHost failed, ret[%d]", ret);
+                return;
+            }
+		}
+		else {
+			ret = aclrtMalloc(&dims, sizeof(aclmdlIODims), ACL_MEM_MALLOC_NORMAL_ONLY);
+			if (ret != ACL_ERROR_NONE) {
+                ERROR_LOG("malloc device buffer failed, ret[%d]", ret);
+                return;
+            }
+		}
+        dim = reinterpret_cast<aclmdlIODims*>(dims);
+        ret = aclmdlGetOutputDims(modelDesc_, i, dim);
+        if (ret != ACL_ERROR_NONE) {
+            ERROR_LOG("aclmdlGetOutputDims failed, ret[%d]", ret);
+            return;
+        }
+ 
+        void *outHostData = NULL;
+        ret = ACL_ERROR_NONE;
+        void *outData = NULL;
+        if (!g_isDevice) {
+            ret = aclrtMallocHost(&outHostData, len);
+            if (ret != ACL_ERROR_NONE) {
+                ERROR_LOG("aclrtMallocHost failed, ret[%d]", ret);
+                return;
+            }
+ 
+            ret = aclrtMemcpy(outHostData, len, data, len, ACL_MEMCPY_DEVICE_TO_HOST);
+            if (ret != ACL_ERROR_NONE) {
+                ERROR_LOG("aclrtMemcpy failed, ret[%d]", ret);
+                return;
+            }
+            switch (datatype)
+            {
+                case 0:
+                    outData = reinterpret_cast<float*>(outHostData);
+                    break;
+                case 1:
+                    outData = reinterpret_cast<aclFloat16*>(outHostData);
+                    break;
+                case 2:
+                    outData = reinterpret_cast<int8_t*>(outHostData);
+                    break;
+                case 3:
+                    outData = reinterpret_cast<int*>(outHostData);
+                    break;
+                case 4:
+                    outData = reinterpret_cast<uint8_t*>(outHostData);
+                    break;
+                case 6:
+                    outData = reinterpret_cast<int16_t*>(outHostData);
+                    break;
+                case 7:
+                    outData = reinterpret_cast<uint16_t*>(outHostData);
+                    break;
+                case 8:
+                    outData = reinterpret_cast<uint32_t*>(outHostData);
+                    break;
+                case 9:
+                    outData = reinterpret_cast<int64_t*>(outHostData);
+                    break;
+                case 10:
+                    outData = reinterpret_cast<uint64_t*>(outHostData);
+                    break;
+                case 11:
+                    outData = reinterpret_cast<double*>(outHostData);
+                    break;
+                case 12:
+                    outData = reinterpret_cast<bool*>(outHostData);
+                    break;
+                default :
+                    printf("undefined data type!\n");
+                    break;
+            }
+            
+        } else {
+            outData = reinterpret_cast<float*>(data);
+        }
+        if (f_isTXT)
+        {
+            ofstream outstr(times+"/"+modelName+"_output_"+to_string(i)+".txt", ios::out);
+            switch (datatype)
+            {
+                case 0:
+                    for (int i = 0; i < len/sizeof(float); i++)
+			{
+			    float out = *((float*)outData+i);
+			    outstr << out << " ";
+			    for (int j = 0; j < dim->dimCount; j++)
+			    {
+				if (i !=0 && i%dim->dims[j] == 0 && dim->dims[j] > 10)
+				    {outstr << "\n" ;}
+				}
+			    }
+                    break;
+                case 1:
+                    for (int i = 0; i < len/sizeof(aclFloat16); i++)
+					{
+						aclFloat16 out = *((aclFloat16*)outData+i);
+						outstr << out << " ";
+						for (int j = 0; j < dim->dimCount; j++)
+						{
+							if (i !=0 && i%dim->dims[j] == 0 && dim->dims[j] > 10)
+								{outstr << "\n" ;}
+						}
+					}
+                    break;
+                case 2:
+                    for (int i = 0; i < len/sizeof(int8_t); i++)
+					{
+						int8_t out = *((int8_t*)outData+i);
+						outstr << out << " ";
+						for (int j = 0; j < dim->dimCount; j++)
+						{
+							if (i !=0 && i%dim->dims[j] == 0 && dim->dims[j] > 10)
+								{outstr << "\n" ;}
+						}
+					}
+                    break;
+                case 3:
+                    for (int i = 0; i < len/sizeof(int); i++)
+					{
+						int out = *((int*)outData+i);
+						outstr << out << " ";
+						for (int j = 0; j < dim->dimCount; j++)
+						{
+							if (i !=0 && i%dim->dims[j] == 0 && dim->dims[j] > 10)
+								{outstr << "\n" ;}
+						}
+					}
+                    break;
+                case 4:
+                    for (int i = 0; i < len/sizeof(uint8_t); i++)
+					{
+						uint8_t out = *((uint8_t*)outData+i);
+						outstr << out << " ";
+						for (int j = 0; j < dim->dimCount; j++)
+						{
+							if (i !=0 && i%dim->dims[j] == 0 && dim->dims[j] > 10)
+								{outstr << "\n" ;}
+						}
+					}
+                    break;
+                case 6:
+                    for (int i = 0; i < len/sizeof(int16_t); i++)
+					{
+						int16_t out = *((int16_t*)outData+i);
+						outstr << out << " ";
+						for (int j = 0; j < dim->dimCount; j++)
+						{
+							if (i !=0 && i%dim->dims[j] == 0 && dim->dims[j] > 10)
+								{outstr << "\n" ;}
+						}
+					}
+                    break;
+                case 7:
+                    for (int i = 0; i < len/sizeof(uint16_t); i++)
+					{
+						uint16_t out = *((uint16_t*)outData+i);
+						outstr << out << " ";
+						for (int j = 0; j < dim->dimCount; j++)
+						{
+							if (i !=0 && i%dim->dims[j] == 0 && dim->dims[j] > 10)
+								{outstr << "\n" ;}
+						}
+					}
+                    break;
+                case 8:
+                    for (int i = 0; i < len/sizeof(uint32_t); i++)
+					{
+						uint32_t out = *((uint32_t*)outData+i);
+						outstr << out << " ";
+						for (int j = 0; j < dim->dimCount; j++)
+						{
+							if (i !=0 && i%dim->dims[j] == 0 && dim->dims[j] > 10)
+								{outstr << "\n" ;}
+						}
+					}
+                    break;
+                case 9:
+                    for (int i = 0; i < len/sizeof(int64_t); i++)
+					{
+						int64_t out = *((int64_t*)outData+i);
+						outstr << out << " ";
+						for (int j = 0; j < dim->dimCount; j++)
+						{
+							if (i !=0 && i%dim->dims[j] == 0 && dim->dims[j] > 10)
+								{outstr << "\n" ;}
+						}
+					}
+                    break;
+                case 10:
+                    for (int i = 0; i < len/sizeof(uint64_t); i++)
+					{
+						uint64_t out = *((uint64_t*)outData+i);
+						outstr << out << " ";
+						for (int j = 0; j < dim->dimCount; j++)
+						{
+							if (i !=0 && i%dim->dims[j] == 0 && dim->dims[j] > 10)
+								{outstr << "\n" ;}
+						}
+					}
+                    break;
+                case 11:
+                    for (int i = 0; i < len/sizeof(double); i++)
+					{
+						double out = *((double*)outData+i);
+						outstr << out << " ";
+						for (int j = 0; j < dim->dimCount; j++)
+						{
+							if (i !=0 && i%dim->dims[j] == 0 && dim->dims[j] > 10)
+								{outstr << "\n" ;}
+						}
+					}
+                    break;
+                case 12:
+                    for (int i = 0; i < len/sizeof(bool); i++)
+					{
+						int out = *((bool*)outData+i);
+						outstr << out << " ";
+						for (int j = 0; j < dim->dimCount; j++)
+						{
+							if (i !=0 && i%dim->dims[j] == 0 && dim->dims[j] > 10)
+								{outstr << "\n" ;}
+						}
+					}
+                    break;
+                default :
+                    printf("undefined data type!\n");
+                    break;
+            }
+            outstr.close();
+        }
+        else
+        {
+            ofstream outstr(times+"/"+modelName+"_output_"+to_string(i)+".bin", ios::out|ios::binary);
+     
+	        outstr.write((char*)outData, len);
+            outstr.close();
+        }
+ 
+
+        if (!g_isDevice) {
+            ret = aclrtFreeHost(outHostData);
+            if (ret != ACL_ERROR_NONE) {
+                ERROR_LOG("aclrtFreeHost failed, ret[%d]", ret);
+                return;
+            }
+        }
+    }
+ 
+    INFO_LOG("output data success");
+    return;
+}
+ 
+void ModelProcess::DestroyOutput()
+{
+    if (output_ == nullptr) {
+        return;
+   }
+ 
+    for (size_t i = 0; i < aclmdlGetDatasetNumBuffers(output_); ++i) {
+        aclDataBuffer* dataBuffer = aclmdlGetDatasetBuffer(output_, i);
+        void* data = aclGetDataBufferAddr(dataBuffer);
+        (void)aclrtFree(data);
+        (void)aclDestroyDataBuffer(dataBuffer);
+    }
+ 
+    (void)aclmdlDestroyDataset(output_);
+    output_ = nullptr;
+}
+ 
+Result ModelProcess::Execute()
+{
+    aclError ret = aclmdlExecute(modelId_, input_, output_);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("execute model failed, modelId is %u", modelId_);
+        return FAILED;
+    }
+ 
+    INFO_LOG("model execute success");
+    return SUCCESS;
+}
+ 
+void ModelProcess::Unload()
+{
+    if (!loadFlag_) {
+        WARN_LOG("no model had been loaded, unload failed");
+        return;
+    }
+ 
+    aclError ret = aclmdlUnload(modelId_);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("unload model failed, modelId is %u", modelId_);
+    }
+    if (modelDesc_ != nullptr) {
+        (void)aclmdlDestroyDesc(modelDesc_);
+        modelDesc_ = nullptr;
+    }
+ 
+    if (modelMemPtr_ != nullptr) {
+        aclrtFree(modelMemPtr_);
+        modelMemPtr_ = nullptr;
+        modelMemSize_ = 0;
+	}
+	if (modelWeightPtr_ != nullptr) {
+		aclrtFree(modelWeightPtr_);
+		modelWeightPtr_ = nullptr;
+		modelWeightSize_ = 0;
+	}
+	
+	loadFlag_ = false;
+	INFO_LOG("unload model success, model Id is %u", modelId_);
+}

msame/src/sample_process.cpp

@@ -0,0 +1,269 @@
+//Sample_process.cpp
+ 
+/**
+* @file sample_process.cpp
+*
+* Copyright (C) 2020. Huawei Technologies Co., Ltd. All rights reserved.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*/
+#include "sample_process.h"
+#include "model_process.h"
+#include "acl/acl.h"
+#include "utils.h"
+using namespace std;
+extern bool g_isDevice;
+extern bool f_isTXT;
+extern int loop;
+extern int32_t device;
+extern bool is_debug;
+extern bool is_profi;
+extern bool is_dump;
+
+ 
+SampleProcess::SampleProcess() :deviceId_(0), context_(nullptr), stream_(nullptr)
+{
+}
+ 
+SampleProcess::~SampleProcess()
+{
+    DestroyResource();
+}
+ 
+Result SampleProcess::InitResource()
+{
+    // ACL init
+    aclError ret;
+    const char *aclConfigPath = "acl.json";
+    if (is_profi == true){
+        ret = aclInit(aclConfigPath);
+    } else
+    {
+        ret = aclInit(nullptr);
+    }
+    if (ret != ACL_ERROR_NONE) {
+/*        if (is_debug || is_profi){
+              if (remove("acl.json")==0){
+                  INFO_LOG("delete acl.json success");
+              }
+              else{
+                  ERROR_LOG("delete acl.json failed");
+              }
+          }
+*/
+        ERROR_LOG("acl init failed");
+        return FAILED;
+   }
+    INFO_LOG("acl init success");
+ 
+    // open device
+    deviceId_ = device;
+    ret = aclrtSetDevice(deviceId_);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("acl open device %d failed", deviceId_);
+        return FAILED;
+    }
+    INFO_LOG("open device %d success", deviceId_);
+ 
+    // create context (set current)
+    ret = aclrtCreateContext(&context_, deviceId_);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("acl create context failed");
+        return FAILED;
+    }
+    INFO_LOG("create context success");
+ 
+    // create stream
+    ret = aclrtCreateStream(&stream_);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("acl create stream failed");
+        return FAILED;
+    }
+    INFO_LOG("create stream success");
+ 
+    // get run mode
+    aclrtRunMode runMode;
+    ret = aclrtGetRunMode(&runMode);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("acl get run mode failed");
+        return FAILED;
+    }
+    g_isDevice = (runMode == ACL_DEVICE);
+    INFO_LOG("get run mode success");
+
+/*    // dump init
+    if (is_dump == true){ 
+        ret = aclmdlInitDump();
+        if (ret != ACL_ERROR_NONE) {
+            ERROR_LOG("dump init failed");
+            return FAILED;
+        }
+        INFO_LOG("dump init success");
+    } 
+*/
+    return SUCCESS;
+}
+ 
+Result SampleProcess::Process(map<char,string>& params, vector<string>& input_files)
+{
+    // model init
+    ModelProcess processModel;
+    const char* omModelPath = params['m'].c_str();
+    std::string output_path = params['o'].c_str();
+    const char* outfmt = params['f'].c_str();
+    const char* fmt_TXT = "TXT";
+    f_isTXT = (strcmp(outfmt,fmt_TXT)==0);
+ 
+    std::string modelPath = params['m'].c_str();
+    std::string modelName = Utils::modelName(modelPath);
+ 
+    struct timeval begin;
+    struct timeval end;
+    double inference_time[loop];
+    Result ret = processModel.LoadModelFromFileWithMem(omModelPath);
+    if (ret != SUCCESS) {
+        ERROR_LOG("load model from file failed");
+        return FAILED;
+    }
+ 
+    ret = processModel.CreateDesc();
+    if (ret != SUCCESS) {
+        ERROR_LOG("create model description failed");
+        return FAILED;
+    }
+ /*   // dump init
+    if (is_dump){
+        const char *aclConfigPath = "acl.json";
+        ret = aclmdlSetDump(aclConfigPath);
+        if (ret != SUCCESS) {
+            ERROR_LOG("dump init failed");
+            return FAILED;
+        }
+        INFO_LOG("dump init success");
+    }
+*/
+    if (is_debug){
+        ret = processModel.PrintDesc();
+        if (ret != SUCCESS) {
+            ERROR_LOG("print model descrtption failed");
+            return FAILED;
+        }
+    }
+    ret = processModel.CreateOutput();
+    if (ret != SUCCESS) {
+        ERROR_LOG("create model output failed");
+        return FAILED;
+    }
+ 
+    if (input_files.empty() == 1) {
+        ret = processModel.CreateZeroInput();
+        if (ret != SUCCESS) {
+            ERROR_LOG("model create input failed");
+            return FAILED;
+        }
+    }
+    else {
+        vector < void* > picDevBuffer(input_files.size(), nullptr);
+        for (size_t index = 0; index < input_files.size(); ++index) {
+            INFO_LOG("start to process file:%s", input_files[index].c_str());
+            // model process
+            uint32_t devBufferSize;
+            picDevBuffer[index] = Utils::GetDeviceBufferOfFile(input_files[index], devBufferSize);
+            if (picDevBuffer[index] == nullptr) {
+                ERROR_LOG("get pic device buffer failed,index is %zu", index);
+                return FAILED;
+            }
+
+            ret = processModel.CreateInput(picDevBuffer[index], devBufferSize);
+            if (ret != SUCCESS) {
+                ERROR_LOG("model create input failed");
+                return FAILED;
+            }
+        }
+    }
+
+    // loop end
+    for (size_t t = 0; t < loop; ++t) {
+        gettimeofday(&begin, NULL);
+        ret = processModel.Execute();
+        gettimeofday(&end, NULL);
+        inference_time[t] = 1000 * (end.tv_sec - begin.tv_sec) + (end.tv_usec - begin.tv_usec) / 1000.000;
+        std::cout << "Inference time: " << inference_time[t] << "ms" << endl;
+        if (ret != SUCCESS) {
+            ERROR_LOG("model execute failed");
+//            for (size_t i = 0; i < input_files.size(); i++) {
+//                aclrtFree(picDevBuffer[i]);
+//            }
+            return FAILED;
+        }
+        processModel.OutputModelResult(output_path, modelName, t);
+    }
+    double infer_time_ave = Utils::InferenceTimeAverage(inference_time, loop);
+    printf("Inference average time: %f ms\n", infer_time_ave);
+    if (loop > 1) {
+        double infer_time_ave_without_first = Utils::InferenceTimeAverageWithoutFirst(inference_time, loop);
+        printf("Inference average time without first time: %f ms\n", infer_time_ave_without_first);
+    }
+    processModel.DestroyInput();
+
+    if (is_dump || is_profi){
+        if (remove("acl.json")==0){
+            INFO_LOG("delete acl.json success");
+        }
+        else{
+            ERROR_LOG("delete acl.json failed");
+        }
+    }
+
+    // release model input buffer
+//    for (size_t i = 0; i < input_files.size(); i++) {
+//        aclrtFree(picDevBuffer[i]);
+//    }
+
+    return SUCCESS;
+}
+ 
+void SampleProcess::DestroyResource()
+{
+    aclError ret;
+    if (stream_ != nullptr) {
+        ret = aclrtDestroyStream(stream_);
+        if (ret != ACL_ERROR_NONE) {
+            ERROR_LOG("destroy stream failed");
+        }
+        stream_ = nullptr;
+    }
+    INFO_LOG("end to destroy stream");
+ 
+    if (context_ != nullptr) {
+        ret = aclrtDestroyContext(context_);
+        if (ret != ACL_ERROR_NONE) {
+            ERROR_LOG("destroy context failed");
+        }
+        context_ = nullptr;
+    }
+    INFO_LOG("end to destroy context");
+ 
+    ret = aclrtResetDevice(deviceId_);
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("reset device failed");
+    }
+    INFO_LOG("end to reset device is %d", deviceId_);
+
+/*    if (is_dump){
+        ret = aclmdlFinalizeDump();
+        if (ret != ACL_ERROR_NONE) {
+            ERROR_LOG("finalize dump failed");
+        }
+    }
+    INFO_LOG("end to finalize dump");
+*/ 
+    ret = aclFinalize();
+    if (ret != ACL_ERROR_NONE) {
+        ERROR_LOG("finalize acl failed");
+    }
+    INFO_LOG("end to finalize acl");
+ 
+}

msame/src/utils.cpp

@@ -0,0 +1,302 @@
+//Util.cpp
+ 
+/**
+* @file utils.cpp
+*
+* Copyright (C) 2020. Huawei Technologies Co., Ltd. All rights reserved.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+*/
+#include "utils.h"
+#include <sys/time.h>
+#include "acl/acl.h"
+using namespace std;
+extern bool g_isDevice;
+extern bool f_isTXT;
+extern int32_t device;
+extern bool is_profi;
+extern bool is_dump;
+
+void* Utils::ReadBinFile(std::string fileName, uint32_t &fileSize)
+{
+    std::ifstream binFile(fileName, std::ifstream::binary);
+    if (binFile.is_open() == false) {
+        ERROR_LOG("open file %s failed", fileName.c_str());
+        return nullptr;
+    }
+ 
+    binFile.seekg(0, binFile.end);
+    uint32_t binFileBufferLen = binFile.tellg();
+    if (binFileBufferLen == 0) {
+        ERROR_LOG("binfile is empty, filename is %s", fileName.c_str());
+        binFile.close();
+        return nullptr;
+    }
+ 
+    binFile.seekg(0, binFile.beg);
+ 
+    void* binFileBufferData = nullptr;
+    aclError ret = ACL_ERROR_NONE;
+    if (!g_isDevice) {
+        ret = aclrtMallocHost(&binFileBufferData, binFileBufferLen);
+        if (binFileBufferData == nullptr) {
+            ERROR_LOG("malloc binFileBufferData failed");
+            binFile.close();
+            return nullptr;
+        }
+    } else {
+        ret = aclrtMalloc(&binFileBufferData, binFileBufferLen, ACL_MEM_MALLOC_NORMAL_ONLY);
+        if (ret != ACL_ERROR_NONE) {
+            ERROR_LOG("malloc device buffer failed. size is %u", binFileBufferLen);
+            binFile.close();
+            return nullptr;
+        }
+    }
+		
+    binFile.read(static_cast<char *>(binFileBufferData), binFileBufferLen);
+    binFile.close();
+    fileSize = binFileBufferLen;
+    return binFileBufferData;
+}
+ 
+void* Utils::GetDeviceBufferOfFile(std::string fileName, uint32_t &fileSize)
+{
+    uint32_t inputHostBuffSize = 0;
+    void* inputHostBuff = Utils::ReadBinFile(fileName, inputHostBuffSize);
+    if (inputHostBuff == nullptr) {
+        return nullptr;
+    }
+    if (!g_isDevice) {
+        void *inBufferDev = nullptr;
+        uint32_t inBufferSize = inputHostBuffSize;
+        aclError ret = aclrtMalloc(&inBufferDev, inBufferSize, ACL_MEM_MALLOC_NORMAL_ONLY);
+        if (ret != ACL_ERROR_NONE) {
+            ERROR_LOG("malloc device buffer failed. size is %u", inBufferSize);
+            aclrtFreeHost(inputHostBuff);
+            return nullptr;
+        }
+ 
+        ret = aclrtMemcpy(inBufferDev, inBufferSize, inputHostBuff, inputHostBuffSize, ACL_MEMCPY_HOST_TO_DEVICE);
+        if (ret != ACL_ERROR_NONE) {
+            ERROR_LOG("memcpy failed. device buffer size is %u, input host buffer size is %u",
+                inBufferSize, inputHostBuffSize);
+            aclrtFree(inBufferDev);
+            aclrtFreeHost(inputHostBuff);
+            return nullptr;
+        }
+        aclrtFreeHost(inputHostBuff);
+        fileSize = inBufferSize;
+        return inBufferDev;
+    } else {
+        fileSize = inputHostBuffSize;
+        return inputHostBuff;
+    }
+}
+ 
+void Utils::SplitString(std::string& s, std::vector<std::string>& v, char c)
+{
+    std::string::size_type pos1, pos2;
+    pos2 = s.find(c);
+    pos1 = 0;
+    while(std::string::npos != pos2)
+    {
+        std::string s1 = s.substr(pos1, pos2-pos1);
+        size_t n = s1.find_last_not_of(" \r\n\t");
+        if (n != string::npos) {
+            s1.erase(n + 1, s.size() - n);
+        }
+        n = s1.find_first_not_of(" \r\n\t");
+        if (n != string::npos) {
+            s1.erase(0, n);
+        }
+        v.push_back(s1);
+        pos1 = pos2 + 1;
+        pos2 = s.find(c, pos1);
+    }
+    if(pos1 != s.length())
+    {
+        std::string s1 = s.substr(pos1);
+        size_t n = s1.find_last_not_of(" \r\n\t");
+        if (n != string::npos) {
+            s1.erase(n + 1, s.size() - n);
+        }
+        n = s1.find_first_not_of(" \r\n\t");
+        if (n != string::npos) {
+            s1.erase(0, n);
+        }
+        v.push_back(s1);
+    }
+}
+ 
+int Utils::str2num(char *str)
+{
+    int n = 0;
+    int flag = 0;
+    while(*str >= '0' && *str <= '9')
+    {
+        n = n*10 + (*str - '0');
+        str++;
+    }
+    if(flag == 1)
+    {
+        n = -n;
+    }
+    return n;
+}
+
+std::string Utils::modelName(string& s)
+{
+	string::size_type position1,position2;
+	position1 = s.find_last_of("/");
+	if (position1 == s.npos)
+	{
+		position1 = 0;
+	}
+	position2 = s.find_last_of(".");
+	std::string modelName = s.substr(position1,position2-position1);
+	return modelName;
+}
+
+std::string  Utils::TimeLine()
+{
+	time_t currentTime = time(NULL);
+	char chCurrentTime[64];
+	strftime(chCurrentTime, sizeof(chCurrentTime), "%Y%m%d_%H%M%S", localtime(&currentTime)); 
+	std::string stCurrentTime = chCurrentTime;
+	return stCurrentTime;
+}
+
+void Utils::printCurrentTime()
+{
+    char szBuf[256] = {0};
+    struct timeval    tv;
+    struct timezone   tz;
+    struct tm         *p;
+
+    gettimeofday(&tv, &tz);
+    p = localtime(&tv.tv_sec);
+    printf("%02d-%02d-%02d %02d:%02d:%02d.%06ld\n", p->tm_year + 1900, p->tm_mon + 1, p->tm_mday, p->tm_hour, p->tm_min, p->tm_sec, tv.tv_usec);
+
+}
+void Utils::printHelpLetter()
+{
+    cout<< endl;
+    cout<< "Usage:" << endl;
+	cout<< "generate offline model inference output file example:" << endl;
+	cout<< "./msame --model /home/HwHiAiUser/ljj/colorization.om --input /home/HwHiAiUser/ljj/colorization_input.bin --output /home/HwHiAiUser/ljj/AMEXEC/out/output1 --outfmt TXT --loop 2" << endl << endl;
+
+	cout<< "arguments explain:" << endl;
+	cout<< "  --model       Model file path" << endl;
+	cout<< "  --input	Input data path(only accept binary data file) 	If there are several file, please seprate by ','" << endl;
+	cout<< "  --output	Output path(User needs to have permission to create directories)" <<  endl;
+	cout<< "  --outfmt	Output file format (TXT or BIN)" << endl;
+	cout<< "  --loop 	loop time(must in 1 to 100)" << endl;
+	cout<< "  --dump	Enable dump (true or false)(Do not support now)" << endl;
+	cout<< "  --profiler	Enable profiler (true or false)" << endl;
+        cout<< "  --device      Designated the device ID(must in 0 to 255)" << endl;
+        cout<< "  --debug       Debug switch,print model information (true or false)" << endl;
+	cout<< "  --dymBatch 	dynamic batch (Do not support now)" << endl << endl << endl;
+	  
+	  
+//	cout<< "NOTECE: " << endl;
+//	cout<< "	The order of parameter must follow in --model --input --output --outfmt --loop " << endl;
+}
+
+
+double Utils::printDiffTime(time_t begin, time_t end)
+{
+    double diffT = difftime(begin, end);
+    printf("The inference time is: %f millisecond\n", 1000*diffT);
+    return diffT * 1000;
+}
+
+double Utils::InferenceTimeAverage(double *x, int len)
+{
+    double sum = 0;
+    for (int i = 0; i < len; i++)
+        sum += x[i];
+    return sum / len;
+}
+
+double Utils::InferenceTimeAverageWithoutFirst(double *x, int len)
+{
+    double sum = 0;
+    for (int i = 0; i < len; i++)
+		if (i !=0){
+		    sum += x[i];
+		}
+        
+    return sum / (len - 1);
+}
+
+void Utils::ProfilerJson(bool isprof, map<char,string>& params)
+{
+    if (isprof){
+        std::string out_path = params['o'].c_str();
+        std::string out_profiler_path = out_path + "/profiler";
+        ofstream outstr("acl.json", ios::out);
+        outstr << "{\n\"profiler\": {\n    \"switch\": \"on\",\n    \"device_id\": \"";
+        outstr << device << "\",\n    \"result_path\": \"" << out_profiler_path << "\",\n    ";
+        outstr << "\"ai_core_metrics\": \"\"}\n}";
+        //outstr << "\"ai_core_metrics\": \"aicorePipelineStall\"}\n}";
+        //outstr <<"}]n}";
+        outstr.close();
+                
+        //mkdir profiler output dir
+        const char* temp_s = out_path.c_str();
+        if (NULL == opendir(temp_s)){
+            mkdir(temp_s,0775);
+        }
+        const char* temp_s1 = out_profiler_path.c_str();
+        if (NULL == opendir(temp_s1)){
+            mkdir(temp_s1,0775);
+        }
+        /*{  
+        "profiler": {
+            "switch": "on",
+            "device_id": "all",
+            "result_path": "/home/HwHiAiUser",
+            "ai_core_metrics": "aicorePipelineStall"
+            }
+        }
+        */
+    }
+}
+
+void Utils::DumpJson(bool isdump, map<char,string>& params)
+{
+    if (is_dump){
+        std::string modelPath = params['m'].c_str();
+        std::string modelName = Utils::modelName(modelPath);
+        std::string out_path = params['o'].c_str();
+        std::string out_dump_path = out_path + "/dump";
+        ofstream outstr("acl.json", ios::out);
+        outstr << "{\n\"dump\": {\n    \"dump_path\"： \"";
+        outstr << out_dump_path << "\",\n    ";
+        outstr << "\"dump_mode\": \"output\",\n    \"dump_list\": [{\n    ";
+        outstr << "        \"model_name\": \"" << modelName << "\",\n        }]\n";
+        outstr << "    }\n}";
+        outstr.close();
+        
+        //mkdir dump output dir
+        const char* temp_s = out_path.c_str();
+        if (NULL == opendir(temp_s)){
+            mkdir(temp_s,0775);
+        }
+        const char* temp_s1 = out_dump_path.c_str();
+        if (NULL == opendir(temp_s1)){
+            mkdir(temp_s1,0775);
+        }
+        // {
+        //  "dump": {
+        // 	"dump_path": "output_path",
+        //     "dump_mode": "output",    
+        // 	"dump_list": [{
+        // 			"model_name": "model_name",
+        // 		}]
+        //     }
+        // }
+    }
+}