package xla

Get desktop application:
View/edit binary Protocol Buffers messages

Used in: OpRequest

• optional ComputationDataHandle operand = 1

• optional ComputationDataHandle scale = 2

• optional ComputationDataHandle mean = 3

• optional ComputationDataHandle variance = 4

• optional ComputationDataHandle grad_output = 5

• float epsilon = 6

• int64 feature_index = 7

Used in: OpRequest

• optional ComputationDataHandle operand = 1

• optional ComputationDataHandle scale = 2

• optional ComputationDataHandle offset = 3

• optional ComputationDataHandle mean = 4

• optional ComputationDataHandle variance = 5

• float epsilon = 6

• int64 feature_index = 7

Used in: OpRequest

• optional ComputationDataHandle operand = 1

• optional ComputationDataHandle scale = 2

• optional ComputationDataHandle offset = 3

• float epsilon = 4

• int64 feature_index = 5

Used in: OpRequest

• BinaryOperation binop = 2

• optional ComputationDataHandle lhs = 3

• optional ComputationDataHandle rhs = 4

• repeated int64 broadcast_dimensions = 5

Used in: BinaryOpRequest

• BINOP_INVALID = 0

• BINOP_ADD = 1

  Arithmetic operations.

• BINOP_DIV = 2

• BINOP_MUL = 3

• BINOP_SUB = 4

• BINOP_EQ = 5

  Comparison operators.

• BINOP_GE = 6

• BINOP_GT = 7

• BINOP_LE = 8

• BINOP_LT = 9

• BINOP_NE = 10

• BINOP_DOT = 12

  Dot product, matrix multiply.

• BINOP_MAX = 14

  Element-wise maximum.

• BINOP_MIN = 15

  Element-wise minimum.

• BINOP_POW = 16

  Raises the left-hand-side to the right-hand-side power.

• BINOP_REM = 17

  Remainder operation.

• BINOP_AND = 18

  Element-wise, logical operators on booleans and bitwise operators on ints.

• BINOP_OR = 19

• BINOP_SHIFT_LEFT = 20

• BINOP_SHIFT_RIGHT_ARITHMETIC = 21

• BINOP_SHIFT_RIGHT_LOGICAL = 22

• BINOP_COMPLEX = 23

  Complex from real, imag.

• BINOP_ATAN2 = 24

  Computes the 4-quadrant arctangent of the y, x input arguments.

Used in: OpRequest

• optional ComputationDataHandle operand = 2

• repeated int64 broadcast_sizes = 3

Serialization of BufferAllocation.

Used in: BufferAssignmentProto

• int64 index = 1

• int64 size = 2

• bool is_thread_local = 3

• bool is_reusable = 4

• bool is_entry_computation_parameter = 5

• int64 parameter_number = 6

• bool maybe_live_out = 7

• int64 color = 8

• repeated BufferAllocationProto.Assigned assigned = 9

Assigned represents a single LogicalBuffer that is assigned to this BufferAllocation.

Used in: BufferAllocationProto

• int64 logical_buffer_id = 1

• int64 offset = 2

• int64 size = 3

Serialization of BufferAssignment.

Used in: HloProto

• repeated LogicalBufferProto logical_buffers = 1

• repeated BufferAssignmentProto.BufferAlias buffer_aliases = 2

• repeated BufferAllocationProto buffer_allocations = 3

• repeated HeapSimulatorTrace heap_simulator_traces = 4

Alias represents a source LogicalBuffer, and the buffer location that aliases it.

Used in: BufferAssignmentProto

• int64 source_buffer_id = 1

• optional LogicalBufferProto.Location location = 2

Used in: OpRequest

• optional ComputationHandle to_apply = 2

• repeated ComputationDataHandle operands = 3

Handle given to a user to represent a channel between two computations via a Send and Recv instruction pair. Channels are unbuffered, so Send Send instructions will be blocked until the data is transferred.

Used in: CreateChannelHandleResponse, RecvRequest, SendRequest

• int64 handle = 1

Handle given to a user that represents a data result in a computation. This is used to pass to subsequent computations that depends upon the data as an operand.

Used in: BatchNormGradRequest, BatchNormInferenceRequest, BatchNormTrainingRequest, BinaryOpRequest, BroadcastRequest, CallRequest, ComputeConstantRequest, ConcatenateRequest, ConvertRequest, ConvolveRequest, CrossReplicaSumRequest, CustomCallRequest, DynamicSliceRequest, DynamicUpdateSliceRequest, FftRequest, GetLocalShapeRequest, GetTupleElementRequest, IsConstantRequest, MapRequest, OpResponse, OperationRequest, OutfeedRequest, PadRequest, ReducePrecisionRequest, ReduceRequest, ReduceWindowRequest, ReshapeRequest, ReverseRequest, RngRequest, SelectAndScatterRequest, SendRequest, SetReturnValueRequest, SliceRequest, TernaryOpRequest, TraceRequest, TransposeRequest, UnaryOpRequest, VariadicOpRequest, WhileRequest

• int64 handle = 1

Handle given to a user that represents a computation that the user builds up before execution.

Used in: CallRequest, ComputationResponse, ComputationStatsRequest, ComputeConstantRequest, ExecuteAsyncRequest, ExecuteRequest, GetComputationShapeRequest, GetLocalShapeRequest, IsConstantRequest, LoadComputationSnapshotResponse, MapRequest, OpRequest, ReduceRequest, ReduceWindowRequest, SelectAndScatterRequest, SessionComputation, SetReturnValueRequest, SnapshotComputationRequest, SpecializeRequest, WhileRequest

• int64 handle = 1

• string name = 1

• optional ComputationHandle computation = 1

