[xpu] adjust XPU_L3_LOCK_REQUIRED implements

test=develop test=xpu

lite/backends/xpu/target_wrapper.cc

@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "lite/backends/xpu/target_wrapper.h"
+#include "lite/core/context.h"
 #include "lite/utils/macros.h"
 
 namespace paddle {
@@ -78,6 +79,7 @@ XPUScratchPadGuard TargetWrapperXPU::MallocScratchPad(size_t size,
 std::string TargetWrapperXPU::multi_encoder_precision;  // NOLINT
 int TargetWrapperXPU::workspace_l3_size_per_thread{0};
 LITE_THREAD_LOCAL xdnn::Context* TargetWrapperXPU::tls_raw_ctx_{nullptr};
+int Context<TargetType::kXPU>::_reentrant{0};
 
 }  // namespace lite
 }  // namespace paddle

lite/core/context.h

@@ -29,6 +29,7 @@
 #include "lite/backends/mlu/mlu_utils.h"
 #endif
 #ifdef LITE_WITH_XPU
+#include <fcntl.h>
 #include "lite/backends/xpu/xpu_header_sitter.h"
 #endif
 
@@ -188,6 +189,45 @@ class Context<TargetType::kXPU> {
   }
 
   std::string name() const { return "XPUContext"; }
+
+  inline static int LockXPU() {
+    _reentrant = 0;
+    int xpu_l3_lock_fd = -1;
+    struct flock f_lock;
+    f_lock.l_whence = 0;
+    f_lock.l_len = 0;
+
+    if (_reentrant == 0) {
+      int pd = 0;  // TODO(luohang): need get from lite api
+      std::string buf = "/opt/xpu_lock" + std::to_string(pd);
+      xpu_l3_lock_fd = open(buf.c_str(), O_RDWR);
+      CHECK(xpu_l3_lock_fd > 0) << "open " << buf
+                                << " failed: " << xpu_l3_lock_fd;
+
+      // lock
+      f_lock.l_type = F_WRLCK;
+      fcntl(xpu_l3_lock_fd, F_SETLKW, &f_lock);
+    }
+    _reentrant++;
+    return xpu_l3_lock_fd;
+  }
+
+  inline static void ReleaseXPU(int lock_fd) {
+    if (lock_fd < 0) return;
+
+    if (_reentrant == 1) {
+      struct flock f_lock;
+      f_lock.l_whence = 0;
+      f_lock.l_len = 0;
+      f_lock.l_type = F_UNLCK;
+      fcntl(lock_fd, F_SETLKW, &f_lock);
+      close(lock_fd);
+    }
+    _reentrant--;
+  }
+
+ private:
+  static int _reentrant;
 };
 #endif
 

lite/core/program.cc

@@ -292,8 +292,17 @@ void RuntimeProgram::Run() {
     if (inst.need_sync()) {
       inst.Sync();
     }
+#endif
+#ifdef LITE_WITH_XPU
+    auto need_lock_l3 = std::getenv("XPU_L3_LOCK_REQUIRED");
+    int lock_fd = -1;
+    if (need_lock_l3) lock_fd = Context<TargetType::kXPU>::LockXPU();
 #endif
     inst.Run();
+#ifdef LITE_WITH_XPU
+    if (need_lock_l3 && lock_fd >= 0)
+      Context<TargetType::kXPU>::ReleaseXPU(lock_fd);
+#endif
 #ifdef LITE_WITH_PRECISION_PROFILE
 #ifndef LITE_WITH_FPGA
     precision_profiler_summary +=
@@ -442,44 +451,7 @@ void Instruction::Run() {
     CHECK(op_->CheckShape());
   }
 
-#ifdef LITE_WITH_XPU
-  static int reentrant = 0;
-  int xpu_l3_lock_fd;
-  auto need_lock_l3 = std::getenv("XPU_L3_LOCK_REQUIRED");
-  struct flock f_lock;
-  f_lock.l_whence = 0;
-  f_lock.l_len = 0;
-
-  if (reentrant == 0) {
-    if (need_lock_l3) {
-      int pd = 0;  // TODO(luohang): need get from lite api
-      std::string buf = "/opt/xpu_lock" + std::to_string(pd);
-      xpu_l3_lock_fd = open(buf.c_str(), O_RDWR);
-      CHECK(xpu_l3_lock_fd > 0) << "open " << buf
-                                << " failed: " << xpu_l3_lock_fd;
-
-      // lock
-      f_lock.l_type = F_WRLCK;
-      fcntl(xpu_l3_lock_fd, F_SETLKW, &f_lock);
-    } else {
-      xpu_l3_lock_fd = -1;
-    }
-  }
-  reentrant++;
-#endif
-
-  bool run_res = op_->run_once() && has_run_;
-
-#ifdef LITE_WITH_XPU
-  if (need_lock_l3 && reentrant == 1) {
-    f_lock.l_type = F_UNLCK;
-    fcntl(xpu_l3_lock_fd, F_SETLKW, &f_lock);
-    close(xpu_l3_lock_fd);
-  }
-  reentrant--;
-#endif
-
-  if (run_res) {
+  if (op_->run_once() && has_run_) {
     return;
   }