m53297601
/
mindspore
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

clean_code_8

Browse Source
pull/8824/head
yefeng 4 years ago
parent d773b54fe7
commit bd7ecf9a1a
228 changed files with 727 additions and 726 deletions
Show Stats Download Patch File Download Diff File

22
mindspore/lite/src/common/file_utils.cc
Unescape View File

@ -28,15 +28,15 @@ char *ReadFile(const char *file, size_t *size) {
return nullptr;
}
MS_ASSERT(size != nullptr);
std::string realPath = RealPath(file);
std::ifstream ifs(realPath);
std::string real_path = RealPath(file);
std::ifstream ifs(real_path);
if (!ifs.good()) {
MS_LOG(ERROR) << "file: " << realPath << " is not exist";
MS_LOG(ERROR) << "file: " << real_path << " is not exist";
return nullptr;
}
if (!ifs.is_open()) {
MS_LOG(ERROR) << "file: " << realPath << " open failed";
MS_LOG(ERROR) << "file: " << real_path << " open failed";
return nullptr;
}
@ -44,7 +44,7 @@ char *ReadFile(const char *file, size_t *size) {
*size = ifs.tellg();
std::unique_ptr<char[]> buf(new (std::nothrow) char[*size]);
if (buf == nullptr) {
MS_LOG(ERROR) << "malloc buf failed, file: " << realPath;
MS_LOG(ERROR) << "malloc buf failed, file: " << real_path;
ifs.close();
return nullptr;
}
@ -65,21 +65,21 @@ std::string RealPath(const char *path) {
MS_LOG(ERROR) << "path is too long";
return "";
}
auto resolvedPath = std::make_unique<char[]>(PATH_MAX);
if (resolvedPath == nullptr) {
MS_LOG(ERROR) << "new resolvedPath failed";
auto resolved_path = std::make_unique<char[]>(PATH_MAX);
if (resolved_path == nullptr) {
MS_LOG(ERROR) << "new resolved_path failed";
return "";
}
#ifdef _WIN32
char *real_path = _fullpath(resolvedPath.get(), path, 1024);
char *real_path = _fullpath(resolved_path.get(), path, 1024);
#else
char *real_path = realpath(path, resolvedPath.get());
char *real_path = realpath(path, resolved_path.get());
#endif
if (real_path == nullptr || strlen(real_path) == 0) {
MS_LOG(ERROR) << "file path is not valid : " << path;
return "";
}
std::string res = resolvedPath.get();
std::string res = resolved_path.get();
return res;
}
} // namespace lite

4
mindspore/lite/src/common/log_adapter.cc
Unescape View File