Statistics of a computation.

Used in: ComputationStatsResponse

• double flop_count = 1

  The number of floating point operations in the computation.

• double transcendental_count = 2

  The number of transcendental operations (e.g., exp) in the computation.

• optional ComputationHandle computation = 1

• optional DebugOptions debug_options = 2

• optional ComputationStats stats = 1

• optional ComputationHandle computation = 1

• optional ComputationDataHandle operand = 2

• optional Layout output_layout = 3

• repeated LiteralProto parameters = 4

• optional LiteralProto literal = 1

  A LiteralProto is returned directly for this request, instead of a ComputationDataHandle.

Used in: OpRequest

• repeated ComputationDataHandle operands = 2

• int64 dimension = 3

  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).

Used in: OpRequest

• optional LiteralProto literal = 2

Used in: OpRequest

• optional ComputationDataHandle operand = 2

• PrimitiveType new_element_type = 3

Used in: ConvolveRequest, HloInstructionProto

• int64 input_batch_dimension = 7

  The number of the dimension that represents batch in the input.

• int64 input_feature_dimension = 8

  The number of the dimension that represents features in the input.

• int64 output_batch_dimension = 9

  The number of the dimension that represents batch in the output.

• int64 output_feature_dimension = 10

  The number of the dimension that represents features in the output.

• repeated int64 spatial_dimensions = 5

  The dimension numbers for the spatial dimensions that the window moves through in the input (lhs) and output.

• int64 kernel_input_feature_dimension = 3

  The number of the dimension that represents input features in the convolutional kernel (rhs).

• int64 kernel_output_feature_dimension = 4

  The number of the dimension that represents output features in the convolutional kernel (rhs).

• repeated int64 kernel_spatial_dimensions = 6

  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.

Used in: OpRequest

• optional ComputationDataHandle lhs = 2

• optional ComputationDataHandle rhs = 3

  This is the filter/kernel.

• optional Window window = 4

  Describes the filter/kenel.

• optional ConvolutionDimensionNumbers dimension_numbers = 5

(message has no fields)

• optional ChannelHandle channel = 1

Used in: OpRequest

• optional ComputationDataHandle operand = 2

Used in: OpRequest

• string call_target_name = 2

• repeated ComputationDataHandle operands = 3

• optional Shape shape = 4

Debugging options for XLA. These options may change at any time - there are no guarantees about backward or forward compatibility for these fields.

Used in: ComputationStatsRequest, ExecutionOptions

• string xla_generate_hlo_graph = 1

  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.

• bool xla_hlo_graph_addresses = 2

  Show addresses of HLO ops in graph dump.

• string xla_hlo_graph_path = 4

  Path to dump HLO graphs to.

• bool xla_hlo_dump_as_graphdef = 5

  Dump HLO graphs as TensorFlow GraphDefs.

• string xla_log_hlo_text = 6

  HLO modules matching this regex will be dumped to LOG(INFO). Set to ".*" to dump *all* HLO modules.

• string xla_generate_hlo_text_to = 7

  Dump all HLO modules as text into the provided directory path.

• string xla_dump_hlo_proto_to = 8

  Dump compilation artifacts in binary proto into this directory.

• bool xla_hlo_profile = 9

  Instrument the computation to collect per-HLO cycle counts.

• string xla_dump_computations_to = 10

  Dumps computations that XLA executes into the provided directory path.

• string xla_dump_executions_to = 11

  Dumps parameters and results of computations that XLA executes into the provided directory path.

• repeated string xla_disable_hlo_passes = 30

  List of HLO passes to disable. These names must exactly match the pass names as specified by the HloPassInterface::name() method.

• int32 xla_backend_optimization_level = 31

  Numerical optimization level for the XLA compiler backend; the specific interpretation of this value is left to the backends.

• bool xla_enable_fast_math = 32

  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.

• bool xla_embed_ir_in_executable = 33

  Embed the compiler IR as a string in the executable.

• string xla_dump_ir_to = 34

  Dump the compiler IR into this directory as individual files.

• bool xla_eliminate_hlo_implicit_broadcast = 35

  Eliminate implicit broadcasts when lowering user computations to HLO instructions; use explicit broadcast instead.

• bool xla_cpu_multi_thread_eigen = 60

  When generating calls to Eigen in the CPU backend, use multi-threaded Eigen mode.

• string xla_gpu_cuda_data_dir = 61

  Path to directory with cuda/ptx tools and libraries.

• bool xla_gpu_ftz = 62

  Enable flush-to-zero semantics in the GPU backend.

• bool xla_gpu_disable_multi_streaming = 63

  Disable multi-streaming in the GPU backend.

• bool xla_llvm_enable_alias_scope_metadata = 70

  If true, in LLVM-based backends, emit !alias.scope metadata in generated IR.

• bool xla_llvm_enable_noalias_metadata = 71

  If true, in LLVM-based backends, emit !noalias metadata in the generated IR.

• bool xla_llvm_enable_invariant_load_metadata = 72

  If true, in LLVM-based backends, emit !invariant.load metadata in the generated IR.

• bool xla_llvm_disable_expensive_passes = 73

  If true, a set of expensive LLVM optimization passes will not be run.

• repeated HloReducePrecisionOptions hlo_reduce_precision_options = 80

  Options for inserting reduce-precision operations for numerical experimentation. This is a repeated field, as we may want to have multiple passes with different parameters.

• bool xla_test_all_output_layouts = 90

  This is used by ClientLibraryTestBase::ComputeAndCompare*. If true, the computation will run n! times with all permunations of layouts for the output shape in rank n. For example, with a 3D shape, all permutations of the set {0, 1, 2} are tried.

