xla

type BatchNormTrainingRequest struct {
	Operand      *ComputationDataHandle `protobuf:"bytes,1,opt,name=operand" json:"operand,omitempty"`
	Scale        *ComputationDataHandle `protobuf:"bytes,2,opt,name=scale" json:"scale,omitempty"`
	Offset       *ComputationDataHandle `protobuf:"bytes,3,opt,name=offset" json:"offset,omitempty"`
	Epsilon      float32                `protobuf:"fixed32,4,opt,name=epsilon" json:"epsilon,omitempty"`
	FeatureIndex int64                  `protobuf:"varint,5,opt,name=feature_index,json=featureIndex" json:"feature_index,omitempty"`
}

type BinaryOpRequest struct {
	Binop               BinaryOperation        `protobuf:"varint,2,opt,name=binop,enum=xla.BinaryOperation" json:"binop,omitempty"`
	Lhs                 *ComputationDataHandle `protobuf:"bytes,3,opt,name=lhs" json:"lhs,omitempty"`
	Rhs                 *ComputationDataHandle `protobuf:"bytes,4,opt,name=rhs" json:"rhs,omitempty"`
	BroadcastDimensions []int64                `protobuf:"varint,5,rep,packed,name=broadcast_dimensions,json=broadcastDimensions" json:"broadcast_dimensions,omitempty"`
}

type BinaryOperation int32

type BroadcastRequest struct {
	Operand        *ComputationDataHandle `protobuf:"bytes,2,opt,name=operand" json:"operand,omitempty"`
	BroadcastSizes []int64                `protobuf:"varint,3,rep,packed,name=broadcast_sizes,json=broadcastSizes" json:"broadcast_sizes,omitempty"`
}

type CallRequest struct {
	ToApply  *ComputationHandle       `protobuf:"bytes,2,opt,name=to_apply,json=toApply" json:"to_apply,omitempty"`
	Operands []*ComputationDataHandle `protobuf:"bytes,3,rep,name=operands" json:"operands,omitempty"`
}

type ChannelHandle struct {
	Handle int64 `protobuf:"varint,1,opt,name=handle" json:"handle,omitempty"`
}

type ComputationDataHandle struct {
	Handle int64 `protobuf:"varint,1,opt,name=handle" json:"handle,omitempty"`
}

type ComputationHandle struct {
	Handle int64 `protobuf:"varint,1,opt,name=handle" json:"handle,omitempty"`
}

type ComputationRequest struct {
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}

type ComputationResponse struct {
	Computation *ComputationHandle `protobuf:"bytes,1,opt,name=computation" json:"computation,omitempty"`
}

type ComputationStats struct {
	// The number of floating point operations in the computation.
	FlopCount float64 `protobuf:"fixed64,1,opt,name=flop_count,json=flopCount" json:"flop_count,omitempty"`
	// The number of transcendental operations (e.g., exp) in the computation.
	TranscendentalCount float64 `protobuf:"fixed64,2,opt,name=transcendental_count,json=transcendentalCount" json:"transcendental_count,omitempty"`
}

type ComputationStatsRequest struct {
	Computation *ComputationHandle `protobuf:"bytes,1,opt,name=computation" json:"computation,omitempty"`
}

type ComputationStatsResponse struct {
	Stats *ComputationStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
}

type ComputeConstantRequest struct {
	Computation  *ComputationHandle     `protobuf:"bytes,1,opt,name=computation" json:"computation,omitempty"`
	Operand      *ComputationDataHandle `protobuf:"bytes,2,opt,name=operand" json:"operand,omitempty"`
	OutputLayout *Layout                `protobuf:"bytes,3,opt,name=output_layout,json=outputLayout" json:"output_layout,omitempty"`
}

type ComputeConstantResponse struct {
	Output *GlobalDataHandle `protobuf:"bytes,1,opt,name=output" json:"output,omitempty"`
}

type ConcatenateRequest struct {
	Operands []*ComputationDataHandle `protobuf:"bytes,2,rep,name=operands" json:"operands,omitempty"`
	// The dimension in which we concatenate; e.g. if you had dimension arrays of
	// [4, 1] and [5, 1], you'd concatenate in dimension 0 to produce a [9, 1].
	// Attempting to concatenate those in dimension 1 would produce an error, as
	// 4 != 5 (and there is no ragged array support).
	Dimension int64 `protobuf:"varint,3,opt,name=dimension" json:"dimension,omitempty"`
}

type ConstantRequest struct {
	Literal *LiteralProto `protobuf:"bytes,2,opt,name=literal" json:"literal,omitempty"`
}

