// Sort `concrete_functions`, which is an unordered map from function names to
  // SavedConcreteFunction, using the suffix UID of the function name. Assumes
  // that the trackable children are listed in a deterministic order during
  // serialization.
  absl::btree_map<int64_t, std::string> uid_to_function_names;
  for (const auto& [name, concrete_function] :
       object_graph_def.concrete_functions()) {

    std::unique_ptr<TFConcreteFunction> concrete_function;
    TF_RETURN_IF_ERROR(TFConcreteFunction::Create(/*function_def=*/&function,
                                                  /*captures=*/{},
                                                  /*metadata=*/{},
                                                  /*ctx=*/context,
                                                  /*out=*/&concrete_function));

      func->setAttr(
          kTfSavedModelExportedNamesAttr,
          builder.getStrArrayAttr(object_names.GetExportedNames(node_id)));
      const SavedConcreteFunction& concrete_function =
          object_graph.concrete_functions().at(function.concrete_functions(0));

      // We do not handle the other element of this tuple, which corresponds to
      // Python kwonlyargs, since currently TensorFlow prohibits this in

      t->Unref();
    }
  });
  return Unflatten(outs, concrete_fn.output_signature);
}

StatusOr<Function::ConcreteFunction> Function::GetConcreteFunction(
    TaggedValue value) const {
  if (concrete_fns_.empty()) {
    return tensorflow::errors::FailedPrecondition(
        "No registered ConcreteFunctions.");
  }
  for (auto& spec : concrete_fns_) {
    if (Match(spec.input_signature, value)) {
      return spec;

        "//tensorflow/c:__subpackages__",
        "//tensorflow/c/experimental/saved_model/internal:__pkg__",
    ],
    licenses = ["notice"],
)

cc_library(
    name = "concrete_function",
    hdrs = [
        "concrete_function.h",
    ],
    deps = [
        ":function_metadata",
        "//tensorflow/c/eager:immediate_execution_operation",
        "//tensorflow/c/eager:immediate_execution_tensor_handle",

package(
    # copybara:uncomment default_applicable_licenses = ["//tensorflow:license"],
    licenses = ["notice"],
)

cc_library(
    name = "concrete_function",
    srcs = [
        "concrete_function.cc",
    ],
    hdrs = [
        "//tensorflow/c/experimental/saved_model/public:concrete_function.h",
    ],
    copts = tf_copts(),
    visibility = [

#include "tensorflow/c/experimental/saved_model/core/tf_saved_model_api.h"
#include "tensorflow/c/experimental/saved_model/internal/saved_model_api_type.h"
#include "tensorflow/c/experimental/saved_model/public/concrete_function.h"
#include "tensorflow/c/experimental/saved_model/public/signature_def_function.h"
#include "tensorflow/c/experimental/saved_model/public/signature_def_function_metadata.h"

* Introducing `tf.types.experimental.AtomicFunction` as the fastest way to perform TF computations in Python.

    * Can be accessed through `inference_fn` property of `ConcreteFunction`s
    * Does not support gradients.