remove tensor signature and backend set member

.gitignore

@@ -4,7 +4,6 @@ paddle/fluid/API_DEV.spec
 paddle/fluid/API_PR.spec
 paddle/fluid/op_use_default_grad_maker_DEV.spec
 paddle/fluid/op_use_default_grad_maker_PR.spec
-tools/__pycache__/static_mode_white_list.cpython-37.pyc
 
 *.DS_Store
 *.vs

paddle/fluid/operators/mean_op.h

@@ -49,7 +49,7 @@ using EigenVector = framework::EigenVector<T, MajorType, IndexType>;
  * Currently, only the first two cases are adapted.
  *
  * The principle here is that the implementation in the kernel must reuse the
- * corresponding functions in the Tensor compute library and cannot maintain
+ * corresponding functions in the Tensor Operation library and cannot maintain
  * two copies of the code.
  */
 template <typename DeviceContext, typename T>

paddle/pten/common/backend.h

@@ -28,8 +28,8 @@ namespace experimental {
  * but in order to make the boundary of the kernel clearer and the function
  * more specific, we need to distinguish the calculation method.
  *
- * Such as the kernel for CUDA device, it can be a native CUDA kernel,
- * or a kernel implemented by CUDNN library.
+ * Such as the kernel for CPU device, it can be a native CPU kernel,
+ * or a kernel implemented by MKLDNN library.
  *
  * Note(chenweihang): HIP is not needed now, we can added it if needed
  * in the future

paddle/pten/hapi/include/backend_set.h

@@ -26,8 +26,8 @@ namespace experimental {
  * We use the backend to form a bit set to assist the runtime kernel selection,
  * and the higher backend bit has a higher priority.
  *
- * A Tensor may belong to multiple backends at the same time, such CUDNN and
- * CUDA. Only one backend value cannot
+ * A Tensor may belong to multiple backends at the same time, such CPU and
+ * MKLDNN. Only one backend value cannot
  */
 class BackendSet final {
  public:

paddle/pten/hapi/include/tensor.h

@@ -19,18 +19,17 @@ limitations under the License. */
 #include <utility>
 
 #include "paddle/pten/core/tensor_base.h"
-#include "paddle/pten/hapi/include/tensor_signature.h"
 
 /**
  * [ Why still include the fluid headers? ]
  *
  * We hope to organize the basic implementation of Tensor and the logic related
  * to Tensor computation into an independent library, which we call
- * [Tensor Compute Library, pten], so we extract or rewrite the original
+ * [Tensor Operation Library, pten], so we extract or rewrite the original
  * Kernels.
  *
  * In the future, the training library, inference library and custom operators
- * will link to this Tensor Compute library.
+ * will link to this Tensor Operation library.
  *
  * However, if we directly split the link relation, we need to make too many
  * changes, which will affect the stability of the framework, so here we still
@@ -47,15 +46,15 @@ namespace experimental {
 
 class Tensor;
 
-class AutogradMetaInterface {
+class AbstractAutogradMeta {
  public:
-  // No AutogradMetaInterface should be created
-  virtual ~AutogradMetaInterface() {}
+  // No AbstractAutogradMeta should be created
+  virtual ~AbstractAutogradMeta() {}
 };
 
 /**
  * Tensor is the API description of the basic data structure in the
- * [ Paddle "Tensor CoMPuTe (pten)" Library ].
+ * [ "Paddle Tensor Operation (pten)" Library ].
  *
  * It is not limited to a simple n-dimensional array.
  * It contains a smart pointer to `TensorImpl`. The data description contained
@@ -97,7 +96,6 @@ class Tensor final {
     if (impl_.get() == nullptr) {
       throw std::runtime_error("TensorImpl with nullptr is not supported");
     }
-    signature_.reset(new TensorSignature(impl_->backend()));
   }
 
   /* Part 2: Dimension, DataType and DataLayout methods */
@@ -140,16 +138,8 @@ class Tensor final {
   /**
    * Backend judgment APIs, shield the concept of Backend.
    */
-  BackendSet backend_set() const { return signature_->backend_set; }
-  void set_backend_set(const BackendSet& backend_set) {
-    if (signature_ == nullptr) {
-      signature_.reset(new TensorSignature());
-    }
-    signature_->backend_set = backend_set;
-  }
-
-  bool is_cpu() const { return signature_->backend_set.Has(Backend::CPU); }
-  bool is_cuda() const { return signature_->backend_set.Has(Backend::CUDA); }
+  bool is_cpu() const { return paddle::platform::is_cpu_place(place()); }
+  bool is_cuda() const { return paddle::platform::is_gpu_place(place()); }
 
   /**
    * Backend convert APIs.
@@ -211,11 +201,11 @@ class Tensor final {
   }
 
   /* Part 7: Autograd methods */
-  AutogradMetaInterface* get_autograd_meta() const {
+  AbstractAutogradMeta* get_autograd_meta() const {
     return autograd_meta_.get();
   }
 
-  void set_autograd_meta(std::shared_ptr<AutogradMetaInterface> autograd_meta) {
+  void set_autograd_meta(std::shared_ptr<AbstractAutogradMeta> autograd_meta) {
     autograd_meta_ = std::move(autograd_meta);
   }
 
@@ -244,7 +234,7 @@ class Tensor final {
   std::shared_ptr<pten::TensorBase> impl_;
 
   /**
-   * [ Why need abstract AutogradMetaInterface here? ]
+   * [ Why need abstract AbstractAutogradMeta here? ]
    *
    * Dynamic graphs need to hold backward information
    *
@@ -254,17 +244,13 @@ class Tensor final {
    *    information, not Tensor data description-related information.
    * 2. Kernel calculation does not require AutogradMeta.
    */
-  std::shared_ptr<AutogradMetaInterface> autograd_meta_{nullptr};
+  std::shared_ptr<AbstractAutogradMeta> autograd_meta_{nullptr};
 
   /**
-   * TensorSignature is used to store auxiliary description information
-   * needed by Tensor.
-   *
-   * The currently stored information includes:
-   * 1. name: used for Debug analysis in the development of new dygraph.
-   * 2. backend_set: used by the API to determine the kernel backend.
+   * Tensor name: used for adapt original execution mechanism and debug analysis
+   * in the development of new dygraph.
    */
-  std::shared_ptr<TensorSignature> signature_{nullptr};
+  std::string name_;
 };
 
 }  // namespace experimental

paddle/pten/hapi/lib/creation.cc

@@ -56,7 +56,6 @@ Tensor full_like(const Tensor& x,
       std::make_shared<pten::DenseTensor>(out_meta, pten::TensorStatus());
   kernel_context.EmplaceBackOutput(dense_out);
   out.set_impl(dense_out);
-  out.set_backend_set(x.backend_set());
 
   // 6. Call kernel
   kernel(&kernel_context);

paddle/pten/hapi/lib/kernel_dispatch.h

@@ -24,6 +24,7 @@ limitations under the License. */
 #include "paddle/pten/hapi/include/tensor.h"
 
 // TODO(chenweihang): split KernelName, Key, Kernel, Factory into diff files
+#include "paddle/pten/core/convert_utils.h"
 #include "paddle/pten/core/kernel_factory.h"
 
 // See Note [ Why still include the fluid headers? ]
@@ -39,6 +40,19 @@ using CUDAContext = paddle::platform::CUDADeviceContext;
 #endif
 
 namespace detail {
+BackendSet GetTensorBackendSet(const Tensor& t) {
+  BackendSet backend_set(pten::TransToPtenBackend(t.place()));
+  switch (t.layout()) {
+    case DataLayout::MKLDNN:
+      backend_set = backend_set | BackendSet(Backend::MKLDNN);
+      break;
+    default:
+      // do nothing
+      break;
+  }
+  return backend_set;
+}
+
 std::size_t CountLeadingZeros(uint64_t val) {
   if (val == 0) {
     return 64;
@@ -102,7 +116,7 @@ struct KernelKeyParser : ArgsIterator<KernelKeyParser> {
   // TODO(chenweihang): deal with multiple diff input Tensors
   // TODO(chenweihang): add global device guard method to set backend
   void operator()(const Tensor& x) {
-    key_set.backend_set = key_set.backend_set | x.backend_set();
+    key_set.backend_set = key_set.backend_set | detail::GetTensorBackendSet(x);
     // TODO(chenweihang): selecte multi layout and dtype
     key_set.layout = x.layout();
     key_set.dtype = x.type();

paddle/pten/hapi/lib/linalg.cc

@@ -56,7 +56,6 @@ Tensor dot(const Tensor& x, const Tensor& y) {
       std::make_shared<pten::DenseTensor>(out_meta, pten::TensorStatus());
   kernel_context.EmplaceBackOutput(dense_out);
   out.set_impl(dense_out);
-  out.set_backend_set(x.backend_set());
 
   // 6. Call kernel
   kernel(&kernel_context);

paddle/pten/hapi/lib/manipulation.cc

@@ -50,7 +50,6 @@ Tensor flatten(const Tensor& x, int start_axis, int stop_axis) {
       std::make_shared<pten::DenseTensor>(out_meta, pten::TensorStatus());
   kernel_context.EmplaceBackOutput(dense_out);
   out.set_impl(dense_out);
-  out.set_backend_set(x.backend_set());
 
   // 6. Call kernel
   kernel(&kernel_context);

paddle/pten/hapi/lib/math.cc

@@ -50,7 +50,6 @@ Tensor mean(const Tensor& x) {
       std::make_shared<pten::DenseTensor>(out_meta, pten::TensorStatus());
   kernel_context.EmplaceBackOutput(dense_out);
   out.set_impl(dense_out);
-  out.set_backend_set(x.backend_set());
 
   // 6. Call kernel
   kernel(&kernel_context);