type ConvertRequest struct {
	Operand        *ComputationDataHandle `protobuf:"bytes,2,opt,name=operand" json:"operand,omitempty"`
	NewElementType PrimitiveType          `protobuf:"varint,3,opt,name=new_element_type,json=newElementType,enum=xla.PrimitiveType" json:"new_element_type,omitempty"`
}

type ConvolutionDimensionNumbers struct {
	// The number of the dimension that represents batch in the input
	// (lhs) and output.
	BatchDimension int64 `protobuf:"varint,1,opt,name=batch_dimension,json=batchDimension" json:"batch_dimension,omitempty"`
	// The number of the dimension that represents features in the input
	// (lhs) and output.
	FeatureDimension int64 `protobuf:"varint,2,opt,name=feature_dimension,json=featureDimension" json:"feature_dimension,omitempty"`
	// The dimension numbers for the spatial dimensions that the window
	// moves through in the input (lhs) and output.
	SpatialDimensions []int64 `protobuf:"varint,5,rep,packed,name=spatial_dimensions,json=spatialDimensions" json:"spatial_dimensions,omitempty"`
	// The number of the dimension that represents input features in the
	// convolutional kernel (rhs).
	KernelInputFeatureDimension int64 `` /* 140-byte string literal not displayed */
	// The number of the dimension that represents output features in
	// the convolutional kernel (rhs).
	KernelOutputFeatureDimension int64 `` /* 143-byte string literal not displayed */
	// The dimension numbers for the spatial dimensions that the window
	// moves through in the kernel (rhs). window.strides(0) is the
	// stride in the kernel_spatial_dimensions(0) dimension.
	KernelSpatialDimensions []int64 `` /* 133-byte string literal not displayed */
}

type ConvolveRequest struct {
	Lhs              *ComputationDataHandle       `protobuf:"bytes,2,opt,name=lhs" json:"lhs,omitempty"`
	Rhs              *ComputationDataHandle       `protobuf:"bytes,3,opt,name=rhs" json:"rhs,omitempty"`
	Window           *Window                      `protobuf:"bytes,4,opt,name=window" json:"window,omitempty"`
	DimensionNumbers *ConvolutionDimensionNumbers `protobuf:"bytes,5,opt,name=dimension_numbers,json=dimensionNumbers" json:"dimension_numbers,omitempty"`
}

type CreateChannelHandleRequest struct {
}

type CreateChannelHandleResponse struct {
	Channel *ChannelHandle `protobuf:"bytes,1,opt,name=channel" json:"channel,omitempty"`
}

type CrossReplicaSumRequest struct {
	Operand *ComputationDataHandle `protobuf:"bytes,2,opt,name=operand" json:"operand,omitempty"`
}

type CustomCallRequest struct {
	CallTargetName string                   `protobuf:"bytes,2,opt,name=call_target_name,json=callTargetName" json:"call_target_name,omitempty"`
	Operands       []*ComputationDataHandle `protobuf:"bytes,3,rep,name=operands" json:"operands,omitempty"`
	Shape          *Shape                   `protobuf:"bytes,4,opt,name=shape" json:"shape,omitempty"`
}

type DebugOptions struct {
	// HLO modules matching this regex will be dumped to a .dot file throughout
	// various stages in compilation (file names are LOG(INFO)'d). Set to ".*" to
	// dump *all* HLO modules.
	XlaGenerateHloGraph string `protobuf:"bytes,1,opt,name=xla_generate_hlo_graph,json=xlaGenerateHloGraph" json:"xla_generate_hlo_graph,omitempty"`
	// List of HLO passes to disable. These names must exactly match the pass
	// names as specified by the HloPassInterface::name() method.
	XlaDisableHloPasses []string `protobuf:"bytes,2,rep,name=xla_disable_hlo_passes,json=xlaDisableHloPasses" json:"xla_disable_hlo_passes,omitempty"`
	// Numerical optimization level for the XLA compiler backend; the specific
	// interpretation of this value is left to the backends.
	XlaBackendOptimizationLevel int32 `` /* 140-byte string literal not displayed */
	// When true, "unsafe" mathematical optimizations are enabled. These
	// transformations include but are not limited to:
	//
	//  - Reducing the precision of operations (e.g. using an approximate sin
	//    function, or transforming x/y into x * (1/y)).
	//  - Assuming that operations never produce or consume NaN or +/- Inf.
	//  - Assuming that +0 and -0 are indistinguishable.
	XlaEnableFastMath bool `protobuf:"varint,4,opt,name=xla_enable_fast_math,json=xlaEnableFastMath" json:"xla_enable_fast_math,omitempty"`
	// Embed the compiler IR as a string in the executable.
	XlaEmbedIrInExecutable bool `` /* 127-byte string literal not displayed */
	// Dump compilation artifacts as JSON into this directory.
	XlaDumpDebugJsonTo string `protobuf:"bytes,6,opt,name=xla_dump_debug_json_to,json=xlaDumpDebugJsonTo" json:"xla_dump_debug_json_to,omitempty"`
	// Path to directory with cuda/ptx tools and libraries.
	XlaGpuCudaDataDir string `protobuf:"bytes,7,opt,name=xla_gpu_cuda_data_dir,json=xlaGpuCudaDataDir" json:"xla_gpu_cuda_data_dir,omitempty"`
	// Enable flush-to-zero semantics in the GPU backend.
	XlaGpuFtz bool `protobuf:"varint,8,opt,name=xla_gpu_ftz,json=xlaGpuFtz" json:"xla_gpu_ftz,omitempty"`
	// Extra options to pass to the compilation backend; specific interpretation
	// of these values is left to the backend.
	XlaBackendExtraOptions map[string]string `` /* 200-byte string literal not displayed */
}

