# Description:

# TensorFlow is a computational framework, primarily for use in machine

# learning applications.

#

# Public targets:

#

# ":protos_all" - exports all core TensorFlow protos

# ":protos_all_py" - py_proto_library version (Google-internal)

# ":lib" - exports the public non-test headers for:

# //third_party/tensorflow/core/platform:: Platform-specific code and external dependencies

# lib/: Low-level libraries that are not TensorFlow-specific

# ":test" - test equivalent of ":lib".

# This is currently public, but may be made internal in the

# future. Try to avoid depending on it.

# ":framework" - exports the public non-test headers for:

# util/: General low-level TensorFlow-specific libraries

# framework/: Support for adding new ops & kernels

# example/: Wrappers to simplify access to Example proto

# //third_party/tensorflow/lite/kernels/shim: Template for writing ops supporting TF & TF Lite.

# ":ops" - defines TensorFlow ops, but no implementations / kernels

# ops/: Standard ops

# user_ops/: User-supplied ops

# This aggregates a number of smaller op libraries (":*_op_lib")

# ":core_cpu" - exports the public non-test headers for:

# graph/: Support for graphs made up of ops

# common_runtime/: Common code for execution of graphs

# public/: Public APIs for running graphs

# ":core" - The code for ":core_cpu" plus a GPU runtime

# ":all_kernels" - The cpu-specific kernels, plus gpu kernels if

# built with Cuda

# ":tensorflow_opensource" - The complete open-source package, including

# ":all_kernels", ":core", and a Session implementation.

# ":tensorflow" - "tensorflow_opensource" plus some Google-internal libraries.

# ":testlib" - TensorFlow-specific test support, e.g. utilities for testing

# kernels.

# ":direct_session" - An implementation of the Session interface that

# directly runs Graphs via the internal TensorFlow executor.

# "framework_lite" - Intended to be used by operator implementations

# (kernels) that can also be run outside the tensorflow runtime. This

# contains a small set of headers and utilities that can be used for core

# kernels, without bringing in libraries that can bloat code size (e.g.,

# logging is not included because using it will bring in a large amount of

# ostream code).

#

# ":example_parser_configuration" -- A library for extracting the

# tensorflow.Example proto configuration from a Graph.

#

# Public mobile targets, e.g. for Android:

#

# cc_library ":portable_tensorflow_lib" - Native library

# cc_library ":portable_tensorflow_lib_lite" - Native library, without ops,

# supporting SELECTIVE_REGISTRATION feature.

#

# Note that :framework and :lib have incomplete transitive dependencies (they

# declare but do not define some symbols) if framework_shared_object=True

# (meaning there is an explicit framework shared object). Missing symbols are

# included in //tensorflow:libtensorflow_framework.so. This split supports

# custom op registration; see comments on

# //tensorflow:libtensorflow_framework.so. It does mean that TensorFlow cc_test

# and cc_binary rules will not build. Using tf_cc_test and tf_cc_binary (from

# //tensorflow/tensorflow.bzl) will include the necessary symbols in binary

# build targets.

load("@com_google_protobuf//bazel:java_proto_library.bzl", "java_proto_library")

load("@local_config_cuda//cuda:build_defs.bzl", "if_cuda")

load("@local_config_tensorrt//:build_defs.bzl", "if_tensorrt")

load("@rules_python//python:proto.bzl", "py_proto_library")

load(

"@xla//xla/tsl/mkl:build_defs.bzl",

"if_mkl",

)

load(

"//tensorflow:tensorflow.bzl",

"if_android",

"if_cuda_or_rocm",

"if_google",

"if_ios",

"if_libtpu",

"if_mobile",

"if_nccl",

"tf_cc_test",

"tf_cc_test_mkl",

"tf_cc_tests",

"tf_copts",

"tf_cuda_library",

"tf_defines_nortti_if_lite_protos",

"tf_features_nomodules_if_mobile",

"tf_opts_nortti_if_lite_protos",

"transitive_hdrs",

)

load(

"//tensorflow:tensorflow.default.bzl",

"cc_header_only_library",

"custom_op_cc_header_only_library",

"filegroup",

"get_compatible_with_portable",

"tensorflow_opensource_extra_deps",

"tf_monitoring_framework_deps",

"tf_selective_registration_deps",

)

# For platform specific build config

load(

"//tensorflow/core/platform:build_config.bzl",

"tf_additional_lib_deps",

"tf_additional_test_deps",

"tf_dtensor_tpu_dependencies",

"tf_jspb_proto_library",

"tf_lib_proto_parsing_deps",

"tf_portable_deps_no_runtime",

"tf_portable_proto_lib",

"tf_proto_library",

"tf_protos_grappler_impl",

"tf_tpu_dependencies",

)

load(

"//tensorflow/core/platform:build_config_root.bzl",

"if_dynamic_kernels",

"if_static",

)

load(

"//tensorflow/core/platform:rules_cc.bzl",

"cc_library",

)

# load("//tools/build_defs/go:go_library.bzl", "go_library")

