for_core_protos_go_proto

type AssetFileDef struct {

	// The tensor to bind the asset filename to.
	TensorInfo *TensorInfo `protobuf:"bytes,1,opt,name=tensor_info,json=tensorInfo,proto3" json:"tensor_info,omitempty"`
	// The filename within an assets directory. Note: does not include the path
	// prefix, i.e. directories. For an asset at /tmp/path/vocab.txt, the filename
	// would be "vocab.txt".
	Filename string `protobuf:"bytes,2,opt,name=filename,proto3" json:"filename,omitempty"`
	// contains filtered or unexported fields
}

type AutoParallelOptions struct {
	Enable      bool  `protobuf:"varint,1,opt,name=enable,proto3" json:"enable,omitempty"`
	NumReplicas int32 `protobuf:"varint,2,opt,name=num_replicas,json=numReplicas,proto3" json:"num_replicas,omitempty"`
	// contains filtered or unexported fields
}

type BinSummary = for_core_protos_go_proto.BinSummary

type BoundedTensorSpecProto struct {
	Name    string                                  `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Shape   *tensor_shape_go_proto.TensorShapeProto `protobuf:"bytes,2,opt,name=shape,proto3" json:"shape,omitempty"`
	Dtype   types_go_proto.DataType                 `protobuf:"varint,3,opt,name=dtype,proto3,enum=tensorflow.DataType" json:"dtype,omitempty"`
	Minimum *tensor_go_proto.TensorProto            `protobuf:"bytes,4,opt,name=minimum,proto3" json:"minimum,omitempty"`
	Maximum *tensor_go_proto.TensorProto            `protobuf:"bytes,5,opt,name=maximum,proto3" json:"maximum,omitempty"`
	// contains filtered or unexported fields
}

type BundleEntryProto struct {

	// The tensor dtype and shape.
	Dtype types_go_proto.DataType                 `protobuf:"varint,1,opt,name=dtype,proto3,enum=tensorflow.DataType" json:"dtype,omitempty"`
	Shape *tensor_shape_go_proto.TensorShapeProto `protobuf:"bytes,2,opt,name=shape,proto3" json:"shape,omitempty"`
	// The binary content of the tensor lies in:
	//
	//	File "shard_id": bytes [offset, offset + size).
	ShardId int32 `protobuf:"varint,3,opt,name=shard_id,json=shardId,proto3" json:"shard_id,omitempty"`
	Offset  int64 `protobuf:"varint,4,opt,name=offset,proto3" json:"offset,omitempty"`
	Size    int64 `protobuf:"varint,5,opt,name=size,proto3" json:"size,omitempty"`
	// The CRC32C checksum of the tensor bytes.
	Crc32C uint32 `protobuf:"fixed32,6,opt,name=crc32c,proto3" json:"crc32c,omitempty"`
	// Iff present, this entry represents a partitioned tensor.  The previous
	// fields are interpreted as follows:
	//
	//	"dtype", "shape": describe the full tensor.
	//	"shard_id", "offset", "size", "crc32c": all IGNORED.
	//	   These information for each slice can be looked up in their own
	//	   BundleEntryProto, keyed by each "slice_name".
	Slices []*tensor_slice_go_proto.TensorSliceProto `protobuf:"bytes,7,rep,name=slices,proto3" json:"slices,omitempty"`
	// contains filtered or unexported fields
}

type BundleHeaderProto struct {

	// Number of data files in the bundle.
	NumShards  int32                        `protobuf:"varint,1,opt,name=num_shards,json=numShards,proto3" json:"num_shards,omitempty"`
	Endianness BundleHeaderProto_Endianness `protobuf:"varint,2,opt,name=endianness,proto3,enum=tensorflow.BundleHeaderProto_Endianness" json:"endianness,omitempty"`
	// Versioning of the tensor bundle format.
	Version *versions_go_proto.VersionDef `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
	// contains filtered or unexported fields
}

type BundleHeaderProto_Endianness int32