type DeconstructTupleRequest struct {
	TupleHandle *GlobalDataHandle `protobuf:"bytes,2,opt,name=tuple_handle,json=tupleHandle" json:"tuple_handle,omitempty"`
}

type DeconstructTupleResponse struct {
	ElementHandles []*GlobalDataHandle `protobuf:"bytes,1,rep,name=element_handles,json=elementHandles" json:"element_handles,omitempty"`
}

type DeviceAssignmentProto struct {
	ReplicaCount       int32                                      `protobuf:"varint,1,opt,name=replica_count,json=replicaCount" json:"replica_count,omitempty"`
	ComputationCount   int32                                      `protobuf:"varint,2,opt,name=computation_count,json=computationCount" json:"computation_count,omitempty"`
	ComputationDevices []*DeviceAssignmentProto_ComputationDevice `protobuf:"bytes,3,rep,name=computation_devices,json=computationDevices" json:"computation_devices,omitempty"`
}

type DeviceAssignmentProto_ComputationDevice struct {
	ReplicaDeviceIds []int32 `protobuf:"varint,1,rep,packed,name=replica_device_ids,json=replicaDeviceIds" json:"replica_device_ids,omitempty"`
}

type DeviceHandle struct {
	Handle int64 `protobuf:"varint,1,opt,name=handle" json:"handle,omitempty"`
	// The number of model-parallel virtual devices that communicate via XLA
	// Send/Recv instructions.
	DeviceCount int64 `protobuf:"varint,2,opt,name=device_count,json=deviceCount" json:"device_count,omitempty"`
}

type DynamicSliceRequest struct {
	// Operand from which to slice at dynamic 'start_indices'.
	Operand *ComputationDataHandle `protobuf:"bytes,2,opt,name=operand" json:"operand,omitempty"`
	// Dynamically computed 'start_indices' for slice operation.
	StartIndices *ComputationDataHandle `protobuf:"bytes,3,opt,name=start_indices,json=startIndices" json:"start_indices,omitempty"`
	// Slice sizes for each dimension (note that indices calculations are computed
	// modulo dimension sizes to avoid out-of-bound array accesses).
	SliceSizes []int64 `protobuf:"varint,4,rep,packed,name=slice_sizes,json=sliceSizes" json:"slice_sizes,omitempty"`
}

type DynamicUpdateSliceRequest struct {
	// Operand on which slice 'update' is to be applied.
	Operand *ComputationDataHandle `protobuf:"bytes,2,opt,name=operand" json:"operand,omitempty"`
	// The slice update to apply to 'operand'.
	Update *ComputationDataHandle `protobuf:"bytes,3,opt,name=update" json:"update,omitempty"`
	// Dynamically computed start indices for the update slice operation.
	StartIndices *ComputationDataHandle `protobuf:"bytes,4,opt,name=start_indices,json=startIndices" json:"start_indices,omitempty"`
}

type ExecuteAsyncRequest struct {
	Computation *ComputationHandle  `protobuf:"bytes,1,opt,name=computation" json:"computation,omitempty"`
	Arguments   []*GlobalDataHandle `protobuf:"bytes,2,rep,name=arguments" json:"arguments,omitempty"`
	// Options that affect how XLA compiles and runs code to service this request.
	ExecutionOptions *ExecutionOptions `protobuf:"bytes,6,opt,name=execution_options,json=executionOptions" json:"execution_options,omitempty"`
}