package(

# copybara:uncomment default_applicable_licenses = ["//tensorflow:license"],

default_visibility = [

":dependency_allowlist",

"//tensorflow:internal",

"//tensorflow_models:__subpackages__",

],

features = if_google([

"-parse_headers",

]),

licenses = ["notice"],

)

package_group(

name = "dependency_allowlist",

packages = [

"//learning/freud/topic_models/tensorflow/...",

"//learning/infra/mira/...",

"//perftools/accelerators/xprof/...",

"//quality/webanswers/brain/tokenization/custom_tf_ops/kernels/...",

"//smartass/brain/server/...",

"//third_party/neptune/...",

"//waymo/ml/deploy/benchmark/...",

],

)

# Export the BUILD file so automated tooling can check licenses

exports_files([

"BUILD",

])

# Authorized users go here.

package_group(

name = "friends",

packages = if_google([

"//learning/brain/...",

"//third_party/car/...",

"//tensorflow/...",

"@tf_runtime//...",

"//third_party/tf_runtime_google/...",

]),

)

# -----------------------------------------------------------------------------

# Public targets

tf_proto_library(

name = "protos_all",

srcs = [],

create_go_proto = False,

make_default_target_header_only = True,

visibility = ["//visibility:public"],

deps = [

"//tensorflow/core/example:protos_all",

"//tensorflow/core/framework:protos_all",

"//tensorflow/core/grappler/costs:op_performance_data",

"//tensorflow/core/lib/core:error_codes_proto",

"//tensorflow/core/profiler:profiler_options_proto",

"//tensorflow/core/protobuf:error_codes_proto_impl",

"//tensorflow/core/protobuf:for_core_protos",

"//tensorflow/core/util:protos_all",

"//tensorflow/core/util:test_log_proto",

"@tsl//tsl/profiler/protobuf:profiler_options_proto",

"@tsl//tsl/profiler/protobuf:xplane_proto",

"@xla//xla/tsl/protobuf:coordination_config_proto",

"@xla//xla/tsl/protobuf:distributed_runtime_payloads_proto",

"@xla//xla/tsl/protobuf:status_proto",

],

)

tf_jspb_proto_library(

name = "protos_all_jspb_proto",

visibility = ["//visibility:public"],

deps = [":protos_all"],

)

alias(

name = "example_protos",

actual = "//tensorflow/core/example:example_protos",

visibility = ["//visibility:public"],

)

java_proto_library(

name = "example_java_proto",

visibility = ["//visibility:public"],

deps = [":example_protos"],

)

cc_library(

name = "platform_base",

hdrs = [

"//tensorflow/core/platform:base_hdrs",

"@tsl//tsl/platform:base_hdrs",

],

compatible_with = get_compatible_with_portable(),

copts = tf_copts(),

tags = ["avoid_dep"],

deps = [

"//tensorflow/core/platform",

"//tensorflow/core/platform:byte_order",

"//tensorflow/core/platform:cord",

"//tensorflow/core/platform:env_time",

"//tensorflow/core/platform:logging",

"//tensorflow/core/platform:macros",

"//tensorflow/core/platform:stack_frame",

"//tensorflow/core/platform:threadpool_interface",

"//tensorflow/core/platform:threadpool_options",

"//tensorflow/core/platform:types",

"@com_google_absl//absl/base",

"@com_google_absl//absl/strings",

],

)

# Minimal lib so that tools used for mobile compilation

# don't have to depend on lib/platformlib.

cc_library(

name = "lib_proto_parsing",

hdrs = [

"//tensorflow/core/lib/core:legacy_lib_proto_parsing_headers",

"//tensorflow/core/lib/strings:legacy_lib_proto_parsing_headers",

"//tensorflow/core/platform:lib_proto_parsing_hdrs",

"@tsl//tsl/platform:lib_proto_parsing_hdrs",

],

copts = tf_copts(),

visibility = ["//visibility:public"],

deps = tf_lib_proto_parsing_deps() + [

":platform_base",

"//tensorflow/core/lib/core:errors",

"//tensorflow/core/lib/core:status",

"//tensorflow/core/lib/core:stringpiece",

"//tensorflow/core/lib/strings:numbers",

"//tensorflow/core/lib/strings:strcat",

"//tensorflow/core/platform",

"//tensorflow/core/platform:logging",

"//tensorflow/core/platform:macros",

"//tensorflow/core/platform:platform_port",

"//tensorflow/core/platform:protobuf",

"//tensorflow/core/platform:status",

"//tensorflow/core/platform:stringpiece",

"//tensorflow/core/platform:tstring",

"//tensorflow/core/platform:types",

"@com_google_absl//absl/strings",

],

)

# This build rule (along with :lib_internal, :framework, and

# :framework_internal) purposefully omits the definitions of many declared

# symbols, which are included in //tensorflow:libtensorflow_framework.so. Using

# tf_cc_test and tf_cc_binary will include the necessary symbols.

