Branch 145436800

RELEASE.md

@@ -59,6 +59,8 @@
   behavior by specifying the attribute dct_method='INTEGER_ACCURATE'.
 * `tf.complex_abs` has been removed from the Python interface. `tf.abs`
   supports complex tensors and should be used instead.
+* In the C++ API (in tensorflow/cc), Input, Output, etc. have moved
+  from the tensorflow::ops namespace to tensorflow.
 
 # Release 0.12.0
 

tensorflow/BUILD

@@ -24,7 +24,7 @@ config_setting(
     name = "android_arm",
     values = {
         "crosstool_top": "//external:android/crosstool",
-        "android_cpu": "armeabi-v7a",
+        "cpu": "armeabi-v7a",
     },
     visibility = ["//visibility:public"],
 )
@@ -33,7 +33,7 @@ config_setting(
     name = "android_arm64",
     values = {
         "crosstool_top": "//external:android/crosstool",
-        "android_cpu": "arm64-v8a",
+        "cpu": "arm64-v8a",
     },
     visibility = ["//visibility:public"],
 )

tensorflow/c/c_api.cc

@@ -76,6 +76,7 @@ using tensorflow::SessionOptions;
 using tensorflow::Status;
 using tensorflow::Tensor;
 using tensorflow::TensorBuffer;
+using tensorflow::TensorId;
 using tensorflow::TensorShape;
 using tensorflow::TensorShapeProto;
 
@@ -1667,30 +1668,86 @@ void TF_ImportGraphDefOptionsSetPrefix(TF_ImportGraphDefOptions* opts,
   opts->opts.prefix = prefix;
 }
 
+namespace {
+
+TensorId ToTensorId(const TF_Output& output) {
+  return TensorId(output.oper->node.name(), output.index);
+}
+
+}  // namespace
+
+void TF_ImportGraphDefOptionsAddInputMapping(TF_ImportGraphDefOptions* opts,
+                                             const char* src_name,
+                                             int src_index, TF_Output dst) {
+  opts->opts.input_map[TensorId(src_name, src_index)] = ToTensorId(dst);
+}
+
+extern void TF_ImportGraphDefOptionsAddControlDependency(
+    TF_ImportGraphDefOptions* opts, TF_Operation* oper) {
+  opts->opts.control_dependencies.push_back(oper->node.name());
+}
+
+void TF_ImportGraphDefOptionsAddReturnOutput(TF_ImportGraphDefOptions* opts,
+                                             const char* oper_name, int index) {
+  opts->opts.return_tensors.push_back({oper_name, index});
+}
+
+int TF_ImportGraphDefOptionsNumReturnOutputs(
+    const TF_ImportGraphDefOptions* opts) {
+  return opts->opts.return_tensors.size();
+}
+
 static void GraphImportGraphDefLocked(TF_Graph* graph, const GraphDef& def,
                                       const TF_ImportGraphDefOptions* opts,
-                                      TF_Status* status)
+                                      TF_Output* return_outputs,
+                                      int num_return_outputs, TF_Status* status)
     EXCLUSIVE_LOCKS_REQUIRED(graph->mu) {
+  if (num_return_outputs != opts->opts.return_tensors.size()) {
+    status->status = InvalidArgument("Expected 'num_return_outputs' to be ",
+                                     opts->opts.return_tensors.size(), ", got ",
+                                     num_return_outputs);
+    return;
+  }
+  if (num_return_outputs > 0 && return_outputs == nullptr) {
+    status->status = InvalidArgument(
+        "'return_outputs' must be preallocated to length ", num_return_outputs);
+    return;
+  }
   const int last_node_id = graph->graph.num_node_ids();
-  status->status = tensorflow::ImportGraphDef(opts->opts, def, &graph->graph,
-                                              &graph->refiner);
+  std::vector<std::pair<Node*, int>> return_outputs_vec;
+  status->status = tensorflow::ImportGraphDef(
+      opts->opts, def, &graph->graph, &graph->refiner, &return_outputs_vec);
   if (!status->status.ok()) return;
   for (int i = last_node_id; i < graph->graph.num_node_ids(); ++i) {
     auto* node = graph->graph.FindNodeId(i);
     if (node != nullptr) graph->name_map[node->name()] = node;
   }
+  DCHECK_EQ(return_outputs_vec.size(), num_return_outputs);
+  for (int i = 0; i < num_return_outputs; ++i) {
+    return_outputs[i].oper = ToOperation(return_outputs_vec[i].first);
+    return_outputs[i].index = return_outputs_vec[i].second;
+  }
 }
 