@ -26,7 +26,7 @@
namespace mindspore {
constexpr const char *ANDROID_LOG_TAG = "MS_LITE";
int EnvToInt(const char *env) {
int StrToInt(const char *env) {
if (env == nullptr) return 2;
if (strcmp(env, "0") == 0) return 0;
if (strcmp(env, "1") == 0) return 1;
@ -37,7 +37,7 @@ int EnvToInt(const char *env) {
bool IsPrint(int level) {
static const char *env = std::getenv("GLOG_v");
static int ms_level = EnvToInt(env);
static int ms_level = StrToInt(env);
if (level < 0) {
level = 2;
}

12
mindspore/lite/src/common/utils.cc
Unescape View File

@ -48,11 +48,11 @@ uint64_t GetTimeUs() {
return 0;
}
// USECS_IN_SEC *NSECS_IN_USEC;
auto retval = static_cast<uint64_t>((ts.tv_sec * USEC) + (ts.tv_nsec / MSEC));
return retval;
auto ret_val = static_cast<uint64_t>((ts.tv_sec * USEC) + (ts.tv_nsec / MSEC));
return ret_val;
}
std::string Remove(const std::string &from, const std::string &subStr, Mode mode) {
std::string RemoveSubStr(const std::string &from, const std::string &subStr, RemoveSubStrMode mode) {
std::string result = from;
if (mode == PREFIX) {
if (from.substr(0, subStr.length()) == subStr) {
@ -90,8 +90,8 @@ std::vector<std::string> StrSplit(const std::string &str, const std::string &pat
}
std::vector<std::string> Tokenize(const std::string &src, const std::string &delimiters,
const Option<size_t> &maxTokenNum) {
if (maxTokenNum.IsSome() && maxTokenNum.Get() == 0) {
const Option<size_t> &max_token_num) {
if (max_token_num.IsSome() && max_token_num.Get() == 0) {
return {};
}
@ -104,7 +104,7 @@ std::vector<std::string> Tokenize(const std::string &src, const std::string &del
break;
}
size_t delimiter = src.find_first_of(delimiters, nonDelimiter);
if (delimiter == std::string::npos || (maxTokenNum.IsSome() && tokens.size() == maxTokenNum.Get() - 1)) {
if (delimiter == std::string::npos || (max_token_num.IsSome() && tokens.size() == max_token_num.Get() - 1)) {
tokens.push_back(src.substr(nonDelimiter));
break;
}

4
mindspore/lite/src/common/utils.h
Unescape View File

@ -148,10 +148,10 @@ std::vector<std::string> StrSplit(const std::string &str, const std::string &pat
std::vector<std::string> Tokenize(const std::string &src, const std::string &delimiters,
const Option<size_t> &maxTokenNum = Option<size_t>(None()));
enum Mode { PREFIX, SUFFIX, ANY };
enum RemoveSubStrMode { PREFIX, SUFFIX, ANY };
// remove redundant charactor
std::string Remove(const std::string &from, const std::string &subStr, Mode mode = ANY);
std::string RemoveSubStr(const std::string &from, const std::string &subStr, RemoveSubStrMode mode = ANY);
template <typename T>
inline Option<T> GenericParseValue(const std::string &value) {

2
mindspore/lite/src/kernel_registry.cc
Unescape View File

@ -95,7 +95,7 @@ void KernelRegistry::RegKernel(const KERNEL_ARCH arch, const TypeId data_type, c
creator_arrays_[index] = creator;
}
bool KernelRegistry::Merge(const std::unordered_map<KernelKey, KernelCreator> &newCreators) { return false; }
bool KernelRegistry::Merge(const std::unordered_map<KernelKey, KernelCreator> &new_creators) { return false; }
const kernel::KernelCreator *KernelRegistry::GetCreatorArrays() { return creator_arrays_; }

12
mindspore/lite/src/lite_kernel.cc
Unescape View File

@ -26,7 +26,9 @@ using mindspore::lite::RET_OK;
void *LiteKernel::workspace_ = nullptr;
void LiteKernel::AllocWorkspace(size_t size) {
if (size == 0) return;
if (size == 0) {
return;
}
workspace_ = malloc(size);
if (workspace_ == nullptr) {
MS_LOG(ERROR) << "fail to alloc " << size;
@ -74,10 +76,10 @@ int LiteKernel::FreeWorkTensor() const {
int LiteKernel::PreProcess() {
if (!InferShapeDone()) {
(const_cast<mindspore::lite::PrimitiveC *>(primitive_))->SetInferFlag(true);
(const_cast<mindspore::lite::PrimitiveC *>(primitive_))->set_infer_flag(true);
auto ret = (const_cast<mindspore::lite::PrimitiveC *>(primitive_))->InferShape(in_tensors_, out_tensors_);
if (ret != 0) {
(const_cast<mindspore::lite::PrimitiveC *>(primitive_))->SetInferFlag(false);
(const_cast<mindspore::lite::PrimitiveC *>(primitive_))->set_infer_flag(false);
MS_LOG(ERROR) << "InferShape fail!";
return ret;
}
@ -279,8 +281,8 @@ int LiteKernelUtil::TopologicalSortKernels(std::vector<kernel::LiteKernel *> *ke
void LiteKernelUtil::InitIOKernels(std::vector<kernel::LiteKernel *> &kernels) {
for (auto *kernel : kernels) {
// clean io kernels
kernel->SetInKernel({});
kernel->SetOutKernel({});
kernel->set_in_kernel({});
kernel->set_out_kernel({});
// find io kernels
for (auto *search_kernel : kernels) {
if (search_kernel == kernel) {

16
mindspore/lite/src/lite_kernel.h
Unescape View File

@ -109,9 +109,9 @@ class LiteKernel {
virtual bool IsEval() const { return !this->train_mode_; }
virtual void SetTrainable(bool trainable = true) { this->trainable_ = trainable; }
virtual void set_trainable(bool trainable = true) { this->trainable_ = trainable; }
virtual bool IsTrainable() const { return this->trainable_; }
virtual bool is_trainable() const { return this->trainable_; }
void set_name(const std::string &name) { this->name_ = name; }
@ -146,9 +146,9 @@ class LiteKernel {
}
}
void SetInKernel(const std::vector<LiteKernel *> &kernel) { this->in_kernels_ = kernel; }
void set_in_kernel(const std::vector<LiteKernel *> &kernel) { this->in_kernels_ = kernel; }
void SetOutKernel(const std::vector<LiteKernel *> &kernel) { this->out_kernels_ = kernel; }
void set_out_kernel(const std::vector<LiteKernel *> &kernel) { this->out_kernels_ = kernel; }
const std::vector<LiteKernel *> &in_kernels() const { return this->in_kernels_; }
@ -165,18 +165,18 @@ class LiteKernel {
void set_desc(const KernelKey kernel_key) { desc_ = kernel_key; }
const mindspore::lite::PrimitiveC *GetPrimitive() const { return primitive_; }
void SetWorkspaceSize(size_t value) { workspace_size_ = value; }
size_t GetWorkspaceSize() { return workspace_size_; }
void set_workspace_size(size_t value) { workspace_size_ = value; }
size_t workspace_size() { return workspace_size_; }
static void AllocWorkspace(size_t size);
static void FreeWorkspace();
void *GetWorkspace() { return workspace_; }
void *workspace() { return workspace_; }
SubGraphType subgraph_type() const { return this->subgraph_type_; }
virtual std::string ToString() const;
protected:
bool InferShapeDone() { return !(primitive_ != nullptr && !primitive_->GetInferFlag()); }
bool InferShapeDone() { return !(primitive_ != nullptr && !primitive_->infer_flag()); }
KernelKey desc_{};
std::string name_;

2
mindspore/lite/src/lite_session.cc
Unescape View File

@ -74,7 +74,7 @@ void LiteSession::ConvertTensorsQuantParam(const schema::Tensor *src_tensor, lit
for (size_t j = 0; j < quant_clusters->size(); j++) {
clusters.push_back(quant_clusters->Get(j));
}
dst_tensor->SetQuantClusters(clusters);
dst_tensor->set_quant_clusters(clusters);
}
}

4
mindspore/lite/src/model_common.h
Unescape View File

@ -32,7 +32,7 @@ namespace mindspore::lite {
int ConvertSubGraph(const schema::SubGraph &sub_graph, Model *model);
template <typename T = schema::MetaGraph, typename U = schema::CNode>
bool ConvertNodes(const T &meta_graph, Model *model, int schema_version = 0) {
bool ConvertNodes(const T &meta_graph, Model *model, int schema_version = SCHEMA_CUR) {
MS_ASSERT(model != nullptr);
for (size_t i = 0; i < meta_graph.nodes()->size(); ++i) {
auto *node = new (std::nothrow) Model::Node();
@ -53,7 +53,7 @@ bool ConvertNodes(const T &meta_graph, Model *model, int schema_version = 0) {
delete node;
return false;
}
node->primitive_->SetQuantType(static_cast<schema::QuantType>(c_node->quantType()));
node->primitive_->set_quant_type(static_cast<schema::QuantType>(c_node->quantType()));
node->name_ = c_node->name()->c_str();
node->node_type_ = static_cast<NodeType>(c_node->nodeType());
auto count = c_node->inputIndex()->size();

2
mindspore/lite/src/ops/adam.cc
Unescape View File

@ -88,7 +88,7 @@ int Adam::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Tenso
auto *out = outputs.front();
MS_ASSERT(out != nullptr);
out->set_data_type(inputs[0]->data_type());
out->SetFormat(inputs[0]->GetFormat());
out->set_format(inputs[0]->format());
out->set_shape({1});
}

4
mindspore/lite/src/ops/addn.cc
Unescape View File

@ -83,9 +83,9 @@ int AddN::InferShape(std::vector<Tensor *> inputs, std::vector<Tensor *> outputs
MS_LOG(ERROR) << "input size" << inputs.size() << " is error!";
return RET_INPUT_TENSOR_ERROR;
}
output->SetFormat(input->GetFormat());
output->set_format(input->format());
output->set_data_type(input->data_type());
if (!GetInferFlag()) {
if (!infer_flag()) {
return RET_OK;
}
output->set_shape(input->shape());

2
mindspore/lite/src/ops/apply_momentum.cc
Unescape View File

@ -93,7 +93,7 @@ int ApplyMomentum::InferShape(std::vector<lite::Tensor *> inputs, std::vector<li
auto *out = outputs.front();
MS_ASSERT(out != nullptr);
out->set_data_type(inputs[0]->data_type());
out->SetFormat(inputs[0]->GetFormat());
out->set_format(inputs[0]->format());
out->set_shape({1});
}

4
mindspore/lite/src/ops/argmax.cc
Unescape View File

@ -71,9 +71,9 @@ int ArgMax::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outp
return RET_ERROR;
}
output->SetFormat(input->GetFormat());
output->set_format(input->format());
output->set_data_type(input->data_type());
if (!GetInferFlag()) {
if (!infer_flag()) {
return RET_OK;
}
std::vector<int> output_shape(input->shape());

4
mindspore/lite/src/ops/argmin.cc
Unescape View File

@ -69,9 +69,9 @@ int ArgMin::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite::Te
if (inputs_.size() != kSingleNum || outputs_.size() != kSingleNum) {
MS_LOG(ERROR) << "tensor number is error.";
}
output->SetFormat(input->GetFormat());
output->set_format(input->format());
output->set_data_type(input->data_type());
if (!GetInferFlag()) {
if (!infer_flag()) {
return RET_OK;
}
auto input_shape_size = input->shape().size();

8
mindspore/lite/src/ops/arithmetic.cc
Unescape View File

@ -41,10 +41,10 @@ int Arithmetic::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite
auto input_shape0 = input0->shape();
auto input_shape1 = input1->shape();
auto format = input0->GetFormat();
output->SetFormat(format);
auto format = input0->format();
output->set_format(format);
output->set_data_type(input0->data_type());
if (!GetInferFlag()) {
if (!infer_flag()) {
return RET_OK;
}
if (input_shape0.size() > 10 || input_shape1.size() > 10) {
@ -69,7 +69,7 @@ int Arithmetic::InferShape(std::vector<lite::Tensor *> inputs_, std::vector<lite
}
in_shape1_[i] = input_shape1[i];
}
format = input0->GetFormat();
format = input0->format();
} else if (input_shape0.size() > input_shape1.size()) {
ndim_ = input_shape0.size();
auto fill_dim_num = input_shape0.size() - input_shape1.size();

4
mindspore/lite/src/ops/arithmetic_self.cc
Unescape View File

@ -30,9 +30,9 @@ int ArithmeticSelf::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor
MS_ASSERT(input != nullptr);
auto output = outputs_.front();
MS_ASSERT(output != nullptr);
output->SetFormat(input->GetFormat());
output->set_format(input->format());
output->set_data_type(input->data_type());
if (!GetInferFlag()) {
if (!infer_flag()) {
return RET_OK;
}
output->set_shape(input->shape());

2
mindspore/lite/src/ops/assign.cc
Unescape View File

@ -80,7 +80,7 @@ int Assign::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Ten
auto *out = outputs.front();
MS_ASSERT(out != nullptr);
out->set_data_type(inputs[0]->data_type());
out->SetFormat(inputs[0]->GetFormat());
out->set_format(inputs[0]->format());
out->set_shape({1});
}
return RET_OK;

2
mindspore/lite/src/ops/assign_add.cc
Unescape View File

@ -86,7 +86,7 @@ int AssignAdd::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> o
output_shape[i] = x_shape[i];
}
out->set_shape(output_shape);
out->SetFormat(x->GetFormat());
out->set_format(x->format());
out->set_data_type(x->data_type());
return RET_OK;
}

4
mindspore/lite/src/ops/audio_spectrogram.cc
Unescape View File

@ -75,8 +75,8 @@ int AudioSpectrogram::InferShape(std::vector<Tensor *> inputs_, std::vector<Tens
auto output = outputs_.front();
MS_ASSERT(output != nullptr);
output->set_data_type(input->data_type());
output->SetFormat(input->GetFormat());
if (!GetInferFlag()) {
output->set_format(input->format());
if (!infer_flag()) {
return RET_OK;
}
auto input_shape = input->shape();

6
mindspore/lite/src/ops/batch_to_space.cc
Unescape View File

@ -91,13 +91,13 @@ int BatchToSpace::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lit
}
auto input = inputs.at(0);
if (input->GetFormat() != schema::Format::Format_NHWC) {
if (input->format() != schema::Format::Format_NHWC) {
MS_LOG(ERROR) << "batch_to_space only support NHWC now!";
return RET_FORMAT_ERR;
}
outputs[0]->SetFormat(input->GetFormat());
outputs[0]->set_format(input->format());
outputs[0]->set_data_type(input->data_type());
if (!GetInferFlag()) {
if (!infer_flag()) {
return RET_OK;
}
auto input_shape = input->shape();

2
mindspore/lite/src/ops/bias_grad.cc
Unescape View File

@ -111,7 +111,7 @@ int BiasGrad::InferShape(std::vector<Tensor *> inputs, std::vector<Tensor *> out
}
out->set_shape(inshape);
out->set_data_type(in0->data_type());
out->SetFormat(in0->GetFormat());
out->set_format(in0->format());
return RET_OK;
}

2
mindspore/lite/src/ops/binary_cross_entropy.cc
Unescape View File

@ -102,7 +102,7 @@ Registry BinaryCrossEntropyRegistry(schema::PrimitiveType_BinaryCrossEntropy, Bi
int BinaryCrossEntropy::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outputs_) {
Tensor *x = inputs_[0];
Tensor *out = outputs_[0];
out->SetFormat(x->GetFormat());
out->set_format(x->format());
out->set_data_type(x->data_type());
int reduction = GetReduction();
if (reduction == 1 || reduction == 2) {

2
mindspore/lite/src/ops/binary_cross_entropy_grad.cc
Unescape View File

@ -109,7 +109,7 @@ Registry BinaryCrossEntropyGradRegistry(schema::PrimitiveType_BinaryCrossEntropy
int BinaryCrossEntropyGrad::InferShape(std::vector<Tensor *> inputs_, std::vector<Tensor *> outputs_) {
Tensor *x = inputs_[0];
Tensor *out = outputs_[0];
out->SetFormat(x->GetFormat());
out->set_format(x->format());
out->set_data_type(x->data_type());
std::vector<int> x_shape = x->shape();
std::vector<int> output_shape(x_shape.size());

6
mindspore/lite/src/ops/bn_grad.cc
Unescape View File

@ -106,9 +106,9 @@ int BNGrad::InferShape(std::vector<lite::Tensor *> inputs, std::vector<lite::Ten
outputs[0]->set_data_type(in->data_type());
outputs[1]->set_data_type(scale->data_type());
outputs[2]->set_data_type(scale->data_type());
outputs[0]->SetFormat(in->GetFormat());
outputs[1]->SetFormat(scale->GetFormat());
outputs[2]->SetFormat(scale->GetFormat());
outputs[0]->set_format(in->format());
outputs[1]->set_format(scale->format());
outputs[2]->set_format(scale->format());
return RET_OK;
}
} // namespace lite

4
mindspore/lite/src/ops/broadcast_to.cc
Unescape View File

@ -77,9 +77,9 @@ int BroadcastTo::InferShape(std::vector<Tensor *> inputs, std::vector<Tensor *>
}
auto input = inputs.at(0);
outputs[0]->SetFormat(input->GetFormat());
outputs[0]->set_format(input->format());
outputs[0]->set_data_type(input->data_type());
if (!GetInferFlag()) {
if (!infer_flag()) {
return RET_OK;
}
std::vector<int32_t> dst_shape(GetDstShape());

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save