* Copyright 2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "coder/coder.h"
#include <iomanip>
#include <string>
#include <vector>
#include <map>
#include "schema/inner/model_generated.h"
#include "tools/common/flag_parser.h"
#include "coder/session.h"
#include "coder/context.h"
#include "utils/dir_utils.h"
#include "securec/include/securec.h"
#include "src/common/file_utils.h"
#include "src/common/utils.h"
#include "coder/config.h"
#include "coder/generator/component/component.h"
namespace mindspore::lite::micro {
class CoderFlags : public virtual FlagParser {
public:
CoderFlags() {
AddFlag(&CoderFlags::model_path_, "modelPath", "Input model path", "");
AddFlag(&CoderFlags::code_path_, "codePath", "Input code path", ".");
AddFlag(&CoderFlags::target_, "target", "generated code target, x86| ARM32M| ARM32A| ARM64", "x86");
AddFlag(&CoderFlags::code_mode_, "codeMode", "generated code mode, Inference | Train", "Inference");
AddFlag(&CoderFlags::support_parallel_, "supportParallel", "whether support parallel launch, true | false", false);
AddFlag(&CoderFlags::debug_mode_, "debugMode", "dump the tensors data for debugging, true | false", false);
}
~CoderFlags() override = default;
std::string model_path_;
bool support_parallel_{false};
std::string code_path_;
std::string code_mode_;
bool debug_mode_{false};
std::string target_;
};
int Coder::Run(const std::string &model_path) {
session_ = CreateCoderSession();
if (session_ == nullptr) {
MS_LOG(ERROR) << "new session failed while running!";
return RET_ERROR;
}
STATUS status = session_->Init(model_path);
if (status != RET_OK) {
MS_LOG(ERROR) << "Init session failed!";
return RET_ERROR;
}
status = session_->Build();
if (status != RET_OK) {
MS_LOG(ERROR) << "Compile graph failed!";
return status;
}
status = session_->Run();
if (status != RET_OK) {
MS_LOG(ERROR) << "Generate Code Files error!" << status;
return status;
}
status = session_->GenerateCode();
if (status != RET_OK) {
MS_LOG(ERROR) << "Generate Code Files error!" << status;
}
return status;
}
int Configurator::ParseProjDir(std::string model_path) {
proj_dir_ = model_path;
size_t found = proj_dir_.find_last_of("/\\");
if (found != std::string::npos) {
proj_dir_ = proj_dir_.substr(found + 1);
}
found = proj_dir_.find(".ms");
if (found != std::string::npos) {
proj_dir_ = proj_dir_.substr(0, found);
} else {
MS_LOG(ERROR) << "model file's name must be end with \".ms\".";
return RET_ERROR;
}
if (proj_dir_.size() == 0) {
proj_dir_ = "net";
MS_LOG(WARNING) << "parse model's name failed, use \"net\" instead.";
}
return RET_OK;
}
int Coder::Init(const CoderFlags &flags) const {
static const std::map<std::string, Target> kTargetMap = {
{"x86", kX86}, {"ARM32M", kARM32M}, {"ARM32A", kARM32A}, {"ARM64", kARM64}, {"All", kAllTargets}};
static const std::map<std::string, CodeMode> kCodeModeMap = {{"Inference", Inference}, {"Train", Train}};
Configurator *config = Configurator::GetInstance();
std::vector<std::function<bool()>> parsers;
parsers.emplace_back([&flags, config]() -> bool {
if (!FileExists(flags.model_path_)) {
MS_LOG(ERROR) << "model_path \"" << flags.model_path_ << "\" is not valid";
return false;
}
if (config->ParseProjDir(flags.model_path_) != RET_OK) {
return false;
}
return true;
});
parsers.emplace_back([&flags, config]() -> bool {
auto target_item = kTargetMap.find(flags.target_);
MS_CHECK_TRUE_RET_BOOL(target_item != kTargetMap.end(), "unsupported target: " + flags.target_);
config->set_target(target_item->second);
return true;
});
parsers.emplace_back([&flags, config]() -> bool {
auto code_item = kCodeModeMap.find(flags.code_mode_);
MS_CHECK_TRUE_RET_BOOL(code_item != kCodeModeMap.end(), "unsupported code mode: " + flags.code_mode_);
config->set_code_mode(code_item->second);
return true;
});
parsers.emplace_back([&flags, config]() -> bool {
if (flags.support_parallel_ && config->target() == kARM32M) {
MS_LOG(ERROR) << "arm32M cannot support parallel.";
return false;
}
config->set_support_parallel(flags.support_parallel_);
return true;
});
parsers.emplace_back([&flags, config]() -> bool {
config->set_debug_mode(flags.debug_mode_);
return true;
});
parsers.emplace_back([&flags, config]() -> bool {
const std::string slash = std::string(kSlash);
if (!flags.code_path_.empty() && !DirExists(flags.code_path_)) {
MS_LOG(ERROR) << "code_gen code path " << flags.code_path_ << " is not valid";
return false;
}
config->set_code_path(flags.code_path_);
if (flags.code_path_.empty()) {
std::string path = ".." + slash + config->proj_dir();
config->set_code_path(path);
} else {
if (flags.code_path_.substr(flags.code_path_.size() - 1, 1) != slash) {
std::string path = flags.code_path_ + slash + config->proj_dir();
config->set_code_path(path);
} else {
std::string path = flags.code_path_ + config->proj_dir();
config->set_code_path(path);
}
}
return InitProjDirs(flags.code_path_, config->proj_dir()) != RET_ERROR;
});
if (!std::all_of(parsers.begin(), parsers.end(), [](auto &parser) -> bool { return parser(); })) {
if (!flags.help) {
std::cerr << flags.Usage() << std::endl;
return 0;
}
return RET_ERROR;
}
auto print_parameter = [](auto name, auto value) {
MS_LOG(INFO) << std::setw(20) << std::left << name << "= " << value;
};
print_parameter("modelPath", flags.model_path_);
print_parameter("projectName", config->proj_dir());
print_parameter("target", config->target());
print_parameter("codePath", config->code_path());
print_parameter("codeMode", config->code_mode());
print_parameter("debugMode", config->debug_mode());
return RET_OK;
}
int RunCoder(int argc, const char **argv) {
CoderFlags flags;
Option<std::string> err = flags.ParseFlags(argc, argv, false, false);
if (err.IsSome()) {
std::cerr << err.Get() << std::endl;
std::cerr << flags.Usage() << std::endl;
return RET_ERROR;
}
if (flags.help) {
std::cerr << flags.Usage() << std::endl;
return RET_OK;
}
Coder code_gen;
STATUS status = code_gen.Init(flags);
if (status != RET_OK) {
MS_LOG(ERROR) << "Coder init Error";
return status;
}
status = code_gen.Run(flags.model_path_);
if (status != RET_OK) {
MS_LOG(ERROR) << "Coder Run Error.";
return status;
}
MS_LOG(INFO) << "end of Coder";
return RET_OK;
}
}