From 842326f7c6905122aaba808f182bcacb647e4f81 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E7=9F=B3=E6=99=93=E4=BC=9F?= <39303645+Shixiaowei02@users.noreply.github.com> Date: Wed, 23 Oct 2019 19:04:32 +0800 Subject: [PATCH] Add kernel version table and update framework.proto, test=develop (#2243) * update framework.proto * add compatibility check, test=develop * remove head files, test=develop --- lite/core/framework.proto | 35 +++++++++++-- lite/core/type_system.h | 26 ++++++++- lite/core/version.h.in | 15 ++++++ lite/kernels/cuda/CMakeLists.txt | 1 - lite/kernels/cuda/leaky_relu_compute.cu | 1 + lite/model_parser/CMakeLists.txt | 12 ++++- lite/model_parser/compatibility.cc | 70 +++++++++++++++++++++++++ lite/model_parser/compatibility.h | 55 +++++++++++++++++++ lite/model_parser/compatibility_test.cc | 45 ++++++++++++++++ lite/model_parser/pb/op_desc.h | 2 - lite/tools/cmake_tools/ast.py | 8 ++- lite/utils/all.h | 1 + 12 files changed, 262 insertions(+), 9 deletions(-) create mode 100644 lite/model_parser/compatibility.cc create mode 100644 lite/model_parser/compatibility.h create mode 100644 lite/model_parser/compatibility_test.cc diff --git a/lite/core/framework.proto b/lite/core/framework.proto index 6c60a041a1..5adf2a18b9 100644 --- a/lite/core/framework.proto +++ b/lite/core/framework.proto @@ -13,7 +13,7 @@ See the License for the specific language governing permissions and limitations under the License. */ syntax = "proto2"; -// option optimize_for = LITE_RUNTIME; +option optimize_for = LITE_RUNTIME; package paddle.framework.proto; // Any incompatible changes to ProgramDesc and its dependencies should @@ -166,6 +166,9 @@ message VarDesc { required string name = 1; required VarType type = 2; optional bool persistable = 3 [ default = false ]; + // True if the variable is an input data and + // have to check the feed data shape and dtype + optional bool need_check_feed = 4 [ default = false ]; } message BlockDesc { @@ -176,13 +179,39 @@ message BlockDesc { optional int32 forward_block_idx = 5 [ default = -1 ]; } +// CompatibleInfo is used to determine if a feature is compatible and +// provides the information. +message CompatibleInfo { + enum Type { + COMPATIBLE = 0; + DEFINITELY_NOT = 1; + POSSIBLE = 2; + BUG_FIX = 3; + PRECISION_CHANGE = 4; + } + required string version = 1; + required Type type = 2; +} + +// In some cases, Paddle Fluid may perform operator definition iterations, +// and the operator uses OpCompatibleMap for compatibility testing. +message OpCompatibleMap { + message OpCompatiblePair { + required string op_name = 1; + required CompatibleInfo compatible_info = 2; + } + repeated OpCompatiblePair pair = 1; + optional string default_required_version = 2; +} + // Please refer to // https://github.com/PaddlePaddle/Paddle/blob/develop/doc/design/program.md // for more details. // TODO(panyx0718): A model can have multiple programs. Need a // way to distinguish them. Maybe ID or name? message ProgramDesc { + reserved 2; // For backward compatibility. repeated BlockDesc blocks = 1; - - optional Version version = 2; + optional Version version = 4; + optional OpCompatibleMap op_compatible_map = 3; } diff --git a/lite/core/type_system.h b/lite/core/type_system.h index 722cdca0eb..aeddf965c3 100644 --- a/lite/core/type_system.h +++ b/lite/core/type_system.h @@ -27,6 +27,7 @@ #include #include #include "lite/core/tensor.h" +#include "lite/core/version.h" #include "lite/utils/all.h" namespace paddle { @@ -280,7 +281,7 @@ struct ParamTypeRecorder { */ class ParamTypeRegistry { public: - enum class IO : int { kInput = 0, kOutput }; + enum class IO : int { kInvalid = 0, kInput, kOutput }; template types_; + std::map versions_; }; } // namespace lite diff --git a/lite/core/version.h.in b/lite/core/version.h.in index 13f6a3b8e3..3082adc5ab 100644 --- a/lite/core/version.h.in +++ b/lite/core/version.h.in @@ -16,10 +16,15 @@ #include #include "lite/utils/replace_stl/stream.h" +#include "lite/utils/string.h" namespace paddle { namespace lite { +static constexpr int MAJOR_COEFF = 1000000; +static constexpr int MINOR_COEFF = 1000; +static constexpr int PATCH_COEFF = 1; + static std::string paddlelite_commit() { return "@PADDLE_LITE_COMMIT@"; } @@ -45,5 +50,15 @@ static std::string version() { return ss.str(); } +static int64_t int_version(const std::string& version) { + const std::vector vec = Split(version, "."); + if (vec.size() == 3) { + return std::stoi(vec[0]) * MAJOR_COEFF + + std::stoi(vec[1]) * MINOR_COEFF + + std::stoi(vec[2]) * PATCH_COEFF; + } + return -1; +} + } // namespace lite } // namespace paddle diff --git a/lite/kernels/cuda/CMakeLists.txt b/lite/kernels/cuda/CMakeLists.txt index a8b699f59b..8aa084c243 100644 --- a/lite/kernels/cuda/CMakeLists.txt +++ b/lite/kernels/cuda/CMakeLists.txt @@ -33,7 +33,6 @@ nv_test(transpose_compute_cuda_test SRCS transpose_compute_test.cc DEPS transpos nv_test(concat_compute_cuda_test SRCS concat_compute_test.cc DEPS concat_compute_cuda) nv_test(elementwise_add_compute_cuda_test SRCS elementwise_add_compute_test.cc DEPS elementwise_add_compute_cuda) nv_test(softmax_compute_cuda_test SRCS softmax_compute_test.cc DEPS softmax_compute_cuda) -nv_test(pool_compute_cuda_test SRCS pool_compute_test.cc DEPS pool_compute_cuda) #nv_test(layout_cuda_test SRCS layout_compute_test.cc DEPS layout_compute_cuda) nv_test(mul_compute_cuda_test SRCS mul_compute_test.cc DEPS mul_compute_cuda) nv_test(dropout_compute_cuda_test SRCS dropout_compute_test.cc DEPS dropout_compute_cuda ) diff --git a/lite/kernels/cuda/leaky_relu_compute.cu b/lite/kernels/cuda/leaky_relu_compute.cu index 5d09c038e8..0dc281c493 100644 --- a/lite/kernels/cuda/leaky_relu_compute.cu +++ b/lite/kernels/cuda/leaky_relu_compute.cu @@ -66,4 +66,5 @@ REGISTER_LITE_KERNEL(leaky_relu, def) .BindInput("X", {LiteType::GetTensorTy(TARGET(kCUDA))}) .BindOutput("Out", {LiteType::GetTensorTy(TARGET(kCUDA))}) + .SetVersion("1.5.0") .Finalize(); diff --git a/lite/model_parser/CMakeLists.txt b/lite/model_parser/CMakeLists.txt index d9871ff177..34d524c5c1 100644 --- a/lite/model_parser/CMakeLists.txt +++ b/lite/model_parser/CMakeLists.txt @@ -29,5 +29,15 @@ lite_cc_library(model_parser SRCS model_parser.cc DEPS compatible_pb memory CUDA_DEPS target_wrapper_cuda) - lite_cc_test(test_compatible_pb SRCS compatible_pb_test.cc DEPS compatible_pb) + +if (LITE_WITH_CUDA AND NOT LITE_ON_TINY_PUBLISH) + lite_cc_library(compatibility SRCS compatibility.cc DEPS + kernel + variable + compatible_pb + type_system + ${cpp_wrapper} + ${naive_wrapper}) + lite_cc_test(test_compatibility SRCS compatibility_test.cc DEPS compatibility leaky_relu_compute_cuda) +endif() diff --git a/lite/model_parser/compatibility.cc b/lite/model_parser/compatibility.cc new file mode 100644 index 0000000000..d2fcfaa49c --- /dev/null +++ b/lite/model_parser/compatibility.cc @@ -0,0 +1,70 @@ +// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. +// +// 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 "lite/model_parser/compatibility.h" + +#include "lite/core/type_system.h" +#include "lite/model_parser/naive_buffer/block_desc.h" +#include "lite/model_parser/naive_buffer/op_desc.h" +#include "lite/model_parser/naive_buffer/program_desc.h" +#include "lite/model_parser/naive_buffer/var_desc.h" +#ifndef LITE_ON_TINY_PUBLISH +#include "lite/model_parser/cpp/block_desc.h" +#include "lite/model_parser/cpp/op_desc.h" +#include "lite/model_parser/cpp/program_desc.h" +#include "lite/model_parser/cpp/var_desc.h" +#endif + +namespace paddle { +namespace lite { + +template +bool CompatibleChecker::CheckKernelVersion(const std::string& type, + const lite_api::Place& place) { + int64_t impl_version = ParamTypeRegistry::Global().GetVersion(type, place); + const int64_t prog_version = program_.Version(); + VLOG(3) << "Kernel implement version: " << type << ", " << impl_version; + VLOG(3) << "Kernel program version: " << type << ", " << prog_version; + if (impl_version == -1) { + impl_version = mini_version_; + } + return prog_version <= impl_version; +} + +template +std::unordered_set CompatibleChecker::OpsType(T* program) { + LOG(WARNING) << "OpsType() is not yet implemented."; + return std::unordered_set(); +} + +#ifndef LITE_ON_TINY_PUBLISH +template <> +std::unordered_set CompatibleChecker::OpsType( + cpp::ProgramDesc* program) { + std::unordered_set ops_type; + for (size_t i = 0; i < program->BlocksSize(); ++i) { + auto* block = program->GetBlock(i); + for (size_t j = 0; j < block->OpsSize(); ++j) { + auto* op = block->GetOp(j); + ops_type.insert(op->Type()); + } + } + return ops_type; +} + +template class CompatibleChecker; +#endif // LITE_ON_TINY_PUBLISH + +} // namespace lite +} // namespace paddle diff --git a/lite/model_parser/compatibility.h b/lite/model_parser/compatibility.h new file mode 100644 index 0000000000..132f5c941a --- /dev/null +++ b/lite/model_parser/compatibility.h @@ -0,0 +1,55 @@ +// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. +// +// 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. + +#pragma once + +#include +#include +#include "lite/api/paddle_place.h" +#include "lite/model_parser/desc_apis.h" + +namespace paddle { +namespace lite { + +template +class CompatibleChecker { + public: + explicit CompatibleChecker(const T& program, + const int64_t mini_version = 1005000) + : program_(program), mini_version_(mini_version) {} + + bool operator()(const lite_api::Place& place) { + bool status = true; + const std::unordered_set& ops_type = OpsType(&program_); + if (ops_type.empty()) { + VLOG(3) << "You are checking the compatibility of an empty program."; + } + for (const auto& type : ops_type) { + bool ret = CheckKernelVersion(type, place); + VLOG(3) << "Kernel version is supported: " << type << ", " << ret; + status = status && ret; + } + return status; + } + + private: + std::unordered_set OpsType(T* program); + bool CheckKernelVersion(const std::string& type, + const lite_api::Place& place); + T program_; + int64_t mini_version_; +}; + +} // namespace lite +} // namespace paddle diff --git a/lite/model_parser/compatibility_test.cc b/lite/model_parser/compatibility_test.cc new file mode 100644 index 0000000000..b3cb38f1c9 --- /dev/null +++ b/lite/model_parser/compatibility_test.cc @@ -0,0 +1,45 @@ +// Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved. +// +// 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 "lite/model_parser/compatibility.h" +#include +#include "lite/api/paddle_lite_factory_helper.h" + +#include "lite/model_parser/compatible_pb.h" +#include "lite/model_parser/cpp/block_desc.h" +#include "lite/model_parser/cpp/op_desc.h" +#include "lite/model_parser/cpp/program_desc.h" +#include "lite/model_parser/cpp/var_desc.h" + +USE_LITE_KERNEL(leaky_relu, kCUDA, kFloat, kNCHW, def); + +namespace paddle { +namespace lite { + +static constexpr int64_t version = 1005000; + +TEST(CompatibleChecker, CppProgramDesc) { + cpp::ProgramDesc program; + program.SetVersion(version); + auto* block = program.AddBlock(); + auto* op = block->AddOp(); + op->SetType("leaky_relu"); + + CompatibleChecker checker(program); + lite_api::Place place{TARGET(kCUDA), PRECISION(kFloat), DATALAYOUT(kNCHW)}; + CHECK(checker(place)); +} + +} // namespace lite +} // namespace paddle diff --git a/lite/model_parser/pb/op_desc.h b/lite/model_parser/pb/op_desc.h index 5275875c09..a9c2f863a0 100644 --- a/lite/model_parser/pb/op_desc.h +++ b/lite/model_parser/pb/op_desc.h @@ -143,8 +143,6 @@ class OpDesc : public OpDescAPI { template T GetAttr(const std::string &name) const; - std::string DebugString() const { return desc_->DebugString(); } - private: std::vector GetArguments( const google::protobuf::RepeatedPtrField diff --git a/lite/tools/cmake_tools/ast.py b/lite/tools/cmake_tools/ast.py index 6058f677ef..86b8a58b06 100644 --- a/lite/tools/cmake_tools/ast.py +++ b/lite/tools/cmake_tools/ast.py @@ -292,7 +292,7 @@ class RegisterLiteKernelParser(SyntaxParser): self.eat_point() self.eat_spaces() self.eat_word() - assert self.token in ('BindInput', 'BindOutput', 'Finalize') + assert self.token in ('BindInput', 'BindOutput', 'SetVersion', 'Finalize') io = IO() if self.token == 'BindInput': @@ -301,6 +301,12 @@ class RegisterLiteKernelParser(SyntaxParser): elif self.token == 'BindOutput': eat_io(False, io) k.outputs.append(io) + elif self.token == 'SetVersion': + self.eat_left_parentheses() + self.eat_str() + self.version = self.token + self.eat_right_parentheses() + self.eat_spaces() else: self.eat_left_parentheses() self.eat_right_parentheses() diff --git a/lite/utils/all.h b/lite/utils/all.h index b8cffb9fd1..a0d323aa24 100644 --- a/lite/utils/all.h +++ b/lite/utils/all.h @@ -21,6 +21,7 @@ #include "lite/utils/hash.h" #include "lite/utils/io.h" #include "lite/utils/macros.h" +#include "lite/utils/string.h" #include "lite/utils/varient.h" #ifdef LITE_ON_TINY_PUBLISH -- GitLab