type ExecuteAsyncResponse struct {
	// A handle to the execution launched asynchronously.
	Execution *ExecutionHandle `protobuf:"bytes,1,opt,name=execution" json:"execution,omitempty"`
}

type ExecuteParallelRequest struct {
	Requests []*ExecuteRequest `protobuf:"bytes,1,rep,name=requests" json:"requests,omitempty"`
}

type ExecuteParallelResponse struct {
	Responses []*ExecuteResponse `protobuf:"bytes,1,rep,name=responses" json:"responses,omitempty"`
}

type ExecuteRequest struct {
	Computation *ComputationHandle  `protobuf:"bytes,1,opt,name=computation" json:"computation,omitempty"`
	Arguments   []*GlobalDataHandle `protobuf:"bytes,2,rep,name=arguments" json:"arguments,omitempty"`
	// This optional field specifies a particular device to run the computation.
	// If not provided, the default device will be chosen.
	DeviceHandle *DeviceHandle `protobuf:"bytes,5,opt,name=device_handle,json=deviceHandle" json:"device_handle,omitempty"`
	// Options that affect how XLA compiles and runs code to service this request.
	ExecutionOptions *ExecutionOptions `protobuf:"bytes,6,opt,name=execution_options,json=executionOptions" json:"execution_options,omitempty"`
}

type ExecuteResponse struct {
	Output  *GlobalDataHandle `protobuf:"bytes,1,opt,name=output" json:"output,omitempty"`
	Profile *ExecutionProfile `protobuf:"bytes,2,opt,name=profile" json:"profile,omitempty"`
}

type ExecutionHandle struct {
	Handle int64 `protobuf:"varint,1,opt,name=handle" json:"handle,omitempty"`
}

type ExecutionOptions struct {
	// This optional field's layout is used as a hint when storing the output of
	// this computation.  Subsequent transfers of this output array to the client
	// may be faster when using this layout.
	//
	// We use a Shape here to accommodate computations that return a tuple.
	ShapeWithOutputLayout *Shape `protobuf:"bytes,2,opt,name=shape_with_output_layout,json=shapeWithOutputLayout" json:"shape_with_output_layout,omitempty"`
	// Used to seed random-number generators used in this computation.  If this is
	// 0, we generate a seed ourselves.
	//
	// TODO(b/32083678): Changing the seed unnecessarily forces a recompilation.
	Seed         uint64        `protobuf:"varint,3,opt,name=seed" json:"seed,omitempty"`
	DebugOptions *DebugOptions `protobuf:"bytes,4,opt,name=debug_options,json=debugOptions" json:"debug_options,omitempty"`
}

type ExecutionProfile struct {
	// Whether the executable was read from the compilation cache.
	CompilationCacheHit bool `protobuf:"varint,1,opt,name=compilation_cache_hit,json=compilationCacheHit" json:"compilation_cache_hit,omitempty"`
	// The time in milliseconds spent to compile the computation. This only set if
	// the executable was not read from the compilation cache
	// (compilation_cache_hit == false).
	CompileTimeMs int64 `protobuf:"varint,2,opt,name=compile_time_ms,json=compileTimeMs" json:"compile_time_ms,omitempty"`
	// The number of cycles spent for the computation. This does not include the
	// time taken for the data transfers between the host and the device. This is
	// a target-dependent field and only used for debugging purposes.
	ComputeCycleCount int64 `protobuf:"varint,3,opt,name=compute_cycle_count,json=computeCycleCount" json:"compute_cycle_count,omitempty"`
	// The time in nanoseconds spent for the computation, without data transfer.
	ComputeTimeNs int64 `protobuf:"varint,4,opt,name=compute_time_ns,json=computeTimeNs" json:"compute_time_ns,omitempty"`
	// The time in nanoseconds spent for the entire computation, including the
	// result data transfer time. Current implementation does not spend any cycles
	// for the input data transfer since the memory is initialized with the proper
	// values before the execution.
	ComputeAndTransferTimeNs int64 `` /* 133-byte string literal not displayed */
}

type GetComputationShapeRequest struct {
	Computation *ComputationHandle `protobuf:"bytes,1,opt,name=computation" json:"computation,omitempty"`
}

type GetComputationShapeResponse struct {
	ProgramShape *ProgramShape `protobuf:"bytes,1,opt,name=program_shape,json=programShape" json:"program_shape,omitempty"`
}

type GetDeviceHandlesRequest struct {
	DeviceCount int64 `protobuf:"varint,1,opt,name=device_count,json=deviceCount" json:"device_count,omitempty"`
}

