From 6ba87e89d20124979fd9c3581f122464c7805f96 Mon Sep 17 00:00:00 2001
From: JZZ-NOTE <jzz2446071400@163.com>
Date: Fri, 27 Aug 2021 12:33:08 +0000
Subject: [PATCH 01/11] support nnadapter and ascend310

---
 cmake/external/lite.cmake                     | 32 ++++++++++
 paddle/fluid/inference/analysis/argument.h    | 16 +++++
 .../inference/analysis/ir_pass_manager.cc     | 20 +++++++
 .../analysis/ir_passes/lite_subgraph_pass.cc  | 26 +++++++++
 paddle/fluid/inference/api/analysis_config.cc | 58 ++++++++++++++++++-
 .../fluid/inference/api/analysis_predictor.cc | 41 +++++++++++++
 .../inference/api/paddle_analysis_config.h    | 33 +++++++++++
 paddle/fluid/inference/lite/CMakeLists.txt    |  6 +-
 paddle/fluid/inference/lite/engine.cc         | 20 +++++++
 paddle/fluid/inference/lite/engine.h          |  9 +++
 10 files changed, 257 insertions(+), 4 deletions(-)

diff --git a/cmake/external/lite.cmake b/cmake/external/lite.cmake
index e213068377b140..c77aa643ce9d9a 100644
--- a/cmake/external/lite.cmake
+++ b/cmake/external/lite.cmake
@@ -35,6 +35,14 @@ if (LITE_WITH_XPU)
   ENDIF()
 endif()
 
+if (LITE_WITH_NNADAPTER)
+  add_definitions(-DLITE_SUBGRAPH_WITH_NNADAPTER) 
+  if (NNADAPTER_WITH_NPU)
+    add_definitions(-DLITE_SUBGRAPH_WITH_NPU)
+    set(NPU_SDK_ROOT "/usr/local/Ascend/ascend-toolkit/latest" CACHE STRING "default NPU SDK ROOT")
+  endif()
+endif()
+
 if (NOT LITE_SOURCE_DIR OR NOT LITE_BINARY_DIR)
   include(ExternalProject)
   set(LITE_PROJECT extern_lite)
@@ -67,6 +75,9 @@ if (NOT LITE_SOURCE_DIR OR NOT LITE_BINARY_DIR)
                            -DLITE_WITH_XPU=${LITE_WITH_XPU}
                            -DXPU_SDK_URL=${XPU_BASE_URL}
                            -DXPU_SDK_ENV=${XPU_SDK_ENV}
+                           -DLITE_WITH_NNADAPTER=${LITE_WITH_NNADAPTER}
+                           -DNNADAPTER_WITH_HUAWEI_ASCEND_NPU=${NNADAPTER_WITH_NPU}
+                           -DNNADAPTER_HUAWEI_ASCEND_NPU_SDK_ROOT=${NPU_SDK_ROOT}
                            -DLITE_WITH_CODE_META_INFO=OFF
                            -DLITE_WITH_ARM=ON)
     ExternalProject_Add(
@@ -77,6 +88,7 @@ if (NOT LITE_SOURCE_DIR OR NOT LITE_BINARY_DIR)
       PREFIX              ${LITE_SOURCES_DIR}
       PATCH_COMMAND       mkdir -p ${LITE_SOURCES_DIR}/src/extern_lite-build/lite/gen_code && touch ${LITE_SOURCES_DIR}/src/extern_lite-build/lite/gen_code/__generated_code__.cc && sed -i "/aarch64-linux-gnu-gcc/d" ${LITE_SOURCES_DIR}/src/extern_lite/cmake/cross_compiling/armlinux.cmake && sed -i "/aarch64-linux-gnu-g++/d" ${LITE_SOURCES_DIR}/src/extern_lite/cmake/cross_compiling/armlinux.cmake
       UPDATE_COMMAND      ""
+      BUILD_ALWAYS         1
       BUILD_COMMAND       ${LITE_BUILD_COMMAND}
       INSTALL_COMMAND     ""
       CMAKE_ARGS          -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
@@ -110,6 +122,9 @@ if (NOT LITE_SOURCE_DIR OR NOT LITE_BINARY_DIR)
                            -DLITE_WITH_XPU=${LITE_WITH_XPU}
                            -DXPU_SDK_URL=${XPU_BASE_URL}
                            -DXPU_SDK_ENV=${XPU_SDK_ENV}
+                           -DLITE_WITH_NNADAPTER=${LITE_WITH_NNADAPTER}
+                           -DNNADAPTER_WITH_HUAWEI_ASCEND_NPU=${NNADAPTER_WITH_NPU}
+                           -DNNADAPTER_HUAWEI_ASCEND_NPU_SDK_ROOT=${NPU_SDK_ROOT}
                            -DLITE_WITH_CODE_META_INFO=OFF
                            -DLITE_WITH_ARM=OFF)
 
@@ -146,6 +161,11 @@ endif()
 if (WITH_ARM)
   if(LITE_WITH_XPU)
     set(LITE_OUTPUT_BIN_DIR inference_lite_lib.armlinux.armv8.xpu)
+  elseif(LITE_WITH_NNADAPTER)
+    message("Enable LITE_WITH_NNADAPTER")
+    if (NNADAPTER_WITH_NPU)
+      set(LITE_OUTPUT_BIN_DIR inference_lite_lib.armlinux.armv8.nnadapter)
+    endif()
   else()
     set(LITE_OUTPUT_BIN_DIR inference_lite_lib.armlinux.armv8)
   endif()
@@ -174,5 +194,17 @@ endfunction()
 external_lite_libs(lite_full_static ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libpaddle_full_api_shared.so)
 set(LITE_SHARED_LIB ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libpaddle_full_api_shared.so)
 
+if (LITE_WITH_NNADAPTER)
+  if (NNADAPTER_WITH_NPU)
+    external_lite_libs(lite_nnadapter ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter.so ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter_driver_huawei_ascend_npu.so)
+    set(LITE_DEPS lite_full_static lite_nnadapter)
+    set(LITE_SHARED_LIB ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libpaddle_full_api_shared.so 
+      ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter.so
+      ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter_driver_huawei_ascend_npu.so)
+  endif()
+else()
+  set(LITE_DEPS lite_full_static)
+endif()
+
 add_definitions(-DPADDLE_WITH_LITE)
 add_definitions(-DLITE_WITH_LOG)