cc_library(

name = "lib",

hdrs = [

# TODO(rmlarsen): Remove bfloat16.h once dependency in third_party/swift is updated.

"//tensorflow/core/lib/bfloat16:bfloat16.h",

"//tensorflow/core/lib/core:legacy_lib_core_headers",

"@xla//xla/tsl/lib/core:legacy_lib_core_headers",

"//tensorflow/core/lib/gtl:legacy_lib_gtl_headers",

"//tensorflow/core/lib/hash:legacy_lib_hash_all_headers",

"//tensorflow/core/lib/histogram:legacy_lib_histogram_all_headers",

"//tensorflow/core/lib/io:legacy_lib_io_headers",

"//tensorflow/core/lib/math:math_util.h",

"@xla//xla/tsl/lib/math:math_util.h",

"//tensorflow/core/lib/monitoring:legacy_lib_monitoring_lib_headers",

"//tensorflow/core/lib/random:legacy_lib_random_headers",

"//tensorflow/core/lib/strings:legacy_lib_string_headers",

"//tensorflow/core/platform:lib_hdrs",

"//tensorflow/core/util:lib_hdrs",

"@xla//xla/tsl/lib/io:legacy_lib_io_headers",

"@tsl//tsl/platform:lib_hdrs",

],

tags = ["avoid_dep"],

visibility = ["//visibility:public"],

deps = [

":lib_internal",

"@com_google_absl//absl/container:inlined_vector",

"@com_google_absl//absl/functional:any_invocable",

"@com_google_absl//absl/status:statusor",

"@com_google_absl//absl/strings",

"@com_google_absl//absl/strings:cord",

"@com_google_absl//absl/types:optional",

],

)

alias(

name = "feature_util",

actual = "//tensorflow/core/example:feature_util",

visibility = ["//visibility:public"],

)

# DEPRECATED: use platform:stringpiece instead.

cc_library(

name = "core_stringpiece",

hdrs = ["//tensorflow/core/lib/core:legacy_lib_core_stringpiece_header"],

copts = tf_copts(),

deps = [

"//tensorflow/core/platform:stringpiece",

],

)

# Test support library needed for all tests

# This is currently public, but may be made internal in the

# future. Try to avoid depending on it.

cc_library(

name = "test",

testonly = 1,

hdrs = [

"//tensorflow/core/lib/core:legacy_lib_core_status_test_util_header",

"//tensorflow/core/platform:test_hdrs",

"//tensorflow/core/util:test_hdrs",

"@tsl//tsl/platform:test_hdrs",

],

copts = tf_copts(),

linkopts = select({

"//tensorflow:windows": [],

"//conditions:default": ["-lm"],

}),

visibility = ["//visibility:public"],

deps = [

":function_ops_op_lib",

":functional_ops_op_lib",

":lib",

":lib_internal",

":protos_all_cc",

"//tensorflow/core/kernels:required",

"@com_google_absl//absl/status:status_matchers",

"@tsl//tsl/platform:test",

"@tsl//tsl/platform:test_benchmark",

] + tf_additional_test_deps(),

)

# This build rule (along with :framework_internal, :lib, and :lib_internal)

# purposefully omits the definitions of many declared symbols, which are

# included in //tensorflow:libtensorflow_framework.so. Using tf_cc_test and tf_cc_binary

# will include the necessary symbols.