• bool xla_test_all_input_layouts = 91

  This is used by ClientLibraryTestBase::ComputeAndCompare*. If true, the computation will run for all permunations of layouts of all input arguments. For example, with 2 input arguments in 2D and 4D shapes, the computation will run 2! * 4! times.

• bool xla_hlo_graph_sharding_color = 92

  Assign colors based on sharding information when generating the Graphviz HLO graph.

• bool xla_hlo_tfgraph_device_scopes = 93

  Prefix the name scopes of the TF graph exports with "devX" device assignments, if available.

• map<string, string> xla_backend_extra_options = 500

  Extra options to pass to the compilation backend; specific interpretation of these values is left to the backend.

• optional GlobalDataHandle tuple_handle = 2

• repeated GlobalDataHandle element_handles = 1

DeviceAssignmentProto is a serialized form of DeviceAssignment class, which represents the device ids assigned to a set of replicated computations. See xla::DeviceAssignment class comment for more details.

• int32 replica_count = 1

• int32 computation_count = 2

• repeated DeviceAssignmentProto.ComputationDevice computation_devices = 3

Each logical computation runs on replica_count physical devices. ComputationDevice represents the device ids assinged to the replicas.

Used in: DeviceAssignmentProto

• repeated int32 replica_device_ids = 1

Handle given to a user that represents a replicated virtual device. Each replicated device represents N physical devices for execution where N is the number of replicas.

Used in: ExecutionOptions, GetDeviceHandlesResponse, ResetDeviceRequest, TransferFromOutfeedRequest, TransferToInfeedRequest, TransferToServerRequest

• int64 handle = 1

• int64 device_count = 2

  The number of model-parallel virtual devices that communicate via XLA Send/Recv instructions.

Used in: OpRequest

• optional ComputationDataHandle operand = 2

  Operand from which to slice at dynamic 'start_indices'.

• optional ComputationDataHandle start_indices = 3

  Dynamically computed 'start_indices' for slice operation.

• repeated int64 slice_sizes = 4

  Slice sizes for each dimension (note that indices calculations are computed modulo dimension sizes to avoid out-of-bound array accesses).

Used in: OpRequest

• optional ComputationDataHandle operand = 2

  Operand on which slice 'update' is to be applied.

• optional ComputationDataHandle update = 3

  The slice update to apply to 'operand'.

• optional ComputationDataHandle start_indices = 4

  Dynamically computed start indices for the update slice operation.

• optional ComputationHandle computation = 1

• repeated GlobalDataHandle arguments = 2

• optional ExecutionOptions execution_options = 6

  Options that affect how XLA compiles and runs code to service this request.

• optional ExecutionHandle execution = 1

  A handle to the execution launched asynchronously.

• repeated ExecuteRequest requests = 1

• repeated ExecuteResponse responses = 1

Used in: ExecuteParallelRequest

• optional ComputationHandle computation = 1

• repeated GlobalDataHandle arguments = 2

• optional ExecutionOptions execution_options = 5

  Options that affect how XLA compiles and runs code to service this request.

Used in: ExecuteParallelResponse

• optional GlobalDataHandle output = 1

• optional ExecutionProfile profile = 2

Handle given to a user that represents an execution that the user launched asynchronously on the device.

Used in: ExecuteAsyncResponse, WaitForExecutionRequest

• int64 handle = 1

These settings control how XLA compiles and/or runs code. Not all settings will have an effect on every platform. When adding new fields, keep in mind that boolean fields default to false.

Used in: ExecuteAsyncRequest, ExecuteRequest

• optional Shape shape_with_output_layout = 2

  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.

• uint64 seed = 3

  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.

• optional DebugOptions debug_options = 4

• repeated DeviceHandle device_handles = 5

  This optional field specifies a particular set of devices to run the computation on. The computation will be partitioned across these devices. If not provided, the default device will be chosen.

Profile data from the execution of a computation.

Used in: ExecuteResponse, WaitForExecutionResponse

• bool compilation_cache_hit = 1

  Whether the executable was read from the compilation cache.

• int64 compile_time_ms = 2

  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).

• int64 compute_cycle_count = 3

  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.

• int64 compute_time_ns = 4

  The time in nanoseconds spent for the computation, without data transfer.

• int64 compute_and_transfer_time_ns = 5

  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.

Used in: OpRequest

• FftType fft_type = 1

• repeated int64 fft_length = 2

  Multivalent for higher-order FFT.

• optional ComputationDataHandle operand = 3

Used in: FftRequest

• FFT = 0

  Forward FFT; complex in, complex out.

• IFFT = 1

  Inverse FFT; complex in, complex out.

• RFFT = 2

  Forward real FFT; real in, fft_length / 2 + 1 complex out

• IRFFT = 3

  Inverse real FFT; fft_length / 2 + 1 complex in,

• optional ComputationHandle computation = 1

• optional ProgramShape program_shape = 1

• int64 device_count = 1

• repeated DeviceHandle device_handles = 1

• optional ComputationHandle computation = 1

• optional ComputationDataHandle operand = 2

• optional Shape shape = 1

• optional GlobalDataHandle data = 1

• optional Shape shape = 1

Used in: OpRequest

• optional ComputationDataHandle operand = 2

• int64 index = 3

Handle given to a user that represents a globally accessible allocation. Contrast this against a ComputationDataHandle, which is not globally accessible, since it only exists within a specific computation.

Used in: DeconstructTupleRequest, DeconstructTupleResponse, ExecuteAsyncRequest, ExecuteRequest, ExecuteResponse, GetShapeRequest, LoadDataResponse, SpecializeRequest, TransferToClientRequest, TransferToServerResponse, UnpackRequest, UnpackResponse, UnregisterRequest, WaitForExecutionResponse

