Add call stack info during runtime and compile time

test=develop

paddle/fluid/framework/CMakeLists.txt

@@ -124,7 +124,7 @@ cc_library(shape_inference SRCS shape_inference.cc DEPS ddim attribute device_co
 cc_library(transfer_scope_cache SRCS transfer_scope_cache.cc DEPS scope framework_proto device_context)
 cc_library(op_kernel_type SRCS op_kernel_type.cc DEPS device_context place)
 cc_library(operator SRCS operator.cc DEPS op_info device_context tensor scope glog
-    shape_inference data_transform lod_tensor profiler transfer_scope_cache op_kernel_type)
+    shape_inference data_transform lod_tensor profiler transfer_scope_cache op_kernel_type operator_call_stack)
 
 cc_test(operator_test SRCS operator_test.cc DEPS operator op_registry device_context)
 
@@ -135,6 +135,8 @@ cc_library(proto_desc SRCS var_desc.cc op_desc.cc block_desc.cc program_desc.cc
 
 cc_library(op_registry SRCS op_registry.cc DEPS op_proto_maker op_info operator glog proto_desc)
 
+cc_library(operator_call_stack SRCS operator_call_stack.cc DEPS op_proto_maker enforce)
+
 nv_test(op_registry_test SRCS op_registry_test.cc DEPS op_registry)
 
 py_proto_compile(framework_py_proto SRCS framework.proto data_feed.proto)

paddle/fluid/framework/op_desc.cc

@@ -18,10 +18,12 @@ limitations under the License. */
 #include <mutex>  // NOLINT
 #include <string>
 #include <unordered_map>
+#include <utility>
 #include "glog/logging.h"
 #include "paddle/fluid/framework/block_desc.h"
 #include "paddle/fluid/framework/op_proto_maker.h"
 #include "paddle/fluid/framework/operator.h"
+#include "paddle/fluid/framework/operator_call_stack.h"
 #include "paddle/fluid/framework/program_desc.h"
 #include "paddle/fluid/framework/shape_inference.h"
 #include "paddle/fluid/framework/var_type_inference.h"
@@ -679,26 +681,33 @@ void OpDesc::CheckAttrs() {
 }
 
 void OpDesc::InferShape(const BlockDesc &block) const {
-  VLOG(3) << "CompileTime infer shape on " << Type();
-  InitInferShapeFuncs();
-  auto &infer_shape = OpInfoMap::Instance().Get(this->Type()).infer_shape_;
-  PADDLE_ENFORCE(static_cast<bool>(infer_shape),
-                 "%s's infer_shape has not been registered", this->Type());
-  CompileTimeInferShapeContext ctx(*this, block);
-  if (VLOG_IS_ON(10)) {
-    std::ostringstream sout;
-    auto inames = this->InputArgumentNames();
-    sout << " From [";
-    std::copy(inames.begin(), inames.end(),
-              std::ostream_iterator<std::string>(sout, ", "));
-    sout << "] to [";
-    auto onames = this->OutputArgumentNames();
-    std::copy(onames.begin(), onames.end(),
-              std::ostream_iterator<std::string>(sout, ", "));
-    sout << "]";
-    VLOG(10) << sout.str();
-  }
-  infer_shape(&ctx);
+  try {
+    VLOG(3) << "CompileTime infer shape on " << Type();
+    InitInferShapeFuncs();
+    auto &infer_shape = OpInfoMap::Instance().Get(this->Type()).infer_shape_;
+    PADDLE_ENFORCE(static_cast<bool>(infer_shape),
+                   "%s's infer_shape has not been registered", this->Type());
+    CompileTimeInferShapeContext ctx(*this, block);
+    if (VLOG_IS_ON(10)) {
+      std::ostringstream sout;
+      auto inames = this->InputArgumentNames();
+      sout << " From [";
+      std::copy(inames.begin(), inames.end(),
+                std::ostream_iterator<std::string>(sout, ", "));
+      sout << "] to [";
+      auto onames = this->OutputArgumentNames();
+      std::copy(onames.begin(), onames.end(),
+                std::ostream_iterator<std::string>(sout, ", "));
+      sout << "]";
+      VLOG(10) << sout.str();
+    }
+    infer_shape(&ctx);
+  } catch (platform::EnforceNotMet exception) {
+    framework::InsertCallStackInfo(Type(), attrs_, &exception);
+    throw std::move(exception);
+  } catch (...) {
+    std::rethrow_exception(std::current_exception());
+  }
 }
 
 void OpDesc::InferVarType(BlockDesc *block) const {

paddle/fluid/framework/operator.cc

@@ -25,6 +25,7 @@ limitations under the License. */
 #include "paddle/fluid/framework/lod_tensor.h"
 #include "paddle/fluid/framework/op_proto_maker.h"
 #include "paddle/fluid/framework/operator.h"
+#include "paddle/fluid/framework/operator_call_stack.h"
 #include "paddle/fluid/framework/shape_inference.h"
 #include "paddle/fluid/framework/transfer_scope_cache.h"
 #include "paddle/fluid/framework/var_type.h"
@@ -186,29 +187,9 @@ void OperatorBase::Run(const Scope& scope, const platform::Place& place) {
     } else {
       RunImpl(scope, place);
     }
-
     VLOG(3) << place << " " << DebugStringEx(&scope);
   } catch (platform::EnforceNotMet exception) {
-    if (Attrs().count("sub_block") != 0) {
-      throw std::move(exception);
-    }
-
-    auto& callstack = Attr<std::vector<std::string>>(
-        OpProtoAndCheckerMaker::OpCreationCallstackAttrName());
-
-    if (callstack.empty()) {
-      throw std::move(exception);
-    }
-    std::ostringstream sout;
-    sout << "Invoke operator " << Type() << " error.\n";
-    sout << "Python Callstacks: \n";
-    for (auto& line : callstack) {
-      sout << line;
-    }
-    sout << "C++ Callstacks: \n";
-    sout << exception.err_str_;
-    exception.err_str_ = sout.str();
-    throw std::move(exception);
+    framework::InsertCallStackInfo(Type(), Attrs(), &exception);
   } catch (...) {
     std::rethrow_exception(std::current_exception());
   }

paddle/fluid/framework/operator_call_stack.cc

@@ -0,0 +1,47 @@
+/* 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 "paddle/fluid/framework/operator_call_stack.h"
+#include <string>
+#include <vector>
+#include "paddle/fluid/framework/attribute.h"
+#include "paddle/fluid/framework/op_proto_maker.h"
+
+namespace paddle {
+namespace framework {
+
+void InsertCallStackInfo(const std::string &type, const AttributeMap &attrs,
+                         platform::EnforceNotMet *exception) {
+  if (attrs.count("sub_block") != 0) {
+    return;
+  }
+  auto &callstack = boost::get<std::vector<std::string>>(
+      attrs.at(OpProtoAndCheckerMaker::OpCreationCallstackAttrName()));
+
+  if (callstack.empty()) {
+    return;
+  }
+  std::ostringstream sout;
+  sout << "Invoke operator " << type << " error.\n";
+  sout << "Python Call stacks: \n";
+  for (auto &line : callstack) {
+    sout << line;
+  }
+  sout << "C++ Call stacks: \n";
+  sout << exception->err_str_;
+  exception->err_str_ = sout.str();
+}
+
+}  // namespace framework
+}  // namespace paddle

paddle/fluid/framework/operator_call_stack.h

@@ -0,0 +1,26 @@
+/* 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 <string>
+#include "paddle/fluid/framework/type_defs.h"
+#include "paddle/fluid/platform/enforce.h"
+
+namespace paddle {
+namespace framework {
+void InsertCallStackInfo(const std::string &type, const AttributeMap &attrs,
+                         platform::EnforceNotMet *exception);
+}  // namespace framework
+}  // namespace paddle