type CallableOptions struct {

	// Tensors to be fed in the callable. Each feed is the name of a tensor.
	Feed []string `protobuf:"bytes,1,rep,name=feed,proto3" json:"feed,omitempty"`
	// Fetches. A list of tensor names. The caller of the callable expects a
	// tensor to be returned for each fetch[i] (see RunStepResponse.tensor). The
	// order of specified fetches does not change the execution order.
	Fetch []string `protobuf:"bytes,2,rep,name=fetch,proto3" json:"fetch,omitempty"`
	// Target Nodes. A list of node names. The named nodes will be run by the
	// callable but their outputs will not be returned.
	Target []string `protobuf:"bytes,3,rep,name=target,proto3" json:"target,omitempty"`
	// Options that will be applied to each run.
	RunOptions *RunOptions `protobuf:"bytes,4,opt,name=run_options,json=runOptions,proto3" json:"run_options,omitempty"`
	// Tensors to be connected in the callable. Each TensorConnection denotes
	// a pair of tensors in the graph, between which an edge will be created
	// in the callable.
	TensorConnection []*TensorConnection `protobuf:"bytes,5,rep,name=tensor_connection,json=tensorConnection,proto3" json:"tensor_connection,omitempty"`
	// The Tensor objects fed in the callable and fetched from the callable
	// are expected to be backed by host (CPU) memory by default.
	//
	// The options below allow changing that - feeding tensors backed by
	// device memory, or returning tensors that are backed by device memory.
	//
	// The maps below map the name of a feed/fetch tensor (which appears in
	// 'feed' or 'fetch' fields above), to the fully qualified name of the device
	// owning the memory backing the contents of the tensor.
	//
	// For example, creating a callable with the following options:
	//
	//	CallableOptions {
	//	  feed: "a:0"
	//	  feed: "b:0"
	//
	//	  fetch: "x:0"
	//	  fetch: "y:0"
	//
	//	  feed_devices: {
	//	    "a:0": "/job:localhost/replica:0/task:0/device:GPU:0"
	//	  }
	//
	//	  fetch_devices: {
	//	    "y:0": "/job:localhost/replica:0/task:0/device:GPU:0"
	//	 }
	//	}
	//
	// means that the Callable expects:
	// - The first argument ("a:0") is a Tensor backed by GPU memory.
	// - The second argument ("b:0") is a Tensor backed by host memory.
	// and of its return values:
	// - The first output ("x:0") will be backed by host memory.
	// - The second output ("y:0") will be backed by GPU memory.
	//
	// FEEDS:
	// It is the responsibility of the caller to ensure that the memory of the fed
	// tensors will be correctly initialized and synchronized before it is
	// accessed by operations executed during the call to Session::RunCallable().
	//
	// This is typically ensured by using the TensorFlow memory allocators
	// (Device::GetAllocator()) to create the Tensor to be fed.
	//
	// Alternatively, for CUDA-enabled GPU devices, this typically means that the
	// operation that produced the contents of the tensor has completed, i.e., the
	// CUDA stream has been synchronized (e.g., via cuCtxSynchronize() or
	// cuStreamSynchronize()).
	FeedDevices  map[string]string `` /* 182-byte string literal not displayed */
	FetchDevices map[string]string `` /* 185-byte string literal not displayed */
	// By default, RunCallable() will synchronize the GPU stream before returning
	// fetched tensors on a GPU device, to ensure that the values in those tensors
	// have been produced. This simplifies interacting with the tensors, but
	// potentially incurs a performance hit.
	//
	// If this options is set to true, the caller is responsible for ensuring
	// that the values in the fetched tensors have been produced before they are
	// used. The caller can do this by invoking `Device::Sync()` on the underlying
	// device(s), or by feeding the tensors back to the same Session using
	// `feed_devices` with the same corresponding device name.
	FetchSkipSync bool `protobuf:"varint,8,opt,name=fetch_skip_sync,json=fetchSkipSync,proto3" json:"fetch_skip_sync,omitempty"`
	// contains filtered or unexported fields
}

type CapturedTensor struct {

	// Name of captured tensor
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Name of concrete function which contains the computed graph tensor.
	ConcreteFunction string `protobuf:"bytes,2,opt,name=concrete_function,json=concreteFunction,proto3" json:"concrete_function,omitempty"`
	// contains filtered or unexported fields
}

type ClusterDef struct {

	// The jobs that comprise the cluster.
	Job []*JobDef `protobuf:"bytes,1,rep,name=job,proto3" json:"job,omitempty"`
	// contains filtered or unexported fields
}