• int64 handle = 1

A trace of a HeapSimulator run.

Used in: BufferAssignmentProto

• repeated HeapSimulatorTrace.Event events = 1

• bool whole_module_simulation = 2

The trace includes a list of events, where each event describes one action performed by the heap simulator.

Used in: HeapSimulatorTrace

• Event.Kind kind = 1

• int64 buffer_id = 2

  The id of the LogicalBuffer that the event applies to.

• string computation_name = 3

  The HloInstruction that the simulation was processing that caused this event to occur, identified by its computation and instruction name. E.g. buffers defined by instruction A are allocated when processing A.

• string instruction_name = 4

• int64 share_with_canonical_id = 5

  The id of the canonical LogicalBuffer that the buffer shares with. Only set for SHARE_WITH events.

Used in: Event

• ALLOC = 0

  A memory region was allocated for the buffer.

• FREE = 1

  A memory region was freed for the buffer.

• SHARE_WITH = 2

  A buffer was shared with another (canonical) buffer. This is similar to ALLOC, except that instead of allocating a new region of memory, the memory region of the canonical buffer is directly re-used. Multiple buffers may share with the same canonical buffer. The lifetime of the canonical buffer is extended to the union of all lifetimes.

Serialization of HloComputation.

Used in: HloInstructionProto, HloModuleProto

• string name = 1

• repeated HloInstructionProto instructions = 2

  The array of instructions is always in a valid dependency order, where operands appear before their users.

• string root_name = 3

  The name of the root of the computation.

Serialization of HloInstruction.

Used in: HloComputationProto

• string name = 1

• string opcode = 2

• optional Shape shape = 3

• repeated string operand_names = 4

  TODO(b/67782397): Replace instruction names with HloInstruction ids.

• repeated string control_predecessor_names = 5

• repeated string called_computation_names = 6

• optional OpMetadata metadata = 7

• optional LiteralProto literal = 8

  Literal, only present for kConstant.

• int64 parameter_number = 9

  Parameter info, only present for kParameter.

• string parameter_name = 10

• string fusion_kind = 11

  Fusion state, only present for kFusion.

• optional HloComputationProto fused_instructions_computation = 12

• int64 tuple_index = 13

  Index for kGetTupleElement.

• repeated int64 dimensions = 14

  Dimensions present for some operations that require reshaping or broadcasting, including Reshape, Reduce, ReduceWindow, and Reverse.

• optional Window window = 15

  Describes the window in a windowed operation such as convolution.

• optional ConvolutionDimensionNumbers convolution_dimension_numbers = 16

  Describes the dimension numbers used for a convolution.

• repeated HloInstructionProto.SliceDimensions slice_dimensions = 17

• int32 exponent_bits = 18

  The bit sizes for a reduce-precision operation.

• int32 mantissa_bits = 19

• repeated int64 dynamic_slice_sizes = 20

  Describes the [start, start + size) range size for a dynamic slice ('start' is specified dynamically in the second operand of the operation).

• optional PaddingConfig padding_config = 21

  The padding configuration that describes the edge padding and interior padding of this pad instruction. Only set for pad instructions.

• bytes outfeed_config = 22

  Outfeed configuration information, only present for kOutfeed.

• RandomDistribution distribution = 23

  The distribution requested for random number generation. Only present for kRng.

• float epsilon = 24

  A small float number added to the variance to avoid divide-by-zero error. Only present for kBatchNormTraining.

• int64 feature_index = 25

  An integer value representing the index of the feature dimension. Only present for kBatchNormTraining.

• int64 channel_id = 26

  Represents a unique identifier for each Send/Recv instruction pair. Only present for kSend or kRecv.

• bytes infeed_config = 27

  The string representation of the infeed configuration.

• string custom_call_target = 28

  Name of a global symbol to call, only present for kCustomCall.

• optional Shape outfeed_shape = 29

  Shape of outfeed request.

Describes the [begin, end) index range and stride for slices.

Used in: HloInstructionProto

• int64 start = 1

• int64 limit = 2

• int64 stride = 3

Serialization of HloModule.

Used in: HloProto

• string name = 1

• string entry_computation_name = 2

• repeated HloComputationProto computations = 3

  The array of computations is always in a valid dependency order, where callees appear before their callers.

Serialization of HloOrdering.

Used in: HloProto

• repeated HloOrderingProto.SequentialComputation sequential_computations = 1

NOTE: currently only sequential orderings are serialized.

Used in: HloOrderingProto

• string computation_name = 1

• repeated string instruction_names = 2

Grouping message that contains all of the information above.

Used in: HloProtos

• optional HloModuleProto hlo_module = 1

• optional HloOrderingProto hlo_ordering = 2

• optional BufferAssignmentProto buffer_assignment = 3

• repeated HloProto hlo_protos = 1

Options for the HLO insert-reduce-precision-operations pass.

Used in: DebugOptions

• HloReducePrecisionOptions.Location location = 1

• uint32 exponent_bits = 2

  Exponent and mantissa bit counts for the reduced precision.

• uint32 mantissa_bits = 3

• repeated uint32 opcodes_to_suffix = 4

  Operations matching these opcodes should be suffixed with reduce-precision operations.

• repeated string opname_substrings_to_suffix = 5

  Operations with names containing these substrings should be suffixed with reduce-precision operations.

Where and when the reduce-precision operations will be added.

Used in: HloReducePrecisionOptions

• OP_INPUTS = 0

  Add reduce-precision operations to the inputs of selected instructions. This is done before any optimization occurs.