diff --git a/paddle/fluid/inference/analysis/argument.h b/paddle/fluid/inference/analysis/argument.h
index 255c6ca75dfd74..b0ad10367b38bb 100644
--- a/paddle/fluid/inference/analysis/argument.h
+++ b/paddle/fluid/inference/analysis/argument.h
@@ -233,6 +233,22 @@ struct Argument {
   DECL_ARGUMENT_FIELD(xpu_precision, XpuPrecision, std::string);
   DECL_ARGUMENT_FIELD(xpu_adaptive_seqlen, XpuAdaptiveSeqlen, bool);
 
+  DECL_ARGUMENT_FIELD(use_nnadapter, UseNNAdapter, bool);
+  DECL_ARGUMENT_FIELD(nnadapter_model_cache_dir, NNAdapterModelCacheDir,
+                      std::string);
+  DECL_ARGUMENT_FIELD(nnadapter_device_names, NNAdapterDeviceNames,
+                      std::vector<std::string>);
+  DECL_ARGUMENT_FIELD(nnadapter_context_properties, NNAdapterContextProperties,
+                      std::string);
+  DECL_ARGUMENT_FIELD(nnadapter_subgraph_partition_config_buffer,
+                      NNAdapterSubgraphPartitionConfigBuffer, std::string);
+  DECL_ARGUMENT_FIELD(nnadapter_subgraph_partition_config_path,
+                      NNAdapterSubgraphPartitionConfigPath, std::string);
+  DECL_ARGUMENT_FIELD(nnadapter_model_cache_token, NNAdapterModelCacheToken,
+                      std::vector<std::string>);
+  DECL_ARGUMENT_FIELD(nnadapter_model_cache_buffer, NNAdapterModelCacheBuffer,
+                      std::vector<std::vector<char>>);
+
   // Memory optimized related.
   DECL_ARGUMENT_FIELD(enable_memory_optim, EnableMemoryOptim, bool);
 
diff --git a/paddle/fluid/inference/analysis/ir_pass_manager.cc b/paddle/fluid/inference/analysis/ir_pass_manager.cc
index 4bb08dc96b1cf5..d1be7246ef7f12 100644
--- a/paddle/fluid/inference/analysis/ir_pass_manager.cc
+++ b/paddle/fluid/inference/analysis/ir_pass_manager.cc
@@ -194,6 +194,26 @@ void IRPassManager::CreatePasses(Argument *argument,
                 new std::string(argument->xpu_autotune_file()));
       pass->Set("precision", new std::string(argument->xpu_precision()));
       pass->Set("adaptive_seqlen", new bool(argument->xpu_adaptive_seqlen()));
+      // NNAdapter Related
+      pass->Set("use_nnadapter", new bool(argument->use_nnadapter()));
+      pass->Set("model_cache_dir",
+                new std::string(argument->nnadapter_model_cache_dir()));
+      pass->Set("device_names", new std::vector<std::string>(
+                                    argument->nnadapter_device_names()));
+      pass->Set("context_properties",
+                new std::string(argument->nnadapter_context_properties()));
+      pass->Set("subgraph_partition_config_buffer",
+                new std::string(
+                    argument->nnadapter_subgraph_partition_config_buffer()));
+      pass->Set("subgraph_partition_config_path",
+                new std::string(
+                    argument->nnadapter_subgraph_partition_config_path()));
+      pass->Set("nnadapter_model_cache_buffer",
+                new std::vector<std::vector<char>>(
+                    argument->nnadapter_model_cache_buffer()));
+      pass->Set("nnadapter_model_cache_token",
+                new std::vector<std::string>(
+                    argument->nnadapter_model_cache_token()));
     }
     disable_logs_ = argument->disable_logs();
     if (pass_name == "fc_fuse_pass") {
diff --git a/paddle/fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc b/paddle/fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc
index b8cac8992f4eed..c7acbf401efd10 100644
--- a/paddle/fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc
+++ b/paddle/fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc
@@ -250,12 +250,27 @@ void LiteSubgraphPass::SetUpEngine(
   std::string autotune_file = Get<std::string>("autotune_file");
   std::string precision = Get<std::string>("precision");
   bool adaptive_seqlen = Get<bool>("adaptive_seqlen");
+  // NPU Related
+  bool use_nnadapter = Get<bool>("use_nnadapter");
+  std::string model_cache_dir = Get<std::string>("model_cache_dir");
+  auto device_names = Get<std::vector<std::string>>("device_names");
+  std::string context_properties = Get<std::string>("context_properties");
+  std::string subgraph_partition_config_buffer =
+      Get<std::string>("subgraph_partition_config_buffer");
+  std::string nnadapter_subgraph_partition_config_path =
+      Get<std::string>("subgraph_partition_config_path");
+  auto nnadapter_model_cache_buffer =
+      Get<std::vector<std::vector<char>>>("nnadapter_model_cache_buffer");
+  auto nnadapter_model_cache_token =
+      Get<std::vector<std::string>>("nnadapter_model_cache_token");
 
   lite_api::TargetType target_type;
   if (use_gpu) {
     target_type = TARGET(kCUDA);
   } else if (use_xpu) {
     target_type = TARGET(kXPU);
+  } else if (use_nnadapter) {
+    target_type = TARGET(kNNAdapter);
   } else {
 #ifdef PADDLE_WITH_ARM
     target_type = TARGET(kARM);
@@ -292,6 +307,17 @@ void LiteSubgraphPass::SetUpEngine(
   config.autotune_file = autotune_file;
   config.precision = precision;
   config.adaptive_seqlen = adaptive_seqlen;
+  // NPU Related
+  config.nnadapter_model_cache_dir = model_cache_dir;
+  config.nnadapter_device_names = device_names;
+  config.nnadapter_context_properties = context_properties;
+  config.nnadapter_subgraph_partition_config_buffer =
+      subgraph_partition_config_buffer;
+  config.nnadapter_subgraph_partition_config_path =
+      nnadapter_subgraph_partition_config_path;
+  config.nnadapter_model_cache_buffer = nnadapter_model_cache_buffer;
+  config.nnadapter_model_cache_token = nnadapter_model_cache_token;
+
   if (dump_model) {
     lite::StrToBinaryFile("./model.bin", config.model);
     lite::StrToBinaryFile("./param.bin", config.param);
diff --git a/paddle/fluid/inference/api/analysis_config.cc b/paddle/fluid/inference/api/analysis_config.cc
index bf7199491343e8..644e46b7e7e86c 100644
--- a/paddle/fluid/inference/api/analysis_config.cc
+++ b/paddle/fluid/inference/api/analysis_config.cc
@@ -195,6 +195,7 @@ AnalysisConfig::AnalysisConfig(const AnalysisConfig &other) {
   // NPU related.
   CP_MEMBER(use_npu_);
   CP_MEMBER(npu_device_id_);
+  CP_MEMBER(nnadapter_config_);
 
   // profile related.
   CP_MEMBER(with_profile_);
@@ -542,7 +543,7 @@ void AnalysisConfig::Update() {
   }
 
   if (use_npu_) {
-#ifdef PADDLE_WITH_ASCEND_CL
+#if defined(PADDLE_WITH_ASCEND_CL) || defined(LITE_SUBGRAPH_WITH_NPU)
     PADDLE_ENFORCE_EQ(use_gpu_, false,
                       platform::errors::Unavailable(
                           "Currently, NPU and GPU cannot be enabled in the "
@@ -816,4 +817,59 @@ std::string AnalysisConfig::Summary() {
   return os.PrintTable();
 }
 
+LiteNNAdapterConfig &LiteNNAdapterConfig::SetDeviceNames(
+    const std::vector<std::string> &names) {
+  device_names = names;
+  return *this;
+}
+
+LiteNNAdapterConfig &LiteNNAdapterConfig::SetContextProperties(
+    const std::string &properties) {
+  context_properties = properties;
+  return *this;
+}
+
+LiteNNAdapterConfig &LiteNNAdapterConfig::SetModelCacheDir(
+    const std::string &dir) {
+  model_cache_dir = dir;
+  return *this;
+}
+
+LiteNNAdapterConfig &LiteNNAdapterConfig::SetModelCacheBuffers(
+    const std::string &model_cache_token,
+    const std::vector<char> &model_cache_buffer) {
+  PADDLE_ENFORCE_EQ(model_cache_token.empty(), false,
+                    platform::errors::InvalidArgument(
+                        "model_cache_token should not be empty."));
+  PADDLE_ENFORCE_EQ(model_cache_buffer.empty(), false,
+                    platform::errors::InvalidArgument(
+                        "model_cache_buffer should not be empty."));
+  PADDLE_ENFORCE_EQ(model_cache_buffers.count(model_cache_token), false,
+                    platform::errors::InvalidArgument(
+                        "model_cache_token has already been set."));
+
+  model_cache_buffers[model_cache_token] = model_cache_buffer;
+  return *this;
+}
+
+LiteNNAdapterConfig &LiteNNAdapterConfig::SetSubgraphPartitionConfigPath(
+    const std::string &path) {
+  subgraph_partition_config_path = path;
+  return *this;
+}
+
+LiteNNAdapterConfig &LiteNNAdapterConfig::SetSubgraphPartitionConfigBuffer(
+    const std::string &buffer) {
+  subgraph_partition_config_buffer = buffer;
+  return *this;
+}
+LiteNNAdapterConfig &LiteNNAdapterConfig::Enable() {
+  use_nnadapter = true;
+  return *this;
+}
+LiteNNAdapterConfig &LiteNNAdapterConfig::Disable() {
+  use_nnadapter = false;
+  return *this;
+}
+
 }  // namespace paddle
diff --git a/paddle/fluid/inference/api/analysis_predictor.cc b/paddle/fluid/inference/api/analysis_predictor.cc
index b31b5f906b9b9b..ba143709355389 100644
--- a/paddle/fluid/inference/api/analysis_predictor.cc
+++ b/paddle/fluid/inference/api/analysis_predictor.cc
@@ -272,6 +272,29 @@ bool AnalysisPredictor::CreateExecutor() {
         "You tried to use NPU forward propagation, but Paddle was not compiled "
         "with WITH_ASCEND_CL."));
 #endif
+  } else if (config_.NNAdapter().use_nnadapter) {
+    if (config_.lite_engine_enabled()) {
+#ifdef LITE_SUBGRAPH_WITH_NNADAPTER
+      // Currently, Paddle-Lite's NNAdapter user interface only supports the
+      // transfer
+      // of Host data pointers. If it is currently used as a subgraph, execution
+      // efficiency will be sacrificed, so it is temporarily set to cpu place.
+      // And, the current lite engine of xpu must execute all parts of the
+      // model.
+      place_ = paddle::platform::CPUPlace();
+#else
+      PADDLE_THROW(
+          platform::errors::Unavailable("You tried to use an NNAdapter lite "
+                                        "engine, but Paddle was not compiled "
+                                        "with it."));
+#endif  // LITE_SUBGRAPH_WITH_NNADAPTER
+    } else {
+      PADDLE_THROW(
+          platform::errors::Unavailable("You tried to use NNadapter forward "
+                                        "propagation (inference without lite "
+                                        "engine), but Paddle was not compiled "
+                                        "with LITE_WITH_NNADAPTER."));
+    }
   } else {
     place_ = paddle::platform::CPUPlace();
   }
@@ -592,6 +615,24 @@ void AnalysisPredictor::PrepareArgument() {
     argument_.SetXpuAutotuneFile(config_.xpu_autotune_file_);
     argument_.SetXpuPrecision(config_.xpu_precision_);
     argument_.SetXpuAdaptiveSeqlen(config_.xpu_adaptive_seqlen_);
+    // NNAdapter related
+    argument_.SetUseNNAdapter(config_.NNAdapter().use_nnadapter);
+    argument_.SetNNAdapterDeviceNames(config_.NNAdapter().device_names);
+    argument_.SetNNAdapterContextProperties(
+        config_.NNAdapter().context_properties);
+    argument_.SetNNAdapterModelCacheDir(config_.NNAdapter().model_cache_dir);
+    argument_.SetNNAdapterSubgraphPartitionConfigBuffer(
+        config_.NNAdapter().subgraph_partition_config_buffer);
+    argument_.SetNNAdapterSubgraphPartitionConfigPath(
+        config_.NNAdapter().subgraph_partition_config_path);
+    std::vector<std::string> buffer_keys;
+    std::vector<std::vector<char>> buffer_vals;
+    for (auto it : config_.NNAdapter().model_cache_buffers) {
+      buffer_keys.emplace_back(it.first);
+      buffer_vals.emplace_back(it.second);
+    }
+    argument_.SetNNAdapterModelCacheToken(buffer_keys);
+    argument_.SetNNAdapterModelCacheBuffer(buffer_vals);
     LOG(INFO) << "Lite subgraph engine is enabled";
   }
 
diff --git a/paddle/fluid/inference/api/paddle_analysis_config.h b/paddle/fluid/inference/api/paddle_analysis_config.h
index 04ebe0efaed2cf..2027c0f7fad8e7 100644
--- a/paddle/fluid/inference/api/paddle_analysis_config.h
+++ b/paddle/fluid/inference/api/paddle_analysis_config.h
@@ -48,6 +48,34 @@ namespace paddle {
 class AnalysisPredictor;
 struct MkldnnQuantizerConfig;
 
+struct LiteNNAdapterConfig {
+  bool use_nnadapter{false};
+  std::string model_cache_dir;
+  std::map<std::string, std::vector<char>> model_cache_buffers;
+  std::vector<std::string> device_names;
+  std::string context_properties;
+  std::string subgraph_partition_config_path;
+  std::string subgraph_partition_config_buffer;
+
+  LiteNNAdapterConfig& SetDeviceNames(const std::vector<std::string>& names);
+
+  LiteNNAdapterConfig& SetContextProperties(const std::string& properties);
+
+  LiteNNAdapterConfig& SetModelCacheDir(const std::string& dir);
+
+  LiteNNAdapterConfig& SetModelCacheBuffers(
+      const std::string& model_cache_token,
+      const std::vector<char>& model_cache_buffer);
+
+  LiteNNAdapterConfig& SetSubgraphPartitionConfigPath(const std::string& path);
+
+  LiteNNAdapterConfig& SetSubgraphPartitionConfigBuffer(
+      const std::string& buffer);
+
+  LiteNNAdapterConfig& Enable();
+  LiteNNAdapterConfig& Disable();
+};
+
 ///
 /// \brief configuration manager for AnalysisPredictor.
 /// \since 1.7.0
@@ -627,6 +655,8 @@ struct PD_INFER_DECL AnalysisConfig {
   ///
   std::string Summary();
 
+  LiteNNAdapterConfig& NNAdapter() { return nnadapter_config_; }
+
  protected:
   // Update the config.
   void Update();
@@ -726,6 +756,9 @@ struct PD_INFER_DECL AnalysisConfig {
   std::string xpu_precision_;
   bool xpu_adaptive_seqlen_;
 
+  // NNAdapter related
+  LiteNNAdapterConfig nnadapter_config_;
+
   // mkldnn related.
   int mkldnn_cache_capacity_{10};
   bool use_mkldnn_quantizer_{false};
diff --git a/paddle/fluid/inference/lite/CMakeLists.txt b/paddle/fluid/inference/lite/CMakeLists.txt
index 2482a6917530bb..6d981d007e73a6 100644
--- a/paddle/fluid/inference/lite/CMakeLists.txt
+++ b/paddle/fluid/inference/lite/CMakeLists.txt
@@ -2,8 +2,8 @@ if(XPU_SDK_ROOT)
   set(XPU_DEPS xpuapi xpurt)
 endif()
 
-cc_library(lite_op_teller SRCS op_teller.cc DEPS lite_full_static framework_proto device_context boost xxhash)
-cc_library(lite_engine SRCS engine.cc DEPS lite_full_static framework_proto ${XPU_DEPS})
-cc_library(lite_tensor_utils SRCS tensor_utils.cc DEPS memcpy lite_full_static framework_proto boost device_context ${XPU_DEPS})
+cc_library(lite_op_teller SRCS op_teller.cc DEPS ${LITE_DEPS} framework_proto device_context boost xxhash)
+cc_library(lite_engine SRCS engine.cc DEPS ${LITE_DEPS} framework_proto ${XPU_DEPS})
+cc_library(lite_tensor_utils SRCS tensor_utils.cc DEPS memcpy ${LITE_DEPS} framework_proto boost device_context ${XPU_DEPS})
 cc_test(test_lite_engine SRCS test_engine_lite.cc DEPS lite_engine protobuf framework_proto glog gtest analysis)
 cc_test(test_lite_tensor_utils SRCS test_tensor_utils.cc DEPS lite_engine lite_tensor_utils)
diff --git a/paddle/fluid/inference/lite/engine.cc b/paddle/fluid/inference/lite/engine.cc
index 908e1ab990bb73..64868d71c6c471 100644
--- a/paddle/fluid/inference/lite/engine.cc
+++ b/paddle/fluid/inference/lite/engine.cc
@@ -25,6 +25,7 @@
 #endif
 
 #include "paddle/fluid/inference/lite/engine.h"
+#include <iostream>
 #include <utility>
 
 namespace paddle {
@@ -69,6 +70,25 @@ paddle::lite_api::PaddlePredictor* EngineManager::Create(
                                                cfg.adaptive_seqlen);
 #endif
 
+#ifdef LITE_SUBGRAPH_WITH_NPU
+  lite_cxx_config.set_nnadapter_device_names(cfg.nnadapter_device_names);
+  lite_cxx_config.set_nnadapter_context_properties(
+      cfg.nnadapter_context_properties);
+  lite_cxx_config.set_nnadapter_model_cache_dir(cfg.nnadapter_model_cache_dir);
+  if (!cfg.nnadapter_subgraph_partition_config_path.empty()) {
+    lite_cxx_config.set_nnadapter_subgraph_partition_config_path(
+        cfg.nnadapter_subgraph_partition_config_path);
+  }
+  if (!cfg.nnadapter_subgraph_partition_config_buffer.empty()) {
+    lite_cxx_config.set_nnadapter_subgraph_partition_config_buffer(
+        cfg.nnadapter_subgraph_partition_config_buffer);
+  }
+  for (size_t i = 0; i < cfg.nnadapter_model_cache_token.size(); ++i) {
+    lite_cxx_config.set_nnadapter_model_cache_buffers(
+        cfg.nnadapter_model_cache_token[i],
+        cfg.nnadapter_model_cache_buffer[i]);
+  }
+#endif
   // create predictor
   std::shared_ptr<paddle::lite_api::PaddlePredictor> p =
       paddle::lite_api::CreatePaddlePredictor(lite_cxx_config);
diff --git a/paddle/fluid/inference/lite/engine.h b/paddle/fluid/inference/lite/engine.h
index a64ef1eda828bf..48072656cb9966 100644
--- a/paddle/fluid/inference/lite/engine.h
+++ b/paddle/fluid/inference/lite/engine.h
@@ -53,6 +53,15 @@ struct EngineConfig {
 
   // for cuda
   bool use_multi_stream{false};
+
+  // for nnadapter or npu.
+  std::string nnadapter_model_cache_dir;
+  std::vector<std::string> nnadapter_device_names;
+  std::string nnadapter_context_properties;
+  std::string nnadapter_subgraph_partition_config_buffer;
+  std::string nnadapter_subgraph_partition_config_path;
+  std::vector<std::string> nnadapter_model_cache_token;
+  std::vector<std::vector<char>> nnadapter_model_cache_buffer;
 };
 
 class EngineManager {

From f975bc0a1750926355350d39309660a073c234c6 Mon Sep 17 00:00:00 2001
From: JZZ-NOTE <jzz2446071400@163.com>
Date: Fri, 27 Aug 2021 13:05:53 +0000
Subject: [PATCH 02/11] modify code

---
 cmake/external/lite.cmake                                     | 1 -
 .../fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc  | 4 ++--
 paddle/fluid/inference/lite/engine.cc                         | 1 -
 3 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/cmake/external/lite.cmake b/cmake/external/lite.cmake
index c77aa643ce9d9a..46e4f6db2dcc2b 100644
--- a/cmake/external/lite.cmake
+++ b/cmake/external/lite.cmake
@@ -88,7 +88,6 @@ if (NOT LITE_SOURCE_DIR OR NOT LITE_BINARY_DIR)
       PREFIX              ${LITE_SOURCES_DIR}
       PATCH_COMMAND       mkdir -p ${LITE_SOURCES_DIR}/src/extern_lite-build/lite/gen_code && touch ${LITE_SOURCES_DIR}/src/extern_lite-build/lite/gen_code/__generated_code__.cc && sed -i "/aarch64-linux-gnu-gcc/d" ${LITE_SOURCES_DIR}/src/extern_lite/cmake/cross_compiling/armlinux.cmake && sed -i "/aarch64-linux-gnu-g++/d" ${LITE_SOURCES_DIR}/src/extern_lite/cmake/cross_compiling/armlinux.cmake
       UPDATE_COMMAND      ""
-      BUILD_ALWAYS         1
       BUILD_COMMAND       ${LITE_BUILD_COMMAND}
       INSTALL_COMMAND     ""
       CMAKE_ARGS          -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
diff --git a/paddle/fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc b/paddle/fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc
index c7acbf401efd10..ce23dbb8deff9c 100644
--- a/paddle/fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc
+++ b/paddle/fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc
@@ -250,7 +250,7 @@ void LiteSubgraphPass::SetUpEngine(
   std::string autotune_file = Get<std::string>("autotune_file");
   std::string precision = Get<std::string>("precision");
   bool adaptive_seqlen = Get<bool>("adaptive_seqlen");
-  // NPU Related
+  // NNAdapter Related
   bool use_nnadapter = Get<bool>("use_nnadapter");
   std::string model_cache_dir = Get<std::string>("model_cache_dir");
   auto device_names = Get<std::vector<std::string>>("device_names");
@@ -307,7 +307,7 @@ void LiteSubgraphPass::SetUpEngine(
   config.autotune_file = autotune_file;
   config.precision = precision;
   config.adaptive_seqlen = adaptive_seqlen;
-  // NPU Related
+  // NNAdapter Related
   config.nnadapter_model_cache_dir = model_cache_dir;
   config.nnadapter_device_names = device_names;
   config.nnadapter_context_properties = context_properties;
diff --git a/paddle/fluid/inference/lite/engine.cc b/paddle/fluid/inference/lite/engine.cc
index 64868d71c6c471..47b9d681b4754f 100644
--- a/paddle/fluid/inference/lite/engine.cc
+++ b/paddle/fluid/inference/lite/engine.cc
@@ -25,7 +25,6 @@
 #endif
 
 #include "paddle/fluid/inference/lite/engine.h"
-#include <iostream>
 #include <utility>
 
 namespace paddle {

From b84070b5f17ecaa866f96404ec617395c4b86761 Mon Sep 17 00:00:00 2001
From: jiweibo <jiweibo@baidu.com>
Date: Wed, 15 Sep 2021 07:21:25 +0000
Subject: [PATCH 03/11] fix WITH_PYTHON compile error

---
 cmake/external/lite.cmake      | 5 ++---
 paddle/scripts/paddle_build.sh | 2 +-
 python/setup.py.in             | 6 ++++++
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/cmake/external/lite.cmake b/cmake/external/lite.cmake
index 46e4f6db2dcc2b..a7adf513420ad6 100644
--- a/cmake/external/lite.cmake
+++ b/cmake/external/lite.cmake
@@ -194,12 +194,11 @@ external_lite_libs(lite_full_static ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cx
 set(LITE_SHARED_LIB ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libpaddle_full_api_shared.so)
 
 if (LITE_WITH_NNADAPTER)
+  set(LITE_NNADAPTER_LIB ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter.so)
   if (NNADAPTER_WITH_NPU)
     external_lite_libs(lite_nnadapter ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter.so ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter_driver_huawei_ascend_npu.so)
     set(LITE_DEPS lite_full_static lite_nnadapter)
-    set(LITE_SHARED_LIB ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libpaddle_full_api_shared.so 
-      ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter.so
-      ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter_driver_huawei_ascend_npu.so)
+    set(LITE_NNADAPTER_NPU_LIB ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter_driver_huawei_ascend_npu.so)
   endif()
 else()
   set(LITE_DEPS lite_full_static)
diff --git a/paddle/scripts/paddle_build.sh b/paddle/scripts/paddle_build.sh
index a98cb00153c12d..24f250c46f14bd 100755
--- a/paddle/scripts/paddle_build.sh
+++ b/paddle/scripts/paddle_build.sh
@@ -222,7 +222,7 @@ function cmake_base() {
         -DWITH_GLOO=${gloo_flag}
         -DWITH_LITE=${WITH_LITE:-OFF}
         -DWITH_XPU=${WITH_XPU:-OFF}
-        -DLITE_GIT_TAG=release/v2.8
+        -DLITE_GIT_TAG=_release/v2.10
         -DWITH_UNITY_BUILD=${WITH_UNITY_BUILD:-OFF}
         -DWITH_XPU_BKCL=${WITH_XPU_BKCL:-OFF}
         -DWITH_ARM=${WITH_ARM:-OFF}
diff --git a/python/setup.py.in b/python/setup.py.in
index 8f9f973d933933..5e5265027fa56d 100644
--- a/python/setup.py.in
+++ b/python/setup.py.in
@@ -322,6 +322,12 @@ else:
 if '${WITH_LITE}' == 'ON':
     shutil.copy('${LITE_SHARED_LIB}', libs_path)
     package_data['paddle.libs']+=['libpaddle_full_api_shared' + ext_name]
+    if '${LITE_WITH_NNADAPTER}' == 'ON':
+        shutil.copy('${LITE_NNADAPTER_LIB}', libs_path)
+        package_data['paddle.libs']+=['libnnadapter' + ext_name]
+        if '${NNADAPTER_WITH_NPU}' == 'ON':
+            shutil.copy('${LITE_NNADAPTER_NPU_LIB}', libs_path)
+            package_data['paddle.libs']+=['libnnadapter_driver_huawei_ascend_npu' + ext_name]
 
 if '${WITH_PSLIB}' == 'ON':
     shutil.copy('${PSLIB_LIB}', libs_path)

From 99dc4e32da4fa3409c543f8dade2c57de7072571 Mon Sep 17 00:00:00 2001
From: JZZ-NOTE <jzz2446071400@163.com>
Date: Wed, 15 Sep 2021 08:28:02 +0000
Subject: [PATCH 04/11] modify files

---
 cmake/external/lite.cmake                     | 10 ++++----
 .../inference/analysis/ir_pass_manager.cc     | 13 ++++++-----
 .../analysis/ir_passes/lite_subgraph_pass.cc  | 23 +++++++++++--------
 paddle/fluid/inference/api/analysis_config.cc | 12 +++++-----
 .../fluid/inference/api/analysis_predictor.cc | 14 ++++++-----
 .../inference/api/paddle_analysis_config.h    | 12 +++++-----
 python/setup.py.in                            |  2 +-
 7 files changed, 46 insertions(+), 40 deletions(-)

diff --git a/cmake/external/lite.cmake b/cmake/external/lite.cmake
index a7adf513420ad6..e122be611f4609 100644
--- a/cmake/external/lite.cmake
+++ b/cmake/external/lite.cmake
@@ -37,7 +37,7 @@ endif()
 
 if (LITE_WITH_NNADAPTER)
   add_definitions(-DLITE_SUBGRAPH_WITH_NNADAPTER) 
-  if (NNADAPTER_WITH_NPU)
+  if (NNADAPTER_WITH_HUAWEI_ASCEND_NPU)
     add_definitions(-DLITE_SUBGRAPH_WITH_NPU)
     set(NPU_SDK_ROOT "/usr/local/Ascend/ascend-toolkit/latest" CACHE STRING "default NPU SDK ROOT")
   endif()
@@ -76,7 +76,7 @@ if (NOT LITE_SOURCE_DIR OR NOT LITE_BINARY_DIR)
                            -DXPU_SDK_URL=${XPU_BASE_URL}
                            -DXPU_SDK_ENV=${XPU_SDK_ENV}
                            -DLITE_WITH_NNADAPTER=${LITE_WITH_NNADAPTER}
-                           -DNNADAPTER_WITH_HUAWEI_ASCEND_NPU=${NNADAPTER_WITH_NPU}
+                           -DNNADAPTER_WITH_HUAWEI_ASCEND_NPU=${NNADAPTER_WITH_HUAWEI_ASCEND_NPU}
                            -DNNADAPTER_HUAWEI_ASCEND_NPU_SDK_ROOT=${NPU_SDK_ROOT}
                            -DLITE_WITH_CODE_META_INFO=OFF
                            -DLITE_WITH_ARM=ON)
@@ -122,7 +122,7 @@ if (NOT LITE_SOURCE_DIR OR NOT LITE_BINARY_DIR)
                            -DXPU_SDK_URL=${XPU_BASE_URL}
                            -DXPU_SDK_ENV=${XPU_SDK_ENV}
                            -DLITE_WITH_NNADAPTER=${LITE_WITH_NNADAPTER}
-                           -DNNADAPTER_WITH_HUAWEI_ASCEND_NPU=${NNADAPTER_WITH_NPU}
+                           -DNNADAPTER_WITH_HUAWEI_ASCEND_NPU=${NNADAPTER_WITH_HUAWEI_ASCEND_NPU}
                            -DNNADAPTER_HUAWEI_ASCEND_NPU_SDK_ROOT=${NPU_SDK_ROOT}
                            -DLITE_WITH_CODE_META_INFO=OFF
                            -DLITE_WITH_ARM=OFF)
@@ -162,7 +162,7 @@ if (WITH_ARM)
     set(LITE_OUTPUT_BIN_DIR inference_lite_lib.armlinux.armv8.xpu)
   elseif(LITE_WITH_NNADAPTER)
     message("Enable LITE_WITH_NNADAPTER")
-    if (NNADAPTER_WITH_NPU)
+    if (NNADAPTER_WITH_HUAWEI_ASCEND_NPU)
       set(LITE_OUTPUT_BIN_DIR inference_lite_lib.armlinux.armv8.nnadapter)
     endif()
   else()
@@ -195,7 +195,7 @@ set(LITE_SHARED_LIB ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libpaddle_
 
 if (LITE_WITH_NNADAPTER)
   set(LITE_NNADAPTER_LIB ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter.so)
-  if (NNADAPTER_WITH_NPU)
+  if (NNADAPTER_WITH_HUAWEI_ASCEND_NPU)
     external_lite_libs(lite_nnadapter ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter.so ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter_driver_huawei_ascend_npu.so)
     set(LITE_DEPS lite_full_static lite_nnadapter)
     set(LITE_NNADAPTER_NPU_LIB ${LITE_BINARY_DIR}/${LITE_OUTPUT_BIN_DIR}/cxx/lib/libnnadapter_driver_huawei_ascend_npu.so)
diff --git a/paddle/fluid/inference/analysis/ir_pass_manager.cc b/paddle/fluid/inference/analysis/ir_pass_manager.cc
index 364044ec98a2cb..4fdd963b6abff9 100644
--- a/paddle/fluid/inference/analysis/ir_pass_manager.cc
+++ b/paddle/fluid/inference/analysis/ir_pass_manager.cc
@@ -204,16 +204,17 @@ void IRPassManager::CreatePasses(Argument *argument,
       pass->Set("adaptive_seqlen", new bool(argument->xpu_adaptive_seqlen()));
       // NNAdapter Related
       pass->Set("use_nnadapter", new bool(argument->use_nnadapter()));
-      pass->Set("model_cache_dir",
+      pass->Set("nnadapter_model_cache_dir",
                 new std::string(argument->nnadapter_model_cache_dir()));
-      pass->Set("device_names", new std::vector<std::string>(
-                                    argument->nnadapter_device_names()));
-      pass->Set("context_properties",
+      pass->Set(
+          "nnadapter_device_names",
+          new std::vector<std::string>(argument->nnadapter_device_names()));
+      pass->Set("nnadapter_context_properties",
                 new std::string(argument->nnadapter_context_properties()));
-      pass->Set("subgraph_partition_config_buffer",
+      pass->Set("nnadapter_subgraph_partition_config_buffer",
                 new std::string(
                     argument->nnadapter_subgraph_partition_config_buffer()));
-      pass->Set("subgraph_partition_config_path",
+      pass->Set("nnadapter_subgraph_partition_config_path",
                 new std::string(
                     argument->nnadapter_subgraph_partition_config_path()));
       pass->Set("nnadapter_model_cache_buffer",
diff --git a/paddle/fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc b/paddle/fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc
index ce23dbb8deff9c..c04342f837e3f9 100644
--- a/paddle/fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc
+++ b/paddle/fluid/inference/analysis/ir_passes/lite_subgraph_pass.cc
@@ -252,13 +252,16 @@ void LiteSubgraphPass::SetUpEngine(
   bool adaptive_seqlen = Get<bool>("adaptive_seqlen");
   // NNAdapter Related
   bool use_nnadapter = Get<bool>("use_nnadapter");
-  std::string model_cache_dir = Get<std::string>("model_cache_dir");
-  auto device_names = Get<std::vector<std::string>>("device_names");
-  std::string context_properties = Get<std::string>("context_properties");
-  std::string subgraph_partition_config_buffer =
-      Get<std::string>("subgraph_partition_config_buffer");
+  std::string nnadapter_model_cache_dir =
+      Get<std::string>("nnadapter_model_cache_dir");
+  auto nnadapter_device_names =
+      Get<std::vector<std::string>>("nnadapter_device_names");
+  std::string nnadapter_context_properties =
+      Get<std::string>("nnadapter_context_properties");
+  std::string nnadapter_subgraph_partition_config_buffer =
+      Get<std::string>("nnadapter_subgraph_partition_config_buffer");
   std::string nnadapter_subgraph_partition_config_path =
-      Get<std::string>("subgraph_partition_config_path");
+      Get<std::string>("nnadapter_subgraph_partition_config_path");
   auto nnadapter_model_cache_buffer =
       Get<std::vector<std::vector<char>>>("nnadapter_model_cache_buffer");
   auto nnadapter_model_cache_token =
@@ -308,11 +311,11 @@ void LiteSubgraphPass::SetUpEngine(
   config.precision = precision;
   config.adaptive_seqlen = adaptive_seqlen;
   // NNAdapter Related
-  config.nnadapter_model_cache_dir = model_cache_dir;
-  config.nnadapter_device_names = device_names;
-  config.nnadapter_context_properties = context_properties;
+  config.nnadapter_model_cache_dir = nnadapter_model_cache_dir;
+  config.nnadapter_device_names = nnadapter_device_names;
+  config.nnadapter_context_properties = nnadapter_context_properties;
   config.nnadapter_subgraph_partition_config_buffer =
-      subgraph_partition_config_buffer;
+      nnadapter_subgraph_partition_config_buffer;
   config.nnadapter_subgraph_partition_config_path =
       nnadapter_subgraph_partition_config_path;
   config.nnadapter_model_cache_buffer = nnadapter_model_cache_buffer;
diff --git a/paddle/fluid/inference/api/analysis_config.cc b/paddle/fluid/inference/api/analysis_config.cc
index 6b5b6916665ddb..1bd768f1b3849a 100644
--- a/paddle/fluid/inference/api/analysis_config.cc
+++ b/paddle/fluid/inference/api/analysis_config.cc
@@ -828,19 +828,19 @@ std::string AnalysisConfig::Summary() {
 
 LiteNNAdapterConfig &LiteNNAdapterConfig::SetDeviceNames(
     const std::vector<std::string> &names) {
-  device_names = names;
+  nnadapter_device_names = names;
   return *this;
 }
 
 LiteNNAdapterConfig &LiteNNAdapterConfig::SetContextProperties(
     const std::string &properties) {
-  context_properties = properties;
+  nnadapter_context_properties = properties;
   return *this;
 }
 
 LiteNNAdapterConfig &LiteNNAdapterConfig::SetModelCacheDir(
     const std::string &dir) {
-  model_cache_dir = dir;
+  nnadapter_model_cache_dir = dir;
   return *this;
 }
 
@@ -857,19 +857,19 @@ LiteNNAdapterConfig &LiteNNAdapterConfig::SetModelCacheBuffers(
                     platform::errors::InvalidArgument(
                         "model_cache_token has already been set."));
 
-  model_cache_buffers[model_cache_token] = model_cache_buffer;
+  nnadapter_model_cache_buffers[model_cache_token] = model_cache_buffer;
   return *this;
 }
 
 LiteNNAdapterConfig &LiteNNAdapterConfig::SetSubgraphPartitionConfigPath(
     const std::string &path) {
-  subgraph_partition_config_path = path;
+  nnadapter_subgraph_partition_config_path = path;
   return *this;
 }
 
 LiteNNAdapterConfig &LiteNNAdapterConfig::SetSubgraphPartitionConfigBuffer(
     const std::string &buffer) {
-  subgraph_partition_config_buffer = buffer;
+  nnadapter_subgraph_partition_config_buffer = buffer;
   return *this;
 }
 LiteNNAdapterConfig &LiteNNAdapterConfig::Enable() {
diff --git a/paddle/fluid/inference/api/analysis_predictor.cc b/paddle/fluid/inference/api/analysis_predictor.cc
index 7b2da7cb3a83cd..4e2b9fbe28597b 100644
--- a/paddle/fluid/inference/api/analysis_predictor.cc
+++ b/paddle/fluid/inference/api/analysis_predictor.cc
@@ -626,17 +626,19 @@ void AnalysisPredictor::PrepareArgument() {
     argument_.SetXpuAdaptiveSeqlen(config_.xpu_adaptive_seqlen_);
     // NNAdapter related
     argument_.SetUseNNAdapter(config_.NNAdapter().use_nnadapter);
-    argument_.SetNNAdapterDeviceNames(config_.NNAdapter().device_names);
+    argument_.SetNNAdapterDeviceNames(
+        config_.NNAdapter().nnadapter_device_names);
     argument_.SetNNAdapterContextProperties(
-        config_.NNAdapter().context_properties);
-    argument_.SetNNAdapterModelCacheDir(config_.NNAdapter().model_cache_dir);
+        config_.NNAdapter().nnadapter_context_properties);
+    argument_.SetNNAdapterModelCacheDir(
+        config_.NNAdapter().nnadapter_model_cache_dir);
     argument_.SetNNAdapterSubgraphPartitionConfigBuffer(
-        config_.NNAdapter().subgraph_partition_config_buffer);
+        config_.NNAdapter().nnadapter_subgraph_partition_config_buffer);
     argument_.SetNNAdapterSubgraphPartitionConfigPath(
-        config_.NNAdapter().subgraph_partition_config_path);
+        config_.NNAdapter().nnadapter_subgraph_partition_config_path);
     std::vector<std::string> buffer_keys;
     std::vector<std::vector<char>> buffer_vals;
-    for (auto it : config_.NNAdapter().model_cache_buffers) {
+    for (auto it : config_.NNAdapter().nnadapter_model_cache_buffers) {
       buffer_keys.emplace_back(it.first);
       buffer_vals.emplace_back(it.second);
     }
diff --git a/paddle/fluid/inference/api/paddle_analysis_config.h b/paddle/fluid/inference/api/paddle_analysis_config.h
index da5ad749f5149d..e85bcf5e1fd4f9 100644
--- a/paddle/fluid/inference/api/paddle_analysis_config.h
+++ b/paddle/fluid/inference/api/paddle_analysis_config.h
@@ -50,12 +50,12 @@ struct MkldnnQuantizerConfig;
 
 struct LiteNNAdapterConfig {
   bool use_nnadapter{false};
-  std::string model_cache_dir;
-  std::map<std::string, std::vector<char>> model_cache_buffers;
-  std::vector<std::string> device_names;
-  std::string context_properties;
-  std::string subgraph_partition_config_path;
-  std::string subgraph_partition_config_buffer;
+  std::string nnadapter_model_cache_dir;
+  std::map<std::string, std::vector<char>> nnadapter_model_cache_buffers;
+  std::vector<std::string> nnadapter_device_names;
+  std::string nnadapter_context_properties;
+  std::string nnadapter_subgraph_partition_config_path;
+  std::string nnadapter_subgraph_partition_config_buffer;
 
   LiteNNAdapterConfig& SetDeviceNames(const std::vector<std::string>& names);
 
diff --git a/python/setup.py.in b/python/setup.py.in
index 5e5265027fa56d..8766b4c6031903 100644
--- a/python/setup.py.in
+++ b/python/setup.py.in
@@ -325,7 +325,7 @@ if '${WITH_LITE}' == 'ON':
     if '${LITE_WITH_NNADAPTER}' == 'ON':
         shutil.copy('${LITE_NNADAPTER_LIB}', libs_path)
         package_data['paddle.libs']+=['libnnadapter' + ext_name]
-        if '${NNADAPTER_WITH_NPU}' == 'ON':
+        if '${NNADAPTER_WITH_HUAWEI_ASCEND_NPU}' == 'ON':
             shutil.copy('${LITE_NNADAPTER_NPU_LIB}', libs_path)
             package_data['paddle.libs']+=['libnnadapter_driver_huawei_ascend_npu' + ext_name]
 

From 264fe38ba4346d15ca2d79d6bf95d2cea0a0cd69 Mon Sep 17 00:00:00 2001
From: JZZ-NOTE <jzz2446071400@163.com>
Date: Wed, 15 Sep 2021 10:56:10 +0000
Subject: [PATCH 05/11] modify file

---
 paddle/fluid/inference/api/analysis_config.cc | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/paddle/fluid/inference/api/analysis_config.cc b/paddle/fluid/inference/api/analysis_config.cc
index 3dc123b503c4e6..5d056e054f51c5 100644
--- a/paddle/fluid/inference/api/analysis_config.cc
+++ b/paddle/fluid/inference/api/analysis_config.cc
@@ -861,9 +861,9 @@ LiteNNAdapterConfig &LiteNNAdapterConfig::SetModelCacheBuffers(
   PADDLE_ENFORCE_EQ(model_cache_buffer.empty(), false,
                     platform::errors::InvalidArgument(
                         "model_cache_buffer should not be empty."));
-  PADDLE_ENFORCE_EQ(model_cache_buffers.count(model_cache_token), false,
-                    platform::errors::InvalidArgument(
-                        "model_cache_token has already been set."));
+  PADDLE_ENFORCE_EQ(nnadapter_model_cache_buffers.count(model_cache_token),
+                    false, platform::errors::InvalidArgument(
+                               "model_cache_token has already been set."));
 
   nnadapter_model_cache_buffers[model_cache_token] = model_cache_buffer;
   return *this;

From d99f20c1b2bf67ff15b3f29ac349d8d111fbae08 Mon Sep 17 00:00:00 2001
From: jiweibo <jiweibo@baidu.com>
Date: Wed, 15 Sep 2021 12:58:15 +0000
Subject: [PATCH 06/11] add python api

---
 paddle/fluid/pybind/inference_api.cc | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/paddle/fluid/pybind/inference_api.cc b/paddle/fluid/pybind/inference_api.cc
index b1a91cd302187e..a18cbfb86fe5c0 100644
--- a/paddle/fluid/pybind/inference_api.cc
+++ b/paddle/fluid/pybind/inference_api.cc
@@ -87,6 +87,7 @@ void BindPaddlePlace(py::module *m);
 void BindPaddlePredictor(py::module *m);
 void BindNativeConfig(py::module *m);
 void BindNativePredictor(py::module *m);
+void BindLiteNNAdapterConfig(py::module *m);
 void BindAnalysisConfig(py::module *m);
 void BindAnalysisPredictor(py::module *m);
 void BindZeroCopyTensor(py::module *m);
@@ -303,6 +304,7 @@ void BindInferenceApi(py::module *m) {
   BindPaddlePredictor(m);
   BindNativeConfig(m);
   BindNativePredictor(m);
+  BindLiteNNAdapterConfig(m);
   BindAnalysisConfig(m);
   BindAnalysisPredictor(m);
   BindPaddleInferPredictor(m);
@@ -624,7 +626,26 @@ void BindAnalysisConfig(py::module *m) {
            [](AnalysisConfig &self) {
              return dynamic_cast<PaddlePassBuilder *>(self.pass_builder());
            },
-           py::return_value_policy::reference);
+           py::return_value_policy::reference)
+      .def("nnadapter", &AnalysisConfig::NNAdapter);
+}
+
+void BindLiteNNAdapterConfig(py::module *m) {
+  py::class_<LiteNNAdapterConfig> lite_nnadapter_config(*m,
+                                                        "LiteNNAdapterConfig");
+
+  lite_nnadapter_config
+      .def("set_device_names", &LiteNNAdapterConfig::SetDeviceNames)
+      .def("set_context_properties", &LiteNNAdapterConfig::SetContextProperties)
+      .def("set_model_cache_dir", &LiteNNAdapterConfig::SetModelCacheDir)
+      .def("set_model_cache_buffers",
+           &LiteNNAdapterConfig::SetModelCacheBuffers)
+      .def("set_subgraph_partition_config_path",
+           &LiteNNAdapterConfig::SetSubgraphPartitionConfigPath)
+      .def("set_subgraph_partition_config_buffer",
+           &LiteNNAdapterConfig::SetSubgraphPartitionConfigBuffer)
+      .def("enable", &LiteNNAdapterConfig::Enable)
+      .def("disable", &LiteNNAdapterConfig::Disable);
 }
 
 #ifdef PADDLE_WITH_MKLDNN

From d796d5f528cf548f08b36acd98a80e25fb4dabf1 Mon Sep 17 00:00:00 2001
From: JZZ-NOTE <jzz2446071400@163.com>
Date: Thu, 16 Sep 2021 02:44:55 +0000
Subject: [PATCH 07/11] modify paddle_build

---
 paddle/scripts/paddle_build.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/paddle/scripts/paddle_build.sh b/paddle/scripts/paddle_build.sh
index 24f250c46f14bd..d88bc92a5ee430 100755
--- a/paddle/scripts/paddle_build.sh
+++ b/paddle/scripts/paddle_build.sh
@@ -262,7 +262,7 @@ EOF
         -DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX:-/paddle/build} \
         -DWITH_PSCORE=${distibuted_flag} \
         -DWITH_GLOO=${gloo_flag} \
-        -DLITE_GIT_TAG=release/v2.8 \
+        -DLITE_GIT_TAG=_release/v2.10 \
         -DWITH_XPU=${WITH_XPU:-OFF} \
         -DXPU_SDK_ROOT=${XPU_SDK_ROOT:-""} \
         -DWITH_LITE=${WITH_LITE:-OFF} \

From 3137fe4a9a6daf7377fec6daff322126cecd2cc2 Mon Sep 17 00:00:00 2001
From: jiweibo <jiweibo@baidu.com>
Date: Sat, 18 Sep 2021 05:25:33 +0000
Subject: [PATCH 08/11] fix compile error for _release/v2.10

---
 cmake/external/lite.cmake | 1 +
 1 file changed, 1 insertion(+)

diff --git a/cmake/external/lite.cmake b/cmake/external/lite.cmake
index e122be611f4609..e8e7ad3628a862 100644
--- a/cmake/external/lite.cmake
+++ b/cmake/external/lite.cmake
@@ -134,6 +134,7 @@ if (NOT LITE_SOURCE_DIR OR NOT LITE_BINARY_DIR)
         GIT_TAG             ${LITE_GIT_TAG}
         PREFIX              ${LITE_SOURCES_DIR}
         UPDATE_COMMAND      ""
+        PATCH_COMMAND       sed -i "s?NNadapter_bridges_path = os.path.abspath('..')+\"\/lite\/kernels\/nnadapter\/bridges\/paddle_use_bridges.h\"?NNadapter_bridges_path = os.path.abspath(\'..\')+\"\/extern_lite\/lite\/kernels\/nnadapter\/bridges\/paddle_use_bridges.h\"?" ${LITE_SOURCES_DIR}/src/extern_lite//lite/tools/cmake_tools/record_supported_kernel_op.py
         BUILD_COMMAND       ${LITE_BUILD_COMMAND}
         INSTALL_COMMAND     ""
         CMAKE_ARGS          -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}

From fdc70bb8ed41bee58283f5a6f004a26eae31e660 Mon Sep 17 00:00:00 2001
From: jiweibo <jiweibo@baidu.com>
Date: Sat, 18 Sep 2021 11:37:52 +0000
Subject: [PATCH 09/11] fix test error.

---
 cmake/external/lite.cmake                          | 2 +-
 paddle/fluid/operators/lite/lite_engine_op_test.cc | 8 ++++++--
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/cmake/external/lite.cmake b/cmake/external/lite.cmake
index e8e7ad3628a862..ffadf7bea93768 100644
--- a/cmake/external/lite.cmake
+++ b/cmake/external/lite.cmake
@@ -134,7 +134,7 @@ if (NOT LITE_SOURCE_DIR OR NOT LITE_BINARY_DIR)
         GIT_TAG             ${LITE_GIT_TAG}
         PREFIX              ${LITE_SOURCES_DIR}
         UPDATE_COMMAND      ""
-        PATCH_COMMAND       sed -i "s?NNadapter_bridges_path = os.path.abspath('..')+\"\/lite\/kernels\/nnadapter\/bridges\/paddle_use_bridges.h\"?NNadapter_bridges_path = os.path.abspath(\'..\')+\"\/extern_lite\/lite\/kernels\/nnadapter\/bridges\/paddle_use_bridges.h\"?" ${LITE_SOURCES_DIR}/src/extern_lite//lite/tools/cmake_tools/record_supported_kernel_op.py
+        PATCH_COMMAND       sed -i "s?NNadapter_bridges_path = os.path.abspath('..')+\"\/lite\/kernels\/nnadapter\/bridges\/paddle_use_bridges.h\"?NNadapter_bridges_path = os.path.abspath(\'..\')+\"\/extern_lite\/lite\/kernels\/nnadapter\/bridges\/paddle_use_bridges.h\"?" ${LITE_SOURCES_DIR}/src/extern_lite//lite/tools/cmake_tools/record_supported_kernel_op.py && sed -i "/general::ssa::ConvertToSSA(cpp_prog)$<SEMICOLON>/d" ${LITE_SOURCES_DIR}/src/extern_lite/lite/model_parser/model_parser.cc
         BUILD_COMMAND       ${LITE_BUILD_COMMAND}
         INSTALL_COMMAND     ""
         CMAKE_ARGS          -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
diff --git a/paddle/fluid/operators/lite/lite_engine_op_test.cc b/paddle/fluid/operators/lite/lite_engine_op_test.cc
index 44ba1e4e497bf1..8b7f1268081343 100644
--- a/paddle/fluid/operators/lite/lite_engine_op_test.cc
+++ b/paddle/fluid/operators/lite/lite_engine_op_test.cc
@@ -30,6 +30,8 @@ using paddle::inference::lite::CreateTensor;
 using paddle::inference::lite::serialize_params;
 namespace paddle {
 namespace operators {
+
+#if defined(PADDLE_WITH_CUDA)
 TEST(LiteEngineOp, engine_op) {
   framework::ProgramDesc program;
   auto* block_ = program.Proto()->mutable_blocks(0);
@@ -75,8 +77,8 @@ TEST(LiteEngineOp, engine_op) {
   platform::CPUDeviceContext ctx(place);
 #endif
   // Prepare variables.
-  CreateTensor(&scope, "x", std::vector<int64_t>({2, 4}), false);
-  CreateTensor(&scope, "y", std::vector<int64_t>({2, 4}), false);
+  CreateTensor(&scope, "x", std::vector<int64_t>({2, 4}), true);
+  CreateTensor(&scope, "y", std::vector<int64_t>({2, 4}), true);
   CreateTensor(&scope, "out", std::vector<int64_t>({2, 4}), false);
 
   ASSERT_EQ(block_->ops_size(), 4);
@@ -113,5 +115,7 @@ TEST(LiteEngineOp, engine_op) {
   engine_op->Run(scope, place);
   LOG(INFO) << "done";
 }
+#endif
+
 }  // namespace operators
 }  // namespace paddle

From 6ed50e4bc4002c4b2c1bab469b8e22a780fc1ae8 Mon Sep 17 00:00:00 2001
From: jiweibo <jiweibo@baidu.com>
Date: Mon, 20 Sep 2021 04:24:51 +0000
Subject: [PATCH 10/11] ci coverage.

---
 .../fluid/inference/api/analysis_predictor.cc  |  9 +--------
 .../inference/api/analysis_predictor_tester.cc | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/paddle/fluid/inference/api/analysis_predictor.cc b/paddle/fluid/inference/api/analysis_predictor.cc
index 4e2b9fbe28597b..a66ce609ba8961 100644
--- a/paddle/fluid/inference/api/analysis_predictor.cc
+++ b/paddle/fluid/inference/api/analysis_predictor.cc
@@ -278,15 +278,8 @@ bool AnalysisPredictor::CreateExecutor() {
 #endif
   } else if (config_.NNAdapter().use_nnadapter) {
     if (config_.lite_engine_enabled()) {
-#ifdef LITE_SUBGRAPH_WITH_NNADAPTER
-      // Currently, Paddle-Lite's NNAdapter user interface only supports the
-      // transfer
-      // of Host data pointers. If it is currently used as a subgraph, execution
-      // efficiency will be sacrificed, so it is temporarily set to cpu place.
-      // And, the current lite engine of xpu must execute all parts of the
-      // model.
       place_ = paddle::platform::CPUPlace();
-#else
+#ifndef LITE_SUBGRAPH_WITH_NNADAPTER
       PADDLE_THROW(
           platform::errors::Unavailable("You tried to use an NNAdapter lite "
                                         "engine, but Paddle was not compiled "
diff --git a/paddle/fluid/inference/api/analysis_predictor_tester.cc b/paddle/fluid/inference/api/analysis_predictor_tester.cc
index 513f3669a19ce9..6ed67e6c79259e 100644
--- a/paddle/fluid/inference/api/analysis_predictor_tester.cc
+++ b/paddle/fluid/inference/api/analysis_predictor_tester.cc
@@ -61,6 +61,24 @@ TEST(AnalysisPredictor, analysis_off) {
   ASSERT_TRUE(predictor->Run(inputs, &outputs));
 }
 
+TEST(AnalysisPredictor, lite_nn_adapter_npu) {
+  AnalysisConfig config;
+  config.SetModel(FLAGS_dirname);
+  config.EnableLiteEngine();
+  config.NNAdapter()
+      .Disable()
+      .Enable()
+      .SetDeviceNames({"huawei_ascend_npu"})
+      .SetContextProperties("HUAWEI_ASCEND_NPU_SELECTED_DEVICE_IDS=0")
+      .SetModelCacheDir("cache_dirr")
+      .SetSubgraphPartitionConfigPath("")
+      .SetModelCacheBuffers("c1", {'c'});
+#ifndef LITE_SUBGRAPH_WITH_NNADAPTER
+  EXPECT_THROW(CreatePaddlePredictor<AnalysisConfig>(config),
+               paddle::platform::EnforceNotMet);
+#endif
+}
+
 TEST(AnalysisPredictor, analysis_on) {
   AnalysisConfig config;
   config.SetModel(FLAGS_dirname);

From 550ed0844f90aea6be56e2ba90a50c2495111365 Mon Sep 17 00:00:00 2001
From: jiweibo <jiweibo@baidu.com>
Date: Mon, 20 Sep 2021 15:43:05 +0000
Subject: [PATCH 11/11] fix windows ci error

---
 paddle/fluid/inference/api/analysis_predictor_tester.cc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/paddle/fluid/inference/api/analysis_predictor_tester.cc b/paddle/fluid/inference/api/analysis_predictor_tester.cc
index 6ed67e6c79259e..86fbde00075f09 100644
--- a/paddle/fluid/inference/api/analysis_predictor_tester.cc
+++ b/paddle/fluid/inference/api/analysis_predictor_tester.cc
@@ -61,6 +61,7 @@ TEST(AnalysisPredictor, analysis_off) {
   ASSERT_TRUE(predictor->Run(inputs, &outputs));
 }
 
+#ifndef WIN32
 TEST(AnalysisPredictor, lite_nn_adapter_npu) {
   AnalysisConfig config;
   config.SetModel(FLAGS_dirname);
@@ -78,6 +79,7 @@ TEST(AnalysisPredictor, lite_nn_adapter_npu) {
                paddle::platform::EnforceNotMet);
 #endif
 }
+#endif
 
 TEST(AnalysisPredictor, analysis_on) {
   AnalysisConfig config;