tf_cuda_library(

name = "framework",

hdrs = [

"//tensorflow/core/example:feature_util.h",

"//tensorflow/core/framework:allocator.h",

"//tensorflow/core/framework:allocator_registry.h",

"//tensorflow/core/framework:attr_value_util.h",

"//tensorflow/core/framework:bfloat16.h",

"//tensorflow/core/framework:bounds_check.h",

"//tensorflow/core/framework:cancellation.h",

"//tensorflow/core/framework:collective.h",

"//tensorflow/core/framework:common_shape_fns.h",

"//tensorflow/core/framework:control_flow.h", # TODO(josh11b): Make internal?

"//tensorflow/core/framework:dataset.h",

"//tensorflow/core/framework:dataset_stateful_op_allowlist.h",

"//tensorflow/core/framework:device.h",

"//tensorflow/core/framework:device_base.h",

"//tensorflow/core/framework:device_factory.h",

"//tensorflow/core/framework:function.h",

"//tensorflow/core/framework:function_handle_cache.h",

"//tensorflow/core/framework:graph_def_util.h",

"//tensorflow/core/framework:graph_to_functiondef.h",

"//tensorflow/core/framework:kernel_def_builder.h",

"//tensorflow/core/framework:kernel_def_util.h",

"//tensorflow/core/framework:kernel_shape_util.h",

"//tensorflow/core/framework:log_memory.h",

"//tensorflow/core/framework:logging.h",

"//tensorflow/core/framework:lookup_interface.h",

"//tensorflow/core/framework:memory_types.h",

"//tensorflow/core/framework:metrics.h",

"//tensorflow/core/framework:node_def_builder.h",

"//tensorflow/core/framework:node_def_util.h",

"//tensorflow/core/framework:node_properties.h",

"//tensorflow/core/framework:numeric_op.h",

"//tensorflow/core/framework:numeric_types.h",

"//tensorflow/core/framework:op.h",

"//tensorflow/core/framework:op_def_builder.h",

"//tensorflow/core/framework:op_def_util.h",

"//tensorflow/core/framework:op_kernel.h",

"//tensorflow/core/framework:op_requires.h",

"//tensorflow/core/framework:ops_util.h",

"//tensorflow/core/framework:partial_tensor_shape.h",

"//tensorflow/core/framework:queue_interface.h",

"//tensorflow/core/framework:reader_interface.h",

"//tensorflow/core/framework:reader_op_kernel.h",

"//tensorflow/core/framework:register_types.h",

"//tensorflow/core/framework:register_types_traits.h",

"//tensorflow/core/framework:resource_handle.h",

"//tensorflow/core/framework:resource_mgr.h",

"//tensorflow/core/framework:resource_op_kernel.h",

"//tensorflow/core/framework:rng_alg.h",

"//tensorflow/core/framework:session_state.h",

"//tensorflow/core/framework:shape_inference.h",

"//tensorflow/core/framework:shared_ptr_variant.h",

"//tensorflow/core/framework:stats_aggregator.h",

"//tensorflow/core/framework:tensor.h",

"//tensorflow/core/framework:tensor_shape.h",

"//tensorflow/core/framework:tensor_slice.h",

"//tensorflow/core/framework:tensor_types.h",

"//tensorflow/core/framework:tensor_util.h",

"//tensorflow/core/framework:tf_data_file_logger_options.h",

"//tensorflow/core/framework:thread_factory.h",

"//tensorflow/core/framework:tracking_allocator.h",

"//tensorflow/core/framework:type_index.h",

"//tensorflow/core/framework:type_traits.h",

"//tensorflow/core/framework:typed_allocator.h",

"//tensorflow/core/framework:types.h",

"//tensorflow/core/framework:variant.h",

"//tensorflow/core/framework:variant_encode_decode.h",

"//tensorflow/core/framework:variant_op_registry.h",

"//tensorflow/core/framework:variant_tensor_data.h",

"//tensorflow/core/framework/registration:options.h",

"//tensorflow/core/framework/registration:registration.h",

"//tensorflow/core/public:version.h",

"//tensorflow/core/util:determinism_hdr",

"//tensorflow/core/util:framework_srcs",

"//tensorflow/core/util:memmapped_file_system_hdrs",

"//tensorflow/core/util/sparse:framework_group",

"//tensorflow/lite/kernels/shim:tf_headers",

"@xla//xla/tsl/framework:allocator_hdrs",

"@xla//xla/tsl/framework:cancellation_hdrs",

"@xla//xla/tsl/framework:device_type.h",

] + if_mkl([

"//tensorflow/core/util:mkl_util_hdrs",

]),

visibility = ["//visibility:public"],

deps = [

":framework_internal",

"@com_google_absl//absl/base",

"@com_google_absl//absl/functional:any_invocable",

],

)

# TODO(gonnet): Remove this alias once all users have been moved to the actual target.

alias(

name = "reader_base",

actual = "//tensorflow/core/framework:reader_base",

visibility = ["//visibility:public"],

)

# TODO(gonnet): Remove this alias once all users have been moved to the actual target.

alias(

name = "op_gen_lib",

actual = "//tensorflow/core/framework:op_gen_lib",

visibility = ["//visibility:public"],

)

cc_library(

name = "session_options",

hdrs = ["//tensorflow/core/public:session_options.h"],

visibility = ["//visibility:public"],

deps = [

":protos_all_cc",

],

)

cc_library(

name = "framework_types_hdr",

hdrs = [

"//tensorflow/core/framework:types.h",

"@xla//xla/tsl/framework:device_type.h",

],

linkstatic = 1,

visibility = ["//visibility:public"],

)

cc_library(

name = "framework_lite",

hdrs = [

"//tensorflow/core/framework:numeric_types.h",

"//tensorflow/core/framework:tensor_types.h",

"//tensorflow/core/framework:type_traits.h",

"//tensorflow/core/platform:framework_lite_hdrs",

"@tsl//tsl/platform:framework_lite_hdrs",

"@xla//xla/tsl/framework:numeric_types.h",

"@xla//xla/tsl/framework:type_traits.h",

],

visibility = ["//visibility:public"],

deps = [

"//tensorflow/core/platform:dynamic_annotations",

"//tensorflow/core/platform:mutex",

"//tensorflow/core/platform:platform_port",

"//tensorflow/core/platform:thread_annotations",

"//tensorflow/core/platform:types",

"@eigen_archive//:eigen3",

"@xla//xla/tsl/framework:fixedpoint_types",

],

)

# One target for all user ops.

alias(

name = "user_ops_op_lib",

actual = "//tensorflow/core/user_ops:user_ops_op_lib",

visibility = ["//visibility:public"],

)