• OP_OUTPUTS = 1

  Add reduce-precision operations to the outputs of selected instructions. This is done before any optimization occurs.

• UNFUSED_OP_OUTPUTS = 2

  After operation-fusion occurs, add reduce-precision operations to the outputs of any selected instructions that have not been fused into fusion instructions.

• FUSION_INPUTS_BY_CONTENT = 3

  After operation-fusion occurs, add reduce-precision operations to the outputs of any fusion instructions that contain operations matching the selection criteria.

• FUSION_OUTPUTS_BY_CONTENT = 4

  After operation-fusion occurs, add reduce-precision operations to the outputs of any fusion instructions that contain operations matching the selection criteria.

Used in: OpRequest

• optional Shape shape = 2

  The shape of the data returned by reading the device's infeed buffer.

• bytes config = 3

  Additional infeed configuration for the backend.

• optional ComputationHandle computation = 1

• optional ComputationDataHandle operand = 2

• int64 num_parameters = 3

• bool is_constant = 1

A layout describes how the array is placed in (1D) memory space. This includes the minor-to-major ordering of dimensions within a shape, as well as any padding present in those dimensions. Clients must specify the layouts of input Literals to the computation. Layouts specified in interior operations which take Shapes (for example, Convert) are ignored. See the XLA documentation for more information on shapes and layouts.

Used in: ComputeConstantRequest, Shape

• repeated int64 minor_to_major = 1

  Sequence of dimension numbers, from minor (fastest varying index) to major (slowest varying index). This field is required.

• repeated int64 padded_dimensions = 2

  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.

• PaddingValue padding_value = 3

  Describes the values in the padding specified by padded_dimensions.

Literals are used when the server and client need to exchange materialized data / results. Literals are also used to describe constants used in computations. Transfers to/from the client are encoded in literal form, and the structure of the repeated fields is implied by the shape.

Used in: ComputeConstantRequest, ComputeConstantResponse, ConstantRequest, HloInstructionProto, SessionModule, TransferFromOutfeedResponse, TransferToClientResponse, TransferToInfeedRequest, TransferToServerRequest

• optional Shape shape = 1

• repeated bool preds = 2

• bytes u8s = 3

• repeated int32 s32s = 4

• repeated int64 s64s = 5

• repeated uint32 u32s = 6

• repeated uint64 u64s = 7

• repeated float f32s = 8

• repeated double f64s = 9

• repeated float c64s = 12

  Stored as interleaved real, imag floats.

• repeated LiteralProto tuple_literals = 10

• bytes f16s = 11

  The F16s and BF16s are encoded in little endian byte order

• bytes bf16s = 13

  Next = 14

• optional SessionModule module = 1

• optional ComputationHandle computation = 1

• string columnio_tablet_path = 1

  Describes the path of the ColumnIO tablet to load.

• string columnio_field = 2

  Describes the field to load within the ColumnIO tablet.

• optional Shape element_shape = 3

  Individual element shape, excluding rows.

• int64 offset = 4

  Warning: ColumnIO does not support random-access, so use offset with caution in performance-critical scenarios.

• int64 limit = 5

  Maximum number of elements (with shape element_shape) to load.

• bool zip = 6

  If more than one item is requested (via limit > 1), then this request attribute zips together the produced vectors.

• optional GlobalDataHandle data = 1

• optional Shape data_shape = 2

• int64 available_rows = 3

• int64 rows_loaded = 4

• int64 nanoseconds = 5

Serialization of LogicalBuffer.

Used in: BufferAssignmentProto

• int64 id = 1

• int64 size = 2

• optional LogicalBufferProto.Location defined_at = 3

  The location where the buffer is defined.

• int64 color = 4

Location represents an instruction and its shape index, which uniquely identifies a point where a buffer is needed.

Used in: BufferAssignmentProto.BufferAlias, LogicalBufferProto

• string computation_name = 1

  NOTE: module_name isn't necessary, since all LogicalBuffers are associated with a single HloModule.

• string instruction_name = 2

• repeated int64 shape_index = 3

Used in: OpRequest

• repeated ComputationDataHandle operands = 2

• optional ComputationHandle to_apply = 3

• repeated ComputationDataHandle static_operands = 4

• repeated int64 dimensions = 5

  The dimensions over which to map. Example mapping a Dot operation along the batch dimension 0: operand0.shape = [2, 2, 2], operand1.shape = [2,2,3] Map({operand0, operand1}, Dot, {0})

Symbolization metadata for HLO Instructions. This metadata is used for debugging XLA code generation, as well as performance profiling of XLA-generated executables.

Used in: HloInstructionProto, OpRequest

• string op_type = 1

  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".)

• string op_name = 2

  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.

• string source_file = 3

  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.

• int32 source_line = 4

Used in: OperationRequest

• optional ComputationHandle computation = 1

• optional OpMetadata metadata = 33

• optional OpSharding sharding = 40