type GetDeviceHandlesResponse struct {
	DeviceHandles []*DeviceHandle `protobuf:"bytes,1,rep,name=device_handles,json=deviceHandles" json:"device_handles,omitempty"`
}

type GetLocalShapeRequest struct {
	Computation *ComputationHandle     `protobuf:"bytes,1,opt,name=computation" json:"computation,omitempty"`
	Operand     *ComputationDataHandle `protobuf:"bytes,2,opt,name=operand" json:"operand,omitempty"`
}

type GetLocalShapeResponse struct {
	Shape *Shape `protobuf:"bytes,1,opt,name=shape" json:"shape,omitempty"`
}

type GetShapeRequest struct {
	Data *GlobalDataHandle `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"`
}

type GetShapeResponse struct {
	Shape *Shape `protobuf:"bytes,1,opt,name=shape" json:"shape,omitempty"`
}

type GetTupleElementRequest struct {
	Operand *ComputationDataHandle `protobuf:"bytes,2,opt,name=operand" json:"operand,omitempty"`
	Index   int64                  `protobuf:"varint,3,opt,name=index" json:"index,omitempty"`
}

type GlobalDataHandle struct {
	Handle int64 `protobuf:"varint,1,opt,name=handle" json:"handle,omitempty"`
}

type InfeedRequest struct {
	// The shape of the data returned by reading the device's infeed buffer.
	Shape *Shape `protobuf:"bytes,2,opt,name=shape" json:"shape,omitempty"`
	// Additional infeed configuration for the backend.
	Config []byte `protobuf:"bytes,3,opt,name=config,proto3" json:"config,omitempty"`
}

type IsConstantRequest struct {
	Computation *ComputationHandle     `protobuf:"bytes,1,opt,name=computation" json:"computation,omitempty"`
	Operand     *ComputationDataHandle `protobuf:"bytes,2,opt,name=operand" json:"operand,omitempty"`
}

type IsConstantResponse struct {
	IsConstant bool `protobuf:"varint,1,opt,name=is_constant,json=isConstant" json:"is_constant,omitempty"`
}

type Layout struct {
	// Sequence of dimension numbers, from minor (fastest varying index) to major
	// (slowest varying index). This field is required.
	MinorToMajor []int64 `protobuf:"varint,1,rep,packed,name=minor_to_major,json=minorToMajor" json:"minor_to_major,omitempty"`
	// The width to which the layout of each dimension is padded up
	// to. If present, the size of the padded_dimensions must equal the
	// rank of the shape. The padding appears at the end of a dimension,
	// not at the beginning. This kind of padding, unlike padding in
	// e.g. convolution, is not part of the shape.
	PaddedDimensions []int64 `protobuf:"varint,2,rep,packed,name=padded_dimensions,json=paddedDimensions" json:"padded_dimensions,omitempty"`
	// Describes the values in the padding specified by
	// padded_dimensions.
	PaddingValue PaddingValue `protobuf:"varint,3,opt,name=padding_value,json=paddingValue,enum=xla.PaddingValue" json:"padding_value,omitempty"`
}

type LiteralProto struct {
	Shape         *Shape          `protobuf:"bytes,1,opt,name=shape" json:"shape,omitempty"`
	Preds         []bool          `protobuf:"varint,2,rep,packed,name=preds" json:"preds,omitempty"`
	U8S           []byte          `protobuf:"bytes,3,opt,name=u8s,proto3" json:"u8s,omitempty"`
	S32S          []int32         `protobuf:"varint,4,rep,packed,name=s32s" json:"s32s,omitempty"`
	S64S          []int64         `protobuf:"varint,5,rep,packed,name=s64s" json:"s64s,omitempty"`
	U32S          []uint32        `protobuf:"varint,6,rep,packed,name=u32s" json:"u32s,omitempty"`
	U64S          []uint64        `protobuf:"varint,7,rep,packed,name=u64s" json:"u64s,omitempty"`
	F32S          []float32       `protobuf:"fixed32,8,rep,packed,name=f32s" json:"f32s,omitempty"`
	F64S          []float64       `protobuf:"fixed64,9,rep,packed,name=f64s" json:"f64s,omitempty"`
	TupleLiterals []*LiteralProto `protobuf:"bytes,10,rep,name=tuple_literals,json=tupleLiterals" json:"tuple_literals,omitempty"`
	F16S          []byte          `protobuf:"bytes,11,opt,name=f16s,proto3" json:"f16s,omitempty"`
}