cc_library(

name = "ops",

visibility = ["//visibility:public"],

deps = [

":user_ops_op_lib",

"//tensorflow/c/kernels:bitcast_op_lib",

"//tensorflow/c/kernels:histogram_summary_op_lib",

"//tensorflow/c/kernels:merge_summary_op_lib",

"//tensorflow/c/kernels:summary_op_lib",

"//tensorflow/core/ops",

"//tensorflow/dtensor/cc:dtensor_ops",

] + select({

# Non-tpu platforms don't need tpu dependency.

# copybara:uncomment_begin(google-only)

# "//buildenv/platforms/settings:chrome_linux": [],

# copybara:uncomment_end

"//tensorflow:chromiumos": [],

"//tensorflow:fuchsia": [],

"//conditions:default": [

"//tensorflow/core/tpu/ops",

"//tensorflow/dtensor/cc:dtensor_tpu_ops",

],

}) + if_tensorrt([

"//tensorflow/compiler/tf2tensorrt:trt_engine_resource_ops_op_lib",

"//tensorflow/compiler/tf2tensorrt:trt_op_libs",

]) + if_libtpu(

if_false = ["//tensorflow/compiler/mlir/tensorflow:mlir_passthrough_op"],

if_true = [],

),

)

alias(

name = "core_cpu",

actual = "//tensorflow/core/common_runtime:core_cpu",

visibility = ["//visibility:public"],

)

alias(

name = "core",

actual =

"//tensorflow/core/common_runtime:core",

visibility = ["//visibility:public"],

)

# This includes implementations of all kernels built into TensorFlow.

cc_library(

name = "all_kernels_impl",

visibility = [":__subpackages__"],

deps = [

"//tensorflow/c/kernels:bitcast_op",

"//tensorflow/c/kernels:histogram_summary_op",

"//tensorflow/c/kernels:merge_summary_op",

"//tensorflow/c/kernels:summary_op",

"//tensorflow/core/kernels:array",

"//tensorflow/core/kernels:audio",

"//tensorflow/core/kernels:batch_kernels",

"//tensorflow/core/kernels:bincount_op",

"//tensorflow/core/kernels:boosted_trees_ops",

"//tensorflow/core/kernels:candidate_sampler_ops",

"//tensorflow/core/kernels:checkpoint_ops",

"//tensorflow/core/kernels:clustering_ops",

"//tensorflow/core/kernels:collective_ops",

"//tensorflow/core/kernels:composite_tensor_ops",

"//tensorflow/core/kernels:constant_op",

"//tensorflow/core/kernels:control_flow_ops",

"//tensorflow/core/kernels:count_ops",

"//tensorflow/core/kernels:ctc_ops",

"//tensorflow/core/kernels:data_flow",

"//tensorflow/core/kernels:decode_proto_op",

"//tensorflow/core/kernels:encode_proto_op",

"//tensorflow/core/kernels:fact_op",

"//tensorflow/core/kernels:fake_quant_ops",

"//tensorflow/core/kernels:filesystem_ops",

"//tensorflow/core/kernels:function_ops",

"//tensorflow/core/kernels:functional_ops",

"//tensorflow/core/kernels:grappler",

"//tensorflow/core/kernels:histogram_op",

"//tensorflow/core/kernels:io",

"//tensorflow/core/kernels:isotonic_regression_op",

"//tensorflow/core/kernels:logging",

"//tensorflow/core/kernels:lookup",

"//tensorflow/core/kernels:manip",

"//tensorflow/core/kernels:math",

"//tensorflow/core/kernels:multinomial_op",

"//tensorflow/core/kernels:mutex_ops",

"//tensorflow/core/kernels:nn",

"//tensorflow/core/kernels:parameterized_truncated_normal_op",

"//tensorflow/core/kernels:parsing",

"//tensorflow/core/kernels:partitioned_function_ops",

"//tensorflow/core/kernels:pooling_ops",

"//tensorflow/core/kernels:quantized_ops",

"//tensorflow/core/kernels:ragged_ops",

"//tensorflow/core/kernels:random_binomial_op",

"//tensorflow/core/kernels:random_index_shuffle_ops",

"//tensorflow/core/kernels:random_ops",

"//tensorflow/core/kernels:random_poisson_op",

"//tensorflow/core/kernels:required",

"//tensorflow/core/kernels:resource_variable_ops",

"//tensorflow/core/kernels:rnn_ops",

"//tensorflow/core/kernels:scoped_allocator_ops",

"//tensorflow/core/kernels:sdca_ops",

"//tensorflow/core/kernels:searchsorted_op",

"//tensorflow/core/kernels:set_kernels",

"//tensorflow/core/kernels:sparse",

"//tensorflow/core/kernels:state",

"//tensorflow/core/kernels:stateful_random_ops",

"//tensorflow/core/kernels:stateless_random_gamma_op",

"//tensorflow/core/kernels:stateless_random_ops",

"//tensorflow/core/kernels:stateless_shuffle",

"//tensorflow/core/kernels:stochastic_cast_op",

"//tensorflow/core/kernels:string",

"//tensorflow/core/kernels:summary_kernels",

"//tensorflow/core/kernels:sync_ops",

"//tensorflow/core/kernels:training_ops",

"//tensorflow/core/kernels:word2vec_kernels",

"//tensorflow/core/kernels/image",

"//tensorflow/core/kernels/linalg",

"//tensorflow/core/kernels/sparse:kernels",

"//tensorflow/core/kernels/uniform_quant_ops:kernels",

] + if_mkl([

"//tensorflow/core/kernels/mkl:mkl_concat_op",

"//tensorflow/core/kernels/mkl:mkl_dequantize_op",

"//tensorflow/core/kernels/mkl:mkl_conv_op",

"//tensorflow/core/kernels/mkl:mkl_fused_batch_norm_op",

"//tensorflow/core/kernels/mkl:mkl_fused_instance_norm_op",

"//tensorflow/core/kernels/mkl:mkl_layer_norm_op",

"//tensorflow/core/kernels/mkl:mkl_pooling_ops",

"//tensorflow/core/kernels/mkl:mkl_qmatmul_op",

"//tensorflow/core/kernels/mkl:mkl_requantize_ops",

"//tensorflow/core/kernels/mkl:mkl_quantize_op",

"//tensorflow/core/kernels/mkl:mkl_relu_op",

"//tensorflow/core/kernels/mkl:mkl_softmax_op",

"//tensorflow/core/kernels/mkl:mkl_swish_op",

"//tensorflow/core/kernels/mkl:mkl_fused_mish_op",

"//tensorflow/core/kernels/mkl:mkl_transpose_op",

"//tensorflow/core/kernels/mkl:mkl_batch_matmul_op",

"//tensorflow/core/kernels/mkl:mkl_einsum_op",

"//tensorflow/core/kernels/mkl:mkl_matmul_op",

"//tensorflow/core/kernels/mkl:mkl_sparse_matrix_matmul_op",

"//tensorflow/core/kernels/mkl:mkl_tmp_ops",

]) + if_cuda_or_rocm([

"//tensorflow/core/kernels:cudnn_rnn_kernels",

]) + if_cuda([

"//tensorflow/core/grappler/optimizers:gpu_swapping_kernels",

"//tensorflow/core/grappler/optimizers:gpu_swapping_ops",

]) + if_nccl([

"//tensorflow/core/kernels:nccl_kernels",

]) + if_tensorrt([

"//tensorflow/compiler/tf2tensorrt:trt_engine_resource_op_kernels",

"//tensorflow/compiler/tf2tensorrt:trt_op_kernels",

]) + tf_tpu_dependencies() + tf_dtensor_tpu_dependencies(),

)