-void TF_GraphImportGraphDef(TF_Graph* graph, const TF_Buffer* graph_def,
-                            const TF_ImportGraphDefOptions* opts,
-                            TF_Status* status) {
+void TF_GraphImportGraphDefWithReturnOutputs(
+    TF_Graph* graph, const TF_Buffer* graph_def,
+    const TF_ImportGraphDefOptions* opts, TF_Output* return_outputs,
+    int num_return_outputs, TF_Status* status) {
   GraphDef def;
   if (!def.ParseFromArray(graph_def->data, graph_def->length)) {
     status->status = InvalidArgument("Invalid GraphDef");
     return;
   }
   mutex_lock l(graph->mu);
-  GraphImportGraphDefLocked(graph, def, opts, status);
+  GraphImportGraphDefLocked(graph, def, opts, return_outputs,
+                            num_return_outputs, status);
+}
+
+void TF_GraphImportGraphDef(TF_Graph* graph, const TF_Buffer* graph_def,
+                            const TF_ImportGraphDefOptions* options,
+                            TF_Status* status) {
+  TF_GraphImportGraphDefWithReturnOutputs(graph, graph_def, options, nullptr, 0,
+                                          status);
 }
 
 // TF_Session functions ----------------------------------------------
@@ -1750,7 +1807,7 @@ TF_Session* TF_LoadSessionFromSavedModel(
   // GraphDefs, return the Graph generated in LoadSavedModel().
   TF_ImportGraphDefOptions* import_opts = TF_NewImportGraphDefOptions();
   GraphImportGraphDefLocked(graph, bundle.meta_graph_def.graph_def(),
-                            import_opts, status);
+                            import_opts, nullptr, 0, status);
   TF_DeleteImportGraphDefOptions(import_opts);
   if (TF_GetCode(status) != TF_OK) return nullptr;
 

tensorflow/c/c_api.h

@@ -160,7 +160,7 @@ extern const char* TF_Message(const TF_Status* s);
 // By default, TF_Buffer itself does not do any memory management of the
 // pointed-to block.  If need be, users of this struct should specify how to
 // deallocate the block by setting the `data_deallocator` function pointer.
-typedef struct {
+typedef struct TF_Buffer {
   const void* data;
   size_t length;
   void (*data_deallocator)(void* data, size_t length);
@@ -594,7 +594,7 @@ typedef enum {
 } TF_AttrType;
 
 // TF_AttrMetadata describes the value of an attribute on an operation.
-typedef struct {
+typedef struct TF_AttrMetadata {
   // A boolean: 1 if the attribute value is a list, 0 otherwise.
   unsigned char is_list;
 
@@ -801,7 +801,42 @@ extern void TF_DeleteImportGraphDefOptions(TF_ImportGraphDefOptions* opts);
 extern void TF_ImportGraphDefOptionsSetPrefix(TF_ImportGraphDefOptions* opts,
                                               const char* prefix);
 
+// Set any imported nodes with input `src_name:src_index` to have that input
+// replaced with `dst`. `src_name` refers to a node in the graph to be imported,
+// `dst` references a node already existing in the graph being imported into.
+extern void TF_ImportGraphDefOptionsAddInputMapping(
+    TF_ImportGraphDefOptions* opts, const char* src_name, int src_index,
+    TF_Output dst);
+
+// Cause the imported graph to have a control dependency on `oper`. `oper`
+// should exist in the graph being imported into.
+extern void TF_ImportGraphDefOptionsAddControlDependency(
+    TF_ImportGraphDefOptions* opts, TF_Operation* oper);
+
+// Add an output in `graph_def` to be returned via the `return_outputs` output
+// parameter of TF_GraphImportGraphDef(). If the output is remapped via an input
+// mapping, the corresponding existing tensor in `graph` will be returned.
+extern void TF_ImportGraphDefOptionsAddReturnOutput(
+    TF_ImportGraphDefOptions* opts, const char* oper_name, int index);
+
+// Returns the number of return outputs added via
+// TF_ImportGraphDefOptionsAddReturnOutput().
+extern int TF_ImportGraphDefOptionsNumReturnOutputs(
+    const TF_ImportGraphDefOptions* opts);
+
+// Import the graph serialized in `graph_def` into `graph`.
+//
+// `num_return_outputs` must be the number of return outputs added (i.e. the
+// result of TF_ImportGraphDefOptionsNumReturnOutputs()).  If
+// `num_return_outputs` is non-zero, `return_outputs` must be of length
+// `num_return_outputs`. Otherwise it can be null.
+extern void TF_GraphImportGraphDefWithReturnOutputs(
+    TF_Graph* graph, const TF_Buffer* graph_def,
+    const TF_ImportGraphDefOptions* options, TF_Output* return_outputs,
+    int num_return_outputs, TF_Status* status);
+
 // Import the graph serialized in `graph_def` into `graph`.
+// Convenience function for when no return outputs have been added.
 extern void TF_GraphImportGraphDef(TF_Graph* graph, const TF_Buffer* graph_def,
                                    const TF_ImportGraphDefOptions* options,
                                    TF_Status* status);

tensorflow/c/c_api_test.cc

@@ -675,9 +675,12 @@ TEST(CAPI, ImportGraphDef) {
   Placeholder(graph, s);
   ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);
   ASSERT_TRUE(TF_GraphOperationByName(graph, "feed") != nullptr);
-  ScalarConst(3, graph, s);
+  TF_Operation* oper = ScalarConst(3, graph, s);
   ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);
   ASSERT_TRUE(TF_GraphOperationByName(graph, "scalar") != nullptr);
+  Neg(oper, graph, s);
+  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);
+  ASSERT_TRUE(TF_GraphOperationByName(graph, "neg") != nullptr);
 
   // Export to a GraphDef
   TF_Buffer* graph_def = TF_NewBuffer();
@@ -692,13 +695,78 @@ TEST(CAPI, ImportGraphDef) {
   TF_GraphImportGraphDef(graph, graph_def, opts, s);
   ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);
 
-  TF_DeleteImportGraphDefOptions(opts);
-  TF_DeleteBuffer(graph_def);
-
   TF_Operation* scalar = TF_GraphOperationByName(graph, "imported/scalar");
   TF_Operation* feed = TF_GraphOperationByName(graph, "imported/feed");
+  TF_Operation* neg = TF_GraphOperationByName(graph, "imported/neg");
   ASSERT_TRUE(scalar != nullptr);
   ASSERT_TRUE(feed != nullptr);
+  ASSERT_TRUE(neg != nullptr);
+
+  // Import it again, with an input mapping and return outputs, into the same
+  // graph.
+  TF_DeleteImportGraphDefOptions(opts);
+  opts = TF_NewImportGraphDefOptions();
+  TF_ImportGraphDefOptionsSetPrefix(opts, "imported2");
+  TF_ImportGraphDefOptionsAddInputMapping(opts, "scalar", 0, {scalar, 0});
+  TF_ImportGraphDefOptionsAddReturnOutput(opts, "feed", 0);
+  TF_ImportGraphDefOptionsAddReturnOutput(opts, "scalar", 0);
+  EXPECT_EQ(2, TF_ImportGraphDefOptionsNumReturnOutputs(opts));
+  TF_Output return_outputs[2];
+  TF_GraphImportGraphDefWithReturnOutputs(graph, graph_def, opts,
+                                          return_outputs, 2, s);
+  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);
+
+  TF_Operation* scalar2 = TF_GraphOperationByName(graph, "imported2/scalar");
+  TF_Operation* feed2 = TF_GraphOperationByName(graph, "imported2/feed");
+  TF_Operation* neg2 = TF_GraphOperationByName(graph, "imported2/neg");
+  ASSERT_TRUE(scalar2 != nullptr);
+  ASSERT_TRUE(feed2 != nullptr);
+  ASSERT_TRUE(neg2 != nullptr);
+
+  // Check input mapping
+  TF_Output neg_input = TF_OperationInput({neg, 0});
+  EXPECT_EQ(scalar, neg_input.oper);
+  EXPECT_EQ(0, neg_input.index);
+
+  // Check return outputs
+  EXPECT_EQ(feed2, return_outputs[0].oper);
+  EXPECT_EQ(0, return_outputs[0].index);
+  EXPECT_EQ(scalar, return_outputs[1].oper);  // remapped
+  EXPECT_EQ(0, return_outputs[1].index);
+
+  // Import again, with control dependencies, into the same graph.
+  TF_DeleteImportGraphDefOptions(opts);
+  opts = TF_NewImportGraphDefOptions();
+  TF_ImportGraphDefOptionsSetPrefix(opts, "imported3");
+  TF_ImportGraphDefOptionsAddControlDependency(opts, feed);
+  TF_ImportGraphDefOptionsAddControlDependency(opts, feed2);
+  TF_GraphImportGraphDef(graph, graph_def, opts, s);
+  ASSERT_EQ(TF_OK, TF_GetCode(s)) << TF_Message(s);
+
+  TF_Operation* scalar3 = TF_GraphOperationByName(graph, "imported3/scalar");
+  TF_Operation* feed3 = TF_GraphOperationByName(graph, "imported3/feed");
+  TF_Operation* neg3 = TF_GraphOperationByName(graph, "imported3/neg");
+  ASSERT_TRUE(scalar3 != nullptr);
+  ASSERT_TRUE(feed3 != nullptr);
+  ASSERT_TRUE(neg3 != nullptr);
+
+  // Check that newly-imported scalar and feed have control deps (neg3 will
+  // inherit them from input)
+  TF_Operation* control_inputs[100];
+  int num_control_inputs = TF_OperationGetControlInputs(
+      scalar3, control_inputs, TF_OperationNumControlInputs(scalar3));
+  ASSERT_EQ(2, num_control_inputs);
+  EXPECT_EQ(feed, control_inputs[0]);
+  EXPECT_EQ(feed2, control_inputs[1]);
+
+  num_control_inputs = TF_OperationGetControlInputs(
+      feed3, control_inputs, TF_OperationNumControlInputs(feed3));
+  ASSERT_EQ(2, num_control_inputs);
+  EXPECT_EQ(feed, control_inputs[0]);
+  EXPECT_EQ(feed2, control_inputs[1]);
+
+  TF_DeleteImportGraphDefOptions(opts);
+  TF_DeleteBuffer(graph_def);
 
   // Can add nodes to the imported graph without trouble.
   Add(feed, scalar, graph, s);

tensorflow/cc/client/client_session.cc

@@ -32,8 +32,11 @@ ClientSession::ClientSession(const Scope& scope) : ClientSession(scope, "") {}
 
 ClientSession::ClientSession(const Scope& scope,
                              const SessionOptions& session_options)
-    : session_(NewSession(session_options)),
-      graph_(scope.graph_as_shared_ptr()) {
+    : graph_(scope.graph_as_shared_ptr()) {
+  Session* new_session;
+  Status status = NewSession(session_options, &new_session);
+  TF_CHECK_OK(status) << status;
+  session_.reset(new_session);
   CHECK_NOTNULL(session_.get());
 }
 

tensorflow/cc/framework/ops.h

@@ -284,19 +284,6 @@ class InputList {
   std::vector<Input> inputs_;
 };
 
-// These symbols used to live in the ops namespace, so we temporarily
-// declare some aliases there. TODO(josh11b): Delete this!
-namespace ops {
-
-using ::tensorflow::Input;
-using ::tensorflow::InputList;
-using ::tensorflow::Operation;
-using ::tensorflow::Output;
-using ::tensorflow::OutputHash;
-using ::tensorflow::OutputList;
-
-}  // namespace ops
-
 }  // namespace tensorflow
 
 #endif  // THIRD_PARTY_TENSORFLOW_CC_FRAMEWORK_OPS_H_

tensorflow/cc/saved_model/BUILD

@@ -48,7 +48,6 @@ tf_cc_test(
         ":saved_model_half_plus_two",
     ],
     linkstatic = 1,
-    tags = ["manual"],
     deps = [
         ":constants",
         ":loader",

tensorflow/compiler/jit/mark_for_compilation_pass.cc

@@ -42,9 +42,6 @@ const char* const kXlaClusterAttr = "_XlaCluster";
 namespace {
 
 bool HasXLAKernel(const Node& node, const DeviceType& jit_device_type) {
-  // _Send and _Recv should not be marked for compilation.
-  if (node.IsSend() || node.IsRecv()) return false;
-
   // There is a SymbolicGradient kernel on the XLA_JIT device, but the gradient
   // is really a kind of function call and will be handled by
   // IsCompilableCall().

tensorflow/compiler/jit/xla_device_ops.cc

@@ -29,8 +29,8 @@ void XlaDeviceAssignOp::Copy(OpKernelContext* context, Tensor* lhs,
 XlaDeviceDummyOp::XlaDeviceDummyOp(OpKernelConstruction* ctx) : OpKernel(ctx) {}
 
 void XlaDeviceDummyOp::Compute(OpKernelContext* ctx) {
-  LOG(FATAL) << "Attempted to execute Op " << name() << "type " << type_string()
-             << " on an XLA device. This should never happen.";
+  LOG(FATAL) << "Attempted to execute Op " << name() << " type "
+             << type_string() << " on an XLA device. This should never happen.";
 }
 
 }  // namespace tensorflow

tensorflow/compiler/tests/BUILD

@@ -70,7 +70,7 @@ tf_xla_py_test(
 
 tf_xla_py_test(
     name = "concat_ops_test",
-    size = "small",
+    size = "medium",
     srcs = ["concat_ops_test.py"],
     deps = [
         ":xla_test",