type LoadComputationSnapshotRequest struct {
	Module *xla1.SessionModule `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
}

type LoadComputationSnapshotResponse struct {
	Computation *ComputationHandle `protobuf:"bytes,1,opt,name=computation" json:"computation,omitempty"`
}

type LoadDataRequest struct {
	// Describes the path of the ColumnIO tablet to load.
	ColumnioTabletPath string `protobuf:"bytes,1,opt,name=columnio_tablet_path,json=columnioTabletPath" json:"columnio_tablet_path,omitempty"`
	// Describes the field to load within the ColumnIO tablet.
	ColumnioField string `protobuf:"bytes,2,opt,name=columnio_field,json=columnioField" json:"columnio_field,omitempty"`
	// Individual element shape, excluding rows.
	ElementShape *Shape `protobuf:"bytes,3,opt,name=element_shape,json=elementShape" json:"element_shape,omitempty"`
	// Warning: ColumnIO does not support random-access, so use offset with
	// caution in performance-critical scenarios.
	Offset int64 `protobuf:"varint,4,opt,name=offset" json:"offset,omitempty"`
	// Maximum number of elements (with shape element_shape) to load.
	Limit int64 `protobuf:"varint,5,opt,name=limit" json:"limit,omitempty"`
	// If more than one item is requested (via limit > 1), then this request
	// attribute zips together the produced vectors.
	Zip bool `protobuf:"varint,6,opt,name=zip" json:"zip,omitempty"`
}

type LoadDataResponse struct {
	Data          *GlobalDataHandle `protobuf:"bytes,1,opt,name=data" json:"data,omitempty"`
	DataShape     *Shape            `protobuf:"bytes,2,opt,name=data_shape,json=dataShape" json:"data_shape,omitempty"`
	AvailableRows int64             `protobuf:"varint,3,opt,name=available_rows,json=availableRows" json:"available_rows,omitempty"`
	RowsLoaded    int64             `protobuf:"varint,4,opt,name=rows_loaded,json=rowsLoaded" json:"rows_loaded,omitempty"`
	Nanoseconds   int64             `protobuf:"varint,5,opt,name=nanoseconds" json:"nanoseconds,omitempty"`
}

type MapRequest struct {
	Operands       []*ComputationDataHandle `protobuf:"bytes,2,rep,name=operands" json:"operands,omitempty"`
	ToApply        *ComputationHandle       `protobuf:"bytes,3,opt,name=to_apply,json=toApply" json:"to_apply,omitempty"`
	StaticOperands []*ComputationDataHandle `protobuf:"bytes,4,rep,name=static_operands,json=staticOperands" json:"static_operands,omitempty"`
}

type OpMetadata struct {
	// The framework op name that generated this XLA op.
	//
	// Frameworks that build on top of XLA should mirror the names of their ops
	// back to users by specifying the op_type. In this way, even if the
	// framework's "ops" are implemented as multiple XLA HLO Ops, they can be
	// grouped appropriately. (e.g. if a SoftMax layer is emitted into XLA as
	// multiple ops, then each op should have the op_type be "SoftMax".)
	OpType string `protobuf:"bytes,1,opt,name=op_type,json=opType" json:"op_type,omitempty"`
	// The user-specified name of the op.
	//
	// This name is often unique within a computation. Note: some frameworks
	// add auto-generated names if the user does not provide one.
	OpName string `protobuf:"bytes,2,opt,name=op_name,json=opName" json:"op_name,omitempty"`
	// Indicate a file and line that this op is associated to in a user's program.
	//
	// e.g. it could be the file and line of user code that generated the op.
	SourceFile string `protobuf:"bytes,3,opt,name=source_file,json=sourceFile" json:"source_file,omitempty"`
	SourceLine int32  `protobuf:"varint,4,opt,name=source_line,json=sourceLine" json:"source_line,omitempty"`
}

type OpRequest struct {
	Computation *ComputationHandle `protobuf:"bytes,1,opt,name=computation" json:"computation,omitempty"`
	Metadata    *OpMetadata        `protobuf:"bytes,33,opt,name=metadata" json:"metadata,omitempty"`
	// Types that are valid to be assigned to Op:
	//	*OpRequest_BinaryOpRequest
	//	*OpRequest_BroadcastRequest
	//	*OpRequest_CallRequest
	//	*OpRequest_ConcatenateRequest
	//	*OpRequest_ConstantRequest
	//	*OpRequest_ConvertRequest
	//	*OpRequest_ConvolveRequest
	//	*OpRequest_CrossReplicaSumRequest
	//	*OpRequest_CustomCallRequest
	//	*OpRequest_DynamicSliceRequest
	//	*OpRequest_DynamicUpdateSliceRequest
	//	*OpRequest_GetTupleElementRequest
	//	*OpRequest_InfeedRequest
	//	*OpRequest_MapRequest
	//	*OpRequest_PadRequest
	//	*OpRequest_ParameterRequest
	//	*OpRequest_ReducePrecisionRequest
	//	*OpRequest_ReduceRequest
	//	*OpRequest_ReduceWindowRequest
	//	*OpRequest_ReshapeRequest
	//	*OpRequest_ReverseRequest
	//	*OpRequest_RngRequest
	//	*OpRequest_SelectAndScatterRequest
	//	*OpRequest_SliceRequest
	//	*OpRequest_TernaryOpRequest
	//	*OpRequest_TraceRequest
	//	*OpRequest_TransposeRequest
	//	*OpRequest_UnaryOpRequest
	//	*OpRequest_VariadicOpRequest
	//	*OpRequest_WhileRequest
	//	*OpRequest_SendRequest
	//	*OpRequest_RecvRequest
	//	*OpRequest_OutfeedRequest
	//	*OpRequest_BatchNormTrainingRequest
	Op isOpRequest_Op `protobuf_oneof:"op"`
}

type OpRequest_BatchNormTrainingRequest struct {
	BatchNormTrainingRequest *BatchNormTrainingRequest `protobuf:"bytes,35,opt,name=batch_norm_training_request,json=batchNormTrainingRequest,oneof"`
}

type OpRequest_BinaryOpRequest struct {
	BinaryOpRequest *BinaryOpRequest `protobuf:"bytes,2,opt,name=binary_op_request,json=binaryOpRequest,oneof"`
}

type OpRequest_BroadcastRequest struct {
	BroadcastRequest *BroadcastRequest `protobuf:"bytes,3,opt,name=broadcast_request,json=broadcastRequest,oneof"`
}

type OpRequest_CallRequest struct {
	CallRequest *CallRequest `protobuf:"bytes,4,opt,name=call_request,json=callRequest,oneof"`
}

type OpRequest_ConcatenateRequest struct {
	ConcatenateRequest *ConcatenateRequest `protobuf:"bytes,5,opt,name=concatenate_request,json=concatenateRequest,oneof"`
}

type OpRequest_ConstantRequest struct {
	ConstantRequest *ConstantRequest `protobuf:"bytes,6,opt,name=constant_request,json=constantRequest,oneof"`
}

type OpRequest_ConvertRequest struct {
	ConvertRequest *ConvertRequest `protobuf:"bytes,7,opt,name=convert_request,json=convertRequest,oneof"`
}

type OpRequest_ConvolveRequest struct {
	ConvolveRequest *ConvolveRequest `protobuf:"bytes,8,opt,name=convolve_request,json=convolveRequest,oneof"`
}

type OpRequest_CrossReplicaSumRequest struct {
	CrossReplicaSumRequest *CrossReplicaSumRequest `protobuf:"bytes,9,opt,name=cross_replica_sum_request,json=crossReplicaSumRequest,oneof"`
}

type OpRequest_CustomCallRequest struct {
	CustomCallRequest *CustomCallRequest `protobuf:"bytes,10,opt,name=custom_call_request,json=customCallRequest,oneof"`
}

type OpRequest_DynamicSliceRequest struct {
	DynamicSliceRequest *DynamicSliceRequest `protobuf:"bytes,11,opt,name=dynamic_slice_request,json=dynamicSliceRequest,oneof"`
}

type OpRequest_DynamicUpdateSliceRequest struct {
	DynamicUpdateSliceRequest *DynamicUpdateSliceRequest `protobuf:"bytes,12,opt,name=dynamic_update_slice_request,json=dynamicUpdateSliceRequest,oneof"`
}

type OpRequest_GetTupleElementRequest struct {
	GetTupleElementRequest *GetTupleElementRequest `protobuf:"bytes,13,opt,name=get_tuple_element_request,json=getTupleElementRequest,oneof"`
}

type OpRequest_InfeedRequest struct {
	InfeedRequest *InfeedRequest `protobuf:"bytes,14,opt,name=infeed_request,json=infeedRequest,oneof"`
}

type OpRequest_MapRequest struct {
	MapRequest *MapRequest `protobuf:"bytes,15,opt,name=map_request,json=mapRequest,oneof"`
}

type OpRequest_OutfeedRequest struct {
	OutfeedRequest *OutfeedRequest `protobuf:"bytes,32,opt,name=outfeed_request,json=outfeedRequest,oneof"`
}

type OpRequest_PadRequest struct {
	PadRequest *PadRequest `protobuf:"bytes,16,opt,name=pad_request,json=padRequest,oneof"`
}

type OpRequest_ParameterRequest struct {
	ParameterRequest *ParameterRequest `protobuf:"bytes,17,opt,name=parameter_request,json=parameterRequest,oneof"`
}

type OpRequest_RecvRequest struct {
	RecvRequest *RecvRequest `protobuf:"bytes,31,opt,name=recv_request,json=recvRequest,oneof"`
}

type OpRequest_ReducePrecisionRequest struct {
	ReducePrecisionRequest *ReducePrecisionRequest `protobuf:"bytes,36,opt,name=reduce_precision_request,json=reducePrecisionRequest,oneof"`
}

type OpRequest_ReduceRequest struct {
	ReduceRequest *ReduceRequest `protobuf:"bytes,18,opt,name=reduce_request,json=reduceRequest,oneof"`
}

type OpRequest_ReduceWindowRequest struct {
	ReduceWindowRequest *ReduceWindowRequest `protobuf:"bytes,19,opt,name=reduce_window_request,json=reduceWindowRequest,oneof"`
}

type OpRequest_ReshapeRequest struct {
	ReshapeRequest *ReshapeRequest `protobuf:"bytes,20,opt,name=reshape_request,json=reshapeRequest,oneof"`
}

type OpRequest_ReverseRequest struct {
	ReverseRequest *ReverseRequest `protobuf:"bytes,21,opt,name=reverse_request,json=reverseRequest,oneof"`
}

type OpRequest_RngRequest struct {
	RngRequest *RngRequest `protobuf:"bytes,22,opt,name=rng_request,json=rngRequest,oneof"`
}

type OpRequest_SelectAndScatterRequest struct {
	SelectAndScatterRequest *SelectAndScatterRequest `protobuf:"bytes,23,opt,name=select_and_scatter_request,json=selectAndScatterRequest,oneof"`
}

type OpRequest_SendRequest struct {
	SendRequest *SendRequest `protobuf:"bytes,30,opt,name=send_request,json=sendRequest,oneof"`
}

type OpRequest_SliceRequest struct {
	SliceRequest *SliceRequest `protobuf:"bytes,24,opt,name=slice_request,json=sliceRequest,oneof"`
}

type OpRequest_TernaryOpRequest struct {
	TernaryOpRequest *TernaryOpRequest `protobuf:"bytes,25,opt,name=ternary_op_request,json=ternaryOpRequest,oneof"`
}

type OpRequest_TraceRequest struct {
	TraceRequest *TraceRequest `protobuf:"bytes,26,opt,name=trace_request,json=traceRequest,oneof"`
}

type OpRequest_TransposeRequest struct {
	TransposeRequest *TransposeRequest `protobuf:"bytes,34,opt,name=transpose_request,json=transposeRequest,oneof"`
}

type OpRequest_UnaryOpRequest struct {
	UnaryOpRequest *UnaryOpRequest `protobuf:"bytes,27,opt,name=unary_op_request,json=unaryOpRequest,oneof"`
}

type OpRequest_VariadicOpRequest struct {
	VariadicOpRequest *VariadicOpRequest `protobuf:"bytes,28,opt,name=variadic_op_request,json=variadicOpRequest,oneof"`
}

type OpRequest_WhileRequest struct {
	WhileRequest *WhileRequest `protobuf:"bytes,29,opt,name=while_request,json=whileRequest,oneof"`
}

type OpResponse struct {
	Output *ComputationDataHandle `protobuf:"bytes,1,opt,name=output" json:"output,omitempty"`
}

type OutfeedRequest struct {
	// The shape of the data returned by reading the device's outfeed buffer.
	Shape *Shape `protobuf:"bytes,1,opt,name=shape" json:"shape,omitempty"`
	// Operand to the Outfeed. Supports tuple.
	Operand *ComputationDataHandle `protobuf:"bytes,2,opt,name=operand" json:"operand,omitempty"`
	// Backend-specific information for how to perform the outfeed.
	OutfeedConfig []byte `protobuf:"bytes,3,opt,name=outfeed_config,json=outfeedConfig,proto3" json:"outfeed_config,omitempty"`
}

type PadRequest struct {
	Operand       *ComputationDataHandle `protobuf:"bytes,2,opt,name=operand" json:"operand,omitempty"`
	PaddingValue  *ComputationDataHandle `protobuf:"bytes,3,opt,name=padding_value,json=paddingValue" json:"padding_value,omitempty"`
	PaddingConfig *PaddingConfig         `protobuf:"bytes,4,opt,name=padding_config,json=paddingConfig" json:"padding_config,omitempty"`
}