cc_library(

name = "dynamic_kernels_impl",

visibility = ["//visibility:private"],

deps = [

"//tensorflow/core/kernels:sobol_op",

],

)

cc_library(

name = "all_kernels",

visibility = ["//visibility:public"],

deps = if_dynamic_kernels(

[],

otherwise = [":dynamic_kernels_impl"],

) + [

# TODO(gunan): Split this up and load the resulting kernels dynamically once

# the dependency issues are resolved.

":all_kernels_impl",

# TODO(gunan): Work on the API between these and rest of TF and make

# these also dynamically loading.

"//tensorflow/core/kernels:dataset_ops", # Depends on grappler

"//tensorflow/core/kernels:list_kernels", # Depends on variant_op_registry.h

"//tensorflow/core/kernels:map_kernels",

"//tensorflow/core/kernels:tensor_map",

],

)

tf_cuda_library(

name = "tensorflow_opensource",

copts = tf_copts(),

visibility = ["//visibility:public"],

deps = [

":all_kernels",

":core",

":direct_session",

":example_parser_configuration",

":gpu_runtime",

":lib",

":ops",

] + tensorflow_opensource_extra_deps(),

)

cc_library(

name = "tensorflow",

visibility = ["//visibility:public"],

deps = [

":tensorflow_opensource",

"//tensorflow/core/platform/default/build_config:tensorflow_platform_specific",

],

)

cc_library(

name = "distributed_tensorflow_dependencies",

visibility = ["//visibility:public"],

deps = [

"//tensorflow/core/distributed_runtime/rpc:grpc_session",

"//tensorflow/core/kernels:data_service_ops",

"//tensorflow/distribute/experimental/rpc/kernels:rpc_ops",

],

)

cc_library(

name = "testlib_kernels_impl",

deps = [

"//tensorflow/core/kernels:aggregate_ops",

"//tensorflow/core/kernels:bcast_ops",

"//tensorflow/core/kernels:cast_op",

"//tensorflow/core/kernels:constant_op",

"//tensorflow/core/kernels:host_constant_op",

"//tensorflow/core/kernels:identity_op",

"//tensorflow/core/kernels:random_ops",

"//tensorflow/core/kernels:reduction_ops",

"//tensorflow/core/kernels:reshape_op",

],

)

# Test support library needed for higher-level (TensorFlow-specific) tests