type ClusterDeviceFilters struct {
	Jobs []*JobDeviceFilters `protobuf:"bytes,1,rep,name=jobs,proto3" json:"jobs,omitempty"`
	// contains filtered or unexported fields
}

type Code = for_core_protos_go_proto.Code

type CodeLocation struct {

	// Host name on which the source files are located.
	HostName string `protobuf:"bytes,1,opt,name=host_name,json=hostName,proto3" json:"host_name,omitempty"`
	// ID to a stack frame, each of which is pointed to
	// by a unique ID. The ordering of the frames is consistent with Python's
	// `traceback.extract_tb()`.
	StackFrameIds []string `protobuf:"bytes,2,rep,name=stack_frame_ids,json=stackFrameIds,proto3" json:"stack_frame_ids,omitempty"`
	// contains filtered or unexported fields
}

type CollectionDef struct {

	// Types that are assignable to Kind:
	//
	//	*CollectionDef_NodeList_
	//	*CollectionDef_BytesList_
	//	*CollectionDef_Int64List_
	//	*CollectionDef_FloatList_
	//	*CollectionDef_AnyList_
	Kind isCollectionDef_Kind `protobuf_oneof:"kind"`
	// contains filtered or unexported fields
}

type CollectionDef_AnyList struct {
	Value []*anypb.Any `protobuf:"bytes,1,rep,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type CollectionDef_AnyList_ struct {
	AnyList *CollectionDef_AnyList `protobuf:"bytes,5,opt,name=any_list,json=anyList,proto3,oneof"`
}

type CollectionDef_BytesList struct {
	Value [][]byte `protobuf:"bytes,1,rep,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type CollectionDef_BytesList_ struct {
	BytesList *CollectionDef_BytesList `protobuf:"bytes,2,opt,name=bytes_list,json=bytesList,proto3,oneof"`
}

type CollectionDef_FloatList struct {
	Value []float32 `protobuf:"fixed32,1,rep,packed,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type CollectionDef_FloatList_ struct {
	FloatList *CollectionDef_FloatList `protobuf:"bytes,4,opt,name=float_list,json=floatList,proto3,oneof"`
}

type CollectionDef_Int64List struct {
	Value []int64 `protobuf:"varint,1,rep,packed,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type CollectionDef_Int64List_ struct {
	Int64List *CollectionDef_Int64List `protobuf:"bytes,3,opt,name=int64_list,json=int64List,proto3,oneof"`
}

