chore: import upstream snapshot with attribution

tensorflow/cc/saved_model/experimental/public/BUILD

@@ -0,0 +1,85 @@
+# Experimental C++ SavedModel Header Only APIs. See RFC
+# https://github.com/tensorflow/community/pull/207
+
+load("//tensorflow/core/platform:rules_cc.bzl", "cc_library")
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:license"],
+    # This is intentionally public
+    default_visibility = [
+        "//visibility:public",
+    ],
+    licenses = ["notice"],
+)
+
+cc_library(
+    name = "concrete_function",
+    hdrs = [
+        "concrete_function.h",
+    ],
+    deps = [
+        ":function_metadata",
+        "//tensorflow/c/eager:c_api",
+        "//tensorflow/c/experimental/saved_model/public:concrete_function",
+        "//tensorflow/cc/experimental/base/public:status",
+    ],
+)
+
+cc_library(
+    name = "concrete_function_list",
+    hdrs = [
+        "concrete_function_list.h",
+    ],
+    deps = [
+        ":concrete_function",
+        "//tensorflow/c/experimental/saved_model/public:concrete_function_list",
+    ],
+)
+
+cc_library(
+    name = "function_metadata",
+    hdrs = [
+        "function_metadata.h",
+    ],
+    deps = [
+        "//tensorflow/c/experimental/saved_model/public:function_metadata",
+    ],
+)
+
+cc_library(
+    name = "saved_model_api",
+    hdrs = [
+        "saved_model_api.h",
+    ],
+    deps = [
+        ":concrete_function",
+        ":concrete_function_list",
+        ":signature_def_function",
+        "//tensorflow/c/experimental/saved_model/public:saved_model_api",
+        "//tensorflow/cc/experimental/base/public:runtime",
+        "//tensorflow/cc/experimental/base/public:status",
+    ],
+)
+
+cc_library(
+    name = "signature_def_function",
+    hdrs = [
+        "signature_def_function.h",
+    ],
+    deps = [
+        ":signature_def_function_metadata",
+        "//tensorflow/c/eager:c_api",
+        "//tensorflow/c/experimental/saved_model/public:signature_def_function",
+        "//tensorflow/cc/experimental/base/public:status",
+    ],
+)
+
+cc_library(
+    name = "signature_def_function_metadata",
+    hdrs = [
+        "signature_def_function_metadata.h",
+    ],
+    deps = [
+        "//tensorflow/c/experimental/saved_model/public:signature_def_function_metadata",
+    ],
+)

tensorflow/cc/saved_model/experimental/public/concrete_function.h

