Mlu notifier reuse (#825)

Author: ShawnNew

backends/mlu/CMakeLists.txt

@@ -25,7 +25,7 @@ message(STATUS "C compiler: ${CMAKE_C_COMPILER}, version: "
 message(STATUS "AR tools: ${CMAKE_AR}")
 
 # custom runtime
-set(CUSTOM_MLU_SRCS runtime/runtime.cc)
+set(CUSTOM_MLU_SRCS runtime/runtime.cc runtime/CNRTEvent.h)
 add_definitions(-DPADDLE_WITH_CUSTOM_DEVICE)
 # TODO(qiil93): avoid compile error, to be removed
 add_definitions(-DPADDLE_WITH_CUSTOM_KERNEL)

backends/mlu/runtime/CNRTEvent.h

@@ -0,0 +1,138 @@
+// Copyright (c) 2023 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 <cnrt.h>
+
+#include "runtime/runtime.h"
+
+/*
+ * CNRTEvents are movable not copyable wrappers around CNRT's events.
+ */
+struct CNRTEvent {
+  // Constructors
+  // Default value for "flags" is specified below - it's
+  // CNRT_NOTIFIER_DISABLE_TIMING_ALL
+  CNRTEvent() noexcept = default;
+  explicit CNRTEvent(cnrtNotifierFlags flag, int dev_idx) noexcept
+      : flag_{flag}, dev_idx_(dev_idx) {
+    createEvent();
+  }
+
+  ~CNRTEvent() {
+    try {
+      if (is_created_) {
+        PADDLE_ENFORCE_MLU_SUCCESS(cnrtNotifierDestroy(event_));
+      }
+    } catch (...) { /* No throw */
+    }
+  }
+
+  CNRTEvent(const CNRTEvent&) = delete;
+  CNRTEvent& operator=(const CNRTEvent&) = delete;
+
+  CNRTEvent(CNRTEvent&& other) noexcept { moveHelper(std::move(other)); }
+  CNRTEvent& operator=(CNRTEvent&& other) noexcept {
+    if (this != &other) {
+      moveHelper(std::move(other));
+    }
+    return *this;
+  }
+
+  operator cnrtNotifier_t() const { return event(); }
+
+  // Less than operator (to allow use in sets)
+  friend bool operator<(const CNRTEvent& left, const CNRTEvent& right) {
+    return left.event_ < right.event_;
+  }
+
+  int device() const {
+    if (is_created_) {
+      return dev_idx_;
+    } else {
+      return -1;
+    }
+  }
+
+  bool isCreated() const { return is_created_; }
+  bool wasRecorded() const { return was_recorded_; }
+  bool isCompleted() const { return is_completed_; }
+  int device_index() const { return dev_idx_; }
+  cnrtNotifier_t event() const { return event_; }
+
+  bool query() {
+    if (!is_created_) {
+      return true;
+    }
+
+    cnrtRet_t ret_err = cnrtQueryNotifier(event_);
+    if (ret_err == cnrtSuccess) {
+      is_completed_ = true;
+    } else {
+      (void)cnrtGetLastError();
+    }
+
+    return is_completed_ ? true : false;
+  }
+
+  void record(const int device, cnrtQueue_t stream) {
+    PADDLE_ENFORCE_EQ(
+        dev_idx_,
+        device,
+        phi::errors::InvalidArgument(
+            "Event device %d does not match recording stream's device %d.",
+            dev_idx_,
+            device));
+    PADDLE_ENFORCE_MLU_SUCCESS(
+        cnrtPlaceNotifier(reinterpret_cast<cnrtNotifier_t>(event_), stream));
+    was_recorded_ = true;
+  }
+
+  void block(const cnrtQueue_t stream) {
+    if (is_created_) {
+      PADDLE_ENFORCE_MLU_SUCCESS(cnrtQueueWaitNotifier(
+          reinterpret_cast<cnrtNotifier_t>(event_), stream, 0));
+    }
+  }
+
+  void synchronize() const {
+    if (is_created_) {
+      PADDLE_ENFORCE_MLU_SUCCESS(
+          cnrtWaitNotifier(reinterpret_cast<cnrtNotifier_t>(event_)));
+    }
+  }
+
+ private:
+  cnrtNotifierFlags flag_ =
+      CNRT_NOTIFIER_DISABLE_TIMING_ALL;  // no time elapsing
+  bool is_created_ = false;
+  bool was_recorded_ = false;
+  bool is_completed_ = false;
+  int dev_idx_ = -1;
+  cnrtNotifier_t event_ = nullptr;
+
+  void createEvent() {
+    // dev_idx_ = dev_idx;
+    PADDLE_ENFORCE_MLU_SUCCESS(cnrtNotifierCreateWithFlags(&event_, flag_));
+    is_created_ = true;
+  }
+
+  void moveHelper(CNRTEvent&& other) {
+    std::swap(flag_, other.flag_);
+    std::swap(is_created_, other.is_created_);
+    std::swap(was_recorded_, other.was_recorded_);
+    std::swap(dev_idx_, other.dev_idx_);
+    std::swap(event_, other.event_);
+  }
+};

backends/mlu/runtime/flags.h

@@ -0,0 +1,80 @@
+// Copyright (c) 2023 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.
+
+// Part of the following code in this file is from
+//     https://github.com/google/glog/blob/master/src/base/commandlineflags.h
+//     Git commit hash: 9f0b7d3bfe1542848f784e8d1c545b916cec6b3e
+// Retain the following license from the original files:
+
+// Copyright (c) 2008, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef BACKENDS_MLU_RUNTIME_FLAGS_H_
+#define BACKENDS_MLU_RUNTIME_FLAGS_H_
+
+#include "gflags/gflags.h"
+
+#define FLAGS_DEFINE_bool(name, value, meaning) \
+  DEFINE_bool(name, EnvToBool("FLAGS_" #name, value), meaning)
+
+#define FLAGS_DEFINE_int32(name, value, meaning) \
+  DEFINE_int32(name, EnvToInt("FLAGS_" #name, value), meaning)
+
+#define FLAGS_DEFINE_uint32(name, value, meaning) \
+  DEFINE_uint32(name, EnvToUInt("FLAGS_" #name, value), meaning)
+
+#define FLAGS_DEFINE_uint64(name, value, meaning) \
+  DEFINE_uint64(name, EnvToUInt("FLAGS_" #name, value), meaning)
+
+#define FLAGS_DEFINE_string(name, value, meaning) \
+  DEFINE_string(name, EnvToString("FLAGS_" #name, value), meaning)
+
+#define EnvToString(envname, dflt) (!getenv(envname) ? (dflt) : getenv(envname))
+
+#define EnvToBool(envname, dflt) \
+  (!getenv(envname) ? (dflt) : memchr("tTyY1\0", getenv(envname)[0], 6) != NULL)
+
+#define EnvToInt(envname, dflt) \
+  (!getenv(envname) ? (dflt) : strtol(getenv(envname), NULL, 10))
+
+#define EnvToUInt(envname, dflt) \
+  (!getenv(envname) ? (dflt) : strtoul(getenv(envname), NULL, 10))
+
+#endif  // BACKENDS_MLU_RUNTIME_FLAGS_H_