tf_cuda_library(

name = "testlib",

testonly = 1,

srcs = [

"//tensorflow/core/common_runtime:testlib_srcs",

"//tensorflow/core/graph:testlib_srcs",

],

hdrs = [

"//tensorflow/core/common_runtime:testlib_headers",

"//tensorflow/core/graph:testlib_headers",

# TODO(josh11b): Drop this once users are depending on

# kernels:ops_testutil instead.

"//tensorflow/core/kernels:ops_testutil.h",

# TODO(gonnet): Stop exporting these headers once users depend on

# the tensorflow/core/framework:* targets directly.

"//tensorflow/core/framework:shape_inference_testutil.h",

"//tensorflow/core/framework:tensor_testutil.h",

"//tensorflow/core/framework:fake_input.h",

"//tensorflow/core/framework:function_testlib.h",

],

copts = tf_copts(),

visibility = ["//visibility:public"],

deps = [

":core_cpu",

":core_cpu_internal",

":core_cpu_lib",

":framework",

":framework_internal",

":lib",

":lib_internal",

":ops",

":protos_all_cc",

":test",

# TODO(gunan): resolve dependency issues and load these kernels dynamically.

":testlib_kernels_impl",

"//tensorflow/cc:scope",

"//tensorflow/core/common_runtime:testlib_ops",

"//tensorflow/core/framework:fake_input",

"//tensorflow/core/framework:function_testlib",

"//tensorflow/core/framework:shape_inference_testutil",

"//tensorflow/core/framework:tensor_testutil",

"//tensorflow/core/kernels:ops_testutil",

"//tensorflow/core/kernels:ops_util",

] + if_mkl(["//tensorflow/core/graph:mkl_graph_util"]),

)

# This is a link-only library to provide a DirectSession

# implementation of the Session interface.

tf_cuda_library(

name = "direct_session",

copts = tf_copts(),

linkstatic = 1,

visibility = ["//visibility:public"],

deps = [

"//tensorflow/core/common_runtime:direct_session_internal",

],

alwayslink = 1,

)

# -----------------------------------------------------------------------------

# Public Android targets

# Sources required to build the TensorFlow framework without the runtime on

# mobile platforms. This is essentially the sources required to build

# tensorflow/core/framework:tensor without using granular targets.

filegroup(

name = "mobile_srcs_no_runtime",

srcs = [

"//tensorflow/compiler/jit:mobile_srcs_no_runtime",

"//tensorflow/core/activity_watcher:activity_watcher_headers",

"//tensorflow/core/example:mobile_srcs_no_runtime",

"//tensorflow/core/framework:attr_value_proto_text_srcs",

"//tensorflow/core/framework:mobile_srcs_no_runtime",

"//tensorflow/core/lib/core:mobile_srcs_no_runtime",

"//tensorflow/core/lib/gtl:mobile_srcs_no_runtime",

"//tensorflow/core/lib/hash:mobile_srcs_no_runtime",

"//tensorflow/core/lib/strings:mobile_srcs_no_runtime",

"//tensorflow/core/platform:mobile_srcs_no_runtime",

"//tensorflow/core/profiler:mobile_srcs_no_runtime",

"//tensorflow/core/public:mobile_srcs_no_runtime",

"//tensorflow/core/util:mobile_srcs_no_runtime",

"//tensorflow/core/util/ctc:mobile_srcs",

"@tsl//tsl/platform:mobile_srcs_no_runtime",

"@xla//xla/tsl/framework:mobile_srcs_no_runtime",

"@xla//xla/tsl/framework/fixedpoint:mobile_srcs_no_runtime",

],

visibility = ["//visibility:public"],

)

# Sources required to build the TensorFlow framework with runtime on

# mobile platforms without granular targets. It is assumed that the source

# files in tensorflow/core:mobile_srcs_no_runtime have been compiled

# separately and are linked in as a dependency.

filegroup(

name = "mobile_srcs_only_runtime",

srcs = [

# Sources for which we do not yet have granular targets.

"//tensorflow/c/eager:srcs",

# StreamExecutor C API is currently not supported for mobile.

# Including just the header for SP_Stream reference in kernels C API.

"//tensorflow/c/experimental/stream_executor:headers",

"//tensorflow/c:srcs",

"//tensorflow/core/common_runtime:mobile_srcs_only_runtime",

"//tensorflow/core/common_runtime/eager:srcs",

"//tensorflow/core/framework:mobile_srcs_only_runtime",

"//tensorflow/core/graph:mobile_srcs_only_runtime",

"//tensorflow/core/kernels:mobile_srcs",

"//tensorflow/core/lib/io:mobile_srcs_only_runtime",

"@xla//xla/tsl/lib/io:mobile_srcs_only_runtime",

"//tensorflow/core/nccl:mobile_srcs",

"//tensorflow/core/profiler:mobile_srcs_only_runtime",

"//tensorflow/core/public:mobile_srcs_only_runtime",

"//tensorflow/core/util/sparse:mobile_srcs_only_runtime",

"//tensorflow/core/util/tensor_bundle:mobile_srcs",

"//tensorflow/core/util:mobile_srcs_only_runtime",

# Sources for which we already have granular targets.

"//tensorflow/core/lib/core:mobile_srcs_only_runtime",

"@xla//xla/tsl/lib/core:mobile_srcs_only_runtime",

"//tensorflow/core/lib/gtl:mobile_srcs_only_runtime",

"//tensorflow/core/lib/hash:mobile_srcs_only_runtime",

"//tensorflow/core/lib/histogram:mobile_srcs_only_runtime",

"//tensorflow/core/lib/math:mobile_srcs_only_runtime",

"@xla//xla/tsl/lib/math:mobile_srcs_only_runtime",

"//tensorflow/core/lib/monitoring:mobile_srcs_only_runtime",

"//tensorflow/core/lib/random:mobile_srcs_only_runtime",

"//tensorflow/core/lib/strings:mobile_srcs_only_runtime",

"//tensorflow/core/platform:mobile_srcs_only_runtime",

"@tsl//tsl/platform:mobile_srcs_only_runtime",

"@xla//xla/tsl/framework:mobile_srcs_only_runtime",

"@xla//xla/tsl/framework/fixedpoint:mobile_srcs_only_runtime",

# Wav io files

"//tensorflow/core/lib/wav:wav_io.h",

"//tensorflow/core/lib/wav:wav_io.cc",

],

visibility = ["//visibility:public"],

)