@@ -0,0 +1,61 @@
+/* Copyright 2020 The TensorFlow 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_CONCRETE_FUNCTION_H_
+#define TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_CONCRETE_FUNCTION_H_
+
+#include <vector>
+
+#include "tensorflow/c/eager/c_api.h"
+#include "tensorflow/c/experimental/saved_model/public/concrete_function.h"
+#include "tensorflow/cc/experimental/base/public/status.h"
+#include "tensorflow/cc/saved_model/experimental/public/function_metadata.h"
+
+namespace tensorflow {
+namespace experimental {
+namespace cc {
+
+// ConcreteFunction is an executable "function" loaded from a SavedModelAPI.
+class ConcreteFunction final {
+ public:
+  // TODO(bmzhao): Adding ConcreteFunction::Run in subsequent CL, since
+  // it depends on tensorflow::cc::Tensor and tensorflow::cc::TensorHandle
+
+  // Returns FunctionMetadata associated with this ConcreteFunction.
+  const FunctionMetadata* GetFunctionMetadata();
+
+ private:
+  friend class SavedModelAPI;
+  friend class ConcreteFunctionList;
+
+  // TODO(bmzhao): Consider adding a macro for wrapping/unwrapping
+  // when moving out of experimental.
+  static ConcreteFunction* wrap(TF_ConcreteFunction* p) {
+    return reinterpret_cast<ConcreteFunction*>(p);
+  }
+  static TF_ConcreteFunction* unwrap(ConcreteFunction* p) {
+    return reinterpret_cast<TF_ConcreteFunction*>(p);
+  }
+};
+
+inline const FunctionMetadata* ConcreteFunction::GetFunctionMetadata() {
+  return FunctionMetadata::wrap(TF_ConcreteFunctionGetMetadata(unwrap(this)));
+}
+
+}  // namespace cc
+}  // namespace experimental
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_CONCRETE_FUNCTION_H_

tensorflow/cc/saved_model/experimental/public/concrete_function_list.h

@@ -0,0 +1,63 @@
+/* Copyright 2020 The TensorFlow 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_CONCRETE_FUNCTION_LIST_H_
+#define TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_CONCRETE_FUNCTION_LIST_H_
+
+#include <vector>
+
+#include "tensorflow/c/experimental/saved_model/public/concrete_function_list.h"
+#include "tensorflow/cc/saved_model/experimental/public/concrete_function.h"
+
+namespace tensorflow {
+namespace experimental {
+namespace cc {
+
+// ConcreteFunctionList helps convert an opaque pointer to an array of
+// ConcreteFunction pointers to a std::vector.
+class ConcreteFunctionList {
+ public:
+  // Converts this object to a std::vector<ConcreteFunction*>
+  std::vector<ConcreteFunction*> ToVector();
+
+ private:
+  friend class SavedModelAPI;
+  // Wraps a TF_ConcreteFunctionList. Takes ownership of list.
+  explicit ConcreteFunctionList(TF_ConcreteFunctionList* list) : list_(list) {}
+
+  struct TFConcreteFunctionListDeleter {
+    void operator()(TF_ConcreteFunctionList* p) const {
+      TF_DeleteConcreteFunctionList(p);
+    }
+  };
+  std::unique_ptr<TF_ConcreteFunctionList, TFConcreteFunctionListDeleter> list_;
+};
+
+inline std::vector<ConcreteFunction*> ConcreteFunctionList::ToVector() {
+  int size = TF_ConcreteFunctionListSize(list_.get());
+  std::vector<ConcreteFunction*> result;
+  result.reserve(size);
+  for (int i = 0; i < size; ++i) {
+    result.push_back(
+        ConcreteFunction::wrap(TF_ConcreteFunctionListGet(list_.get(), i)));
+  }
+  return result;
+}
+
+}  // namespace cc
+}  // namespace experimental
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_CONCRETE_FUNCTION_LIST_H_

tensorflow/cc/saved_model/experimental/public/function_metadata.h

@@ -0,0 +1,47 @@
+/* Copyright 2020 The TensorFlow 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_FUNCTION_METADATA_H_
+#define TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_FUNCTION_METADATA_H_
+
+#include <memory>
+
+#include "tensorflow/c/experimental/saved_model/public/function_metadata.h"
+
+namespace tensorflow {
+namespace experimental {
+namespace cc {
+
+// FunctionMetadata stores additional function information, including
+// optional signaturedef feeds/fetches (for TF1-based ConcreteFunctions),
+// a valid function path (for TF2-based ConcreteFunctions), and
+// the types + number of inputs and outputs.
+class FunctionMetadata final {
+  // TODO(bmzhao): Add getters here as necessary.
+ private:
+  friend class ConcreteFunction;
+  static FunctionMetadata* wrap(TF_FunctionMetadata* p) {
+    return reinterpret_cast<FunctionMetadata*>(p);
+  }
+  static TF_FunctionMetadata* unwrap(FunctionMetadata* p) {
+    return reinterpret_cast<TF_FunctionMetadata*>(p);
+  }
+};
+
+}  // namespace cc
+}  // namespace experimental
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_FUNCTION_METADATA_H_

tensorflow/cc/saved_model/experimental/public/saved_model_api.h

@@ -0,0 +1,155 @@
+/* Copyright 2020 The TensorFlow 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_SAVED_MODEL_API_H_
+#define TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_SAVED_MODEL_API_H_
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+#include "tensorflow/c/experimental/saved_model/public/saved_model_api.h"
+#include "tensorflow/cc/experimental/base/public/runtime.h"
+#include "tensorflow/cc/experimental/base/public/status.h"
+#include "tensorflow/cc/saved_model/experimental/public/concrete_function.h"
+#include "tensorflow/cc/saved_model/experimental/public/concrete_function_list.h"
+#include "tensorflow/cc/saved_model/experimental/public/signature_def_function.h"
+
+namespace tensorflow {
+namespace experimental {
+namespace cc {
+
+// SavedModelAPI offers a way to load Tensorflow Saved Models
+// (https://www.tensorflow.org/guide/saved_model) and execute saved
+// tf.functions or legacy SignatureDefs in a TF2-idiomatic fashion.
+// See RFC 207
+// (https://github.com/tensorflow/community/blob/master/rfcs/20200218-tf-c-saved-model.md)
+// TODO(bmzhao): Add an e2e example here, once ConcreteFunction::Run is added.
+class SavedModelAPI {
+ public:
+  // Load a SavedModel from `dirname`.
+  //
+  // Params:
+  //  saved_model_path - A directory filepath that the SavedModel is at.
+  //  runtime - A runtime used to load SavedModelAPI. `runtime` must outlive the
+  //            returned TF_SavedModel pointer.
+  //  tags - Optional set of tags. If tags = nullptr, we expect the SavedModel
+  //         to contain a single Metagraph (as for those exported from TF2's
+  //         `tf.saved_model.save`). If tags != nullptr, we load the metagraph
+  //         matching the tags:
+  //         https://github.com/tensorflow/tensorflow/blob/428cdeda09aef81e958eeb274b83d27ad635b57b/tensorflow/core/protobuf/meta_graph.proto#L50-L56
+  //  status - Set to OK on success and an appropriate error on failure.
+  // Returns:
+  //  If status is not OK, returns nullptr.
+  static std::unique_ptr<SavedModelAPI> Load(
+      const std::string& saved_model_path, const Runtime& runtime,
+      Status* status, const std::unordered_set<std::string>* tags = nullptr);
+
+  // Retrieve a function from the TF2 SavedModel via function path.
+  //
+  // Params:
+  //  function_path - A string containing the path from the root saved python
+  //                  object to a tf.function method.
+  //  status - Set to OK on success and an appropriate error on failure.
+  // Returns:
+  //  If status is not OK, returns nullptr. Otherwise, returns a
+  //  tensorflow::cc::ConcreteFunction pointer. The lifetime of this pointer
+  //  is bound to SavedModelAPI it was loaded from.
+  ConcreteFunction* GetConcreteFunction(const std::string& function_path,
+                                        Status* status);
+
+  // Retrieve a function from the TF SavedModel via a SignatureDef key.
+  //
+  // Params:
+  //  signature_def_key - String key of SignatureDef map of a SavedModel:
+  //                      https://github.com/tensorflow/tensorflow/blob/69b08900b1e991d84bce31f3b404f5ed768f339f/tensorflow/core/protobuf/meta_graph.proto#L89
+  //  status - Set to OK on success and an appropriate error on failure.
+  // Returns:
+  //  If status is not OK, returns nullptr. Otherwise, returns a
+  //  tensorflow::cc::ConcreteFunction pointer. The lifetime of this pointer
+  //  is bound to SavedModelAPI it was loaded from.
+  SignatureDefFunction* GetSignatureDefFunction(
+      const std::string& function_path, Status* status);
+
+  // SavedModelAPI is movable, but not copyable.
+  SavedModelAPI(SavedModelAPI&&) = default;
+  SavedModelAPI& operator=(SavedModelAPI&&) = default;
+
+ private:
+  SavedModelAPI(const SavedModelAPI&) = delete;
+  SavedModelAPI& operator=(const SavedModelAPI&) = delete;
+
+  explicit SavedModelAPI(TF_SavedModel* model) : saved_model_(model) {}
+  struct TFSavedModelDeleter {
+    void operator()(TF_SavedModel* p) const { TF_DeleteSavedModel(p); }
+  };
+  std::unique_ptr<TF_SavedModel, TFSavedModelDeleter> saved_model_;
+};
+
+inline std::unique_ptr<SavedModelAPI> SavedModelAPI::Load(
+    const std::string& saved_model_path, const Runtime& runtime, Status* status,
+    const std::unordered_set<std::string>* tags) {
+  TF_SavedModel* saved_model = nullptr;
+
+  if (tags == nullptr) {
+    saved_model =
+        TF_LoadSavedModel(saved_model_path.c_str(), runtime.GetTFEContext(),
+                          status->GetTFStatus());
+  } else {
+    std::vector<const char*> tags_vector;
+    tags_vector.reserve(tags->size());
+    for (const std::string& tag : *tags) {
+      tags_vector.push_back(tag.c_str());
+    }
+    saved_model = TF_LoadSavedModelWithTags(
+        saved_model_path.c_str(), runtime.GetTFEContext(), tags_vector.data(),
+        tags_vector.size(), status->GetTFStatus());
+  }
+
+  if (!status->ok()) {
+    return nullptr;
+  }
+
+  // We can't use std::make_unique here because of its interaction with a
+  // private constructor: https://abseil.io/tips/134
+  return std::unique_ptr<SavedModelAPI>(new SavedModelAPI(saved_model));
+}
+
+inline ConcreteFunction* SavedModelAPI::GetConcreteFunction(
+    const std::string& function_path, Status* status) {
+  TF_ConcreteFunction* function = TF_GetSavedModelConcreteFunction(
+      saved_model_.get(), function_path.c_str(), status->GetTFStatus());
+  if (!status->ok()) {
+    return nullptr;
+  }
+  return ConcreteFunction::wrap(function);
+}
+
+inline SignatureDefFunction* SavedModelAPI::GetSignatureDefFunction(
+    const std::string& function_path, Status* status) {
+  TF_SignatureDefFunction* function = TF_GetSavedModelSignatureDefFunction(
+      saved_model_.get(), function_path.c_str(), status->GetTFStatus());
+  if (!status->ok()) {
+    return nullptr;
+  }
+  return SignatureDefFunction::wrap(function);
+}
+
+}  // namespace cc
+}  // namespace experimental
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_SAVED_MODEL_API_H_

tensorflow/cc/saved_model/experimental/public/signature_def_function.h

@@ -0,0 +1,89 @@
+/* Copyright 2020 The TensorFlow 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_SIGNATURE_DEF_FUNCTION_H_
+#define TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_SIGNATURE_DEF_FUNCTION_H_
+
+#include <vector>
+
+#include "tensorflow/c/eager/c_api.h"
+#include "tensorflow/c/experimental/saved_model/public/signature_def_function.h"
+#include "tensorflow/cc/experimental/base/public/status.h"
+#include "tensorflow/cc/saved_model/experimental/public/signature_def_function_metadata.h"
+
+namespace tensorflow {
+namespace experimental {
+namespace cc {
+
+// SignatureDefFunctions are functions that correspond to either:
+// "signatures" saved from a TF2 SavedModel APIs:
+// https://github.com/tensorflow/tensorflow/blob/8ce0600f58ed84a8c84a7bbdb014d1f09e44f4c8/tensorflow/python/saved_model/save.py#L830-L854
+// Or the "SignatureDefMap" saved from TF1 SavedModel APIs:
+// https://github.com/tensorflow/tensorflow/blob/8ce0600f58ed84a8c84a7bbdb014d1f09e44f4c8/tensorflow/python/saved_model/load_v1_in_v2_test.py#L170-L174
+// In both cases, a SignatureDef is serialized as a SignatureDef protobuf:
+// https://github.com/tensorflow/tensorflow/blob/8ce0600f58ed84a8c84a7bbdb014d1f09e44f4c8/tensorflow/core/protobuf/meta_graph.proto#L260-L330
+// and represents a computation defined by a TF subgraph.
+// These Signatures were primarily designed to be interoperable with the legacy
+// TF 1 Session-based C++ SavedModelBundle loading APIs:
+// https://github.com/tensorflow/tensorflow/blob/26c4ee0c833e74f94d0102d8b005c41a28b44445/tensorflow/cc/saved_model/loader.h#L96-L108
+// SignatureDefFunctions have different semantics from regular TF2
+// ConcreteFunctions, and are mainly intended provide a serving-friendly
+// transition point from the TF1 Session API.
+// First, SignatureDefFunctions have different calling conventions.
+// SignatureDefFunctions' inputs and outputs are constrained to **flattened
+// lists of TensorHandles only**. They do not support more exotic input/output
+// types (like optionals, generators, etc). Additionally, this flattening means
+// they will not preserve the exact interface of the original tf.function they
+// were traced from, as things like composite tensors decay into their
+// internal dense tensor representation.
+// Second, all inputs and outputs are "named", and these names are load bearing
+// (eg: they are part of the interface of tensorflow_serving):
+// https://github.com/tensorflow/serving/blob/e0d247b2e4050713194b8fad0be24a0636df7209/tensorflow_serving/apis/predict.proto#L21
+// https://github.com/tensorflow/serving/blob/e0d247b2e4050713194b8fad0be24a0636df7209/tensorflow_serving/apis/predict.proto#L39
+// The name of each input/output is stored in the corresponding tf::Argument in
+// SignatureDefFunctionMetadata::arguments(). Users must ensure the order of
+// TensorHandles passed to the function matches with the order of named
+// arguments. Similarly the name of the outputs is stored in
+// SignatureDefFunctionMetadata::returns().
+class SignatureDefFunction final {
+ public:
+  // Returns FunctionMetadata associated with this ConcreteFunction.
+  const SignatureDefFunctionMetadata* GetFunctionMetadata();
+
+ private:
+  friend class SavedModelAPI;
+  friend class ConcreteFunctionList;
+
+  // TODO(bmzhao): Consider adding a macro for wrapping/unwrapping
+  // when moving out of experimental.
+  static SignatureDefFunction* wrap(TF_SignatureDefFunction* p) {
+    return reinterpret_cast<SignatureDefFunction*>(p);
+  }
+  static TF_SignatureDefFunction* unwrap(SignatureDefFunction* p) {
+    return reinterpret_cast<TF_SignatureDefFunction*>(p);
+  }
+};
+
+inline const SignatureDefFunctionMetadata*
+SignatureDefFunction::GetFunctionMetadata() {
+  return SignatureDefFunctionMetadata::wrap(
+      TF_SignatureDefFunctionGetMetadata(unwrap(this)));
+}
+
+}  // namespace cc
+}  // namespace experimental
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_SIGNATURE_DEF_FUNCTION_H_

tensorflow/cc/saved_model/experimental/public/signature_def_function_metadata.h

@@ -0,0 +1,47 @@
+/* Copyright 2020 The TensorFlow 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.
+==============================================================================*/
+
+#ifndef TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_SIGNATURE_DEF_FUNCTION_METADATA_H_
+#define TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_SIGNATURE_DEF_FUNCTION_METADATA_H_
+
+#include <memory>
+
+#include "tensorflow/c/experimental/saved_model/public/signature_def_function_metadata.h"
+
+namespace tensorflow {
+namespace experimental {
+namespace cc {
+
+// SignatureDefFunctionMetadata stores additional information on each input
+// and output's names, dtypes, and shape.
+class SignatureDefFunctionMetadata final {
+  // TODO(bmzhao): Add getters here as necessary.
+ private:
+  friend class SignatureDefFunction;
+  static SignatureDefFunctionMetadata* wrap(
+      TF_SignatureDefFunctionMetadata* p) {
+    return reinterpret_cast<SignatureDefFunctionMetadata*>(p);
+  }
+  static TF_SignatureDefFunctionMetadata* unwrap(
+      SignatureDefFunctionMetadata* p) {
+    return reinterpret_cast<TF_SignatureDefFunctionMetadata*>(p);
+  }
+};
+
+}  // namespace cc
+}  // namespace experimental
+}  // namespace tensorflow
+
+#endif  // TENSORFLOW_CC_SAVED_MODEL_EXPERIMENTAL_PUBLIC_SIGNATURE_DEF_FUNCTION_METADATA_H_