• oneof op

  • BinaryOpRequest binary_op_request = 2

  • BroadcastRequest broadcast_request = 3

  • CallRequest call_request = 4

  • ConcatenateRequest concatenate_request = 5

  • ConstantRequest constant_request = 6

  • ConvertRequest convert_request = 7

  • ConvolveRequest convolve_request = 8

  • CrossReplicaSumRequest cross_replica_sum_request = 9

  • CustomCallRequest custom_call_request = 10

  • DynamicSliceRequest dynamic_slice_request = 11

  • DynamicUpdateSliceRequest dynamic_update_slice_request = 12

  • GetTupleElementRequest get_tuple_element_request = 13

  • InfeedRequest infeed_request = 14

  • MapRequest map_request = 15

  • PadRequest pad_request = 16

  • ParameterRequest parameter_request = 17

  • ReducePrecisionRequest reduce_precision_request = 36

  • ReduceRequest reduce_request = 18

  • ReduceWindowRequest reduce_window_request = 19

  • ReshapeRequest reshape_request = 20

  • ReverseRequest reverse_request = 21

  • RngRequest rng_request = 22

  • SelectAndScatterRequest select_and_scatter_request = 23

  • SliceRequest slice_request = 24

  • TernaryOpRequest ternary_op_request = 25

  • TraceRequest trace_request = 26

  • TransposeRequest transpose_request = 34

  • UnaryOpRequest unary_op_request = 27

  • VariadicOpRequest variadic_op_request = 28

  • WhileRequest while_request = 29

  • SendRequest send_request = 30

  • RecvRequest recv_request = 31

  • OutfeedRequest outfeed_request = 32

  • BatchNormTrainingRequest batch_norm_training_request = 35

  • BatchNormGradRequest batch_norm_grad_request = 37

  • BatchNormInferenceRequest batch_norm_inference_request = 38

  • FftRequest fft_request = 41

    Next: 42

• optional ComputationDataHandle output = 1

Used in: OpRequest

• OpSharding.Type type = 1

• optional Shape tile_shape = 2

  The shape of the sharded tile.

• repeated int64 tile_assignment_dimensions = 3

  The shape of the tile assignment tensor - this must be the same rank as tile_shape and the product of its dimensions must equal tile_assignment_devices.size().

• repeated int64 tile_assignment_devices = 4

  Flattened list of device IDs. The order of flattening is the same as used by IndexUtil::MultiToLinearIndex(tile_assignment_shape).

• repeated OpSharding tuple_shardings = 5

  If type == TUPLE, the sub-shardings, one per leaf node in the tuple shape, in pre-order. The tuple shape could be nested; here we store just a flattened list of all leaves in the tuple shape. Note that the tuple shape is not stored here; shardings do not store the shapes to which they are applied, this is inferred from the instruction this sharding gets attached to.

Used in: OpSharding

• REPLICATED = 0

  This sharding is replicated across all devices (implies maximal, all other fields are unused).

• MAXIMAL = 1

  This sharding is maximal - one device runs the entire operation.

• TUPLE = 2

  This sharding is a tuple - only the tuple_shardings field is valid.

• OTHER = 3

  None of the above; tile_shape and tile_assignment are both used.

Describes a single operation request.

Used in: SessionComputation

• optional ComputationDataHandle output_handle = 1

• optional Shape output_shape = 2

• repeated int64 embedded_computation_versions = 3

  For operations which call embedded computations such as "Map", these are the version(s) that the embedded computation should be called at. A version value of a computation is the ComputationDataHandle of the root of the computation at the point in time. "Call", "Map", "Reduce", and "ReduceWindow" operations take a single embedded computation so this field will have a single value for those operations. "While" operation takes two; index 0 is the "condition" version and index 1 is the "body" version.

• optional OpRequest request = 4

  The actual request, which in itself is a tagged union of all possible operation request types.

Used in: OpRequest

• optional Shape shape = 1

  The shape of the data returned by reading the device's outfeed buffer.

• optional ComputationDataHandle operand = 2

  Operand to the Outfeed. Supports tuple.

• bytes outfeed_config = 3

  Backend-specific information for how to perform the outfeed.

Used in: OpRequest

• optional ComputationDataHandle operand = 2

• optional ComputationDataHandle padding_value = 3

• optional PaddingConfig padding_config = 4

Describes the padding configuration for Pad operation. The padding amount on both edges as well as between the elements are specified for each dimension.

Used in: HloInstructionProto, PadRequest

• repeated PaddingConfig.PaddingConfigDimension dimensions = 1

  The padding configuration for all dimensions.

Describes the padding configuration for a dimension.

Used in: PaddingConfig

• int64 edge_padding_low = 1

  Padding amount on the low-end (next to the index 0).

• int64 edge_padding_high = 2

  Padding amount on the high-end (next to the highest index).

• int64 interior_padding = 3

  Padding amount between the elements.

Describes the value held inside padding elements.

Used in: Layout

• INVALID_PAD = 0

• ZERO_PAD = 1

  Zero padding must be 0-values that correspond to the shape's element type.

• ONE_PAD = 2

  One padding must be 1-values that correspond to the shape's element type.

• LOWEST_PAD = 3

  "Lowest" padding must be the lowest values in the shape's element type, used as padding for operations like max-accumulation.

• HIGHEST_PAD = 4

  "Highest" padding must be the largest values in the shape's element type, used as padding for operations like min-accumulation.

• UNKNOWN_PAD = 5

  Unknown padding could be anything; e.g. floating NaNs!

Used in: OpRequest

• optional Shape shape = 2

• int64 parameter = 3

• string name = 4

Primitive types are the individual values that can be held in rectangular multidimensional arrays. A description of the rectangular multidimensional array dimensions / primitive type is given by Shape, below.

Used in: ConvertRequest, Shape

• PRIMITIVE_TYPE_INVALID = 0

  Invalid primitive type to serve as default.

• PRED = 1

  Predicates are two-state booleans.

• S8 = 2

  Signed integral values of fixed width.

• S16 = 3

• S32 = 4

• S64 = 5

• U8 = 6

  Unsigned integral values of fixed width.

• U16 = 7

• U32 = 8

• U64 = 9

• F16 = 10

  Floating-point values of fixed width. Note: if f16s are not natively supported on the device, they will be converted to f16 from f32 at arbirary points in the computation.

• F32 = 11