type CollectionDef_NodeList struct {
	Value []string `protobuf:"bytes,1,rep,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type CollectionDef_NodeList_ struct {
	NodeList *CollectionDef_NodeList `protobuf:"bytes,1,opt,name=node_list,json=nodeList,proto3,oneof"`
}

type CompositeTensorVariantMetadata struct {
	TypeSpecProto *TypeSpecProto `protobuf:"bytes,1,opt,name=type_spec_proto,json=typeSpecProto,proto3" json:"type_spec_proto,omitempty"`
	// contains filtered or unexported fields
}

type CondContextDef struct {

	// Name of the context.
	ContextName string `protobuf:"bytes,1,opt,name=context_name,json=contextName,proto3" json:"context_name,omitempty"`
	// Name of the pred tensor.
	PredName string `protobuf:"bytes,2,opt,name=pred_name,json=predName,proto3" json:"pred_name,omitempty"`
	// Name of the pivot tensor.
	PivotName string `protobuf:"bytes,3,opt,name=pivot_name,json=pivotName,proto3" json:"pivot_name,omitempty"`
	// Branch prediction. 0 or 1.
	Branch int32 `protobuf:"varint,4,opt,name=branch,proto3" json:"branch,omitempty"`
	// Values and external values in control flow context.
	ValuesDef *ValuesDef `protobuf:"bytes,5,opt,name=values_def,json=valuesDef,proto3" json:"values_def,omitempty"`
	// Contexts contained inside this context (e.g. nested conds).
	NestedContexts []*ControlFlowContextDef `protobuf:"bytes,6,rep,name=nested_contexts,json=nestedContexts,proto3" json:"nested_contexts,omitempty"`
	// contains filtered or unexported fields
}

type ConfigProto struct {

	// Map from device type name (e.g., "CPU" or "GPU" ) to maximum
	// number of devices of that type to use.  If a particular device
	// type is not found in the map, the system picks an appropriate
	// number.
	DeviceCount map[string]int32 `` /* 183-byte string literal not displayed */
	// The execution of an individual op (for some op types) can be
	// parallelized on a pool of intra_op_parallelism_threads.
	// 0 means the system picks an appropriate number.
	//
	// If you create an ordinary session, e.g., from Python or C++,
	// then there is exactly one intra op thread pool per process.
	// The first session created determines the number of threads in this pool.
	// All subsequent sessions reuse/share this one global pool.
	//
	// There are notable exceptions to the default behavior described above:
	//  1. There is an environment variable  for overriding this thread pool,
	//     named TF_OVERRIDE_GLOBAL_THREADPOOL.
	//  2. When connecting to a server, such as a remote `tf.train.Server`
	//     instance, then this option will be ignored altogether.
	IntraOpParallelismThreads int32 `` /* 141-byte string literal not displayed */
	// Nodes that perform blocking operations are enqueued on a pool of
	// inter_op_parallelism_threads available in each process.
	//
	// 0 means the system picks an appropriate number.
	// Negative means all operations are performed in caller's thread.
	//
	// Note that the first Session created in the process sets the
	// number of threads for all future sessions unless use_per_session_threads is
	// true or session_inter_op_thread_pool is configured.
	InterOpParallelismThreads int32 `` /* 141-byte string literal not displayed */
	// If true, use a new set of threads for this session rather than the global
	// pool of threads. Only supported by direct sessions.
	//
	// If false, use the global threads created by the first session, or the
	// per-session thread pools configured by session_inter_op_thread_pool.
	//
	// This option is deprecated. The same effect can be achieved by setting
	// session_inter_op_thread_pool to have one element, whose num_threads equals
	// inter_op_parallelism_threads.
	UsePerSessionThreads bool `` /* 126-byte string literal not displayed */
	// This option is experimental - it may be replaced with a different mechanism
	// in the future.
	//
	// Configures session thread pools. If this is configured, then RunOptions for
	// a Run call can select the thread pool to use.
	//
	// The intended use is for when some session invocations need to run in a
	// background pool limited to a small number of threads:
	// - For example, a session may be configured to have one large pool (for
	// regular compute) and one small pool (for periodic, low priority work);
	// using the small pool is currently the mechanism for limiting the inter-op
	// parallelism of the low priority work.  Note that it does not limit the
	// parallelism of work spawned by a single op kernel implementation.
	// - Using this setting is normally not needed in training, but may help some
	// serving use cases.
	// - It is also generally recommended to set the global_name field of this
	// proto, to avoid creating multiple large pools. It is typically better to
	// run the non-low-priority work, even across sessions, in a single large
	// pool.
	SessionInterOpThreadPool []*ThreadPoolOptionProto `` /* 140-byte string literal not displayed */
	// Assignment of Nodes to Devices is recomputed every placement_period
	// steps until the system warms up (at which point the recomputation
	// typically slows down automatically).
	PlacementPeriod int32 `protobuf:"varint,3,opt,name=placement_period,json=placementPeriod,proto3" json:"placement_period,omitempty"`
	// When any filters are present sessions will ignore all devices which do not
	// match the filters. Each filter can be partially specified, e.g. "/job:ps"
	// "/job:worker/replica:3", etc.
	DeviceFilters []string `protobuf:"bytes,4,rep,name=device_filters,json=deviceFilters,proto3" json:"device_filters,omitempty"`
	// Options that apply to all GPUs.
	GpuOptions *GPUOptions `protobuf:"bytes,6,opt,name=gpu_options,json=gpuOptions,proto3" json:"gpu_options,omitempty"`
	// Whether soft placement is allowed. If allow_soft_placement is true,
	// an op will be placed on CPU if
	//  1. there's no GPU implementation for the OP
	//
	// or
	//  2. no GPU devices are known or registered
	//
	// or
	//  3. need to co-locate with reftype input(s) which are from CPU.
	AllowSoftPlacement bool `protobuf:"varint,7,opt,name=allow_soft_placement,json=allowSoftPlacement,proto3" json:"allow_soft_placement,omitempty"`
	// Whether device placements should be logged.
	LogDevicePlacement bool `protobuf:"varint,8,opt,name=log_device_placement,json=logDevicePlacement,proto3" json:"log_device_placement,omitempty"`
	// Options that apply to all graphs.
	GraphOptions *GraphOptions `protobuf:"bytes,10,opt,name=graph_options,json=graphOptions,proto3" json:"graph_options,omitempty"`
	// Global timeout for all blocking operations in this session.  If non-zero,
	// and not overridden on a per-operation basis, this value will be used as the
	// deadline for all blocking operations.
	OperationTimeoutInMs int64 `` /* 127-byte string literal not displayed */
	// Options that apply when this session uses the distributed runtime.
	RpcOptions *for_core_protos_go_proto.RPCOptions `protobuf:"bytes,13,opt,name=rpc_options,json=rpcOptions,proto3" json:"rpc_options,omitempty"`
	// Optional list of all workers to use in this session.
	ClusterDef *ClusterDef `protobuf:"bytes,14,opt,name=cluster_def,json=clusterDef,proto3" json:"cluster_def,omitempty"`
	// If true, any resources such as Variables used in the session will not be
	// shared with other sessions. However, when clusterspec propagation is
	// enabled, this field is ignored and sessions are always isolated.
	IsolateSessionState bool `protobuf:"varint,15,opt,name=isolate_session_state,json=isolateSessionState,proto3" json:"isolate_session_state,omitempty"`
	// When true, WorkerSessions are created with device attributes from the
	// full cluster.
	// This is helpful when a worker wants to partition a graph
	// (for example during a PartitionedCallOp).
	ShareClusterDevicesInSession bool                      `` /* 153-byte string literal not displayed */
	Experimental                 *ConfigProto_Experimental `protobuf:"bytes,16,opt,name=experimental,proto3" json:"experimental,omitempty"`
	// contains filtered or unexported fields
}

type ConfigProto_Experimental struct {

	// Task name for group resolution.
	CollectiveGroupLeader string `` /* 126-byte string literal not displayed */
	// Which executor to use, the default executor will be used
	// if it is an empty string or "DEFAULT"
	ExecutorType string `protobuf:"bytes,3,opt,name=executor_type,json=executorType,proto3" json:"executor_type,omitempty"`
	// Guidance to formatting of large RecvBuf fields for transfer.
	// Any positive value sets the max chunk size.  0 defaults to 4096.
	// Any negative value indicates no max, i.e. one chunk only.
	RecvBufMaxChunk int32 `protobuf:"varint,4,opt,name=recv_buf_max_chunk,json=recvBufMaxChunk,proto3" json:"recv_buf_max_chunk,omitempty"`
	// If true, and supported by the platform, the runtime will attempt to
	// use NUMA affinity where applicable.  One consequence will be the
	// existence of as many CPU devices as there are available NUMA nodes.
	UseNumaAffinity bool `protobuf:"varint,5,opt,name=use_numa_affinity,json=useNumaAffinity,proto3" json:"use_numa_affinity,omitempty"`
	// If true, make collective op execution order sequential and deterministic
	// for potentially concurrent collective instances.
	CollectiveDeterministicSequentialExecution bool `` /* 192-byte string literal not displayed */
	// If true, use NCCL for CollectiveOps.  This feature is highly
	// experimental.
	CollectiveNccl bool `protobuf:"varint,7,opt,name=collective_nccl,json=collectiveNccl,proto3" json:"collective_nccl,omitempty"`
	// In the following, session state means the value of a variable, elements
	// in a hash table, or any other resource, accessible by worker sessions
	// held by a TF server.
	//
	// When ClusterSpec propagation is enabled, the value of
	// isolate_session_state is ignored when deciding whether to share session
	// states in a TF server (for backwards compatibility reasons).
	// - If share_session_state_in_clusterspec_propagation is true, the session
	// states are shared.
	// - If share_session_state_in_clusterspec_propagation is false, session
	// states are isolated.
	//
	// When clusterspec propagation is not used, the value of
	// share_session_state_in_clusterspec_propagation is ignored when deciding
	// whether to share session states in a TF server.
	// - If isolate_session_state is true, session states are isolated.
	// - If isolate_session_state is false, session states are shared.
	//
	// TODO(b/129330037): Add a single API that consistently treats
	// isolate_session_state and ClusterSpec propagation.
	ShareSessionStateInClusterspecPropagation bool `` /* 193-byte string literal not displayed */
	// If using a direct session, disable spinning while waiting for work in
	// the thread pool. This may result in higher latency for completing ops,
	// but in the case where there is a lot of spinning may result in lower
	// CPU usage.
	DisableThreadSpinning bool `` /* 127-byte string literal not displayed */
	// This was promoted to a non-experimental API. Please use
	// ConfigProto.share_cluster_devices_in_session instead.
	ShareClusterDevicesInSession bool `` /* 153-byte string literal not displayed */
	// Metadata about the session.
	//
	// If set, this can be used by the runtime and the Ops for debugging,
	// monitoring, etc.
	//
	// NOTE: This is currently used and propagated only by the direct session
	// and EagerContext.
	SessionMetadata *SessionMetadata `protobuf:"bytes,11,opt,name=session_metadata,json=sessionMetadata,proto3" json:"session_metadata,omitempty"`
	// If true, the session may treat the graph as being static for optimization
	// purposes.
	//
	// If this option is set to true when a session is created, the full
	// GraphDef must be passed in a single call to Session::Create(), and
	// Session::Extend() may not be supported.
	OptimizeForStaticGraph bool `` /* 133-byte string literal not displayed */
	// Whether to enable the MLIR-based TF->XLA bridge. This is only used if set
	// to true. Default value or false is ignored. Use mlir_bridge_rollout for
	// finer control.
	//
	// If this option is set to true when a session is created, MLIR is used to
	// perform the set of graph transformations to put the graph in a form that
	// can be executed with delegation of some computations to an accelerator.
	// This builds on the model of XLA where a subset of the graph is
	// encapsulated and attached to a "compile" operation, whose result is fed
	// to an "execute" operation. The kernel for these operations is responsible
	// to lower the encapsulated graph to a particular device.
	EnableMlirBridge bool `protobuf:"varint,13,opt,name=enable_mlir_bridge,json=enableMlirBridge,proto3" json:"enable_mlir_bridge,omitempty"`
	// Whether to enable the MLIR-based TF->XLA bridge.
	MlirBridgeRollout ConfigProto_Experimental_MlirBridgeRollout `` /* 175-byte string literal not displayed */
	// Whether to enable the MLIR-based Graph optimizations.
	//
	// This will become a part of standard Tensorflow graph optimization
	// pipeline, currently this is only used for gradual migration and testing
	// new passes that are replacing existing optimizations in Grappler.
	EnableMlirGraphOptimization bool `` /* 148-byte string literal not displayed */
	// If true, the session will not store an additional copy of the graph for
	// each subgraph.
	//
	// If this option is set to true when a session is created, the
	// `RunOptions.output_partition_graphs` options must not be set.
	DisableOutputPartitionGraphs bool `` /* 151-byte string literal not displayed */
	// Minimum number of batches run through the XLA graph before XLA fusion
	// autotuner is enabled. Default value of zero disables the autotuner.
	//
	// The XLA fusion autotuner can improve performance by executing a heuristic
	// search on the compiler parameters.
	XlaFusionAutotunerThresh int64 `` /* 139-byte string literal not displayed */
	// Whether runtime execution uses TFRT.
	UseTfrt bool `protobuf:"varint,18,opt,name=use_tfrt,json=useTfrt,proto3" json:"use_tfrt,omitempty"`
	// If true, use Pathways with TFRT API for multi host support.
	EnableMultiHost bool `protobuf:"varint,27,opt,name=enable_multi_host,json=enableMultiHost,proto3" json:"enable_multi_host,omitempty"`
	// Port for the Pathways server. Ignored if enable_multi_host=false.
	BackendServerPort int32 `protobuf:"varint,28,opt,name=backend_server_port,json=backendServerPort,proto3" json:"backend_server_port,omitempty"`
	// If true, TFRT will use TPU specific compiler passes and perform TPU
	// specific initialization.
	TargetTpu bool `protobuf:"varint,29,opt,name=target_tpu,json=targetTpu,proto3" json:"target_tpu,omitempty"`
	// If true, TFRT will use GPU specific compiler passes and perform GPU
	// specific initialization.
	TargetGpu bool `protobuf:"varint,30,opt,name=target_gpu,json=targetGpu,proto3" json:"target_gpu,omitempty"`
	// The threshold to merge small streams in TFRT. The stream with cost
	// smaller than the threshold will be merged. Setting it to value 1
	// disables all merges.
	StreamMergeThreshold int32 `protobuf:"varint,31,opt,name=stream_merge_threshold,json=streamMergeThreshold,proto3" json:"stream_merge_threshold,omitempty"`
	// Whether functional control flow op lowering should be disabled. This is
	// useful when executing within a portable runtime where control flow op
	// kernels may not be loaded due to selective registration.
	DisableFunctionalOpsLowering bool `` /* 151-byte string literal not displayed */
	// Provides a hint to XLA auto clustering to prefer forming a single large
	// cluster that encompases most of the graph.
	XlaPreferSingleGraphCluster bool `` /* 150-byte string literal not displayed */
	// Distributed coordination service configurations.
	CoordinationConfig *CoordinationServiceConfig `protobuf:"bytes,23,opt,name=coordination_config,json=coordinationConfig,proto3" json:"coordination_config,omitempty"`
	// If true, the session will treat the graph as being non-static for
	// optimization purposes.
	//
	// If this option is set to true when a session is created, the full
	// GraphDef will be retained to enable calls to Session::Extend().
	// Calling Extend() without setting this flag will result in errors.
	//
	// This option is meant to replace `optimize_for_static_graph` and it
	// aims to negate its value.
	DisableOptimizeForStaticGraph bool `` /* 156-byte string literal not displayed */
	// Whether eager remote execution will stream all the function calls or
	// allow them to happen in parallel. When true, streaming execution is
	// disabled, and parallel execution is allowed.
	DisableEagerExecutorStreamingEnqueue bool `` /* 177-byte string literal not displayed */
	// contains filtered or unexported fields
}

type ConfigProto_Experimental_MlirBridgeRollout int32

type ControlFlowContextDef struct {

	// Types that are assignable to Ctxt:
	//
	//	*ControlFlowContextDef_CondCtxt
	//	*ControlFlowContextDef_WhileCtxt
	Ctxt isControlFlowContextDef_Ctxt `protobuf_oneof:"ctxt"`
	// contains filtered or unexported fields
}

type ControlFlowContextDef_CondCtxt struct {
	CondCtxt *CondContextDef `protobuf:"bytes,1,opt,name=cond_ctxt,json=condCtxt,proto3,oneof"`
}

type ControlFlowContextDef_WhileCtxt struct {
	WhileCtxt *WhileContextDef `protobuf:"bytes,2,opt,name=while_ctxt,json=whileCtxt,proto3,oneof"`
}

type CoordinatedJob struct {
	Name     string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	NumTasks int32  `protobuf:"varint,2,opt,name=num_tasks,json=numTasks,proto3" json:"num_tasks,omitempty"`
	// contains filtered or unexported fields
}

type CoordinationServiceConfig struct {

	// Type of coordination service implementation to enable.
	// For example, setting the service type as "standalone" starts a service
	// instance on the leader task to provide the coordination services such as
	// heartbeats and consistent key-value store.
	ServiceType string `protobuf:"bytes,1,opt,name=service_type,json=serviceType,proto3" json:"service_type,omitempty"`
	// Address where the coordination service instance is hosted.
	ServiceLeader string `protobuf:"bytes,2,opt,name=service_leader,json=serviceLeader,proto3" json:"service_leader,omitempty"`
	// Whether to enable the health check mechanism.
	EnableHealthCheck bool `protobuf:"varint,3,opt,name=enable_health_check,json=enableHealthCheck,proto3" json:"enable_health_check,omitempty"`
	// Maximum wait time for all members in the cluster to be registered.
	ClusterRegisterTimeoutInMs int64 `` /* 146-byte string literal not displayed */
	// Heartbeat timeout, if a task does not record heartbeat in this time
	// window, it will be considered disconnected.
	// Note: This is also used as a grace period to accept any heartbeats after
	// the agent has disconnected, to account for the lag time between the service
	// recording the state change and the agent stopping heartbeats.
	HeartbeatTimeoutInMs int64             `` /* 126-byte string literal not displayed */
	CoordinatedJobList   []*CoordinatedJob `protobuf:"bytes,10,rep,name=coordinated_job_list,json=coordinatedJobList,proto3" json:"coordinated_job_list,omitempty"`
	// Denotes how long to wait for all coordination agents to reach the barriers
	// (after the first shutdown request) before disconnecting together. If
	// set to 0, no barrier is imposed upon shutdown and each worker can
	// disconnect individually.
	ShutdownBarrierTimeoutInMs int64 `` /* 146-byte string literal not displayed */
	// If set, agents do not make an explicit Shutdown() call. Service will only
	// find out about the disconnecte agent via stale heartbeats. Used for
	// testing.
	AgentDestructionWithoutShutdown bool `` /* 159-byte string literal not displayed */
	// The list of jobs which are recoverable. If a task in this list fails,
	// it will not propagate error to other tasks.
	// If empty, no jobs will be recoverable and every task failure will cause
	// error propagation to other tasks.
	RecoverableJobs []string `protobuf:"bytes,9,rep,name=recoverable_jobs,json=recoverableJobs,proto3" json:"recoverable_jobs,omitempty"`
	// If a task restarts with a new incarnation, we may allow it to reconnect
	// silently. This is useful when we know that a task can immediately resume
	// work upon re-connecting to the service.
	AllowNewIncarnationToReconnect bool `` /* 159-byte string literal not displayed */
	// Disables coordination service.
	// Some libraries enable coordination service by default even if the user did
	// not specify any config. This field allows users to explicitly disable
	// coordination service under all situations.
	ForceDisable bool `protobuf:"varint,12,opt,name=force_disable,json=forceDisable,proto3" json:"force_disable,omitempty"`
	// contains filtered or unexported fields
}

type CrossTrainerCacheOptions struct {
	TrainerId string `protobuf:"bytes,1,opt,name=trainer_id,json=trainerId,proto3" json:"trainer_id,omitempty"`
	// contains filtered or unexported fields
}

type DataServiceConfig struct {
	DeploymentMode DeploymentMode `` /* 140-byte string literal not displayed */
	// contains filtered or unexported fields
}

type DataServiceMetadata struct {

	// Types that are assignable to OptionalElementSpec:
	//
	//	*DataServiceMetadata_ElementSpec
	OptionalElementSpec isDataServiceMetadata_OptionalElementSpec `protobuf_oneof:"optional_element_spec"`
	Compression         DataServiceMetadata_Compression           `` /* 129-byte string literal not displayed */
	// Cardinality of the dataset.
	Cardinality int64 `protobuf:"varint,3,opt,name=cardinality,proto3" json:"cardinality,omitempty"`
	// contains filtered or unexported fields
}

type DataServiceMetadata_Compression int32

type DataServiceMetadata_ElementSpec struct {
	// Serialized element spec.
	ElementSpec []byte `protobuf:"bytes,1,opt,name=element_spec,json=elementSpec,proto3,oneof"`
}

type DebugEvent struct {

	// Timestamp in seconds (with microsecond precision).
	WallTime float64 `protobuf:"fixed64,1,opt,name=wall_time,json=wallTime,proto3" json:"wall_time,omitempty"`
	// Step of training (if available).
	Step int64 `protobuf:"varint,2,opt,name=step,proto3" json:"step,omitempty"`
	// Types that are assignable to What:
	//
	//	*DebugEvent_DebugMetadata
	//	*DebugEvent_SourceFile
	//	*DebugEvent_StackFrameWithId
	//	*DebugEvent_GraphOpCreation
	//	*DebugEvent_DebuggedGraph
	//	*DebugEvent_Execution
	//	*DebugEvent_GraphExecutionTrace
	//	*DebugEvent_GraphId
	//	*DebugEvent_DebuggedDevice
	What isDebugEvent_What `protobuf_oneof:"what"`
	// contains filtered or unexported fields
}

type DebugEvent_DebugMetadata struct {
	// Metadata related to this debugging data.
	DebugMetadata *DebugMetadata `protobuf:"bytes,3,opt,name=debug_metadata,json=debugMetadata,proto3,oneof"`
}

type DebugEvent_DebuggedDevice struct {
	// A device on which debugger-instrumented ops and/or tensors reside.
	DebuggedDevice *DebuggedDevice `protobuf:"bytes,12,opt,name=debugged_device,json=debuggedDevice,proto3,oneof"`
}

type DebugEvent_DebuggedGraph struct {
	// Information about a debugged graph.
	DebuggedGraph *DebuggedGraph `protobuf:"bytes,8,opt,name=debugged_graph,json=debuggedGraph,proto3,oneof"`
}