tensorflow/cc/saved_model/experimental/tests/BUILD

@@ -0,0 +1,28 @@
+# Tests for the C++ header-only SavedModelAPI.
+load("//tensorflow:tensorflow.bzl", "tf_cc_test")
+
+package(
+    # copybara:uncomment default_applicable_licenses = ["//tensorflow:license"],
+    licenses = ["notice"],
+)
+
+tf_cc_test(
+    name = "saved_model_api_test",
+    srcs = [
+        "saved_model_api_test.cc",
+    ],
+    data = [
+        "//tensorflow/cc/saved_model:saved_model_half_plus_two",
+    ],
+    deps = [
+        "//tensorflow/c:tf_status_headers",
+        "//tensorflow/cc/experimental/base/public:runtime",
+        "//tensorflow/cc/experimental/base/public:runtime_builder",
+        "//tensorflow/cc/experimental/base/public:status",
+        "//tensorflow/cc/saved_model/experimental/public:saved_model_api",
+        "//tensorflow/core:lib",
+        "//tensorflow/core:test",
+        "//tensorflow/core:test_main",
+        "@com_google_absl//absl/strings:string_view",
+    ],
+)

tensorflow/cc/saved_model/experimental/tests/saved_model_api_test.cc

@@ -0,0 +1,98 @@
+/* Copyright 2020 The TensorFlow 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 "tensorflow/cc/saved_model/experimental/public/saved_model_api.h"
+
+#include <memory>
+#include <string>
+#include <unordered_set>
+
+#include "absl/strings/string_view.h"
+#include "tensorflow/c/tf_status.h"
+#include "tensorflow/cc/experimental/base/public/runtime.h"
+#include "tensorflow/cc/experimental/base/public/runtime_builder.h"
+#include "tensorflow/cc/experimental/base/public/status.h"
+#include "tensorflow/core/platform/path.h"
+#include "tensorflow/core/platform/stringpiece.h"
+#include "tensorflow/core/platform/test.h"
+
+
+namespace {
+
+using tensorflow::experimental::cc::Runtime;
+using tensorflow::experimental::cc::RuntimeBuilder;
+using tensorflow::experimental::cc::SavedModelAPI;
+using tensorflow::experimental::cc::Status;
+
+constexpr char kTestData[] = "cc/saved_model/testdata";
+
+std::string SavedModelPath(absl::string_view saved_model_dir) {
+  return tensorflow::io::JoinPath(tensorflow::testing::TensorFlowSrcRoot(),
+                                  kTestData, saved_model_dir);
+}
+
+// This value parameterized test allows us to test both TFRT
+// and non TFRT runtimes.
+// https://github.com/google/googletest/blob/dcc92d0ab6c4ce022162a23566d44f673251eee4/googletest/docs/advanced.md#value-parameterized-tests
+class CPPSavedModelAPITest : public ::testing::TestWithParam<bool> {};
+
+TEST_P(CPPSavedModelAPITest, LoadsSavedModelWithTags) {
+  Status status;
+  RuntimeBuilder builder;
+  bool use_tfrt = GetParam();
+  if (use_tfrt) {
+    GTEST_SKIP();  // TODO(chky) : Enable this once TFRT is open sourced.
+  }
+
+  builder.SetUseTFRT(use_tfrt);
+  std::unique_ptr<Runtime> runtime = builder.Build(&status);
+  ASSERT_TRUE(status.ok()) << status.message();
+
+  std::string model_dir = SavedModelPath("VarsAndArithmeticObjectGraph");
+  std::unordered_set<std::string> tags = {"serve"};
+  std::unique_ptr<SavedModelAPI> model =
+      SavedModelAPI::Load(model_dir, *runtime, &status, &tags);
+
+  // TODO(bmzhao): Change this to expect TF_OK when loading is implemented.
+  // That unblocks writing other tests that require a TF_SavedModel*,
+  // like loading a ConcreteFunction. This test at least checks that the
+  // C API builds and can be minimally run.
+  EXPECT_EQ(status.code(), TF_UNIMPLEMENTED);
+}
+
+TEST_P(CPPSavedModelAPITest, LoadsSavedModel) {
+  Status status;
+  RuntimeBuilder builder;
+  bool use_tfrt = GetParam();
+  if (use_tfrt) {
+    GTEST_SKIP();  // TODO(chky) : Enable this once TFRT is open sourced.
+  }
+
+  builder.SetUseTFRT(use_tfrt);
+  std::unique_ptr<Runtime> runtime = builder.Build(&status);
+  ASSERT_TRUE(status.ok()) << status.message();
+
+  std::string model_dir = SavedModelPath("VarsAndArithmeticObjectGraph");
+  std::unique_ptr<SavedModelAPI> model =
+      SavedModelAPI::Load(model_dir, *runtime, &status);
+
+  EXPECT_EQ(status.code(), TF_OK) << status.message();
+}
+
+INSTANTIATE_TEST_SUITE_P(RuntimeAgnosticCPPSavedModelTests,
+                         CPPSavedModelAPITest, ::testing::Bool());
+
+}  // namespace
+