• BF16 = 16

  Truncated 16 bit floating-point format. This is similar to IEEE's 16 bit floating-point format, but uses 1 bit for the sign, 8 bits for the exponent and 7 bits for the mantissa.

• F64 = 12

• C64 = 15

  Complex values of fixed width.

  Paired F32 (real, imag), as in std::complex<float>.

• TUPLE = 13

  A tuple is a polymorphic sequence; e.g. a shape that holds different sub-shapes. They are used for things like returning multiple values from a computation; e.g. a computation that returns weights and biases may have a signature that results in a tuple like (f32[784x2000], f32[2000]) If a shape proto has the tuple element type, it may not have any entries in the dimensions field.

• OPAQUE = 14

  An opaque type used for passing context specific data to a custom operation.

Shape of the parameters and output of a computation (like a traditional function signature).

Used in: GetComputationShapeResponse

• repeated Shape parameters = 1

• optional Shape result = 2

• repeated string parameter_names = 3

Used in: HloInstructionProto, RngRequest

• RNG_INVALID = 0

• RNG_UNIFORM = 1

  Creates a uniform-distribution-generated random number on the semi-open interval [parameter[0], parameter[1]).

• RNG_NORMAL = 2

  Creates a normal-distribution-generated random number with mean parameter[0] and standard deviation parameter[1].

• RNG_BERNOULLI = 3

  Creates a Bernoulli-distribution-generated random number with mean parameter[0].

Used in: OpRequest

• optional Shape shape = 1

• optional ChannelHandle channel_handle = 2

Used in: OpRequest

• optional ComputationDataHandle operand = 1

• int32 exponent_bits = 2

• int32 mantissa_bits = 3

Used in: OpRequest

• optional ComputationDataHandle operand = 2

  Operand to the reduction.

• optional ComputationDataHandle init_value = 3

  Initial value for the reduction. This must be consistent with the result shape of to_apply.

• repeated int64 dimensions = 4

  The dimensions to reduce over.

• optional ComputationHandle to_apply = 5

  The computation to apply in the reduction.

Used in: OpRequest

• optional ComputationDataHandle operand = 2

• optional ComputationDataHandle init_value = 3

• optional Window window = 4

• optional ComputationHandle to_apply = 5

• optional DeviceHandle device_handle = 1

(message has no fields)

Used in: OpRequest

• optional ComputationDataHandle operand = 2

• repeated int64 dimensions = 3

  The dimension order for collapse (from fastest-changing to slowest).

• repeated int64 new_sizes = 4

  The new dimension sizes (from dimension 0 to n-1).

Used in: OpRequest

• optional ComputationDataHandle operand = 2

• repeated int64 dimensions = 3

Used in: OpRequest

• RandomDistribution distribution = 2

• repeated ComputationDataHandle parameter = 3

• optional Shape shape = 4

Used in: OpRequest

• optional ComputationDataHandle operand = 2

  Operand array on which the windows slide.

• optional ComputationDataHandle source = 3

  Source array for the data to scatter.

• optional ComputationDataHandle init_value = 4

  Initial scalar value for each element in the output.

• optional Window window = 5

  Window configuration.

• optional ComputationHandle select = 6

  Binary function used to select an element from each window.

• optional ComputationHandle scatter = 7

  Binary function used to combine each scattered value from source with the current output value at the selected location.

Used in: OpRequest

• optional ComputationDataHandle operand = 1

• optional ChannelHandle channel_handle = 2

Describes a sequence of operation requests which define an XLA computation.

Used in: SessionModule

• string name = 1

• optional ComputationHandle computation_handle = 2

  The ComputationHandle used to refer to this computation in the XLA service.

• map<int64, OperationRequest> requests = 3

  Map from ComputationDataHandle value to operation request. The highest ComputationDataHandle value corresponds to the root of the computation.

Describes a group of SessionComputations with an "entry point" computation that may refer to the other non-entry (AKA embedded) computations. This message is used to serialize a computation that has been built via the XLA service API, along with its dependencies, for purposes such as analysis/replay/file-storage.

Used in: LoadComputationSnapshotRequest, SnapshotComputationResponse

• optional SessionComputation entry = 1

  The entry computation, which was requested for serialization. This may have referred to embedded computations, which are reflected below.

• repeated SessionComputation embedded_computations = 2

  Embedded computations that are transitively referred to by the entry computation.

• repeated LiteralProto arguments = 3

  The arguments passed to the computation.

• optional LiteralProto result = 4

  The result of the computation.

• string execution_platform = 5

  The name of the platform used to run the computation.

• optional ComputationHandle computation = 1

• optional ComputationDataHandle operand = 2

(message has no fields)

A shape describes the number of dimensions in the array, the size of each dimension, and the primitive component type. Tuples are a special case in that they have rank zero and have tuple_shapes defined. See the XLA documentation for more information on shapes and layouts.

Used in: CustomCallRequest, ExecutionOptions, GetLocalShapeResponse, GetShapeResponse, HloInstructionProto, InfeedRequest, LiteralProto, LoadDataRequest, LoadDataResponse, OpSharding, OperationRequest, OutfeedRequest, ParameterRequest, ProgramShape, RecvRequest, RngRequest, TransferFromOutfeedRequest, TransferToClientRequest

• PrimitiveType element_type = 2

  The element type for this shape.

• repeated int64 dimensions = 3

  The size (number of elements) for each dimension. In XLA, dimensions are numbered from 0 to N-1 for an N-dimensional array. The first element of 'dimensions' is the size of dimension 0, the second element is the size of dimension 1, and so forth. Empty list indicates a scalar.

• repeated Shape tuple_shapes = 4

  For tuples only, the shapes of constitutent shapes in the tuple sequence.