filegroup(

name = "mobile_srcs",

srcs = [

":mobile_srcs_no_runtime",

":mobile_srcs_only_runtime",

],

visibility = ["//visibility:public"],

)

# All the aliases for stuff under ops/

# Once the dependencies move to the real targets, remove the aliases here!

[

alias(

name = "%s" % (name,),

actual = "//tensorflow/core/ops:%s" % (name,),

visibility = ["//visibility:public"],

)

for name in [

"array_grad",

"array_ops_op_lib",

"audio_ops_op_lib",

"batch_ops_op_lib",

"bitwise_ops_op_lib",

"boosted_trees_ops_op_lib",

"candidate_sampling_ops_op_lib",

"checkpoint_ops_op_lib",

"clustering_ops_op_lib",

"collective_ops_op_lib",

"control_flow_ops_op_lib",

"count_ops_op_lib",

"ctc_ops_op_lib",

"cudnn_rnn_ops_op_lib",

"data_flow_ops_op_lib",

"dataset_ops_op_lib",

"debug_ops_op_lib",

"decode_proto_ops_op_lib",

"encode_proto_ops_op_lib",

"experimental_dataset_ops_op_lib",

"filesystem_ops_op_lib",

"function_ops_op_lib",

"functional_grad",

"functional_ops_op_lib",

"image_ops_op_lib",

"io_ops_op_lib",

"linalg_ops_op_lib",

"list_ops_op_lib",

"logging_ops_op_lib",

"lookup_ops_op_lib",

"manip_ops_op_lib",

"map_ops_op_lib",

"math_grad",

"math_ops_op_lib",

"mkl_array_ops_op_lib",

"mkl_nn_ops_op_lib",

"nccl_ops_op_lib",

"nn_grad",

"nn_ops_op_lib",

"no_op_op_lib",

"optional_ops_op_lib",

"parsing_ops_op_lib",

"portable_op_registrations_and_gradients",

"ragged_array_ops_op_lib",

"ragged_conversion_ops_op_lib",

"ragged_math_ops_op_lib",

"ragged_ops",

"composite_tensor_ops_op_lib",

"random_grad_op_lib",

"random_index_shuffle_ops_op_lib",

"random_ops_op_lib",

"resource_variable_ops_op_lib",

"risc_ops_op_lib",

"rnn_ops_op_lib",

"scoped_allocator_ops_op_lib",

"script_ops_op_lib",

"sdca_ops_op_lib",

"sendrecv_ops_op_lib",

"set_ops_op_lib",

"sparse_csr_matrix_ops_op_lib",

"sparse_ops_op_lib",

"special_math_ops_op_lib",

"spectral_ops_op_lib",

"state_ops_op_lib",

"stateful_random_ops_op_lib",

"stateless_random_ops_op_lib",

"stateless_random_ops_v2_op_lib",

"stochastic_cast_op_op_lib",

"string_ops_op_lib",

"summary_ops_op_lib",

"sync_ops_op_lib",

"tpu_configuration_ops_op_lib",

"tpu_cross_replica_ops_op_lib",

"tpu_embedding_ops_op_lib",

"tpu_embedding_load_retrieve_ops_op_lib",

"tpu_functional_ops_op_lib",

"tpu_heartbeat_ops_op_lib",

"tpu_host_compute_ops_op_lib",

"tpu_infeed_ops_op_lib",

"tpu_outfeed_ops_op_lib",

"tpu_ordinal_selector_ops_op_lib",

"tpu_replication_ops_op_lib",

"tpu_sharding_util_ops_op_lib",

"training_ops_op_lib",

"uniform_quant_ops_op_lib",

"word2vec_ops",

]

]

# Native library support for mobile applications. Does not contain

# operators, use :portable_tensorflow_lib if you want full operator

# support.

#

# If you just need TensorFlow types, e.g. Tensors, use

# :portable_tensorflow_lib_lite_no_runtime.