• optional Layout layout = 5

  The layout used to back this shape.

Used in: OpRequest

• optional ComputationDataHandle operand = 2

• repeated int64 start_indices = 3

• repeated int64 limit_indices = 4

• repeated int64 strides = 5

• optional ComputationHandle computation = 1

• optional SessionModule module = 1

• optional ComputationHandle computation = 1

• repeated GlobalDataHandle arguments = 2

(message has no fields)

Used in: OpRequest

• TernaryOperation triop = 2

• optional ComputationDataHandle lhs = 3

• optional ComputationDataHandle rhs = 4

• optional ComputationDataHandle ehs = 5

Used in: TernaryOpRequest

• TRIOP_INVALID = 0

• TRIOP_SELECT = 1

  Given a predicate and two operands, selects operand0 if the predicate is true and operand1 if the predicate is false.

• TRIOP_CLAMP = 3

  Given a min, max and an operand returns the operand if between min and max, else returns min if operand is less than min or max if operand is greater than max.

Used in: OpRequest

• string tag = 2

• optional ComputationDataHandle operand = 3

• optional Shape shape_with_layout = 1

  This optional field directs the service to return the literal in this layout. A shape is used to hold the layout to accommodate tuples.

• int64 replica_id = 2

• optional DeviceHandle device_handle = 3

• optional LiteralProto literal = 1

• optional GlobalDataHandle data = 1

• optional Shape shape_with_layout = 2

  This optional field directs the service to return the literal in this layout. A shape is used to hold the layout to accommodate tuples.

• optional LiteralProto literal = 1

• optional LiteralProto literal = 1

• int64 replica_id = 2

• optional DeviceHandle device_handle = 3

(message has no fields)

• optional LiteralProto literal = 1

• optional DeviceHandle device_handle = 2

• optional GlobalDataHandle data = 1

Used in: OpRequest

• optional ComputationDataHandle operand = 2

• repeated int64 dimensions = 3

  The permutation of the operand's dimensions (in the range 0 to n-1).

Used in: OpRequest

• UnaryOperation unop = 2

• optional ComputationDataHandle operand = 3

Used in: UnaryOpRequest

• UNOP_INVALID = 0

• UNOP_NOT = 1

  Elementwise, logical negation on booleans and bitwise negation on ints.

• UNOP_EXP = 2

  Elementwise, computes e^x.

• UNOP_NEGATE = 3

  Elementwise, computes -x.

• UNOP_SORT = 4

  Puts the elements in the operand into sorted order.

• UNOP_TANH = 5

  Elementwise, computes tanh(x).

• UNOP_LOG = 6

  Elementwise, computes the natural logarithm of x.

• UNOP_FLOOR = 7

  Elementwise, computes the floor of x.

• UNOP_CEIL = 8

  Elementwise, computes the ceil of x.

• UNOP_ABS = 9

  Elementwise, computes the abs of x.

• UNOP_SIGN = 10

  Elementwise, computes the sign of x.

• UNOP_IS_FINITE = 11

  Elementwise, tests if values are finite (not NaN or inf)

• UNOP_COS = 12

  Elementwise, computes the cosine of x.

• UNOP_SIN = 13

  Elementwise, computes the sine of x.

• UNOP_ROUND_NEAREST_AFZ = 14

  Elementwise, rounds x to nearest integral value, rounding half-way cases away from zero.

• UNOP_REAL = 15

  Elementwise, extract real component of complex x.

• UNOP_IMAG = 16

  Elementwise, extract real component of complex x.

• optional GlobalDataHandle data = 1

• repeated GlobalDataHandle tied_data = 1

• optional GlobalDataHandle data = 1

(message has no fields)

Used in: OpRequest

• VariadicOperation varop = 2

• repeated ComputationDataHandle operands = 3

Used in: VariadicOpRequest

• VAROP_INVALID = 0

• VAROP_TUPLE = 1

  Creates a tuple from its operands.

• optional ExecutionHandle execution = 1

• optional GlobalDataHandle output = 1

• optional ExecutionProfile profile = 2

Used in: OpRequest

• optional ComputationHandle condition = 2

• optional ComputationHandle body = 3

• optional ComputationDataHandle init = 4

Describes the windowing in an operation such as convolution. The window is moved across a base area and for each position of the window a computation is performed. The field below describes the window and the movement of the window across a base area.

Used in: ConvolveRequest, HloInstructionProto, ReduceWindowRequest, SelectAndScatterRequest

• repeated WindowDimension dimensions = 1

Used in: Window

• int64 size = 1

  The size of the window in this dimension. For a rectangle, this would be the width or height.

• int64 stride = 2

  The stride at which the window moves across the base area in this dimension. In other words, this is the spacing between different positions of the window in this dimension.

• int64 padding_low = 3

  If positive, means the amount of padding with zeroes to add to the base area at the low end of this dimension; if negative, its negative means the number of elements removed from the low end of this dimension. For example, in the horizontal dimension of a rectangle, this would be the number of zeroes to pad on the left, given that indices increase when going right.

• int64 padding_high = 4

  As padding_low, but on the high end of this dimension. For example, in the horizontal dimension of a rectangle, this would be the number of zeroes to pad on the right, given that indices increase when going right.

• int64 window_dilation = 5

  Dilation factor of the sliding window in this dimension. A dilation factor of 1 means no dilation. window_dilation - 1 no-op entries ("holes") are implicitly placed between each kernel element. See documentation for convolution.

• int64 base_dilation = 6

  Dilation factor of the base area in this dimension. A dilation factor of 1 means no dilation. base_dilation - 1 no-op entries ("holes") are implicitly placed between each base area element. See documentation for convolution.