// Generated by the protocol buffer compiler. DO NOT EDIT! // source: xla/xla.proto #ifndef GOOGLE_PROTOBUF_INCLUDED_xla_2fxla_2eproto #define GOOGLE_PROTOBUF_INCLUDED_xla_2fxla_2eproto #include #include #include #if PROTOBUF_VERSION < 3021000 #error This file was generated by a newer version of protoc which is #error incompatible with your Protocol Buffer headers. Please update #error your headers. #endif #if 3021009 < PROTOBUF_MIN_PROTOC_VERSION #error This file was generated by an older version of protoc which is #error incompatible with your Protocol Buffer headers. Please #error regenerate this file with a newer version of protoc. #endif #include #include #include #include #include #include #include #include #include // IWYU pragma: export #include // IWYU pragma: export #include // IWYU pragma: export #include #include #include #include #include #include "xla/service/hlo.pb.h" #include "xla/xla_data.pb.h" // @@protoc_insertion_point(includes) #include #define PROTOBUF_INTERNAL_EXPORT_xla_2fxla_2eproto PROTOBUF_NAMESPACE_OPEN namespace internal { class AnyMetadata; } // namespace internal PROTOBUF_NAMESPACE_CLOSE // Internal implementation detail -- do not use these members. struct TableStruct_xla_2fxla_2eproto { static const uint32_t offsets[]; }; extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_xla_2fxla_2eproto; namespace xla { class CompilationEnvironmentsProto; struct CompilationEnvironmentsProtoDefaultTypeInternal; extern CompilationEnvironmentsProtoDefaultTypeInternal _CompilationEnvironmentsProto_default_instance_; class DebugOptions; struct DebugOptionsDefaultTypeInternal; extern DebugOptionsDefaultTypeInternal _DebugOptions_default_instance_; class DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse; struct DebugOptions_XlaBackendExtraOptionsEntry_DoNotUseDefaultTypeInternal; extern DebugOptions_XlaBackendExtraOptionsEntry_DoNotUseDefaultTypeInternal _DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse_default_instance_; class DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse; struct DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUseDefaultTypeInternal; extern DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUseDefaultTypeInternal _DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse_default_instance_; class ExecutionOptions; struct ExecutionOptionsDefaultTypeInternal; extern ExecutionOptionsDefaultTypeInternal _ExecutionOptions_default_instance_; class GpuCompilationEnvironment; struct GpuCompilationEnvironmentDefaultTypeInternal; extern GpuCompilationEnvironmentDefaultTypeInternal _GpuCompilationEnvironment_default_instance_; class HloModuleConfigProto; struct HloModuleConfigProtoDefaultTypeInternal; extern HloModuleConfigProtoDefaultTypeInternal _HloModuleConfigProto_default_instance_; class HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse; struct HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUseDefaultTypeInternal; extern HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUseDefaultTypeInternal _HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse_default_instance_; class HloModuleConfigProto_BoolList; struct HloModuleConfigProto_BoolListDefaultTypeInternal; extern HloModuleConfigProto_BoolListDefaultTypeInternal _HloModuleConfigProto_BoolList_default_instance_; class HloModuleConfigProto_DotConfigEntry_DoNotUse; struct HloModuleConfigProto_DotConfigEntry_DoNotUseDefaultTypeInternal; extern HloModuleConfigProto_DotConfigEntry_DoNotUseDefaultTypeInternal _HloModuleConfigProto_DotConfigEntry_DoNotUse_default_instance_; class HloModuleConfigProto_Int64List; struct HloModuleConfigProto_Int64ListDefaultTypeInternal; extern HloModuleConfigProto_Int64ListDefaultTypeInternal _HloModuleConfigProto_Int64List_default_instance_; class HloModuleConfigProto_Int64ListList; struct HloModuleConfigProto_Int64ListListDefaultTypeInternal; extern HloModuleConfigProto_Int64ListListDefaultTypeInternal _HloModuleConfigProto_Int64ListList_default_instance_; class HloModuleProtoWithConfig; struct HloModuleProtoWithConfigDefaultTypeInternal; extern HloModuleProtoWithConfigDefaultTypeInternal _HloModuleProtoWithConfig_default_instance_; class NodeShardingConfigProto; struct NodeShardingConfigProtoDefaultTypeInternal; extern NodeShardingConfigProtoDefaultTypeInternal _NodeShardingConfigProto_default_instance_; class ScheduleProto; struct ScheduleProtoDefaultTypeInternal; extern ScheduleProtoDefaultTypeInternal _ScheduleProto_default_instance_; class ScheduleProto_Instruction; struct ScheduleProto_InstructionDefaultTypeInternal; extern ScheduleProto_InstructionDefaultTypeInternal _ScheduleProto_Instruction_default_instance_; class ShardableValueUpdatePairProto; struct ShardableValueUpdatePairProtoDefaultTypeInternal; extern ShardableValueUpdatePairProtoDefaultTypeInternal _ShardableValueUpdatePairProto_default_instance_; class ShardingConfigProto; struct ShardingConfigProtoDefaultTypeInternal; extern ShardingConfigProtoDefaultTypeInternal _ShardingConfigProto_default_instance_; } // namespace xla PROTOBUF_NAMESPACE_OPEN template<> ::xla::CompilationEnvironmentsProto* Arena::CreateMaybeMessage<::xla::CompilationEnvironmentsProto>(Arena*); template<> ::xla::DebugOptions* Arena::CreateMaybeMessage<::xla::DebugOptions>(Arena*); template<> ::xla::DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse* Arena::CreateMaybeMessage<::xla::DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse>(Arena*); template<> ::xla::DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse* Arena::CreateMaybeMessage<::xla::DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse>(Arena*); template<> ::xla::ExecutionOptions* Arena::CreateMaybeMessage<::xla::ExecutionOptions>(Arena*); template<> ::xla::GpuCompilationEnvironment* Arena::CreateMaybeMessage<::xla::GpuCompilationEnvironment>(Arena*); template<> ::xla::HloModuleConfigProto* Arena::CreateMaybeMessage<::xla::HloModuleConfigProto>(Arena*); template<> ::xla::HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse* Arena::CreateMaybeMessage<::xla::HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse>(Arena*); template<> ::xla::HloModuleConfigProto_BoolList* Arena::CreateMaybeMessage<::xla::HloModuleConfigProto_BoolList>(Arena*); template<> ::xla::HloModuleConfigProto_DotConfigEntry_DoNotUse* Arena::CreateMaybeMessage<::xla::HloModuleConfigProto_DotConfigEntry_DoNotUse>(Arena*); template<> ::xla::HloModuleConfigProto_Int64List* Arena::CreateMaybeMessage<::xla::HloModuleConfigProto_Int64List>(Arena*); template<> ::xla::HloModuleConfigProto_Int64ListList* Arena::CreateMaybeMessage<::xla::HloModuleConfigProto_Int64ListList>(Arena*); template<> ::xla::HloModuleProtoWithConfig* Arena::CreateMaybeMessage<::xla::HloModuleProtoWithConfig>(Arena*); template<> ::xla::NodeShardingConfigProto* Arena::CreateMaybeMessage<::xla::NodeShardingConfigProto>(Arena*); template<> ::xla::ScheduleProto* Arena::CreateMaybeMessage<::xla::ScheduleProto>(Arena*); template<> ::xla::ScheduleProto_Instruction* Arena::CreateMaybeMessage<::xla::ScheduleProto_Instruction>(Arena*); template<> ::xla::ShardableValueUpdatePairProto* Arena::CreateMaybeMessage<::xla::ShardableValueUpdatePairProto>(Arena*); template<> ::xla::ShardingConfigProto* Arena::CreateMaybeMessage<::xla::ShardingConfigProto>(Arena*); PROTOBUF_NAMESPACE_CLOSE namespace xla { enum DebugOptions_CollectiveOpType : int { DebugOptions_CollectiveOpType_NOOP = 0, DebugOptions_CollectiveOpType_ALLREDUCE = 1, DebugOptions_CollectiveOpType_ALLGATHER = 2, DebugOptions_CollectiveOpType_REDUCESCATTER = 3, DebugOptions_CollectiveOpType_COLLECTIVEBROADCAST = 4, DebugOptions_CollectiveOpType_ALLTOALL = 5, DebugOptions_CollectiveOpType_COLLECTIVEPERMUTE = 6, DebugOptions_CollectiveOpType_RAGGEDALLTOALL = 7, DebugOptions_CollectiveOpType_DebugOptions_CollectiveOpType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), DebugOptions_CollectiveOpType_DebugOptions_CollectiveOpType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DebugOptions_CollectiveOpType_IsValid(int value); constexpr DebugOptions_CollectiveOpType DebugOptions_CollectiveOpType_CollectiveOpType_MIN = DebugOptions_CollectiveOpType_NOOP; constexpr DebugOptions_CollectiveOpType DebugOptions_CollectiveOpType_CollectiveOpType_MAX = DebugOptions_CollectiveOpType_RAGGEDALLTOALL; constexpr int DebugOptions_CollectiveOpType_CollectiveOpType_ARRAYSIZE = DebugOptions_CollectiveOpType_CollectiveOpType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugOptions_CollectiveOpType_descriptor(); template inline const std::string& DebugOptions_CollectiveOpType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DebugOptions_CollectiveOpType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DebugOptions_CollectiveOpType_descriptor(), enum_t_value); } inline bool DebugOptions_CollectiveOpType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DebugOptions_CollectiveOpType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DebugOptions_CollectiveOpType_descriptor(), name, value); } enum DebugOptions_CommandBufferCmdType : int { DebugOptions_CommandBufferCmdType_INVALID = 0, DebugOptions_CommandBufferCmdType_FUSION = 1, DebugOptions_CommandBufferCmdType_CUBLAS = 2, DebugOptions_CommandBufferCmdType_CUDNN = 3, DebugOptions_CommandBufferCmdType_COLLECTIVES = 4, DebugOptions_CommandBufferCmdType_CONDITIONAL = 5, DebugOptions_CommandBufferCmdType_WHILE = 6, DebugOptions_CommandBufferCmdType_CUSTOM_CALL = 7, DebugOptions_CommandBufferCmdType_CUBLASLT = 8, DebugOptions_CommandBufferCmdType_DYNAMIC_SLICE_FUSION = 9, DebugOptions_CommandBufferCmdType_DebugOptions_CommandBufferCmdType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), DebugOptions_CommandBufferCmdType_DebugOptions_CommandBufferCmdType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DebugOptions_CommandBufferCmdType_IsValid(int value); constexpr DebugOptions_CommandBufferCmdType DebugOptions_CommandBufferCmdType_CommandBufferCmdType_MIN = DebugOptions_CommandBufferCmdType_INVALID; constexpr DebugOptions_CommandBufferCmdType DebugOptions_CommandBufferCmdType_CommandBufferCmdType_MAX = DebugOptions_CommandBufferCmdType_DYNAMIC_SLICE_FUSION; constexpr int DebugOptions_CommandBufferCmdType_CommandBufferCmdType_ARRAYSIZE = DebugOptions_CommandBufferCmdType_CommandBufferCmdType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugOptions_CommandBufferCmdType_descriptor(); template inline const std::string& DebugOptions_CommandBufferCmdType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DebugOptions_CommandBufferCmdType_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DebugOptions_CommandBufferCmdType_descriptor(), enum_t_value); } inline bool DebugOptions_CommandBufferCmdType_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DebugOptions_CommandBufferCmdType* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DebugOptions_CommandBufferCmdType_descriptor(), name, value); } enum DebugOptions_LibNvJitLinkMode : int { DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_AUTO = 0, DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_DISABLED = 1, DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_ENABLED = 2, DebugOptions_LibNvJitLinkMode_DebugOptions_LibNvJitLinkMode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), DebugOptions_LibNvJitLinkMode_DebugOptions_LibNvJitLinkMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DebugOptions_LibNvJitLinkMode_IsValid(int value); constexpr DebugOptions_LibNvJitLinkMode DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_MIN = DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_AUTO; constexpr DebugOptions_LibNvJitLinkMode DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_MAX = DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_ENABLED; constexpr int DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_ARRAYSIZE = DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugOptions_LibNvJitLinkMode_descriptor(); template inline const std::string& DebugOptions_LibNvJitLinkMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DebugOptions_LibNvJitLinkMode_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DebugOptions_LibNvJitLinkMode_descriptor(), enum_t_value); } inline bool DebugOptions_LibNvJitLinkMode_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DebugOptions_LibNvJitLinkMode* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DebugOptions_LibNvJitLinkMode_descriptor(), name, value); } enum DebugOptions_PGLEStrictnessLevel : int { DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_OFF = 0, DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_WARN = 1, DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_ERROR = 2, DebugOptions_PGLEStrictnessLevel_DebugOptions_PGLEStrictnessLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), DebugOptions_PGLEStrictnessLevel_DebugOptions_PGLEStrictnessLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DebugOptions_PGLEStrictnessLevel_IsValid(int value); constexpr DebugOptions_PGLEStrictnessLevel DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_MIN = DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_OFF; constexpr DebugOptions_PGLEStrictnessLevel DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_MAX = DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_ERROR; constexpr int DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_ARRAYSIZE = DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugOptions_PGLEStrictnessLevel_descriptor(); template inline const std::string& DebugOptions_PGLEStrictnessLevel_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DebugOptions_PGLEStrictnessLevel_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DebugOptions_PGLEStrictnessLevel_descriptor(), enum_t_value); } inline bool DebugOptions_PGLEStrictnessLevel_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DebugOptions_PGLEStrictnessLevel* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DebugOptions_PGLEStrictnessLevel_descriptor(), name, value); } enum DebugOptions_ShapeChecks : int { DebugOptions_ShapeChecks_IGNORE = 0, DebugOptions_ShapeChecks_RUNTIME = 1, DebugOptions_ShapeChecks_COMPILE_TIME = 2, DebugOptions_ShapeChecks_DebugOptions_ShapeChecks_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), DebugOptions_ShapeChecks_DebugOptions_ShapeChecks_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DebugOptions_ShapeChecks_IsValid(int value); constexpr DebugOptions_ShapeChecks DebugOptions_ShapeChecks_ShapeChecks_MIN = DebugOptions_ShapeChecks_IGNORE; constexpr DebugOptions_ShapeChecks DebugOptions_ShapeChecks_ShapeChecks_MAX = DebugOptions_ShapeChecks_COMPILE_TIME; constexpr int DebugOptions_ShapeChecks_ShapeChecks_ARRAYSIZE = DebugOptions_ShapeChecks_ShapeChecks_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugOptions_ShapeChecks_descriptor(); template inline const std::string& DebugOptions_ShapeChecks_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DebugOptions_ShapeChecks_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DebugOptions_ShapeChecks_descriptor(), enum_t_value); } inline bool DebugOptions_ShapeChecks_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DebugOptions_ShapeChecks* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DebugOptions_ShapeChecks_descriptor(), name, value); } enum DebugOptions_WhileLoopUnrolling : int { DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_NO_UNROLL = 0, DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_DOUBLE_BUFFER = 1, DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_FULL_UNROLL = 2, DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_AUTO_UNROLL = 3, DebugOptions_WhileLoopUnrolling_DebugOptions_WhileLoopUnrolling_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), DebugOptions_WhileLoopUnrolling_DebugOptions_WhileLoopUnrolling_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DebugOptions_WhileLoopUnrolling_IsValid(int value); constexpr DebugOptions_WhileLoopUnrolling DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_MIN = DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_NO_UNROLL; constexpr DebugOptions_WhileLoopUnrolling DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_MAX = DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_AUTO_UNROLL; constexpr int DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_ARRAYSIZE = DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugOptions_WhileLoopUnrolling_descriptor(); template inline const std::string& DebugOptions_WhileLoopUnrolling_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DebugOptions_WhileLoopUnrolling_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DebugOptions_WhileLoopUnrolling_descriptor(), enum_t_value); } inline bool DebugOptions_WhileLoopUnrolling_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DebugOptions_WhileLoopUnrolling* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DebugOptions_WhileLoopUnrolling_descriptor(), name, value); } enum DebugOptions_XnnGraphFusionMode : int { DebugOptions_XnnGraphFusionMode_XNN_GRAPH_FUSION_MODE_DISABLED = 0, DebugOptions_XnnGraphFusionMode_XNN_GRAPH_FUSION_MODE_GREEDY = 1, DebugOptions_XnnGraphFusionMode_DebugOptions_XnnGraphFusionMode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), DebugOptions_XnnGraphFusionMode_DebugOptions_XnnGraphFusionMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DebugOptions_XnnGraphFusionMode_IsValid(int value); constexpr DebugOptions_XnnGraphFusionMode DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_MIN = DebugOptions_XnnGraphFusionMode_XNN_GRAPH_FUSION_MODE_DISABLED; constexpr DebugOptions_XnnGraphFusionMode DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_MAX = DebugOptions_XnnGraphFusionMode_XNN_GRAPH_FUSION_MODE_GREEDY; constexpr int DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_ARRAYSIZE = DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugOptions_XnnGraphFusionMode_descriptor(); template inline const std::string& DebugOptions_XnnGraphFusionMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DebugOptions_XnnGraphFusionMode_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DebugOptions_XnnGraphFusionMode_descriptor(), enum_t_value); } inline bool DebugOptions_XnnGraphFusionMode_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DebugOptions_XnnGraphFusionMode* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DebugOptions_XnnGraphFusionMode_descriptor(), name, value); } enum DebugOptions_PipelineParallelismOptLevel : int { DebugOptions_PipelineParallelismOptLevel_PIPELINE_PARALLELISM_OPT_LEVEL_DISABLE = 0, DebugOptions_PipelineParallelismOptLevel_PIPELINE_PARALLELISM_OPT_LEVEL_ENABLE = 1, DebugOptions_PipelineParallelismOptLevel_PIPELINE_PARALLELISM_OPT_LEVEL_ENABLE_CYCLE_DECOMPOSER = 2, DebugOptions_PipelineParallelismOptLevel_DebugOptions_PipelineParallelismOptLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), DebugOptions_PipelineParallelismOptLevel_DebugOptions_PipelineParallelismOptLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DebugOptions_PipelineParallelismOptLevel_IsValid(int value); constexpr DebugOptions_PipelineParallelismOptLevel DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_MIN = DebugOptions_PipelineParallelismOptLevel_PIPELINE_PARALLELISM_OPT_LEVEL_DISABLE; constexpr DebugOptions_PipelineParallelismOptLevel DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_MAX = DebugOptions_PipelineParallelismOptLevel_PIPELINE_PARALLELISM_OPT_LEVEL_ENABLE_CYCLE_DECOMPOSER; constexpr int DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_ARRAYSIZE = DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugOptions_PipelineParallelismOptLevel_descriptor(); template inline const std::string& DebugOptions_PipelineParallelismOptLevel_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DebugOptions_PipelineParallelismOptLevel_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DebugOptions_PipelineParallelismOptLevel_descriptor(), enum_t_value); } inline bool DebugOptions_PipelineParallelismOptLevel_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DebugOptions_PipelineParallelismOptLevel* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DebugOptions_PipelineParallelismOptLevel_descriptor(), name, value); } enum DebugOptions_StepMarkerLocation : int { DebugOptions_StepMarkerLocation_STEP_MARK_AT_ENTRY = 0, DebugOptions_StepMarkerLocation_STEP_MARK_AT_TOP_LEVEL_WHILE_LOOP = 1, DebugOptions_StepMarkerLocation_STEP_MARK_AT_SECOND_LEVEL_WHILE_LOOP = 3, DebugOptions_StepMarkerLocation_STEP_MARK_NONE = 2, DebugOptions_StepMarkerLocation_DebugOptions_StepMarkerLocation_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), DebugOptions_StepMarkerLocation_DebugOptions_StepMarkerLocation_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DebugOptions_StepMarkerLocation_IsValid(int value); constexpr DebugOptions_StepMarkerLocation DebugOptions_StepMarkerLocation_StepMarkerLocation_MIN = DebugOptions_StepMarkerLocation_STEP_MARK_AT_ENTRY; constexpr DebugOptions_StepMarkerLocation DebugOptions_StepMarkerLocation_StepMarkerLocation_MAX = DebugOptions_StepMarkerLocation_STEP_MARK_AT_SECOND_LEVEL_WHILE_LOOP; constexpr int DebugOptions_StepMarkerLocation_StepMarkerLocation_ARRAYSIZE = DebugOptions_StepMarkerLocation_StepMarkerLocation_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugOptions_StepMarkerLocation_descriptor(); template inline const std::string& DebugOptions_StepMarkerLocation_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DebugOptions_StepMarkerLocation_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DebugOptions_StepMarkerLocation_descriptor(), enum_t_value); } inline bool DebugOptions_StepMarkerLocation_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DebugOptions_StepMarkerLocation* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DebugOptions_StepMarkerLocation_descriptor(), name, value); } enum DebugOptions_PartitioningAlgorithm : int { DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_NOOP = 0, DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP0 = 1, DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP1 = 2, DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP2 = 3, DebugOptions_PartitioningAlgorithm_DebugOptions_PartitioningAlgorithm_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), DebugOptions_PartitioningAlgorithm_DebugOptions_PartitioningAlgorithm_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DebugOptions_PartitioningAlgorithm_IsValid(int value); constexpr DebugOptions_PartitioningAlgorithm DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_MIN = DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_NOOP; constexpr DebugOptions_PartitioningAlgorithm DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_MAX = DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP2; constexpr int DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_ARRAYSIZE = DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugOptions_PartitioningAlgorithm_descriptor(); template inline const std::string& DebugOptions_PartitioningAlgorithm_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DebugOptions_PartitioningAlgorithm_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DebugOptions_PartitioningAlgorithm_descriptor(), enum_t_value); } inline bool DebugOptions_PartitioningAlgorithm_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DebugOptions_PartitioningAlgorithm* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DebugOptions_PartitioningAlgorithm_descriptor(), name, value); } enum DebugOptions_AutotuneCacheMode : int { DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_UNSPECIFIED = 0, DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_UPDATE = 1, DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_READ = 2, DebugOptions_AutotuneCacheMode_DebugOptions_AutotuneCacheMode_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), DebugOptions_AutotuneCacheMode_DebugOptions_AutotuneCacheMode_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool DebugOptions_AutotuneCacheMode_IsValid(int value); constexpr DebugOptions_AutotuneCacheMode DebugOptions_AutotuneCacheMode_AutotuneCacheMode_MIN = DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_UNSPECIFIED; constexpr DebugOptions_AutotuneCacheMode DebugOptions_AutotuneCacheMode_AutotuneCacheMode_MAX = DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_READ; constexpr int DebugOptions_AutotuneCacheMode_AutotuneCacheMode_ARRAYSIZE = DebugOptions_AutotuneCacheMode_AutotuneCacheMode_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DebugOptions_AutotuneCacheMode_descriptor(); template inline const std::string& DebugOptions_AutotuneCacheMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function DebugOptions_AutotuneCacheMode_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( DebugOptions_AutotuneCacheMode_descriptor(), enum_t_value); } inline bool DebugOptions_AutotuneCacheMode_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DebugOptions_AutotuneCacheMode* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( DebugOptions_AutotuneCacheMode_descriptor(), name, value); } enum HloModuleConfigProto_FusionConfigCollection : int { HloModuleConfigProto_FusionConfigCollection_OFF = 0, HloModuleConfigProto_FusionConfigCollection_PER_EDGE = 1, HloModuleConfigProto_FusionConfigCollection_PER_NODE = 2, HloModuleConfigProto_FusionConfigCollection_HloModuleConfigProto_FusionConfigCollection_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), HloModuleConfigProto_FusionConfigCollection_HloModuleConfigProto_FusionConfigCollection_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool HloModuleConfigProto_FusionConfigCollection_IsValid(int value); constexpr HloModuleConfigProto_FusionConfigCollection HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_MIN = HloModuleConfigProto_FusionConfigCollection_OFF; constexpr HloModuleConfigProto_FusionConfigCollection HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_MAX = HloModuleConfigProto_FusionConfigCollection_PER_NODE; constexpr int HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_ARRAYSIZE = HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HloModuleConfigProto_FusionConfigCollection_descriptor(); template inline const std::string& HloModuleConfigProto_FusionConfigCollection_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function HloModuleConfigProto_FusionConfigCollection_Name."); return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum( HloModuleConfigProto_FusionConfigCollection_descriptor(), enum_t_value); } inline bool HloModuleConfigProto_FusionConfigCollection_Parse( ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HloModuleConfigProto_FusionConfigCollection* value) { return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum( HloModuleConfigProto_FusionConfigCollection_descriptor(), name, value); } // =================================================================== class CompilationEnvironmentsProto final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.CompilationEnvironmentsProto) */ { public: inline CompilationEnvironmentsProto() : CompilationEnvironmentsProto(nullptr) {} ~CompilationEnvironmentsProto() override; explicit PROTOBUF_CONSTEXPR CompilationEnvironmentsProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); CompilationEnvironmentsProto(const CompilationEnvironmentsProto& from); CompilationEnvironmentsProto(CompilationEnvironmentsProto&& from) noexcept : CompilationEnvironmentsProto() { *this = ::std::move(from); } inline CompilationEnvironmentsProto& operator=(const CompilationEnvironmentsProto& from) { CopyFrom(from); return *this; } inline CompilationEnvironmentsProto& operator=(CompilationEnvironmentsProto&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const CompilationEnvironmentsProto& default_instance() { return *internal_default_instance(); } static inline const CompilationEnvironmentsProto* internal_default_instance() { return reinterpret_cast( &_CompilationEnvironmentsProto_default_instance_); } static constexpr int kIndexInFileMessages = 0; friend void swap(CompilationEnvironmentsProto& a, CompilationEnvironmentsProto& b) { a.Swap(&b); } inline void Swap(CompilationEnvironmentsProto* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(CompilationEnvironmentsProto* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- CompilationEnvironmentsProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const CompilationEnvironmentsProto& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const CompilationEnvironmentsProto& from) { CompilationEnvironmentsProto::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(CompilationEnvironmentsProto* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.CompilationEnvironmentsProto"; } protected: explicit CompilationEnvironmentsProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kEnvironmentsFieldNumber = 1, }; // repeated .google.protobuf.Any environments = 1; int environments_size() const; private: int _internal_environments_size() const; public: void clear_environments(); ::PROTOBUF_NAMESPACE_ID::Any* mutable_environments(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >* mutable_environments(); private: const ::PROTOBUF_NAMESPACE_ID::Any& _internal_environments(int index) const; ::PROTOBUF_NAMESPACE_ID::Any* _internal_add_environments(); public: const ::PROTOBUF_NAMESPACE_ID::Any& environments(int index) const; ::PROTOBUF_NAMESPACE_ID::Any* add_environments(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >& environments() const; // @@protoc_insertion_point(class_scope:xla.CompilationEnvironmentsProto) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any > environments_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { public: typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse(); explicit PROTOBUF_CONSTEXPR DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); explicit DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); void MergeFrom(const DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse& other); static const DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse_default_instance_); } static bool ValidateKey(std::string* s) { return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "xla.DebugOptions.XlaGpuAnalyticalLatencyEstimatorOptionsEntry.key"); } static bool ValidateValue(std::string* s) { return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "xla.DebugOptions.XlaGpuAnalyticalLatencyEstimatorOptionsEntry.value"); } using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { public: typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse(); explicit PROTOBUF_CONSTEXPR DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); explicit DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); void MergeFrom(const DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse& other); static const DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse_default_instance_); } static bool ValidateKey(std::string* s) { return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "xla.DebugOptions.XlaBackendExtraOptionsEntry.key"); } static bool ValidateValue(std::string* s) { return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "xla.DebugOptions.XlaBackendExtraOptionsEntry.value"); } using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class DebugOptions final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.DebugOptions) */ { public: inline DebugOptions() : DebugOptions(nullptr) {} ~DebugOptions() override; explicit PROTOBUF_CONSTEXPR DebugOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); DebugOptions(const DebugOptions& from); DebugOptions(DebugOptions&& from) noexcept : DebugOptions() { *this = ::std::move(from); } inline DebugOptions& operator=(const DebugOptions& from) { CopyFrom(from); return *this; } inline DebugOptions& operator=(DebugOptions&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const DebugOptions& default_instance() { return *internal_default_instance(); } static inline const DebugOptions* internal_default_instance() { return reinterpret_cast( &_DebugOptions_default_instance_); } static constexpr int kIndexInFileMessages = 3; friend void swap(DebugOptions& a, DebugOptions& b) { a.Swap(&b); } inline void Swap(DebugOptions* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(DebugOptions* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- DebugOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const DebugOptions& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const DebugOptions& from) { DebugOptions::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(DebugOptions* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.DebugOptions"; } protected: explicit DebugOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); private: static void ArenaDtor(void* object); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- typedef DebugOptions_CollectiveOpType CollectiveOpType; static constexpr CollectiveOpType NOOP = DebugOptions_CollectiveOpType_NOOP; static constexpr CollectiveOpType ALLREDUCE = DebugOptions_CollectiveOpType_ALLREDUCE; static constexpr CollectiveOpType ALLGATHER = DebugOptions_CollectiveOpType_ALLGATHER; static constexpr CollectiveOpType REDUCESCATTER = DebugOptions_CollectiveOpType_REDUCESCATTER; static constexpr CollectiveOpType COLLECTIVEBROADCAST = DebugOptions_CollectiveOpType_COLLECTIVEBROADCAST; static constexpr CollectiveOpType ALLTOALL = DebugOptions_CollectiveOpType_ALLTOALL; static constexpr CollectiveOpType COLLECTIVEPERMUTE = DebugOptions_CollectiveOpType_COLLECTIVEPERMUTE; static constexpr CollectiveOpType RAGGEDALLTOALL = DebugOptions_CollectiveOpType_RAGGEDALLTOALL; static inline bool CollectiveOpType_IsValid(int value) { return DebugOptions_CollectiveOpType_IsValid(value); } static constexpr CollectiveOpType CollectiveOpType_MIN = DebugOptions_CollectiveOpType_CollectiveOpType_MIN; static constexpr CollectiveOpType CollectiveOpType_MAX = DebugOptions_CollectiveOpType_CollectiveOpType_MAX; static constexpr int CollectiveOpType_ARRAYSIZE = DebugOptions_CollectiveOpType_CollectiveOpType_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CollectiveOpType_descriptor() { return DebugOptions_CollectiveOpType_descriptor(); } template static inline const std::string& CollectiveOpType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function CollectiveOpType_Name."); return DebugOptions_CollectiveOpType_Name(enum_t_value); } static inline bool CollectiveOpType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CollectiveOpType* value) { return DebugOptions_CollectiveOpType_Parse(name, value); } typedef DebugOptions_CommandBufferCmdType CommandBufferCmdType; static constexpr CommandBufferCmdType INVALID = DebugOptions_CommandBufferCmdType_INVALID; static constexpr CommandBufferCmdType FUSION = DebugOptions_CommandBufferCmdType_FUSION; static constexpr CommandBufferCmdType CUBLAS = DebugOptions_CommandBufferCmdType_CUBLAS; static constexpr CommandBufferCmdType CUDNN = DebugOptions_CommandBufferCmdType_CUDNN; static constexpr CommandBufferCmdType COLLECTIVES = DebugOptions_CommandBufferCmdType_COLLECTIVES; static constexpr CommandBufferCmdType CONDITIONAL = DebugOptions_CommandBufferCmdType_CONDITIONAL; static constexpr CommandBufferCmdType WHILE = DebugOptions_CommandBufferCmdType_WHILE; static constexpr CommandBufferCmdType CUSTOM_CALL = DebugOptions_CommandBufferCmdType_CUSTOM_CALL; static constexpr CommandBufferCmdType CUBLASLT = DebugOptions_CommandBufferCmdType_CUBLASLT; static constexpr CommandBufferCmdType DYNAMIC_SLICE_FUSION = DebugOptions_CommandBufferCmdType_DYNAMIC_SLICE_FUSION; static inline bool CommandBufferCmdType_IsValid(int value) { return DebugOptions_CommandBufferCmdType_IsValid(value); } static constexpr CommandBufferCmdType CommandBufferCmdType_MIN = DebugOptions_CommandBufferCmdType_CommandBufferCmdType_MIN; static constexpr CommandBufferCmdType CommandBufferCmdType_MAX = DebugOptions_CommandBufferCmdType_CommandBufferCmdType_MAX; static constexpr int CommandBufferCmdType_ARRAYSIZE = DebugOptions_CommandBufferCmdType_CommandBufferCmdType_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CommandBufferCmdType_descriptor() { return DebugOptions_CommandBufferCmdType_descriptor(); } template static inline const std::string& CommandBufferCmdType_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function CommandBufferCmdType_Name."); return DebugOptions_CommandBufferCmdType_Name(enum_t_value); } static inline bool CommandBufferCmdType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CommandBufferCmdType* value) { return DebugOptions_CommandBufferCmdType_Parse(name, value); } typedef DebugOptions_LibNvJitLinkMode LibNvJitLinkMode; static constexpr LibNvJitLinkMode LIB_NV_JIT_LINK_MODE_AUTO = DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_AUTO; static constexpr LibNvJitLinkMode LIB_NV_JIT_LINK_MODE_DISABLED = DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_DISABLED; static constexpr LibNvJitLinkMode LIB_NV_JIT_LINK_MODE_ENABLED = DebugOptions_LibNvJitLinkMode_LIB_NV_JIT_LINK_MODE_ENABLED; static inline bool LibNvJitLinkMode_IsValid(int value) { return DebugOptions_LibNvJitLinkMode_IsValid(value); } static constexpr LibNvJitLinkMode LibNvJitLinkMode_MIN = DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_MIN; static constexpr LibNvJitLinkMode LibNvJitLinkMode_MAX = DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_MAX; static constexpr int LibNvJitLinkMode_ARRAYSIZE = DebugOptions_LibNvJitLinkMode_LibNvJitLinkMode_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LibNvJitLinkMode_descriptor() { return DebugOptions_LibNvJitLinkMode_descriptor(); } template static inline const std::string& LibNvJitLinkMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function LibNvJitLinkMode_Name."); return DebugOptions_LibNvJitLinkMode_Name(enum_t_value); } static inline bool LibNvJitLinkMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LibNvJitLinkMode* value) { return DebugOptions_LibNvJitLinkMode_Parse(name, value); } typedef DebugOptions_PGLEStrictnessLevel PGLEStrictnessLevel; static constexpr PGLEStrictnessLevel PGLE_STRICTNESS_LEVEL_OFF = DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_OFF; static constexpr PGLEStrictnessLevel PGLE_STRICTNESS_LEVEL_WARN = DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_WARN; static constexpr PGLEStrictnessLevel PGLE_STRICTNESS_LEVEL_ERROR = DebugOptions_PGLEStrictnessLevel_PGLE_STRICTNESS_LEVEL_ERROR; static inline bool PGLEStrictnessLevel_IsValid(int value) { return DebugOptions_PGLEStrictnessLevel_IsValid(value); } static constexpr PGLEStrictnessLevel PGLEStrictnessLevel_MIN = DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_MIN; static constexpr PGLEStrictnessLevel PGLEStrictnessLevel_MAX = DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_MAX; static constexpr int PGLEStrictnessLevel_ARRAYSIZE = DebugOptions_PGLEStrictnessLevel_PGLEStrictnessLevel_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PGLEStrictnessLevel_descriptor() { return DebugOptions_PGLEStrictnessLevel_descriptor(); } template static inline const std::string& PGLEStrictnessLevel_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function PGLEStrictnessLevel_Name."); return DebugOptions_PGLEStrictnessLevel_Name(enum_t_value); } static inline bool PGLEStrictnessLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PGLEStrictnessLevel* value) { return DebugOptions_PGLEStrictnessLevel_Parse(name, value); } typedef DebugOptions_ShapeChecks ShapeChecks; static constexpr ShapeChecks IGNORE = DebugOptions_ShapeChecks_IGNORE; static constexpr ShapeChecks RUNTIME = DebugOptions_ShapeChecks_RUNTIME; static constexpr ShapeChecks COMPILE_TIME = DebugOptions_ShapeChecks_COMPILE_TIME; static inline bool ShapeChecks_IsValid(int value) { return DebugOptions_ShapeChecks_IsValid(value); } static constexpr ShapeChecks ShapeChecks_MIN = DebugOptions_ShapeChecks_ShapeChecks_MIN; static constexpr ShapeChecks ShapeChecks_MAX = DebugOptions_ShapeChecks_ShapeChecks_MAX; static constexpr int ShapeChecks_ARRAYSIZE = DebugOptions_ShapeChecks_ShapeChecks_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ShapeChecks_descriptor() { return DebugOptions_ShapeChecks_descriptor(); } template static inline const std::string& ShapeChecks_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function ShapeChecks_Name."); return DebugOptions_ShapeChecks_Name(enum_t_value); } static inline bool ShapeChecks_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ShapeChecks* value) { return DebugOptions_ShapeChecks_Parse(name, value); } typedef DebugOptions_WhileLoopUnrolling WhileLoopUnrolling; static constexpr WhileLoopUnrolling WHILE_LOOP_UNROLLING_NO_UNROLL = DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_NO_UNROLL; static constexpr WhileLoopUnrolling WHILE_LOOP_UNROLLING_DOUBLE_BUFFER = DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_DOUBLE_BUFFER; static constexpr WhileLoopUnrolling WHILE_LOOP_UNROLLING_FULL_UNROLL = DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_FULL_UNROLL; static constexpr WhileLoopUnrolling WHILE_LOOP_UNROLLING_AUTO_UNROLL = DebugOptions_WhileLoopUnrolling_WHILE_LOOP_UNROLLING_AUTO_UNROLL; static inline bool WhileLoopUnrolling_IsValid(int value) { return DebugOptions_WhileLoopUnrolling_IsValid(value); } static constexpr WhileLoopUnrolling WhileLoopUnrolling_MIN = DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_MIN; static constexpr WhileLoopUnrolling WhileLoopUnrolling_MAX = DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_MAX; static constexpr int WhileLoopUnrolling_ARRAYSIZE = DebugOptions_WhileLoopUnrolling_WhileLoopUnrolling_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WhileLoopUnrolling_descriptor() { return DebugOptions_WhileLoopUnrolling_descriptor(); } template static inline const std::string& WhileLoopUnrolling_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function WhileLoopUnrolling_Name."); return DebugOptions_WhileLoopUnrolling_Name(enum_t_value); } static inline bool WhileLoopUnrolling_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WhileLoopUnrolling* value) { return DebugOptions_WhileLoopUnrolling_Parse(name, value); } typedef DebugOptions_XnnGraphFusionMode XnnGraphFusionMode; static constexpr XnnGraphFusionMode XNN_GRAPH_FUSION_MODE_DISABLED = DebugOptions_XnnGraphFusionMode_XNN_GRAPH_FUSION_MODE_DISABLED; static constexpr XnnGraphFusionMode XNN_GRAPH_FUSION_MODE_GREEDY = DebugOptions_XnnGraphFusionMode_XNN_GRAPH_FUSION_MODE_GREEDY; static inline bool XnnGraphFusionMode_IsValid(int value) { return DebugOptions_XnnGraphFusionMode_IsValid(value); } static constexpr XnnGraphFusionMode XnnGraphFusionMode_MIN = DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_MIN; static constexpr XnnGraphFusionMode XnnGraphFusionMode_MAX = DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_MAX; static constexpr int XnnGraphFusionMode_ARRAYSIZE = DebugOptions_XnnGraphFusionMode_XnnGraphFusionMode_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* XnnGraphFusionMode_descriptor() { return DebugOptions_XnnGraphFusionMode_descriptor(); } template static inline const std::string& XnnGraphFusionMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function XnnGraphFusionMode_Name."); return DebugOptions_XnnGraphFusionMode_Name(enum_t_value); } static inline bool XnnGraphFusionMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, XnnGraphFusionMode* value) { return DebugOptions_XnnGraphFusionMode_Parse(name, value); } typedef DebugOptions_PipelineParallelismOptLevel PipelineParallelismOptLevel; static constexpr PipelineParallelismOptLevel PIPELINE_PARALLELISM_OPT_LEVEL_DISABLE = DebugOptions_PipelineParallelismOptLevel_PIPELINE_PARALLELISM_OPT_LEVEL_DISABLE; static constexpr PipelineParallelismOptLevel PIPELINE_PARALLELISM_OPT_LEVEL_ENABLE = DebugOptions_PipelineParallelismOptLevel_PIPELINE_PARALLELISM_OPT_LEVEL_ENABLE; static constexpr PipelineParallelismOptLevel PIPELINE_PARALLELISM_OPT_LEVEL_ENABLE_CYCLE_DECOMPOSER = DebugOptions_PipelineParallelismOptLevel_PIPELINE_PARALLELISM_OPT_LEVEL_ENABLE_CYCLE_DECOMPOSER; static inline bool PipelineParallelismOptLevel_IsValid(int value) { return DebugOptions_PipelineParallelismOptLevel_IsValid(value); } static constexpr PipelineParallelismOptLevel PipelineParallelismOptLevel_MIN = DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_MIN; static constexpr PipelineParallelismOptLevel PipelineParallelismOptLevel_MAX = DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_MAX; static constexpr int PipelineParallelismOptLevel_ARRAYSIZE = DebugOptions_PipelineParallelismOptLevel_PipelineParallelismOptLevel_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PipelineParallelismOptLevel_descriptor() { return DebugOptions_PipelineParallelismOptLevel_descriptor(); } template static inline const std::string& PipelineParallelismOptLevel_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function PipelineParallelismOptLevel_Name."); return DebugOptions_PipelineParallelismOptLevel_Name(enum_t_value); } static inline bool PipelineParallelismOptLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PipelineParallelismOptLevel* value) { return DebugOptions_PipelineParallelismOptLevel_Parse(name, value); } typedef DebugOptions_StepMarkerLocation StepMarkerLocation; static constexpr StepMarkerLocation STEP_MARK_AT_ENTRY = DebugOptions_StepMarkerLocation_STEP_MARK_AT_ENTRY; static constexpr StepMarkerLocation STEP_MARK_AT_TOP_LEVEL_WHILE_LOOP = DebugOptions_StepMarkerLocation_STEP_MARK_AT_TOP_LEVEL_WHILE_LOOP; static constexpr StepMarkerLocation STEP_MARK_AT_SECOND_LEVEL_WHILE_LOOP = DebugOptions_StepMarkerLocation_STEP_MARK_AT_SECOND_LEVEL_WHILE_LOOP; static constexpr StepMarkerLocation STEP_MARK_NONE = DebugOptions_StepMarkerLocation_STEP_MARK_NONE; static inline bool StepMarkerLocation_IsValid(int value) { return DebugOptions_StepMarkerLocation_IsValid(value); } static constexpr StepMarkerLocation StepMarkerLocation_MIN = DebugOptions_StepMarkerLocation_StepMarkerLocation_MIN; static constexpr StepMarkerLocation StepMarkerLocation_MAX = DebugOptions_StepMarkerLocation_StepMarkerLocation_MAX; static constexpr int StepMarkerLocation_ARRAYSIZE = DebugOptions_StepMarkerLocation_StepMarkerLocation_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* StepMarkerLocation_descriptor() { return DebugOptions_StepMarkerLocation_descriptor(); } template static inline const std::string& StepMarkerLocation_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function StepMarkerLocation_Name."); return DebugOptions_StepMarkerLocation_Name(enum_t_value); } static inline bool StepMarkerLocation_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, StepMarkerLocation* value) { return DebugOptions_StepMarkerLocation_Parse(name, value); } typedef DebugOptions_PartitioningAlgorithm PartitioningAlgorithm; static constexpr PartitioningAlgorithm PARTITIONING_ALGORITHM_NOOP = DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_NOOP; static constexpr PartitioningAlgorithm PARTITIONING_ALGORITHM_EXP0 = DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP0; static constexpr PartitioningAlgorithm PARTITIONING_ALGORITHM_EXP1 = DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP1; static constexpr PartitioningAlgorithm PARTITIONING_ALGORITHM_EXP2 = DebugOptions_PartitioningAlgorithm_PARTITIONING_ALGORITHM_EXP2; static inline bool PartitioningAlgorithm_IsValid(int value) { return DebugOptions_PartitioningAlgorithm_IsValid(value); } static constexpr PartitioningAlgorithm PartitioningAlgorithm_MIN = DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_MIN; static constexpr PartitioningAlgorithm PartitioningAlgorithm_MAX = DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_MAX; static constexpr int PartitioningAlgorithm_ARRAYSIZE = DebugOptions_PartitioningAlgorithm_PartitioningAlgorithm_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PartitioningAlgorithm_descriptor() { return DebugOptions_PartitioningAlgorithm_descriptor(); } template static inline const std::string& PartitioningAlgorithm_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function PartitioningAlgorithm_Name."); return DebugOptions_PartitioningAlgorithm_Name(enum_t_value); } static inline bool PartitioningAlgorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PartitioningAlgorithm* value) { return DebugOptions_PartitioningAlgorithm_Parse(name, value); } typedef DebugOptions_AutotuneCacheMode AutotuneCacheMode; static constexpr AutotuneCacheMode AUTOTUNE_CACHE_MODE_UNSPECIFIED = DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_UNSPECIFIED; static constexpr AutotuneCacheMode AUTOTUNE_CACHE_MODE_UPDATE = DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_UPDATE; static constexpr AutotuneCacheMode AUTOTUNE_CACHE_MODE_READ = DebugOptions_AutotuneCacheMode_AUTOTUNE_CACHE_MODE_READ; static inline bool AutotuneCacheMode_IsValid(int value) { return DebugOptions_AutotuneCacheMode_IsValid(value); } static constexpr AutotuneCacheMode AutotuneCacheMode_MIN = DebugOptions_AutotuneCacheMode_AutotuneCacheMode_MIN; static constexpr AutotuneCacheMode AutotuneCacheMode_MAX = DebugOptions_AutotuneCacheMode_AutotuneCacheMode_MAX; static constexpr int AutotuneCacheMode_ARRAYSIZE = DebugOptions_AutotuneCacheMode_AutotuneCacheMode_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* AutotuneCacheMode_descriptor() { return DebugOptions_AutotuneCacheMode_descriptor(); } template static inline const std::string& AutotuneCacheMode_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function AutotuneCacheMode_Name."); return DebugOptions_AutotuneCacheMode_Name(enum_t_value); } static inline bool AutotuneCacheMode_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, AutotuneCacheMode* value) { return DebugOptions_AutotuneCacheMode_Parse(name, value); } // accessors ------------------------------------------------------- enum : int { kXlaDisableHloPassesFieldNumber = 30, kXlaEnableHloPassesOnlyFieldNumber = 124, kXlaGpuPtxFileFieldNumber = 127, kXlaGpuLlvmIrFileFieldNumber = 150, kXlaGpuEnableCommandBufferFieldNumber = 258, kXlaGpuDisableAsyncCollectivesFieldNumber = 289, kLegacyCommandBufferCustomCallTargetsFieldNumber = 314, kXlaGpuAnalyticalLatencyEstimatorOptionsFieldNumber = 357, kXlaBackendExtraOptionsFieldNumber = 500, kXlaGpuCudaDataDirFieldNumber = 61, kXlaDumpToFieldNumber = 109, kXlaDumpHloModuleReFieldNumber = 110, kXlaDumpHloPassReFieldNumber = 111, kXlaGpuAlgorithmDenylistPathFieldNumber = 128, kXlaDumpHloPipelineReFieldNumber = 154, kXlaGpuPgleProfileFileOrDirectoryPathFieldNumber = 210, kXlaGpuDumpAutotuneResultsToFieldNumber = 222, kXlaGpuLoadAutotuneResultsFromFieldNumber = 223, kXlaGpuTargetConfigFilenameFieldNumber = 261, kXlaGpuEnableCustomFusionsReFieldNumber = 264, kXlaGpuDumpAutotuneLogsToFieldNumber = 292, kXlaGpuOverrideGemmAutotunerFieldNumber = 295, kXlaGpuKernelCacheFileFieldNumber = 306, kXlaGpuPerFusionAutotuneCacheDirFieldNumber = 310, kXlaCpuMaxIsaFieldNumber = 333, kXlaBackendOptimizationLevelFieldNumber = 31, kXlaEmbedIrInExecutableFieldNumber = 33, kXlaEliminateHloImplicitBroadcastFieldNumber = 35, kXlaCpuMultiThreadEigenFieldNumber = 60, kXlaLlvmEnableAliasScopeMetadataFieldNumber = 70, kXlaLlvmEnableNoaliasMetadataFieldNumber = 71, kXlaLlvmEnableInvariantLoadMetadataFieldNumber = 72, kXlaLlvmDisableExpensivePassesFieldNumber = 73, kXlaTestAllOutputLayoutsFieldNumber = 90, kXlaTestAllInputLayoutsFieldNumber = 91, kXlaHloGraphShardingColorFieldNumber = 92, kXlaCpuUseMklDnnFieldNumber = 97, kXlaAllowExcessPrecisionFieldNumber = 122, kXlaGpuVerifyTritonFusionNumericsFieldNumber = 291, kXlaHloGraphAddressesFieldNumber = 2, kXlaHloProfileFieldNumber = 9, kXlaDisableAllHloPassesFieldNumber = 104, kXlaForceHostPlatformDeviceCountFieldNumber = 102, kXlaStepMarkerLocationFieldNumber = 108, kXlaDumpHloAsProtoFieldNumber = 113, kXlaDumpHloAsDotFieldNumber = 114, kXlaDumpHloAsUrlFieldNumber = 115, kXlaDumpHloAsHtmlFieldNumber = 116, kXlaGpuAutotuneLevelFieldNumber = 123, kXlaCpuEnableFastMinMaxFieldNumber = 140, kXlaCpuFastMathHonorDivisionFieldNumber = 126, kXlaCpuFastMathHonorFunctionsFieldNumber = 129, kXlaCpuFastMathHonorInfsFieldNumber = 121, kXlaDumpMaxHloModulesFieldNumber = 132, kXlaDumpFusionVisualizationFieldNumber = 149, kXlaDumpHloSnapshotsFieldNumber = 118, kXlaDumpIncludeTimestampFieldNumber = 131, kXlaDumpModuleMetadataFieldNumber = 144, kXlaMultiheapSizeConstraintPerHeapFieldNumber = 142, kXlaGpuForceConvNchwFieldNumber = 125, kXlaGpuForceConvNhwcFieldNumber = 146, kXlaGpuFtzFieldNumber = 62, kXlaGpuFusedAttentionUseCudnnRngFieldNumber = 235, kXlaGpuForceCompilationParallelismFieldNumber = 147, kXlaGpuCrashOnVerificationFailuresFieldNumber = 101, kXlaGpuCublasFallbackFieldNumber = 247, kXlaGpuDeterministicOpsFieldNumber = 148, kXlaGpuDisableGpuasmOptimizationsFieldNumber = 103, kXlaGpuAllReduceCombineThresholdBytesFieldNumber = 157, kXlaDumpCompressProtosFieldNumber = 151, kXlaDumpHloAsLongTextFieldNumber = 164, kXlaDumpEnableMlirPrettyFormFieldNumber = 185, kXlaTpuDetectNanFieldNumber = 135, kXlaGpuAllReduceBlueconnectNumDevicesPerHostFieldNumber = 159, kXlaGpuNcclTerminationTimeoutSecondsFieldNumber = 163, kXlaGpuRedzoneScratchMaxMegabytesFieldNumber = 167, kXlaGpuShapeChecksFieldNumber = 170, kXlaGpuEnableCustomFusionsFieldNumber = 263, kXlaGpuEnableDynamicSliceFusionFieldNumber = 105, kXlaGpuEnableFastMinMaxFieldNumber = 100, kXlaGpuEnableHighestPriorityAsyncStreamFieldNumber = 216, kXlaHloEvaluatorUseFastPathFieldNumber = 106, kXlaAllowScalarIndexDynamicOpsFieldNumber = 107, kXlaFlagsResetFieldNumber = 364, kXlaDumpHloAsTextFieldNumber = 112, kXlaPartitioningAlgorithmFieldNumber = 187, kXlaGpuEnableCublasltFieldNumber = 166, kXlaGpuEnableCudnnFrontendFieldNumber = 160, kXlaGpuEnableCudnnInt8X32ConvolutionReorderingFieldNumber = 189, kXlaGpuEnableCudnnLayerNormFieldNumber = 262, kXlaTpuDetectInfFieldNumber = 136, kXlaCpuEnableXprofTracemeFieldNumber = 137, kXlaDetailedLoggingFieldNumber = 252, kXlaEnableDumpingFieldNumber = 253, kXlaLlvmForceInlineBeforeSplitFieldNumber = 300, kXlaDumpDisableMetadataFieldNumber = 153, kXlaCpuUseAclFieldNumber = 174, kXlaCpuStrictDotConvMathFieldNumber = 175, kXlaGpuCollectiveInflationFactorFieldNumber = 205, kXlaGpuAllGatherCombineThresholdBytesFieldNumber = 212, kXlaGpuReduceScatterCombineThresholdBytesFieldNumber = 213, kXlaGpuGraphMinGraphSizeFieldNumber = 208, kXlaGpuAutoSpmdPartitioningMemoryBudgetGbFieldNumber = 224, kXlaGpuRedzonePaddingBytesFieldNumber = 228, kXlaGpuAutoSpmdPartitioningMemoryBudgetRatioFieldNumber = 225, kXlaGpuEnablePipelinedAllGatherFieldNumber = 227, kXlaGpuEnablePipelinedAllReduceFieldNumber = 217, kXlaGpuEnablePipelinedCollectivesFieldNumber = 239, kXlaGpuEnablePipelinedP2PFieldNumber = 246, kXlaGpuEnableScatterDeterminismExpanderFieldNumber = 345, kXlaGpuEnableSharedConstantsFieldNumber = 165, kXlaGpuEnableSplitKAutotuningFieldNumber = 241, kXlaGpuEnableTritonGemmFieldNumber = 188, kXlaGpuEnablePipelinedReduceScatterFieldNumber = 231, kXlaGpuEnableReassociationForConvertedArFieldNumber = 209, kXlaGpuEnableReduceScatterCombineByDimFieldNumber = 257, kXlaGpuEnableReductionEpilogueFusionFieldNumber = 243, kXlaGpuCollectivePermuteDecomposerThresholdFieldNumber = 237, kXlaGpuShardAutotuningFieldNumber = 304, kXlaGpuStrictConvAlgorithmPickerFieldNumber = 156, kXlaGpuTempBufferUseSeparateColorFieldNumber = 312, kXlaGpuTritonGemmAnyFieldNumber = 190, kXlaGpuEnableTritonHopperFieldNumber = 266, kXlaGpuEnableWhileLoopDoubleBufferingFieldNumber = 248, kXlaGpuEnableWhileLoopReduceScatterCodeMotionFieldNumber = 203, kXlaGpuEnsureMinorDotContractionDimsFieldNumber = 249, kXlaDebugBufferAssignmentShowMaxFieldNumber = 251, kXlaGpuDumpAutotunedGemmFusionsFieldNumber = 232, kXlaGpuDumpHloUnoptimizedSnapshotsFieldNumber = 352, kXlaGpuDumpLlvmirFieldNumber = 155, kXlaGpuEnableAllGatherCombineByDimFieldNumber = 254, kXlaGpuEnableHostMemoryOffloadingFieldNumber = 296, kXlaGpuEnableLatencyHidingSchedulerFieldNumber = 186, kXlaGpuEnableLibnvptxcompilerFieldNumber = 269, kXlaGpuEnableLlvmModuleCompilationParallelismFieldNumber = 268, kXlaGpuLlvmVerificationLevelFieldNumber = 256, kXlaGpuTritonGemmDisableReducedPrecisionReductionFieldNumber = 226, kXlaGpuUnsafeFallbackToDriverOnPtxasNotFoundFieldNumber = 138, kXlaGpuUnsafePipelinedLoopAnnotatorFieldNumber = 309, kXlaGpuUnsupportedAnnotateWithEmitterLocFieldNumber = 358, kXlaGpuMemoryLimitSlopFactorFieldNumber = 260, kXlaGpuEnableNcclCliqueOptimizationFieldNumber = 244, kXlaGpuEnableNcclCommSplittingFieldNumber = 272, kXlaGpuEnableNcclPerStreamCommsFieldNumber = 276, kXlaGpuEnableNcclUserBuffersFieldNumber = 267, kXlaGpuThresholdForWindowedEinsumMibFieldNumber = 265, kXlaGpuNcclCollectiveMaxNchannelsFieldNumber = 273, kXlaGpuNcclP2PMaxNchannelsFieldNumber = 274, kXlaDumpLatencyHidingScheduleFieldNumber = 182, kXlaDumpLargeConstantsFieldNumber = 290, kXlaSyntaxSugarAsyncOpsFieldNumber = 315, kXlaEnableCommandBuffersDuringProfilingFieldNumber = 317, kXlaUnsupportedCrashOnHloPassFixMaxIterationsFieldNumber = 363, kXlaCpuCopyInsertionUseRegionAnalysisFieldNumber = 337, kXlaCpuEnableConcurrencyOptimizedSchedulerFieldNumber = 307, kXlaCpuEnableFastMathFieldNumber = 99, kXlaGpuNcclInitMaxRankPerRootRatioFieldNumber = 277, kXlaCpuFastMathHonorNansFieldNumber = 120, kXlaCpuUseThunkRuntimeFieldNumber = 298, kXlaCpuUseXnnpackFieldNumber = 359, kXlaEnableFastMathFieldNumber = 335, kXlaGpuCudnnGemmFusionLevelFieldNumber = 285, kXlaGpuGemmRewriteSizeThresholdFieldNumber = 283, kXlaGpuUnsupportedEnableRaggedAllToAllDecomposerFieldNumber = 350, kXlaGpuUnsupportedEnableTritonGemmFieldNumber = 322, kXlaGpuUseMemcpyLocalP2PFieldNumber = 287, kXlaGpuUseRuntimeFusionFieldNumber = 181, kXlaGpuAsyncDotFieldNumber = 321, kXlaGpuCollectCostModelStatsFieldNumber = 240, kXlaGpuCollectivesUsePersistentCliquesFieldNumber = 354, kXlaGpuCopyInsertionUseRegionAnalysisFieldNumber = 236, kXlaGpuAutotuneMaxSolutionsFieldNumber = 288, kXlaGpuGenerateDebugInfoFieldNumber = 348, kXlaGpuGenerateLineInfoFieldNumber = 349, kXlaGpuGraphEnableConcurrentRegionFieldNumber = 215, kXlaGpuMockCustomCallsFieldNumber = 245, kXlaGpuEnableAnalyticalLatencyEstimatorFieldNumber = 255, kXlaGpuEnableAnalyticalSolLatencyEstimatorFieldNumber = 356, kXlaGpuEnableApproxCostlyCollectivesFieldNumber = 305, kXlaGpuEnableCubRadixSortFieldNumber = 259, kXlaReduceWindowRewriteBaseLengthFieldNumber = 293, kXlaGpuEnableWhileLoopUnrollingFieldNumber = 294, kXlaGpuExcludeNondeterministicOpsFieldNumber = 297, kXlaGpuExhaustiveTilingSearchFieldNumber = 219, kXlaGpuExperimentalDisableBinaryLibrariesFieldNumber = 329, kXlaGpuExperimentalDumpFdoProfilesFieldNumber = 338, kXlaGpuMultiStreamedWindowedEinsumFieldNumber = 280, kXlaGpuNcclTerminateOnErrorFieldNumber = 301, kXlaGpuRequireCompleteAotAutotuneResultsFieldNumber = 284, kXlaGpuRequireExclusiveLockFieldNumber = 347, kXlaCpuPreferVectorWidthFieldNumber = 308, kXlaCmdBufferTraceCacheSizeFieldNumber = 311, kXlaGpuAutotuneGemmRtolFieldNumber = 316, kXlaGpuCudnnGemmMaxPlansFieldNumber = 318, kXlaCpuParallelCodegenSplitCountFieldNumber = 323, kXlaGpuExperimentalAutotuneCacheModeFieldNumber = 324, kXlaGpuExperimentalPackDotOperandsAlongKDimensionFieldNumber = 362, kXlaGpuExperimentalStreamAnnotationFieldNumber = 342, kXlaGpuFailPtxCompilationOnRegisterSpillingFieldNumber = 353, kXlaGpuFilterKernelsSpillingRegistersOnAutotuningFieldNumber = 250, kXlaGpuExecutableWarnStuckTimeoutSecondsFieldNumber = 327, kXlaGpuExecutableTerminateTimeoutSecondsFieldNumber = 328, kXlaGpuDotMergerThresholdMbFieldNumber = 331, kXlaGpuExperimentalParallelCollectiveOverlapLimitFieldNumber = 336, kXlaIgnoreChannelIdFieldNumber = 330, kXlaPjrtAllowAutoLayoutInHloFieldNumber = 344, kXlaGpuOperandBytesThresholdForWindowedEinsumFieldNumber = 339, kXlaGpuPgleAccuracyCheckerFieldNumber = 341, kXlaGpuLibnvjitlinkModeFieldNumber = 343, kXlaGpuExperimentalEnableAlltoallWindowedEinsumFieldNumber = 360, kXlaGpuExperimentalEnableFusionBlockLevelRewriterFieldNumber = 334, kXlaGpuExperimentalEnableTritonHerolessPriorityFusionFieldNumber = 340, kXlaGpuExperimentalEnableTritonTmaFieldNumber = 355, kXlaGpuExperimentalPipelineParallelismOptLevelFieldNumber = 351, kXlaCpuExperimentalXnnGraphFusionModeFieldNumber = 365, }; // repeated string xla_disable_hlo_passes = 30; int xla_disable_hlo_passes_size() const; private: int _internal_xla_disable_hlo_passes_size() const; public: void clear_xla_disable_hlo_passes(); const std::string& xla_disable_hlo_passes(int index) const; std::string* mutable_xla_disable_hlo_passes(int index); void set_xla_disable_hlo_passes(int index, const std::string& value); void set_xla_disable_hlo_passes(int index, std::string&& value); void set_xla_disable_hlo_passes(int index, const char* value); void set_xla_disable_hlo_passes(int index, const char* value, size_t size); std::string* add_xla_disable_hlo_passes(); void add_xla_disable_hlo_passes(const std::string& value); void add_xla_disable_hlo_passes(std::string&& value); void add_xla_disable_hlo_passes(const char* value); void add_xla_disable_hlo_passes(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& xla_disable_hlo_passes() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_xla_disable_hlo_passes(); private: const std::string& _internal_xla_disable_hlo_passes(int index) const; std::string* _internal_add_xla_disable_hlo_passes(); public: // repeated string xla_enable_hlo_passes_only = 124; int xla_enable_hlo_passes_only_size() const; private: int _internal_xla_enable_hlo_passes_only_size() const; public: void clear_xla_enable_hlo_passes_only(); const std::string& xla_enable_hlo_passes_only(int index) const; std::string* mutable_xla_enable_hlo_passes_only(int index); void set_xla_enable_hlo_passes_only(int index, const std::string& value); void set_xla_enable_hlo_passes_only(int index, std::string&& value); void set_xla_enable_hlo_passes_only(int index, const char* value); void set_xla_enable_hlo_passes_only(int index, const char* value, size_t size); std::string* add_xla_enable_hlo_passes_only(); void add_xla_enable_hlo_passes_only(const std::string& value); void add_xla_enable_hlo_passes_only(std::string&& value); void add_xla_enable_hlo_passes_only(const char* value); void add_xla_enable_hlo_passes_only(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& xla_enable_hlo_passes_only() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_xla_enable_hlo_passes_only(); private: const std::string& _internal_xla_enable_hlo_passes_only(int index) const; std::string* _internal_add_xla_enable_hlo_passes_only(); public: // repeated string xla_gpu_ptx_file = 127; int xla_gpu_ptx_file_size() const; private: int _internal_xla_gpu_ptx_file_size() const; public: void clear_xla_gpu_ptx_file(); const std::string& xla_gpu_ptx_file(int index) const; std::string* mutable_xla_gpu_ptx_file(int index); void set_xla_gpu_ptx_file(int index, const std::string& value); void set_xla_gpu_ptx_file(int index, std::string&& value); void set_xla_gpu_ptx_file(int index, const char* value); void set_xla_gpu_ptx_file(int index, const char* value, size_t size); std::string* add_xla_gpu_ptx_file(); void add_xla_gpu_ptx_file(const std::string& value); void add_xla_gpu_ptx_file(std::string&& value); void add_xla_gpu_ptx_file(const char* value); void add_xla_gpu_ptx_file(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& xla_gpu_ptx_file() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_xla_gpu_ptx_file(); private: const std::string& _internal_xla_gpu_ptx_file(int index) const; std::string* _internal_add_xla_gpu_ptx_file(); public: // repeated string xla_gpu_llvm_ir_file = 150; int xla_gpu_llvm_ir_file_size() const; private: int _internal_xla_gpu_llvm_ir_file_size() const; public: void clear_xla_gpu_llvm_ir_file(); const std::string& xla_gpu_llvm_ir_file(int index) const; std::string* mutable_xla_gpu_llvm_ir_file(int index); void set_xla_gpu_llvm_ir_file(int index, const std::string& value); void set_xla_gpu_llvm_ir_file(int index, std::string&& value); void set_xla_gpu_llvm_ir_file(int index, const char* value); void set_xla_gpu_llvm_ir_file(int index, const char* value, size_t size); std::string* add_xla_gpu_llvm_ir_file(); void add_xla_gpu_llvm_ir_file(const std::string& value); void add_xla_gpu_llvm_ir_file(std::string&& value); void add_xla_gpu_llvm_ir_file(const char* value); void add_xla_gpu_llvm_ir_file(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& xla_gpu_llvm_ir_file() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_xla_gpu_llvm_ir_file(); private: const std::string& _internal_xla_gpu_llvm_ir_file(int index) const; std::string* _internal_add_xla_gpu_llvm_ir_file(); public: // repeated .xla.DebugOptions.CommandBufferCmdType xla_gpu_enable_command_buffer = 258; int xla_gpu_enable_command_buffer_size() const; private: int _internal_xla_gpu_enable_command_buffer_size() const; public: void clear_xla_gpu_enable_command_buffer(); private: ::xla::DebugOptions_CommandBufferCmdType _internal_xla_gpu_enable_command_buffer(int index) const; void _internal_add_xla_gpu_enable_command_buffer(::xla::DebugOptions_CommandBufferCmdType value); ::PROTOBUF_NAMESPACE_ID::RepeatedField* _internal_mutable_xla_gpu_enable_command_buffer(); public: ::xla::DebugOptions_CommandBufferCmdType xla_gpu_enable_command_buffer(int index) const; void set_xla_gpu_enable_command_buffer(int index, ::xla::DebugOptions_CommandBufferCmdType value); void add_xla_gpu_enable_command_buffer(::xla::DebugOptions_CommandBufferCmdType value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField& xla_gpu_enable_command_buffer() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_xla_gpu_enable_command_buffer(); // repeated .xla.DebugOptions.CollectiveOpType xla_gpu_disable_async_collectives = 289; int xla_gpu_disable_async_collectives_size() const; private: int _internal_xla_gpu_disable_async_collectives_size() const; public: void clear_xla_gpu_disable_async_collectives(); private: ::xla::DebugOptions_CollectiveOpType _internal_xla_gpu_disable_async_collectives(int index) const; void _internal_add_xla_gpu_disable_async_collectives(::xla::DebugOptions_CollectiveOpType value); ::PROTOBUF_NAMESPACE_ID::RepeatedField* _internal_mutable_xla_gpu_disable_async_collectives(); public: ::xla::DebugOptions_CollectiveOpType xla_gpu_disable_async_collectives(int index) const; void set_xla_gpu_disable_async_collectives(int index, ::xla::DebugOptions_CollectiveOpType value); void add_xla_gpu_disable_async_collectives(::xla::DebugOptions_CollectiveOpType value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField& xla_gpu_disable_async_collectives() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField* mutable_xla_gpu_disable_async_collectives(); // repeated string legacy_command_buffer_custom_call_targets = 314; int legacy_command_buffer_custom_call_targets_size() const; private: int _internal_legacy_command_buffer_custom_call_targets_size() const; public: void clear_legacy_command_buffer_custom_call_targets(); const std::string& legacy_command_buffer_custom_call_targets(int index) const; std::string* mutable_legacy_command_buffer_custom_call_targets(int index); void set_legacy_command_buffer_custom_call_targets(int index, const std::string& value); void set_legacy_command_buffer_custom_call_targets(int index, std::string&& value); void set_legacy_command_buffer_custom_call_targets(int index, const char* value); void set_legacy_command_buffer_custom_call_targets(int index, const char* value, size_t size); std::string* add_legacy_command_buffer_custom_call_targets(); void add_legacy_command_buffer_custom_call_targets(const std::string& value); void add_legacy_command_buffer_custom_call_targets(std::string&& value); void add_legacy_command_buffer_custom_call_targets(const char* value); void add_legacy_command_buffer_custom_call_targets(const char* value, size_t size); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& legacy_command_buffer_custom_call_targets() const; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* mutable_legacy_command_buffer_custom_call_targets(); private: const std::string& _internal_legacy_command_buffer_custom_call_targets(int index) const; std::string* _internal_add_legacy_command_buffer_custom_call_targets(); public: // map xla_gpu_analytical_latency_estimator_options = 357; int xla_gpu_analytical_latency_estimator_options_size() const; private: int _internal_xla_gpu_analytical_latency_estimator_options_size() const; public: void clear_xla_gpu_analytical_latency_estimator_options(); private: const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& _internal_xla_gpu_analytical_latency_estimator_options() const; ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* _internal_mutable_xla_gpu_analytical_latency_estimator_options(); public: const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& xla_gpu_analytical_latency_estimator_options() const; ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* mutable_xla_gpu_analytical_latency_estimator_options(); // map xla_backend_extra_options = 500; int xla_backend_extra_options_size() const; private: int _internal_xla_backend_extra_options_size() const; public: void clear_xla_backend_extra_options(); private: const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& _internal_xla_backend_extra_options() const; ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* _internal_mutable_xla_backend_extra_options(); public: const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& xla_backend_extra_options() const; ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* mutable_xla_backend_extra_options(); // string xla_gpu_cuda_data_dir = 61; void clear_xla_gpu_cuda_data_dir(); const std::string& xla_gpu_cuda_data_dir() const; template void set_xla_gpu_cuda_data_dir(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_gpu_cuda_data_dir(); PROTOBUF_NODISCARD std::string* release_xla_gpu_cuda_data_dir(); void set_allocated_xla_gpu_cuda_data_dir(std::string* xla_gpu_cuda_data_dir); private: const std::string& _internal_xla_gpu_cuda_data_dir() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_cuda_data_dir(const std::string& value); std::string* _internal_mutable_xla_gpu_cuda_data_dir(); public: // string xla_dump_to = 109; void clear_xla_dump_to(); const std::string& xla_dump_to() const; template void set_xla_dump_to(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_dump_to(); PROTOBUF_NODISCARD std::string* release_xla_dump_to(); void set_allocated_xla_dump_to(std::string* xla_dump_to); private: const std::string& _internal_xla_dump_to() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_dump_to(const std::string& value); std::string* _internal_mutable_xla_dump_to(); public: // string xla_dump_hlo_module_re = 110; void clear_xla_dump_hlo_module_re(); const std::string& xla_dump_hlo_module_re() const; template void set_xla_dump_hlo_module_re(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_dump_hlo_module_re(); PROTOBUF_NODISCARD std::string* release_xla_dump_hlo_module_re(); void set_allocated_xla_dump_hlo_module_re(std::string* xla_dump_hlo_module_re); private: const std::string& _internal_xla_dump_hlo_module_re() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_dump_hlo_module_re(const std::string& value); std::string* _internal_mutable_xla_dump_hlo_module_re(); public: // string xla_dump_hlo_pass_re = 111; void clear_xla_dump_hlo_pass_re(); const std::string& xla_dump_hlo_pass_re() const; template void set_xla_dump_hlo_pass_re(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_dump_hlo_pass_re(); PROTOBUF_NODISCARD std::string* release_xla_dump_hlo_pass_re(); void set_allocated_xla_dump_hlo_pass_re(std::string* xla_dump_hlo_pass_re); private: const std::string& _internal_xla_dump_hlo_pass_re() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_dump_hlo_pass_re(const std::string& value); std::string* _internal_mutable_xla_dump_hlo_pass_re(); public: // string xla_gpu_algorithm_denylist_path = 128; void clear_xla_gpu_algorithm_denylist_path(); const std::string& xla_gpu_algorithm_denylist_path() const; template void set_xla_gpu_algorithm_denylist_path(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_gpu_algorithm_denylist_path(); PROTOBUF_NODISCARD std::string* release_xla_gpu_algorithm_denylist_path(); void set_allocated_xla_gpu_algorithm_denylist_path(std::string* xla_gpu_algorithm_denylist_path); private: const std::string& _internal_xla_gpu_algorithm_denylist_path() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_algorithm_denylist_path(const std::string& value); std::string* _internal_mutable_xla_gpu_algorithm_denylist_path(); public: // string xla_dump_hlo_pipeline_re = 154; void clear_xla_dump_hlo_pipeline_re(); const std::string& xla_dump_hlo_pipeline_re() const; template void set_xla_dump_hlo_pipeline_re(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_dump_hlo_pipeline_re(); PROTOBUF_NODISCARD std::string* release_xla_dump_hlo_pipeline_re(); void set_allocated_xla_dump_hlo_pipeline_re(std::string* xla_dump_hlo_pipeline_re); private: const std::string& _internal_xla_dump_hlo_pipeline_re() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_dump_hlo_pipeline_re(const std::string& value); std::string* _internal_mutable_xla_dump_hlo_pipeline_re(); public: // string xla_gpu_pgle_profile_file_or_directory_path = 210; void clear_xla_gpu_pgle_profile_file_or_directory_path(); const std::string& xla_gpu_pgle_profile_file_or_directory_path() const; template void set_xla_gpu_pgle_profile_file_or_directory_path(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_gpu_pgle_profile_file_or_directory_path(); PROTOBUF_NODISCARD std::string* release_xla_gpu_pgle_profile_file_or_directory_path(); void set_allocated_xla_gpu_pgle_profile_file_or_directory_path(std::string* xla_gpu_pgle_profile_file_or_directory_path); private: const std::string& _internal_xla_gpu_pgle_profile_file_or_directory_path() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_pgle_profile_file_or_directory_path(const std::string& value); std::string* _internal_mutable_xla_gpu_pgle_profile_file_or_directory_path(); public: // string xla_gpu_dump_autotune_results_to = 222; void clear_xla_gpu_dump_autotune_results_to(); const std::string& xla_gpu_dump_autotune_results_to() const; template void set_xla_gpu_dump_autotune_results_to(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_gpu_dump_autotune_results_to(); PROTOBUF_NODISCARD std::string* release_xla_gpu_dump_autotune_results_to(); void set_allocated_xla_gpu_dump_autotune_results_to(std::string* xla_gpu_dump_autotune_results_to); private: const std::string& _internal_xla_gpu_dump_autotune_results_to() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_dump_autotune_results_to(const std::string& value); std::string* _internal_mutable_xla_gpu_dump_autotune_results_to(); public: // string xla_gpu_load_autotune_results_from = 223; void clear_xla_gpu_load_autotune_results_from(); const std::string& xla_gpu_load_autotune_results_from() const; template void set_xla_gpu_load_autotune_results_from(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_gpu_load_autotune_results_from(); PROTOBUF_NODISCARD std::string* release_xla_gpu_load_autotune_results_from(); void set_allocated_xla_gpu_load_autotune_results_from(std::string* xla_gpu_load_autotune_results_from); private: const std::string& _internal_xla_gpu_load_autotune_results_from() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_load_autotune_results_from(const std::string& value); std::string* _internal_mutable_xla_gpu_load_autotune_results_from(); public: // string xla_gpu_target_config_filename = 261; void clear_xla_gpu_target_config_filename(); const std::string& xla_gpu_target_config_filename() const; template void set_xla_gpu_target_config_filename(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_gpu_target_config_filename(); PROTOBUF_NODISCARD std::string* release_xla_gpu_target_config_filename(); void set_allocated_xla_gpu_target_config_filename(std::string* xla_gpu_target_config_filename); private: const std::string& _internal_xla_gpu_target_config_filename() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_target_config_filename(const std::string& value); std::string* _internal_mutable_xla_gpu_target_config_filename(); public: // string xla_gpu_enable_custom_fusions_re = 264; void clear_xla_gpu_enable_custom_fusions_re(); const std::string& xla_gpu_enable_custom_fusions_re() const; template void set_xla_gpu_enable_custom_fusions_re(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_gpu_enable_custom_fusions_re(); PROTOBUF_NODISCARD std::string* release_xla_gpu_enable_custom_fusions_re(); void set_allocated_xla_gpu_enable_custom_fusions_re(std::string* xla_gpu_enable_custom_fusions_re); private: const std::string& _internal_xla_gpu_enable_custom_fusions_re() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_enable_custom_fusions_re(const std::string& value); std::string* _internal_mutable_xla_gpu_enable_custom_fusions_re(); public: // string xla_gpu_dump_autotune_logs_to = 292; void clear_xla_gpu_dump_autotune_logs_to(); const std::string& xla_gpu_dump_autotune_logs_to() const; template void set_xla_gpu_dump_autotune_logs_to(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_gpu_dump_autotune_logs_to(); PROTOBUF_NODISCARD std::string* release_xla_gpu_dump_autotune_logs_to(); void set_allocated_xla_gpu_dump_autotune_logs_to(std::string* xla_gpu_dump_autotune_logs_to); private: const std::string& _internal_xla_gpu_dump_autotune_logs_to() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_dump_autotune_logs_to(const std::string& value); std::string* _internal_mutable_xla_gpu_dump_autotune_logs_to(); public: // string xla_gpu_override_gemm_autotuner = 295; void clear_xla_gpu_override_gemm_autotuner(); const std::string& xla_gpu_override_gemm_autotuner() const; template void set_xla_gpu_override_gemm_autotuner(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_gpu_override_gemm_autotuner(); PROTOBUF_NODISCARD std::string* release_xla_gpu_override_gemm_autotuner(); void set_allocated_xla_gpu_override_gemm_autotuner(std::string* xla_gpu_override_gemm_autotuner); private: const std::string& _internal_xla_gpu_override_gemm_autotuner() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_override_gemm_autotuner(const std::string& value); std::string* _internal_mutable_xla_gpu_override_gemm_autotuner(); public: // string xla_gpu_kernel_cache_file = 306; void clear_xla_gpu_kernel_cache_file(); const std::string& xla_gpu_kernel_cache_file() const; template void set_xla_gpu_kernel_cache_file(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_gpu_kernel_cache_file(); PROTOBUF_NODISCARD std::string* release_xla_gpu_kernel_cache_file(); void set_allocated_xla_gpu_kernel_cache_file(std::string* xla_gpu_kernel_cache_file); private: const std::string& _internal_xla_gpu_kernel_cache_file() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_kernel_cache_file(const std::string& value); std::string* _internal_mutable_xla_gpu_kernel_cache_file(); public: // string xla_gpu_per_fusion_autotune_cache_dir = 310; void clear_xla_gpu_per_fusion_autotune_cache_dir(); const std::string& xla_gpu_per_fusion_autotune_cache_dir() const; template void set_xla_gpu_per_fusion_autotune_cache_dir(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_gpu_per_fusion_autotune_cache_dir(); PROTOBUF_NODISCARD std::string* release_xla_gpu_per_fusion_autotune_cache_dir(); void set_allocated_xla_gpu_per_fusion_autotune_cache_dir(std::string* xla_gpu_per_fusion_autotune_cache_dir); private: const std::string& _internal_xla_gpu_per_fusion_autotune_cache_dir() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_gpu_per_fusion_autotune_cache_dir(const std::string& value); std::string* _internal_mutable_xla_gpu_per_fusion_autotune_cache_dir(); public: // string xla_cpu_max_isa = 333; void clear_xla_cpu_max_isa(); const std::string& xla_cpu_max_isa() const; template void set_xla_cpu_max_isa(ArgT0&& arg0, ArgT... args); std::string* mutable_xla_cpu_max_isa(); PROTOBUF_NODISCARD std::string* release_xla_cpu_max_isa(); void set_allocated_xla_cpu_max_isa(std::string* xla_cpu_max_isa); private: const std::string& _internal_xla_cpu_max_isa() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_xla_cpu_max_isa(const std::string& value); std::string* _internal_mutable_xla_cpu_max_isa(); public: // int32 xla_backend_optimization_level = 31; void clear_xla_backend_optimization_level(); int32_t xla_backend_optimization_level() const; void set_xla_backend_optimization_level(int32_t value); private: int32_t _internal_xla_backend_optimization_level() const; void _internal_set_xla_backend_optimization_level(int32_t value); public: // bool xla_embed_ir_in_executable = 33; void clear_xla_embed_ir_in_executable(); bool xla_embed_ir_in_executable() const; void set_xla_embed_ir_in_executable(bool value); private: bool _internal_xla_embed_ir_in_executable() const; void _internal_set_xla_embed_ir_in_executable(bool value); public: // bool xla_eliminate_hlo_implicit_broadcast = 35; void clear_xla_eliminate_hlo_implicit_broadcast(); bool xla_eliminate_hlo_implicit_broadcast() const; void set_xla_eliminate_hlo_implicit_broadcast(bool value); private: bool _internal_xla_eliminate_hlo_implicit_broadcast() const; void _internal_set_xla_eliminate_hlo_implicit_broadcast(bool value); public: // bool xla_cpu_multi_thread_eigen = 60; void clear_xla_cpu_multi_thread_eigen(); bool xla_cpu_multi_thread_eigen() const; void set_xla_cpu_multi_thread_eigen(bool value); private: bool _internal_xla_cpu_multi_thread_eigen() const; void _internal_set_xla_cpu_multi_thread_eigen(bool value); public: // bool xla_llvm_enable_alias_scope_metadata = 70; void clear_xla_llvm_enable_alias_scope_metadata(); bool xla_llvm_enable_alias_scope_metadata() const; void set_xla_llvm_enable_alias_scope_metadata(bool value); private: bool _internal_xla_llvm_enable_alias_scope_metadata() const; void _internal_set_xla_llvm_enable_alias_scope_metadata(bool value); public: // bool xla_llvm_enable_noalias_metadata = 71; void clear_xla_llvm_enable_noalias_metadata(); bool xla_llvm_enable_noalias_metadata() const; void set_xla_llvm_enable_noalias_metadata(bool value); private: bool _internal_xla_llvm_enable_noalias_metadata() const; void _internal_set_xla_llvm_enable_noalias_metadata(bool value); public: // bool xla_llvm_enable_invariant_load_metadata = 72; void clear_xla_llvm_enable_invariant_load_metadata(); bool xla_llvm_enable_invariant_load_metadata() const; void set_xla_llvm_enable_invariant_load_metadata(bool value); private: bool _internal_xla_llvm_enable_invariant_load_metadata() const; void _internal_set_xla_llvm_enable_invariant_load_metadata(bool value); public: // bool xla_llvm_disable_expensive_passes = 73; void clear_xla_llvm_disable_expensive_passes(); bool xla_llvm_disable_expensive_passes() const; void set_xla_llvm_disable_expensive_passes(bool value); private: bool _internal_xla_llvm_disable_expensive_passes() const; void _internal_set_xla_llvm_disable_expensive_passes(bool value); public: // bool xla_test_all_output_layouts = 90; void clear_xla_test_all_output_layouts(); bool xla_test_all_output_layouts() const; void set_xla_test_all_output_layouts(bool value); private: bool _internal_xla_test_all_output_layouts() const; void _internal_set_xla_test_all_output_layouts(bool value); public: // bool xla_test_all_input_layouts = 91; void clear_xla_test_all_input_layouts(); bool xla_test_all_input_layouts() const; void set_xla_test_all_input_layouts(bool value); private: bool _internal_xla_test_all_input_layouts() const; void _internal_set_xla_test_all_input_layouts(bool value); public: // bool xla_hlo_graph_sharding_color = 92; void clear_xla_hlo_graph_sharding_color(); bool xla_hlo_graph_sharding_color() const; void set_xla_hlo_graph_sharding_color(bool value); private: bool _internal_xla_hlo_graph_sharding_color() const; void _internal_set_xla_hlo_graph_sharding_color(bool value); public: // bool xla_cpu_use_mkl_dnn = 97; void clear_xla_cpu_use_mkl_dnn(); bool xla_cpu_use_mkl_dnn() const; void set_xla_cpu_use_mkl_dnn(bool value); private: bool _internal_xla_cpu_use_mkl_dnn() const; void _internal_set_xla_cpu_use_mkl_dnn(bool value); public: // bool xla_allow_excess_precision = 122; void clear_xla_allow_excess_precision(); bool xla_allow_excess_precision() const; void set_xla_allow_excess_precision(bool value); private: bool _internal_xla_allow_excess_precision() const; void _internal_set_xla_allow_excess_precision(bool value); public: // bool xla_gpu_verify_triton_fusion_numerics = 291; void clear_xla_gpu_verify_triton_fusion_numerics(); bool xla_gpu_verify_triton_fusion_numerics() const; void set_xla_gpu_verify_triton_fusion_numerics(bool value); private: bool _internal_xla_gpu_verify_triton_fusion_numerics() const; void _internal_set_xla_gpu_verify_triton_fusion_numerics(bool value); public: // bool xla_hlo_graph_addresses = 2; void clear_xla_hlo_graph_addresses(); bool xla_hlo_graph_addresses() const; void set_xla_hlo_graph_addresses(bool value); private: bool _internal_xla_hlo_graph_addresses() const; void _internal_set_xla_hlo_graph_addresses(bool value); public: // bool xla_hlo_profile = 9; void clear_xla_hlo_profile(); bool xla_hlo_profile() const; void set_xla_hlo_profile(bool value); private: bool _internal_xla_hlo_profile() const; void _internal_set_xla_hlo_profile(bool value); public: // bool xla_disable_all_hlo_passes = 104; void clear_xla_disable_all_hlo_passes(); bool xla_disable_all_hlo_passes() const; void set_xla_disable_all_hlo_passes(bool value); private: bool _internal_xla_disable_all_hlo_passes() const; void _internal_set_xla_disable_all_hlo_passes(bool value); public: // int32 xla_force_host_platform_device_count = 102; void clear_xla_force_host_platform_device_count(); int32_t xla_force_host_platform_device_count() const; void set_xla_force_host_platform_device_count(int32_t value); private: int32_t _internal_xla_force_host_platform_device_count() const; void _internal_set_xla_force_host_platform_device_count(int32_t value); public: // .xla.DebugOptions.StepMarkerLocation xla_step_marker_location = 108; void clear_xla_step_marker_location(); ::xla::DebugOptions_StepMarkerLocation xla_step_marker_location() const; void set_xla_step_marker_location(::xla::DebugOptions_StepMarkerLocation value); private: ::xla::DebugOptions_StepMarkerLocation _internal_xla_step_marker_location() const; void _internal_set_xla_step_marker_location(::xla::DebugOptions_StepMarkerLocation value); public: // bool xla_dump_hlo_as_proto = 113; void clear_xla_dump_hlo_as_proto(); bool xla_dump_hlo_as_proto() const; void set_xla_dump_hlo_as_proto(bool value); private: bool _internal_xla_dump_hlo_as_proto() const; void _internal_set_xla_dump_hlo_as_proto(bool value); public: // bool xla_dump_hlo_as_dot = 114; void clear_xla_dump_hlo_as_dot(); bool xla_dump_hlo_as_dot() const; void set_xla_dump_hlo_as_dot(bool value); private: bool _internal_xla_dump_hlo_as_dot() const; void _internal_set_xla_dump_hlo_as_dot(bool value); public: // bool xla_dump_hlo_as_url = 115; void clear_xla_dump_hlo_as_url(); bool xla_dump_hlo_as_url() const; void set_xla_dump_hlo_as_url(bool value); private: bool _internal_xla_dump_hlo_as_url() const; void _internal_set_xla_dump_hlo_as_url(bool value); public: // bool xla_dump_hlo_as_html = 116; void clear_xla_dump_hlo_as_html(); bool xla_dump_hlo_as_html() const; void set_xla_dump_hlo_as_html(bool value); private: bool _internal_xla_dump_hlo_as_html() const; void _internal_set_xla_dump_hlo_as_html(bool value); public: // int32 xla_gpu_autotune_level = 123; void clear_xla_gpu_autotune_level(); int32_t xla_gpu_autotune_level() const; void set_xla_gpu_autotune_level(int32_t value); private: int32_t _internal_xla_gpu_autotune_level() const; void _internal_set_xla_gpu_autotune_level(int32_t value); public: // bool xla_cpu_enable_fast_min_max = 140; void clear_xla_cpu_enable_fast_min_max(); bool xla_cpu_enable_fast_min_max() const; void set_xla_cpu_enable_fast_min_max(bool value); private: bool _internal_xla_cpu_enable_fast_min_max() const; void _internal_set_xla_cpu_enable_fast_min_max(bool value); public: // bool xla_cpu_fast_math_honor_division = 126; void clear_xla_cpu_fast_math_honor_division(); bool xla_cpu_fast_math_honor_division() const; void set_xla_cpu_fast_math_honor_division(bool value); private: bool _internal_xla_cpu_fast_math_honor_division() const; void _internal_set_xla_cpu_fast_math_honor_division(bool value); public: // bool xla_cpu_fast_math_honor_functions = 129; void clear_xla_cpu_fast_math_honor_functions(); bool xla_cpu_fast_math_honor_functions() const; void set_xla_cpu_fast_math_honor_functions(bool value); private: bool _internal_xla_cpu_fast_math_honor_functions() const; void _internal_set_xla_cpu_fast_math_honor_functions(bool value); public: // bool xla_cpu_fast_math_honor_infs = 121; void clear_xla_cpu_fast_math_honor_infs(); bool xla_cpu_fast_math_honor_infs() const; void set_xla_cpu_fast_math_honor_infs(bool value); private: bool _internal_xla_cpu_fast_math_honor_infs() const; void _internal_set_xla_cpu_fast_math_honor_infs(bool value); public: // int32 xla_dump_max_hlo_modules = 132; void clear_xla_dump_max_hlo_modules(); int32_t xla_dump_max_hlo_modules() const; void set_xla_dump_max_hlo_modules(int32_t value); private: int32_t _internal_xla_dump_max_hlo_modules() const; void _internal_set_xla_dump_max_hlo_modules(int32_t value); public: // bool xla_dump_fusion_visualization = 149; void clear_xla_dump_fusion_visualization(); bool xla_dump_fusion_visualization() const; void set_xla_dump_fusion_visualization(bool value); private: bool _internal_xla_dump_fusion_visualization() const; void _internal_set_xla_dump_fusion_visualization(bool value); public: // bool xla_dump_hlo_snapshots = 118; void clear_xla_dump_hlo_snapshots(); bool xla_dump_hlo_snapshots() const; void set_xla_dump_hlo_snapshots(bool value); private: bool _internal_xla_dump_hlo_snapshots() const; void _internal_set_xla_dump_hlo_snapshots(bool value); public: // bool xla_dump_include_timestamp = 131; void clear_xla_dump_include_timestamp(); bool xla_dump_include_timestamp() const; void set_xla_dump_include_timestamp(bool value); private: bool _internal_xla_dump_include_timestamp() const; void _internal_set_xla_dump_include_timestamp(bool value); public: // bool xla_dump_module_metadata = 144; void clear_xla_dump_module_metadata(); bool xla_dump_module_metadata() const; void set_xla_dump_module_metadata(bool value); private: bool _internal_xla_dump_module_metadata() const; void _internal_set_xla_dump_module_metadata(bool value); public: // int32 xla_multiheap_size_constraint_per_heap = 142; void clear_xla_multiheap_size_constraint_per_heap(); int32_t xla_multiheap_size_constraint_per_heap() const; void set_xla_multiheap_size_constraint_per_heap(int32_t value); private: int32_t _internal_xla_multiheap_size_constraint_per_heap() const; void _internal_set_xla_multiheap_size_constraint_per_heap(int32_t value); public: // bool xla_gpu_force_conv_nchw = 125; void clear_xla_gpu_force_conv_nchw(); bool xla_gpu_force_conv_nchw() const; void set_xla_gpu_force_conv_nchw(bool value); private: bool _internal_xla_gpu_force_conv_nchw() const; void _internal_set_xla_gpu_force_conv_nchw(bool value); public: // bool xla_gpu_force_conv_nhwc = 146; void clear_xla_gpu_force_conv_nhwc(); bool xla_gpu_force_conv_nhwc() const; void set_xla_gpu_force_conv_nhwc(bool value); private: bool _internal_xla_gpu_force_conv_nhwc() const; void _internal_set_xla_gpu_force_conv_nhwc(bool value); public: // bool xla_gpu_ftz = 62; void clear_xla_gpu_ftz(); bool xla_gpu_ftz() const; void set_xla_gpu_ftz(bool value); private: bool _internal_xla_gpu_ftz() const; void _internal_set_xla_gpu_ftz(bool value); public: // bool xla_gpu_fused_attention_use_cudnn_rng = 235; void clear_xla_gpu_fused_attention_use_cudnn_rng(); bool xla_gpu_fused_attention_use_cudnn_rng() const; void set_xla_gpu_fused_attention_use_cudnn_rng(bool value); private: bool _internal_xla_gpu_fused_attention_use_cudnn_rng() const; void _internal_set_xla_gpu_fused_attention_use_cudnn_rng(bool value); public: // int32 xla_gpu_force_compilation_parallelism = 147; void clear_xla_gpu_force_compilation_parallelism(); int32_t xla_gpu_force_compilation_parallelism() const; void set_xla_gpu_force_compilation_parallelism(int32_t value); private: int32_t _internal_xla_gpu_force_compilation_parallelism() const; void _internal_set_xla_gpu_force_compilation_parallelism(int32_t value); public: // bool xla_gpu_crash_on_verification_failures = 101; void clear_xla_gpu_crash_on_verification_failures(); bool xla_gpu_crash_on_verification_failures() const; void set_xla_gpu_crash_on_verification_failures(bool value); private: bool _internal_xla_gpu_crash_on_verification_failures() const; void _internal_set_xla_gpu_crash_on_verification_failures(bool value); public: // bool xla_gpu_cublas_fallback = 247; void clear_xla_gpu_cublas_fallback(); bool xla_gpu_cublas_fallback() const; void set_xla_gpu_cublas_fallback(bool value); private: bool _internal_xla_gpu_cublas_fallback() const; void _internal_set_xla_gpu_cublas_fallback(bool value); public: // bool xla_gpu_deterministic_ops = 148; void clear_xla_gpu_deterministic_ops(); bool xla_gpu_deterministic_ops() const; void set_xla_gpu_deterministic_ops(bool value); private: bool _internal_xla_gpu_deterministic_ops() const; void _internal_set_xla_gpu_deterministic_ops(bool value); public: // bool xla_gpu_disable_gpuasm_optimizations = 103; void clear_xla_gpu_disable_gpuasm_optimizations(); bool xla_gpu_disable_gpuasm_optimizations() const; void set_xla_gpu_disable_gpuasm_optimizations(bool value); private: bool _internal_xla_gpu_disable_gpuasm_optimizations() const; void _internal_set_xla_gpu_disable_gpuasm_optimizations(bool value); public: // int64 xla_gpu_all_reduce_combine_threshold_bytes = 157; void clear_xla_gpu_all_reduce_combine_threshold_bytes(); int64_t xla_gpu_all_reduce_combine_threshold_bytes() const; void set_xla_gpu_all_reduce_combine_threshold_bytes(int64_t value); private: int64_t _internal_xla_gpu_all_reduce_combine_threshold_bytes() const; void _internal_set_xla_gpu_all_reduce_combine_threshold_bytes(int64_t value); public: // bool xla_dump_compress_protos = 151; void clear_xla_dump_compress_protos(); bool xla_dump_compress_protos() const; void set_xla_dump_compress_protos(bool value); private: bool _internal_xla_dump_compress_protos() const; void _internal_set_xla_dump_compress_protos(bool value); public: // bool xla_dump_hlo_as_long_text = 164; void clear_xla_dump_hlo_as_long_text(); bool xla_dump_hlo_as_long_text() const; void set_xla_dump_hlo_as_long_text(bool value); private: bool _internal_xla_dump_hlo_as_long_text() const; void _internal_set_xla_dump_hlo_as_long_text(bool value); public: // bool xla_dump_enable_mlir_pretty_form = 185; void clear_xla_dump_enable_mlir_pretty_form(); bool xla_dump_enable_mlir_pretty_form() const; void set_xla_dump_enable_mlir_pretty_form(bool value); private: bool _internal_xla_dump_enable_mlir_pretty_form() const; void _internal_set_xla_dump_enable_mlir_pretty_form(bool value); public: // bool xla_tpu_detect_nan = 135; void clear_xla_tpu_detect_nan(); bool xla_tpu_detect_nan() const; void set_xla_tpu_detect_nan(bool value); private: bool _internal_xla_tpu_detect_nan() const; void _internal_set_xla_tpu_detect_nan(bool value); public: // int32 xla_gpu_all_reduce_blueconnect_num_devices_per_host = 159; void clear_xla_gpu_all_reduce_blueconnect_num_devices_per_host(); int32_t xla_gpu_all_reduce_blueconnect_num_devices_per_host() const; void set_xla_gpu_all_reduce_blueconnect_num_devices_per_host(int32_t value); private: int32_t _internal_xla_gpu_all_reduce_blueconnect_num_devices_per_host() const; void _internal_set_xla_gpu_all_reduce_blueconnect_num_devices_per_host(int32_t value); public: // int64 xla_gpu_nccl_termination_timeout_seconds = 163; void clear_xla_gpu_nccl_termination_timeout_seconds(); int64_t xla_gpu_nccl_termination_timeout_seconds() const; void set_xla_gpu_nccl_termination_timeout_seconds(int64_t value); private: int64_t _internal_xla_gpu_nccl_termination_timeout_seconds() const; void _internal_set_xla_gpu_nccl_termination_timeout_seconds(int64_t value); public: // int64 xla_gpu_redzone_scratch_max_megabytes = 167; void clear_xla_gpu_redzone_scratch_max_megabytes(); int64_t xla_gpu_redzone_scratch_max_megabytes() const; void set_xla_gpu_redzone_scratch_max_megabytes(int64_t value); private: int64_t _internal_xla_gpu_redzone_scratch_max_megabytes() const; void _internal_set_xla_gpu_redzone_scratch_max_megabytes(int64_t value); public: // .xla.DebugOptions.ShapeChecks xla_gpu_shape_checks = 170; void clear_xla_gpu_shape_checks(); ::xla::DebugOptions_ShapeChecks xla_gpu_shape_checks() const; void set_xla_gpu_shape_checks(::xla::DebugOptions_ShapeChecks value); private: ::xla::DebugOptions_ShapeChecks _internal_xla_gpu_shape_checks() const; void _internal_set_xla_gpu_shape_checks(::xla::DebugOptions_ShapeChecks value); public: // bool xla_gpu_enable_custom_fusions = 263; void clear_xla_gpu_enable_custom_fusions(); bool xla_gpu_enable_custom_fusions() const; void set_xla_gpu_enable_custom_fusions(bool value); private: bool _internal_xla_gpu_enable_custom_fusions() const; void _internal_set_xla_gpu_enable_custom_fusions(bool value); public: // bool xla_gpu_enable_dynamic_slice_fusion = 105; void clear_xla_gpu_enable_dynamic_slice_fusion(); bool xla_gpu_enable_dynamic_slice_fusion() const; void set_xla_gpu_enable_dynamic_slice_fusion(bool value); private: bool _internal_xla_gpu_enable_dynamic_slice_fusion() const; void _internal_set_xla_gpu_enable_dynamic_slice_fusion(bool value); public: // bool xla_gpu_enable_fast_min_max = 100; void clear_xla_gpu_enable_fast_min_max(); bool xla_gpu_enable_fast_min_max() const; void set_xla_gpu_enable_fast_min_max(bool value); private: bool _internal_xla_gpu_enable_fast_min_max() const; void _internal_set_xla_gpu_enable_fast_min_max(bool value); public: // bool xla_gpu_enable_highest_priority_async_stream = 216; void clear_xla_gpu_enable_highest_priority_async_stream(); bool xla_gpu_enable_highest_priority_async_stream() const; void set_xla_gpu_enable_highest_priority_async_stream(bool value); private: bool _internal_xla_gpu_enable_highest_priority_async_stream() const; void _internal_set_xla_gpu_enable_highest_priority_async_stream(bool value); public: // bool xla_hlo_evaluator_use_fast_path = 106; void clear_xla_hlo_evaluator_use_fast_path(); bool xla_hlo_evaluator_use_fast_path() const; void set_xla_hlo_evaluator_use_fast_path(bool value); private: bool _internal_xla_hlo_evaluator_use_fast_path() const; void _internal_set_xla_hlo_evaluator_use_fast_path(bool value); public: // bool xla_allow_scalar_index_dynamic_ops = 107; void clear_xla_allow_scalar_index_dynamic_ops(); bool xla_allow_scalar_index_dynamic_ops() const; void set_xla_allow_scalar_index_dynamic_ops(bool value); private: bool _internal_xla_allow_scalar_index_dynamic_ops() const; void _internal_set_xla_allow_scalar_index_dynamic_ops(bool value); public: // bool xla_flags_reset = 364; void clear_xla_flags_reset(); bool xla_flags_reset() const; void set_xla_flags_reset(bool value); private: bool _internal_xla_flags_reset() const; void _internal_set_xla_flags_reset(bool value); public: // bool xla_dump_hlo_as_text = 112; void clear_xla_dump_hlo_as_text(); bool xla_dump_hlo_as_text() const; void set_xla_dump_hlo_as_text(bool value); private: bool _internal_xla_dump_hlo_as_text() const; void _internal_set_xla_dump_hlo_as_text(bool value); public: // .xla.DebugOptions.PartitioningAlgorithm xla_partitioning_algorithm = 187; void clear_xla_partitioning_algorithm(); ::xla::DebugOptions_PartitioningAlgorithm xla_partitioning_algorithm() const; void set_xla_partitioning_algorithm(::xla::DebugOptions_PartitioningAlgorithm value); private: ::xla::DebugOptions_PartitioningAlgorithm _internal_xla_partitioning_algorithm() const; void _internal_set_xla_partitioning_algorithm(::xla::DebugOptions_PartitioningAlgorithm value); public: // bool xla_gpu_enable_cublaslt = 166; void clear_xla_gpu_enable_cublaslt(); bool xla_gpu_enable_cublaslt() const; void set_xla_gpu_enable_cublaslt(bool value); private: bool _internal_xla_gpu_enable_cublaslt() const; void _internal_set_xla_gpu_enable_cublaslt(bool value); public: // bool xla_gpu_enable_cudnn_frontend = 160; void clear_xla_gpu_enable_cudnn_frontend(); bool xla_gpu_enable_cudnn_frontend() const; void set_xla_gpu_enable_cudnn_frontend(bool value); private: bool _internal_xla_gpu_enable_cudnn_frontend() const; void _internal_set_xla_gpu_enable_cudnn_frontend(bool value); public: // bool xla_gpu_enable_cudnn_int8x32_convolution_reordering = 189; void clear_xla_gpu_enable_cudnn_int8x32_convolution_reordering(); bool xla_gpu_enable_cudnn_int8x32_convolution_reordering() const; void set_xla_gpu_enable_cudnn_int8x32_convolution_reordering(bool value); private: bool _internal_xla_gpu_enable_cudnn_int8x32_convolution_reordering() const; void _internal_set_xla_gpu_enable_cudnn_int8x32_convolution_reordering(bool value); public: // bool xla_gpu_enable_cudnn_layer_norm = 262; void clear_xla_gpu_enable_cudnn_layer_norm(); bool xla_gpu_enable_cudnn_layer_norm() const; void set_xla_gpu_enable_cudnn_layer_norm(bool value); private: bool _internal_xla_gpu_enable_cudnn_layer_norm() const; void _internal_set_xla_gpu_enable_cudnn_layer_norm(bool value); public: // bool xla_tpu_detect_inf = 136; void clear_xla_tpu_detect_inf(); bool xla_tpu_detect_inf() const; void set_xla_tpu_detect_inf(bool value); private: bool _internal_xla_tpu_detect_inf() const; void _internal_set_xla_tpu_detect_inf(bool value); public: // bool xla_cpu_enable_xprof_traceme = 137; void clear_xla_cpu_enable_xprof_traceme(); bool xla_cpu_enable_xprof_traceme() const; void set_xla_cpu_enable_xprof_traceme(bool value); private: bool _internal_xla_cpu_enable_xprof_traceme() const; void _internal_set_xla_cpu_enable_xprof_traceme(bool value); public: // bool xla_detailed_logging = 252; void clear_xla_detailed_logging(); bool xla_detailed_logging() const; void set_xla_detailed_logging(bool value); private: bool _internal_xla_detailed_logging() const; void _internal_set_xla_detailed_logging(bool value); public: // bool xla_enable_dumping = 253; void clear_xla_enable_dumping(); bool xla_enable_dumping() const; void set_xla_enable_dumping(bool value); private: bool _internal_xla_enable_dumping() const; void _internal_set_xla_enable_dumping(bool value); public: // bool xla_llvm_force_inline_before_split = 300; void clear_xla_llvm_force_inline_before_split(); bool xla_llvm_force_inline_before_split() const; void set_xla_llvm_force_inline_before_split(bool value); private: bool _internal_xla_llvm_force_inline_before_split() const; void _internal_set_xla_llvm_force_inline_before_split(bool value); public: // bool xla_dump_disable_metadata = 153; void clear_xla_dump_disable_metadata(); bool xla_dump_disable_metadata() const; void set_xla_dump_disable_metadata(bool value); private: bool _internal_xla_dump_disable_metadata() const; void _internal_set_xla_dump_disable_metadata(bool value); public: // bool xla_cpu_use_acl = 174; void clear_xla_cpu_use_acl(); bool xla_cpu_use_acl() const; void set_xla_cpu_use_acl(bool value); private: bool _internal_xla_cpu_use_acl() const; void _internal_set_xla_cpu_use_acl(bool value); public: // bool xla_cpu_strict_dot_conv_math = 175; void clear_xla_cpu_strict_dot_conv_math(); bool xla_cpu_strict_dot_conv_math() const; void set_xla_cpu_strict_dot_conv_math(bool value); private: bool _internal_xla_cpu_strict_dot_conv_math() const; void _internal_set_xla_cpu_strict_dot_conv_math(bool value); public: // int32 xla_gpu_collective_inflation_factor = 205; void clear_xla_gpu_collective_inflation_factor(); int32_t xla_gpu_collective_inflation_factor() const; void set_xla_gpu_collective_inflation_factor(int32_t value); private: int32_t _internal_xla_gpu_collective_inflation_factor() const; void _internal_set_xla_gpu_collective_inflation_factor(int32_t value); public: // int64 xla_gpu_all_gather_combine_threshold_bytes = 212; void clear_xla_gpu_all_gather_combine_threshold_bytes(); int64_t xla_gpu_all_gather_combine_threshold_bytes() const; void set_xla_gpu_all_gather_combine_threshold_bytes(int64_t value); private: int64_t _internal_xla_gpu_all_gather_combine_threshold_bytes() const; void _internal_set_xla_gpu_all_gather_combine_threshold_bytes(int64_t value); public: // int64 xla_gpu_reduce_scatter_combine_threshold_bytes = 213; void clear_xla_gpu_reduce_scatter_combine_threshold_bytes(); int64_t xla_gpu_reduce_scatter_combine_threshold_bytes() const; void set_xla_gpu_reduce_scatter_combine_threshold_bytes(int64_t value); private: int64_t _internal_xla_gpu_reduce_scatter_combine_threshold_bytes() const; void _internal_set_xla_gpu_reduce_scatter_combine_threshold_bytes(int64_t value); public: // int32 xla_gpu_graph_min_graph_size = 208; void clear_xla_gpu_graph_min_graph_size(); int32_t xla_gpu_graph_min_graph_size() const; void set_xla_gpu_graph_min_graph_size(int32_t value); private: int32_t _internal_xla_gpu_graph_min_graph_size() const; void _internal_set_xla_gpu_graph_min_graph_size(int32_t value); public: // int32 xla_gpu_auto_spmd_partitioning_memory_budget_gb = 224; void clear_xla_gpu_auto_spmd_partitioning_memory_budget_gb(); int32_t xla_gpu_auto_spmd_partitioning_memory_budget_gb() const; void set_xla_gpu_auto_spmd_partitioning_memory_budget_gb(int32_t value); private: int32_t _internal_xla_gpu_auto_spmd_partitioning_memory_budget_gb() const; void _internal_set_xla_gpu_auto_spmd_partitioning_memory_budget_gb(int32_t value); public: // int64 xla_gpu_redzone_padding_bytes = 228; void clear_xla_gpu_redzone_padding_bytes(); int64_t xla_gpu_redzone_padding_bytes() const; void set_xla_gpu_redzone_padding_bytes(int64_t value); private: int64_t _internal_xla_gpu_redzone_padding_bytes() const; void _internal_set_xla_gpu_redzone_padding_bytes(int64_t value); public: // float xla_gpu_auto_spmd_partitioning_memory_budget_ratio = 225; void clear_xla_gpu_auto_spmd_partitioning_memory_budget_ratio(); float xla_gpu_auto_spmd_partitioning_memory_budget_ratio() const; void set_xla_gpu_auto_spmd_partitioning_memory_budget_ratio(float value); private: float _internal_xla_gpu_auto_spmd_partitioning_memory_budget_ratio() const; void _internal_set_xla_gpu_auto_spmd_partitioning_memory_budget_ratio(float value); public: // bool xla_gpu_enable_pipelined_all_gather = 227; void clear_xla_gpu_enable_pipelined_all_gather(); bool xla_gpu_enable_pipelined_all_gather() const; void set_xla_gpu_enable_pipelined_all_gather(bool value); private: bool _internal_xla_gpu_enable_pipelined_all_gather() const; void _internal_set_xla_gpu_enable_pipelined_all_gather(bool value); public: // bool xla_gpu_enable_pipelined_all_reduce = 217; void clear_xla_gpu_enable_pipelined_all_reduce(); bool xla_gpu_enable_pipelined_all_reduce() const; void set_xla_gpu_enable_pipelined_all_reduce(bool value); private: bool _internal_xla_gpu_enable_pipelined_all_reduce() const; void _internal_set_xla_gpu_enable_pipelined_all_reduce(bool value); public: // bool xla_gpu_enable_pipelined_collectives = 239; void clear_xla_gpu_enable_pipelined_collectives(); bool xla_gpu_enable_pipelined_collectives() const; void set_xla_gpu_enable_pipelined_collectives(bool value); private: bool _internal_xla_gpu_enable_pipelined_collectives() const; void _internal_set_xla_gpu_enable_pipelined_collectives(bool value); public: // bool xla_gpu_enable_pipelined_p2p = 246; void clear_xla_gpu_enable_pipelined_p2p(); bool xla_gpu_enable_pipelined_p2p() const; void set_xla_gpu_enable_pipelined_p2p(bool value); private: bool _internal_xla_gpu_enable_pipelined_p2p() const; void _internal_set_xla_gpu_enable_pipelined_p2p(bool value); public: // bool xla_gpu_enable_scatter_determinism_expander = 345; void clear_xla_gpu_enable_scatter_determinism_expander(); bool xla_gpu_enable_scatter_determinism_expander() const; void set_xla_gpu_enable_scatter_determinism_expander(bool value); private: bool _internal_xla_gpu_enable_scatter_determinism_expander() const; void _internal_set_xla_gpu_enable_scatter_determinism_expander(bool value); public: // bool xla_gpu_enable_shared_constants = 165; void clear_xla_gpu_enable_shared_constants(); bool xla_gpu_enable_shared_constants() const; void set_xla_gpu_enable_shared_constants(bool value); private: bool _internal_xla_gpu_enable_shared_constants() const; void _internal_set_xla_gpu_enable_shared_constants(bool value); public: // bool xla_gpu_enable_split_k_autotuning = 241; void clear_xla_gpu_enable_split_k_autotuning(); bool xla_gpu_enable_split_k_autotuning() const; void set_xla_gpu_enable_split_k_autotuning(bool value); private: bool _internal_xla_gpu_enable_split_k_autotuning() const; void _internal_set_xla_gpu_enable_split_k_autotuning(bool value); public: // bool xla_gpu_enable_triton_gemm = 188; void clear_xla_gpu_enable_triton_gemm(); bool xla_gpu_enable_triton_gemm() const; void set_xla_gpu_enable_triton_gemm(bool value); private: bool _internal_xla_gpu_enable_triton_gemm() const; void _internal_set_xla_gpu_enable_triton_gemm(bool value); public: // bool xla_gpu_enable_pipelined_reduce_scatter = 231; void clear_xla_gpu_enable_pipelined_reduce_scatter(); bool xla_gpu_enable_pipelined_reduce_scatter() const; void set_xla_gpu_enable_pipelined_reduce_scatter(bool value); private: bool _internal_xla_gpu_enable_pipelined_reduce_scatter() const; void _internal_set_xla_gpu_enable_pipelined_reduce_scatter(bool value); public: // bool xla_gpu_enable_reassociation_for_converted_ar = 209; void clear_xla_gpu_enable_reassociation_for_converted_ar(); bool xla_gpu_enable_reassociation_for_converted_ar() const; void set_xla_gpu_enable_reassociation_for_converted_ar(bool value); private: bool _internal_xla_gpu_enable_reassociation_for_converted_ar() const; void _internal_set_xla_gpu_enable_reassociation_for_converted_ar(bool value); public: // bool xla_gpu_enable_reduce_scatter_combine_by_dim = 257; void clear_xla_gpu_enable_reduce_scatter_combine_by_dim(); bool xla_gpu_enable_reduce_scatter_combine_by_dim() const; void set_xla_gpu_enable_reduce_scatter_combine_by_dim(bool value); private: bool _internal_xla_gpu_enable_reduce_scatter_combine_by_dim() const; void _internal_set_xla_gpu_enable_reduce_scatter_combine_by_dim(bool value); public: // bool xla_gpu_enable_reduction_epilogue_fusion = 243; void clear_xla_gpu_enable_reduction_epilogue_fusion(); bool xla_gpu_enable_reduction_epilogue_fusion() const; void set_xla_gpu_enable_reduction_epilogue_fusion(bool value); private: bool _internal_xla_gpu_enable_reduction_epilogue_fusion() const; void _internal_set_xla_gpu_enable_reduction_epilogue_fusion(bool value); public: // int64 xla_gpu_collective_permute_decomposer_threshold = 237; void clear_xla_gpu_collective_permute_decomposer_threshold(); int64_t xla_gpu_collective_permute_decomposer_threshold() const; void set_xla_gpu_collective_permute_decomposer_threshold(int64_t value); private: int64_t _internal_xla_gpu_collective_permute_decomposer_threshold() const; void _internal_set_xla_gpu_collective_permute_decomposer_threshold(int64_t value); public: // bool xla_gpu_shard_autotuning = 304; void clear_xla_gpu_shard_autotuning(); bool xla_gpu_shard_autotuning() const; void set_xla_gpu_shard_autotuning(bool value); private: bool _internal_xla_gpu_shard_autotuning() const; void _internal_set_xla_gpu_shard_autotuning(bool value); public: // bool xla_gpu_strict_conv_algorithm_picker = 156; void clear_xla_gpu_strict_conv_algorithm_picker(); bool xla_gpu_strict_conv_algorithm_picker() const; void set_xla_gpu_strict_conv_algorithm_picker(bool value); private: bool _internal_xla_gpu_strict_conv_algorithm_picker() const; void _internal_set_xla_gpu_strict_conv_algorithm_picker(bool value); public: // bool xla_gpu_temp_buffer_use_separate_color = 312; void clear_xla_gpu_temp_buffer_use_separate_color(); bool xla_gpu_temp_buffer_use_separate_color() const; void set_xla_gpu_temp_buffer_use_separate_color(bool value); private: bool _internal_xla_gpu_temp_buffer_use_separate_color() const; void _internal_set_xla_gpu_temp_buffer_use_separate_color(bool value); public: // bool xla_gpu_triton_gemm_any = 190; void clear_xla_gpu_triton_gemm_any(); bool xla_gpu_triton_gemm_any() const; void set_xla_gpu_triton_gemm_any(bool value); private: bool _internal_xla_gpu_triton_gemm_any() const; void _internal_set_xla_gpu_triton_gemm_any(bool value); public: // bool xla_gpu_enable_triton_hopper = 266; void clear_xla_gpu_enable_triton_hopper(); bool xla_gpu_enable_triton_hopper() const; void set_xla_gpu_enable_triton_hopper(bool value); private: bool _internal_xla_gpu_enable_triton_hopper() const; void _internal_set_xla_gpu_enable_triton_hopper(bool value); public: // bool xla_gpu_enable_while_loop_double_buffering = 248; void clear_xla_gpu_enable_while_loop_double_buffering(); bool xla_gpu_enable_while_loop_double_buffering() const; void set_xla_gpu_enable_while_loop_double_buffering(bool value); private: bool _internal_xla_gpu_enable_while_loop_double_buffering() const; void _internal_set_xla_gpu_enable_while_loop_double_buffering(bool value); public: // bool xla_gpu_enable_while_loop_reduce_scatter_code_motion = 203; void clear_xla_gpu_enable_while_loop_reduce_scatter_code_motion(); bool xla_gpu_enable_while_loop_reduce_scatter_code_motion() const; void set_xla_gpu_enable_while_loop_reduce_scatter_code_motion(bool value); private: bool _internal_xla_gpu_enable_while_loop_reduce_scatter_code_motion() const; void _internal_set_xla_gpu_enable_while_loop_reduce_scatter_code_motion(bool value); public: // bool xla_gpu_ensure_minor_dot_contraction_dims = 249; void clear_xla_gpu_ensure_minor_dot_contraction_dims(); bool xla_gpu_ensure_minor_dot_contraction_dims() const; void set_xla_gpu_ensure_minor_dot_contraction_dims(bool value); private: bool _internal_xla_gpu_ensure_minor_dot_contraction_dims() const; void _internal_set_xla_gpu_ensure_minor_dot_contraction_dims(bool value); public: // int64 xla_debug_buffer_assignment_show_max = 251; void clear_xla_debug_buffer_assignment_show_max(); int64_t xla_debug_buffer_assignment_show_max() const; void set_xla_debug_buffer_assignment_show_max(int64_t value); private: int64_t _internal_xla_debug_buffer_assignment_show_max() const; void _internal_set_xla_debug_buffer_assignment_show_max(int64_t value); public: // bool xla_gpu_dump_autotuned_gemm_fusions = 232; void clear_xla_gpu_dump_autotuned_gemm_fusions(); bool xla_gpu_dump_autotuned_gemm_fusions() const; void set_xla_gpu_dump_autotuned_gemm_fusions(bool value); private: bool _internal_xla_gpu_dump_autotuned_gemm_fusions() const; void _internal_set_xla_gpu_dump_autotuned_gemm_fusions(bool value); public: // bool xla_gpu_dump_hlo_unoptimized_snapshots = 352; void clear_xla_gpu_dump_hlo_unoptimized_snapshots(); bool xla_gpu_dump_hlo_unoptimized_snapshots() const; void set_xla_gpu_dump_hlo_unoptimized_snapshots(bool value); private: bool _internal_xla_gpu_dump_hlo_unoptimized_snapshots() const; void _internal_set_xla_gpu_dump_hlo_unoptimized_snapshots(bool value); public: // bool xla_gpu_dump_llvmir = 155; void clear_xla_gpu_dump_llvmir(); bool xla_gpu_dump_llvmir() const; void set_xla_gpu_dump_llvmir(bool value); private: bool _internal_xla_gpu_dump_llvmir() const; void _internal_set_xla_gpu_dump_llvmir(bool value); public: // bool xla_gpu_enable_all_gather_combine_by_dim = 254; void clear_xla_gpu_enable_all_gather_combine_by_dim(); bool xla_gpu_enable_all_gather_combine_by_dim() const; void set_xla_gpu_enable_all_gather_combine_by_dim(bool value); private: bool _internal_xla_gpu_enable_all_gather_combine_by_dim() const; void _internal_set_xla_gpu_enable_all_gather_combine_by_dim(bool value); public: // bool xla_gpu_enable_host_memory_offloading = 296; void clear_xla_gpu_enable_host_memory_offloading(); bool xla_gpu_enable_host_memory_offloading() const; void set_xla_gpu_enable_host_memory_offloading(bool value); private: bool _internal_xla_gpu_enable_host_memory_offloading() const; void _internal_set_xla_gpu_enable_host_memory_offloading(bool value); public: // bool xla_gpu_enable_latency_hiding_scheduler = 186; void clear_xla_gpu_enable_latency_hiding_scheduler(); bool xla_gpu_enable_latency_hiding_scheduler() const; void set_xla_gpu_enable_latency_hiding_scheduler(bool value); private: bool _internal_xla_gpu_enable_latency_hiding_scheduler() const; void _internal_set_xla_gpu_enable_latency_hiding_scheduler(bool value); public: // bool xla_gpu_enable_libnvptxcompiler = 269; void clear_xla_gpu_enable_libnvptxcompiler(); bool xla_gpu_enable_libnvptxcompiler() const; void set_xla_gpu_enable_libnvptxcompiler(bool value); private: bool _internal_xla_gpu_enable_libnvptxcompiler() const; void _internal_set_xla_gpu_enable_libnvptxcompiler(bool value); public: // bool xla_gpu_enable_llvm_module_compilation_parallelism = 268; void clear_xla_gpu_enable_llvm_module_compilation_parallelism(); bool xla_gpu_enable_llvm_module_compilation_parallelism() const; void set_xla_gpu_enable_llvm_module_compilation_parallelism(bool value); private: bool _internal_xla_gpu_enable_llvm_module_compilation_parallelism() const; void _internal_set_xla_gpu_enable_llvm_module_compilation_parallelism(bool value); public: // int32 xla_gpu_llvm_verification_level = 256; void clear_xla_gpu_llvm_verification_level(); int32_t xla_gpu_llvm_verification_level() const; void set_xla_gpu_llvm_verification_level(int32_t value); private: int32_t _internal_xla_gpu_llvm_verification_level() const; void _internal_set_xla_gpu_llvm_verification_level(int32_t value); public: // bool xla_gpu_triton_gemm_disable_reduced_precision_reduction = 226; void clear_xla_gpu_triton_gemm_disable_reduced_precision_reduction(); bool xla_gpu_triton_gemm_disable_reduced_precision_reduction() const; void set_xla_gpu_triton_gemm_disable_reduced_precision_reduction(bool value); private: bool _internal_xla_gpu_triton_gemm_disable_reduced_precision_reduction() const; void _internal_set_xla_gpu_triton_gemm_disable_reduced_precision_reduction(bool value); public: // bool xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found = 138; void clear_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found(); bool xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() const; void set_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found(bool value); private: bool _internal_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() const; void _internal_set_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found(bool value); public: // bool xla_gpu_unsafe_pipelined_loop_annotator = 309; void clear_xla_gpu_unsafe_pipelined_loop_annotator(); bool xla_gpu_unsafe_pipelined_loop_annotator() const; void set_xla_gpu_unsafe_pipelined_loop_annotator(bool value); private: bool _internal_xla_gpu_unsafe_pipelined_loop_annotator() const; void _internal_set_xla_gpu_unsafe_pipelined_loop_annotator(bool value); public: // bool xla_gpu_unsupported_annotate_with_emitter_loc = 358; void clear_xla_gpu_unsupported_annotate_with_emitter_loc(); bool xla_gpu_unsupported_annotate_with_emitter_loc() const; void set_xla_gpu_unsupported_annotate_with_emitter_loc(bool value); private: bool _internal_xla_gpu_unsupported_annotate_with_emitter_loc() const; void _internal_set_xla_gpu_unsupported_annotate_with_emitter_loc(bool value); public: // int32 xla_gpu_memory_limit_slop_factor = 260; void clear_xla_gpu_memory_limit_slop_factor(); int32_t xla_gpu_memory_limit_slop_factor() const; void set_xla_gpu_memory_limit_slop_factor(int32_t value); private: int32_t _internal_xla_gpu_memory_limit_slop_factor() const; void _internal_set_xla_gpu_memory_limit_slop_factor(int32_t value); public: // bool xla_gpu_enable_nccl_clique_optimization = 244; void clear_xla_gpu_enable_nccl_clique_optimization(); bool xla_gpu_enable_nccl_clique_optimization() const; void set_xla_gpu_enable_nccl_clique_optimization(bool value); private: bool _internal_xla_gpu_enable_nccl_clique_optimization() const; void _internal_set_xla_gpu_enable_nccl_clique_optimization(bool value); public: // bool xla_gpu_enable_nccl_comm_splitting = 272; void clear_xla_gpu_enable_nccl_comm_splitting(); bool xla_gpu_enable_nccl_comm_splitting() const; void set_xla_gpu_enable_nccl_comm_splitting(bool value); private: bool _internal_xla_gpu_enable_nccl_comm_splitting() const; void _internal_set_xla_gpu_enable_nccl_comm_splitting(bool value); public: // bool xla_gpu_enable_nccl_per_stream_comms = 276; void clear_xla_gpu_enable_nccl_per_stream_comms(); bool xla_gpu_enable_nccl_per_stream_comms() const; void set_xla_gpu_enable_nccl_per_stream_comms(bool value); private: bool _internal_xla_gpu_enable_nccl_per_stream_comms() const; void _internal_set_xla_gpu_enable_nccl_per_stream_comms(bool value); public: // bool xla_gpu_enable_nccl_user_buffers = 267; void clear_xla_gpu_enable_nccl_user_buffers(); bool xla_gpu_enable_nccl_user_buffers() const; void set_xla_gpu_enable_nccl_user_buffers(bool value); private: bool _internal_xla_gpu_enable_nccl_user_buffers() const; void _internal_set_xla_gpu_enable_nccl_user_buffers(bool value); public: // int64 xla_gpu_threshold_for_windowed_einsum_mib = 265; void clear_xla_gpu_threshold_for_windowed_einsum_mib(); int64_t xla_gpu_threshold_for_windowed_einsum_mib() const; void set_xla_gpu_threshold_for_windowed_einsum_mib(int64_t value); private: int64_t _internal_xla_gpu_threshold_for_windowed_einsum_mib() const; void _internal_set_xla_gpu_threshold_for_windowed_einsum_mib(int64_t value); public: // int64 xla_gpu_nccl_collective_max_nchannels = 273; void clear_xla_gpu_nccl_collective_max_nchannels(); int64_t xla_gpu_nccl_collective_max_nchannels() const; void set_xla_gpu_nccl_collective_max_nchannels(int64_t value); private: int64_t _internal_xla_gpu_nccl_collective_max_nchannels() const; void _internal_set_xla_gpu_nccl_collective_max_nchannels(int64_t value); public: // int64 xla_gpu_nccl_p2p_max_nchannels = 274; void clear_xla_gpu_nccl_p2p_max_nchannels(); int64_t xla_gpu_nccl_p2p_max_nchannels() const; void set_xla_gpu_nccl_p2p_max_nchannels(int64_t value); private: int64_t _internal_xla_gpu_nccl_p2p_max_nchannels() const; void _internal_set_xla_gpu_nccl_p2p_max_nchannels(int64_t value); public: // bool xla_dump_latency_hiding_schedule = 182; void clear_xla_dump_latency_hiding_schedule(); bool xla_dump_latency_hiding_schedule() const; void set_xla_dump_latency_hiding_schedule(bool value); private: bool _internal_xla_dump_latency_hiding_schedule() const; void _internal_set_xla_dump_latency_hiding_schedule(bool value); public: // bool xla_dump_large_constants = 290; void clear_xla_dump_large_constants(); bool xla_dump_large_constants() const; void set_xla_dump_large_constants(bool value); private: bool _internal_xla_dump_large_constants() const; void _internal_set_xla_dump_large_constants(bool value); public: // bool xla_syntax_sugar_async_ops = 315; void clear_xla_syntax_sugar_async_ops(); bool xla_syntax_sugar_async_ops() const; void set_xla_syntax_sugar_async_ops(bool value); private: bool _internal_xla_syntax_sugar_async_ops() const; void _internal_set_xla_syntax_sugar_async_ops(bool value); public: // bool xla_enable_command_buffers_during_profiling = 317; void clear_xla_enable_command_buffers_during_profiling(); bool xla_enable_command_buffers_during_profiling() const; void set_xla_enable_command_buffers_during_profiling(bool value); private: bool _internal_xla_enable_command_buffers_during_profiling() const; void _internal_set_xla_enable_command_buffers_during_profiling(bool value); public: // bool xla_unsupported_crash_on_hlo_pass_fix_max_iterations = 363; void clear_xla_unsupported_crash_on_hlo_pass_fix_max_iterations(); bool xla_unsupported_crash_on_hlo_pass_fix_max_iterations() const; void set_xla_unsupported_crash_on_hlo_pass_fix_max_iterations(bool value); private: bool _internal_xla_unsupported_crash_on_hlo_pass_fix_max_iterations() const; void _internal_set_xla_unsupported_crash_on_hlo_pass_fix_max_iterations(bool value); public: // bool xla_cpu_copy_insertion_use_region_analysis = 337; void clear_xla_cpu_copy_insertion_use_region_analysis(); bool xla_cpu_copy_insertion_use_region_analysis() const; void set_xla_cpu_copy_insertion_use_region_analysis(bool value); private: bool _internal_xla_cpu_copy_insertion_use_region_analysis() const; void _internal_set_xla_cpu_copy_insertion_use_region_analysis(bool value); public: // bool xla_cpu_enable_concurrency_optimized_scheduler = 307; void clear_xla_cpu_enable_concurrency_optimized_scheduler(); bool xla_cpu_enable_concurrency_optimized_scheduler() const; void set_xla_cpu_enable_concurrency_optimized_scheduler(bool value); private: bool _internal_xla_cpu_enable_concurrency_optimized_scheduler() const; void _internal_set_xla_cpu_enable_concurrency_optimized_scheduler(bool value); public: // bool xla_cpu_enable_fast_math = 99; void clear_xla_cpu_enable_fast_math(); bool xla_cpu_enable_fast_math() const; void set_xla_cpu_enable_fast_math(bool value); private: bool _internal_xla_cpu_enable_fast_math() const; void _internal_set_xla_cpu_enable_fast_math(bool value); public: // int64 xla_gpu_nccl_init_max_rank_per_root_ratio = 277; void clear_xla_gpu_nccl_init_max_rank_per_root_ratio(); int64_t xla_gpu_nccl_init_max_rank_per_root_ratio() const; void set_xla_gpu_nccl_init_max_rank_per_root_ratio(int64_t value); private: int64_t _internal_xla_gpu_nccl_init_max_rank_per_root_ratio() const; void _internal_set_xla_gpu_nccl_init_max_rank_per_root_ratio(int64_t value); public: // bool xla_cpu_fast_math_honor_nans = 120; void clear_xla_cpu_fast_math_honor_nans(); bool xla_cpu_fast_math_honor_nans() const; void set_xla_cpu_fast_math_honor_nans(bool value); private: bool _internal_xla_cpu_fast_math_honor_nans() const; void _internal_set_xla_cpu_fast_math_honor_nans(bool value); public: // bool xla_cpu_use_thunk_runtime = 298; void clear_xla_cpu_use_thunk_runtime(); bool xla_cpu_use_thunk_runtime() const; void set_xla_cpu_use_thunk_runtime(bool value); private: bool _internal_xla_cpu_use_thunk_runtime() const; void _internal_set_xla_cpu_use_thunk_runtime(bool value); public: // bool xla_cpu_use_xnnpack = 359; void clear_xla_cpu_use_xnnpack(); bool xla_cpu_use_xnnpack() const; void set_xla_cpu_use_xnnpack(bool value); private: bool _internal_xla_cpu_use_xnnpack() const; void _internal_set_xla_cpu_use_xnnpack(bool value); public: // bool xla_enable_fast_math = 335; void clear_xla_enable_fast_math(); bool xla_enable_fast_math() const; void set_xla_enable_fast_math(bool value); private: bool _internal_xla_enable_fast_math() const; void _internal_set_xla_enable_fast_math(bool value); public: // int32 xla_gpu_cudnn_gemm_fusion_level = 285; void clear_xla_gpu_cudnn_gemm_fusion_level(); int32_t xla_gpu_cudnn_gemm_fusion_level() const; void set_xla_gpu_cudnn_gemm_fusion_level(int32_t value); private: int32_t _internal_xla_gpu_cudnn_gemm_fusion_level() const; void _internal_set_xla_gpu_cudnn_gemm_fusion_level(int32_t value); public: // int64 xla_gpu_gemm_rewrite_size_threshold = 283; void clear_xla_gpu_gemm_rewrite_size_threshold(); int64_t xla_gpu_gemm_rewrite_size_threshold() const; void set_xla_gpu_gemm_rewrite_size_threshold(int64_t value); private: int64_t _internal_xla_gpu_gemm_rewrite_size_threshold() const; void _internal_set_xla_gpu_gemm_rewrite_size_threshold(int64_t value); public: // bool xla_gpu_unsupported_enable_ragged_all_to_all_decomposer = 350; void clear_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer(); bool xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() const; void set_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer(bool value); private: bool _internal_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() const; void _internal_set_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer(bool value); public: // bool xla_gpu_unsupported_enable_triton_gemm = 322; void clear_xla_gpu_unsupported_enable_triton_gemm(); bool xla_gpu_unsupported_enable_triton_gemm() const; void set_xla_gpu_unsupported_enable_triton_gemm(bool value); private: bool _internal_xla_gpu_unsupported_enable_triton_gemm() const; void _internal_set_xla_gpu_unsupported_enable_triton_gemm(bool value); public: // bool xla_gpu_use_memcpy_local_p2p = 287; void clear_xla_gpu_use_memcpy_local_p2p(); bool xla_gpu_use_memcpy_local_p2p() const; void set_xla_gpu_use_memcpy_local_p2p(bool value); private: bool _internal_xla_gpu_use_memcpy_local_p2p() const; void _internal_set_xla_gpu_use_memcpy_local_p2p(bool value); public: // bool xla_gpu_use_runtime_fusion = 181; void clear_xla_gpu_use_runtime_fusion(); bool xla_gpu_use_runtime_fusion() const; void set_xla_gpu_use_runtime_fusion(bool value); private: bool _internal_xla_gpu_use_runtime_fusion() const; void _internal_set_xla_gpu_use_runtime_fusion(bool value); public: // bool xla_gpu_async_dot = 321; void clear_xla_gpu_async_dot(); bool xla_gpu_async_dot() const; void set_xla_gpu_async_dot(bool value); private: bool _internal_xla_gpu_async_dot() const; void _internal_set_xla_gpu_async_dot(bool value); public: // bool xla_gpu_collect_cost_model_stats = 240; void clear_xla_gpu_collect_cost_model_stats(); bool xla_gpu_collect_cost_model_stats() const; void set_xla_gpu_collect_cost_model_stats(bool value); private: bool _internal_xla_gpu_collect_cost_model_stats() const; void _internal_set_xla_gpu_collect_cost_model_stats(bool value); public: // bool xla_gpu_collectives_use_persistent_cliques = 354; void clear_xla_gpu_collectives_use_persistent_cliques(); bool xla_gpu_collectives_use_persistent_cliques() const; void set_xla_gpu_collectives_use_persistent_cliques(bool value); private: bool _internal_xla_gpu_collectives_use_persistent_cliques() const; void _internal_set_xla_gpu_collectives_use_persistent_cliques(bool value); public: // bool xla_gpu_copy_insertion_use_region_analysis = 236; void clear_xla_gpu_copy_insertion_use_region_analysis(); bool xla_gpu_copy_insertion_use_region_analysis() const; void set_xla_gpu_copy_insertion_use_region_analysis(bool value); private: bool _internal_xla_gpu_copy_insertion_use_region_analysis() const; void _internal_set_xla_gpu_copy_insertion_use_region_analysis(bool value); public: // int64 xla_gpu_autotune_max_solutions = 288; void clear_xla_gpu_autotune_max_solutions(); int64_t xla_gpu_autotune_max_solutions() const; void set_xla_gpu_autotune_max_solutions(int64_t value); private: int64_t _internal_xla_gpu_autotune_max_solutions() const; void _internal_set_xla_gpu_autotune_max_solutions(int64_t value); public: // bool xla_gpu_generate_debug_info = 348; void clear_xla_gpu_generate_debug_info(); bool xla_gpu_generate_debug_info() const; void set_xla_gpu_generate_debug_info(bool value); private: bool _internal_xla_gpu_generate_debug_info() const; void _internal_set_xla_gpu_generate_debug_info(bool value); public: // bool xla_gpu_generate_line_info = 349; void clear_xla_gpu_generate_line_info(); bool xla_gpu_generate_line_info() const; void set_xla_gpu_generate_line_info(bool value); private: bool _internal_xla_gpu_generate_line_info() const; void _internal_set_xla_gpu_generate_line_info(bool value); public: // bool xla_gpu_graph_enable_concurrent_region = 215; void clear_xla_gpu_graph_enable_concurrent_region(); bool xla_gpu_graph_enable_concurrent_region() const; void set_xla_gpu_graph_enable_concurrent_region(bool value); private: bool _internal_xla_gpu_graph_enable_concurrent_region() const; void _internal_set_xla_gpu_graph_enable_concurrent_region(bool value); public: // bool xla_gpu_mock_custom_calls = 245; void clear_xla_gpu_mock_custom_calls(); bool xla_gpu_mock_custom_calls() const; void set_xla_gpu_mock_custom_calls(bool value); private: bool _internal_xla_gpu_mock_custom_calls() const; void _internal_set_xla_gpu_mock_custom_calls(bool value); public: // bool xla_gpu_enable_analytical_latency_estimator = 255; void clear_xla_gpu_enable_analytical_latency_estimator(); bool xla_gpu_enable_analytical_latency_estimator() const; void set_xla_gpu_enable_analytical_latency_estimator(bool value); private: bool _internal_xla_gpu_enable_analytical_latency_estimator() const; void _internal_set_xla_gpu_enable_analytical_latency_estimator(bool value); public: // bool xla_gpu_enable_analytical_sol_latency_estimator = 356; void clear_xla_gpu_enable_analytical_sol_latency_estimator(); bool xla_gpu_enable_analytical_sol_latency_estimator() const; void set_xla_gpu_enable_analytical_sol_latency_estimator(bool value); private: bool _internal_xla_gpu_enable_analytical_sol_latency_estimator() const; void _internal_set_xla_gpu_enable_analytical_sol_latency_estimator(bool value); public: // bool xla_gpu_enable_approx_costly_collectives = 305; void clear_xla_gpu_enable_approx_costly_collectives(); bool xla_gpu_enable_approx_costly_collectives() const; void set_xla_gpu_enable_approx_costly_collectives(bool value); private: bool _internal_xla_gpu_enable_approx_costly_collectives() const; void _internal_set_xla_gpu_enable_approx_costly_collectives(bool value); public: // bool xla_gpu_enable_cub_radix_sort = 259; void clear_xla_gpu_enable_cub_radix_sort(); bool xla_gpu_enable_cub_radix_sort() const; void set_xla_gpu_enable_cub_radix_sort(bool value); private: bool _internal_xla_gpu_enable_cub_radix_sort() const; void _internal_set_xla_gpu_enable_cub_radix_sort(bool value); public: // int64 xla_reduce_window_rewrite_base_length = 293; void clear_xla_reduce_window_rewrite_base_length(); int64_t xla_reduce_window_rewrite_base_length() const; void set_xla_reduce_window_rewrite_base_length(int64_t value); private: int64_t _internal_xla_reduce_window_rewrite_base_length() const; void _internal_set_xla_reduce_window_rewrite_base_length(int64_t value); public: // .xla.DebugOptions.WhileLoopUnrolling xla_gpu_enable_while_loop_unrolling = 294; void clear_xla_gpu_enable_while_loop_unrolling(); ::xla::DebugOptions_WhileLoopUnrolling xla_gpu_enable_while_loop_unrolling() const; void set_xla_gpu_enable_while_loop_unrolling(::xla::DebugOptions_WhileLoopUnrolling value); private: ::xla::DebugOptions_WhileLoopUnrolling _internal_xla_gpu_enable_while_loop_unrolling() const; void _internal_set_xla_gpu_enable_while_loop_unrolling(::xla::DebugOptions_WhileLoopUnrolling value); public: // bool xla_gpu_exclude_nondeterministic_ops = 297; void clear_xla_gpu_exclude_nondeterministic_ops(); bool xla_gpu_exclude_nondeterministic_ops() const; void set_xla_gpu_exclude_nondeterministic_ops(bool value); private: bool _internal_xla_gpu_exclude_nondeterministic_ops() const; void _internal_set_xla_gpu_exclude_nondeterministic_ops(bool value); public: // bool xla_gpu_exhaustive_tiling_search = 219; void clear_xla_gpu_exhaustive_tiling_search(); bool xla_gpu_exhaustive_tiling_search() const; void set_xla_gpu_exhaustive_tiling_search(bool value); private: bool _internal_xla_gpu_exhaustive_tiling_search() const; void _internal_set_xla_gpu_exhaustive_tiling_search(bool value); public: // bool xla_gpu_experimental_disable_binary_libraries = 329; void clear_xla_gpu_experimental_disable_binary_libraries(); bool xla_gpu_experimental_disable_binary_libraries() const; void set_xla_gpu_experimental_disable_binary_libraries(bool value); private: bool _internal_xla_gpu_experimental_disable_binary_libraries() const; void _internal_set_xla_gpu_experimental_disable_binary_libraries(bool value); public: // bool xla_gpu_experimental_dump_fdo_profiles = 338; void clear_xla_gpu_experimental_dump_fdo_profiles(); bool xla_gpu_experimental_dump_fdo_profiles() const; void set_xla_gpu_experimental_dump_fdo_profiles(bool value); private: bool _internal_xla_gpu_experimental_dump_fdo_profiles() const; void _internal_set_xla_gpu_experimental_dump_fdo_profiles(bool value); public: // bool xla_gpu_multi_streamed_windowed_einsum = 280; void clear_xla_gpu_multi_streamed_windowed_einsum(); bool xla_gpu_multi_streamed_windowed_einsum() const; void set_xla_gpu_multi_streamed_windowed_einsum(bool value); private: bool _internal_xla_gpu_multi_streamed_windowed_einsum() const; void _internal_set_xla_gpu_multi_streamed_windowed_einsum(bool value); public: // bool xla_gpu_nccl_terminate_on_error = 301; void clear_xla_gpu_nccl_terminate_on_error(); bool xla_gpu_nccl_terminate_on_error() const; void set_xla_gpu_nccl_terminate_on_error(bool value); private: bool _internal_xla_gpu_nccl_terminate_on_error() const; void _internal_set_xla_gpu_nccl_terminate_on_error(bool value); public: // bool xla_gpu_require_complete_aot_autotune_results = 284; void clear_xla_gpu_require_complete_aot_autotune_results(); bool xla_gpu_require_complete_aot_autotune_results() const; void set_xla_gpu_require_complete_aot_autotune_results(bool value); private: bool _internal_xla_gpu_require_complete_aot_autotune_results() const; void _internal_set_xla_gpu_require_complete_aot_autotune_results(bool value); public: // bool xla_gpu_require_exclusive_lock = 347; void clear_xla_gpu_require_exclusive_lock(); bool xla_gpu_require_exclusive_lock() const; void set_xla_gpu_require_exclusive_lock(bool value); private: bool _internal_xla_gpu_require_exclusive_lock() const; void _internal_set_xla_gpu_require_exclusive_lock(bool value); public: // int32 xla_cpu_prefer_vector_width = 308; void clear_xla_cpu_prefer_vector_width(); int32_t xla_cpu_prefer_vector_width() const; void set_xla_cpu_prefer_vector_width(int32_t value); private: int32_t _internal_xla_cpu_prefer_vector_width() const; void _internal_set_xla_cpu_prefer_vector_width(int32_t value); public: // int64 xla_cmd_buffer_trace_cache_size = 311; void clear_xla_cmd_buffer_trace_cache_size(); int64_t xla_cmd_buffer_trace_cache_size() const; void set_xla_cmd_buffer_trace_cache_size(int64_t value); private: int64_t _internal_xla_cmd_buffer_trace_cache_size() const; void _internal_set_xla_cmd_buffer_trace_cache_size(int64_t value); public: // float xla_gpu_autotune_gemm_rtol = 316; void clear_xla_gpu_autotune_gemm_rtol(); float xla_gpu_autotune_gemm_rtol() const; void set_xla_gpu_autotune_gemm_rtol(float value); private: float _internal_xla_gpu_autotune_gemm_rtol() const; void _internal_set_xla_gpu_autotune_gemm_rtol(float value); public: // int32 xla_gpu_cudnn_gemm_max_plans = 318; void clear_xla_gpu_cudnn_gemm_max_plans(); int32_t xla_gpu_cudnn_gemm_max_plans() const; void set_xla_gpu_cudnn_gemm_max_plans(int32_t value); private: int32_t _internal_xla_gpu_cudnn_gemm_max_plans() const; void _internal_set_xla_gpu_cudnn_gemm_max_plans(int32_t value); public: // int32 xla_cpu_parallel_codegen_split_count = 323; void clear_xla_cpu_parallel_codegen_split_count(); int32_t xla_cpu_parallel_codegen_split_count() const; void set_xla_cpu_parallel_codegen_split_count(int32_t value); private: int32_t _internal_xla_cpu_parallel_codegen_split_count() const; void _internal_set_xla_cpu_parallel_codegen_split_count(int32_t value); public: // .xla.DebugOptions.AutotuneCacheMode xla_gpu_experimental_autotune_cache_mode = 324; void clear_xla_gpu_experimental_autotune_cache_mode(); ::xla::DebugOptions_AutotuneCacheMode xla_gpu_experimental_autotune_cache_mode() const; void set_xla_gpu_experimental_autotune_cache_mode(::xla::DebugOptions_AutotuneCacheMode value); private: ::xla::DebugOptions_AutotuneCacheMode _internal_xla_gpu_experimental_autotune_cache_mode() const; void _internal_set_xla_gpu_experimental_autotune_cache_mode(::xla::DebugOptions_AutotuneCacheMode value); public: // bool xla_gpu_experimental_pack_dot_operands_along_k_dimension = 362; void clear_xla_gpu_experimental_pack_dot_operands_along_k_dimension(); bool xla_gpu_experimental_pack_dot_operands_along_k_dimension() const; void set_xla_gpu_experimental_pack_dot_operands_along_k_dimension(bool value); private: bool _internal_xla_gpu_experimental_pack_dot_operands_along_k_dimension() const; void _internal_set_xla_gpu_experimental_pack_dot_operands_along_k_dimension(bool value); public: // bool xla_gpu_experimental_stream_annotation = 342; void clear_xla_gpu_experimental_stream_annotation(); bool xla_gpu_experimental_stream_annotation() const; void set_xla_gpu_experimental_stream_annotation(bool value); private: bool _internal_xla_gpu_experimental_stream_annotation() const; void _internal_set_xla_gpu_experimental_stream_annotation(bool value); public: // bool xla_gpu_fail_ptx_compilation_on_register_spilling = 353; void clear_xla_gpu_fail_ptx_compilation_on_register_spilling(); bool xla_gpu_fail_ptx_compilation_on_register_spilling() const; void set_xla_gpu_fail_ptx_compilation_on_register_spilling(bool value); private: bool _internal_xla_gpu_fail_ptx_compilation_on_register_spilling() const; void _internal_set_xla_gpu_fail_ptx_compilation_on_register_spilling(bool value); public: // bool xla_gpu_filter_kernels_spilling_registers_on_autotuning = 250; void clear_xla_gpu_filter_kernels_spilling_registers_on_autotuning(); bool xla_gpu_filter_kernels_spilling_registers_on_autotuning() const; void set_xla_gpu_filter_kernels_spilling_registers_on_autotuning(bool value); private: bool _internal_xla_gpu_filter_kernels_spilling_registers_on_autotuning() const; void _internal_set_xla_gpu_filter_kernels_spilling_registers_on_autotuning(bool value); public: // int32 xla_gpu_executable_warn_stuck_timeout_seconds = 327; void clear_xla_gpu_executable_warn_stuck_timeout_seconds(); int32_t xla_gpu_executable_warn_stuck_timeout_seconds() const; void set_xla_gpu_executable_warn_stuck_timeout_seconds(int32_t value); private: int32_t _internal_xla_gpu_executable_warn_stuck_timeout_seconds() const; void _internal_set_xla_gpu_executable_warn_stuck_timeout_seconds(int32_t value); public: // int32 xla_gpu_executable_terminate_timeout_seconds = 328; void clear_xla_gpu_executable_terminate_timeout_seconds(); int32_t xla_gpu_executable_terminate_timeout_seconds() const; void set_xla_gpu_executable_terminate_timeout_seconds(int32_t value); private: int32_t _internal_xla_gpu_executable_terminate_timeout_seconds() const; void _internal_set_xla_gpu_executable_terminate_timeout_seconds(int32_t value); public: // int32 xla_gpu_dot_merger_threshold_mb = 331; void clear_xla_gpu_dot_merger_threshold_mb(); int32_t xla_gpu_dot_merger_threshold_mb() const; void set_xla_gpu_dot_merger_threshold_mb(int32_t value); private: int32_t _internal_xla_gpu_dot_merger_threshold_mb() const; void _internal_set_xla_gpu_dot_merger_threshold_mb(int32_t value); public: // int32 xla_gpu_experimental_parallel_collective_overlap_limit = 336; void clear_xla_gpu_experimental_parallel_collective_overlap_limit(); int32_t xla_gpu_experimental_parallel_collective_overlap_limit() const; void set_xla_gpu_experimental_parallel_collective_overlap_limit(int32_t value); private: int32_t _internal_xla_gpu_experimental_parallel_collective_overlap_limit() const; void _internal_set_xla_gpu_experimental_parallel_collective_overlap_limit(int32_t value); public: // bool xla_ignore_channel_id = 330; void clear_xla_ignore_channel_id(); bool xla_ignore_channel_id() const; void set_xla_ignore_channel_id(bool value); private: bool _internal_xla_ignore_channel_id() const; void _internal_set_xla_ignore_channel_id(bool value); public: // bool xla_pjrt_allow_auto_layout_in_hlo = 344; void clear_xla_pjrt_allow_auto_layout_in_hlo(); bool xla_pjrt_allow_auto_layout_in_hlo() const; void set_xla_pjrt_allow_auto_layout_in_hlo(bool value); private: bool _internal_xla_pjrt_allow_auto_layout_in_hlo() const; void _internal_set_xla_pjrt_allow_auto_layout_in_hlo(bool value); public: // int64 xla_gpu_operand_bytes_threshold_for_windowed_einsum = 339; void clear_xla_gpu_operand_bytes_threshold_for_windowed_einsum(); int64_t xla_gpu_operand_bytes_threshold_for_windowed_einsum() const; void set_xla_gpu_operand_bytes_threshold_for_windowed_einsum(int64_t value); private: int64_t _internal_xla_gpu_operand_bytes_threshold_for_windowed_einsum() const; void _internal_set_xla_gpu_operand_bytes_threshold_for_windowed_einsum(int64_t value); public: // .xla.DebugOptions.PGLEStrictnessLevel xla_gpu_pgle_accuracy_checker = 341; void clear_xla_gpu_pgle_accuracy_checker(); ::xla::DebugOptions_PGLEStrictnessLevel xla_gpu_pgle_accuracy_checker() const; void set_xla_gpu_pgle_accuracy_checker(::xla::DebugOptions_PGLEStrictnessLevel value); private: ::xla::DebugOptions_PGLEStrictnessLevel _internal_xla_gpu_pgle_accuracy_checker() const; void _internal_set_xla_gpu_pgle_accuracy_checker(::xla::DebugOptions_PGLEStrictnessLevel value); public: // .xla.DebugOptions.LibNvJitLinkMode xla_gpu_libnvjitlink_mode = 343; void clear_xla_gpu_libnvjitlink_mode(); ::xla::DebugOptions_LibNvJitLinkMode xla_gpu_libnvjitlink_mode() const; void set_xla_gpu_libnvjitlink_mode(::xla::DebugOptions_LibNvJitLinkMode value); private: ::xla::DebugOptions_LibNvJitLinkMode _internal_xla_gpu_libnvjitlink_mode() const; void _internal_set_xla_gpu_libnvjitlink_mode(::xla::DebugOptions_LibNvJitLinkMode value); public: // bool xla_gpu_experimental_enable_alltoall_windowed_einsum = 360; void clear_xla_gpu_experimental_enable_alltoall_windowed_einsum(); bool xla_gpu_experimental_enable_alltoall_windowed_einsum() const; void set_xla_gpu_experimental_enable_alltoall_windowed_einsum(bool value); private: bool _internal_xla_gpu_experimental_enable_alltoall_windowed_einsum() const; void _internal_set_xla_gpu_experimental_enable_alltoall_windowed_einsum(bool value); public: // bool xla_gpu_experimental_enable_fusion_block_level_rewriter = 334; void clear_xla_gpu_experimental_enable_fusion_block_level_rewriter(); bool xla_gpu_experimental_enable_fusion_block_level_rewriter() const; void set_xla_gpu_experimental_enable_fusion_block_level_rewriter(bool value); private: bool _internal_xla_gpu_experimental_enable_fusion_block_level_rewriter() const; void _internal_set_xla_gpu_experimental_enable_fusion_block_level_rewriter(bool value); public: // bool xla_gpu_experimental_enable_triton_heroless_priority_fusion = 340; void clear_xla_gpu_experimental_enable_triton_heroless_priority_fusion(); bool xla_gpu_experimental_enable_triton_heroless_priority_fusion() const; void set_xla_gpu_experimental_enable_triton_heroless_priority_fusion(bool value); private: bool _internal_xla_gpu_experimental_enable_triton_heroless_priority_fusion() const; void _internal_set_xla_gpu_experimental_enable_triton_heroless_priority_fusion(bool value); public: // bool xla_gpu_experimental_enable_triton_tma = 355; void clear_xla_gpu_experimental_enable_triton_tma(); bool xla_gpu_experimental_enable_triton_tma() const; void set_xla_gpu_experimental_enable_triton_tma(bool value); private: bool _internal_xla_gpu_experimental_enable_triton_tma() const; void _internal_set_xla_gpu_experimental_enable_triton_tma(bool value); public: // .xla.DebugOptions.PipelineParallelismOptLevel xla_gpu_experimental_pipeline_parallelism_opt_level = 351; void clear_xla_gpu_experimental_pipeline_parallelism_opt_level(); ::xla::DebugOptions_PipelineParallelismOptLevel xla_gpu_experimental_pipeline_parallelism_opt_level() const; void set_xla_gpu_experimental_pipeline_parallelism_opt_level(::xla::DebugOptions_PipelineParallelismOptLevel value); private: ::xla::DebugOptions_PipelineParallelismOptLevel _internal_xla_gpu_experimental_pipeline_parallelism_opt_level() const; void _internal_set_xla_gpu_experimental_pipeline_parallelism_opt_level(::xla::DebugOptions_PipelineParallelismOptLevel value); public: // .xla.DebugOptions.XnnGraphFusionMode xla_cpu_experimental_xnn_graph_fusion_mode = 365; void clear_xla_cpu_experimental_xnn_graph_fusion_mode(); ::xla::DebugOptions_XnnGraphFusionMode xla_cpu_experimental_xnn_graph_fusion_mode() const; void set_xla_cpu_experimental_xnn_graph_fusion_mode(::xla::DebugOptions_XnnGraphFusionMode value); private: ::xla::DebugOptions_XnnGraphFusionMode _internal_xla_cpu_experimental_xnn_graph_fusion_mode() const; void _internal_set_xla_cpu_experimental_xnn_graph_fusion_mode(::xla::DebugOptions_XnnGraphFusionMode value); public: // @@protoc_insertion_point(class_scope:xla.DebugOptions) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField xla_disable_hlo_passes_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField xla_enable_hlo_passes_only_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField xla_gpu_ptx_file_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField xla_gpu_llvm_ir_file_; ::PROTOBUF_NAMESPACE_ID::RepeatedField xla_gpu_enable_command_buffer_; mutable std::atomic _xla_gpu_enable_command_buffer_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField xla_gpu_disable_async_collectives_; mutable std::atomic _xla_gpu_disable_async_collectives_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField legacy_command_buffer_custom_call_targets_; ::PROTOBUF_NAMESPACE_ID::internal::MapField< DebugOptions_XlaGpuAnalyticalLatencyEstimatorOptionsEntry_DoNotUse, std::string, std::string, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> xla_gpu_analytical_latency_estimator_options_; ::PROTOBUF_NAMESPACE_ID::internal::MapField< DebugOptions_XlaBackendExtraOptionsEntry_DoNotUse, std::string, std::string, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> xla_backend_extra_options_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_gpu_cuda_data_dir_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_dump_to_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_dump_hlo_module_re_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_dump_hlo_pass_re_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_gpu_algorithm_denylist_path_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_dump_hlo_pipeline_re_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_gpu_pgle_profile_file_or_directory_path_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_gpu_dump_autotune_results_to_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_gpu_load_autotune_results_from_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_gpu_target_config_filename_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_gpu_enable_custom_fusions_re_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_gpu_dump_autotune_logs_to_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_gpu_override_gemm_autotuner_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_gpu_kernel_cache_file_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_gpu_per_fusion_autotune_cache_dir_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr xla_cpu_max_isa_; int32_t xla_backend_optimization_level_; bool xla_embed_ir_in_executable_; bool xla_eliminate_hlo_implicit_broadcast_; bool xla_cpu_multi_thread_eigen_; bool xla_llvm_enable_alias_scope_metadata_; bool xla_llvm_enable_noalias_metadata_; bool xla_llvm_enable_invariant_load_metadata_; bool xla_llvm_disable_expensive_passes_; bool xla_test_all_output_layouts_; bool xla_test_all_input_layouts_; bool xla_hlo_graph_sharding_color_; bool xla_cpu_use_mkl_dnn_; bool xla_allow_excess_precision_; bool xla_gpu_verify_triton_fusion_numerics_; bool xla_hlo_graph_addresses_; bool xla_hlo_profile_; bool xla_disable_all_hlo_passes_; int32_t xla_force_host_platform_device_count_; int xla_step_marker_location_; bool xla_dump_hlo_as_proto_; bool xla_dump_hlo_as_dot_; bool xla_dump_hlo_as_url_; bool xla_dump_hlo_as_html_; int32_t xla_gpu_autotune_level_; bool xla_cpu_enable_fast_min_max_; bool xla_cpu_fast_math_honor_division_; bool xla_cpu_fast_math_honor_functions_; bool xla_cpu_fast_math_honor_infs_; int32_t xla_dump_max_hlo_modules_; bool xla_dump_fusion_visualization_; bool xla_dump_hlo_snapshots_; bool xla_dump_include_timestamp_; bool xla_dump_module_metadata_; int32_t xla_multiheap_size_constraint_per_heap_; bool xla_gpu_force_conv_nchw_; bool xla_gpu_force_conv_nhwc_; bool xla_gpu_ftz_; bool xla_gpu_fused_attention_use_cudnn_rng_; int32_t xla_gpu_force_compilation_parallelism_; bool xla_gpu_crash_on_verification_failures_; bool xla_gpu_cublas_fallback_; bool xla_gpu_deterministic_ops_; bool xla_gpu_disable_gpuasm_optimizations_; int64_t xla_gpu_all_reduce_combine_threshold_bytes_; bool xla_dump_compress_protos_; bool xla_dump_hlo_as_long_text_; bool xla_dump_enable_mlir_pretty_form_; bool xla_tpu_detect_nan_; int32_t xla_gpu_all_reduce_blueconnect_num_devices_per_host_; int64_t xla_gpu_nccl_termination_timeout_seconds_; int64_t xla_gpu_redzone_scratch_max_megabytes_; int xla_gpu_shape_checks_; bool xla_gpu_enable_custom_fusions_; bool xla_gpu_enable_dynamic_slice_fusion_; bool xla_gpu_enable_fast_min_max_; bool xla_gpu_enable_highest_priority_async_stream_; bool xla_hlo_evaluator_use_fast_path_; bool xla_allow_scalar_index_dynamic_ops_; bool xla_flags_reset_; bool xla_dump_hlo_as_text_; int xla_partitioning_algorithm_; bool xla_gpu_enable_cublaslt_; bool xla_gpu_enable_cudnn_frontend_; bool xla_gpu_enable_cudnn_int8x32_convolution_reordering_; bool xla_gpu_enable_cudnn_layer_norm_; bool xla_tpu_detect_inf_; bool xla_cpu_enable_xprof_traceme_; bool xla_detailed_logging_; bool xla_enable_dumping_; bool xla_llvm_force_inline_before_split_; bool xla_dump_disable_metadata_; bool xla_cpu_use_acl_; bool xla_cpu_strict_dot_conv_math_; int32_t xla_gpu_collective_inflation_factor_; int64_t xla_gpu_all_gather_combine_threshold_bytes_; int64_t xla_gpu_reduce_scatter_combine_threshold_bytes_; int32_t xla_gpu_graph_min_graph_size_; int32_t xla_gpu_auto_spmd_partitioning_memory_budget_gb_; int64_t xla_gpu_redzone_padding_bytes_; float xla_gpu_auto_spmd_partitioning_memory_budget_ratio_; bool xla_gpu_enable_pipelined_all_gather_; bool xla_gpu_enable_pipelined_all_reduce_; bool xla_gpu_enable_pipelined_collectives_; bool xla_gpu_enable_pipelined_p2p_; bool xla_gpu_enable_scatter_determinism_expander_; bool xla_gpu_enable_shared_constants_; bool xla_gpu_enable_split_k_autotuning_; bool xla_gpu_enable_triton_gemm_; bool xla_gpu_enable_pipelined_reduce_scatter_; bool xla_gpu_enable_reassociation_for_converted_ar_; bool xla_gpu_enable_reduce_scatter_combine_by_dim_; bool xla_gpu_enable_reduction_epilogue_fusion_; int64_t xla_gpu_collective_permute_decomposer_threshold_; bool xla_gpu_shard_autotuning_; bool xla_gpu_strict_conv_algorithm_picker_; bool xla_gpu_temp_buffer_use_separate_color_; bool xla_gpu_triton_gemm_any_; bool xla_gpu_enable_triton_hopper_; bool xla_gpu_enable_while_loop_double_buffering_; bool xla_gpu_enable_while_loop_reduce_scatter_code_motion_; bool xla_gpu_ensure_minor_dot_contraction_dims_; int64_t xla_debug_buffer_assignment_show_max_; bool xla_gpu_dump_autotuned_gemm_fusions_; bool xla_gpu_dump_hlo_unoptimized_snapshots_; bool xla_gpu_dump_llvmir_; bool xla_gpu_enable_all_gather_combine_by_dim_; bool xla_gpu_enable_host_memory_offloading_; bool xla_gpu_enable_latency_hiding_scheduler_; bool xla_gpu_enable_libnvptxcompiler_; bool xla_gpu_enable_llvm_module_compilation_parallelism_; int32_t xla_gpu_llvm_verification_level_; bool xla_gpu_triton_gemm_disable_reduced_precision_reduction_; bool xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found_; bool xla_gpu_unsafe_pipelined_loop_annotator_; bool xla_gpu_unsupported_annotate_with_emitter_loc_; int32_t xla_gpu_memory_limit_slop_factor_; bool xla_gpu_enable_nccl_clique_optimization_; bool xla_gpu_enable_nccl_comm_splitting_; bool xla_gpu_enable_nccl_per_stream_comms_; bool xla_gpu_enable_nccl_user_buffers_; int64_t xla_gpu_threshold_for_windowed_einsum_mib_; int64_t xla_gpu_nccl_collective_max_nchannels_; int64_t xla_gpu_nccl_p2p_max_nchannels_; bool xla_dump_latency_hiding_schedule_; bool xla_dump_large_constants_; bool xla_syntax_sugar_async_ops_; bool xla_enable_command_buffers_during_profiling_; bool xla_unsupported_crash_on_hlo_pass_fix_max_iterations_; bool xla_cpu_copy_insertion_use_region_analysis_; bool xla_cpu_enable_concurrency_optimized_scheduler_; bool xla_cpu_enable_fast_math_; int64_t xla_gpu_nccl_init_max_rank_per_root_ratio_; bool xla_cpu_fast_math_honor_nans_; bool xla_cpu_use_thunk_runtime_; bool xla_cpu_use_xnnpack_; bool xla_enable_fast_math_; int32_t xla_gpu_cudnn_gemm_fusion_level_; int64_t xla_gpu_gemm_rewrite_size_threshold_; bool xla_gpu_unsupported_enable_ragged_all_to_all_decomposer_; bool xla_gpu_unsupported_enable_triton_gemm_; bool xla_gpu_use_memcpy_local_p2p_; bool xla_gpu_use_runtime_fusion_; bool xla_gpu_async_dot_; bool xla_gpu_collect_cost_model_stats_; bool xla_gpu_collectives_use_persistent_cliques_; bool xla_gpu_copy_insertion_use_region_analysis_; int64_t xla_gpu_autotune_max_solutions_; bool xla_gpu_generate_debug_info_; bool xla_gpu_generate_line_info_; bool xla_gpu_graph_enable_concurrent_region_; bool xla_gpu_mock_custom_calls_; bool xla_gpu_enable_analytical_latency_estimator_; bool xla_gpu_enable_analytical_sol_latency_estimator_; bool xla_gpu_enable_approx_costly_collectives_; bool xla_gpu_enable_cub_radix_sort_; int64_t xla_reduce_window_rewrite_base_length_; int xla_gpu_enable_while_loop_unrolling_; bool xla_gpu_exclude_nondeterministic_ops_; bool xla_gpu_exhaustive_tiling_search_; bool xla_gpu_experimental_disable_binary_libraries_; bool xla_gpu_experimental_dump_fdo_profiles_; bool xla_gpu_multi_streamed_windowed_einsum_; bool xla_gpu_nccl_terminate_on_error_; bool xla_gpu_require_complete_aot_autotune_results_; bool xla_gpu_require_exclusive_lock_; int32_t xla_cpu_prefer_vector_width_; int64_t xla_cmd_buffer_trace_cache_size_; float xla_gpu_autotune_gemm_rtol_; int32_t xla_gpu_cudnn_gemm_max_plans_; int32_t xla_cpu_parallel_codegen_split_count_; int xla_gpu_experimental_autotune_cache_mode_; bool xla_gpu_experimental_pack_dot_operands_along_k_dimension_; bool xla_gpu_experimental_stream_annotation_; bool xla_gpu_fail_ptx_compilation_on_register_spilling_; bool xla_gpu_filter_kernels_spilling_registers_on_autotuning_; int32_t xla_gpu_executable_warn_stuck_timeout_seconds_; int32_t xla_gpu_executable_terminate_timeout_seconds_; int32_t xla_gpu_dot_merger_threshold_mb_; int32_t xla_gpu_experimental_parallel_collective_overlap_limit_; bool xla_ignore_channel_id_; bool xla_pjrt_allow_auto_layout_in_hlo_; int64_t xla_gpu_operand_bytes_threshold_for_windowed_einsum_; int xla_gpu_pgle_accuracy_checker_; int xla_gpu_libnvjitlink_mode_; bool xla_gpu_experimental_enable_alltoall_windowed_einsum_; bool xla_gpu_experimental_enable_fusion_block_level_rewriter_; bool xla_gpu_experimental_enable_triton_heroless_priority_fusion_; bool xla_gpu_experimental_enable_triton_tma_; int xla_gpu_experimental_pipeline_parallelism_opt_level_; int xla_cpu_experimental_xnn_graph_fusion_mode_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class GpuCompilationEnvironment final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.GpuCompilationEnvironment) */ { public: inline GpuCompilationEnvironment() : GpuCompilationEnvironment(nullptr) {} ~GpuCompilationEnvironment() override; explicit PROTOBUF_CONSTEXPR GpuCompilationEnvironment(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); GpuCompilationEnvironment(const GpuCompilationEnvironment& from); GpuCompilationEnvironment(GpuCompilationEnvironment&& from) noexcept : GpuCompilationEnvironment() { *this = ::std::move(from); } inline GpuCompilationEnvironment& operator=(const GpuCompilationEnvironment& from) { CopyFrom(from); return *this; } inline GpuCompilationEnvironment& operator=(GpuCompilationEnvironment&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const GpuCompilationEnvironment& default_instance() { return *internal_default_instance(); } static inline const GpuCompilationEnvironment* internal_default_instance() { return reinterpret_cast( &_GpuCompilationEnvironment_default_instance_); } static constexpr int kIndexInFileMessages = 4; friend void swap(GpuCompilationEnvironment& a, GpuCompilationEnvironment& b) { a.Swap(&b); } inline void Swap(GpuCompilationEnvironment* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(GpuCompilationEnvironment* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- GpuCompilationEnvironment* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const GpuCompilationEnvironment& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const GpuCompilationEnvironment& from) { GpuCompilationEnvironment::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(GpuCompilationEnvironment* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.GpuCompilationEnvironment"; } protected: explicit GpuCompilationEnvironment(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDummyFlagFieldNumber = 1, }; // int64 dummy_flag = 1; void clear_dummy_flag(); int64_t dummy_flag() const; void set_dummy_flag(int64_t value); private: int64_t _internal_dummy_flag() const; void _internal_set_dummy_flag(int64_t value); public: // @@protoc_insertion_point(class_scope:xla.GpuCompilationEnvironment) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { int64_t dummy_flag_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class ShardableValueUpdatePairProto final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.ShardableValueUpdatePairProto) */ { public: inline ShardableValueUpdatePairProto() : ShardableValueUpdatePairProto(nullptr) {} ~ShardableValueUpdatePairProto() override; explicit PROTOBUF_CONSTEXPR ShardableValueUpdatePairProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ShardableValueUpdatePairProto(const ShardableValueUpdatePairProto& from); ShardableValueUpdatePairProto(ShardableValueUpdatePairProto&& from) noexcept : ShardableValueUpdatePairProto() { *this = ::std::move(from); } inline ShardableValueUpdatePairProto& operator=(const ShardableValueUpdatePairProto& from) { CopyFrom(from); return *this; } inline ShardableValueUpdatePairProto& operator=(ShardableValueUpdatePairProto&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ShardableValueUpdatePairProto& default_instance() { return *internal_default_instance(); } static inline const ShardableValueUpdatePairProto* internal_default_instance() { return reinterpret_cast( &_ShardableValueUpdatePairProto_default_instance_); } static constexpr int kIndexInFileMessages = 5; friend void swap(ShardableValueUpdatePairProto& a, ShardableValueUpdatePairProto& b) { a.Swap(&b); } inline void Swap(ShardableValueUpdatePairProto* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ShardableValueUpdatePairProto* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ShardableValueUpdatePairProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ShardableValueUpdatePairProto& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ShardableValueUpdatePairProto& from) { ShardableValueUpdatePairProto::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ShardableValueUpdatePairProto* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.ShardableValueUpdatePairProto"; } protected: explicit ShardableValueUpdatePairProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kParameterShapeIndexFieldNumber = 2, kOutputShapeIndexFieldNumber = 3, kInputParameterNumberFieldNumber = 1, }; // repeated int64 parameter_shape_index = 2; int parameter_shape_index_size() const; private: int _internal_parameter_shape_index_size() const; public: void clear_parameter_shape_index(); private: int64_t _internal_parameter_shape_index(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& _internal_parameter_shape_index() const; void _internal_add_parameter_shape_index(int64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* _internal_mutable_parameter_shape_index(); public: int64_t parameter_shape_index(int index) const; void set_parameter_shape_index(int index, int64_t value); void add_parameter_shape_index(int64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& parameter_shape_index() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* mutable_parameter_shape_index(); // repeated int64 output_shape_index = 3; int output_shape_index_size() const; private: int _internal_output_shape_index_size() const; public: void clear_output_shape_index(); private: int64_t _internal_output_shape_index(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& _internal_output_shape_index() const; void _internal_add_output_shape_index(int64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* _internal_mutable_output_shape_index(); public: int64_t output_shape_index(int index) const; void set_output_shape_index(int index, int64_t value); void add_output_shape_index(int64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& output_shape_index() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* mutable_output_shape_index(); // int64 input_parameter_number = 1; void clear_input_parameter_number(); int64_t input_parameter_number() const; void set_input_parameter_number(int64_t value); private: int64_t _internal_input_parameter_number() const; void _internal_set_input_parameter_number(int64_t value); public: // @@protoc_insertion_point(class_scope:xla.ShardableValueUpdatePairProto) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > parameter_shape_index_; mutable std::atomic _parameter_shape_index_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > output_shape_index_; mutable std::atomic _output_shape_index_cached_byte_size_; int64_t input_parameter_number_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class ExecutionOptions final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.ExecutionOptions) */ { public: inline ExecutionOptions() : ExecutionOptions(nullptr) {} ~ExecutionOptions() override; explicit PROTOBUF_CONSTEXPR ExecutionOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ExecutionOptions(const ExecutionOptions& from); ExecutionOptions(ExecutionOptions&& from) noexcept : ExecutionOptions() { *this = ::std::move(from); } inline ExecutionOptions& operator=(const ExecutionOptions& from) { CopyFrom(from); return *this; } inline ExecutionOptions& operator=(ExecutionOptions&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ExecutionOptions& default_instance() { return *internal_default_instance(); } static inline const ExecutionOptions* internal_default_instance() { return reinterpret_cast( &_ExecutionOptions_default_instance_); } static constexpr int kIndexInFileMessages = 6; friend void swap(ExecutionOptions& a, ExecutionOptions& b) { a.Swap(&b); } inline void Swap(ExecutionOptions* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ExecutionOptions* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ExecutionOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ExecutionOptions& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ExecutionOptions& from) { ExecutionOptions::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ExecutionOptions* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.ExecutionOptions"; } protected: explicit ExecutionOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kDeviceHandlesFieldNumber = 5, kAllowSpmdShardingPropagationToOutputFieldNumber = 14, kAutoSpmdPartitioningMeshShapeFieldNumber = 16, kAutoSpmdPartitioningMeshIdsFieldNumber = 17, kParamRequiresBroadcastViaCollectivesFieldNumber = 18, kShardableValueUpdatePairsFieldNumber = 20, kAllowSpmdShardingPropagationToParametersFieldNumber = 23, kFdoProfileFieldNumber = 21, kShapeWithOutputLayoutFieldNumber = 2, kDebugOptionsFieldNumber = 4, kDeviceAssignmentFieldNumber = 7, kSeedFieldNumber = 3, kNumReplicasFieldNumber = 6, kNumPartitionsFieldNumber = 9, kLaunchIdFieldNumber = 10, kAliasPassthroughParamsFieldNumber = 8, kUseSpmdPartitioningFieldNumber = 11, kUseAutoSpmdPartitioningFieldNumber = 15, kDeduplicateHloFieldNumber = 12, kDeviceMemorySizeFieldNumber = 22, kAllowSeparateShardingProgramsFieldNumber = 19, kUseShardyPartitionerFieldNumber = 24, kExecTimeOptimizationEffortFieldNumber = 25, kMemoryFittingEffortFieldNumber = 26, }; // repeated .xla.DeviceHandle device_handles = 5; int device_handles_size() const; private: int _internal_device_handles_size() const; public: void clear_device_handles(); ::xla::DeviceHandle* mutable_device_handles(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceHandle >* mutable_device_handles(); private: const ::xla::DeviceHandle& _internal_device_handles(int index) const; ::xla::DeviceHandle* _internal_add_device_handles(); public: const ::xla::DeviceHandle& device_handles(int index) const; ::xla::DeviceHandle* add_device_handles(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceHandle >& device_handles() const; // repeated bool allow_spmd_sharding_propagation_to_output = 14; int allow_spmd_sharding_propagation_to_output_size() const; private: int _internal_allow_spmd_sharding_propagation_to_output_size() const; public: void clear_allow_spmd_sharding_propagation_to_output(); private: bool _internal_allow_spmd_sharding_propagation_to_output(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& _internal_allow_spmd_sharding_propagation_to_output() const; void _internal_add_allow_spmd_sharding_propagation_to_output(bool value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* _internal_mutable_allow_spmd_sharding_propagation_to_output(); public: bool allow_spmd_sharding_propagation_to_output(int index) const; void set_allow_spmd_sharding_propagation_to_output(int index, bool value); void add_allow_spmd_sharding_propagation_to_output(bool value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& allow_spmd_sharding_propagation_to_output() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* mutable_allow_spmd_sharding_propagation_to_output(); // repeated int64 auto_spmd_partitioning_mesh_shape = 16; int auto_spmd_partitioning_mesh_shape_size() const; private: int _internal_auto_spmd_partitioning_mesh_shape_size() const; public: void clear_auto_spmd_partitioning_mesh_shape(); private: int64_t _internal_auto_spmd_partitioning_mesh_shape(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& _internal_auto_spmd_partitioning_mesh_shape() const; void _internal_add_auto_spmd_partitioning_mesh_shape(int64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* _internal_mutable_auto_spmd_partitioning_mesh_shape(); public: int64_t auto_spmd_partitioning_mesh_shape(int index) const; void set_auto_spmd_partitioning_mesh_shape(int index, int64_t value); void add_auto_spmd_partitioning_mesh_shape(int64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& auto_spmd_partitioning_mesh_shape() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* mutable_auto_spmd_partitioning_mesh_shape(); // repeated int64 auto_spmd_partitioning_mesh_ids = 17; int auto_spmd_partitioning_mesh_ids_size() const; private: int _internal_auto_spmd_partitioning_mesh_ids_size() const; public: void clear_auto_spmd_partitioning_mesh_ids(); private: int64_t _internal_auto_spmd_partitioning_mesh_ids(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& _internal_auto_spmd_partitioning_mesh_ids() const; void _internal_add_auto_spmd_partitioning_mesh_ids(int64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* _internal_mutable_auto_spmd_partitioning_mesh_ids(); public: int64_t auto_spmd_partitioning_mesh_ids(int index) const; void set_auto_spmd_partitioning_mesh_ids(int index, int64_t value); void add_auto_spmd_partitioning_mesh_ids(int64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& auto_spmd_partitioning_mesh_ids() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* mutable_auto_spmd_partitioning_mesh_ids(); // repeated bool param_requires_broadcast_via_collectives = 18; int param_requires_broadcast_via_collectives_size() const; private: int _internal_param_requires_broadcast_via_collectives_size() const; public: void clear_param_requires_broadcast_via_collectives(); private: bool _internal_param_requires_broadcast_via_collectives(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& _internal_param_requires_broadcast_via_collectives() const; void _internal_add_param_requires_broadcast_via_collectives(bool value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* _internal_mutable_param_requires_broadcast_via_collectives(); public: bool param_requires_broadcast_via_collectives(int index) const; void set_param_requires_broadcast_via_collectives(int index, bool value); void add_param_requires_broadcast_via_collectives(bool value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& param_requires_broadcast_via_collectives() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* mutable_param_requires_broadcast_via_collectives(); // repeated .xla.ShardableValueUpdatePairProto shardable_value_update_pairs = 20; int shardable_value_update_pairs_size() const; private: int _internal_shardable_value_update_pairs_size() const; public: void clear_shardable_value_update_pairs(); ::xla::ShardableValueUpdatePairProto* mutable_shardable_value_update_pairs(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShardableValueUpdatePairProto >* mutable_shardable_value_update_pairs(); private: const ::xla::ShardableValueUpdatePairProto& _internal_shardable_value_update_pairs(int index) const; ::xla::ShardableValueUpdatePairProto* _internal_add_shardable_value_update_pairs(); public: const ::xla::ShardableValueUpdatePairProto& shardable_value_update_pairs(int index) const; ::xla::ShardableValueUpdatePairProto* add_shardable_value_update_pairs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShardableValueUpdatePairProto >& shardable_value_update_pairs() const; // repeated bool allow_spmd_sharding_propagation_to_parameters = 23; int allow_spmd_sharding_propagation_to_parameters_size() const; private: int _internal_allow_spmd_sharding_propagation_to_parameters_size() const; public: void clear_allow_spmd_sharding_propagation_to_parameters(); private: bool _internal_allow_spmd_sharding_propagation_to_parameters(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& _internal_allow_spmd_sharding_propagation_to_parameters() const; void _internal_add_allow_spmd_sharding_propagation_to_parameters(bool value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* _internal_mutable_allow_spmd_sharding_propagation_to_parameters(); public: bool allow_spmd_sharding_propagation_to_parameters(int index) const; void set_allow_spmd_sharding_propagation_to_parameters(int index, bool value); void add_allow_spmd_sharding_propagation_to_parameters(bool value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& allow_spmd_sharding_propagation_to_parameters() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* mutable_allow_spmd_sharding_propagation_to_parameters(); // bytes fdo_profile = 21; void clear_fdo_profile(); const std::string& fdo_profile() const; template void set_fdo_profile(ArgT0&& arg0, ArgT... args); std::string* mutable_fdo_profile(); PROTOBUF_NODISCARD std::string* release_fdo_profile(); void set_allocated_fdo_profile(std::string* fdo_profile); private: const std::string& _internal_fdo_profile() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_fdo_profile(const std::string& value); std::string* _internal_mutable_fdo_profile(); public: // .xla.ShapeProto shape_with_output_layout = 2; bool has_shape_with_output_layout() const; private: bool _internal_has_shape_with_output_layout() const; public: void clear_shape_with_output_layout(); const ::xla::ShapeProto& shape_with_output_layout() const; PROTOBUF_NODISCARD ::xla::ShapeProto* release_shape_with_output_layout(); ::xla::ShapeProto* mutable_shape_with_output_layout(); void set_allocated_shape_with_output_layout(::xla::ShapeProto* shape_with_output_layout); private: const ::xla::ShapeProto& _internal_shape_with_output_layout() const; ::xla::ShapeProto* _internal_mutable_shape_with_output_layout(); public: void unsafe_arena_set_allocated_shape_with_output_layout( ::xla::ShapeProto* shape_with_output_layout); ::xla::ShapeProto* unsafe_arena_release_shape_with_output_layout(); // .xla.DebugOptions debug_options = 4; bool has_debug_options() const; private: bool _internal_has_debug_options() const; public: void clear_debug_options(); const ::xla::DebugOptions& debug_options() const; PROTOBUF_NODISCARD ::xla::DebugOptions* release_debug_options(); ::xla::DebugOptions* mutable_debug_options(); void set_allocated_debug_options(::xla::DebugOptions* debug_options); private: const ::xla::DebugOptions& _internal_debug_options() const; ::xla::DebugOptions* _internal_mutable_debug_options(); public: void unsafe_arena_set_allocated_debug_options( ::xla::DebugOptions* debug_options); ::xla::DebugOptions* unsafe_arena_release_debug_options(); // .xla.DeviceAssignmentProto device_assignment = 7; bool has_device_assignment() const; private: bool _internal_has_device_assignment() const; public: void clear_device_assignment(); const ::xla::DeviceAssignmentProto& device_assignment() const; PROTOBUF_NODISCARD ::xla::DeviceAssignmentProto* release_device_assignment(); ::xla::DeviceAssignmentProto* mutable_device_assignment(); void set_allocated_device_assignment(::xla::DeviceAssignmentProto* device_assignment); private: const ::xla::DeviceAssignmentProto& _internal_device_assignment() const; ::xla::DeviceAssignmentProto* _internal_mutable_device_assignment(); public: void unsafe_arena_set_allocated_device_assignment( ::xla::DeviceAssignmentProto* device_assignment); ::xla::DeviceAssignmentProto* unsafe_arena_release_device_assignment(); // uint64 seed = 3; void clear_seed(); uint64_t seed() const; void set_seed(uint64_t value); private: uint64_t _internal_seed() const; void _internal_set_seed(uint64_t value); public: // int32 num_replicas = 6; void clear_num_replicas(); int32_t num_replicas() const; void set_num_replicas(int32_t value); private: int32_t _internal_num_replicas() const; void _internal_set_num_replicas(int32_t value); public: // int32 num_partitions = 9; void clear_num_partitions(); int32_t num_partitions() const; void set_num_partitions(int32_t value); private: int32_t _internal_num_partitions() const; void _internal_set_num_partitions(int32_t value); public: // int32 launch_id = 10; void clear_launch_id(); int32_t launch_id() const; void set_launch_id(int32_t value); private: int32_t _internal_launch_id() const; void _internal_set_launch_id(int32_t value); public: // bool alias_passthrough_params = 8; void clear_alias_passthrough_params(); bool alias_passthrough_params() const; void set_alias_passthrough_params(bool value); private: bool _internal_alias_passthrough_params() const; void _internal_set_alias_passthrough_params(bool value); public: // bool use_spmd_partitioning = 11; void clear_use_spmd_partitioning(); bool use_spmd_partitioning() const; void set_use_spmd_partitioning(bool value); private: bool _internal_use_spmd_partitioning() const; void _internal_set_use_spmd_partitioning(bool value); public: // bool use_auto_spmd_partitioning = 15; void clear_use_auto_spmd_partitioning(); bool use_auto_spmd_partitioning() const; void set_use_auto_spmd_partitioning(bool value); private: bool _internal_use_auto_spmd_partitioning() const; void _internal_set_use_auto_spmd_partitioning(bool value); public: // bool deduplicate_hlo = 12; void clear_deduplicate_hlo(); bool deduplicate_hlo() const; void set_deduplicate_hlo(bool value); private: bool _internal_deduplicate_hlo() const; void _internal_set_deduplicate_hlo(bool value); public: // int64 device_memory_size = 22; void clear_device_memory_size(); int64_t device_memory_size() const; void set_device_memory_size(int64_t value); private: int64_t _internal_device_memory_size() const; void _internal_set_device_memory_size(int64_t value); public: // bool allow_separate_sharding_programs = 19; void clear_allow_separate_sharding_programs(); bool allow_separate_sharding_programs() const; void set_allow_separate_sharding_programs(bool value); private: bool _internal_allow_separate_sharding_programs() const; void _internal_set_allow_separate_sharding_programs(bool value); public: // bool use_shardy_partitioner = 24; void clear_use_shardy_partitioner(); bool use_shardy_partitioner() const; void set_use_shardy_partitioner(bool value); private: bool _internal_use_shardy_partitioner() const; void _internal_set_use_shardy_partitioner(bool value); public: // float exec_time_optimization_effort = 25; void clear_exec_time_optimization_effort(); float exec_time_optimization_effort() const; void set_exec_time_optimization_effort(float value); private: float _internal_exec_time_optimization_effort() const; void _internal_set_exec_time_optimization_effort(float value); public: // float memory_fitting_effort = 26; void clear_memory_fitting_effort(); float memory_fitting_effort() const; void set_memory_fitting_effort(float value); private: float _internal_memory_fitting_effort() const; void _internal_set_memory_fitting_effort(float value); public: // @@protoc_insertion_point(class_scope:xla.ExecutionOptions) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceHandle > device_handles_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > allow_spmd_sharding_propagation_to_output_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > auto_spmd_partitioning_mesh_shape_; mutable std::atomic _auto_spmd_partitioning_mesh_shape_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > auto_spmd_partitioning_mesh_ids_; mutable std::atomic _auto_spmd_partitioning_mesh_ids_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > param_requires_broadcast_via_collectives_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShardableValueUpdatePairProto > shardable_value_update_pairs_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > allow_spmd_sharding_propagation_to_parameters_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fdo_profile_; ::xla::ShapeProto* shape_with_output_layout_; ::xla::DebugOptions* debug_options_; ::xla::DeviceAssignmentProto* device_assignment_; uint64_t seed_; int32_t num_replicas_; int32_t num_partitions_; int32_t launch_id_; bool alias_passthrough_params_; bool use_spmd_partitioning_; bool use_auto_spmd_partitioning_; bool deduplicate_hlo_; int64_t device_memory_size_; bool allow_separate_sharding_programs_; bool use_shardy_partitioner_; float exec_time_optimization_effort_; float memory_fitting_effort_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class HloModuleConfigProto_BoolList final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.HloModuleConfigProto.BoolList) */ { public: inline HloModuleConfigProto_BoolList() : HloModuleConfigProto_BoolList(nullptr) {} ~HloModuleConfigProto_BoolList() override; explicit PROTOBUF_CONSTEXPR HloModuleConfigProto_BoolList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); HloModuleConfigProto_BoolList(const HloModuleConfigProto_BoolList& from); HloModuleConfigProto_BoolList(HloModuleConfigProto_BoolList&& from) noexcept : HloModuleConfigProto_BoolList() { *this = ::std::move(from); } inline HloModuleConfigProto_BoolList& operator=(const HloModuleConfigProto_BoolList& from) { CopyFrom(from); return *this; } inline HloModuleConfigProto_BoolList& operator=(HloModuleConfigProto_BoolList&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HloModuleConfigProto_BoolList& default_instance() { return *internal_default_instance(); } static inline const HloModuleConfigProto_BoolList* internal_default_instance() { return reinterpret_cast( &_HloModuleConfigProto_BoolList_default_instance_); } static constexpr int kIndexInFileMessages = 7; friend void swap(HloModuleConfigProto_BoolList& a, HloModuleConfigProto_BoolList& b) { a.Swap(&b); } inline void Swap(HloModuleConfigProto_BoolList* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HloModuleConfigProto_BoolList* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HloModuleConfigProto_BoolList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const HloModuleConfigProto_BoolList& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const HloModuleConfigProto_BoolList& from) { HloModuleConfigProto_BoolList::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(HloModuleConfigProto_BoolList* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.HloModuleConfigProto.BoolList"; } protected: explicit HloModuleConfigProto_BoolList(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kValsFieldNumber = 1, }; // repeated bool vals = 1; int vals_size() const; private: int _internal_vals_size() const; public: void clear_vals(); private: bool _internal_vals(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& _internal_vals() const; void _internal_add_vals(bool value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* _internal_mutable_vals(); public: bool vals(int index) const; void set_vals(int index, bool value); void add_vals(bool value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& vals() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* mutable_vals(); // @@protoc_insertion_point(class_scope:xla.HloModuleConfigProto.BoolList) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > vals_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class HloModuleConfigProto_Int64List final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.HloModuleConfigProto.Int64List) */ { public: inline HloModuleConfigProto_Int64List() : HloModuleConfigProto_Int64List(nullptr) {} ~HloModuleConfigProto_Int64List() override; explicit PROTOBUF_CONSTEXPR HloModuleConfigProto_Int64List(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); HloModuleConfigProto_Int64List(const HloModuleConfigProto_Int64List& from); HloModuleConfigProto_Int64List(HloModuleConfigProto_Int64List&& from) noexcept : HloModuleConfigProto_Int64List() { *this = ::std::move(from); } inline HloModuleConfigProto_Int64List& operator=(const HloModuleConfigProto_Int64List& from) { CopyFrom(from); return *this; } inline HloModuleConfigProto_Int64List& operator=(HloModuleConfigProto_Int64List&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HloModuleConfigProto_Int64List& default_instance() { return *internal_default_instance(); } static inline const HloModuleConfigProto_Int64List* internal_default_instance() { return reinterpret_cast( &_HloModuleConfigProto_Int64List_default_instance_); } static constexpr int kIndexInFileMessages = 8; friend void swap(HloModuleConfigProto_Int64List& a, HloModuleConfigProto_Int64List& b) { a.Swap(&b); } inline void Swap(HloModuleConfigProto_Int64List* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HloModuleConfigProto_Int64List* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HloModuleConfigProto_Int64List* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const HloModuleConfigProto_Int64List& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const HloModuleConfigProto_Int64List& from) { HloModuleConfigProto_Int64List::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(HloModuleConfigProto_Int64List* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.HloModuleConfigProto.Int64List"; } protected: explicit HloModuleConfigProto_Int64List(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kValsFieldNumber = 1, }; // repeated int64 vals = 1; int vals_size() const; private: int _internal_vals_size() const; public: void clear_vals(); private: int64_t _internal_vals(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& _internal_vals() const; void _internal_add_vals(int64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* _internal_mutable_vals(); public: int64_t vals(int index) const; void set_vals(int index, int64_t value); void add_vals(int64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& vals() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* mutable_vals(); // @@protoc_insertion_point(class_scope:xla.HloModuleConfigProto.Int64List) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > vals_; mutable std::atomic _vals_cached_byte_size_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class HloModuleConfigProto_Int64ListList final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.HloModuleConfigProto.Int64ListList) */ { public: inline HloModuleConfigProto_Int64ListList() : HloModuleConfigProto_Int64ListList(nullptr) {} ~HloModuleConfigProto_Int64ListList() override; explicit PROTOBUF_CONSTEXPR HloModuleConfigProto_Int64ListList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); HloModuleConfigProto_Int64ListList(const HloModuleConfigProto_Int64ListList& from); HloModuleConfigProto_Int64ListList(HloModuleConfigProto_Int64ListList&& from) noexcept : HloModuleConfigProto_Int64ListList() { *this = ::std::move(from); } inline HloModuleConfigProto_Int64ListList& operator=(const HloModuleConfigProto_Int64ListList& from) { CopyFrom(from); return *this; } inline HloModuleConfigProto_Int64ListList& operator=(HloModuleConfigProto_Int64ListList&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HloModuleConfigProto_Int64ListList& default_instance() { return *internal_default_instance(); } static inline const HloModuleConfigProto_Int64ListList* internal_default_instance() { return reinterpret_cast( &_HloModuleConfigProto_Int64ListList_default_instance_); } static constexpr int kIndexInFileMessages = 9; friend void swap(HloModuleConfigProto_Int64ListList& a, HloModuleConfigProto_Int64ListList& b) { a.Swap(&b); } inline void Swap(HloModuleConfigProto_Int64ListList* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HloModuleConfigProto_Int64ListList* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HloModuleConfigProto_Int64ListList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const HloModuleConfigProto_Int64ListList& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const HloModuleConfigProto_Int64ListList& from) { HloModuleConfigProto_Int64ListList::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(HloModuleConfigProto_Int64ListList* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.HloModuleConfigProto.Int64ListList"; } protected: explicit HloModuleConfigProto_Int64ListList(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kListsFieldNumber = 1, }; // repeated .xla.HloModuleConfigProto.Int64List lists = 1; int lists_size() const; private: int _internal_lists_size() const; public: void clear_lists(); ::xla::HloModuleConfigProto_Int64List* mutable_lists(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_Int64List >* mutable_lists(); private: const ::xla::HloModuleConfigProto_Int64List& _internal_lists(int index) const; ::xla::HloModuleConfigProto_Int64List* _internal_add_lists(); public: const ::xla::HloModuleConfigProto_Int64List& lists(int index) const; ::xla::HloModuleConfigProto_Int64List* add_lists(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_Int64List >& lists() const; // @@protoc_insertion_point(class_scope:xla.HloModuleConfigProto.Int64ListList) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_Int64List > lists_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class HloModuleConfigProto_DotConfigEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { public: typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; HloModuleConfigProto_DotConfigEntry_DoNotUse(); explicit PROTOBUF_CONSTEXPR HloModuleConfigProto_DotConfigEntry_DoNotUse( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); explicit HloModuleConfigProto_DotConfigEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); void MergeFrom(const HloModuleConfigProto_DotConfigEntry_DoNotUse& other); static const HloModuleConfigProto_DotConfigEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_HloModuleConfigProto_DotConfigEntry_DoNotUse_default_instance_); } static bool ValidateKey(std::string* s) { return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "xla.HloModuleConfigProto.DotConfigEntry.key"); } static bool ValidateValue(void*) { return true; } using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntry { public: typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntry SuperType; HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse(); explicit PROTOBUF_CONSTEXPR HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse( ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); explicit HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena); void MergeFrom(const HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse& other); static const HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse* internal_default_instance() { return reinterpret_cast(&_HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse_default_instance_); } static bool ValidateKey(std::string* s) { return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "xla.HloModuleConfigProto.AnalysisAllowanceMapEntry.key"); } static bool ValidateValue(void*) { return true; } using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class HloModuleConfigProto final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.HloModuleConfigProto) */ { public: inline HloModuleConfigProto() : HloModuleConfigProto(nullptr) {} ~HloModuleConfigProto() override; explicit PROTOBUF_CONSTEXPR HloModuleConfigProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); HloModuleConfigProto(const HloModuleConfigProto& from); HloModuleConfigProto(HloModuleConfigProto&& from) noexcept : HloModuleConfigProto() { *this = ::std::move(from); } inline HloModuleConfigProto& operator=(const HloModuleConfigProto& from) { CopyFrom(from); return *this; } inline HloModuleConfigProto& operator=(HloModuleConfigProto&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HloModuleConfigProto& default_instance() { return *internal_default_instance(); } static inline const HloModuleConfigProto* internal_default_instance() { return reinterpret_cast( &_HloModuleConfigProto_default_instance_); } static constexpr int kIndexInFileMessages = 12; friend void swap(HloModuleConfigProto& a, HloModuleConfigProto& b) { a.Swap(&b); } inline void Swap(HloModuleConfigProto* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HloModuleConfigProto* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HloModuleConfigProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const HloModuleConfigProto& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const HloModuleConfigProto& from) { HloModuleConfigProto::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(HloModuleConfigProto* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.HloModuleConfigProto"; } protected: explicit HloModuleConfigProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); private: static void ArenaDtor(void* object); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- typedef HloModuleConfigProto_BoolList BoolList; typedef HloModuleConfigProto_Int64List Int64List; typedef HloModuleConfigProto_Int64ListList Int64ListList; typedef HloModuleConfigProto_FusionConfigCollection FusionConfigCollection; static constexpr FusionConfigCollection OFF = HloModuleConfigProto_FusionConfigCollection_OFF; static constexpr FusionConfigCollection PER_EDGE = HloModuleConfigProto_FusionConfigCollection_PER_EDGE; static constexpr FusionConfigCollection PER_NODE = HloModuleConfigProto_FusionConfigCollection_PER_NODE; static inline bool FusionConfigCollection_IsValid(int value) { return HloModuleConfigProto_FusionConfigCollection_IsValid(value); } static constexpr FusionConfigCollection FusionConfigCollection_MIN = HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_MIN; static constexpr FusionConfigCollection FusionConfigCollection_MAX = HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_MAX; static constexpr int FusionConfigCollection_ARRAYSIZE = HloModuleConfigProto_FusionConfigCollection_FusionConfigCollection_ARRAYSIZE; static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* FusionConfigCollection_descriptor() { return HloModuleConfigProto_FusionConfigCollection_descriptor(); } template static inline const std::string& FusionConfigCollection_Name(T enum_t_value) { static_assert(::std::is_same::value || ::std::is_integral::value, "Incorrect type passed to function FusionConfigCollection_Name."); return HloModuleConfigProto_FusionConfigCollection_Name(enum_t_value); } static inline bool FusionConfigCollection_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name, FusionConfigCollection* value) { return HloModuleConfigProto_FusionConfigCollection_Parse(name, value); } // accessors ------------------------------------------------------- enum : int { kParamRequiresBroadcastViaCollectivesFieldNumber = 6, kAutoSpmdPartitioningMeshShapeFieldNumber = 9, kAutoSpmdPartitioningMeshIdsFieldNumber = 10, kShardableValueUpdatePairsFieldNumber = 16, kFusionConfigFieldNumber = 20, kDotConfigFieldNumber = 21, kLayoutConfigFieldNumber = 22, kMemorySpaceAssignmentConfigFieldNumber = 23, kPhaseOrderingConfigFieldNumber = 24, kAllowSpmdShardingPropagationToOutputFieldNumber = 27, kAnalysisAllowanceMapFieldNumber = 28, kAllowSpmdShardingPropagationToParametersFieldNumber = 33, kDeviceTypeFieldNumber = 13, kFdoProfileFieldNumber = 31, kEntryComputationLayoutFieldNumber = 1, kDebugOptionsFieldNumber = 14, kStaticDeviceAssignmentFieldNumber = 15, kPreSimulationDeviceAssignmentFieldNumber = 35, kShardingConfigFieldNumber = 38, kSeedFieldNumber = 2, kReplicaCountFieldNumber = 4, kNumPartitionsFieldNumber = 5, kLaunchIdFieldNumber = 3, kUseSpmdPartitioningFieldNumber = 7, kUseAutoSpmdPartitioningFieldNumber = 8, kDeduplicateHloFieldNumber = 11, kAllowSeparateShardingProgramsFieldNumber = 30, kIntraOpParallelismThreadsFieldNumber = 12, kFusionConfigCollectionFieldNumber = 19, kAliasPassthroughParamsFieldNumber = 17, kContentAwareComputationSortingFieldNumber = 18, kUseShardyPartitionerFieldNumber = 34, kPhaseIndexFieldNumber = 25, kMatrixUnitOperandPrecisionFieldNumber = 29, kDeviceMemorySizeFieldNumber = 32, kExecTimeOptimizationEffortFieldNumber = 36, kMemoryFittingEffortFieldNumber = 37, }; // repeated bool param_requires_broadcast_via_collectives = 6; int param_requires_broadcast_via_collectives_size() const; private: int _internal_param_requires_broadcast_via_collectives_size() const; public: void clear_param_requires_broadcast_via_collectives(); private: bool _internal_param_requires_broadcast_via_collectives(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& _internal_param_requires_broadcast_via_collectives() const; void _internal_add_param_requires_broadcast_via_collectives(bool value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* _internal_mutable_param_requires_broadcast_via_collectives(); public: bool param_requires_broadcast_via_collectives(int index) const; void set_param_requires_broadcast_via_collectives(int index, bool value); void add_param_requires_broadcast_via_collectives(bool value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& param_requires_broadcast_via_collectives() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* mutable_param_requires_broadcast_via_collectives(); // repeated int64 auto_spmd_partitioning_mesh_shape = 9; int auto_spmd_partitioning_mesh_shape_size() const; private: int _internal_auto_spmd_partitioning_mesh_shape_size() const; public: void clear_auto_spmd_partitioning_mesh_shape(); private: int64_t _internal_auto_spmd_partitioning_mesh_shape(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& _internal_auto_spmd_partitioning_mesh_shape() const; void _internal_add_auto_spmd_partitioning_mesh_shape(int64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* _internal_mutable_auto_spmd_partitioning_mesh_shape(); public: int64_t auto_spmd_partitioning_mesh_shape(int index) const; void set_auto_spmd_partitioning_mesh_shape(int index, int64_t value); void add_auto_spmd_partitioning_mesh_shape(int64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& auto_spmd_partitioning_mesh_shape() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* mutable_auto_spmd_partitioning_mesh_shape(); // repeated int64 auto_spmd_partitioning_mesh_ids = 10; int auto_spmd_partitioning_mesh_ids_size() const; private: int _internal_auto_spmd_partitioning_mesh_ids_size() const; public: void clear_auto_spmd_partitioning_mesh_ids(); private: int64_t _internal_auto_spmd_partitioning_mesh_ids(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& _internal_auto_spmd_partitioning_mesh_ids() const; void _internal_add_auto_spmd_partitioning_mesh_ids(int64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* _internal_mutable_auto_spmd_partitioning_mesh_ids(); public: int64_t auto_spmd_partitioning_mesh_ids(int index) const; void set_auto_spmd_partitioning_mesh_ids(int index, int64_t value); void add_auto_spmd_partitioning_mesh_ids(int64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& auto_spmd_partitioning_mesh_ids() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* mutable_auto_spmd_partitioning_mesh_ids(); // repeated .xla.ShardableValueUpdatePairProto shardable_value_update_pairs = 16; int shardable_value_update_pairs_size() const; private: int _internal_shardable_value_update_pairs_size() const; public: void clear_shardable_value_update_pairs(); ::xla::ShardableValueUpdatePairProto* mutable_shardable_value_update_pairs(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShardableValueUpdatePairProto >* mutable_shardable_value_update_pairs(); private: const ::xla::ShardableValueUpdatePairProto& _internal_shardable_value_update_pairs(int index) const; ::xla::ShardableValueUpdatePairProto* _internal_add_shardable_value_update_pairs(); public: const ::xla::ShardableValueUpdatePairProto& shardable_value_update_pairs(int index) const; ::xla::ShardableValueUpdatePairProto* add_shardable_value_update_pairs(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShardableValueUpdatePairProto >& shardable_value_update_pairs() const; // repeated .xla.HloModuleConfigProto.BoolList fusion_config = 20; int fusion_config_size() const; private: int _internal_fusion_config_size() const; public: void clear_fusion_config(); ::xla::HloModuleConfigProto_BoolList* mutable_fusion_config(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_BoolList >* mutable_fusion_config(); private: const ::xla::HloModuleConfigProto_BoolList& _internal_fusion_config(int index) const; ::xla::HloModuleConfigProto_BoolList* _internal_add_fusion_config(); public: const ::xla::HloModuleConfigProto_BoolList& fusion_config(int index) const; ::xla::HloModuleConfigProto_BoolList* add_fusion_config(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_BoolList >& fusion_config() const; // map dot_config = 21; int dot_config_size() const; private: int _internal_dot_config_size() const; public: void clear_dot_config(); private: const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::HloModuleConfigProto_Int64List >& _internal_dot_config() const; ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::HloModuleConfigProto_Int64List >* _internal_mutable_dot_config(); public: const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::HloModuleConfigProto_Int64List >& dot_config() const; ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::HloModuleConfigProto_Int64List >* mutable_dot_config(); // repeated .xla.HloModuleConfigProto.Int64ListList layout_config = 22; int layout_config_size() const; private: int _internal_layout_config_size() const; public: void clear_layout_config(); ::xla::HloModuleConfigProto_Int64ListList* mutable_layout_config(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_Int64ListList >* mutable_layout_config(); private: const ::xla::HloModuleConfigProto_Int64ListList& _internal_layout_config(int index) const; ::xla::HloModuleConfigProto_Int64ListList* _internal_add_layout_config(); public: const ::xla::HloModuleConfigProto_Int64ListList& layout_config(int index) const; ::xla::HloModuleConfigProto_Int64ListList* add_layout_config(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_Int64ListList >& layout_config() const; // repeated uint64 memory_space_assignment_config = 23; int memory_space_assignment_config_size() const; private: int _internal_memory_space_assignment_config_size() const; public: void clear_memory_space_assignment_config(); private: uint64_t _internal_memory_space_assignment_config(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& _internal_memory_space_assignment_config() const; void _internal_add_memory_space_assignment_config(uint64_t value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* _internal_mutable_memory_space_assignment_config(); public: uint64_t memory_space_assignment_config(int index) const; void set_memory_space_assignment_config(int index, uint64_t value); void add_memory_space_assignment_config(uint64_t value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& memory_space_assignment_config() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* mutable_memory_space_assignment_config(); // repeated .xla.HloModuleConfigProto.BoolList phase_ordering_config = 24; int phase_ordering_config_size() const; private: int _internal_phase_ordering_config_size() const; public: void clear_phase_ordering_config(); ::xla::HloModuleConfigProto_BoolList* mutable_phase_ordering_config(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_BoolList >* mutable_phase_ordering_config(); private: const ::xla::HloModuleConfigProto_BoolList& _internal_phase_ordering_config(int index) const; ::xla::HloModuleConfigProto_BoolList* _internal_add_phase_ordering_config(); public: const ::xla::HloModuleConfigProto_BoolList& phase_ordering_config(int index) const; ::xla::HloModuleConfigProto_BoolList* add_phase_ordering_config(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_BoolList >& phase_ordering_config() const; // repeated bool allow_spmd_sharding_propagation_to_output = 27; int allow_spmd_sharding_propagation_to_output_size() const; private: int _internal_allow_spmd_sharding_propagation_to_output_size() const; public: void clear_allow_spmd_sharding_propagation_to_output(); private: bool _internal_allow_spmd_sharding_propagation_to_output(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& _internal_allow_spmd_sharding_propagation_to_output() const; void _internal_add_allow_spmd_sharding_propagation_to_output(bool value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* _internal_mutable_allow_spmd_sharding_propagation_to_output(); public: bool allow_spmd_sharding_propagation_to_output(int index) const; void set_allow_spmd_sharding_propagation_to_output(int index, bool value); void add_allow_spmd_sharding_propagation_to_output(bool value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& allow_spmd_sharding_propagation_to_output() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* mutable_allow_spmd_sharding_propagation_to_output(); // map analysis_allowance_map = 28; int analysis_allowance_map_size() const; private: int _internal_analysis_allowance_map_size() const; public: void clear_analysis_allowance_map(); private: const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >& _internal_analysis_allowance_map() const; ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >* _internal_mutable_analysis_allowance_map(); public: const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >& analysis_allowance_map() const; ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >* mutable_analysis_allowance_map(); // repeated bool allow_spmd_sharding_propagation_to_parameters = 33; int allow_spmd_sharding_propagation_to_parameters_size() const; private: int _internal_allow_spmd_sharding_propagation_to_parameters_size() const; public: void clear_allow_spmd_sharding_propagation_to_parameters(); private: bool _internal_allow_spmd_sharding_propagation_to_parameters(int index) const; const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& _internal_allow_spmd_sharding_propagation_to_parameters() const; void _internal_add_allow_spmd_sharding_propagation_to_parameters(bool value); ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* _internal_mutable_allow_spmd_sharding_propagation_to_parameters(); public: bool allow_spmd_sharding_propagation_to_parameters(int index) const; void set_allow_spmd_sharding_propagation_to_parameters(int index, bool value); void add_allow_spmd_sharding_propagation_to_parameters(bool value); const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& allow_spmd_sharding_propagation_to_parameters() const; ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* mutable_allow_spmd_sharding_propagation_to_parameters(); // string device_type = 13; void clear_device_type(); const std::string& device_type() const; template void set_device_type(ArgT0&& arg0, ArgT... args); std::string* mutable_device_type(); PROTOBUF_NODISCARD std::string* release_device_type(); void set_allocated_device_type(std::string* device_type); private: const std::string& _internal_device_type() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_type(const std::string& value); std::string* _internal_mutable_device_type(); public: // bytes fdo_profile = 31; void clear_fdo_profile(); const std::string& fdo_profile() const; template void set_fdo_profile(ArgT0&& arg0, ArgT... args); std::string* mutable_fdo_profile(); PROTOBUF_NODISCARD std::string* release_fdo_profile(); void set_allocated_fdo_profile(std::string* fdo_profile); private: const std::string& _internal_fdo_profile() const; inline PROTOBUF_ALWAYS_INLINE void _internal_set_fdo_profile(const std::string& value); std::string* _internal_mutable_fdo_profile(); public: // .xla.ProgramShapeProto entry_computation_layout = 1; bool has_entry_computation_layout() const; private: bool _internal_has_entry_computation_layout() const; public: void clear_entry_computation_layout(); const ::xla::ProgramShapeProto& entry_computation_layout() const; PROTOBUF_NODISCARD ::xla::ProgramShapeProto* release_entry_computation_layout(); ::xla::ProgramShapeProto* mutable_entry_computation_layout(); void set_allocated_entry_computation_layout(::xla::ProgramShapeProto* entry_computation_layout); private: const ::xla::ProgramShapeProto& _internal_entry_computation_layout() const; ::xla::ProgramShapeProto* _internal_mutable_entry_computation_layout(); public: void unsafe_arena_set_allocated_entry_computation_layout( ::xla::ProgramShapeProto* entry_computation_layout); ::xla::ProgramShapeProto* unsafe_arena_release_entry_computation_layout(); // .xla.DebugOptions debug_options = 14; bool has_debug_options() const; private: bool _internal_has_debug_options() const; public: void clear_debug_options(); const ::xla::DebugOptions& debug_options() const; PROTOBUF_NODISCARD ::xla::DebugOptions* release_debug_options(); ::xla::DebugOptions* mutable_debug_options(); void set_allocated_debug_options(::xla::DebugOptions* debug_options); private: const ::xla::DebugOptions& _internal_debug_options() const; ::xla::DebugOptions* _internal_mutable_debug_options(); public: void unsafe_arena_set_allocated_debug_options( ::xla::DebugOptions* debug_options); ::xla::DebugOptions* unsafe_arena_release_debug_options(); // .xla.DeviceAssignmentProto static_device_assignment = 15; bool has_static_device_assignment() const; private: bool _internal_has_static_device_assignment() const; public: void clear_static_device_assignment(); const ::xla::DeviceAssignmentProto& static_device_assignment() const; PROTOBUF_NODISCARD ::xla::DeviceAssignmentProto* release_static_device_assignment(); ::xla::DeviceAssignmentProto* mutable_static_device_assignment(); void set_allocated_static_device_assignment(::xla::DeviceAssignmentProto* static_device_assignment); private: const ::xla::DeviceAssignmentProto& _internal_static_device_assignment() const; ::xla::DeviceAssignmentProto* _internal_mutable_static_device_assignment(); public: void unsafe_arena_set_allocated_static_device_assignment( ::xla::DeviceAssignmentProto* static_device_assignment); ::xla::DeviceAssignmentProto* unsafe_arena_release_static_device_assignment(); // .xla.DeviceAssignmentProto pre_simulation_device_assignment = 35; bool has_pre_simulation_device_assignment() const; private: bool _internal_has_pre_simulation_device_assignment() const; public: void clear_pre_simulation_device_assignment(); const ::xla::DeviceAssignmentProto& pre_simulation_device_assignment() const; PROTOBUF_NODISCARD ::xla::DeviceAssignmentProto* release_pre_simulation_device_assignment(); ::xla::DeviceAssignmentProto* mutable_pre_simulation_device_assignment(); void set_allocated_pre_simulation_device_assignment(::xla::DeviceAssignmentProto* pre_simulation_device_assignment); private: const ::xla::DeviceAssignmentProto& _internal_pre_simulation_device_assignment() const; ::xla::DeviceAssignmentProto* _internal_mutable_pre_simulation_device_assignment(); public: void unsafe_arena_set_allocated_pre_simulation_device_assignment( ::xla::DeviceAssignmentProto* pre_simulation_device_assignment); ::xla::DeviceAssignmentProto* unsafe_arena_release_pre_simulation_device_assignment(); // .xla.ShardingConfigProto sharding_config = 38; bool has_sharding_config() const; private: bool _internal_has_sharding_config() const; public: void clear_sharding_config(); const ::xla::ShardingConfigProto& sharding_config() const; PROTOBUF_NODISCARD ::xla::ShardingConfigProto* release_sharding_config(); ::xla::ShardingConfigProto* mutable_sharding_config(); void set_allocated_sharding_config(::xla::ShardingConfigProto* sharding_config); private: const ::xla::ShardingConfigProto& _internal_sharding_config() const; ::xla::ShardingConfigProto* _internal_mutable_sharding_config(); public: void unsafe_arena_set_allocated_sharding_config( ::xla::ShardingConfigProto* sharding_config); ::xla::ShardingConfigProto* unsafe_arena_release_sharding_config(); // uint64 seed = 2; void clear_seed(); uint64_t seed() const; void set_seed(uint64_t value); private: uint64_t _internal_seed() const; void _internal_set_seed(uint64_t value); public: // int64 replica_count = 4; void clear_replica_count(); int64_t replica_count() const; void set_replica_count(int64_t value); private: int64_t _internal_replica_count() const; void _internal_set_replica_count(int64_t value); public: // int64 num_partitions = 5; void clear_num_partitions(); int64_t num_partitions() const; void set_num_partitions(int64_t value); private: int64_t _internal_num_partitions() const; void _internal_set_num_partitions(int64_t value); public: // int32 launch_id = 3; void clear_launch_id(); int32_t launch_id() const; void set_launch_id(int32_t value); private: int32_t _internal_launch_id() const; void _internal_set_launch_id(int32_t value); public: // bool use_spmd_partitioning = 7; void clear_use_spmd_partitioning(); bool use_spmd_partitioning() const; void set_use_spmd_partitioning(bool value); private: bool _internal_use_spmd_partitioning() const; void _internal_set_use_spmd_partitioning(bool value); public: // bool use_auto_spmd_partitioning = 8; void clear_use_auto_spmd_partitioning(); bool use_auto_spmd_partitioning() const; void set_use_auto_spmd_partitioning(bool value); private: bool _internal_use_auto_spmd_partitioning() const; void _internal_set_use_auto_spmd_partitioning(bool value); public: // bool deduplicate_hlo = 11; void clear_deduplicate_hlo(); bool deduplicate_hlo() const; void set_deduplicate_hlo(bool value); private: bool _internal_deduplicate_hlo() const; void _internal_set_deduplicate_hlo(bool value); public: // bool allow_separate_sharding_programs = 30; void clear_allow_separate_sharding_programs(); bool allow_separate_sharding_programs() const; void set_allow_separate_sharding_programs(bool value); private: bool _internal_allow_separate_sharding_programs() const; void _internal_set_allow_separate_sharding_programs(bool value); public: // int64 intra_op_parallelism_threads = 12; void clear_intra_op_parallelism_threads(); int64_t intra_op_parallelism_threads() const; void set_intra_op_parallelism_threads(int64_t value); private: int64_t _internal_intra_op_parallelism_threads() const; void _internal_set_intra_op_parallelism_threads(int64_t value); public: // .xla.HloModuleConfigProto.FusionConfigCollection fusion_config_collection = 19; void clear_fusion_config_collection(); ::xla::HloModuleConfigProto_FusionConfigCollection fusion_config_collection() const; void set_fusion_config_collection(::xla::HloModuleConfigProto_FusionConfigCollection value); private: ::xla::HloModuleConfigProto_FusionConfigCollection _internal_fusion_config_collection() const; void _internal_set_fusion_config_collection(::xla::HloModuleConfigProto_FusionConfigCollection value); public: // bool alias_passthrough_params = 17; void clear_alias_passthrough_params(); bool alias_passthrough_params() const; void set_alias_passthrough_params(bool value); private: bool _internal_alias_passthrough_params() const; void _internal_set_alias_passthrough_params(bool value); public: // bool content_aware_computation_sorting = 18; void clear_content_aware_computation_sorting(); bool content_aware_computation_sorting() const; void set_content_aware_computation_sorting(bool value); private: bool _internal_content_aware_computation_sorting() const; void _internal_set_content_aware_computation_sorting(bool value); public: // bool use_shardy_partitioner = 34; void clear_use_shardy_partitioner(); bool use_shardy_partitioner() const; void set_use_shardy_partitioner(bool value); private: bool _internal_use_shardy_partitioner() const; void _internal_set_use_shardy_partitioner(bool value); public: // int32 phase_index = 25; void clear_phase_index(); int32_t phase_index() const; void set_phase_index(int32_t value); private: int32_t _internal_phase_index() const; void _internal_set_phase_index(int32_t value); public: // .xla.PrecisionConfig.Precision matrix_unit_operand_precision = 29; void clear_matrix_unit_operand_precision(); ::xla::PrecisionConfig_Precision matrix_unit_operand_precision() const; void set_matrix_unit_operand_precision(::xla::PrecisionConfig_Precision value); private: ::xla::PrecisionConfig_Precision _internal_matrix_unit_operand_precision() const; void _internal_set_matrix_unit_operand_precision(::xla::PrecisionConfig_Precision value); public: // int64 device_memory_size = 32; void clear_device_memory_size(); int64_t device_memory_size() const; void set_device_memory_size(int64_t value); private: int64_t _internal_device_memory_size() const; void _internal_set_device_memory_size(int64_t value); public: // float exec_time_optimization_effort = 36; void clear_exec_time_optimization_effort(); float exec_time_optimization_effort() const; void set_exec_time_optimization_effort(float value); private: float _internal_exec_time_optimization_effort() const; void _internal_set_exec_time_optimization_effort(float value); public: // float memory_fitting_effort = 37; void clear_memory_fitting_effort(); float memory_fitting_effort() const; void set_memory_fitting_effort(float value); private: float _internal_memory_fitting_effort() const; void _internal_set_memory_fitting_effort(float value); public: // @@protoc_insertion_point(class_scope:xla.HloModuleConfigProto) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > param_requires_broadcast_via_collectives_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > auto_spmd_partitioning_mesh_shape_; mutable std::atomic _auto_spmd_partitioning_mesh_shape_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > auto_spmd_partitioning_mesh_ids_; mutable std::atomic _auto_spmd_partitioning_mesh_ids_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShardableValueUpdatePairProto > shardable_value_update_pairs_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_BoolList > fusion_config_; ::PROTOBUF_NAMESPACE_ID::internal::MapField< HloModuleConfigProto_DotConfigEntry_DoNotUse, std::string, ::xla::HloModuleConfigProto_Int64List, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> dot_config_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_Int64ListList > layout_config_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > memory_space_assignment_config_; mutable std::atomic _memory_space_assignment_config_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_BoolList > phase_ordering_config_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > allow_spmd_sharding_propagation_to_output_; ::PROTOBUF_NAMESPACE_ID::internal::MapField< HloModuleConfigProto_AnalysisAllowanceMapEntry_DoNotUse, std::string, int64_t, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING, ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_INT64> analysis_allowance_map_; ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > allow_spmd_sharding_propagation_to_parameters_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_type_; ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fdo_profile_; ::xla::ProgramShapeProto* entry_computation_layout_; ::xla::DebugOptions* debug_options_; ::xla::DeviceAssignmentProto* static_device_assignment_; ::xla::DeviceAssignmentProto* pre_simulation_device_assignment_; ::xla::ShardingConfigProto* sharding_config_; uint64_t seed_; int64_t replica_count_; int64_t num_partitions_; int32_t launch_id_; bool use_spmd_partitioning_; bool use_auto_spmd_partitioning_; bool deduplicate_hlo_; bool allow_separate_sharding_programs_; int64_t intra_op_parallelism_threads_; int fusion_config_collection_; bool alias_passthrough_params_; bool content_aware_computation_sorting_; bool use_shardy_partitioner_; int32_t phase_index_; int matrix_unit_operand_precision_; int64_t device_memory_size_; float exec_time_optimization_effort_; float memory_fitting_effort_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class HloModuleProtoWithConfig final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.HloModuleProtoWithConfig) */ { public: inline HloModuleProtoWithConfig() : HloModuleProtoWithConfig(nullptr) {} ~HloModuleProtoWithConfig() override; explicit PROTOBUF_CONSTEXPR HloModuleProtoWithConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); HloModuleProtoWithConfig(const HloModuleProtoWithConfig& from); HloModuleProtoWithConfig(HloModuleProtoWithConfig&& from) noexcept : HloModuleProtoWithConfig() { *this = ::std::move(from); } inline HloModuleProtoWithConfig& operator=(const HloModuleProtoWithConfig& from) { CopyFrom(from); return *this; } inline HloModuleProtoWithConfig& operator=(HloModuleProtoWithConfig&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const HloModuleProtoWithConfig& default_instance() { return *internal_default_instance(); } static inline const HloModuleProtoWithConfig* internal_default_instance() { return reinterpret_cast( &_HloModuleProtoWithConfig_default_instance_); } static constexpr int kIndexInFileMessages = 13; friend void swap(HloModuleProtoWithConfig& a, HloModuleProtoWithConfig& b) { a.Swap(&b); } inline void Swap(HloModuleProtoWithConfig* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(HloModuleProtoWithConfig* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- HloModuleProtoWithConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const HloModuleProtoWithConfig& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const HloModuleProtoWithConfig& from) { HloModuleProtoWithConfig::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(HloModuleProtoWithConfig* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.HloModuleProtoWithConfig"; } protected: explicit HloModuleProtoWithConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kHloModuleFieldNumber = 1, kConfigFieldNumber = 2, }; // .xla.HloModuleProto hlo_module = 1; bool has_hlo_module() const; private: bool _internal_has_hlo_module() const; public: void clear_hlo_module(); const ::xla::HloModuleProto& hlo_module() const; PROTOBUF_NODISCARD ::xla::HloModuleProto* release_hlo_module(); ::xla::HloModuleProto* mutable_hlo_module(); void set_allocated_hlo_module(::xla::HloModuleProto* hlo_module); private: const ::xla::HloModuleProto& _internal_hlo_module() const; ::xla::HloModuleProto* _internal_mutable_hlo_module(); public: void unsafe_arena_set_allocated_hlo_module( ::xla::HloModuleProto* hlo_module); ::xla::HloModuleProto* unsafe_arena_release_hlo_module(); // .xla.HloModuleConfigProto config = 2; bool has_config() const; private: bool _internal_has_config() const; public: void clear_config(); const ::xla::HloModuleConfigProto& config() const; PROTOBUF_NODISCARD ::xla::HloModuleConfigProto* release_config(); ::xla::HloModuleConfigProto* mutable_config(); void set_allocated_config(::xla::HloModuleConfigProto* config); private: const ::xla::HloModuleConfigProto& _internal_config() const; ::xla::HloModuleConfigProto* _internal_mutable_config(); public: void unsafe_arena_set_allocated_config( ::xla::HloModuleConfigProto* config); ::xla::HloModuleConfigProto* unsafe_arena_release_config(); // @@protoc_insertion_point(class_scope:xla.HloModuleProtoWithConfig) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::xla::HloModuleProto* hlo_module_; ::xla::HloModuleConfigProto* config_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class ScheduleProto_Instruction final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.ScheduleProto.Instruction) */ { public: inline ScheduleProto_Instruction() : ScheduleProto_Instruction(nullptr) {} ~ScheduleProto_Instruction() override; explicit PROTOBUF_CONSTEXPR ScheduleProto_Instruction(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ScheduleProto_Instruction(const ScheduleProto_Instruction& from); ScheduleProto_Instruction(ScheduleProto_Instruction&& from) noexcept : ScheduleProto_Instruction() { *this = ::std::move(from); } inline ScheduleProto_Instruction& operator=(const ScheduleProto_Instruction& from) { CopyFrom(from); return *this; } inline ScheduleProto_Instruction& operator=(ScheduleProto_Instruction&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ScheduleProto_Instruction& default_instance() { return *internal_default_instance(); } static inline const ScheduleProto_Instruction* internal_default_instance() { return reinterpret_cast( &_ScheduleProto_Instruction_default_instance_); } static constexpr int kIndexInFileMessages = 14; friend void swap(ScheduleProto_Instruction& a, ScheduleProto_Instruction& b) { a.Swap(&b); } inline void Swap(ScheduleProto_Instruction* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ScheduleProto_Instruction* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ScheduleProto_Instruction* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ScheduleProto_Instruction& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ScheduleProto_Instruction& from) { ScheduleProto_Instruction::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ScheduleProto_Instruction* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.ScheduleProto.Instruction"; } protected: explicit ScheduleProto_Instruction(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kIdFieldNumber = 1, kStartTimestampCyclesFieldNumber = 2, kEndTimestampCyclesFieldNumber = 3, }; // int64 id = 1; void clear_id(); int64_t id() const; void set_id(int64_t value); private: int64_t _internal_id() const; void _internal_set_id(int64_t value); public: // double start_timestamp_cycles = 2; void clear_start_timestamp_cycles(); double start_timestamp_cycles() const; void set_start_timestamp_cycles(double value); private: double _internal_start_timestamp_cycles() const; void _internal_set_start_timestamp_cycles(double value); public: // double end_timestamp_cycles = 3; void clear_end_timestamp_cycles(); double end_timestamp_cycles() const; void set_end_timestamp_cycles(double value); private: double _internal_end_timestamp_cycles() const; void _internal_set_end_timestamp_cycles(double value); public: // @@protoc_insertion_point(class_scope:xla.ScheduleProto.Instruction) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { int64_t id_; double start_timestamp_cycles_; double end_timestamp_cycles_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class ScheduleProto final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.ScheduleProto) */ { public: inline ScheduleProto() : ScheduleProto(nullptr) {} ~ScheduleProto() override; explicit PROTOBUF_CONSTEXPR ScheduleProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ScheduleProto(const ScheduleProto& from); ScheduleProto(ScheduleProto&& from) noexcept : ScheduleProto() { *this = ::std::move(from); } inline ScheduleProto& operator=(const ScheduleProto& from) { CopyFrom(from); return *this; } inline ScheduleProto& operator=(ScheduleProto&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ScheduleProto& default_instance() { return *internal_default_instance(); } static inline const ScheduleProto* internal_default_instance() { return reinterpret_cast( &_ScheduleProto_default_instance_); } static constexpr int kIndexInFileMessages = 15; friend void swap(ScheduleProto& a, ScheduleProto& b) { a.Swap(&b); } inline void Swap(ScheduleProto* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ScheduleProto* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ScheduleProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ScheduleProto& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ScheduleProto& from) { ScheduleProto::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ScheduleProto* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.ScheduleProto"; } protected: explicit ScheduleProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- typedef ScheduleProto_Instruction Instruction; // accessors ------------------------------------------------------- enum : int { kInstructionsFieldNumber = 1, kHloModuleFieldNumber = 3, kComputationIdFieldNumber = 2, kCyclesPerMicrosecondFieldNumber = 4, }; // repeated .xla.ScheduleProto.Instruction instructions = 1; int instructions_size() const; private: int _internal_instructions_size() const; public: void clear_instructions(); ::xla::ScheduleProto_Instruction* mutable_instructions(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ScheduleProto_Instruction >* mutable_instructions(); private: const ::xla::ScheduleProto_Instruction& _internal_instructions(int index) const; ::xla::ScheduleProto_Instruction* _internal_add_instructions(); public: const ::xla::ScheduleProto_Instruction& instructions(int index) const; ::xla::ScheduleProto_Instruction* add_instructions(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ScheduleProto_Instruction >& instructions() const; // .xla.HloModuleProto hlo_module = 3; bool has_hlo_module() const; private: bool _internal_has_hlo_module() const; public: void clear_hlo_module(); const ::xla::HloModuleProto& hlo_module() const; PROTOBUF_NODISCARD ::xla::HloModuleProto* release_hlo_module(); ::xla::HloModuleProto* mutable_hlo_module(); void set_allocated_hlo_module(::xla::HloModuleProto* hlo_module); private: const ::xla::HloModuleProto& _internal_hlo_module() const; ::xla::HloModuleProto* _internal_mutable_hlo_module(); public: void unsafe_arena_set_allocated_hlo_module( ::xla::HloModuleProto* hlo_module); ::xla::HloModuleProto* unsafe_arena_release_hlo_module(); // int64 computation_id = 2; void clear_computation_id(); int64_t computation_id() const; void set_computation_id(int64_t value); private: int64_t _internal_computation_id() const; void _internal_set_computation_id(int64_t value); public: // int64 cycles_per_microsecond = 4; void clear_cycles_per_microsecond(); int64_t cycles_per_microsecond() const; void set_cycles_per_microsecond(int64_t value); private: int64_t _internal_cycles_per_microsecond() const; void _internal_set_cycles_per_microsecond(int64_t value); public: // @@protoc_insertion_point(class_scope:xla.ScheduleProto) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ScheduleProto_Instruction > instructions_; ::xla::HloModuleProto* hlo_module_; int64_t computation_id_; int64_t cycles_per_microsecond_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class NodeShardingConfigProto final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.NodeShardingConfigProto) */ { public: inline NodeShardingConfigProto() : NodeShardingConfigProto(nullptr) {} ~NodeShardingConfigProto() override; explicit PROTOBUF_CONSTEXPR NodeShardingConfigProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); NodeShardingConfigProto(const NodeShardingConfigProto& from); NodeShardingConfigProto(NodeShardingConfigProto&& from) noexcept : NodeShardingConfigProto() { *this = ::std::move(from); } inline NodeShardingConfigProto& operator=(const NodeShardingConfigProto& from) { CopyFrom(from); return *this; } inline NodeShardingConfigProto& operator=(NodeShardingConfigProto&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const NodeShardingConfigProto& default_instance() { return *internal_default_instance(); } static inline const NodeShardingConfigProto* internal_default_instance() { return reinterpret_cast( &_NodeShardingConfigProto_default_instance_); } static constexpr int kIndexInFileMessages = 16; friend void swap(NodeShardingConfigProto& a, NodeShardingConfigProto& b) { a.Swap(&b); } inline void Swap(NodeShardingConfigProto* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(NodeShardingConfigProto* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- NodeShardingConfigProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const NodeShardingConfigProto& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const NodeShardingConfigProto& from) { NodeShardingConfigProto::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(NodeShardingConfigProto* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.NodeShardingConfigProto"; } protected: explicit NodeShardingConfigProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kNodesFieldNumber = 2, kShardingFieldNumber = 1, }; // repeated .xla.NodeShardingConfigProto nodes = 2; int nodes_size() const; private: int _internal_nodes_size() const; public: void clear_nodes(); ::xla::NodeShardingConfigProto* mutable_nodes(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::NodeShardingConfigProto >* mutable_nodes(); private: const ::xla::NodeShardingConfigProto& _internal_nodes(int index) const; ::xla::NodeShardingConfigProto* _internal_add_nodes(); public: const ::xla::NodeShardingConfigProto& nodes(int index) const; ::xla::NodeShardingConfigProto* add_nodes(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::NodeShardingConfigProto >& nodes() const; // .xla.OpSharding sharding = 1; bool has_sharding() const; private: bool _internal_has_sharding() const; public: void clear_sharding(); const ::xla::OpSharding& sharding() const; PROTOBUF_NODISCARD ::xla::OpSharding* release_sharding(); ::xla::OpSharding* mutable_sharding(); void set_allocated_sharding(::xla::OpSharding* sharding); private: const ::xla::OpSharding& _internal_sharding() const; ::xla::OpSharding* _internal_mutable_sharding(); public: void unsafe_arena_set_allocated_sharding( ::xla::OpSharding* sharding); ::xla::OpSharding* unsafe_arena_release_sharding(); // @@protoc_insertion_point(class_scope:xla.NodeShardingConfigProto) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::NodeShardingConfigProto > nodes_; ::xla::OpSharding* sharding_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // ------------------------------------------------------------------- class ShardingConfigProto final : public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.ShardingConfigProto) */ { public: inline ShardingConfigProto() : ShardingConfigProto(nullptr) {} ~ShardingConfigProto() override; explicit PROTOBUF_CONSTEXPR ShardingConfigProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); ShardingConfigProto(const ShardingConfigProto& from); ShardingConfigProto(ShardingConfigProto&& from) noexcept : ShardingConfigProto() { *this = ::std::move(from); } inline ShardingConfigProto& operator=(const ShardingConfigProto& from) { CopyFrom(from); return *this; } inline ShardingConfigProto& operator=(ShardingConfigProto&& from) noexcept { if (this == &from) return *this; if (GetOwningArena() == from.GetOwningArena() #ifdef PROTOBUF_FORCE_COPY_IN_MOVE && GetOwningArena() != nullptr #endif // !PROTOBUF_FORCE_COPY_IN_MOVE ) { InternalSwap(&from); } else { CopyFrom(from); } return *this; } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { return GetDescriptor(); } static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { return default_instance().GetMetadata().descriptor; } static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { return default_instance().GetMetadata().reflection; } static const ShardingConfigProto& default_instance() { return *internal_default_instance(); } static inline const ShardingConfigProto* internal_default_instance() { return reinterpret_cast( &_ShardingConfigProto_default_instance_); } static constexpr int kIndexInFileMessages = 17; friend void swap(ShardingConfigProto& a, ShardingConfigProto& b) { a.Swap(&b); } inline void Swap(ShardingConfigProto* other) { if (other == this) return; #ifdef PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() != nullptr && GetOwningArena() == other->GetOwningArena()) { #else // PROTOBUF_FORCE_COPY_IN_SWAP if (GetOwningArena() == other->GetOwningArena()) { #endif // !PROTOBUF_FORCE_COPY_IN_SWAP InternalSwap(other); } else { ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); } } void UnsafeArenaSwap(ShardingConfigProto* other) { if (other == this) return; GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); InternalSwap(other); } // implements Message ---------------------------------------------- ShardingConfigProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { return CreateMaybeMessage(arena); } using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; void CopyFrom(const ShardingConfigProto& from); using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; void MergeFrom( const ShardingConfigProto& from) { ShardingConfigProto::MergeImpl(*this, from); } private: static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); public: PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; bool IsInitialized() const final; size_t ByteSizeLong() const final; const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; uint8_t* _InternalSerialize( uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; int GetCachedSize() const final { return _impl_._cached_size_.Get(); } private: void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); void SharedDtor(); void SetCachedSize(int size) const final; void InternalSwap(ShardingConfigProto* other); private: friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { return "xla.ShardingConfigProto"; } protected: explicit ShardingConfigProto(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned = false); public: static const ClassData _class_data_; const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; // nested types ---------------------------------------------------- // accessors ------------------------------------------------------- enum : int { kNodesFieldNumber = 1, }; // repeated .xla.NodeShardingConfigProto nodes = 1; int nodes_size() const; private: int _internal_nodes_size() const; public: void clear_nodes(); ::xla::NodeShardingConfigProto* mutable_nodes(int index); ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::NodeShardingConfigProto >* mutable_nodes(); private: const ::xla::NodeShardingConfigProto& _internal_nodes(int index) const; ::xla::NodeShardingConfigProto* _internal_add_nodes(); public: const ::xla::NodeShardingConfigProto& nodes(int index) const; ::xla::NodeShardingConfigProto* add_nodes(); const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::NodeShardingConfigProto >& nodes() const; // @@protoc_insertion_point(class_scope:xla.ShardingConfigProto) private: class _Internal; template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; typedef void InternalArenaConstructable_; typedef void DestructorSkippable_; struct Impl_ { ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::NodeShardingConfigProto > nodes_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; friend struct ::TableStruct_xla_2fxla_2eproto; }; // =================================================================== // =================================================================== #ifdef __GNUC__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wstrict-aliasing" #endif // __GNUC__ // CompilationEnvironmentsProto // repeated .google.protobuf.Any environments = 1; inline int CompilationEnvironmentsProto::_internal_environments_size() const { return _impl_.environments_.size(); } inline int CompilationEnvironmentsProto::environments_size() const { return _internal_environments_size(); } inline ::PROTOBUF_NAMESPACE_ID::Any* CompilationEnvironmentsProto::mutable_environments(int index) { // @@protoc_insertion_point(field_mutable:xla.CompilationEnvironmentsProto.environments) return _impl_.environments_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >* CompilationEnvironmentsProto::mutable_environments() { // @@protoc_insertion_point(field_mutable_list:xla.CompilationEnvironmentsProto.environments) return &_impl_.environments_; } inline const ::PROTOBUF_NAMESPACE_ID::Any& CompilationEnvironmentsProto::_internal_environments(int index) const { return _impl_.environments_.Get(index); } inline const ::PROTOBUF_NAMESPACE_ID::Any& CompilationEnvironmentsProto::environments(int index) const { // @@protoc_insertion_point(field_get:xla.CompilationEnvironmentsProto.environments) return _internal_environments(index); } inline ::PROTOBUF_NAMESPACE_ID::Any* CompilationEnvironmentsProto::_internal_add_environments() { return _impl_.environments_.Add(); } inline ::PROTOBUF_NAMESPACE_ID::Any* CompilationEnvironmentsProto::add_environments() { ::PROTOBUF_NAMESPACE_ID::Any* _add = _internal_add_environments(); // @@protoc_insertion_point(field_add:xla.CompilationEnvironmentsProto.environments) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::PROTOBUF_NAMESPACE_ID::Any >& CompilationEnvironmentsProto::environments() const { // @@protoc_insertion_point(field_list:xla.CompilationEnvironmentsProto.environments) return _impl_.environments_; } // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // DebugOptions // bool xla_unsupported_crash_on_hlo_pass_fix_max_iterations = 363; inline void DebugOptions::clear_xla_unsupported_crash_on_hlo_pass_fix_max_iterations() { _impl_.xla_unsupported_crash_on_hlo_pass_fix_max_iterations_ = false; } inline bool DebugOptions::_internal_xla_unsupported_crash_on_hlo_pass_fix_max_iterations() const { return _impl_.xla_unsupported_crash_on_hlo_pass_fix_max_iterations_; } inline bool DebugOptions::xla_unsupported_crash_on_hlo_pass_fix_max_iterations() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_unsupported_crash_on_hlo_pass_fix_max_iterations) return _internal_xla_unsupported_crash_on_hlo_pass_fix_max_iterations(); } inline void DebugOptions::_internal_set_xla_unsupported_crash_on_hlo_pass_fix_max_iterations(bool value) { _impl_.xla_unsupported_crash_on_hlo_pass_fix_max_iterations_ = value; } inline void DebugOptions::set_xla_unsupported_crash_on_hlo_pass_fix_max_iterations(bool value) { _internal_set_xla_unsupported_crash_on_hlo_pass_fix_max_iterations(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_unsupported_crash_on_hlo_pass_fix_max_iterations) } // .xla.DebugOptions.XnnGraphFusionMode xla_cpu_experimental_xnn_graph_fusion_mode = 365; inline void DebugOptions::clear_xla_cpu_experimental_xnn_graph_fusion_mode() { _impl_.xla_cpu_experimental_xnn_graph_fusion_mode_ = 0; } inline ::xla::DebugOptions_XnnGraphFusionMode DebugOptions::_internal_xla_cpu_experimental_xnn_graph_fusion_mode() const { return static_cast< ::xla::DebugOptions_XnnGraphFusionMode >(_impl_.xla_cpu_experimental_xnn_graph_fusion_mode_); } inline ::xla::DebugOptions_XnnGraphFusionMode DebugOptions::xla_cpu_experimental_xnn_graph_fusion_mode() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_experimental_xnn_graph_fusion_mode) return _internal_xla_cpu_experimental_xnn_graph_fusion_mode(); } inline void DebugOptions::_internal_set_xla_cpu_experimental_xnn_graph_fusion_mode(::xla::DebugOptions_XnnGraphFusionMode value) { _impl_.xla_cpu_experimental_xnn_graph_fusion_mode_ = value; } inline void DebugOptions::set_xla_cpu_experimental_xnn_graph_fusion_mode(::xla::DebugOptions_XnnGraphFusionMode value) { _internal_set_xla_cpu_experimental_xnn_graph_fusion_mode(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_experimental_xnn_graph_fusion_mode) } // bool xla_cpu_copy_insertion_use_region_analysis = 337; inline void DebugOptions::clear_xla_cpu_copy_insertion_use_region_analysis() { _impl_.xla_cpu_copy_insertion_use_region_analysis_ = false; } inline bool DebugOptions::_internal_xla_cpu_copy_insertion_use_region_analysis() const { return _impl_.xla_cpu_copy_insertion_use_region_analysis_; } inline bool DebugOptions::xla_cpu_copy_insertion_use_region_analysis() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_copy_insertion_use_region_analysis) return _internal_xla_cpu_copy_insertion_use_region_analysis(); } inline void DebugOptions::_internal_set_xla_cpu_copy_insertion_use_region_analysis(bool value) { _impl_.xla_cpu_copy_insertion_use_region_analysis_ = value; } inline void DebugOptions::set_xla_cpu_copy_insertion_use_region_analysis(bool value) { _internal_set_xla_cpu_copy_insertion_use_region_analysis(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_copy_insertion_use_region_analysis) } // bool xla_cpu_enable_concurrency_optimized_scheduler = 307; inline void DebugOptions::clear_xla_cpu_enable_concurrency_optimized_scheduler() { _impl_.xla_cpu_enable_concurrency_optimized_scheduler_ = false; } inline bool DebugOptions::_internal_xla_cpu_enable_concurrency_optimized_scheduler() const { return _impl_.xla_cpu_enable_concurrency_optimized_scheduler_; } inline bool DebugOptions::xla_cpu_enable_concurrency_optimized_scheduler() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_enable_concurrency_optimized_scheduler) return _internal_xla_cpu_enable_concurrency_optimized_scheduler(); } inline void DebugOptions::_internal_set_xla_cpu_enable_concurrency_optimized_scheduler(bool value) { _impl_.xla_cpu_enable_concurrency_optimized_scheduler_ = value; } inline void DebugOptions::set_xla_cpu_enable_concurrency_optimized_scheduler(bool value) { _internal_set_xla_cpu_enable_concurrency_optimized_scheduler(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_enable_concurrency_optimized_scheduler) } // bool xla_cpu_enable_fast_math = 99; inline void DebugOptions::clear_xla_cpu_enable_fast_math() { _impl_.xla_cpu_enable_fast_math_ = false; } inline bool DebugOptions::_internal_xla_cpu_enable_fast_math() const { return _impl_.xla_cpu_enable_fast_math_; } inline bool DebugOptions::xla_cpu_enable_fast_math() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_enable_fast_math) return _internal_xla_cpu_enable_fast_math(); } inline void DebugOptions::_internal_set_xla_cpu_enable_fast_math(bool value) { _impl_.xla_cpu_enable_fast_math_ = value; } inline void DebugOptions::set_xla_cpu_enable_fast_math(bool value) { _internal_set_xla_cpu_enable_fast_math(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_enable_fast_math) } // bool xla_cpu_enable_fast_min_max = 140; inline void DebugOptions::clear_xla_cpu_enable_fast_min_max() { _impl_.xla_cpu_enable_fast_min_max_ = false; } inline bool DebugOptions::_internal_xla_cpu_enable_fast_min_max() const { return _impl_.xla_cpu_enable_fast_min_max_; } inline bool DebugOptions::xla_cpu_enable_fast_min_max() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_enable_fast_min_max) return _internal_xla_cpu_enable_fast_min_max(); } inline void DebugOptions::_internal_set_xla_cpu_enable_fast_min_max(bool value) { _impl_.xla_cpu_enable_fast_min_max_ = value; } inline void DebugOptions::set_xla_cpu_enable_fast_min_max(bool value) { _internal_set_xla_cpu_enable_fast_min_max(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_enable_fast_min_max) } // bool xla_cpu_fast_math_honor_division = 126; inline void DebugOptions::clear_xla_cpu_fast_math_honor_division() { _impl_.xla_cpu_fast_math_honor_division_ = false; } inline bool DebugOptions::_internal_xla_cpu_fast_math_honor_division() const { return _impl_.xla_cpu_fast_math_honor_division_; } inline bool DebugOptions::xla_cpu_fast_math_honor_division() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_fast_math_honor_division) return _internal_xla_cpu_fast_math_honor_division(); } inline void DebugOptions::_internal_set_xla_cpu_fast_math_honor_division(bool value) { _impl_.xla_cpu_fast_math_honor_division_ = value; } inline void DebugOptions::set_xla_cpu_fast_math_honor_division(bool value) { _internal_set_xla_cpu_fast_math_honor_division(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_fast_math_honor_division) } // bool xla_cpu_fast_math_honor_functions = 129; inline void DebugOptions::clear_xla_cpu_fast_math_honor_functions() { _impl_.xla_cpu_fast_math_honor_functions_ = false; } inline bool DebugOptions::_internal_xla_cpu_fast_math_honor_functions() const { return _impl_.xla_cpu_fast_math_honor_functions_; } inline bool DebugOptions::xla_cpu_fast_math_honor_functions() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_fast_math_honor_functions) return _internal_xla_cpu_fast_math_honor_functions(); } inline void DebugOptions::_internal_set_xla_cpu_fast_math_honor_functions(bool value) { _impl_.xla_cpu_fast_math_honor_functions_ = value; } inline void DebugOptions::set_xla_cpu_fast_math_honor_functions(bool value) { _internal_set_xla_cpu_fast_math_honor_functions(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_fast_math_honor_functions) } // bool xla_cpu_fast_math_honor_infs = 121; inline void DebugOptions::clear_xla_cpu_fast_math_honor_infs() { _impl_.xla_cpu_fast_math_honor_infs_ = false; } inline bool DebugOptions::_internal_xla_cpu_fast_math_honor_infs() const { return _impl_.xla_cpu_fast_math_honor_infs_; } inline bool DebugOptions::xla_cpu_fast_math_honor_infs() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_fast_math_honor_infs) return _internal_xla_cpu_fast_math_honor_infs(); } inline void DebugOptions::_internal_set_xla_cpu_fast_math_honor_infs(bool value) { _impl_.xla_cpu_fast_math_honor_infs_ = value; } inline void DebugOptions::set_xla_cpu_fast_math_honor_infs(bool value) { _internal_set_xla_cpu_fast_math_honor_infs(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_fast_math_honor_infs) } // bool xla_cpu_fast_math_honor_nans = 120; inline void DebugOptions::clear_xla_cpu_fast_math_honor_nans() { _impl_.xla_cpu_fast_math_honor_nans_ = false; } inline bool DebugOptions::_internal_xla_cpu_fast_math_honor_nans() const { return _impl_.xla_cpu_fast_math_honor_nans_; } inline bool DebugOptions::xla_cpu_fast_math_honor_nans() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_fast_math_honor_nans) return _internal_xla_cpu_fast_math_honor_nans(); } inline void DebugOptions::_internal_set_xla_cpu_fast_math_honor_nans(bool value) { _impl_.xla_cpu_fast_math_honor_nans_ = value; } inline void DebugOptions::set_xla_cpu_fast_math_honor_nans(bool value) { _internal_set_xla_cpu_fast_math_honor_nans(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_fast_math_honor_nans) } // string xla_cpu_max_isa = 333; inline void DebugOptions::clear_xla_cpu_max_isa() { _impl_.xla_cpu_max_isa_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_cpu_max_isa() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_max_isa) return _internal_xla_cpu_max_isa(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_cpu_max_isa(ArgT0&& arg0, ArgT... args) { _impl_.xla_cpu_max_isa_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_max_isa) } inline std::string* DebugOptions::mutable_xla_cpu_max_isa() { std::string* _s = _internal_mutable_xla_cpu_max_isa(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_cpu_max_isa) return _s; } inline const std::string& DebugOptions::_internal_xla_cpu_max_isa() const { return _impl_.xla_cpu_max_isa_.Get(); } inline void DebugOptions::_internal_set_xla_cpu_max_isa(const std::string& value) { _impl_.xla_cpu_max_isa_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_cpu_max_isa() { return _impl_.xla_cpu_max_isa_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_cpu_max_isa() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_cpu_max_isa) return _impl_.xla_cpu_max_isa_.Release(); } inline void DebugOptions::set_allocated_xla_cpu_max_isa(std::string* xla_cpu_max_isa) { if (xla_cpu_max_isa != nullptr) { } else { } _impl_.xla_cpu_max_isa_.SetAllocated(xla_cpu_max_isa, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_cpu_max_isa_.IsDefault()) { _impl_.xla_cpu_max_isa_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_cpu_max_isa) } // int32 xla_cpu_parallel_codegen_split_count = 323; inline void DebugOptions::clear_xla_cpu_parallel_codegen_split_count() { _impl_.xla_cpu_parallel_codegen_split_count_ = 0; } inline int32_t DebugOptions::_internal_xla_cpu_parallel_codegen_split_count() const { return _impl_.xla_cpu_parallel_codegen_split_count_; } inline int32_t DebugOptions::xla_cpu_parallel_codegen_split_count() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_parallel_codegen_split_count) return _internal_xla_cpu_parallel_codegen_split_count(); } inline void DebugOptions::_internal_set_xla_cpu_parallel_codegen_split_count(int32_t value) { _impl_.xla_cpu_parallel_codegen_split_count_ = value; } inline void DebugOptions::set_xla_cpu_parallel_codegen_split_count(int32_t value) { _internal_set_xla_cpu_parallel_codegen_split_count(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_parallel_codegen_split_count) } // int32 xla_cpu_prefer_vector_width = 308; inline void DebugOptions::clear_xla_cpu_prefer_vector_width() { _impl_.xla_cpu_prefer_vector_width_ = 0; } inline int32_t DebugOptions::_internal_xla_cpu_prefer_vector_width() const { return _impl_.xla_cpu_prefer_vector_width_; } inline int32_t DebugOptions::xla_cpu_prefer_vector_width() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_prefer_vector_width) return _internal_xla_cpu_prefer_vector_width(); } inline void DebugOptions::_internal_set_xla_cpu_prefer_vector_width(int32_t value) { _impl_.xla_cpu_prefer_vector_width_ = value; } inline void DebugOptions::set_xla_cpu_prefer_vector_width(int32_t value) { _internal_set_xla_cpu_prefer_vector_width(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_prefer_vector_width) } // bool xla_cpu_use_thunk_runtime = 298; inline void DebugOptions::clear_xla_cpu_use_thunk_runtime() { _impl_.xla_cpu_use_thunk_runtime_ = false; } inline bool DebugOptions::_internal_xla_cpu_use_thunk_runtime() const { return _impl_.xla_cpu_use_thunk_runtime_; } inline bool DebugOptions::xla_cpu_use_thunk_runtime() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_use_thunk_runtime) return _internal_xla_cpu_use_thunk_runtime(); } inline void DebugOptions::_internal_set_xla_cpu_use_thunk_runtime(bool value) { _impl_.xla_cpu_use_thunk_runtime_ = value; } inline void DebugOptions::set_xla_cpu_use_thunk_runtime(bool value) { _internal_set_xla_cpu_use_thunk_runtime(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_use_thunk_runtime) } // bool xla_cpu_use_xnnpack = 359; inline void DebugOptions::clear_xla_cpu_use_xnnpack() { _impl_.xla_cpu_use_xnnpack_ = false; } inline bool DebugOptions::_internal_xla_cpu_use_xnnpack() const { return _impl_.xla_cpu_use_xnnpack_; } inline bool DebugOptions::xla_cpu_use_xnnpack() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_use_xnnpack) return _internal_xla_cpu_use_xnnpack(); } inline void DebugOptions::_internal_set_xla_cpu_use_xnnpack(bool value) { _impl_.xla_cpu_use_xnnpack_ = value; } inline void DebugOptions::set_xla_cpu_use_xnnpack(bool value) { _internal_set_xla_cpu_use_xnnpack(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_use_xnnpack) } // bool xla_enable_fast_math = 335; inline void DebugOptions::clear_xla_enable_fast_math() { _impl_.xla_enable_fast_math_ = false; } inline bool DebugOptions::_internal_xla_enable_fast_math() const { return _impl_.xla_enable_fast_math_; } inline bool DebugOptions::xla_enable_fast_math() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_enable_fast_math) return _internal_xla_enable_fast_math(); } inline void DebugOptions::_internal_set_xla_enable_fast_math(bool value) { _impl_.xla_enable_fast_math_ = value; } inline void DebugOptions::set_xla_enable_fast_math(bool value) { _internal_set_xla_enable_fast_math(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_enable_fast_math) } // .xla.DebugOptions.PipelineParallelismOptLevel xla_gpu_experimental_pipeline_parallelism_opt_level = 351; inline void DebugOptions::clear_xla_gpu_experimental_pipeline_parallelism_opt_level() { _impl_.xla_gpu_experimental_pipeline_parallelism_opt_level_ = 0; } inline ::xla::DebugOptions_PipelineParallelismOptLevel DebugOptions::_internal_xla_gpu_experimental_pipeline_parallelism_opt_level() const { return static_cast< ::xla::DebugOptions_PipelineParallelismOptLevel >(_impl_.xla_gpu_experimental_pipeline_parallelism_opt_level_); } inline ::xla::DebugOptions_PipelineParallelismOptLevel DebugOptions::xla_gpu_experimental_pipeline_parallelism_opt_level() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_pipeline_parallelism_opt_level) return _internal_xla_gpu_experimental_pipeline_parallelism_opt_level(); } inline void DebugOptions::_internal_set_xla_gpu_experimental_pipeline_parallelism_opt_level(::xla::DebugOptions_PipelineParallelismOptLevel value) { _impl_.xla_gpu_experimental_pipeline_parallelism_opt_level_ = value; } inline void DebugOptions::set_xla_gpu_experimental_pipeline_parallelism_opt_level(::xla::DebugOptions_PipelineParallelismOptLevel value) { _internal_set_xla_gpu_experimental_pipeline_parallelism_opt_level(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_pipeline_parallelism_opt_level) } // string xla_gpu_algorithm_denylist_path = 128; inline void DebugOptions::clear_xla_gpu_algorithm_denylist_path() { _impl_.xla_gpu_algorithm_denylist_path_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_gpu_algorithm_denylist_path() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_algorithm_denylist_path) return _internal_xla_gpu_algorithm_denylist_path(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_algorithm_denylist_path(ArgT0&& arg0, ArgT... args) { _impl_.xla_gpu_algorithm_denylist_path_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_algorithm_denylist_path) } inline std::string* DebugOptions::mutable_xla_gpu_algorithm_denylist_path() { std::string* _s = _internal_mutable_xla_gpu_algorithm_denylist_path(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_algorithm_denylist_path) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_algorithm_denylist_path() const { return _impl_.xla_gpu_algorithm_denylist_path_.Get(); } inline void DebugOptions::_internal_set_xla_gpu_algorithm_denylist_path(const std::string& value) { _impl_.xla_gpu_algorithm_denylist_path_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_gpu_algorithm_denylist_path() { return _impl_.xla_gpu_algorithm_denylist_path_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_gpu_algorithm_denylist_path() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_algorithm_denylist_path) return _impl_.xla_gpu_algorithm_denylist_path_.Release(); } inline void DebugOptions::set_allocated_xla_gpu_algorithm_denylist_path(std::string* xla_gpu_algorithm_denylist_path) { if (xla_gpu_algorithm_denylist_path != nullptr) { } else { } _impl_.xla_gpu_algorithm_denylist_path_.SetAllocated(xla_gpu_algorithm_denylist_path, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_gpu_algorithm_denylist_path_.IsDefault()) { _impl_.xla_gpu_algorithm_denylist_path_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_algorithm_denylist_path) } // int64 xla_gpu_all_gather_combine_threshold_bytes = 212; inline void DebugOptions::clear_xla_gpu_all_gather_combine_threshold_bytes() { _impl_.xla_gpu_all_gather_combine_threshold_bytes_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_all_gather_combine_threshold_bytes() const { return _impl_.xla_gpu_all_gather_combine_threshold_bytes_; } inline int64_t DebugOptions::xla_gpu_all_gather_combine_threshold_bytes() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_all_gather_combine_threshold_bytes) return _internal_xla_gpu_all_gather_combine_threshold_bytes(); } inline void DebugOptions::_internal_set_xla_gpu_all_gather_combine_threshold_bytes(int64_t value) { _impl_.xla_gpu_all_gather_combine_threshold_bytes_ = value; } inline void DebugOptions::set_xla_gpu_all_gather_combine_threshold_bytes(int64_t value) { _internal_set_xla_gpu_all_gather_combine_threshold_bytes(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_all_gather_combine_threshold_bytes) } // int32 xla_gpu_all_reduce_blueconnect_num_devices_per_host = 159; inline void DebugOptions::clear_xla_gpu_all_reduce_blueconnect_num_devices_per_host() { _impl_.xla_gpu_all_reduce_blueconnect_num_devices_per_host_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_all_reduce_blueconnect_num_devices_per_host() const { return _impl_.xla_gpu_all_reduce_blueconnect_num_devices_per_host_; } inline int32_t DebugOptions::xla_gpu_all_reduce_blueconnect_num_devices_per_host() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_all_reduce_blueconnect_num_devices_per_host) return _internal_xla_gpu_all_reduce_blueconnect_num_devices_per_host(); } inline void DebugOptions::_internal_set_xla_gpu_all_reduce_blueconnect_num_devices_per_host(int32_t value) { _impl_.xla_gpu_all_reduce_blueconnect_num_devices_per_host_ = value; } inline void DebugOptions::set_xla_gpu_all_reduce_blueconnect_num_devices_per_host(int32_t value) { _internal_set_xla_gpu_all_reduce_blueconnect_num_devices_per_host(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_all_reduce_blueconnect_num_devices_per_host) } // int64 xla_gpu_all_reduce_combine_threshold_bytes = 157; inline void DebugOptions::clear_xla_gpu_all_reduce_combine_threshold_bytes() { _impl_.xla_gpu_all_reduce_combine_threshold_bytes_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_all_reduce_combine_threshold_bytes() const { return _impl_.xla_gpu_all_reduce_combine_threshold_bytes_; } inline int64_t DebugOptions::xla_gpu_all_reduce_combine_threshold_bytes() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_all_reduce_combine_threshold_bytes) return _internal_xla_gpu_all_reduce_combine_threshold_bytes(); } inline void DebugOptions::_internal_set_xla_gpu_all_reduce_combine_threshold_bytes(int64_t value) { _impl_.xla_gpu_all_reduce_combine_threshold_bytes_ = value; } inline void DebugOptions::set_xla_gpu_all_reduce_combine_threshold_bytes(int64_t value) { _internal_set_xla_gpu_all_reduce_combine_threshold_bytes(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_all_reduce_combine_threshold_bytes) } // map xla_gpu_analytical_latency_estimator_options = 357; inline int DebugOptions::_internal_xla_gpu_analytical_latency_estimator_options_size() const { return _impl_.xla_gpu_analytical_latency_estimator_options_.size(); } inline int DebugOptions::xla_gpu_analytical_latency_estimator_options_size() const { return _internal_xla_gpu_analytical_latency_estimator_options_size(); } inline void DebugOptions::clear_xla_gpu_analytical_latency_estimator_options() { _impl_.xla_gpu_analytical_latency_estimator_options_.Clear(); } inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& DebugOptions::_internal_xla_gpu_analytical_latency_estimator_options() const { return _impl_.xla_gpu_analytical_latency_estimator_options_.GetMap(); } inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& DebugOptions::xla_gpu_analytical_latency_estimator_options() const { // @@protoc_insertion_point(field_map:xla.DebugOptions.xla_gpu_analytical_latency_estimator_options) return _internal_xla_gpu_analytical_latency_estimator_options(); } inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* DebugOptions::_internal_mutable_xla_gpu_analytical_latency_estimator_options() { return _impl_.xla_gpu_analytical_latency_estimator_options_.MutableMap(); } inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* DebugOptions::mutable_xla_gpu_analytical_latency_estimator_options() { // @@protoc_insertion_point(field_mutable_map:xla.DebugOptions.xla_gpu_analytical_latency_estimator_options) return _internal_mutable_xla_gpu_analytical_latency_estimator_options(); } // bool xla_gpu_async_dot = 321; inline void DebugOptions::clear_xla_gpu_async_dot() { _impl_.xla_gpu_async_dot_ = false; } inline bool DebugOptions::_internal_xla_gpu_async_dot() const { return _impl_.xla_gpu_async_dot_; } inline bool DebugOptions::xla_gpu_async_dot() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_async_dot) return _internal_xla_gpu_async_dot(); } inline void DebugOptions::_internal_set_xla_gpu_async_dot(bool value) { _impl_.xla_gpu_async_dot_ = value; } inline void DebugOptions::set_xla_gpu_async_dot(bool value) { _internal_set_xla_gpu_async_dot(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_async_dot) } // int32 xla_gpu_auto_spmd_partitioning_memory_budget_gb = 224; inline void DebugOptions::clear_xla_gpu_auto_spmd_partitioning_memory_budget_gb() { _impl_.xla_gpu_auto_spmd_partitioning_memory_budget_gb_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_auto_spmd_partitioning_memory_budget_gb() const { return _impl_.xla_gpu_auto_spmd_partitioning_memory_budget_gb_; } inline int32_t DebugOptions::xla_gpu_auto_spmd_partitioning_memory_budget_gb() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_auto_spmd_partitioning_memory_budget_gb) return _internal_xla_gpu_auto_spmd_partitioning_memory_budget_gb(); } inline void DebugOptions::_internal_set_xla_gpu_auto_spmd_partitioning_memory_budget_gb(int32_t value) { _impl_.xla_gpu_auto_spmd_partitioning_memory_budget_gb_ = value; } inline void DebugOptions::set_xla_gpu_auto_spmd_partitioning_memory_budget_gb(int32_t value) { _internal_set_xla_gpu_auto_spmd_partitioning_memory_budget_gb(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_auto_spmd_partitioning_memory_budget_gb) } // float xla_gpu_auto_spmd_partitioning_memory_budget_ratio = 225; inline void DebugOptions::clear_xla_gpu_auto_spmd_partitioning_memory_budget_ratio() { _impl_.xla_gpu_auto_spmd_partitioning_memory_budget_ratio_ = 0; } inline float DebugOptions::_internal_xla_gpu_auto_spmd_partitioning_memory_budget_ratio() const { return _impl_.xla_gpu_auto_spmd_partitioning_memory_budget_ratio_; } inline float DebugOptions::xla_gpu_auto_spmd_partitioning_memory_budget_ratio() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_auto_spmd_partitioning_memory_budget_ratio) return _internal_xla_gpu_auto_spmd_partitioning_memory_budget_ratio(); } inline void DebugOptions::_internal_set_xla_gpu_auto_spmd_partitioning_memory_budget_ratio(float value) { _impl_.xla_gpu_auto_spmd_partitioning_memory_budget_ratio_ = value; } inline void DebugOptions::set_xla_gpu_auto_spmd_partitioning_memory_budget_ratio(float value) { _internal_set_xla_gpu_auto_spmd_partitioning_memory_budget_ratio(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_auto_spmd_partitioning_memory_budget_ratio) } // float xla_gpu_autotune_gemm_rtol = 316; inline void DebugOptions::clear_xla_gpu_autotune_gemm_rtol() { _impl_.xla_gpu_autotune_gemm_rtol_ = 0; } inline float DebugOptions::_internal_xla_gpu_autotune_gemm_rtol() const { return _impl_.xla_gpu_autotune_gemm_rtol_; } inline float DebugOptions::xla_gpu_autotune_gemm_rtol() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_autotune_gemm_rtol) return _internal_xla_gpu_autotune_gemm_rtol(); } inline void DebugOptions::_internal_set_xla_gpu_autotune_gemm_rtol(float value) { _impl_.xla_gpu_autotune_gemm_rtol_ = value; } inline void DebugOptions::set_xla_gpu_autotune_gemm_rtol(float value) { _internal_set_xla_gpu_autotune_gemm_rtol(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_autotune_gemm_rtol) } // int32 xla_gpu_autotune_level = 123; inline void DebugOptions::clear_xla_gpu_autotune_level() { _impl_.xla_gpu_autotune_level_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_autotune_level() const { return _impl_.xla_gpu_autotune_level_; } inline int32_t DebugOptions::xla_gpu_autotune_level() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_autotune_level) return _internal_xla_gpu_autotune_level(); } inline void DebugOptions::_internal_set_xla_gpu_autotune_level(int32_t value) { _impl_.xla_gpu_autotune_level_ = value; } inline void DebugOptions::set_xla_gpu_autotune_level(int32_t value) { _internal_set_xla_gpu_autotune_level(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_autotune_level) } // int64 xla_gpu_autotune_max_solutions = 288; inline void DebugOptions::clear_xla_gpu_autotune_max_solutions() { _impl_.xla_gpu_autotune_max_solutions_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_autotune_max_solutions() const { return _impl_.xla_gpu_autotune_max_solutions_; } inline int64_t DebugOptions::xla_gpu_autotune_max_solutions() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_autotune_max_solutions) return _internal_xla_gpu_autotune_max_solutions(); } inline void DebugOptions::_internal_set_xla_gpu_autotune_max_solutions(int64_t value) { _impl_.xla_gpu_autotune_max_solutions_ = value; } inline void DebugOptions::set_xla_gpu_autotune_max_solutions(int64_t value) { _internal_set_xla_gpu_autotune_max_solutions(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_autotune_max_solutions) } // bool xla_gpu_collect_cost_model_stats = 240; inline void DebugOptions::clear_xla_gpu_collect_cost_model_stats() { _impl_.xla_gpu_collect_cost_model_stats_ = false; } inline bool DebugOptions::_internal_xla_gpu_collect_cost_model_stats() const { return _impl_.xla_gpu_collect_cost_model_stats_; } inline bool DebugOptions::xla_gpu_collect_cost_model_stats() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_collect_cost_model_stats) return _internal_xla_gpu_collect_cost_model_stats(); } inline void DebugOptions::_internal_set_xla_gpu_collect_cost_model_stats(bool value) { _impl_.xla_gpu_collect_cost_model_stats_ = value; } inline void DebugOptions::set_xla_gpu_collect_cost_model_stats(bool value) { _internal_set_xla_gpu_collect_cost_model_stats(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_collect_cost_model_stats) } // int32 xla_gpu_collective_inflation_factor = 205; inline void DebugOptions::clear_xla_gpu_collective_inflation_factor() { _impl_.xla_gpu_collective_inflation_factor_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_collective_inflation_factor() const { return _impl_.xla_gpu_collective_inflation_factor_; } inline int32_t DebugOptions::xla_gpu_collective_inflation_factor() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_collective_inflation_factor) return _internal_xla_gpu_collective_inflation_factor(); } inline void DebugOptions::_internal_set_xla_gpu_collective_inflation_factor(int32_t value) { _impl_.xla_gpu_collective_inflation_factor_ = value; } inline void DebugOptions::set_xla_gpu_collective_inflation_factor(int32_t value) { _internal_set_xla_gpu_collective_inflation_factor(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_collective_inflation_factor) } // int64 xla_gpu_collective_permute_decomposer_threshold = 237; inline void DebugOptions::clear_xla_gpu_collective_permute_decomposer_threshold() { _impl_.xla_gpu_collective_permute_decomposer_threshold_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_collective_permute_decomposer_threshold() const { return _impl_.xla_gpu_collective_permute_decomposer_threshold_; } inline int64_t DebugOptions::xla_gpu_collective_permute_decomposer_threshold() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_collective_permute_decomposer_threshold) return _internal_xla_gpu_collective_permute_decomposer_threshold(); } inline void DebugOptions::_internal_set_xla_gpu_collective_permute_decomposer_threshold(int64_t value) { _impl_.xla_gpu_collective_permute_decomposer_threshold_ = value; } inline void DebugOptions::set_xla_gpu_collective_permute_decomposer_threshold(int64_t value) { _internal_set_xla_gpu_collective_permute_decomposer_threshold(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_collective_permute_decomposer_threshold) } // bool xla_gpu_collectives_use_persistent_cliques = 354; inline void DebugOptions::clear_xla_gpu_collectives_use_persistent_cliques() { _impl_.xla_gpu_collectives_use_persistent_cliques_ = false; } inline bool DebugOptions::_internal_xla_gpu_collectives_use_persistent_cliques() const { return _impl_.xla_gpu_collectives_use_persistent_cliques_; } inline bool DebugOptions::xla_gpu_collectives_use_persistent_cliques() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_collectives_use_persistent_cliques) return _internal_xla_gpu_collectives_use_persistent_cliques(); } inline void DebugOptions::_internal_set_xla_gpu_collectives_use_persistent_cliques(bool value) { _impl_.xla_gpu_collectives_use_persistent_cliques_ = value; } inline void DebugOptions::set_xla_gpu_collectives_use_persistent_cliques(bool value) { _internal_set_xla_gpu_collectives_use_persistent_cliques(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_collectives_use_persistent_cliques) } // bool xla_gpu_copy_insertion_use_region_analysis = 236; inline void DebugOptions::clear_xla_gpu_copy_insertion_use_region_analysis() { _impl_.xla_gpu_copy_insertion_use_region_analysis_ = false; } inline bool DebugOptions::_internal_xla_gpu_copy_insertion_use_region_analysis() const { return _impl_.xla_gpu_copy_insertion_use_region_analysis_; } inline bool DebugOptions::xla_gpu_copy_insertion_use_region_analysis() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_copy_insertion_use_region_analysis) return _internal_xla_gpu_copy_insertion_use_region_analysis(); } inline void DebugOptions::_internal_set_xla_gpu_copy_insertion_use_region_analysis(bool value) { _impl_.xla_gpu_copy_insertion_use_region_analysis_ = value; } inline void DebugOptions::set_xla_gpu_copy_insertion_use_region_analysis(bool value) { _internal_set_xla_gpu_copy_insertion_use_region_analysis(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_copy_insertion_use_region_analysis) } // bool xla_gpu_crash_on_verification_failures = 101; inline void DebugOptions::clear_xla_gpu_crash_on_verification_failures() { _impl_.xla_gpu_crash_on_verification_failures_ = false; } inline bool DebugOptions::_internal_xla_gpu_crash_on_verification_failures() const { return _impl_.xla_gpu_crash_on_verification_failures_; } inline bool DebugOptions::xla_gpu_crash_on_verification_failures() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_crash_on_verification_failures) return _internal_xla_gpu_crash_on_verification_failures(); } inline void DebugOptions::_internal_set_xla_gpu_crash_on_verification_failures(bool value) { _impl_.xla_gpu_crash_on_verification_failures_ = value; } inline void DebugOptions::set_xla_gpu_crash_on_verification_failures(bool value) { _internal_set_xla_gpu_crash_on_verification_failures(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_crash_on_verification_failures) } // bool xla_gpu_cublas_fallback = 247; inline void DebugOptions::clear_xla_gpu_cublas_fallback() { _impl_.xla_gpu_cublas_fallback_ = false; } inline bool DebugOptions::_internal_xla_gpu_cublas_fallback() const { return _impl_.xla_gpu_cublas_fallback_; } inline bool DebugOptions::xla_gpu_cublas_fallback() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_cublas_fallback) return _internal_xla_gpu_cublas_fallback(); } inline void DebugOptions::_internal_set_xla_gpu_cublas_fallback(bool value) { _impl_.xla_gpu_cublas_fallback_ = value; } inline void DebugOptions::set_xla_gpu_cublas_fallback(bool value) { _internal_set_xla_gpu_cublas_fallback(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_cublas_fallback) } // string xla_gpu_cuda_data_dir = 61; inline void DebugOptions::clear_xla_gpu_cuda_data_dir() { _impl_.xla_gpu_cuda_data_dir_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_gpu_cuda_data_dir() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_cuda_data_dir) return _internal_xla_gpu_cuda_data_dir(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_cuda_data_dir(ArgT0&& arg0, ArgT... args) { _impl_.xla_gpu_cuda_data_dir_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_cuda_data_dir) } inline std::string* DebugOptions::mutable_xla_gpu_cuda_data_dir() { std::string* _s = _internal_mutable_xla_gpu_cuda_data_dir(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_cuda_data_dir) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_cuda_data_dir() const { return _impl_.xla_gpu_cuda_data_dir_.Get(); } inline void DebugOptions::_internal_set_xla_gpu_cuda_data_dir(const std::string& value) { _impl_.xla_gpu_cuda_data_dir_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_gpu_cuda_data_dir() { return _impl_.xla_gpu_cuda_data_dir_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_gpu_cuda_data_dir() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_cuda_data_dir) return _impl_.xla_gpu_cuda_data_dir_.Release(); } inline void DebugOptions::set_allocated_xla_gpu_cuda_data_dir(std::string* xla_gpu_cuda_data_dir) { if (xla_gpu_cuda_data_dir != nullptr) { } else { } _impl_.xla_gpu_cuda_data_dir_.SetAllocated(xla_gpu_cuda_data_dir, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_gpu_cuda_data_dir_.IsDefault()) { _impl_.xla_gpu_cuda_data_dir_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_cuda_data_dir) } // int32 xla_gpu_cudnn_gemm_fusion_level = 285; inline void DebugOptions::clear_xla_gpu_cudnn_gemm_fusion_level() { _impl_.xla_gpu_cudnn_gemm_fusion_level_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_cudnn_gemm_fusion_level() const { return _impl_.xla_gpu_cudnn_gemm_fusion_level_; } inline int32_t DebugOptions::xla_gpu_cudnn_gemm_fusion_level() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_cudnn_gemm_fusion_level) return _internal_xla_gpu_cudnn_gemm_fusion_level(); } inline void DebugOptions::_internal_set_xla_gpu_cudnn_gemm_fusion_level(int32_t value) { _impl_.xla_gpu_cudnn_gemm_fusion_level_ = value; } inline void DebugOptions::set_xla_gpu_cudnn_gemm_fusion_level(int32_t value) { _internal_set_xla_gpu_cudnn_gemm_fusion_level(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_cudnn_gemm_fusion_level) } // int32 xla_gpu_cudnn_gemm_max_plans = 318; inline void DebugOptions::clear_xla_gpu_cudnn_gemm_max_plans() { _impl_.xla_gpu_cudnn_gemm_max_plans_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_cudnn_gemm_max_plans() const { return _impl_.xla_gpu_cudnn_gemm_max_plans_; } inline int32_t DebugOptions::xla_gpu_cudnn_gemm_max_plans() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_cudnn_gemm_max_plans) return _internal_xla_gpu_cudnn_gemm_max_plans(); } inline void DebugOptions::_internal_set_xla_gpu_cudnn_gemm_max_plans(int32_t value) { _impl_.xla_gpu_cudnn_gemm_max_plans_ = value; } inline void DebugOptions::set_xla_gpu_cudnn_gemm_max_plans(int32_t value) { _internal_set_xla_gpu_cudnn_gemm_max_plans(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_cudnn_gemm_max_plans) } // bool xla_gpu_deterministic_ops = 148; inline void DebugOptions::clear_xla_gpu_deterministic_ops() { _impl_.xla_gpu_deterministic_ops_ = false; } inline bool DebugOptions::_internal_xla_gpu_deterministic_ops() const { return _impl_.xla_gpu_deterministic_ops_; } inline bool DebugOptions::xla_gpu_deterministic_ops() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_deterministic_ops) return _internal_xla_gpu_deterministic_ops(); } inline void DebugOptions::_internal_set_xla_gpu_deterministic_ops(bool value) { _impl_.xla_gpu_deterministic_ops_ = value; } inline void DebugOptions::set_xla_gpu_deterministic_ops(bool value) { _internal_set_xla_gpu_deterministic_ops(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_deterministic_ops) } // repeated .xla.DebugOptions.CollectiveOpType xla_gpu_disable_async_collectives = 289; inline int DebugOptions::_internal_xla_gpu_disable_async_collectives_size() const { return _impl_.xla_gpu_disable_async_collectives_.size(); } inline int DebugOptions::xla_gpu_disable_async_collectives_size() const { return _internal_xla_gpu_disable_async_collectives_size(); } inline void DebugOptions::clear_xla_gpu_disable_async_collectives() { _impl_.xla_gpu_disable_async_collectives_.Clear(); } inline ::xla::DebugOptions_CollectiveOpType DebugOptions::_internal_xla_gpu_disable_async_collectives(int index) const { return static_cast< ::xla::DebugOptions_CollectiveOpType >(_impl_.xla_gpu_disable_async_collectives_.Get(index)); } inline ::xla::DebugOptions_CollectiveOpType DebugOptions::xla_gpu_disable_async_collectives(int index) const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_disable_async_collectives) return _internal_xla_gpu_disable_async_collectives(index); } inline void DebugOptions::set_xla_gpu_disable_async_collectives(int index, ::xla::DebugOptions_CollectiveOpType value) { _impl_.xla_gpu_disable_async_collectives_.Set(index, value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_disable_async_collectives) } inline void DebugOptions::_internal_add_xla_gpu_disable_async_collectives(::xla::DebugOptions_CollectiveOpType value) { _impl_.xla_gpu_disable_async_collectives_.Add(value); } inline void DebugOptions::add_xla_gpu_disable_async_collectives(::xla::DebugOptions_CollectiveOpType value) { _internal_add_xla_gpu_disable_async_collectives(value); // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_gpu_disable_async_collectives) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& DebugOptions::xla_gpu_disable_async_collectives() const { // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_gpu_disable_async_collectives) return _impl_.xla_gpu_disable_async_collectives_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* DebugOptions::_internal_mutable_xla_gpu_disable_async_collectives() { return &_impl_.xla_gpu_disable_async_collectives_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* DebugOptions::mutable_xla_gpu_disable_async_collectives() { // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_gpu_disable_async_collectives) return _internal_mutable_xla_gpu_disable_async_collectives(); } // bool xla_gpu_disable_gpuasm_optimizations = 103; inline void DebugOptions::clear_xla_gpu_disable_gpuasm_optimizations() { _impl_.xla_gpu_disable_gpuasm_optimizations_ = false; } inline bool DebugOptions::_internal_xla_gpu_disable_gpuasm_optimizations() const { return _impl_.xla_gpu_disable_gpuasm_optimizations_; } inline bool DebugOptions::xla_gpu_disable_gpuasm_optimizations() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_disable_gpuasm_optimizations) return _internal_xla_gpu_disable_gpuasm_optimizations(); } inline void DebugOptions::_internal_set_xla_gpu_disable_gpuasm_optimizations(bool value) { _impl_.xla_gpu_disable_gpuasm_optimizations_ = value; } inline void DebugOptions::set_xla_gpu_disable_gpuasm_optimizations(bool value) { _internal_set_xla_gpu_disable_gpuasm_optimizations(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_disable_gpuasm_optimizations) } // int32 xla_gpu_dot_merger_threshold_mb = 331; inline void DebugOptions::clear_xla_gpu_dot_merger_threshold_mb() { _impl_.xla_gpu_dot_merger_threshold_mb_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_dot_merger_threshold_mb() const { return _impl_.xla_gpu_dot_merger_threshold_mb_; } inline int32_t DebugOptions::xla_gpu_dot_merger_threshold_mb() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_dot_merger_threshold_mb) return _internal_xla_gpu_dot_merger_threshold_mb(); } inline void DebugOptions::_internal_set_xla_gpu_dot_merger_threshold_mb(int32_t value) { _impl_.xla_gpu_dot_merger_threshold_mb_ = value; } inline void DebugOptions::set_xla_gpu_dot_merger_threshold_mb(int32_t value) { _internal_set_xla_gpu_dot_merger_threshold_mb(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_dot_merger_threshold_mb) } // string xla_gpu_dump_autotune_logs_to = 292; inline void DebugOptions::clear_xla_gpu_dump_autotune_logs_to() { _impl_.xla_gpu_dump_autotune_logs_to_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_gpu_dump_autotune_logs_to() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_dump_autotune_logs_to) return _internal_xla_gpu_dump_autotune_logs_to(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_dump_autotune_logs_to(ArgT0&& arg0, ArgT... args) { _impl_.xla_gpu_dump_autotune_logs_to_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_dump_autotune_logs_to) } inline std::string* DebugOptions::mutable_xla_gpu_dump_autotune_logs_to() { std::string* _s = _internal_mutable_xla_gpu_dump_autotune_logs_to(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_dump_autotune_logs_to) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_dump_autotune_logs_to() const { return _impl_.xla_gpu_dump_autotune_logs_to_.Get(); } inline void DebugOptions::_internal_set_xla_gpu_dump_autotune_logs_to(const std::string& value) { _impl_.xla_gpu_dump_autotune_logs_to_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_gpu_dump_autotune_logs_to() { return _impl_.xla_gpu_dump_autotune_logs_to_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_gpu_dump_autotune_logs_to() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_dump_autotune_logs_to) return _impl_.xla_gpu_dump_autotune_logs_to_.Release(); } inline void DebugOptions::set_allocated_xla_gpu_dump_autotune_logs_to(std::string* xla_gpu_dump_autotune_logs_to) { if (xla_gpu_dump_autotune_logs_to != nullptr) { } else { } _impl_.xla_gpu_dump_autotune_logs_to_.SetAllocated(xla_gpu_dump_autotune_logs_to, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_gpu_dump_autotune_logs_to_.IsDefault()) { _impl_.xla_gpu_dump_autotune_logs_to_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_dump_autotune_logs_to) } // string xla_gpu_dump_autotune_results_to = 222; inline void DebugOptions::clear_xla_gpu_dump_autotune_results_to() { _impl_.xla_gpu_dump_autotune_results_to_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_gpu_dump_autotune_results_to() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_dump_autotune_results_to) return _internal_xla_gpu_dump_autotune_results_to(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_dump_autotune_results_to(ArgT0&& arg0, ArgT... args) { _impl_.xla_gpu_dump_autotune_results_to_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_dump_autotune_results_to) } inline std::string* DebugOptions::mutable_xla_gpu_dump_autotune_results_to() { std::string* _s = _internal_mutable_xla_gpu_dump_autotune_results_to(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_dump_autotune_results_to) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_dump_autotune_results_to() const { return _impl_.xla_gpu_dump_autotune_results_to_.Get(); } inline void DebugOptions::_internal_set_xla_gpu_dump_autotune_results_to(const std::string& value) { _impl_.xla_gpu_dump_autotune_results_to_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_gpu_dump_autotune_results_to() { return _impl_.xla_gpu_dump_autotune_results_to_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_gpu_dump_autotune_results_to() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_dump_autotune_results_to) return _impl_.xla_gpu_dump_autotune_results_to_.Release(); } inline void DebugOptions::set_allocated_xla_gpu_dump_autotune_results_to(std::string* xla_gpu_dump_autotune_results_to) { if (xla_gpu_dump_autotune_results_to != nullptr) { } else { } _impl_.xla_gpu_dump_autotune_results_to_.SetAllocated(xla_gpu_dump_autotune_results_to, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_gpu_dump_autotune_results_to_.IsDefault()) { _impl_.xla_gpu_dump_autotune_results_to_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_dump_autotune_results_to) } // bool xla_gpu_dump_autotuned_gemm_fusions = 232; inline void DebugOptions::clear_xla_gpu_dump_autotuned_gemm_fusions() { _impl_.xla_gpu_dump_autotuned_gemm_fusions_ = false; } inline bool DebugOptions::_internal_xla_gpu_dump_autotuned_gemm_fusions() const { return _impl_.xla_gpu_dump_autotuned_gemm_fusions_; } inline bool DebugOptions::xla_gpu_dump_autotuned_gemm_fusions() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_dump_autotuned_gemm_fusions) return _internal_xla_gpu_dump_autotuned_gemm_fusions(); } inline void DebugOptions::_internal_set_xla_gpu_dump_autotuned_gemm_fusions(bool value) { _impl_.xla_gpu_dump_autotuned_gemm_fusions_ = value; } inline void DebugOptions::set_xla_gpu_dump_autotuned_gemm_fusions(bool value) { _internal_set_xla_gpu_dump_autotuned_gemm_fusions(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_dump_autotuned_gemm_fusions) } // bool xla_gpu_dump_hlo_unoptimized_snapshots = 352; inline void DebugOptions::clear_xla_gpu_dump_hlo_unoptimized_snapshots() { _impl_.xla_gpu_dump_hlo_unoptimized_snapshots_ = false; } inline bool DebugOptions::_internal_xla_gpu_dump_hlo_unoptimized_snapshots() const { return _impl_.xla_gpu_dump_hlo_unoptimized_snapshots_; } inline bool DebugOptions::xla_gpu_dump_hlo_unoptimized_snapshots() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_dump_hlo_unoptimized_snapshots) return _internal_xla_gpu_dump_hlo_unoptimized_snapshots(); } inline void DebugOptions::_internal_set_xla_gpu_dump_hlo_unoptimized_snapshots(bool value) { _impl_.xla_gpu_dump_hlo_unoptimized_snapshots_ = value; } inline void DebugOptions::set_xla_gpu_dump_hlo_unoptimized_snapshots(bool value) { _internal_set_xla_gpu_dump_hlo_unoptimized_snapshots(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_dump_hlo_unoptimized_snapshots) } // bool xla_gpu_dump_llvmir = 155; inline void DebugOptions::clear_xla_gpu_dump_llvmir() { _impl_.xla_gpu_dump_llvmir_ = false; } inline bool DebugOptions::_internal_xla_gpu_dump_llvmir() const { return _impl_.xla_gpu_dump_llvmir_; } inline bool DebugOptions::xla_gpu_dump_llvmir() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_dump_llvmir) return _internal_xla_gpu_dump_llvmir(); } inline void DebugOptions::_internal_set_xla_gpu_dump_llvmir(bool value) { _impl_.xla_gpu_dump_llvmir_ = value; } inline void DebugOptions::set_xla_gpu_dump_llvmir(bool value) { _internal_set_xla_gpu_dump_llvmir(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_dump_llvmir) } // bool xla_gpu_enable_all_gather_combine_by_dim = 254; inline void DebugOptions::clear_xla_gpu_enable_all_gather_combine_by_dim() { _impl_.xla_gpu_enable_all_gather_combine_by_dim_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_all_gather_combine_by_dim() const { return _impl_.xla_gpu_enable_all_gather_combine_by_dim_; } inline bool DebugOptions::xla_gpu_enable_all_gather_combine_by_dim() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_all_gather_combine_by_dim) return _internal_xla_gpu_enable_all_gather_combine_by_dim(); } inline void DebugOptions::_internal_set_xla_gpu_enable_all_gather_combine_by_dim(bool value) { _impl_.xla_gpu_enable_all_gather_combine_by_dim_ = value; } inline void DebugOptions::set_xla_gpu_enable_all_gather_combine_by_dim(bool value) { _internal_set_xla_gpu_enable_all_gather_combine_by_dim(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_all_gather_combine_by_dim) } // bool xla_gpu_enable_analytical_latency_estimator = 255; inline void DebugOptions::clear_xla_gpu_enable_analytical_latency_estimator() { _impl_.xla_gpu_enable_analytical_latency_estimator_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_analytical_latency_estimator() const { return _impl_.xla_gpu_enable_analytical_latency_estimator_; } inline bool DebugOptions::xla_gpu_enable_analytical_latency_estimator() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_analytical_latency_estimator) return _internal_xla_gpu_enable_analytical_latency_estimator(); } inline void DebugOptions::_internal_set_xla_gpu_enable_analytical_latency_estimator(bool value) { _impl_.xla_gpu_enable_analytical_latency_estimator_ = value; } inline void DebugOptions::set_xla_gpu_enable_analytical_latency_estimator(bool value) { _internal_set_xla_gpu_enable_analytical_latency_estimator(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_analytical_latency_estimator) } // bool xla_gpu_enable_analytical_sol_latency_estimator = 356; inline void DebugOptions::clear_xla_gpu_enable_analytical_sol_latency_estimator() { _impl_.xla_gpu_enable_analytical_sol_latency_estimator_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_analytical_sol_latency_estimator() const { return _impl_.xla_gpu_enable_analytical_sol_latency_estimator_; } inline bool DebugOptions::xla_gpu_enable_analytical_sol_latency_estimator() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_analytical_sol_latency_estimator) return _internal_xla_gpu_enable_analytical_sol_latency_estimator(); } inline void DebugOptions::_internal_set_xla_gpu_enable_analytical_sol_latency_estimator(bool value) { _impl_.xla_gpu_enable_analytical_sol_latency_estimator_ = value; } inline void DebugOptions::set_xla_gpu_enable_analytical_sol_latency_estimator(bool value) { _internal_set_xla_gpu_enable_analytical_sol_latency_estimator(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_analytical_sol_latency_estimator) } // bool xla_gpu_enable_approx_costly_collectives = 305; inline void DebugOptions::clear_xla_gpu_enable_approx_costly_collectives() { _impl_.xla_gpu_enable_approx_costly_collectives_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_approx_costly_collectives() const { return _impl_.xla_gpu_enable_approx_costly_collectives_; } inline bool DebugOptions::xla_gpu_enable_approx_costly_collectives() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_approx_costly_collectives) return _internal_xla_gpu_enable_approx_costly_collectives(); } inline void DebugOptions::_internal_set_xla_gpu_enable_approx_costly_collectives(bool value) { _impl_.xla_gpu_enable_approx_costly_collectives_ = value; } inline void DebugOptions::set_xla_gpu_enable_approx_costly_collectives(bool value) { _internal_set_xla_gpu_enable_approx_costly_collectives(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_approx_costly_collectives) } // repeated .xla.DebugOptions.CommandBufferCmdType xla_gpu_enable_command_buffer = 258; inline int DebugOptions::_internal_xla_gpu_enable_command_buffer_size() const { return _impl_.xla_gpu_enable_command_buffer_.size(); } inline int DebugOptions::xla_gpu_enable_command_buffer_size() const { return _internal_xla_gpu_enable_command_buffer_size(); } inline void DebugOptions::clear_xla_gpu_enable_command_buffer() { _impl_.xla_gpu_enable_command_buffer_.Clear(); } inline ::xla::DebugOptions_CommandBufferCmdType DebugOptions::_internal_xla_gpu_enable_command_buffer(int index) const { return static_cast< ::xla::DebugOptions_CommandBufferCmdType >(_impl_.xla_gpu_enable_command_buffer_.Get(index)); } inline ::xla::DebugOptions_CommandBufferCmdType DebugOptions::xla_gpu_enable_command_buffer(int index) const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_command_buffer) return _internal_xla_gpu_enable_command_buffer(index); } inline void DebugOptions::set_xla_gpu_enable_command_buffer(int index, ::xla::DebugOptions_CommandBufferCmdType value) { _impl_.xla_gpu_enable_command_buffer_.Set(index, value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_command_buffer) } inline void DebugOptions::_internal_add_xla_gpu_enable_command_buffer(::xla::DebugOptions_CommandBufferCmdType value) { _impl_.xla_gpu_enable_command_buffer_.Add(value); } inline void DebugOptions::add_xla_gpu_enable_command_buffer(::xla::DebugOptions_CommandBufferCmdType value) { _internal_add_xla_gpu_enable_command_buffer(value); // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_gpu_enable_command_buffer) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField& DebugOptions::xla_gpu_enable_command_buffer() const { // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_gpu_enable_command_buffer) return _impl_.xla_gpu_enable_command_buffer_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* DebugOptions::_internal_mutable_xla_gpu_enable_command_buffer() { return &_impl_.xla_gpu_enable_command_buffer_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField* DebugOptions::mutable_xla_gpu_enable_command_buffer() { // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_gpu_enable_command_buffer) return _internal_mutable_xla_gpu_enable_command_buffer(); } // bool xla_gpu_enable_cub_radix_sort = 259; inline void DebugOptions::clear_xla_gpu_enable_cub_radix_sort() { _impl_.xla_gpu_enable_cub_radix_sort_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_cub_radix_sort() const { return _impl_.xla_gpu_enable_cub_radix_sort_; } inline bool DebugOptions::xla_gpu_enable_cub_radix_sort() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_cub_radix_sort) return _internal_xla_gpu_enable_cub_radix_sort(); } inline void DebugOptions::_internal_set_xla_gpu_enable_cub_radix_sort(bool value) { _impl_.xla_gpu_enable_cub_radix_sort_ = value; } inline void DebugOptions::set_xla_gpu_enable_cub_radix_sort(bool value) { _internal_set_xla_gpu_enable_cub_radix_sort(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_cub_radix_sort) } // bool xla_gpu_enable_cublaslt = 166; inline void DebugOptions::clear_xla_gpu_enable_cublaslt() { _impl_.xla_gpu_enable_cublaslt_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_cublaslt() const { return _impl_.xla_gpu_enable_cublaslt_; } inline bool DebugOptions::xla_gpu_enable_cublaslt() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_cublaslt) return _internal_xla_gpu_enable_cublaslt(); } inline void DebugOptions::_internal_set_xla_gpu_enable_cublaslt(bool value) { _impl_.xla_gpu_enable_cublaslt_ = value; } inline void DebugOptions::set_xla_gpu_enable_cublaslt(bool value) { _internal_set_xla_gpu_enable_cublaslt(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_cublaslt) } // bool xla_gpu_enable_cudnn_frontend = 160; inline void DebugOptions::clear_xla_gpu_enable_cudnn_frontend() { _impl_.xla_gpu_enable_cudnn_frontend_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_cudnn_frontend() const { return _impl_.xla_gpu_enable_cudnn_frontend_; } inline bool DebugOptions::xla_gpu_enable_cudnn_frontend() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_cudnn_frontend) return _internal_xla_gpu_enable_cudnn_frontend(); } inline void DebugOptions::_internal_set_xla_gpu_enable_cudnn_frontend(bool value) { _impl_.xla_gpu_enable_cudnn_frontend_ = value; } inline void DebugOptions::set_xla_gpu_enable_cudnn_frontend(bool value) { _internal_set_xla_gpu_enable_cudnn_frontend(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_cudnn_frontend) } // bool xla_gpu_enable_cudnn_int8x32_convolution_reordering = 189; inline void DebugOptions::clear_xla_gpu_enable_cudnn_int8x32_convolution_reordering() { _impl_.xla_gpu_enable_cudnn_int8x32_convolution_reordering_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_cudnn_int8x32_convolution_reordering() const { return _impl_.xla_gpu_enable_cudnn_int8x32_convolution_reordering_; } inline bool DebugOptions::xla_gpu_enable_cudnn_int8x32_convolution_reordering() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_cudnn_int8x32_convolution_reordering) return _internal_xla_gpu_enable_cudnn_int8x32_convolution_reordering(); } inline void DebugOptions::_internal_set_xla_gpu_enable_cudnn_int8x32_convolution_reordering(bool value) { _impl_.xla_gpu_enable_cudnn_int8x32_convolution_reordering_ = value; } inline void DebugOptions::set_xla_gpu_enable_cudnn_int8x32_convolution_reordering(bool value) { _internal_set_xla_gpu_enable_cudnn_int8x32_convolution_reordering(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_cudnn_int8x32_convolution_reordering) } // bool xla_gpu_enable_cudnn_layer_norm = 262; inline void DebugOptions::clear_xla_gpu_enable_cudnn_layer_norm() { _impl_.xla_gpu_enable_cudnn_layer_norm_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_cudnn_layer_norm() const { return _impl_.xla_gpu_enable_cudnn_layer_norm_; } inline bool DebugOptions::xla_gpu_enable_cudnn_layer_norm() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_cudnn_layer_norm) return _internal_xla_gpu_enable_cudnn_layer_norm(); } inline void DebugOptions::_internal_set_xla_gpu_enable_cudnn_layer_norm(bool value) { _impl_.xla_gpu_enable_cudnn_layer_norm_ = value; } inline void DebugOptions::set_xla_gpu_enable_cudnn_layer_norm(bool value) { _internal_set_xla_gpu_enable_cudnn_layer_norm(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_cudnn_layer_norm) } // bool xla_gpu_enable_custom_fusions = 263; inline void DebugOptions::clear_xla_gpu_enable_custom_fusions() { _impl_.xla_gpu_enable_custom_fusions_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_custom_fusions() const { return _impl_.xla_gpu_enable_custom_fusions_; } inline bool DebugOptions::xla_gpu_enable_custom_fusions() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_custom_fusions) return _internal_xla_gpu_enable_custom_fusions(); } inline void DebugOptions::_internal_set_xla_gpu_enable_custom_fusions(bool value) { _impl_.xla_gpu_enable_custom_fusions_ = value; } inline void DebugOptions::set_xla_gpu_enable_custom_fusions(bool value) { _internal_set_xla_gpu_enable_custom_fusions(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_custom_fusions) } // string xla_gpu_enable_custom_fusions_re = 264; inline void DebugOptions::clear_xla_gpu_enable_custom_fusions_re() { _impl_.xla_gpu_enable_custom_fusions_re_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_gpu_enable_custom_fusions_re() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_custom_fusions_re) return _internal_xla_gpu_enable_custom_fusions_re(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_enable_custom_fusions_re(ArgT0&& arg0, ArgT... args) { _impl_.xla_gpu_enable_custom_fusions_re_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_custom_fusions_re) } inline std::string* DebugOptions::mutable_xla_gpu_enable_custom_fusions_re() { std::string* _s = _internal_mutable_xla_gpu_enable_custom_fusions_re(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_enable_custom_fusions_re) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_enable_custom_fusions_re() const { return _impl_.xla_gpu_enable_custom_fusions_re_.Get(); } inline void DebugOptions::_internal_set_xla_gpu_enable_custom_fusions_re(const std::string& value) { _impl_.xla_gpu_enable_custom_fusions_re_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_gpu_enable_custom_fusions_re() { return _impl_.xla_gpu_enable_custom_fusions_re_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_gpu_enable_custom_fusions_re() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_enable_custom_fusions_re) return _impl_.xla_gpu_enable_custom_fusions_re_.Release(); } inline void DebugOptions::set_allocated_xla_gpu_enable_custom_fusions_re(std::string* xla_gpu_enable_custom_fusions_re) { if (xla_gpu_enable_custom_fusions_re != nullptr) { } else { } _impl_.xla_gpu_enable_custom_fusions_re_.SetAllocated(xla_gpu_enable_custom_fusions_re, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_gpu_enable_custom_fusions_re_.IsDefault()) { _impl_.xla_gpu_enable_custom_fusions_re_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_enable_custom_fusions_re) } // bool xla_gpu_enable_dynamic_slice_fusion = 105; inline void DebugOptions::clear_xla_gpu_enable_dynamic_slice_fusion() { _impl_.xla_gpu_enable_dynamic_slice_fusion_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_dynamic_slice_fusion() const { return _impl_.xla_gpu_enable_dynamic_slice_fusion_; } inline bool DebugOptions::xla_gpu_enable_dynamic_slice_fusion() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_dynamic_slice_fusion) return _internal_xla_gpu_enable_dynamic_slice_fusion(); } inline void DebugOptions::_internal_set_xla_gpu_enable_dynamic_slice_fusion(bool value) { _impl_.xla_gpu_enable_dynamic_slice_fusion_ = value; } inline void DebugOptions::set_xla_gpu_enable_dynamic_slice_fusion(bool value) { _internal_set_xla_gpu_enable_dynamic_slice_fusion(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_dynamic_slice_fusion) } // bool xla_gpu_enable_fast_min_max = 100; inline void DebugOptions::clear_xla_gpu_enable_fast_min_max() { _impl_.xla_gpu_enable_fast_min_max_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_fast_min_max() const { return _impl_.xla_gpu_enable_fast_min_max_; } inline bool DebugOptions::xla_gpu_enable_fast_min_max() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_fast_min_max) return _internal_xla_gpu_enable_fast_min_max(); } inline void DebugOptions::_internal_set_xla_gpu_enable_fast_min_max(bool value) { _impl_.xla_gpu_enable_fast_min_max_ = value; } inline void DebugOptions::set_xla_gpu_enable_fast_min_max(bool value) { _internal_set_xla_gpu_enable_fast_min_max(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_fast_min_max) } // bool xla_gpu_enable_highest_priority_async_stream = 216; inline void DebugOptions::clear_xla_gpu_enable_highest_priority_async_stream() { _impl_.xla_gpu_enable_highest_priority_async_stream_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_highest_priority_async_stream() const { return _impl_.xla_gpu_enable_highest_priority_async_stream_; } inline bool DebugOptions::xla_gpu_enable_highest_priority_async_stream() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_highest_priority_async_stream) return _internal_xla_gpu_enable_highest_priority_async_stream(); } inline void DebugOptions::_internal_set_xla_gpu_enable_highest_priority_async_stream(bool value) { _impl_.xla_gpu_enable_highest_priority_async_stream_ = value; } inline void DebugOptions::set_xla_gpu_enable_highest_priority_async_stream(bool value) { _internal_set_xla_gpu_enable_highest_priority_async_stream(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_highest_priority_async_stream) } // bool xla_gpu_enable_host_memory_offloading = 296; inline void DebugOptions::clear_xla_gpu_enable_host_memory_offloading() { _impl_.xla_gpu_enable_host_memory_offloading_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_host_memory_offloading() const { return _impl_.xla_gpu_enable_host_memory_offloading_; } inline bool DebugOptions::xla_gpu_enable_host_memory_offloading() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_host_memory_offloading) return _internal_xla_gpu_enable_host_memory_offloading(); } inline void DebugOptions::_internal_set_xla_gpu_enable_host_memory_offloading(bool value) { _impl_.xla_gpu_enable_host_memory_offloading_ = value; } inline void DebugOptions::set_xla_gpu_enable_host_memory_offloading(bool value) { _internal_set_xla_gpu_enable_host_memory_offloading(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_host_memory_offloading) } // bool xla_gpu_enable_latency_hiding_scheduler = 186; inline void DebugOptions::clear_xla_gpu_enable_latency_hiding_scheduler() { _impl_.xla_gpu_enable_latency_hiding_scheduler_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_latency_hiding_scheduler() const { return _impl_.xla_gpu_enable_latency_hiding_scheduler_; } inline bool DebugOptions::xla_gpu_enable_latency_hiding_scheduler() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_latency_hiding_scheduler) return _internal_xla_gpu_enable_latency_hiding_scheduler(); } inline void DebugOptions::_internal_set_xla_gpu_enable_latency_hiding_scheduler(bool value) { _impl_.xla_gpu_enable_latency_hiding_scheduler_ = value; } inline void DebugOptions::set_xla_gpu_enable_latency_hiding_scheduler(bool value) { _internal_set_xla_gpu_enable_latency_hiding_scheduler(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_latency_hiding_scheduler) } // bool xla_gpu_enable_libnvptxcompiler = 269; inline void DebugOptions::clear_xla_gpu_enable_libnvptxcompiler() { _impl_.xla_gpu_enable_libnvptxcompiler_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_libnvptxcompiler() const { return _impl_.xla_gpu_enable_libnvptxcompiler_; } inline bool DebugOptions::xla_gpu_enable_libnvptxcompiler() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_libnvptxcompiler) return _internal_xla_gpu_enable_libnvptxcompiler(); } inline void DebugOptions::_internal_set_xla_gpu_enable_libnvptxcompiler(bool value) { _impl_.xla_gpu_enable_libnvptxcompiler_ = value; } inline void DebugOptions::set_xla_gpu_enable_libnvptxcompiler(bool value) { _internal_set_xla_gpu_enable_libnvptxcompiler(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_libnvptxcompiler) } // bool xla_gpu_enable_llvm_module_compilation_parallelism = 268; inline void DebugOptions::clear_xla_gpu_enable_llvm_module_compilation_parallelism() { _impl_.xla_gpu_enable_llvm_module_compilation_parallelism_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_llvm_module_compilation_parallelism() const { return _impl_.xla_gpu_enable_llvm_module_compilation_parallelism_; } inline bool DebugOptions::xla_gpu_enable_llvm_module_compilation_parallelism() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_llvm_module_compilation_parallelism) return _internal_xla_gpu_enable_llvm_module_compilation_parallelism(); } inline void DebugOptions::_internal_set_xla_gpu_enable_llvm_module_compilation_parallelism(bool value) { _impl_.xla_gpu_enable_llvm_module_compilation_parallelism_ = value; } inline void DebugOptions::set_xla_gpu_enable_llvm_module_compilation_parallelism(bool value) { _internal_set_xla_gpu_enable_llvm_module_compilation_parallelism(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_llvm_module_compilation_parallelism) } // bool xla_gpu_enable_nccl_clique_optimization = 244; inline void DebugOptions::clear_xla_gpu_enable_nccl_clique_optimization() { _impl_.xla_gpu_enable_nccl_clique_optimization_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_nccl_clique_optimization() const { return _impl_.xla_gpu_enable_nccl_clique_optimization_; } inline bool DebugOptions::xla_gpu_enable_nccl_clique_optimization() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_nccl_clique_optimization) return _internal_xla_gpu_enable_nccl_clique_optimization(); } inline void DebugOptions::_internal_set_xla_gpu_enable_nccl_clique_optimization(bool value) { _impl_.xla_gpu_enable_nccl_clique_optimization_ = value; } inline void DebugOptions::set_xla_gpu_enable_nccl_clique_optimization(bool value) { _internal_set_xla_gpu_enable_nccl_clique_optimization(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_nccl_clique_optimization) } // bool xla_gpu_enable_nccl_comm_splitting = 272; inline void DebugOptions::clear_xla_gpu_enable_nccl_comm_splitting() { _impl_.xla_gpu_enable_nccl_comm_splitting_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_nccl_comm_splitting() const { return _impl_.xla_gpu_enable_nccl_comm_splitting_; } inline bool DebugOptions::xla_gpu_enable_nccl_comm_splitting() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_nccl_comm_splitting) return _internal_xla_gpu_enable_nccl_comm_splitting(); } inline void DebugOptions::_internal_set_xla_gpu_enable_nccl_comm_splitting(bool value) { _impl_.xla_gpu_enable_nccl_comm_splitting_ = value; } inline void DebugOptions::set_xla_gpu_enable_nccl_comm_splitting(bool value) { _internal_set_xla_gpu_enable_nccl_comm_splitting(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_nccl_comm_splitting) } // bool xla_gpu_enable_nccl_per_stream_comms = 276; inline void DebugOptions::clear_xla_gpu_enable_nccl_per_stream_comms() { _impl_.xla_gpu_enable_nccl_per_stream_comms_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_nccl_per_stream_comms() const { return _impl_.xla_gpu_enable_nccl_per_stream_comms_; } inline bool DebugOptions::xla_gpu_enable_nccl_per_stream_comms() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_nccl_per_stream_comms) return _internal_xla_gpu_enable_nccl_per_stream_comms(); } inline void DebugOptions::_internal_set_xla_gpu_enable_nccl_per_stream_comms(bool value) { _impl_.xla_gpu_enable_nccl_per_stream_comms_ = value; } inline void DebugOptions::set_xla_gpu_enable_nccl_per_stream_comms(bool value) { _internal_set_xla_gpu_enable_nccl_per_stream_comms(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_nccl_per_stream_comms) } // bool xla_gpu_enable_nccl_user_buffers = 267; inline void DebugOptions::clear_xla_gpu_enable_nccl_user_buffers() { _impl_.xla_gpu_enable_nccl_user_buffers_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_nccl_user_buffers() const { return _impl_.xla_gpu_enable_nccl_user_buffers_; } inline bool DebugOptions::xla_gpu_enable_nccl_user_buffers() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_nccl_user_buffers) return _internal_xla_gpu_enable_nccl_user_buffers(); } inline void DebugOptions::_internal_set_xla_gpu_enable_nccl_user_buffers(bool value) { _impl_.xla_gpu_enable_nccl_user_buffers_ = value; } inline void DebugOptions::set_xla_gpu_enable_nccl_user_buffers(bool value) { _internal_set_xla_gpu_enable_nccl_user_buffers(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_nccl_user_buffers) } // bool xla_gpu_enable_pipelined_all_gather = 227; inline void DebugOptions::clear_xla_gpu_enable_pipelined_all_gather() { _impl_.xla_gpu_enable_pipelined_all_gather_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_pipelined_all_gather() const { return _impl_.xla_gpu_enable_pipelined_all_gather_; } inline bool DebugOptions::xla_gpu_enable_pipelined_all_gather() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_pipelined_all_gather) return _internal_xla_gpu_enable_pipelined_all_gather(); } inline void DebugOptions::_internal_set_xla_gpu_enable_pipelined_all_gather(bool value) { _impl_.xla_gpu_enable_pipelined_all_gather_ = value; } inline void DebugOptions::set_xla_gpu_enable_pipelined_all_gather(bool value) { _internal_set_xla_gpu_enable_pipelined_all_gather(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_pipelined_all_gather) } // bool xla_gpu_enable_pipelined_all_reduce = 217; inline void DebugOptions::clear_xla_gpu_enable_pipelined_all_reduce() { _impl_.xla_gpu_enable_pipelined_all_reduce_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_pipelined_all_reduce() const { return _impl_.xla_gpu_enable_pipelined_all_reduce_; } inline bool DebugOptions::xla_gpu_enable_pipelined_all_reduce() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_pipelined_all_reduce) return _internal_xla_gpu_enable_pipelined_all_reduce(); } inline void DebugOptions::_internal_set_xla_gpu_enable_pipelined_all_reduce(bool value) { _impl_.xla_gpu_enable_pipelined_all_reduce_ = value; } inline void DebugOptions::set_xla_gpu_enable_pipelined_all_reduce(bool value) { _internal_set_xla_gpu_enable_pipelined_all_reduce(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_pipelined_all_reduce) } // bool xla_gpu_enable_pipelined_collectives = 239; inline void DebugOptions::clear_xla_gpu_enable_pipelined_collectives() { _impl_.xla_gpu_enable_pipelined_collectives_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_pipelined_collectives() const { return _impl_.xla_gpu_enable_pipelined_collectives_; } inline bool DebugOptions::xla_gpu_enable_pipelined_collectives() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_pipelined_collectives) return _internal_xla_gpu_enable_pipelined_collectives(); } inline void DebugOptions::_internal_set_xla_gpu_enable_pipelined_collectives(bool value) { _impl_.xla_gpu_enable_pipelined_collectives_ = value; } inline void DebugOptions::set_xla_gpu_enable_pipelined_collectives(bool value) { _internal_set_xla_gpu_enable_pipelined_collectives(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_pipelined_collectives) } // bool xla_gpu_enable_pipelined_p2p = 246; inline void DebugOptions::clear_xla_gpu_enable_pipelined_p2p() { _impl_.xla_gpu_enable_pipelined_p2p_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_pipelined_p2p() const { return _impl_.xla_gpu_enable_pipelined_p2p_; } inline bool DebugOptions::xla_gpu_enable_pipelined_p2p() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_pipelined_p2p) return _internal_xla_gpu_enable_pipelined_p2p(); } inline void DebugOptions::_internal_set_xla_gpu_enable_pipelined_p2p(bool value) { _impl_.xla_gpu_enable_pipelined_p2p_ = value; } inline void DebugOptions::set_xla_gpu_enable_pipelined_p2p(bool value) { _internal_set_xla_gpu_enable_pipelined_p2p(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_pipelined_p2p) } // bool xla_gpu_enable_pipelined_reduce_scatter = 231; inline void DebugOptions::clear_xla_gpu_enable_pipelined_reduce_scatter() { _impl_.xla_gpu_enable_pipelined_reduce_scatter_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_pipelined_reduce_scatter() const { return _impl_.xla_gpu_enable_pipelined_reduce_scatter_; } inline bool DebugOptions::xla_gpu_enable_pipelined_reduce_scatter() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_pipelined_reduce_scatter) return _internal_xla_gpu_enable_pipelined_reduce_scatter(); } inline void DebugOptions::_internal_set_xla_gpu_enable_pipelined_reduce_scatter(bool value) { _impl_.xla_gpu_enable_pipelined_reduce_scatter_ = value; } inline void DebugOptions::set_xla_gpu_enable_pipelined_reduce_scatter(bool value) { _internal_set_xla_gpu_enable_pipelined_reduce_scatter(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_pipelined_reduce_scatter) } // bool xla_gpu_enable_reassociation_for_converted_ar = 209; inline void DebugOptions::clear_xla_gpu_enable_reassociation_for_converted_ar() { _impl_.xla_gpu_enable_reassociation_for_converted_ar_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_reassociation_for_converted_ar() const { return _impl_.xla_gpu_enable_reassociation_for_converted_ar_; } inline bool DebugOptions::xla_gpu_enable_reassociation_for_converted_ar() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_reassociation_for_converted_ar) return _internal_xla_gpu_enable_reassociation_for_converted_ar(); } inline void DebugOptions::_internal_set_xla_gpu_enable_reassociation_for_converted_ar(bool value) { _impl_.xla_gpu_enable_reassociation_for_converted_ar_ = value; } inline void DebugOptions::set_xla_gpu_enable_reassociation_for_converted_ar(bool value) { _internal_set_xla_gpu_enable_reassociation_for_converted_ar(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_reassociation_for_converted_ar) } // bool xla_gpu_enable_reduce_scatter_combine_by_dim = 257; inline void DebugOptions::clear_xla_gpu_enable_reduce_scatter_combine_by_dim() { _impl_.xla_gpu_enable_reduce_scatter_combine_by_dim_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_reduce_scatter_combine_by_dim() const { return _impl_.xla_gpu_enable_reduce_scatter_combine_by_dim_; } inline bool DebugOptions::xla_gpu_enable_reduce_scatter_combine_by_dim() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_reduce_scatter_combine_by_dim) return _internal_xla_gpu_enable_reduce_scatter_combine_by_dim(); } inline void DebugOptions::_internal_set_xla_gpu_enable_reduce_scatter_combine_by_dim(bool value) { _impl_.xla_gpu_enable_reduce_scatter_combine_by_dim_ = value; } inline void DebugOptions::set_xla_gpu_enable_reduce_scatter_combine_by_dim(bool value) { _internal_set_xla_gpu_enable_reduce_scatter_combine_by_dim(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_reduce_scatter_combine_by_dim) } // bool xla_gpu_enable_reduction_epilogue_fusion = 243; inline void DebugOptions::clear_xla_gpu_enable_reduction_epilogue_fusion() { _impl_.xla_gpu_enable_reduction_epilogue_fusion_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_reduction_epilogue_fusion() const { return _impl_.xla_gpu_enable_reduction_epilogue_fusion_; } inline bool DebugOptions::xla_gpu_enable_reduction_epilogue_fusion() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_reduction_epilogue_fusion) return _internal_xla_gpu_enable_reduction_epilogue_fusion(); } inline void DebugOptions::_internal_set_xla_gpu_enable_reduction_epilogue_fusion(bool value) { _impl_.xla_gpu_enable_reduction_epilogue_fusion_ = value; } inline void DebugOptions::set_xla_gpu_enable_reduction_epilogue_fusion(bool value) { _internal_set_xla_gpu_enable_reduction_epilogue_fusion(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_reduction_epilogue_fusion) } // bool xla_gpu_enable_scatter_determinism_expander = 345; inline void DebugOptions::clear_xla_gpu_enable_scatter_determinism_expander() { _impl_.xla_gpu_enable_scatter_determinism_expander_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_scatter_determinism_expander() const { return _impl_.xla_gpu_enable_scatter_determinism_expander_; } inline bool DebugOptions::xla_gpu_enable_scatter_determinism_expander() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_scatter_determinism_expander) return _internal_xla_gpu_enable_scatter_determinism_expander(); } inline void DebugOptions::_internal_set_xla_gpu_enable_scatter_determinism_expander(bool value) { _impl_.xla_gpu_enable_scatter_determinism_expander_ = value; } inline void DebugOptions::set_xla_gpu_enable_scatter_determinism_expander(bool value) { _internal_set_xla_gpu_enable_scatter_determinism_expander(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_scatter_determinism_expander) } // bool xla_gpu_enable_shared_constants = 165; inline void DebugOptions::clear_xla_gpu_enable_shared_constants() { _impl_.xla_gpu_enable_shared_constants_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_shared_constants() const { return _impl_.xla_gpu_enable_shared_constants_; } inline bool DebugOptions::xla_gpu_enable_shared_constants() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_shared_constants) return _internal_xla_gpu_enable_shared_constants(); } inline void DebugOptions::_internal_set_xla_gpu_enable_shared_constants(bool value) { _impl_.xla_gpu_enable_shared_constants_ = value; } inline void DebugOptions::set_xla_gpu_enable_shared_constants(bool value) { _internal_set_xla_gpu_enable_shared_constants(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_shared_constants) } // bool xla_gpu_enable_split_k_autotuning = 241; inline void DebugOptions::clear_xla_gpu_enable_split_k_autotuning() { _impl_.xla_gpu_enable_split_k_autotuning_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_split_k_autotuning() const { return _impl_.xla_gpu_enable_split_k_autotuning_; } inline bool DebugOptions::xla_gpu_enable_split_k_autotuning() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_split_k_autotuning) return _internal_xla_gpu_enable_split_k_autotuning(); } inline void DebugOptions::_internal_set_xla_gpu_enable_split_k_autotuning(bool value) { _impl_.xla_gpu_enable_split_k_autotuning_ = value; } inline void DebugOptions::set_xla_gpu_enable_split_k_autotuning(bool value) { _internal_set_xla_gpu_enable_split_k_autotuning(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_split_k_autotuning) } // bool xla_gpu_enable_triton_gemm = 188; inline void DebugOptions::clear_xla_gpu_enable_triton_gemm() { _impl_.xla_gpu_enable_triton_gemm_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_triton_gemm() const { return _impl_.xla_gpu_enable_triton_gemm_; } inline bool DebugOptions::xla_gpu_enable_triton_gemm() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_triton_gemm) return _internal_xla_gpu_enable_triton_gemm(); } inline void DebugOptions::_internal_set_xla_gpu_enable_triton_gemm(bool value) { _impl_.xla_gpu_enable_triton_gemm_ = value; } inline void DebugOptions::set_xla_gpu_enable_triton_gemm(bool value) { _internal_set_xla_gpu_enable_triton_gemm(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_triton_gemm) } // bool xla_gpu_enable_triton_hopper = 266; inline void DebugOptions::clear_xla_gpu_enable_triton_hopper() { _impl_.xla_gpu_enable_triton_hopper_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_triton_hopper() const { return _impl_.xla_gpu_enable_triton_hopper_; } inline bool DebugOptions::xla_gpu_enable_triton_hopper() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_triton_hopper) return _internal_xla_gpu_enable_triton_hopper(); } inline void DebugOptions::_internal_set_xla_gpu_enable_triton_hopper(bool value) { _impl_.xla_gpu_enable_triton_hopper_ = value; } inline void DebugOptions::set_xla_gpu_enable_triton_hopper(bool value) { _internal_set_xla_gpu_enable_triton_hopper(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_triton_hopper) } // bool xla_gpu_enable_while_loop_double_buffering = 248; inline void DebugOptions::clear_xla_gpu_enable_while_loop_double_buffering() { _impl_.xla_gpu_enable_while_loop_double_buffering_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_while_loop_double_buffering() const { return _impl_.xla_gpu_enable_while_loop_double_buffering_; } inline bool DebugOptions::xla_gpu_enable_while_loop_double_buffering() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_while_loop_double_buffering) return _internal_xla_gpu_enable_while_loop_double_buffering(); } inline void DebugOptions::_internal_set_xla_gpu_enable_while_loop_double_buffering(bool value) { _impl_.xla_gpu_enable_while_loop_double_buffering_ = value; } inline void DebugOptions::set_xla_gpu_enable_while_loop_double_buffering(bool value) { _internal_set_xla_gpu_enable_while_loop_double_buffering(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_while_loop_double_buffering) } // bool xla_gpu_enable_while_loop_reduce_scatter_code_motion = 203; inline void DebugOptions::clear_xla_gpu_enable_while_loop_reduce_scatter_code_motion() { _impl_.xla_gpu_enable_while_loop_reduce_scatter_code_motion_ = false; } inline bool DebugOptions::_internal_xla_gpu_enable_while_loop_reduce_scatter_code_motion() const { return _impl_.xla_gpu_enable_while_loop_reduce_scatter_code_motion_; } inline bool DebugOptions::xla_gpu_enable_while_loop_reduce_scatter_code_motion() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_while_loop_reduce_scatter_code_motion) return _internal_xla_gpu_enable_while_loop_reduce_scatter_code_motion(); } inline void DebugOptions::_internal_set_xla_gpu_enable_while_loop_reduce_scatter_code_motion(bool value) { _impl_.xla_gpu_enable_while_loop_reduce_scatter_code_motion_ = value; } inline void DebugOptions::set_xla_gpu_enable_while_loop_reduce_scatter_code_motion(bool value) { _internal_set_xla_gpu_enable_while_loop_reduce_scatter_code_motion(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_while_loop_reduce_scatter_code_motion) } // .xla.DebugOptions.WhileLoopUnrolling xla_gpu_enable_while_loop_unrolling = 294; inline void DebugOptions::clear_xla_gpu_enable_while_loop_unrolling() { _impl_.xla_gpu_enable_while_loop_unrolling_ = 0; } inline ::xla::DebugOptions_WhileLoopUnrolling DebugOptions::_internal_xla_gpu_enable_while_loop_unrolling() const { return static_cast< ::xla::DebugOptions_WhileLoopUnrolling >(_impl_.xla_gpu_enable_while_loop_unrolling_); } inline ::xla::DebugOptions_WhileLoopUnrolling DebugOptions::xla_gpu_enable_while_loop_unrolling() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_enable_while_loop_unrolling) return _internal_xla_gpu_enable_while_loop_unrolling(); } inline void DebugOptions::_internal_set_xla_gpu_enable_while_loop_unrolling(::xla::DebugOptions_WhileLoopUnrolling value) { _impl_.xla_gpu_enable_while_loop_unrolling_ = value; } inline void DebugOptions::set_xla_gpu_enable_while_loop_unrolling(::xla::DebugOptions_WhileLoopUnrolling value) { _internal_set_xla_gpu_enable_while_loop_unrolling(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_enable_while_loop_unrolling) } // bool xla_gpu_ensure_minor_dot_contraction_dims = 249; inline void DebugOptions::clear_xla_gpu_ensure_minor_dot_contraction_dims() { _impl_.xla_gpu_ensure_minor_dot_contraction_dims_ = false; } inline bool DebugOptions::_internal_xla_gpu_ensure_minor_dot_contraction_dims() const { return _impl_.xla_gpu_ensure_minor_dot_contraction_dims_; } inline bool DebugOptions::xla_gpu_ensure_minor_dot_contraction_dims() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_ensure_minor_dot_contraction_dims) return _internal_xla_gpu_ensure_minor_dot_contraction_dims(); } inline void DebugOptions::_internal_set_xla_gpu_ensure_minor_dot_contraction_dims(bool value) { _impl_.xla_gpu_ensure_minor_dot_contraction_dims_ = value; } inline void DebugOptions::set_xla_gpu_ensure_minor_dot_contraction_dims(bool value) { _internal_set_xla_gpu_ensure_minor_dot_contraction_dims(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_ensure_minor_dot_contraction_dims) } // bool xla_gpu_exclude_nondeterministic_ops = 297; inline void DebugOptions::clear_xla_gpu_exclude_nondeterministic_ops() { _impl_.xla_gpu_exclude_nondeterministic_ops_ = false; } inline bool DebugOptions::_internal_xla_gpu_exclude_nondeterministic_ops() const { return _impl_.xla_gpu_exclude_nondeterministic_ops_; } inline bool DebugOptions::xla_gpu_exclude_nondeterministic_ops() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_exclude_nondeterministic_ops) return _internal_xla_gpu_exclude_nondeterministic_ops(); } inline void DebugOptions::_internal_set_xla_gpu_exclude_nondeterministic_ops(bool value) { _impl_.xla_gpu_exclude_nondeterministic_ops_ = value; } inline void DebugOptions::set_xla_gpu_exclude_nondeterministic_ops(bool value) { _internal_set_xla_gpu_exclude_nondeterministic_ops(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_exclude_nondeterministic_ops) } // int32 xla_gpu_executable_terminate_timeout_seconds = 328; inline void DebugOptions::clear_xla_gpu_executable_terminate_timeout_seconds() { _impl_.xla_gpu_executable_terminate_timeout_seconds_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_executable_terminate_timeout_seconds() const { return _impl_.xla_gpu_executable_terminate_timeout_seconds_; } inline int32_t DebugOptions::xla_gpu_executable_terminate_timeout_seconds() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_executable_terminate_timeout_seconds) return _internal_xla_gpu_executable_terminate_timeout_seconds(); } inline void DebugOptions::_internal_set_xla_gpu_executable_terminate_timeout_seconds(int32_t value) { _impl_.xla_gpu_executable_terminate_timeout_seconds_ = value; } inline void DebugOptions::set_xla_gpu_executable_terminate_timeout_seconds(int32_t value) { _internal_set_xla_gpu_executable_terminate_timeout_seconds(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_executable_terminate_timeout_seconds) } // int32 xla_gpu_executable_warn_stuck_timeout_seconds = 327; inline void DebugOptions::clear_xla_gpu_executable_warn_stuck_timeout_seconds() { _impl_.xla_gpu_executable_warn_stuck_timeout_seconds_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_executable_warn_stuck_timeout_seconds() const { return _impl_.xla_gpu_executable_warn_stuck_timeout_seconds_; } inline int32_t DebugOptions::xla_gpu_executable_warn_stuck_timeout_seconds() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_executable_warn_stuck_timeout_seconds) return _internal_xla_gpu_executable_warn_stuck_timeout_seconds(); } inline void DebugOptions::_internal_set_xla_gpu_executable_warn_stuck_timeout_seconds(int32_t value) { _impl_.xla_gpu_executable_warn_stuck_timeout_seconds_ = value; } inline void DebugOptions::set_xla_gpu_executable_warn_stuck_timeout_seconds(int32_t value) { _internal_set_xla_gpu_executable_warn_stuck_timeout_seconds(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_executable_warn_stuck_timeout_seconds) } // bool xla_gpu_exhaustive_tiling_search = 219; inline void DebugOptions::clear_xla_gpu_exhaustive_tiling_search() { _impl_.xla_gpu_exhaustive_tiling_search_ = false; } inline bool DebugOptions::_internal_xla_gpu_exhaustive_tiling_search() const { return _impl_.xla_gpu_exhaustive_tiling_search_; } inline bool DebugOptions::xla_gpu_exhaustive_tiling_search() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_exhaustive_tiling_search) return _internal_xla_gpu_exhaustive_tiling_search(); } inline void DebugOptions::_internal_set_xla_gpu_exhaustive_tiling_search(bool value) { _impl_.xla_gpu_exhaustive_tiling_search_ = value; } inline void DebugOptions::set_xla_gpu_exhaustive_tiling_search(bool value) { _internal_set_xla_gpu_exhaustive_tiling_search(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_exhaustive_tiling_search) } // .xla.DebugOptions.AutotuneCacheMode xla_gpu_experimental_autotune_cache_mode = 324; inline void DebugOptions::clear_xla_gpu_experimental_autotune_cache_mode() { _impl_.xla_gpu_experimental_autotune_cache_mode_ = 0; } inline ::xla::DebugOptions_AutotuneCacheMode DebugOptions::_internal_xla_gpu_experimental_autotune_cache_mode() const { return static_cast< ::xla::DebugOptions_AutotuneCacheMode >(_impl_.xla_gpu_experimental_autotune_cache_mode_); } inline ::xla::DebugOptions_AutotuneCacheMode DebugOptions::xla_gpu_experimental_autotune_cache_mode() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_autotune_cache_mode) return _internal_xla_gpu_experimental_autotune_cache_mode(); } inline void DebugOptions::_internal_set_xla_gpu_experimental_autotune_cache_mode(::xla::DebugOptions_AutotuneCacheMode value) { _impl_.xla_gpu_experimental_autotune_cache_mode_ = value; } inline void DebugOptions::set_xla_gpu_experimental_autotune_cache_mode(::xla::DebugOptions_AutotuneCacheMode value) { _internal_set_xla_gpu_experimental_autotune_cache_mode(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_autotune_cache_mode) } // bool xla_gpu_experimental_disable_binary_libraries = 329; inline void DebugOptions::clear_xla_gpu_experimental_disable_binary_libraries() { _impl_.xla_gpu_experimental_disable_binary_libraries_ = false; } inline bool DebugOptions::_internal_xla_gpu_experimental_disable_binary_libraries() const { return _impl_.xla_gpu_experimental_disable_binary_libraries_; } inline bool DebugOptions::xla_gpu_experimental_disable_binary_libraries() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_disable_binary_libraries) return _internal_xla_gpu_experimental_disable_binary_libraries(); } inline void DebugOptions::_internal_set_xla_gpu_experimental_disable_binary_libraries(bool value) { _impl_.xla_gpu_experimental_disable_binary_libraries_ = value; } inline void DebugOptions::set_xla_gpu_experimental_disable_binary_libraries(bool value) { _internal_set_xla_gpu_experimental_disable_binary_libraries(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_disable_binary_libraries) } // bool xla_gpu_experimental_dump_fdo_profiles = 338; inline void DebugOptions::clear_xla_gpu_experimental_dump_fdo_profiles() { _impl_.xla_gpu_experimental_dump_fdo_profiles_ = false; } inline bool DebugOptions::_internal_xla_gpu_experimental_dump_fdo_profiles() const { return _impl_.xla_gpu_experimental_dump_fdo_profiles_; } inline bool DebugOptions::xla_gpu_experimental_dump_fdo_profiles() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_dump_fdo_profiles) return _internal_xla_gpu_experimental_dump_fdo_profiles(); } inline void DebugOptions::_internal_set_xla_gpu_experimental_dump_fdo_profiles(bool value) { _impl_.xla_gpu_experimental_dump_fdo_profiles_ = value; } inline void DebugOptions::set_xla_gpu_experimental_dump_fdo_profiles(bool value) { _internal_set_xla_gpu_experimental_dump_fdo_profiles(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_dump_fdo_profiles) } // bool xla_gpu_experimental_enable_alltoall_windowed_einsum = 360; inline void DebugOptions::clear_xla_gpu_experimental_enable_alltoall_windowed_einsum() { _impl_.xla_gpu_experimental_enable_alltoall_windowed_einsum_ = false; } inline bool DebugOptions::_internal_xla_gpu_experimental_enable_alltoall_windowed_einsum() const { return _impl_.xla_gpu_experimental_enable_alltoall_windowed_einsum_; } inline bool DebugOptions::xla_gpu_experimental_enable_alltoall_windowed_einsum() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_alltoall_windowed_einsum) return _internal_xla_gpu_experimental_enable_alltoall_windowed_einsum(); } inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_alltoall_windowed_einsum(bool value) { _impl_.xla_gpu_experimental_enable_alltoall_windowed_einsum_ = value; } inline void DebugOptions::set_xla_gpu_experimental_enable_alltoall_windowed_einsum(bool value) { _internal_set_xla_gpu_experimental_enable_alltoall_windowed_einsum(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_alltoall_windowed_einsum) } // bool xla_gpu_experimental_enable_fusion_block_level_rewriter = 334; inline void DebugOptions::clear_xla_gpu_experimental_enable_fusion_block_level_rewriter() { _impl_.xla_gpu_experimental_enable_fusion_block_level_rewriter_ = false; } inline bool DebugOptions::_internal_xla_gpu_experimental_enable_fusion_block_level_rewriter() const { return _impl_.xla_gpu_experimental_enable_fusion_block_level_rewriter_; } inline bool DebugOptions::xla_gpu_experimental_enable_fusion_block_level_rewriter() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_fusion_block_level_rewriter) return _internal_xla_gpu_experimental_enable_fusion_block_level_rewriter(); } inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_fusion_block_level_rewriter(bool value) { _impl_.xla_gpu_experimental_enable_fusion_block_level_rewriter_ = value; } inline void DebugOptions::set_xla_gpu_experimental_enable_fusion_block_level_rewriter(bool value) { _internal_set_xla_gpu_experimental_enable_fusion_block_level_rewriter(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_fusion_block_level_rewriter) } // bool xla_gpu_experimental_enable_triton_heroless_priority_fusion = 340; inline void DebugOptions::clear_xla_gpu_experimental_enable_triton_heroless_priority_fusion() { _impl_.xla_gpu_experimental_enable_triton_heroless_priority_fusion_ = false; } inline bool DebugOptions::_internal_xla_gpu_experimental_enable_triton_heroless_priority_fusion() const { return _impl_.xla_gpu_experimental_enable_triton_heroless_priority_fusion_; } inline bool DebugOptions::xla_gpu_experimental_enable_triton_heroless_priority_fusion() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_triton_heroless_priority_fusion) return _internal_xla_gpu_experimental_enable_triton_heroless_priority_fusion(); } inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_triton_heroless_priority_fusion(bool value) { _impl_.xla_gpu_experimental_enable_triton_heroless_priority_fusion_ = value; } inline void DebugOptions::set_xla_gpu_experimental_enable_triton_heroless_priority_fusion(bool value) { _internal_set_xla_gpu_experimental_enable_triton_heroless_priority_fusion(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_triton_heroless_priority_fusion) } // bool xla_gpu_experimental_enable_triton_tma = 355; inline void DebugOptions::clear_xla_gpu_experimental_enable_triton_tma() { _impl_.xla_gpu_experimental_enable_triton_tma_ = false; } inline bool DebugOptions::_internal_xla_gpu_experimental_enable_triton_tma() const { return _impl_.xla_gpu_experimental_enable_triton_tma_; } inline bool DebugOptions::xla_gpu_experimental_enable_triton_tma() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_enable_triton_tma) return _internal_xla_gpu_experimental_enable_triton_tma(); } inline void DebugOptions::_internal_set_xla_gpu_experimental_enable_triton_tma(bool value) { _impl_.xla_gpu_experimental_enable_triton_tma_ = value; } inline void DebugOptions::set_xla_gpu_experimental_enable_triton_tma(bool value) { _internal_set_xla_gpu_experimental_enable_triton_tma(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_enable_triton_tma) } // bool xla_gpu_experimental_pack_dot_operands_along_k_dimension = 362; inline void DebugOptions::clear_xla_gpu_experimental_pack_dot_operands_along_k_dimension() { _impl_.xla_gpu_experimental_pack_dot_operands_along_k_dimension_ = false; } inline bool DebugOptions::_internal_xla_gpu_experimental_pack_dot_operands_along_k_dimension() const { return _impl_.xla_gpu_experimental_pack_dot_operands_along_k_dimension_; } inline bool DebugOptions::xla_gpu_experimental_pack_dot_operands_along_k_dimension() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_pack_dot_operands_along_k_dimension) return _internal_xla_gpu_experimental_pack_dot_operands_along_k_dimension(); } inline void DebugOptions::_internal_set_xla_gpu_experimental_pack_dot_operands_along_k_dimension(bool value) { _impl_.xla_gpu_experimental_pack_dot_operands_along_k_dimension_ = value; } inline void DebugOptions::set_xla_gpu_experimental_pack_dot_operands_along_k_dimension(bool value) { _internal_set_xla_gpu_experimental_pack_dot_operands_along_k_dimension(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_pack_dot_operands_along_k_dimension) } // int32 xla_gpu_experimental_parallel_collective_overlap_limit = 336; inline void DebugOptions::clear_xla_gpu_experimental_parallel_collective_overlap_limit() { _impl_.xla_gpu_experimental_parallel_collective_overlap_limit_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_experimental_parallel_collective_overlap_limit() const { return _impl_.xla_gpu_experimental_parallel_collective_overlap_limit_; } inline int32_t DebugOptions::xla_gpu_experimental_parallel_collective_overlap_limit() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_parallel_collective_overlap_limit) return _internal_xla_gpu_experimental_parallel_collective_overlap_limit(); } inline void DebugOptions::_internal_set_xla_gpu_experimental_parallel_collective_overlap_limit(int32_t value) { _impl_.xla_gpu_experimental_parallel_collective_overlap_limit_ = value; } inline void DebugOptions::set_xla_gpu_experimental_parallel_collective_overlap_limit(int32_t value) { _internal_set_xla_gpu_experimental_parallel_collective_overlap_limit(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_parallel_collective_overlap_limit) } // bool xla_gpu_experimental_stream_annotation = 342; inline void DebugOptions::clear_xla_gpu_experimental_stream_annotation() { _impl_.xla_gpu_experimental_stream_annotation_ = false; } inline bool DebugOptions::_internal_xla_gpu_experimental_stream_annotation() const { return _impl_.xla_gpu_experimental_stream_annotation_; } inline bool DebugOptions::xla_gpu_experimental_stream_annotation() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_experimental_stream_annotation) return _internal_xla_gpu_experimental_stream_annotation(); } inline void DebugOptions::_internal_set_xla_gpu_experimental_stream_annotation(bool value) { _impl_.xla_gpu_experimental_stream_annotation_ = value; } inline void DebugOptions::set_xla_gpu_experimental_stream_annotation(bool value) { _internal_set_xla_gpu_experimental_stream_annotation(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_experimental_stream_annotation) } // bool xla_gpu_fail_ptx_compilation_on_register_spilling = 353; inline void DebugOptions::clear_xla_gpu_fail_ptx_compilation_on_register_spilling() { _impl_.xla_gpu_fail_ptx_compilation_on_register_spilling_ = false; } inline bool DebugOptions::_internal_xla_gpu_fail_ptx_compilation_on_register_spilling() const { return _impl_.xla_gpu_fail_ptx_compilation_on_register_spilling_; } inline bool DebugOptions::xla_gpu_fail_ptx_compilation_on_register_spilling() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_fail_ptx_compilation_on_register_spilling) return _internal_xla_gpu_fail_ptx_compilation_on_register_spilling(); } inline void DebugOptions::_internal_set_xla_gpu_fail_ptx_compilation_on_register_spilling(bool value) { _impl_.xla_gpu_fail_ptx_compilation_on_register_spilling_ = value; } inline void DebugOptions::set_xla_gpu_fail_ptx_compilation_on_register_spilling(bool value) { _internal_set_xla_gpu_fail_ptx_compilation_on_register_spilling(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_fail_ptx_compilation_on_register_spilling) } // bool xla_gpu_filter_kernels_spilling_registers_on_autotuning = 250; inline void DebugOptions::clear_xla_gpu_filter_kernels_spilling_registers_on_autotuning() { _impl_.xla_gpu_filter_kernels_spilling_registers_on_autotuning_ = false; } inline bool DebugOptions::_internal_xla_gpu_filter_kernels_spilling_registers_on_autotuning() const { return _impl_.xla_gpu_filter_kernels_spilling_registers_on_autotuning_; } inline bool DebugOptions::xla_gpu_filter_kernels_spilling_registers_on_autotuning() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_filter_kernels_spilling_registers_on_autotuning) return _internal_xla_gpu_filter_kernels_spilling_registers_on_autotuning(); } inline void DebugOptions::_internal_set_xla_gpu_filter_kernels_spilling_registers_on_autotuning(bool value) { _impl_.xla_gpu_filter_kernels_spilling_registers_on_autotuning_ = value; } inline void DebugOptions::set_xla_gpu_filter_kernels_spilling_registers_on_autotuning(bool value) { _internal_set_xla_gpu_filter_kernels_spilling_registers_on_autotuning(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_filter_kernels_spilling_registers_on_autotuning) } // int32 xla_gpu_force_compilation_parallelism = 147; inline void DebugOptions::clear_xla_gpu_force_compilation_parallelism() { _impl_.xla_gpu_force_compilation_parallelism_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_force_compilation_parallelism() const { return _impl_.xla_gpu_force_compilation_parallelism_; } inline int32_t DebugOptions::xla_gpu_force_compilation_parallelism() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_force_compilation_parallelism) return _internal_xla_gpu_force_compilation_parallelism(); } inline void DebugOptions::_internal_set_xla_gpu_force_compilation_parallelism(int32_t value) { _impl_.xla_gpu_force_compilation_parallelism_ = value; } inline void DebugOptions::set_xla_gpu_force_compilation_parallelism(int32_t value) { _internal_set_xla_gpu_force_compilation_parallelism(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_force_compilation_parallelism) } // bool xla_gpu_force_conv_nchw = 125; inline void DebugOptions::clear_xla_gpu_force_conv_nchw() { _impl_.xla_gpu_force_conv_nchw_ = false; } inline bool DebugOptions::_internal_xla_gpu_force_conv_nchw() const { return _impl_.xla_gpu_force_conv_nchw_; } inline bool DebugOptions::xla_gpu_force_conv_nchw() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_force_conv_nchw) return _internal_xla_gpu_force_conv_nchw(); } inline void DebugOptions::_internal_set_xla_gpu_force_conv_nchw(bool value) { _impl_.xla_gpu_force_conv_nchw_ = value; } inline void DebugOptions::set_xla_gpu_force_conv_nchw(bool value) { _internal_set_xla_gpu_force_conv_nchw(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_force_conv_nchw) } // bool xla_gpu_force_conv_nhwc = 146; inline void DebugOptions::clear_xla_gpu_force_conv_nhwc() { _impl_.xla_gpu_force_conv_nhwc_ = false; } inline bool DebugOptions::_internal_xla_gpu_force_conv_nhwc() const { return _impl_.xla_gpu_force_conv_nhwc_; } inline bool DebugOptions::xla_gpu_force_conv_nhwc() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_force_conv_nhwc) return _internal_xla_gpu_force_conv_nhwc(); } inline void DebugOptions::_internal_set_xla_gpu_force_conv_nhwc(bool value) { _impl_.xla_gpu_force_conv_nhwc_ = value; } inline void DebugOptions::set_xla_gpu_force_conv_nhwc(bool value) { _internal_set_xla_gpu_force_conv_nhwc(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_force_conv_nhwc) } // bool xla_gpu_ftz = 62; inline void DebugOptions::clear_xla_gpu_ftz() { _impl_.xla_gpu_ftz_ = false; } inline bool DebugOptions::_internal_xla_gpu_ftz() const { return _impl_.xla_gpu_ftz_; } inline bool DebugOptions::xla_gpu_ftz() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_ftz) return _internal_xla_gpu_ftz(); } inline void DebugOptions::_internal_set_xla_gpu_ftz(bool value) { _impl_.xla_gpu_ftz_ = value; } inline void DebugOptions::set_xla_gpu_ftz(bool value) { _internal_set_xla_gpu_ftz(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_ftz) } // bool xla_gpu_fused_attention_use_cudnn_rng = 235; inline void DebugOptions::clear_xla_gpu_fused_attention_use_cudnn_rng() { _impl_.xla_gpu_fused_attention_use_cudnn_rng_ = false; } inline bool DebugOptions::_internal_xla_gpu_fused_attention_use_cudnn_rng() const { return _impl_.xla_gpu_fused_attention_use_cudnn_rng_; } inline bool DebugOptions::xla_gpu_fused_attention_use_cudnn_rng() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_fused_attention_use_cudnn_rng) return _internal_xla_gpu_fused_attention_use_cudnn_rng(); } inline void DebugOptions::_internal_set_xla_gpu_fused_attention_use_cudnn_rng(bool value) { _impl_.xla_gpu_fused_attention_use_cudnn_rng_ = value; } inline void DebugOptions::set_xla_gpu_fused_attention_use_cudnn_rng(bool value) { _internal_set_xla_gpu_fused_attention_use_cudnn_rng(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_fused_attention_use_cudnn_rng) } // int64 xla_gpu_gemm_rewrite_size_threshold = 283; inline void DebugOptions::clear_xla_gpu_gemm_rewrite_size_threshold() { _impl_.xla_gpu_gemm_rewrite_size_threshold_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_gemm_rewrite_size_threshold() const { return _impl_.xla_gpu_gemm_rewrite_size_threshold_; } inline int64_t DebugOptions::xla_gpu_gemm_rewrite_size_threshold() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_gemm_rewrite_size_threshold) return _internal_xla_gpu_gemm_rewrite_size_threshold(); } inline void DebugOptions::_internal_set_xla_gpu_gemm_rewrite_size_threshold(int64_t value) { _impl_.xla_gpu_gemm_rewrite_size_threshold_ = value; } inline void DebugOptions::set_xla_gpu_gemm_rewrite_size_threshold(int64_t value) { _internal_set_xla_gpu_gemm_rewrite_size_threshold(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_gemm_rewrite_size_threshold) } // bool xla_gpu_generate_debug_info = 348; inline void DebugOptions::clear_xla_gpu_generate_debug_info() { _impl_.xla_gpu_generate_debug_info_ = false; } inline bool DebugOptions::_internal_xla_gpu_generate_debug_info() const { return _impl_.xla_gpu_generate_debug_info_; } inline bool DebugOptions::xla_gpu_generate_debug_info() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_generate_debug_info) return _internal_xla_gpu_generate_debug_info(); } inline void DebugOptions::_internal_set_xla_gpu_generate_debug_info(bool value) { _impl_.xla_gpu_generate_debug_info_ = value; } inline void DebugOptions::set_xla_gpu_generate_debug_info(bool value) { _internal_set_xla_gpu_generate_debug_info(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_generate_debug_info) } // bool xla_gpu_generate_line_info = 349; inline void DebugOptions::clear_xla_gpu_generate_line_info() { _impl_.xla_gpu_generate_line_info_ = false; } inline bool DebugOptions::_internal_xla_gpu_generate_line_info() const { return _impl_.xla_gpu_generate_line_info_; } inline bool DebugOptions::xla_gpu_generate_line_info() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_generate_line_info) return _internal_xla_gpu_generate_line_info(); } inline void DebugOptions::_internal_set_xla_gpu_generate_line_info(bool value) { _impl_.xla_gpu_generate_line_info_ = value; } inline void DebugOptions::set_xla_gpu_generate_line_info(bool value) { _internal_set_xla_gpu_generate_line_info(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_generate_line_info) } // bool xla_gpu_graph_enable_concurrent_region = 215; inline void DebugOptions::clear_xla_gpu_graph_enable_concurrent_region() { _impl_.xla_gpu_graph_enable_concurrent_region_ = false; } inline bool DebugOptions::_internal_xla_gpu_graph_enable_concurrent_region() const { return _impl_.xla_gpu_graph_enable_concurrent_region_; } inline bool DebugOptions::xla_gpu_graph_enable_concurrent_region() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_graph_enable_concurrent_region) return _internal_xla_gpu_graph_enable_concurrent_region(); } inline void DebugOptions::_internal_set_xla_gpu_graph_enable_concurrent_region(bool value) { _impl_.xla_gpu_graph_enable_concurrent_region_ = value; } inline void DebugOptions::set_xla_gpu_graph_enable_concurrent_region(bool value) { _internal_set_xla_gpu_graph_enable_concurrent_region(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_graph_enable_concurrent_region) } // int32 xla_gpu_graph_min_graph_size = 208; inline void DebugOptions::clear_xla_gpu_graph_min_graph_size() { _impl_.xla_gpu_graph_min_graph_size_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_graph_min_graph_size() const { return _impl_.xla_gpu_graph_min_graph_size_; } inline int32_t DebugOptions::xla_gpu_graph_min_graph_size() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_graph_min_graph_size) return _internal_xla_gpu_graph_min_graph_size(); } inline void DebugOptions::_internal_set_xla_gpu_graph_min_graph_size(int32_t value) { _impl_.xla_gpu_graph_min_graph_size_ = value; } inline void DebugOptions::set_xla_gpu_graph_min_graph_size(int32_t value) { _internal_set_xla_gpu_graph_min_graph_size(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_graph_min_graph_size) } // string xla_gpu_kernel_cache_file = 306; inline void DebugOptions::clear_xla_gpu_kernel_cache_file() { _impl_.xla_gpu_kernel_cache_file_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_gpu_kernel_cache_file() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_kernel_cache_file) return _internal_xla_gpu_kernel_cache_file(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_kernel_cache_file(ArgT0&& arg0, ArgT... args) { _impl_.xla_gpu_kernel_cache_file_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_kernel_cache_file) } inline std::string* DebugOptions::mutable_xla_gpu_kernel_cache_file() { std::string* _s = _internal_mutable_xla_gpu_kernel_cache_file(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_kernel_cache_file) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_kernel_cache_file() const { return _impl_.xla_gpu_kernel_cache_file_.Get(); } inline void DebugOptions::_internal_set_xla_gpu_kernel_cache_file(const std::string& value) { _impl_.xla_gpu_kernel_cache_file_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_gpu_kernel_cache_file() { return _impl_.xla_gpu_kernel_cache_file_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_gpu_kernel_cache_file() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_kernel_cache_file) return _impl_.xla_gpu_kernel_cache_file_.Release(); } inline void DebugOptions::set_allocated_xla_gpu_kernel_cache_file(std::string* xla_gpu_kernel_cache_file) { if (xla_gpu_kernel_cache_file != nullptr) { } else { } _impl_.xla_gpu_kernel_cache_file_.SetAllocated(xla_gpu_kernel_cache_file, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_gpu_kernel_cache_file_.IsDefault()) { _impl_.xla_gpu_kernel_cache_file_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_kernel_cache_file) } // .xla.DebugOptions.LibNvJitLinkMode xla_gpu_libnvjitlink_mode = 343; inline void DebugOptions::clear_xla_gpu_libnvjitlink_mode() { _impl_.xla_gpu_libnvjitlink_mode_ = 0; } inline ::xla::DebugOptions_LibNvJitLinkMode DebugOptions::_internal_xla_gpu_libnvjitlink_mode() const { return static_cast< ::xla::DebugOptions_LibNvJitLinkMode >(_impl_.xla_gpu_libnvjitlink_mode_); } inline ::xla::DebugOptions_LibNvJitLinkMode DebugOptions::xla_gpu_libnvjitlink_mode() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_libnvjitlink_mode) return _internal_xla_gpu_libnvjitlink_mode(); } inline void DebugOptions::_internal_set_xla_gpu_libnvjitlink_mode(::xla::DebugOptions_LibNvJitLinkMode value) { _impl_.xla_gpu_libnvjitlink_mode_ = value; } inline void DebugOptions::set_xla_gpu_libnvjitlink_mode(::xla::DebugOptions_LibNvJitLinkMode value) { _internal_set_xla_gpu_libnvjitlink_mode(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_libnvjitlink_mode) } // repeated string xla_gpu_llvm_ir_file = 150; inline int DebugOptions::_internal_xla_gpu_llvm_ir_file_size() const { return _impl_.xla_gpu_llvm_ir_file_.size(); } inline int DebugOptions::xla_gpu_llvm_ir_file_size() const { return _internal_xla_gpu_llvm_ir_file_size(); } inline void DebugOptions::clear_xla_gpu_llvm_ir_file() { _impl_.xla_gpu_llvm_ir_file_.Clear(); } inline std::string* DebugOptions::add_xla_gpu_llvm_ir_file() { std::string* _s = _internal_add_xla_gpu_llvm_ir_file(); // @@protoc_insertion_point(field_add_mutable:xla.DebugOptions.xla_gpu_llvm_ir_file) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_llvm_ir_file(int index) const { return _impl_.xla_gpu_llvm_ir_file_.Get(index); } inline const std::string& DebugOptions::xla_gpu_llvm_ir_file(int index) const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_llvm_ir_file) return _internal_xla_gpu_llvm_ir_file(index); } inline std::string* DebugOptions::mutable_xla_gpu_llvm_ir_file(int index) { // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_llvm_ir_file) return _impl_.xla_gpu_llvm_ir_file_.Mutable(index); } inline void DebugOptions::set_xla_gpu_llvm_ir_file(int index, const std::string& value) { _impl_.xla_gpu_llvm_ir_file_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_llvm_ir_file) } inline void DebugOptions::set_xla_gpu_llvm_ir_file(int index, std::string&& value) { _impl_.xla_gpu_llvm_ir_file_.Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_llvm_ir_file) } inline void DebugOptions::set_xla_gpu_llvm_ir_file(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.xla_gpu_llvm_ir_file_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:xla.DebugOptions.xla_gpu_llvm_ir_file) } inline void DebugOptions::set_xla_gpu_llvm_ir_file(int index, const char* value, size_t size) { _impl_.xla_gpu_llvm_ir_file_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:xla.DebugOptions.xla_gpu_llvm_ir_file) } inline std::string* DebugOptions::_internal_add_xla_gpu_llvm_ir_file() { return _impl_.xla_gpu_llvm_ir_file_.Add(); } inline void DebugOptions::add_xla_gpu_llvm_ir_file(const std::string& value) { _impl_.xla_gpu_llvm_ir_file_.Add()->assign(value); // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_gpu_llvm_ir_file) } inline void DebugOptions::add_xla_gpu_llvm_ir_file(std::string&& value) { _impl_.xla_gpu_llvm_ir_file_.Add(std::move(value)); // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_gpu_llvm_ir_file) } inline void DebugOptions::add_xla_gpu_llvm_ir_file(const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.xla_gpu_llvm_ir_file_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:xla.DebugOptions.xla_gpu_llvm_ir_file) } inline void DebugOptions::add_xla_gpu_llvm_ir_file(const char* value, size_t size) { _impl_.xla_gpu_llvm_ir_file_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:xla.DebugOptions.xla_gpu_llvm_ir_file) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& DebugOptions::xla_gpu_llvm_ir_file() const { // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_gpu_llvm_ir_file) return _impl_.xla_gpu_llvm_ir_file_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* DebugOptions::mutable_xla_gpu_llvm_ir_file() { // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_gpu_llvm_ir_file) return &_impl_.xla_gpu_llvm_ir_file_; } // int32 xla_gpu_llvm_verification_level = 256; inline void DebugOptions::clear_xla_gpu_llvm_verification_level() { _impl_.xla_gpu_llvm_verification_level_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_llvm_verification_level() const { return _impl_.xla_gpu_llvm_verification_level_; } inline int32_t DebugOptions::xla_gpu_llvm_verification_level() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_llvm_verification_level) return _internal_xla_gpu_llvm_verification_level(); } inline void DebugOptions::_internal_set_xla_gpu_llvm_verification_level(int32_t value) { _impl_.xla_gpu_llvm_verification_level_ = value; } inline void DebugOptions::set_xla_gpu_llvm_verification_level(int32_t value) { _internal_set_xla_gpu_llvm_verification_level(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_llvm_verification_level) } // string xla_gpu_load_autotune_results_from = 223; inline void DebugOptions::clear_xla_gpu_load_autotune_results_from() { _impl_.xla_gpu_load_autotune_results_from_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_gpu_load_autotune_results_from() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_load_autotune_results_from) return _internal_xla_gpu_load_autotune_results_from(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_load_autotune_results_from(ArgT0&& arg0, ArgT... args) { _impl_.xla_gpu_load_autotune_results_from_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_load_autotune_results_from) } inline std::string* DebugOptions::mutable_xla_gpu_load_autotune_results_from() { std::string* _s = _internal_mutable_xla_gpu_load_autotune_results_from(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_load_autotune_results_from) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_load_autotune_results_from() const { return _impl_.xla_gpu_load_autotune_results_from_.Get(); } inline void DebugOptions::_internal_set_xla_gpu_load_autotune_results_from(const std::string& value) { _impl_.xla_gpu_load_autotune_results_from_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_gpu_load_autotune_results_from() { return _impl_.xla_gpu_load_autotune_results_from_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_gpu_load_autotune_results_from() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_load_autotune_results_from) return _impl_.xla_gpu_load_autotune_results_from_.Release(); } inline void DebugOptions::set_allocated_xla_gpu_load_autotune_results_from(std::string* xla_gpu_load_autotune_results_from) { if (xla_gpu_load_autotune_results_from != nullptr) { } else { } _impl_.xla_gpu_load_autotune_results_from_.SetAllocated(xla_gpu_load_autotune_results_from, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_gpu_load_autotune_results_from_.IsDefault()) { _impl_.xla_gpu_load_autotune_results_from_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_load_autotune_results_from) } // int32 xla_gpu_memory_limit_slop_factor = 260; inline void DebugOptions::clear_xla_gpu_memory_limit_slop_factor() { _impl_.xla_gpu_memory_limit_slop_factor_ = 0; } inline int32_t DebugOptions::_internal_xla_gpu_memory_limit_slop_factor() const { return _impl_.xla_gpu_memory_limit_slop_factor_; } inline int32_t DebugOptions::xla_gpu_memory_limit_slop_factor() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_memory_limit_slop_factor) return _internal_xla_gpu_memory_limit_slop_factor(); } inline void DebugOptions::_internal_set_xla_gpu_memory_limit_slop_factor(int32_t value) { _impl_.xla_gpu_memory_limit_slop_factor_ = value; } inline void DebugOptions::set_xla_gpu_memory_limit_slop_factor(int32_t value) { _internal_set_xla_gpu_memory_limit_slop_factor(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_memory_limit_slop_factor) } // bool xla_gpu_mock_custom_calls = 245; inline void DebugOptions::clear_xla_gpu_mock_custom_calls() { _impl_.xla_gpu_mock_custom_calls_ = false; } inline bool DebugOptions::_internal_xla_gpu_mock_custom_calls() const { return _impl_.xla_gpu_mock_custom_calls_; } inline bool DebugOptions::xla_gpu_mock_custom_calls() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_mock_custom_calls) return _internal_xla_gpu_mock_custom_calls(); } inline void DebugOptions::_internal_set_xla_gpu_mock_custom_calls(bool value) { _impl_.xla_gpu_mock_custom_calls_ = value; } inline void DebugOptions::set_xla_gpu_mock_custom_calls(bool value) { _internal_set_xla_gpu_mock_custom_calls(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_mock_custom_calls) } // bool xla_gpu_multi_streamed_windowed_einsum = 280; inline void DebugOptions::clear_xla_gpu_multi_streamed_windowed_einsum() { _impl_.xla_gpu_multi_streamed_windowed_einsum_ = false; } inline bool DebugOptions::_internal_xla_gpu_multi_streamed_windowed_einsum() const { return _impl_.xla_gpu_multi_streamed_windowed_einsum_; } inline bool DebugOptions::xla_gpu_multi_streamed_windowed_einsum() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_multi_streamed_windowed_einsum) return _internal_xla_gpu_multi_streamed_windowed_einsum(); } inline void DebugOptions::_internal_set_xla_gpu_multi_streamed_windowed_einsum(bool value) { _impl_.xla_gpu_multi_streamed_windowed_einsum_ = value; } inline void DebugOptions::set_xla_gpu_multi_streamed_windowed_einsum(bool value) { _internal_set_xla_gpu_multi_streamed_windowed_einsum(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_multi_streamed_windowed_einsum) } // int64 xla_gpu_nccl_collective_max_nchannels = 273; inline void DebugOptions::clear_xla_gpu_nccl_collective_max_nchannels() { _impl_.xla_gpu_nccl_collective_max_nchannels_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_nccl_collective_max_nchannels() const { return _impl_.xla_gpu_nccl_collective_max_nchannels_; } inline int64_t DebugOptions::xla_gpu_nccl_collective_max_nchannels() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_nccl_collective_max_nchannels) return _internal_xla_gpu_nccl_collective_max_nchannels(); } inline void DebugOptions::_internal_set_xla_gpu_nccl_collective_max_nchannels(int64_t value) { _impl_.xla_gpu_nccl_collective_max_nchannels_ = value; } inline void DebugOptions::set_xla_gpu_nccl_collective_max_nchannels(int64_t value) { _internal_set_xla_gpu_nccl_collective_max_nchannels(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_nccl_collective_max_nchannels) } // int64 xla_gpu_nccl_init_max_rank_per_root_ratio = 277; inline void DebugOptions::clear_xla_gpu_nccl_init_max_rank_per_root_ratio() { _impl_.xla_gpu_nccl_init_max_rank_per_root_ratio_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_nccl_init_max_rank_per_root_ratio() const { return _impl_.xla_gpu_nccl_init_max_rank_per_root_ratio_; } inline int64_t DebugOptions::xla_gpu_nccl_init_max_rank_per_root_ratio() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_nccl_init_max_rank_per_root_ratio) return _internal_xla_gpu_nccl_init_max_rank_per_root_ratio(); } inline void DebugOptions::_internal_set_xla_gpu_nccl_init_max_rank_per_root_ratio(int64_t value) { _impl_.xla_gpu_nccl_init_max_rank_per_root_ratio_ = value; } inline void DebugOptions::set_xla_gpu_nccl_init_max_rank_per_root_ratio(int64_t value) { _internal_set_xla_gpu_nccl_init_max_rank_per_root_ratio(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_nccl_init_max_rank_per_root_ratio) } // int64 xla_gpu_nccl_p2p_max_nchannels = 274; inline void DebugOptions::clear_xla_gpu_nccl_p2p_max_nchannels() { _impl_.xla_gpu_nccl_p2p_max_nchannels_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_nccl_p2p_max_nchannels() const { return _impl_.xla_gpu_nccl_p2p_max_nchannels_; } inline int64_t DebugOptions::xla_gpu_nccl_p2p_max_nchannels() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_nccl_p2p_max_nchannels) return _internal_xla_gpu_nccl_p2p_max_nchannels(); } inline void DebugOptions::_internal_set_xla_gpu_nccl_p2p_max_nchannels(int64_t value) { _impl_.xla_gpu_nccl_p2p_max_nchannels_ = value; } inline void DebugOptions::set_xla_gpu_nccl_p2p_max_nchannels(int64_t value) { _internal_set_xla_gpu_nccl_p2p_max_nchannels(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_nccl_p2p_max_nchannels) } // bool xla_gpu_nccl_terminate_on_error = 301; inline void DebugOptions::clear_xla_gpu_nccl_terminate_on_error() { _impl_.xla_gpu_nccl_terminate_on_error_ = false; } inline bool DebugOptions::_internal_xla_gpu_nccl_terminate_on_error() const { return _impl_.xla_gpu_nccl_terminate_on_error_; } inline bool DebugOptions::xla_gpu_nccl_terminate_on_error() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_nccl_terminate_on_error) return _internal_xla_gpu_nccl_terminate_on_error(); } inline void DebugOptions::_internal_set_xla_gpu_nccl_terminate_on_error(bool value) { _impl_.xla_gpu_nccl_terminate_on_error_ = value; } inline void DebugOptions::set_xla_gpu_nccl_terminate_on_error(bool value) { _internal_set_xla_gpu_nccl_terminate_on_error(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_nccl_terminate_on_error) } // int64 xla_gpu_nccl_termination_timeout_seconds = 163; inline void DebugOptions::clear_xla_gpu_nccl_termination_timeout_seconds() { _impl_.xla_gpu_nccl_termination_timeout_seconds_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_nccl_termination_timeout_seconds() const { return _impl_.xla_gpu_nccl_termination_timeout_seconds_; } inline int64_t DebugOptions::xla_gpu_nccl_termination_timeout_seconds() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_nccl_termination_timeout_seconds) return _internal_xla_gpu_nccl_termination_timeout_seconds(); } inline void DebugOptions::_internal_set_xla_gpu_nccl_termination_timeout_seconds(int64_t value) { _impl_.xla_gpu_nccl_termination_timeout_seconds_ = value; } inline void DebugOptions::set_xla_gpu_nccl_termination_timeout_seconds(int64_t value) { _internal_set_xla_gpu_nccl_termination_timeout_seconds(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_nccl_termination_timeout_seconds) } // int64 xla_gpu_operand_bytes_threshold_for_windowed_einsum = 339; inline void DebugOptions::clear_xla_gpu_operand_bytes_threshold_for_windowed_einsum() { _impl_.xla_gpu_operand_bytes_threshold_for_windowed_einsum_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_operand_bytes_threshold_for_windowed_einsum() const { return _impl_.xla_gpu_operand_bytes_threshold_for_windowed_einsum_; } inline int64_t DebugOptions::xla_gpu_operand_bytes_threshold_for_windowed_einsum() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_operand_bytes_threshold_for_windowed_einsum) return _internal_xla_gpu_operand_bytes_threshold_for_windowed_einsum(); } inline void DebugOptions::_internal_set_xla_gpu_operand_bytes_threshold_for_windowed_einsum(int64_t value) { _impl_.xla_gpu_operand_bytes_threshold_for_windowed_einsum_ = value; } inline void DebugOptions::set_xla_gpu_operand_bytes_threshold_for_windowed_einsum(int64_t value) { _internal_set_xla_gpu_operand_bytes_threshold_for_windowed_einsum(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_operand_bytes_threshold_for_windowed_einsum) } // string xla_gpu_override_gemm_autotuner = 295; inline void DebugOptions::clear_xla_gpu_override_gemm_autotuner() { _impl_.xla_gpu_override_gemm_autotuner_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_gpu_override_gemm_autotuner() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_override_gemm_autotuner) return _internal_xla_gpu_override_gemm_autotuner(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_override_gemm_autotuner(ArgT0&& arg0, ArgT... args) { _impl_.xla_gpu_override_gemm_autotuner_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_override_gemm_autotuner) } inline std::string* DebugOptions::mutable_xla_gpu_override_gemm_autotuner() { std::string* _s = _internal_mutable_xla_gpu_override_gemm_autotuner(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_override_gemm_autotuner) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_override_gemm_autotuner() const { return _impl_.xla_gpu_override_gemm_autotuner_.Get(); } inline void DebugOptions::_internal_set_xla_gpu_override_gemm_autotuner(const std::string& value) { _impl_.xla_gpu_override_gemm_autotuner_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_gpu_override_gemm_autotuner() { return _impl_.xla_gpu_override_gemm_autotuner_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_gpu_override_gemm_autotuner() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_override_gemm_autotuner) return _impl_.xla_gpu_override_gemm_autotuner_.Release(); } inline void DebugOptions::set_allocated_xla_gpu_override_gemm_autotuner(std::string* xla_gpu_override_gemm_autotuner) { if (xla_gpu_override_gemm_autotuner != nullptr) { } else { } _impl_.xla_gpu_override_gemm_autotuner_.SetAllocated(xla_gpu_override_gemm_autotuner, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_gpu_override_gemm_autotuner_.IsDefault()) { _impl_.xla_gpu_override_gemm_autotuner_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_override_gemm_autotuner) } // string xla_gpu_per_fusion_autotune_cache_dir = 310; inline void DebugOptions::clear_xla_gpu_per_fusion_autotune_cache_dir() { _impl_.xla_gpu_per_fusion_autotune_cache_dir_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_gpu_per_fusion_autotune_cache_dir() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_per_fusion_autotune_cache_dir) return _internal_xla_gpu_per_fusion_autotune_cache_dir(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_per_fusion_autotune_cache_dir(ArgT0&& arg0, ArgT... args) { _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_per_fusion_autotune_cache_dir) } inline std::string* DebugOptions::mutable_xla_gpu_per_fusion_autotune_cache_dir() { std::string* _s = _internal_mutable_xla_gpu_per_fusion_autotune_cache_dir(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_per_fusion_autotune_cache_dir) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_per_fusion_autotune_cache_dir() const { return _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Get(); } inline void DebugOptions::_internal_set_xla_gpu_per_fusion_autotune_cache_dir(const std::string& value) { _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_gpu_per_fusion_autotune_cache_dir() { return _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_gpu_per_fusion_autotune_cache_dir() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_per_fusion_autotune_cache_dir) return _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Release(); } inline void DebugOptions::set_allocated_xla_gpu_per_fusion_autotune_cache_dir(std::string* xla_gpu_per_fusion_autotune_cache_dir) { if (xla_gpu_per_fusion_autotune_cache_dir != nullptr) { } else { } _impl_.xla_gpu_per_fusion_autotune_cache_dir_.SetAllocated(xla_gpu_per_fusion_autotune_cache_dir, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_gpu_per_fusion_autotune_cache_dir_.IsDefault()) { _impl_.xla_gpu_per_fusion_autotune_cache_dir_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_per_fusion_autotune_cache_dir) } // .xla.DebugOptions.PGLEStrictnessLevel xla_gpu_pgle_accuracy_checker = 341; inline void DebugOptions::clear_xla_gpu_pgle_accuracy_checker() { _impl_.xla_gpu_pgle_accuracy_checker_ = 0; } inline ::xla::DebugOptions_PGLEStrictnessLevel DebugOptions::_internal_xla_gpu_pgle_accuracy_checker() const { return static_cast< ::xla::DebugOptions_PGLEStrictnessLevel >(_impl_.xla_gpu_pgle_accuracy_checker_); } inline ::xla::DebugOptions_PGLEStrictnessLevel DebugOptions::xla_gpu_pgle_accuracy_checker() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_pgle_accuracy_checker) return _internal_xla_gpu_pgle_accuracy_checker(); } inline void DebugOptions::_internal_set_xla_gpu_pgle_accuracy_checker(::xla::DebugOptions_PGLEStrictnessLevel value) { _impl_.xla_gpu_pgle_accuracy_checker_ = value; } inline void DebugOptions::set_xla_gpu_pgle_accuracy_checker(::xla::DebugOptions_PGLEStrictnessLevel value) { _internal_set_xla_gpu_pgle_accuracy_checker(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_pgle_accuracy_checker) } // string xla_gpu_pgle_profile_file_or_directory_path = 210; inline void DebugOptions::clear_xla_gpu_pgle_profile_file_or_directory_path() { _impl_.xla_gpu_pgle_profile_file_or_directory_path_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_gpu_pgle_profile_file_or_directory_path() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_pgle_profile_file_or_directory_path) return _internal_xla_gpu_pgle_profile_file_or_directory_path(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_pgle_profile_file_or_directory_path(ArgT0&& arg0, ArgT... args) { _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_pgle_profile_file_or_directory_path) } inline std::string* DebugOptions::mutable_xla_gpu_pgle_profile_file_or_directory_path() { std::string* _s = _internal_mutable_xla_gpu_pgle_profile_file_or_directory_path(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_pgle_profile_file_or_directory_path) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_pgle_profile_file_or_directory_path() const { return _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Get(); } inline void DebugOptions::_internal_set_xla_gpu_pgle_profile_file_or_directory_path(const std::string& value) { _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_gpu_pgle_profile_file_or_directory_path() { return _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_gpu_pgle_profile_file_or_directory_path() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_pgle_profile_file_or_directory_path) return _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Release(); } inline void DebugOptions::set_allocated_xla_gpu_pgle_profile_file_or_directory_path(std::string* xla_gpu_pgle_profile_file_or_directory_path) { if (xla_gpu_pgle_profile_file_or_directory_path != nullptr) { } else { } _impl_.xla_gpu_pgle_profile_file_or_directory_path_.SetAllocated(xla_gpu_pgle_profile_file_or_directory_path, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_gpu_pgle_profile_file_or_directory_path_.IsDefault()) { _impl_.xla_gpu_pgle_profile_file_or_directory_path_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_pgle_profile_file_or_directory_path) } // repeated string xla_gpu_ptx_file = 127; inline int DebugOptions::_internal_xla_gpu_ptx_file_size() const { return _impl_.xla_gpu_ptx_file_.size(); } inline int DebugOptions::xla_gpu_ptx_file_size() const { return _internal_xla_gpu_ptx_file_size(); } inline void DebugOptions::clear_xla_gpu_ptx_file() { _impl_.xla_gpu_ptx_file_.Clear(); } inline std::string* DebugOptions::add_xla_gpu_ptx_file() { std::string* _s = _internal_add_xla_gpu_ptx_file(); // @@protoc_insertion_point(field_add_mutable:xla.DebugOptions.xla_gpu_ptx_file) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_ptx_file(int index) const { return _impl_.xla_gpu_ptx_file_.Get(index); } inline const std::string& DebugOptions::xla_gpu_ptx_file(int index) const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_ptx_file) return _internal_xla_gpu_ptx_file(index); } inline std::string* DebugOptions::mutable_xla_gpu_ptx_file(int index) { // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_ptx_file) return _impl_.xla_gpu_ptx_file_.Mutable(index); } inline void DebugOptions::set_xla_gpu_ptx_file(int index, const std::string& value) { _impl_.xla_gpu_ptx_file_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_ptx_file) } inline void DebugOptions::set_xla_gpu_ptx_file(int index, std::string&& value) { _impl_.xla_gpu_ptx_file_.Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_ptx_file) } inline void DebugOptions::set_xla_gpu_ptx_file(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.xla_gpu_ptx_file_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:xla.DebugOptions.xla_gpu_ptx_file) } inline void DebugOptions::set_xla_gpu_ptx_file(int index, const char* value, size_t size) { _impl_.xla_gpu_ptx_file_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:xla.DebugOptions.xla_gpu_ptx_file) } inline std::string* DebugOptions::_internal_add_xla_gpu_ptx_file() { return _impl_.xla_gpu_ptx_file_.Add(); } inline void DebugOptions::add_xla_gpu_ptx_file(const std::string& value) { _impl_.xla_gpu_ptx_file_.Add()->assign(value); // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_gpu_ptx_file) } inline void DebugOptions::add_xla_gpu_ptx_file(std::string&& value) { _impl_.xla_gpu_ptx_file_.Add(std::move(value)); // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_gpu_ptx_file) } inline void DebugOptions::add_xla_gpu_ptx_file(const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.xla_gpu_ptx_file_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:xla.DebugOptions.xla_gpu_ptx_file) } inline void DebugOptions::add_xla_gpu_ptx_file(const char* value, size_t size) { _impl_.xla_gpu_ptx_file_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:xla.DebugOptions.xla_gpu_ptx_file) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& DebugOptions::xla_gpu_ptx_file() const { // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_gpu_ptx_file) return _impl_.xla_gpu_ptx_file_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* DebugOptions::mutable_xla_gpu_ptx_file() { // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_gpu_ptx_file) return &_impl_.xla_gpu_ptx_file_; } // int64 xla_gpu_reduce_scatter_combine_threshold_bytes = 213; inline void DebugOptions::clear_xla_gpu_reduce_scatter_combine_threshold_bytes() { _impl_.xla_gpu_reduce_scatter_combine_threshold_bytes_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_reduce_scatter_combine_threshold_bytes() const { return _impl_.xla_gpu_reduce_scatter_combine_threshold_bytes_; } inline int64_t DebugOptions::xla_gpu_reduce_scatter_combine_threshold_bytes() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_reduce_scatter_combine_threshold_bytes) return _internal_xla_gpu_reduce_scatter_combine_threshold_bytes(); } inline void DebugOptions::_internal_set_xla_gpu_reduce_scatter_combine_threshold_bytes(int64_t value) { _impl_.xla_gpu_reduce_scatter_combine_threshold_bytes_ = value; } inline void DebugOptions::set_xla_gpu_reduce_scatter_combine_threshold_bytes(int64_t value) { _internal_set_xla_gpu_reduce_scatter_combine_threshold_bytes(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_reduce_scatter_combine_threshold_bytes) } // int64 xla_gpu_redzone_padding_bytes = 228; inline void DebugOptions::clear_xla_gpu_redzone_padding_bytes() { _impl_.xla_gpu_redzone_padding_bytes_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_redzone_padding_bytes() const { return _impl_.xla_gpu_redzone_padding_bytes_; } inline int64_t DebugOptions::xla_gpu_redzone_padding_bytes() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_redzone_padding_bytes) return _internal_xla_gpu_redzone_padding_bytes(); } inline void DebugOptions::_internal_set_xla_gpu_redzone_padding_bytes(int64_t value) { _impl_.xla_gpu_redzone_padding_bytes_ = value; } inline void DebugOptions::set_xla_gpu_redzone_padding_bytes(int64_t value) { _internal_set_xla_gpu_redzone_padding_bytes(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_redzone_padding_bytes) } // int64 xla_gpu_redzone_scratch_max_megabytes = 167; inline void DebugOptions::clear_xla_gpu_redzone_scratch_max_megabytes() { _impl_.xla_gpu_redzone_scratch_max_megabytes_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_redzone_scratch_max_megabytes() const { return _impl_.xla_gpu_redzone_scratch_max_megabytes_; } inline int64_t DebugOptions::xla_gpu_redzone_scratch_max_megabytes() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_redzone_scratch_max_megabytes) return _internal_xla_gpu_redzone_scratch_max_megabytes(); } inline void DebugOptions::_internal_set_xla_gpu_redzone_scratch_max_megabytes(int64_t value) { _impl_.xla_gpu_redzone_scratch_max_megabytes_ = value; } inline void DebugOptions::set_xla_gpu_redzone_scratch_max_megabytes(int64_t value) { _internal_set_xla_gpu_redzone_scratch_max_megabytes(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_redzone_scratch_max_megabytes) } // bool xla_gpu_require_complete_aot_autotune_results = 284; inline void DebugOptions::clear_xla_gpu_require_complete_aot_autotune_results() { _impl_.xla_gpu_require_complete_aot_autotune_results_ = false; } inline bool DebugOptions::_internal_xla_gpu_require_complete_aot_autotune_results() const { return _impl_.xla_gpu_require_complete_aot_autotune_results_; } inline bool DebugOptions::xla_gpu_require_complete_aot_autotune_results() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_require_complete_aot_autotune_results) return _internal_xla_gpu_require_complete_aot_autotune_results(); } inline void DebugOptions::_internal_set_xla_gpu_require_complete_aot_autotune_results(bool value) { _impl_.xla_gpu_require_complete_aot_autotune_results_ = value; } inline void DebugOptions::set_xla_gpu_require_complete_aot_autotune_results(bool value) { _internal_set_xla_gpu_require_complete_aot_autotune_results(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_require_complete_aot_autotune_results) } // bool xla_gpu_require_exclusive_lock = 347; inline void DebugOptions::clear_xla_gpu_require_exclusive_lock() { _impl_.xla_gpu_require_exclusive_lock_ = false; } inline bool DebugOptions::_internal_xla_gpu_require_exclusive_lock() const { return _impl_.xla_gpu_require_exclusive_lock_; } inline bool DebugOptions::xla_gpu_require_exclusive_lock() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_require_exclusive_lock) return _internal_xla_gpu_require_exclusive_lock(); } inline void DebugOptions::_internal_set_xla_gpu_require_exclusive_lock(bool value) { _impl_.xla_gpu_require_exclusive_lock_ = value; } inline void DebugOptions::set_xla_gpu_require_exclusive_lock(bool value) { _internal_set_xla_gpu_require_exclusive_lock(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_require_exclusive_lock) } // .xla.DebugOptions.ShapeChecks xla_gpu_shape_checks = 170; inline void DebugOptions::clear_xla_gpu_shape_checks() { _impl_.xla_gpu_shape_checks_ = 0; } inline ::xla::DebugOptions_ShapeChecks DebugOptions::_internal_xla_gpu_shape_checks() const { return static_cast< ::xla::DebugOptions_ShapeChecks >(_impl_.xla_gpu_shape_checks_); } inline ::xla::DebugOptions_ShapeChecks DebugOptions::xla_gpu_shape_checks() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_shape_checks) return _internal_xla_gpu_shape_checks(); } inline void DebugOptions::_internal_set_xla_gpu_shape_checks(::xla::DebugOptions_ShapeChecks value) { _impl_.xla_gpu_shape_checks_ = value; } inline void DebugOptions::set_xla_gpu_shape_checks(::xla::DebugOptions_ShapeChecks value) { _internal_set_xla_gpu_shape_checks(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_shape_checks) } // bool xla_gpu_shard_autotuning = 304; inline void DebugOptions::clear_xla_gpu_shard_autotuning() { _impl_.xla_gpu_shard_autotuning_ = false; } inline bool DebugOptions::_internal_xla_gpu_shard_autotuning() const { return _impl_.xla_gpu_shard_autotuning_; } inline bool DebugOptions::xla_gpu_shard_autotuning() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_shard_autotuning) return _internal_xla_gpu_shard_autotuning(); } inline void DebugOptions::_internal_set_xla_gpu_shard_autotuning(bool value) { _impl_.xla_gpu_shard_autotuning_ = value; } inline void DebugOptions::set_xla_gpu_shard_autotuning(bool value) { _internal_set_xla_gpu_shard_autotuning(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_shard_autotuning) } // bool xla_gpu_strict_conv_algorithm_picker = 156; inline void DebugOptions::clear_xla_gpu_strict_conv_algorithm_picker() { _impl_.xla_gpu_strict_conv_algorithm_picker_ = false; } inline bool DebugOptions::_internal_xla_gpu_strict_conv_algorithm_picker() const { return _impl_.xla_gpu_strict_conv_algorithm_picker_; } inline bool DebugOptions::xla_gpu_strict_conv_algorithm_picker() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_strict_conv_algorithm_picker) return _internal_xla_gpu_strict_conv_algorithm_picker(); } inline void DebugOptions::_internal_set_xla_gpu_strict_conv_algorithm_picker(bool value) { _impl_.xla_gpu_strict_conv_algorithm_picker_ = value; } inline void DebugOptions::set_xla_gpu_strict_conv_algorithm_picker(bool value) { _internal_set_xla_gpu_strict_conv_algorithm_picker(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_strict_conv_algorithm_picker) } // string xla_gpu_target_config_filename = 261; inline void DebugOptions::clear_xla_gpu_target_config_filename() { _impl_.xla_gpu_target_config_filename_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_gpu_target_config_filename() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_target_config_filename) return _internal_xla_gpu_target_config_filename(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_gpu_target_config_filename(ArgT0&& arg0, ArgT... args) { _impl_.xla_gpu_target_config_filename_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_target_config_filename) } inline std::string* DebugOptions::mutable_xla_gpu_target_config_filename() { std::string* _s = _internal_mutable_xla_gpu_target_config_filename(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_gpu_target_config_filename) return _s; } inline const std::string& DebugOptions::_internal_xla_gpu_target_config_filename() const { return _impl_.xla_gpu_target_config_filename_.Get(); } inline void DebugOptions::_internal_set_xla_gpu_target_config_filename(const std::string& value) { _impl_.xla_gpu_target_config_filename_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_gpu_target_config_filename() { return _impl_.xla_gpu_target_config_filename_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_gpu_target_config_filename() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_gpu_target_config_filename) return _impl_.xla_gpu_target_config_filename_.Release(); } inline void DebugOptions::set_allocated_xla_gpu_target_config_filename(std::string* xla_gpu_target_config_filename) { if (xla_gpu_target_config_filename != nullptr) { } else { } _impl_.xla_gpu_target_config_filename_.SetAllocated(xla_gpu_target_config_filename, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_gpu_target_config_filename_.IsDefault()) { _impl_.xla_gpu_target_config_filename_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_gpu_target_config_filename) } // bool xla_gpu_temp_buffer_use_separate_color = 312; inline void DebugOptions::clear_xla_gpu_temp_buffer_use_separate_color() { _impl_.xla_gpu_temp_buffer_use_separate_color_ = false; } inline bool DebugOptions::_internal_xla_gpu_temp_buffer_use_separate_color() const { return _impl_.xla_gpu_temp_buffer_use_separate_color_; } inline bool DebugOptions::xla_gpu_temp_buffer_use_separate_color() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_temp_buffer_use_separate_color) return _internal_xla_gpu_temp_buffer_use_separate_color(); } inline void DebugOptions::_internal_set_xla_gpu_temp_buffer_use_separate_color(bool value) { _impl_.xla_gpu_temp_buffer_use_separate_color_ = value; } inline void DebugOptions::set_xla_gpu_temp_buffer_use_separate_color(bool value) { _internal_set_xla_gpu_temp_buffer_use_separate_color(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_temp_buffer_use_separate_color) } // int64 xla_gpu_threshold_for_windowed_einsum_mib = 265; inline void DebugOptions::clear_xla_gpu_threshold_for_windowed_einsum_mib() { _impl_.xla_gpu_threshold_for_windowed_einsum_mib_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_gpu_threshold_for_windowed_einsum_mib() const { return _impl_.xla_gpu_threshold_for_windowed_einsum_mib_; } inline int64_t DebugOptions::xla_gpu_threshold_for_windowed_einsum_mib() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_threshold_for_windowed_einsum_mib) return _internal_xla_gpu_threshold_for_windowed_einsum_mib(); } inline void DebugOptions::_internal_set_xla_gpu_threshold_for_windowed_einsum_mib(int64_t value) { _impl_.xla_gpu_threshold_for_windowed_einsum_mib_ = value; } inline void DebugOptions::set_xla_gpu_threshold_for_windowed_einsum_mib(int64_t value) { _internal_set_xla_gpu_threshold_for_windowed_einsum_mib(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_threshold_for_windowed_einsum_mib) } // bool xla_gpu_triton_gemm_any = 190; inline void DebugOptions::clear_xla_gpu_triton_gemm_any() { _impl_.xla_gpu_triton_gemm_any_ = false; } inline bool DebugOptions::_internal_xla_gpu_triton_gemm_any() const { return _impl_.xla_gpu_triton_gemm_any_; } inline bool DebugOptions::xla_gpu_triton_gemm_any() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_triton_gemm_any) return _internal_xla_gpu_triton_gemm_any(); } inline void DebugOptions::_internal_set_xla_gpu_triton_gemm_any(bool value) { _impl_.xla_gpu_triton_gemm_any_ = value; } inline void DebugOptions::set_xla_gpu_triton_gemm_any(bool value) { _internal_set_xla_gpu_triton_gemm_any(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_triton_gemm_any) } // bool xla_gpu_triton_gemm_disable_reduced_precision_reduction = 226; inline void DebugOptions::clear_xla_gpu_triton_gemm_disable_reduced_precision_reduction() { _impl_.xla_gpu_triton_gemm_disable_reduced_precision_reduction_ = false; } inline bool DebugOptions::_internal_xla_gpu_triton_gemm_disable_reduced_precision_reduction() const { return _impl_.xla_gpu_triton_gemm_disable_reduced_precision_reduction_; } inline bool DebugOptions::xla_gpu_triton_gemm_disable_reduced_precision_reduction() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_triton_gemm_disable_reduced_precision_reduction) return _internal_xla_gpu_triton_gemm_disable_reduced_precision_reduction(); } inline void DebugOptions::_internal_set_xla_gpu_triton_gemm_disable_reduced_precision_reduction(bool value) { _impl_.xla_gpu_triton_gemm_disable_reduced_precision_reduction_ = value; } inline void DebugOptions::set_xla_gpu_triton_gemm_disable_reduced_precision_reduction(bool value) { _internal_set_xla_gpu_triton_gemm_disable_reduced_precision_reduction(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_triton_gemm_disable_reduced_precision_reduction) } // bool xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found = 138; inline void DebugOptions::clear_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() { _impl_.xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found_ = false; } inline bool DebugOptions::_internal_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() const { return _impl_.xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found_; } inline bool DebugOptions::xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found) return _internal_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found(); } inline void DebugOptions::_internal_set_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found(bool value) { _impl_.xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found_ = value; } inline void DebugOptions::set_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found(bool value) { _internal_set_xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsafe_fallback_to_driver_on_ptxas_not_found) } // bool xla_gpu_unsafe_pipelined_loop_annotator = 309; inline void DebugOptions::clear_xla_gpu_unsafe_pipelined_loop_annotator() { _impl_.xla_gpu_unsafe_pipelined_loop_annotator_ = false; } inline bool DebugOptions::_internal_xla_gpu_unsafe_pipelined_loop_annotator() const { return _impl_.xla_gpu_unsafe_pipelined_loop_annotator_; } inline bool DebugOptions::xla_gpu_unsafe_pipelined_loop_annotator() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsafe_pipelined_loop_annotator) return _internal_xla_gpu_unsafe_pipelined_loop_annotator(); } inline void DebugOptions::_internal_set_xla_gpu_unsafe_pipelined_loop_annotator(bool value) { _impl_.xla_gpu_unsafe_pipelined_loop_annotator_ = value; } inline void DebugOptions::set_xla_gpu_unsafe_pipelined_loop_annotator(bool value) { _internal_set_xla_gpu_unsafe_pipelined_loop_annotator(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsafe_pipelined_loop_annotator) } // bool xla_gpu_unsupported_annotate_with_emitter_loc = 358; inline void DebugOptions::clear_xla_gpu_unsupported_annotate_with_emitter_loc() { _impl_.xla_gpu_unsupported_annotate_with_emitter_loc_ = false; } inline bool DebugOptions::_internal_xla_gpu_unsupported_annotate_with_emitter_loc() const { return _impl_.xla_gpu_unsupported_annotate_with_emitter_loc_; } inline bool DebugOptions::xla_gpu_unsupported_annotate_with_emitter_loc() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsupported_annotate_with_emitter_loc) return _internal_xla_gpu_unsupported_annotate_with_emitter_loc(); } inline void DebugOptions::_internal_set_xla_gpu_unsupported_annotate_with_emitter_loc(bool value) { _impl_.xla_gpu_unsupported_annotate_with_emitter_loc_ = value; } inline void DebugOptions::set_xla_gpu_unsupported_annotate_with_emitter_loc(bool value) { _internal_set_xla_gpu_unsupported_annotate_with_emitter_loc(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsupported_annotate_with_emitter_loc) } // bool xla_gpu_unsupported_enable_ragged_all_to_all_decomposer = 350; inline void DebugOptions::clear_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() { _impl_.xla_gpu_unsupported_enable_ragged_all_to_all_decomposer_ = false; } inline bool DebugOptions::_internal_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() const { return _impl_.xla_gpu_unsupported_enable_ragged_all_to_all_decomposer_; } inline bool DebugOptions::xla_gpu_unsupported_enable_ragged_all_to_all_decomposer() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsupported_enable_ragged_all_to_all_decomposer) return _internal_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer(); } inline void DebugOptions::_internal_set_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer(bool value) { _impl_.xla_gpu_unsupported_enable_ragged_all_to_all_decomposer_ = value; } inline void DebugOptions::set_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer(bool value) { _internal_set_xla_gpu_unsupported_enable_ragged_all_to_all_decomposer(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsupported_enable_ragged_all_to_all_decomposer) } // bool xla_gpu_unsupported_enable_triton_gemm = 322; inline void DebugOptions::clear_xla_gpu_unsupported_enable_triton_gemm() { _impl_.xla_gpu_unsupported_enable_triton_gemm_ = false; } inline bool DebugOptions::_internal_xla_gpu_unsupported_enable_triton_gemm() const { return _impl_.xla_gpu_unsupported_enable_triton_gemm_; } inline bool DebugOptions::xla_gpu_unsupported_enable_triton_gemm() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_unsupported_enable_triton_gemm) return _internal_xla_gpu_unsupported_enable_triton_gemm(); } inline void DebugOptions::_internal_set_xla_gpu_unsupported_enable_triton_gemm(bool value) { _impl_.xla_gpu_unsupported_enable_triton_gemm_ = value; } inline void DebugOptions::set_xla_gpu_unsupported_enable_triton_gemm(bool value) { _internal_set_xla_gpu_unsupported_enable_triton_gemm(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_unsupported_enable_triton_gemm) } // bool xla_gpu_use_memcpy_local_p2p = 287; inline void DebugOptions::clear_xla_gpu_use_memcpy_local_p2p() { _impl_.xla_gpu_use_memcpy_local_p2p_ = false; } inline bool DebugOptions::_internal_xla_gpu_use_memcpy_local_p2p() const { return _impl_.xla_gpu_use_memcpy_local_p2p_; } inline bool DebugOptions::xla_gpu_use_memcpy_local_p2p() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_use_memcpy_local_p2p) return _internal_xla_gpu_use_memcpy_local_p2p(); } inline void DebugOptions::_internal_set_xla_gpu_use_memcpy_local_p2p(bool value) { _impl_.xla_gpu_use_memcpy_local_p2p_ = value; } inline void DebugOptions::set_xla_gpu_use_memcpy_local_p2p(bool value) { _internal_set_xla_gpu_use_memcpy_local_p2p(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_use_memcpy_local_p2p) } // bool xla_gpu_use_runtime_fusion = 181; inline void DebugOptions::clear_xla_gpu_use_runtime_fusion() { _impl_.xla_gpu_use_runtime_fusion_ = false; } inline bool DebugOptions::_internal_xla_gpu_use_runtime_fusion() const { return _impl_.xla_gpu_use_runtime_fusion_; } inline bool DebugOptions::xla_gpu_use_runtime_fusion() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_use_runtime_fusion) return _internal_xla_gpu_use_runtime_fusion(); } inline void DebugOptions::_internal_set_xla_gpu_use_runtime_fusion(bool value) { _impl_.xla_gpu_use_runtime_fusion_ = value; } inline void DebugOptions::set_xla_gpu_use_runtime_fusion(bool value) { _internal_set_xla_gpu_use_runtime_fusion(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_use_runtime_fusion) } // bool xla_gpu_verify_triton_fusion_numerics = 291; inline void DebugOptions::clear_xla_gpu_verify_triton_fusion_numerics() { _impl_.xla_gpu_verify_triton_fusion_numerics_ = false; } inline bool DebugOptions::_internal_xla_gpu_verify_triton_fusion_numerics() const { return _impl_.xla_gpu_verify_triton_fusion_numerics_; } inline bool DebugOptions::xla_gpu_verify_triton_fusion_numerics() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_gpu_verify_triton_fusion_numerics) return _internal_xla_gpu_verify_triton_fusion_numerics(); } inline void DebugOptions::_internal_set_xla_gpu_verify_triton_fusion_numerics(bool value) { _impl_.xla_gpu_verify_triton_fusion_numerics_ = value; } inline void DebugOptions::set_xla_gpu_verify_triton_fusion_numerics(bool value) { _internal_set_xla_gpu_verify_triton_fusion_numerics(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_gpu_verify_triton_fusion_numerics) } // bool xla_hlo_graph_addresses = 2; inline void DebugOptions::clear_xla_hlo_graph_addresses() { _impl_.xla_hlo_graph_addresses_ = false; } inline bool DebugOptions::_internal_xla_hlo_graph_addresses() const { return _impl_.xla_hlo_graph_addresses_; } inline bool DebugOptions::xla_hlo_graph_addresses() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_hlo_graph_addresses) return _internal_xla_hlo_graph_addresses(); } inline void DebugOptions::_internal_set_xla_hlo_graph_addresses(bool value) { _impl_.xla_hlo_graph_addresses_ = value; } inline void DebugOptions::set_xla_hlo_graph_addresses(bool value) { _internal_set_xla_hlo_graph_addresses(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_hlo_graph_addresses) } // bool xla_hlo_profile = 9; inline void DebugOptions::clear_xla_hlo_profile() { _impl_.xla_hlo_profile_ = false; } inline bool DebugOptions::_internal_xla_hlo_profile() const { return _impl_.xla_hlo_profile_; } inline bool DebugOptions::xla_hlo_profile() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_hlo_profile) return _internal_xla_hlo_profile(); } inline void DebugOptions::_internal_set_xla_hlo_profile(bool value) { _impl_.xla_hlo_profile_ = value; } inline void DebugOptions::set_xla_hlo_profile(bool value) { _internal_set_xla_hlo_profile(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_hlo_profile) } // repeated string xla_disable_hlo_passes = 30; inline int DebugOptions::_internal_xla_disable_hlo_passes_size() const { return _impl_.xla_disable_hlo_passes_.size(); } inline int DebugOptions::xla_disable_hlo_passes_size() const { return _internal_xla_disable_hlo_passes_size(); } inline void DebugOptions::clear_xla_disable_hlo_passes() { _impl_.xla_disable_hlo_passes_.Clear(); } inline std::string* DebugOptions::add_xla_disable_hlo_passes() { std::string* _s = _internal_add_xla_disable_hlo_passes(); // @@protoc_insertion_point(field_add_mutable:xla.DebugOptions.xla_disable_hlo_passes) return _s; } inline const std::string& DebugOptions::_internal_xla_disable_hlo_passes(int index) const { return _impl_.xla_disable_hlo_passes_.Get(index); } inline const std::string& DebugOptions::xla_disable_hlo_passes(int index) const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_disable_hlo_passes) return _internal_xla_disable_hlo_passes(index); } inline std::string* DebugOptions::mutable_xla_disable_hlo_passes(int index) { // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_disable_hlo_passes) return _impl_.xla_disable_hlo_passes_.Mutable(index); } inline void DebugOptions::set_xla_disable_hlo_passes(int index, const std::string& value) { _impl_.xla_disable_hlo_passes_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_disable_hlo_passes) } inline void DebugOptions::set_xla_disable_hlo_passes(int index, std::string&& value) { _impl_.xla_disable_hlo_passes_.Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_disable_hlo_passes) } inline void DebugOptions::set_xla_disable_hlo_passes(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.xla_disable_hlo_passes_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:xla.DebugOptions.xla_disable_hlo_passes) } inline void DebugOptions::set_xla_disable_hlo_passes(int index, const char* value, size_t size) { _impl_.xla_disable_hlo_passes_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:xla.DebugOptions.xla_disable_hlo_passes) } inline std::string* DebugOptions::_internal_add_xla_disable_hlo_passes() { return _impl_.xla_disable_hlo_passes_.Add(); } inline void DebugOptions::add_xla_disable_hlo_passes(const std::string& value) { _impl_.xla_disable_hlo_passes_.Add()->assign(value); // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_disable_hlo_passes) } inline void DebugOptions::add_xla_disable_hlo_passes(std::string&& value) { _impl_.xla_disable_hlo_passes_.Add(std::move(value)); // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_disable_hlo_passes) } inline void DebugOptions::add_xla_disable_hlo_passes(const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.xla_disable_hlo_passes_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:xla.DebugOptions.xla_disable_hlo_passes) } inline void DebugOptions::add_xla_disable_hlo_passes(const char* value, size_t size) { _impl_.xla_disable_hlo_passes_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:xla.DebugOptions.xla_disable_hlo_passes) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& DebugOptions::xla_disable_hlo_passes() const { // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_disable_hlo_passes) return _impl_.xla_disable_hlo_passes_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* DebugOptions::mutable_xla_disable_hlo_passes() { // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_disable_hlo_passes) return &_impl_.xla_disable_hlo_passes_; } // repeated string xla_enable_hlo_passes_only = 124; inline int DebugOptions::_internal_xla_enable_hlo_passes_only_size() const { return _impl_.xla_enable_hlo_passes_only_.size(); } inline int DebugOptions::xla_enable_hlo_passes_only_size() const { return _internal_xla_enable_hlo_passes_only_size(); } inline void DebugOptions::clear_xla_enable_hlo_passes_only() { _impl_.xla_enable_hlo_passes_only_.Clear(); } inline std::string* DebugOptions::add_xla_enable_hlo_passes_only() { std::string* _s = _internal_add_xla_enable_hlo_passes_only(); // @@protoc_insertion_point(field_add_mutable:xla.DebugOptions.xla_enable_hlo_passes_only) return _s; } inline const std::string& DebugOptions::_internal_xla_enable_hlo_passes_only(int index) const { return _impl_.xla_enable_hlo_passes_only_.Get(index); } inline const std::string& DebugOptions::xla_enable_hlo_passes_only(int index) const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_enable_hlo_passes_only) return _internal_xla_enable_hlo_passes_only(index); } inline std::string* DebugOptions::mutable_xla_enable_hlo_passes_only(int index) { // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_enable_hlo_passes_only) return _impl_.xla_enable_hlo_passes_only_.Mutable(index); } inline void DebugOptions::set_xla_enable_hlo_passes_only(int index, const std::string& value) { _impl_.xla_enable_hlo_passes_only_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_enable_hlo_passes_only) } inline void DebugOptions::set_xla_enable_hlo_passes_only(int index, std::string&& value) { _impl_.xla_enable_hlo_passes_only_.Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_enable_hlo_passes_only) } inline void DebugOptions::set_xla_enable_hlo_passes_only(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.xla_enable_hlo_passes_only_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:xla.DebugOptions.xla_enable_hlo_passes_only) } inline void DebugOptions::set_xla_enable_hlo_passes_only(int index, const char* value, size_t size) { _impl_.xla_enable_hlo_passes_only_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:xla.DebugOptions.xla_enable_hlo_passes_only) } inline std::string* DebugOptions::_internal_add_xla_enable_hlo_passes_only() { return _impl_.xla_enable_hlo_passes_only_.Add(); } inline void DebugOptions::add_xla_enable_hlo_passes_only(const std::string& value) { _impl_.xla_enable_hlo_passes_only_.Add()->assign(value); // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_enable_hlo_passes_only) } inline void DebugOptions::add_xla_enable_hlo_passes_only(std::string&& value) { _impl_.xla_enable_hlo_passes_only_.Add(std::move(value)); // @@protoc_insertion_point(field_add:xla.DebugOptions.xla_enable_hlo_passes_only) } inline void DebugOptions::add_xla_enable_hlo_passes_only(const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.xla_enable_hlo_passes_only_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:xla.DebugOptions.xla_enable_hlo_passes_only) } inline void DebugOptions::add_xla_enable_hlo_passes_only(const char* value, size_t size) { _impl_.xla_enable_hlo_passes_only_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:xla.DebugOptions.xla_enable_hlo_passes_only) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& DebugOptions::xla_enable_hlo_passes_only() const { // @@protoc_insertion_point(field_list:xla.DebugOptions.xla_enable_hlo_passes_only) return _impl_.xla_enable_hlo_passes_only_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* DebugOptions::mutable_xla_enable_hlo_passes_only() { // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.xla_enable_hlo_passes_only) return &_impl_.xla_enable_hlo_passes_only_; } // bool xla_disable_all_hlo_passes = 104; inline void DebugOptions::clear_xla_disable_all_hlo_passes() { _impl_.xla_disable_all_hlo_passes_ = false; } inline bool DebugOptions::_internal_xla_disable_all_hlo_passes() const { return _impl_.xla_disable_all_hlo_passes_; } inline bool DebugOptions::xla_disable_all_hlo_passes() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_disable_all_hlo_passes) return _internal_xla_disable_all_hlo_passes(); } inline void DebugOptions::_internal_set_xla_disable_all_hlo_passes(bool value) { _impl_.xla_disable_all_hlo_passes_ = value; } inline void DebugOptions::set_xla_disable_all_hlo_passes(bool value) { _internal_set_xla_disable_all_hlo_passes(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_disable_all_hlo_passes) } // int32 xla_backend_optimization_level = 31; inline void DebugOptions::clear_xla_backend_optimization_level() { _impl_.xla_backend_optimization_level_ = 0; } inline int32_t DebugOptions::_internal_xla_backend_optimization_level() const { return _impl_.xla_backend_optimization_level_; } inline int32_t DebugOptions::xla_backend_optimization_level() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_backend_optimization_level) return _internal_xla_backend_optimization_level(); } inline void DebugOptions::_internal_set_xla_backend_optimization_level(int32_t value) { _impl_.xla_backend_optimization_level_ = value; } inline void DebugOptions::set_xla_backend_optimization_level(int32_t value) { _internal_set_xla_backend_optimization_level(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_backend_optimization_level) } // bool xla_embed_ir_in_executable = 33; inline void DebugOptions::clear_xla_embed_ir_in_executable() { _impl_.xla_embed_ir_in_executable_ = false; } inline bool DebugOptions::_internal_xla_embed_ir_in_executable() const { return _impl_.xla_embed_ir_in_executable_; } inline bool DebugOptions::xla_embed_ir_in_executable() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_embed_ir_in_executable) return _internal_xla_embed_ir_in_executable(); } inline void DebugOptions::_internal_set_xla_embed_ir_in_executable(bool value) { _impl_.xla_embed_ir_in_executable_ = value; } inline void DebugOptions::set_xla_embed_ir_in_executable(bool value) { _internal_set_xla_embed_ir_in_executable(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_embed_ir_in_executable) } // bool xla_eliminate_hlo_implicit_broadcast = 35; inline void DebugOptions::clear_xla_eliminate_hlo_implicit_broadcast() { _impl_.xla_eliminate_hlo_implicit_broadcast_ = false; } inline bool DebugOptions::_internal_xla_eliminate_hlo_implicit_broadcast() const { return _impl_.xla_eliminate_hlo_implicit_broadcast_; } inline bool DebugOptions::xla_eliminate_hlo_implicit_broadcast() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_eliminate_hlo_implicit_broadcast) return _internal_xla_eliminate_hlo_implicit_broadcast(); } inline void DebugOptions::_internal_set_xla_eliminate_hlo_implicit_broadcast(bool value) { _impl_.xla_eliminate_hlo_implicit_broadcast_ = value; } inline void DebugOptions::set_xla_eliminate_hlo_implicit_broadcast(bool value) { _internal_set_xla_eliminate_hlo_implicit_broadcast(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_eliminate_hlo_implicit_broadcast) } // bool xla_cpu_multi_thread_eigen = 60; inline void DebugOptions::clear_xla_cpu_multi_thread_eigen() { _impl_.xla_cpu_multi_thread_eigen_ = false; } inline bool DebugOptions::_internal_xla_cpu_multi_thread_eigen() const { return _impl_.xla_cpu_multi_thread_eigen_; } inline bool DebugOptions::xla_cpu_multi_thread_eigen() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_multi_thread_eigen) return _internal_xla_cpu_multi_thread_eigen(); } inline void DebugOptions::_internal_set_xla_cpu_multi_thread_eigen(bool value) { _impl_.xla_cpu_multi_thread_eigen_ = value; } inline void DebugOptions::set_xla_cpu_multi_thread_eigen(bool value) { _internal_set_xla_cpu_multi_thread_eigen(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_multi_thread_eigen) } // bool xla_llvm_enable_alias_scope_metadata = 70; inline void DebugOptions::clear_xla_llvm_enable_alias_scope_metadata() { _impl_.xla_llvm_enable_alias_scope_metadata_ = false; } inline bool DebugOptions::_internal_xla_llvm_enable_alias_scope_metadata() const { return _impl_.xla_llvm_enable_alias_scope_metadata_; } inline bool DebugOptions::xla_llvm_enable_alias_scope_metadata() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_llvm_enable_alias_scope_metadata) return _internal_xla_llvm_enable_alias_scope_metadata(); } inline void DebugOptions::_internal_set_xla_llvm_enable_alias_scope_metadata(bool value) { _impl_.xla_llvm_enable_alias_scope_metadata_ = value; } inline void DebugOptions::set_xla_llvm_enable_alias_scope_metadata(bool value) { _internal_set_xla_llvm_enable_alias_scope_metadata(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_llvm_enable_alias_scope_metadata) } // bool xla_llvm_enable_noalias_metadata = 71; inline void DebugOptions::clear_xla_llvm_enable_noalias_metadata() { _impl_.xla_llvm_enable_noalias_metadata_ = false; } inline bool DebugOptions::_internal_xla_llvm_enable_noalias_metadata() const { return _impl_.xla_llvm_enable_noalias_metadata_; } inline bool DebugOptions::xla_llvm_enable_noalias_metadata() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_llvm_enable_noalias_metadata) return _internal_xla_llvm_enable_noalias_metadata(); } inline void DebugOptions::_internal_set_xla_llvm_enable_noalias_metadata(bool value) { _impl_.xla_llvm_enable_noalias_metadata_ = value; } inline void DebugOptions::set_xla_llvm_enable_noalias_metadata(bool value) { _internal_set_xla_llvm_enable_noalias_metadata(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_llvm_enable_noalias_metadata) } // bool xla_llvm_enable_invariant_load_metadata = 72; inline void DebugOptions::clear_xla_llvm_enable_invariant_load_metadata() { _impl_.xla_llvm_enable_invariant_load_metadata_ = false; } inline bool DebugOptions::_internal_xla_llvm_enable_invariant_load_metadata() const { return _impl_.xla_llvm_enable_invariant_load_metadata_; } inline bool DebugOptions::xla_llvm_enable_invariant_load_metadata() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_llvm_enable_invariant_load_metadata) return _internal_xla_llvm_enable_invariant_load_metadata(); } inline void DebugOptions::_internal_set_xla_llvm_enable_invariant_load_metadata(bool value) { _impl_.xla_llvm_enable_invariant_load_metadata_ = value; } inline void DebugOptions::set_xla_llvm_enable_invariant_load_metadata(bool value) { _internal_set_xla_llvm_enable_invariant_load_metadata(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_llvm_enable_invariant_load_metadata) } // bool xla_llvm_disable_expensive_passes = 73; inline void DebugOptions::clear_xla_llvm_disable_expensive_passes() { _impl_.xla_llvm_disable_expensive_passes_ = false; } inline bool DebugOptions::_internal_xla_llvm_disable_expensive_passes() const { return _impl_.xla_llvm_disable_expensive_passes_; } inline bool DebugOptions::xla_llvm_disable_expensive_passes() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_llvm_disable_expensive_passes) return _internal_xla_llvm_disable_expensive_passes(); } inline void DebugOptions::_internal_set_xla_llvm_disable_expensive_passes(bool value) { _impl_.xla_llvm_disable_expensive_passes_ = value; } inline void DebugOptions::set_xla_llvm_disable_expensive_passes(bool value) { _internal_set_xla_llvm_disable_expensive_passes(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_llvm_disable_expensive_passes) } // bool xla_test_all_output_layouts = 90; inline void DebugOptions::clear_xla_test_all_output_layouts() { _impl_.xla_test_all_output_layouts_ = false; } inline bool DebugOptions::_internal_xla_test_all_output_layouts() const { return _impl_.xla_test_all_output_layouts_; } inline bool DebugOptions::xla_test_all_output_layouts() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_test_all_output_layouts) return _internal_xla_test_all_output_layouts(); } inline void DebugOptions::_internal_set_xla_test_all_output_layouts(bool value) { _impl_.xla_test_all_output_layouts_ = value; } inline void DebugOptions::set_xla_test_all_output_layouts(bool value) { _internal_set_xla_test_all_output_layouts(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_test_all_output_layouts) } // bool xla_test_all_input_layouts = 91; inline void DebugOptions::clear_xla_test_all_input_layouts() { _impl_.xla_test_all_input_layouts_ = false; } inline bool DebugOptions::_internal_xla_test_all_input_layouts() const { return _impl_.xla_test_all_input_layouts_; } inline bool DebugOptions::xla_test_all_input_layouts() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_test_all_input_layouts) return _internal_xla_test_all_input_layouts(); } inline void DebugOptions::_internal_set_xla_test_all_input_layouts(bool value) { _impl_.xla_test_all_input_layouts_ = value; } inline void DebugOptions::set_xla_test_all_input_layouts(bool value) { _internal_set_xla_test_all_input_layouts(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_test_all_input_layouts) } // bool xla_hlo_graph_sharding_color = 92; inline void DebugOptions::clear_xla_hlo_graph_sharding_color() { _impl_.xla_hlo_graph_sharding_color_ = false; } inline bool DebugOptions::_internal_xla_hlo_graph_sharding_color() const { return _impl_.xla_hlo_graph_sharding_color_; } inline bool DebugOptions::xla_hlo_graph_sharding_color() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_hlo_graph_sharding_color) return _internal_xla_hlo_graph_sharding_color(); } inline void DebugOptions::_internal_set_xla_hlo_graph_sharding_color(bool value) { _impl_.xla_hlo_graph_sharding_color_ = value; } inline void DebugOptions::set_xla_hlo_graph_sharding_color(bool value) { _internal_set_xla_hlo_graph_sharding_color(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_hlo_graph_sharding_color) } // bool xla_cpu_use_mkl_dnn = 97; inline void DebugOptions::clear_xla_cpu_use_mkl_dnn() { _impl_.xla_cpu_use_mkl_dnn_ = false; } inline bool DebugOptions::_internal_xla_cpu_use_mkl_dnn() const { return _impl_.xla_cpu_use_mkl_dnn_; } inline bool DebugOptions::xla_cpu_use_mkl_dnn() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_use_mkl_dnn) return _internal_xla_cpu_use_mkl_dnn(); } inline void DebugOptions::_internal_set_xla_cpu_use_mkl_dnn(bool value) { _impl_.xla_cpu_use_mkl_dnn_ = value; } inline void DebugOptions::set_xla_cpu_use_mkl_dnn(bool value) { _internal_set_xla_cpu_use_mkl_dnn(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_use_mkl_dnn) } // bool xla_allow_excess_precision = 122; inline void DebugOptions::clear_xla_allow_excess_precision() { _impl_.xla_allow_excess_precision_ = false; } inline bool DebugOptions::_internal_xla_allow_excess_precision() const { return _impl_.xla_allow_excess_precision_; } inline bool DebugOptions::xla_allow_excess_precision() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_allow_excess_precision) return _internal_xla_allow_excess_precision(); } inline void DebugOptions::_internal_set_xla_allow_excess_precision(bool value) { _impl_.xla_allow_excess_precision_ = value; } inline void DebugOptions::set_xla_allow_excess_precision(bool value) { _internal_set_xla_allow_excess_precision(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_allow_excess_precision) } // int32 xla_force_host_platform_device_count = 102; inline void DebugOptions::clear_xla_force_host_platform_device_count() { _impl_.xla_force_host_platform_device_count_ = 0; } inline int32_t DebugOptions::_internal_xla_force_host_platform_device_count() const { return _impl_.xla_force_host_platform_device_count_; } inline int32_t DebugOptions::xla_force_host_platform_device_count() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_force_host_platform_device_count) return _internal_xla_force_host_platform_device_count(); } inline void DebugOptions::_internal_set_xla_force_host_platform_device_count(int32_t value) { _impl_.xla_force_host_platform_device_count_ = value; } inline void DebugOptions::set_xla_force_host_platform_device_count(int32_t value) { _internal_set_xla_force_host_platform_device_count(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_force_host_platform_device_count) } // bool xla_hlo_evaluator_use_fast_path = 106; inline void DebugOptions::clear_xla_hlo_evaluator_use_fast_path() { _impl_.xla_hlo_evaluator_use_fast_path_ = false; } inline bool DebugOptions::_internal_xla_hlo_evaluator_use_fast_path() const { return _impl_.xla_hlo_evaluator_use_fast_path_; } inline bool DebugOptions::xla_hlo_evaluator_use_fast_path() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_hlo_evaluator_use_fast_path) return _internal_xla_hlo_evaluator_use_fast_path(); } inline void DebugOptions::_internal_set_xla_hlo_evaluator_use_fast_path(bool value) { _impl_.xla_hlo_evaluator_use_fast_path_ = value; } inline void DebugOptions::set_xla_hlo_evaluator_use_fast_path(bool value) { _internal_set_xla_hlo_evaluator_use_fast_path(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_hlo_evaluator_use_fast_path) } // bool xla_allow_scalar_index_dynamic_ops = 107; inline void DebugOptions::clear_xla_allow_scalar_index_dynamic_ops() { _impl_.xla_allow_scalar_index_dynamic_ops_ = false; } inline bool DebugOptions::_internal_xla_allow_scalar_index_dynamic_ops() const { return _impl_.xla_allow_scalar_index_dynamic_ops_; } inline bool DebugOptions::xla_allow_scalar_index_dynamic_ops() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_allow_scalar_index_dynamic_ops) return _internal_xla_allow_scalar_index_dynamic_ops(); } inline void DebugOptions::_internal_set_xla_allow_scalar_index_dynamic_ops(bool value) { _impl_.xla_allow_scalar_index_dynamic_ops_ = value; } inline void DebugOptions::set_xla_allow_scalar_index_dynamic_ops(bool value) { _internal_set_xla_allow_scalar_index_dynamic_ops(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_allow_scalar_index_dynamic_ops) } // .xla.DebugOptions.StepMarkerLocation xla_step_marker_location = 108; inline void DebugOptions::clear_xla_step_marker_location() { _impl_.xla_step_marker_location_ = 0; } inline ::xla::DebugOptions_StepMarkerLocation DebugOptions::_internal_xla_step_marker_location() const { return static_cast< ::xla::DebugOptions_StepMarkerLocation >(_impl_.xla_step_marker_location_); } inline ::xla::DebugOptions_StepMarkerLocation DebugOptions::xla_step_marker_location() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_step_marker_location) return _internal_xla_step_marker_location(); } inline void DebugOptions::_internal_set_xla_step_marker_location(::xla::DebugOptions_StepMarkerLocation value) { _impl_.xla_step_marker_location_ = value; } inline void DebugOptions::set_xla_step_marker_location(::xla::DebugOptions_StepMarkerLocation value) { _internal_set_xla_step_marker_location(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_step_marker_location) } // string xla_dump_to = 109; inline void DebugOptions::clear_xla_dump_to() { _impl_.xla_dump_to_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_dump_to() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_to) return _internal_xla_dump_to(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_dump_to(ArgT0&& arg0, ArgT... args) { _impl_.xla_dump_to_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_to) } inline std::string* DebugOptions::mutable_xla_dump_to() { std::string* _s = _internal_mutable_xla_dump_to(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_dump_to) return _s; } inline const std::string& DebugOptions::_internal_xla_dump_to() const { return _impl_.xla_dump_to_.Get(); } inline void DebugOptions::_internal_set_xla_dump_to(const std::string& value) { _impl_.xla_dump_to_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_dump_to() { return _impl_.xla_dump_to_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_dump_to() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_dump_to) return _impl_.xla_dump_to_.Release(); } inline void DebugOptions::set_allocated_xla_dump_to(std::string* xla_dump_to) { if (xla_dump_to != nullptr) { } else { } _impl_.xla_dump_to_.SetAllocated(xla_dump_to, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_dump_to_.IsDefault()) { _impl_.xla_dump_to_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_dump_to) } // bool xla_flags_reset = 364; inline void DebugOptions::clear_xla_flags_reset() { _impl_.xla_flags_reset_ = false; } inline bool DebugOptions::_internal_xla_flags_reset() const { return _impl_.xla_flags_reset_; } inline bool DebugOptions::xla_flags_reset() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_flags_reset) return _internal_xla_flags_reset(); } inline void DebugOptions::_internal_set_xla_flags_reset(bool value) { _impl_.xla_flags_reset_ = value; } inline void DebugOptions::set_xla_flags_reset(bool value) { _internal_set_xla_flags_reset(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_flags_reset) } // string xla_dump_hlo_module_re = 110; inline void DebugOptions::clear_xla_dump_hlo_module_re() { _impl_.xla_dump_hlo_module_re_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_dump_hlo_module_re() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_module_re) return _internal_xla_dump_hlo_module_re(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_dump_hlo_module_re(ArgT0&& arg0, ArgT... args) { _impl_.xla_dump_hlo_module_re_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_module_re) } inline std::string* DebugOptions::mutable_xla_dump_hlo_module_re() { std::string* _s = _internal_mutable_xla_dump_hlo_module_re(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_dump_hlo_module_re) return _s; } inline const std::string& DebugOptions::_internal_xla_dump_hlo_module_re() const { return _impl_.xla_dump_hlo_module_re_.Get(); } inline void DebugOptions::_internal_set_xla_dump_hlo_module_re(const std::string& value) { _impl_.xla_dump_hlo_module_re_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_dump_hlo_module_re() { return _impl_.xla_dump_hlo_module_re_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_dump_hlo_module_re() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_dump_hlo_module_re) return _impl_.xla_dump_hlo_module_re_.Release(); } inline void DebugOptions::set_allocated_xla_dump_hlo_module_re(std::string* xla_dump_hlo_module_re) { if (xla_dump_hlo_module_re != nullptr) { } else { } _impl_.xla_dump_hlo_module_re_.SetAllocated(xla_dump_hlo_module_re, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_dump_hlo_module_re_.IsDefault()) { _impl_.xla_dump_hlo_module_re_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_dump_hlo_module_re) } // string xla_dump_hlo_pass_re = 111; inline void DebugOptions::clear_xla_dump_hlo_pass_re() { _impl_.xla_dump_hlo_pass_re_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_dump_hlo_pass_re() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_pass_re) return _internal_xla_dump_hlo_pass_re(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_dump_hlo_pass_re(ArgT0&& arg0, ArgT... args) { _impl_.xla_dump_hlo_pass_re_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_pass_re) } inline std::string* DebugOptions::mutable_xla_dump_hlo_pass_re() { std::string* _s = _internal_mutable_xla_dump_hlo_pass_re(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_dump_hlo_pass_re) return _s; } inline const std::string& DebugOptions::_internal_xla_dump_hlo_pass_re() const { return _impl_.xla_dump_hlo_pass_re_.Get(); } inline void DebugOptions::_internal_set_xla_dump_hlo_pass_re(const std::string& value) { _impl_.xla_dump_hlo_pass_re_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_dump_hlo_pass_re() { return _impl_.xla_dump_hlo_pass_re_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_dump_hlo_pass_re() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_dump_hlo_pass_re) return _impl_.xla_dump_hlo_pass_re_.Release(); } inline void DebugOptions::set_allocated_xla_dump_hlo_pass_re(std::string* xla_dump_hlo_pass_re) { if (xla_dump_hlo_pass_re != nullptr) { } else { } _impl_.xla_dump_hlo_pass_re_.SetAllocated(xla_dump_hlo_pass_re, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_dump_hlo_pass_re_.IsDefault()) { _impl_.xla_dump_hlo_pass_re_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_dump_hlo_pass_re) } // bool xla_dump_hlo_as_text = 112; inline void DebugOptions::clear_xla_dump_hlo_as_text() { _impl_.xla_dump_hlo_as_text_ = false; } inline bool DebugOptions::_internal_xla_dump_hlo_as_text() const { return _impl_.xla_dump_hlo_as_text_; } inline bool DebugOptions::xla_dump_hlo_as_text() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_as_text) return _internal_xla_dump_hlo_as_text(); } inline void DebugOptions::_internal_set_xla_dump_hlo_as_text(bool value) { _impl_.xla_dump_hlo_as_text_ = value; } inline void DebugOptions::set_xla_dump_hlo_as_text(bool value) { _internal_set_xla_dump_hlo_as_text(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_as_text) } // bool xla_dump_hlo_as_proto = 113; inline void DebugOptions::clear_xla_dump_hlo_as_proto() { _impl_.xla_dump_hlo_as_proto_ = false; } inline bool DebugOptions::_internal_xla_dump_hlo_as_proto() const { return _impl_.xla_dump_hlo_as_proto_; } inline bool DebugOptions::xla_dump_hlo_as_proto() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_as_proto) return _internal_xla_dump_hlo_as_proto(); } inline void DebugOptions::_internal_set_xla_dump_hlo_as_proto(bool value) { _impl_.xla_dump_hlo_as_proto_ = value; } inline void DebugOptions::set_xla_dump_hlo_as_proto(bool value) { _internal_set_xla_dump_hlo_as_proto(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_as_proto) } // bool xla_dump_hlo_as_dot = 114; inline void DebugOptions::clear_xla_dump_hlo_as_dot() { _impl_.xla_dump_hlo_as_dot_ = false; } inline bool DebugOptions::_internal_xla_dump_hlo_as_dot() const { return _impl_.xla_dump_hlo_as_dot_; } inline bool DebugOptions::xla_dump_hlo_as_dot() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_as_dot) return _internal_xla_dump_hlo_as_dot(); } inline void DebugOptions::_internal_set_xla_dump_hlo_as_dot(bool value) { _impl_.xla_dump_hlo_as_dot_ = value; } inline void DebugOptions::set_xla_dump_hlo_as_dot(bool value) { _internal_set_xla_dump_hlo_as_dot(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_as_dot) } // bool xla_dump_hlo_as_url = 115; inline void DebugOptions::clear_xla_dump_hlo_as_url() { _impl_.xla_dump_hlo_as_url_ = false; } inline bool DebugOptions::_internal_xla_dump_hlo_as_url() const { return _impl_.xla_dump_hlo_as_url_; } inline bool DebugOptions::xla_dump_hlo_as_url() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_as_url) return _internal_xla_dump_hlo_as_url(); } inline void DebugOptions::_internal_set_xla_dump_hlo_as_url(bool value) { _impl_.xla_dump_hlo_as_url_ = value; } inline void DebugOptions::set_xla_dump_hlo_as_url(bool value) { _internal_set_xla_dump_hlo_as_url(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_as_url) } // bool xla_dump_hlo_as_html = 116; inline void DebugOptions::clear_xla_dump_hlo_as_html() { _impl_.xla_dump_hlo_as_html_ = false; } inline bool DebugOptions::_internal_xla_dump_hlo_as_html() const { return _impl_.xla_dump_hlo_as_html_; } inline bool DebugOptions::xla_dump_hlo_as_html() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_as_html) return _internal_xla_dump_hlo_as_html(); } inline void DebugOptions::_internal_set_xla_dump_hlo_as_html(bool value) { _impl_.xla_dump_hlo_as_html_ = value; } inline void DebugOptions::set_xla_dump_hlo_as_html(bool value) { _internal_set_xla_dump_hlo_as_html(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_as_html) } // bool xla_dump_fusion_visualization = 149; inline void DebugOptions::clear_xla_dump_fusion_visualization() { _impl_.xla_dump_fusion_visualization_ = false; } inline bool DebugOptions::_internal_xla_dump_fusion_visualization() const { return _impl_.xla_dump_fusion_visualization_; } inline bool DebugOptions::xla_dump_fusion_visualization() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_fusion_visualization) return _internal_xla_dump_fusion_visualization(); } inline void DebugOptions::_internal_set_xla_dump_fusion_visualization(bool value) { _impl_.xla_dump_fusion_visualization_ = value; } inline void DebugOptions::set_xla_dump_fusion_visualization(bool value) { _internal_set_xla_dump_fusion_visualization(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_fusion_visualization) } // bool xla_dump_hlo_snapshots = 118; inline void DebugOptions::clear_xla_dump_hlo_snapshots() { _impl_.xla_dump_hlo_snapshots_ = false; } inline bool DebugOptions::_internal_xla_dump_hlo_snapshots() const { return _impl_.xla_dump_hlo_snapshots_; } inline bool DebugOptions::xla_dump_hlo_snapshots() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_snapshots) return _internal_xla_dump_hlo_snapshots(); } inline void DebugOptions::_internal_set_xla_dump_hlo_snapshots(bool value) { _impl_.xla_dump_hlo_snapshots_ = value; } inline void DebugOptions::set_xla_dump_hlo_snapshots(bool value) { _internal_set_xla_dump_hlo_snapshots(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_snapshots) } // bool xla_dump_include_timestamp = 131; inline void DebugOptions::clear_xla_dump_include_timestamp() { _impl_.xla_dump_include_timestamp_ = false; } inline bool DebugOptions::_internal_xla_dump_include_timestamp() const { return _impl_.xla_dump_include_timestamp_; } inline bool DebugOptions::xla_dump_include_timestamp() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_include_timestamp) return _internal_xla_dump_include_timestamp(); } inline void DebugOptions::_internal_set_xla_dump_include_timestamp(bool value) { _impl_.xla_dump_include_timestamp_ = value; } inline void DebugOptions::set_xla_dump_include_timestamp(bool value) { _internal_set_xla_dump_include_timestamp(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_include_timestamp) } // int32 xla_dump_max_hlo_modules = 132; inline void DebugOptions::clear_xla_dump_max_hlo_modules() { _impl_.xla_dump_max_hlo_modules_ = 0; } inline int32_t DebugOptions::_internal_xla_dump_max_hlo_modules() const { return _impl_.xla_dump_max_hlo_modules_; } inline int32_t DebugOptions::xla_dump_max_hlo_modules() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_max_hlo_modules) return _internal_xla_dump_max_hlo_modules(); } inline void DebugOptions::_internal_set_xla_dump_max_hlo_modules(int32_t value) { _impl_.xla_dump_max_hlo_modules_ = value; } inline void DebugOptions::set_xla_dump_max_hlo_modules(int32_t value) { _internal_set_xla_dump_max_hlo_modules(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_max_hlo_modules) } // bool xla_dump_module_metadata = 144; inline void DebugOptions::clear_xla_dump_module_metadata() { _impl_.xla_dump_module_metadata_ = false; } inline bool DebugOptions::_internal_xla_dump_module_metadata() const { return _impl_.xla_dump_module_metadata_; } inline bool DebugOptions::xla_dump_module_metadata() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_module_metadata) return _internal_xla_dump_module_metadata(); } inline void DebugOptions::_internal_set_xla_dump_module_metadata(bool value) { _impl_.xla_dump_module_metadata_ = value; } inline void DebugOptions::set_xla_dump_module_metadata(bool value) { _internal_set_xla_dump_module_metadata(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_module_metadata) } // bool xla_dump_compress_protos = 151; inline void DebugOptions::clear_xla_dump_compress_protos() { _impl_.xla_dump_compress_protos_ = false; } inline bool DebugOptions::_internal_xla_dump_compress_protos() const { return _impl_.xla_dump_compress_protos_; } inline bool DebugOptions::xla_dump_compress_protos() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_compress_protos) return _internal_xla_dump_compress_protos(); } inline void DebugOptions::_internal_set_xla_dump_compress_protos(bool value) { _impl_.xla_dump_compress_protos_ = value; } inline void DebugOptions::set_xla_dump_compress_protos(bool value) { _internal_set_xla_dump_compress_protos(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_compress_protos) } // bool xla_dump_hlo_as_long_text = 164; inline void DebugOptions::clear_xla_dump_hlo_as_long_text() { _impl_.xla_dump_hlo_as_long_text_ = false; } inline bool DebugOptions::_internal_xla_dump_hlo_as_long_text() const { return _impl_.xla_dump_hlo_as_long_text_; } inline bool DebugOptions::xla_dump_hlo_as_long_text() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_as_long_text) return _internal_xla_dump_hlo_as_long_text(); } inline void DebugOptions::_internal_set_xla_dump_hlo_as_long_text(bool value) { _impl_.xla_dump_hlo_as_long_text_ = value; } inline void DebugOptions::set_xla_dump_hlo_as_long_text(bool value) { _internal_set_xla_dump_hlo_as_long_text(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_as_long_text) } // bool xla_dump_enable_mlir_pretty_form = 185; inline void DebugOptions::clear_xla_dump_enable_mlir_pretty_form() { _impl_.xla_dump_enable_mlir_pretty_form_ = false; } inline bool DebugOptions::_internal_xla_dump_enable_mlir_pretty_form() const { return _impl_.xla_dump_enable_mlir_pretty_form_; } inline bool DebugOptions::xla_dump_enable_mlir_pretty_form() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_enable_mlir_pretty_form) return _internal_xla_dump_enable_mlir_pretty_form(); } inline void DebugOptions::_internal_set_xla_dump_enable_mlir_pretty_form(bool value) { _impl_.xla_dump_enable_mlir_pretty_form_ = value; } inline void DebugOptions::set_xla_dump_enable_mlir_pretty_form(bool value) { _internal_set_xla_dump_enable_mlir_pretty_form(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_enable_mlir_pretty_form) } // bool xla_tpu_detect_nan = 135; inline void DebugOptions::clear_xla_tpu_detect_nan() { _impl_.xla_tpu_detect_nan_ = false; } inline bool DebugOptions::_internal_xla_tpu_detect_nan() const { return _impl_.xla_tpu_detect_nan_; } inline bool DebugOptions::xla_tpu_detect_nan() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_tpu_detect_nan) return _internal_xla_tpu_detect_nan(); } inline void DebugOptions::_internal_set_xla_tpu_detect_nan(bool value) { _impl_.xla_tpu_detect_nan_ = value; } inline void DebugOptions::set_xla_tpu_detect_nan(bool value) { _internal_set_xla_tpu_detect_nan(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_tpu_detect_nan) } // bool xla_tpu_detect_inf = 136; inline void DebugOptions::clear_xla_tpu_detect_inf() { _impl_.xla_tpu_detect_inf_ = false; } inline bool DebugOptions::_internal_xla_tpu_detect_inf() const { return _impl_.xla_tpu_detect_inf_; } inline bool DebugOptions::xla_tpu_detect_inf() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_tpu_detect_inf) return _internal_xla_tpu_detect_inf(); } inline void DebugOptions::_internal_set_xla_tpu_detect_inf(bool value) { _impl_.xla_tpu_detect_inf_ = value; } inline void DebugOptions::set_xla_tpu_detect_inf(bool value) { _internal_set_xla_tpu_detect_inf(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_tpu_detect_inf) } // bool xla_cpu_enable_xprof_traceme = 137; inline void DebugOptions::clear_xla_cpu_enable_xprof_traceme() { _impl_.xla_cpu_enable_xprof_traceme_ = false; } inline bool DebugOptions::_internal_xla_cpu_enable_xprof_traceme() const { return _impl_.xla_cpu_enable_xprof_traceme_; } inline bool DebugOptions::xla_cpu_enable_xprof_traceme() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_enable_xprof_traceme) return _internal_xla_cpu_enable_xprof_traceme(); } inline void DebugOptions::_internal_set_xla_cpu_enable_xprof_traceme(bool value) { _impl_.xla_cpu_enable_xprof_traceme_ = value; } inline void DebugOptions::set_xla_cpu_enable_xprof_traceme(bool value) { _internal_set_xla_cpu_enable_xprof_traceme(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_enable_xprof_traceme) } // int32 xla_multiheap_size_constraint_per_heap = 142; inline void DebugOptions::clear_xla_multiheap_size_constraint_per_heap() { _impl_.xla_multiheap_size_constraint_per_heap_ = 0; } inline int32_t DebugOptions::_internal_xla_multiheap_size_constraint_per_heap() const { return _impl_.xla_multiheap_size_constraint_per_heap_; } inline int32_t DebugOptions::xla_multiheap_size_constraint_per_heap() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_multiheap_size_constraint_per_heap) return _internal_xla_multiheap_size_constraint_per_heap(); } inline void DebugOptions::_internal_set_xla_multiheap_size_constraint_per_heap(int32_t value) { _impl_.xla_multiheap_size_constraint_per_heap_ = value; } inline void DebugOptions::set_xla_multiheap_size_constraint_per_heap(int32_t value) { _internal_set_xla_multiheap_size_constraint_per_heap(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_multiheap_size_constraint_per_heap) } // bool xla_detailed_logging = 252; inline void DebugOptions::clear_xla_detailed_logging() { _impl_.xla_detailed_logging_ = false; } inline bool DebugOptions::_internal_xla_detailed_logging() const { return _impl_.xla_detailed_logging_; } inline bool DebugOptions::xla_detailed_logging() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_detailed_logging) return _internal_xla_detailed_logging(); } inline void DebugOptions::_internal_set_xla_detailed_logging(bool value) { _impl_.xla_detailed_logging_ = value; } inline void DebugOptions::set_xla_detailed_logging(bool value) { _internal_set_xla_detailed_logging(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_detailed_logging) } // bool xla_enable_dumping = 253; inline void DebugOptions::clear_xla_enable_dumping() { _impl_.xla_enable_dumping_ = false; } inline bool DebugOptions::_internal_xla_enable_dumping() const { return _impl_.xla_enable_dumping_; } inline bool DebugOptions::xla_enable_dumping() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_enable_dumping) return _internal_xla_enable_dumping(); } inline void DebugOptions::_internal_set_xla_enable_dumping(bool value) { _impl_.xla_enable_dumping_ = value; } inline void DebugOptions::set_xla_enable_dumping(bool value) { _internal_set_xla_enable_dumping(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_enable_dumping) } // bool xla_llvm_force_inline_before_split = 300; inline void DebugOptions::clear_xla_llvm_force_inline_before_split() { _impl_.xla_llvm_force_inline_before_split_ = false; } inline bool DebugOptions::_internal_xla_llvm_force_inline_before_split() const { return _impl_.xla_llvm_force_inline_before_split_; } inline bool DebugOptions::xla_llvm_force_inline_before_split() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_llvm_force_inline_before_split) return _internal_xla_llvm_force_inline_before_split(); } inline void DebugOptions::_internal_set_xla_llvm_force_inline_before_split(bool value) { _impl_.xla_llvm_force_inline_before_split_ = value; } inline void DebugOptions::set_xla_llvm_force_inline_before_split(bool value) { _internal_set_xla_llvm_force_inline_before_split(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_llvm_force_inline_before_split) } // bool xla_dump_disable_metadata = 153; inline void DebugOptions::clear_xla_dump_disable_metadata() { _impl_.xla_dump_disable_metadata_ = false; } inline bool DebugOptions::_internal_xla_dump_disable_metadata() const { return _impl_.xla_dump_disable_metadata_; } inline bool DebugOptions::xla_dump_disable_metadata() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_disable_metadata) return _internal_xla_dump_disable_metadata(); } inline void DebugOptions::_internal_set_xla_dump_disable_metadata(bool value) { _impl_.xla_dump_disable_metadata_ = value; } inline void DebugOptions::set_xla_dump_disable_metadata(bool value) { _internal_set_xla_dump_disable_metadata(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_disable_metadata) } // string xla_dump_hlo_pipeline_re = 154; inline void DebugOptions::clear_xla_dump_hlo_pipeline_re() { _impl_.xla_dump_hlo_pipeline_re_.ClearToEmpty(); } inline const std::string& DebugOptions::xla_dump_hlo_pipeline_re() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_hlo_pipeline_re) return _internal_xla_dump_hlo_pipeline_re(); } template inline PROTOBUF_ALWAYS_INLINE void DebugOptions::set_xla_dump_hlo_pipeline_re(ArgT0&& arg0, ArgT... args) { _impl_.xla_dump_hlo_pipeline_re_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_hlo_pipeline_re) } inline std::string* DebugOptions::mutable_xla_dump_hlo_pipeline_re() { std::string* _s = _internal_mutable_xla_dump_hlo_pipeline_re(); // @@protoc_insertion_point(field_mutable:xla.DebugOptions.xla_dump_hlo_pipeline_re) return _s; } inline const std::string& DebugOptions::_internal_xla_dump_hlo_pipeline_re() const { return _impl_.xla_dump_hlo_pipeline_re_.Get(); } inline void DebugOptions::_internal_set_xla_dump_hlo_pipeline_re(const std::string& value) { _impl_.xla_dump_hlo_pipeline_re_.Set(value, GetArenaForAllocation()); } inline std::string* DebugOptions::_internal_mutable_xla_dump_hlo_pipeline_re() { return _impl_.xla_dump_hlo_pipeline_re_.Mutable(GetArenaForAllocation()); } inline std::string* DebugOptions::release_xla_dump_hlo_pipeline_re() { // @@protoc_insertion_point(field_release:xla.DebugOptions.xla_dump_hlo_pipeline_re) return _impl_.xla_dump_hlo_pipeline_re_.Release(); } inline void DebugOptions::set_allocated_xla_dump_hlo_pipeline_re(std::string* xla_dump_hlo_pipeline_re) { if (xla_dump_hlo_pipeline_re != nullptr) { } else { } _impl_.xla_dump_hlo_pipeline_re_.SetAllocated(xla_dump_hlo_pipeline_re, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.xla_dump_hlo_pipeline_re_.IsDefault()) { _impl_.xla_dump_hlo_pipeline_re_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.DebugOptions.xla_dump_hlo_pipeline_re) } // bool xla_cpu_use_acl = 174; inline void DebugOptions::clear_xla_cpu_use_acl() { _impl_.xla_cpu_use_acl_ = false; } inline bool DebugOptions::_internal_xla_cpu_use_acl() const { return _impl_.xla_cpu_use_acl_; } inline bool DebugOptions::xla_cpu_use_acl() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_use_acl) return _internal_xla_cpu_use_acl(); } inline void DebugOptions::_internal_set_xla_cpu_use_acl(bool value) { _impl_.xla_cpu_use_acl_ = value; } inline void DebugOptions::set_xla_cpu_use_acl(bool value) { _internal_set_xla_cpu_use_acl(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_use_acl) } // bool xla_cpu_strict_dot_conv_math = 175; inline void DebugOptions::clear_xla_cpu_strict_dot_conv_math() { _impl_.xla_cpu_strict_dot_conv_math_ = false; } inline bool DebugOptions::_internal_xla_cpu_strict_dot_conv_math() const { return _impl_.xla_cpu_strict_dot_conv_math_; } inline bool DebugOptions::xla_cpu_strict_dot_conv_math() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cpu_strict_dot_conv_math) return _internal_xla_cpu_strict_dot_conv_math(); } inline void DebugOptions::_internal_set_xla_cpu_strict_dot_conv_math(bool value) { _impl_.xla_cpu_strict_dot_conv_math_ = value; } inline void DebugOptions::set_xla_cpu_strict_dot_conv_math(bool value) { _internal_set_xla_cpu_strict_dot_conv_math(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cpu_strict_dot_conv_math) } // bool xla_dump_latency_hiding_schedule = 182; inline void DebugOptions::clear_xla_dump_latency_hiding_schedule() { _impl_.xla_dump_latency_hiding_schedule_ = false; } inline bool DebugOptions::_internal_xla_dump_latency_hiding_schedule() const { return _impl_.xla_dump_latency_hiding_schedule_; } inline bool DebugOptions::xla_dump_latency_hiding_schedule() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_latency_hiding_schedule) return _internal_xla_dump_latency_hiding_schedule(); } inline void DebugOptions::_internal_set_xla_dump_latency_hiding_schedule(bool value) { _impl_.xla_dump_latency_hiding_schedule_ = value; } inline void DebugOptions::set_xla_dump_latency_hiding_schedule(bool value) { _internal_set_xla_dump_latency_hiding_schedule(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_latency_hiding_schedule) } // .xla.DebugOptions.PartitioningAlgorithm xla_partitioning_algorithm = 187; inline void DebugOptions::clear_xla_partitioning_algorithm() { _impl_.xla_partitioning_algorithm_ = 0; } inline ::xla::DebugOptions_PartitioningAlgorithm DebugOptions::_internal_xla_partitioning_algorithm() const { return static_cast< ::xla::DebugOptions_PartitioningAlgorithm >(_impl_.xla_partitioning_algorithm_); } inline ::xla::DebugOptions_PartitioningAlgorithm DebugOptions::xla_partitioning_algorithm() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_partitioning_algorithm) return _internal_xla_partitioning_algorithm(); } inline void DebugOptions::_internal_set_xla_partitioning_algorithm(::xla::DebugOptions_PartitioningAlgorithm value) { _impl_.xla_partitioning_algorithm_ = value; } inline void DebugOptions::set_xla_partitioning_algorithm(::xla::DebugOptions_PartitioningAlgorithm value) { _internal_set_xla_partitioning_algorithm(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_partitioning_algorithm) } // int64 xla_debug_buffer_assignment_show_max = 251; inline void DebugOptions::clear_xla_debug_buffer_assignment_show_max() { _impl_.xla_debug_buffer_assignment_show_max_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_debug_buffer_assignment_show_max() const { return _impl_.xla_debug_buffer_assignment_show_max_; } inline int64_t DebugOptions::xla_debug_buffer_assignment_show_max() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_debug_buffer_assignment_show_max) return _internal_xla_debug_buffer_assignment_show_max(); } inline void DebugOptions::_internal_set_xla_debug_buffer_assignment_show_max(int64_t value) { _impl_.xla_debug_buffer_assignment_show_max_ = value; } inline void DebugOptions::set_xla_debug_buffer_assignment_show_max(int64_t value) { _internal_set_xla_debug_buffer_assignment_show_max(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_debug_buffer_assignment_show_max) } // bool xla_dump_large_constants = 290; inline void DebugOptions::clear_xla_dump_large_constants() { _impl_.xla_dump_large_constants_ = false; } inline bool DebugOptions::_internal_xla_dump_large_constants() const { return _impl_.xla_dump_large_constants_; } inline bool DebugOptions::xla_dump_large_constants() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_dump_large_constants) return _internal_xla_dump_large_constants(); } inline void DebugOptions::_internal_set_xla_dump_large_constants(bool value) { _impl_.xla_dump_large_constants_ = value; } inline void DebugOptions::set_xla_dump_large_constants(bool value) { _internal_set_xla_dump_large_constants(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_dump_large_constants) } // int64 xla_reduce_window_rewrite_base_length = 293; inline void DebugOptions::clear_xla_reduce_window_rewrite_base_length() { _impl_.xla_reduce_window_rewrite_base_length_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_reduce_window_rewrite_base_length() const { return _impl_.xla_reduce_window_rewrite_base_length_; } inline int64_t DebugOptions::xla_reduce_window_rewrite_base_length() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_reduce_window_rewrite_base_length) return _internal_xla_reduce_window_rewrite_base_length(); } inline void DebugOptions::_internal_set_xla_reduce_window_rewrite_base_length(int64_t value) { _impl_.xla_reduce_window_rewrite_base_length_ = value; } inline void DebugOptions::set_xla_reduce_window_rewrite_base_length(int64_t value) { _internal_set_xla_reduce_window_rewrite_base_length(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_reduce_window_rewrite_base_length) } // int64 xla_cmd_buffer_trace_cache_size = 311; inline void DebugOptions::clear_xla_cmd_buffer_trace_cache_size() { _impl_.xla_cmd_buffer_trace_cache_size_ = int64_t{0}; } inline int64_t DebugOptions::_internal_xla_cmd_buffer_trace_cache_size() const { return _impl_.xla_cmd_buffer_trace_cache_size_; } inline int64_t DebugOptions::xla_cmd_buffer_trace_cache_size() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_cmd_buffer_trace_cache_size) return _internal_xla_cmd_buffer_trace_cache_size(); } inline void DebugOptions::_internal_set_xla_cmd_buffer_trace_cache_size(int64_t value) { _impl_.xla_cmd_buffer_trace_cache_size_ = value; } inline void DebugOptions::set_xla_cmd_buffer_trace_cache_size(int64_t value) { _internal_set_xla_cmd_buffer_trace_cache_size(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_cmd_buffer_trace_cache_size) } // repeated string legacy_command_buffer_custom_call_targets = 314; inline int DebugOptions::_internal_legacy_command_buffer_custom_call_targets_size() const { return _impl_.legacy_command_buffer_custom_call_targets_.size(); } inline int DebugOptions::legacy_command_buffer_custom_call_targets_size() const { return _internal_legacy_command_buffer_custom_call_targets_size(); } inline void DebugOptions::clear_legacy_command_buffer_custom_call_targets() { _impl_.legacy_command_buffer_custom_call_targets_.Clear(); } inline std::string* DebugOptions::add_legacy_command_buffer_custom_call_targets() { std::string* _s = _internal_add_legacy_command_buffer_custom_call_targets(); // @@protoc_insertion_point(field_add_mutable:xla.DebugOptions.legacy_command_buffer_custom_call_targets) return _s; } inline const std::string& DebugOptions::_internal_legacy_command_buffer_custom_call_targets(int index) const { return _impl_.legacy_command_buffer_custom_call_targets_.Get(index); } inline const std::string& DebugOptions::legacy_command_buffer_custom_call_targets(int index) const { // @@protoc_insertion_point(field_get:xla.DebugOptions.legacy_command_buffer_custom_call_targets) return _internal_legacy_command_buffer_custom_call_targets(index); } inline std::string* DebugOptions::mutable_legacy_command_buffer_custom_call_targets(int index) { // @@protoc_insertion_point(field_mutable:xla.DebugOptions.legacy_command_buffer_custom_call_targets) return _impl_.legacy_command_buffer_custom_call_targets_.Mutable(index); } inline void DebugOptions::set_legacy_command_buffer_custom_call_targets(int index, const std::string& value) { _impl_.legacy_command_buffer_custom_call_targets_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.legacy_command_buffer_custom_call_targets) } inline void DebugOptions::set_legacy_command_buffer_custom_call_targets(int index, std::string&& value) { _impl_.legacy_command_buffer_custom_call_targets_.Mutable(index)->assign(std::move(value)); // @@protoc_insertion_point(field_set:xla.DebugOptions.legacy_command_buffer_custom_call_targets) } inline void DebugOptions::set_legacy_command_buffer_custom_call_targets(int index, const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.legacy_command_buffer_custom_call_targets_.Mutable(index)->assign(value); // @@protoc_insertion_point(field_set_char:xla.DebugOptions.legacy_command_buffer_custom_call_targets) } inline void DebugOptions::set_legacy_command_buffer_custom_call_targets(int index, const char* value, size_t size) { _impl_.legacy_command_buffer_custom_call_targets_.Mutable(index)->assign( reinterpret_cast(value), size); // @@protoc_insertion_point(field_set_pointer:xla.DebugOptions.legacy_command_buffer_custom_call_targets) } inline std::string* DebugOptions::_internal_add_legacy_command_buffer_custom_call_targets() { return _impl_.legacy_command_buffer_custom_call_targets_.Add(); } inline void DebugOptions::add_legacy_command_buffer_custom_call_targets(const std::string& value) { _impl_.legacy_command_buffer_custom_call_targets_.Add()->assign(value); // @@protoc_insertion_point(field_add:xla.DebugOptions.legacy_command_buffer_custom_call_targets) } inline void DebugOptions::add_legacy_command_buffer_custom_call_targets(std::string&& value) { _impl_.legacy_command_buffer_custom_call_targets_.Add(std::move(value)); // @@protoc_insertion_point(field_add:xla.DebugOptions.legacy_command_buffer_custom_call_targets) } inline void DebugOptions::add_legacy_command_buffer_custom_call_targets(const char* value) { GOOGLE_DCHECK(value != nullptr); _impl_.legacy_command_buffer_custom_call_targets_.Add()->assign(value); // @@protoc_insertion_point(field_add_char:xla.DebugOptions.legacy_command_buffer_custom_call_targets) } inline void DebugOptions::add_legacy_command_buffer_custom_call_targets(const char* value, size_t size) { _impl_.legacy_command_buffer_custom_call_targets_.Add()->assign(reinterpret_cast(value), size); // @@protoc_insertion_point(field_add_pointer:xla.DebugOptions.legacy_command_buffer_custom_call_targets) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField& DebugOptions::legacy_command_buffer_custom_call_targets() const { // @@protoc_insertion_point(field_list:xla.DebugOptions.legacy_command_buffer_custom_call_targets) return _impl_.legacy_command_buffer_custom_call_targets_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField* DebugOptions::mutable_legacy_command_buffer_custom_call_targets() { // @@protoc_insertion_point(field_mutable_list:xla.DebugOptions.legacy_command_buffer_custom_call_targets) return &_impl_.legacy_command_buffer_custom_call_targets_; } // bool xla_syntax_sugar_async_ops = 315; inline void DebugOptions::clear_xla_syntax_sugar_async_ops() { _impl_.xla_syntax_sugar_async_ops_ = false; } inline bool DebugOptions::_internal_xla_syntax_sugar_async_ops() const { return _impl_.xla_syntax_sugar_async_ops_; } inline bool DebugOptions::xla_syntax_sugar_async_ops() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_syntax_sugar_async_ops) return _internal_xla_syntax_sugar_async_ops(); } inline void DebugOptions::_internal_set_xla_syntax_sugar_async_ops(bool value) { _impl_.xla_syntax_sugar_async_ops_ = value; } inline void DebugOptions::set_xla_syntax_sugar_async_ops(bool value) { _internal_set_xla_syntax_sugar_async_ops(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_syntax_sugar_async_ops) } // bool xla_enable_command_buffers_during_profiling = 317; inline void DebugOptions::clear_xla_enable_command_buffers_during_profiling() { _impl_.xla_enable_command_buffers_during_profiling_ = false; } inline bool DebugOptions::_internal_xla_enable_command_buffers_during_profiling() const { return _impl_.xla_enable_command_buffers_during_profiling_; } inline bool DebugOptions::xla_enable_command_buffers_during_profiling() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_enable_command_buffers_during_profiling) return _internal_xla_enable_command_buffers_during_profiling(); } inline void DebugOptions::_internal_set_xla_enable_command_buffers_during_profiling(bool value) { _impl_.xla_enable_command_buffers_during_profiling_ = value; } inline void DebugOptions::set_xla_enable_command_buffers_during_profiling(bool value) { _internal_set_xla_enable_command_buffers_during_profiling(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_enable_command_buffers_during_profiling) } // bool xla_ignore_channel_id = 330; inline void DebugOptions::clear_xla_ignore_channel_id() { _impl_.xla_ignore_channel_id_ = false; } inline bool DebugOptions::_internal_xla_ignore_channel_id() const { return _impl_.xla_ignore_channel_id_; } inline bool DebugOptions::xla_ignore_channel_id() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_ignore_channel_id) return _internal_xla_ignore_channel_id(); } inline void DebugOptions::_internal_set_xla_ignore_channel_id(bool value) { _impl_.xla_ignore_channel_id_ = value; } inline void DebugOptions::set_xla_ignore_channel_id(bool value) { _internal_set_xla_ignore_channel_id(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_ignore_channel_id) } // bool xla_pjrt_allow_auto_layout_in_hlo = 344; inline void DebugOptions::clear_xla_pjrt_allow_auto_layout_in_hlo() { _impl_.xla_pjrt_allow_auto_layout_in_hlo_ = false; } inline bool DebugOptions::_internal_xla_pjrt_allow_auto_layout_in_hlo() const { return _impl_.xla_pjrt_allow_auto_layout_in_hlo_; } inline bool DebugOptions::xla_pjrt_allow_auto_layout_in_hlo() const { // @@protoc_insertion_point(field_get:xla.DebugOptions.xla_pjrt_allow_auto_layout_in_hlo) return _internal_xla_pjrt_allow_auto_layout_in_hlo(); } inline void DebugOptions::_internal_set_xla_pjrt_allow_auto_layout_in_hlo(bool value) { _impl_.xla_pjrt_allow_auto_layout_in_hlo_ = value; } inline void DebugOptions::set_xla_pjrt_allow_auto_layout_in_hlo(bool value) { _internal_set_xla_pjrt_allow_auto_layout_in_hlo(value); // @@protoc_insertion_point(field_set:xla.DebugOptions.xla_pjrt_allow_auto_layout_in_hlo) } // map xla_backend_extra_options = 500; inline int DebugOptions::_internal_xla_backend_extra_options_size() const { return _impl_.xla_backend_extra_options_.size(); } inline int DebugOptions::xla_backend_extra_options_size() const { return _internal_xla_backend_extra_options_size(); } inline void DebugOptions::clear_xla_backend_extra_options() { _impl_.xla_backend_extra_options_.Clear(); } inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& DebugOptions::_internal_xla_backend_extra_options() const { return _impl_.xla_backend_extra_options_.GetMap(); } inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >& DebugOptions::xla_backend_extra_options() const { // @@protoc_insertion_point(field_map:xla.DebugOptions.xla_backend_extra_options) return _internal_xla_backend_extra_options(); } inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* DebugOptions::_internal_mutable_xla_backend_extra_options() { return _impl_.xla_backend_extra_options_.MutableMap(); } inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >* DebugOptions::mutable_xla_backend_extra_options() { // @@protoc_insertion_point(field_mutable_map:xla.DebugOptions.xla_backend_extra_options) return _internal_mutable_xla_backend_extra_options(); } // ------------------------------------------------------------------- // GpuCompilationEnvironment // int64 dummy_flag = 1; inline void GpuCompilationEnvironment::clear_dummy_flag() { _impl_.dummy_flag_ = int64_t{0}; } inline int64_t GpuCompilationEnvironment::_internal_dummy_flag() const { return _impl_.dummy_flag_; } inline int64_t GpuCompilationEnvironment::dummy_flag() const { // @@protoc_insertion_point(field_get:xla.GpuCompilationEnvironment.dummy_flag) return _internal_dummy_flag(); } inline void GpuCompilationEnvironment::_internal_set_dummy_flag(int64_t value) { _impl_.dummy_flag_ = value; } inline void GpuCompilationEnvironment::set_dummy_flag(int64_t value) { _internal_set_dummy_flag(value); // @@protoc_insertion_point(field_set:xla.GpuCompilationEnvironment.dummy_flag) } // ------------------------------------------------------------------- // ShardableValueUpdatePairProto // int64 input_parameter_number = 1; inline void ShardableValueUpdatePairProto::clear_input_parameter_number() { _impl_.input_parameter_number_ = int64_t{0}; } inline int64_t ShardableValueUpdatePairProto::_internal_input_parameter_number() const { return _impl_.input_parameter_number_; } inline int64_t ShardableValueUpdatePairProto::input_parameter_number() const { // @@protoc_insertion_point(field_get:xla.ShardableValueUpdatePairProto.input_parameter_number) return _internal_input_parameter_number(); } inline void ShardableValueUpdatePairProto::_internal_set_input_parameter_number(int64_t value) { _impl_.input_parameter_number_ = value; } inline void ShardableValueUpdatePairProto::set_input_parameter_number(int64_t value) { _internal_set_input_parameter_number(value); // @@protoc_insertion_point(field_set:xla.ShardableValueUpdatePairProto.input_parameter_number) } // repeated int64 parameter_shape_index = 2; inline int ShardableValueUpdatePairProto::_internal_parameter_shape_index_size() const { return _impl_.parameter_shape_index_.size(); } inline int ShardableValueUpdatePairProto::parameter_shape_index_size() const { return _internal_parameter_shape_index_size(); } inline void ShardableValueUpdatePairProto::clear_parameter_shape_index() { _impl_.parameter_shape_index_.Clear(); } inline int64_t ShardableValueUpdatePairProto::_internal_parameter_shape_index(int index) const { return _impl_.parameter_shape_index_.Get(index); } inline int64_t ShardableValueUpdatePairProto::parameter_shape_index(int index) const { // @@protoc_insertion_point(field_get:xla.ShardableValueUpdatePairProto.parameter_shape_index) return _internal_parameter_shape_index(index); } inline void ShardableValueUpdatePairProto::set_parameter_shape_index(int index, int64_t value) { _impl_.parameter_shape_index_.Set(index, value); // @@protoc_insertion_point(field_set:xla.ShardableValueUpdatePairProto.parameter_shape_index) } inline void ShardableValueUpdatePairProto::_internal_add_parameter_shape_index(int64_t value) { _impl_.parameter_shape_index_.Add(value); } inline void ShardableValueUpdatePairProto::add_parameter_shape_index(int64_t value) { _internal_add_parameter_shape_index(value); // @@protoc_insertion_point(field_add:xla.ShardableValueUpdatePairProto.parameter_shape_index) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& ShardableValueUpdatePairProto::_internal_parameter_shape_index() const { return _impl_.parameter_shape_index_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& ShardableValueUpdatePairProto::parameter_shape_index() const { // @@protoc_insertion_point(field_list:xla.ShardableValueUpdatePairProto.parameter_shape_index) return _internal_parameter_shape_index(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* ShardableValueUpdatePairProto::_internal_mutable_parameter_shape_index() { return &_impl_.parameter_shape_index_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* ShardableValueUpdatePairProto::mutable_parameter_shape_index() { // @@protoc_insertion_point(field_mutable_list:xla.ShardableValueUpdatePairProto.parameter_shape_index) return _internal_mutable_parameter_shape_index(); } // repeated int64 output_shape_index = 3; inline int ShardableValueUpdatePairProto::_internal_output_shape_index_size() const { return _impl_.output_shape_index_.size(); } inline int ShardableValueUpdatePairProto::output_shape_index_size() const { return _internal_output_shape_index_size(); } inline void ShardableValueUpdatePairProto::clear_output_shape_index() { _impl_.output_shape_index_.Clear(); } inline int64_t ShardableValueUpdatePairProto::_internal_output_shape_index(int index) const { return _impl_.output_shape_index_.Get(index); } inline int64_t ShardableValueUpdatePairProto::output_shape_index(int index) const { // @@protoc_insertion_point(field_get:xla.ShardableValueUpdatePairProto.output_shape_index) return _internal_output_shape_index(index); } inline void ShardableValueUpdatePairProto::set_output_shape_index(int index, int64_t value) { _impl_.output_shape_index_.Set(index, value); // @@protoc_insertion_point(field_set:xla.ShardableValueUpdatePairProto.output_shape_index) } inline void ShardableValueUpdatePairProto::_internal_add_output_shape_index(int64_t value) { _impl_.output_shape_index_.Add(value); } inline void ShardableValueUpdatePairProto::add_output_shape_index(int64_t value) { _internal_add_output_shape_index(value); // @@protoc_insertion_point(field_add:xla.ShardableValueUpdatePairProto.output_shape_index) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& ShardableValueUpdatePairProto::_internal_output_shape_index() const { return _impl_.output_shape_index_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& ShardableValueUpdatePairProto::output_shape_index() const { // @@protoc_insertion_point(field_list:xla.ShardableValueUpdatePairProto.output_shape_index) return _internal_output_shape_index(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* ShardableValueUpdatePairProto::_internal_mutable_output_shape_index() { return &_impl_.output_shape_index_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* ShardableValueUpdatePairProto::mutable_output_shape_index() { // @@protoc_insertion_point(field_mutable_list:xla.ShardableValueUpdatePairProto.output_shape_index) return _internal_mutable_output_shape_index(); } // ------------------------------------------------------------------- // ExecutionOptions // .xla.ShapeProto shape_with_output_layout = 2; inline bool ExecutionOptions::_internal_has_shape_with_output_layout() const { return this != internal_default_instance() && _impl_.shape_with_output_layout_ != nullptr; } inline bool ExecutionOptions::has_shape_with_output_layout() const { return _internal_has_shape_with_output_layout(); } inline const ::xla::ShapeProto& ExecutionOptions::_internal_shape_with_output_layout() const { const ::xla::ShapeProto* p = _impl_.shape_with_output_layout_; return p != nullptr ? *p : reinterpret_cast( ::xla::_ShapeProto_default_instance_); } inline const ::xla::ShapeProto& ExecutionOptions::shape_with_output_layout() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.shape_with_output_layout) return _internal_shape_with_output_layout(); } inline void ExecutionOptions::unsafe_arena_set_allocated_shape_with_output_layout( ::xla::ShapeProto* shape_with_output_layout) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_with_output_layout_); } _impl_.shape_with_output_layout_ = shape_with_output_layout; if (shape_with_output_layout) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.ExecutionOptions.shape_with_output_layout) } inline ::xla::ShapeProto* ExecutionOptions::release_shape_with_output_layout() { ::xla::ShapeProto* temp = _impl_.shape_with_output_layout_; _impl_.shape_with_output_layout_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::xla::ShapeProto* ExecutionOptions::unsafe_arena_release_shape_with_output_layout() { // @@protoc_insertion_point(field_release:xla.ExecutionOptions.shape_with_output_layout) ::xla::ShapeProto* temp = _impl_.shape_with_output_layout_; _impl_.shape_with_output_layout_ = nullptr; return temp; } inline ::xla::ShapeProto* ExecutionOptions::_internal_mutable_shape_with_output_layout() { if (_impl_.shape_with_output_layout_ == nullptr) { auto* p = CreateMaybeMessage<::xla::ShapeProto>(GetArenaForAllocation()); _impl_.shape_with_output_layout_ = p; } return _impl_.shape_with_output_layout_; } inline ::xla::ShapeProto* ExecutionOptions::mutable_shape_with_output_layout() { ::xla::ShapeProto* _msg = _internal_mutable_shape_with_output_layout(); // @@protoc_insertion_point(field_mutable:xla.ExecutionOptions.shape_with_output_layout) return _msg; } inline void ExecutionOptions::set_allocated_shape_with_output_layout(::xla::ShapeProto* shape_with_output_layout) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.shape_with_output_layout_); } if (shape_with_output_layout) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(shape_with_output_layout)); if (message_arena != submessage_arena) { shape_with_output_layout = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, shape_with_output_layout, submessage_arena); } } else { } _impl_.shape_with_output_layout_ = shape_with_output_layout; // @@protoc_insertion_point(field_set_allocated:xla.ExecutionOptions.shape_with_output_layout) } // uint64 seed = 3; inline void ExecutionOptions::clear_seed() { _impl_.seed_ = uint64_t{0u}; } inline uint64_t ExecutionOptions::_internal_seed() const { return _impl_.seed_; } inline uint64_t ExecutionOptions::seed() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.seed) return _internal_seed(); } inline void ExecutionOptions::_internal_set_seed(uint64_t value) { _impl_.seed_ = value; } inline void ExecutionOptions::set_seed(uint64_t value) { _internal_set_seed(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.seed) } // .xla.DebugOptions debug_options = 4; inline bool ExecutionOptions::_internal_has_debug_options() const { return this != internal_default_instance() && _impl_.debug_options_ != nullptr; } inline bool ExecutionOptions::has_debug_options() const { return _internal_has_debug_options(); } inline void ExecutionOptions::clear_debug_options() { if (GetArenaForAllocation() == nullptr && _impl_.debug_options_ != nullptr) { delete _impl_.debug_options_; } _impl_.debug_options_ = nullptr; } inline const ::xla::DebugOptions& ExecutionOptions::_internal_debug_options() const { const ::xla::DebugOptions* p = _impl_.debug_options_; return p != nullptr ? *p : reinterpret_cast( ::xla::_DebugOptions_default_instance_); } inline const ::xla::DebugOptions& ExecutionOptions::debug_options() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.debug_options) return _internal_debug_options(); } inline void ExecutionOptions::unsafe_arena_set_allocated_debug_options( ::xla::DebugOptions* debug_options) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.debug_options_); } _impl_.debug_options_ = debug_options; if (debug_options) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.ExecutionOptions.debug_options) } inline ::xla::DebugOptions* ExecutionOptions::release_debug_options() { ::xla::DebugOptions* temp = _impl_.debug_options_; _impl_.debug_options_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::xla::DebugOptions* ExecutionOptions::unsafe_arena_release_debug_options() { // @@protoc_insertion_point(field_release:xla.ExecutionOptions.debug_options) ::xla::DebugOptions* temp = _impl_.debug_options_; _impl_.debug_options_ = nullptr; return temp; } inline ::xla::DebugOptions* ExecutionOptions::_internal_mutable_debug_options() { if (_impl_.debug_options_ == nullptr) { auto* p = CreateMaybeMessage<::xla::DebugOptions>(GetArenaForAllocation()); _impl_.debug_options_ = p; } return _impl_.debug_options_; } inline ::xla::DebugOptions* ExecutionOptions::mutable_debug_options() { ::xla::DebugOptions* _msg = _internal_mutable_debug_options(); // @@protoc_insertion_point(field_mutable:xla.ExecutionOptions.debug_options) return _msg; } inline void ExecutionOptions::set_allocated_debug_options(::xla::DebugOptions* debug_options) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.debug_options_; } if (debug_options) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(debug_options); if (message_arena != submessage_arena) { debug_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, debug_options, submessage_arena); } } else { } _impl_.debug_options_ = debug_options; // @@protoc_insertion_point(field_set_allocated:xla.ExecutionOptions.debug_options) } // repeated .xla.DeviceHandle device_handles = 5; inline int ExecutionOptions::_internal_device_handles_size() const { return _impl_.device_handles_.size(); } inline int ExecutionOptions::device_handles_size() const { return _internal_device_handles_size(); } inline ::xla::DeviceHandle* ExecutionOptions::mutable_device_handles(int index) { // @@protoc_insertion_point(field_mutable:xla.ExecutionOptions.device_handles) return _impl_.device_handles_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceHandle >* ExecutionOptions::mutable_device_handles() { // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.device_handles) return &_impl_.device_handles_; } inline const ::xla::DeviceHandle& ExecutionOptions::_internal_device_handles(int index) const { return _impl_.device_handles_.Get(index); } inline const ::xla::DeviceHandle& ExecutionOptions::device_handles(int index) const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.device_handles) return _internal_device_handles(index); } inline ::xla::DeviceHandle* ExecutionOptions::_internal_add_device_handles() { return _impl_.device_handles_.Add(); } inline ::xla::DeviceHandle* ExecutionOptions::add_device_handles() { ::xla::DeviceHandle* _add = _internal_add_device_handles(); // @@protoc_insertion_point(field_add:xla.ExecutionOptions.device_handles) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::DeviceHandle >& ExecutionOptions::device_handles() const { // @@protoc_insertion_point(field_list:xla.ExecutionOptions.device_handles) return _impl_.device_handles_; } // int32 num_replicas = 6; inline void ExecutionOptions::clear_num_replicas() { _impl_.num_replicas_ = 0; } inline int32_t ExecutionOptions::_internal_num_replicas() const { return _impl_.num_replicas_; } inline int32_t ExecutionOptions::num_replicas() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.num_replicas) return _internal_num_replicas(); } inline void ExecutionOptions::_internal_set_num_replicas(int32_t value) { _impl_.num_replicas_ = value; } inline void ExecutionOptions::set_num_replicas(int32_t value) { _internal_set_num_replicas(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.num_replicas) } // .xla.DeviceAssignmentProto device_assignment = 7; inline bool ExecutionOptions::_internal_has_device_assignment() const { return this != internal_default_instance() && _impl_.device_assignment_ != nullptr; } inline bool ExecutionOptions::has_device_assignment() const { return _internal_has_device_assignment(); } inline const ::xla::DeviceAssignmentProto& ExecutionOptions::_internal_device_assignment() const { const ::xla::DeviceAssignmentProto* p = _impl_.device_assignment_; return p != nullptr ? *p : reinterpret_cast( ::xla::_DeviceAssignmentProto_default_instance_); } inline const ::xla::DeviceAssignmentProto& ExecutionOptions::device_assignment() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.device_assignment) return _internal_device_assignment(); } inline void ExecutionOptions::unsafe_arena_set_allocated_device_assignment( ::xla::DeviceAssignmentProto* device_assignment) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.device_assignment_); } _impl_.device_assignment_ = device_assignment; if (device_assignment) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.ExecutionOptions.device_assignment) } inline ::xla::DeviceAssignmentProto* ExecutionOptions::release_device_assignment() { ::xla::DeviceAssignmentProto* temp = _impl_.device_assignment_; _impl_.device_assignment_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::xla::DeviceAssignmentProto* ExecutionOptions::unsafe_arena_release_device_assignment() { // @@protoc_insertion_point(field_release:xla.ExecutionOptions.device_assignment) ::xla::DeviceAssignmentProto* temp = _impl_.device_assignment_; _impl_.device_assignment_ = nullptr; return temp; } inline ::xla::DeviceAssignmentProto* ExecutionOptions::_internal_mutable_device_assignment() { if (_impl_.device_assignment_ == nullptr) { auto* p = CreateMaybeMessage<::xla::DeviceAssignmentProto>(GetArenaForAllocation()); _impl_.device_assignment_ = p; } return _impl_.device_assignment_; } inline ::xla::DeviceAssignmentProto* ExecutionOptions::mutable_device_assignment() { ::xla::DeviceAssignmentProto* _msg = _internal_mutable_device_assignment(); // @@protoc_insertion_point(field_mutable:xla.ExecutionOptions.device_assignment) return _msg; } inline void ExecutionOptions::set_allocated_device_assignment(::xla::DeviceAssignmentProto* device_assignment) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.device_assignment_); } if (device_assignment) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_assignment)); if (message_arena != submessage_arena) { device_assignment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, device_assignment, submessage_arena); } } else { } _impl_.device_assignment_ = device_assignment; // @@protoc_insertion_point(field_set_allocated:xla.ExecutionOptions.device_assignment) } // bool alias_passthrough_params = 8; inline void ExecutionOptions::clear_alias_passthrough_params() { _impl_.alias_passthrough_params_ = false; } inline bool ExecutionOptions::_internal_alias_passthrough_params() const { return _impl_.alias_passthrough_params_; } inline bool ExecutionOptions::alias_passthrough_params() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.alias_passthrough_params) return _internal_alias_passthrough_params(); } inline void ExecutionOptions::_internal_set_alias_passthrough_params(bool value) { _impl_.alias_passthrough_params_ = value; } inline void ExecutionOptions::set_alias_passthrough_params(bool value) { _internal_set_alias_passthrough_params(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.alias_passthrough_params) } // int32 num_partitions = 9; inline void ExecutionOptions::clear_num_partitions() { _impl_.num_partitions_ = 0; } inline int32_t ExecutionOptions::_internal_num_partitions() const { return _impl_.num_partitions_; } inline int32_t ExecutionOptions::num_partitions() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.num_partitions) return _internal_num_partitions(); } inline void ExecutionOptions::_internal_set_num_partitions(int32_t value) { _impl_.num_partitions_ = value; } inline void ExecutionOptions::set_num_partitions(int32_t value) { _internal_set_num_partitions(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.num_partitions) } // int32 launch_id = 10; inline void ExecutionOptions::clear_launch_id() { _impl_.launch_id_ = 0; } inline int32_t ExecutionOptions::_internal_launch_id() const { return _impl_.launch_id_; } inline int32_t ExecutionOptions::launch_id() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.launch_id) return _internal_launch_id(); } inline void ExecutionOptions::_internal_set_launch_id(int32_t value) { _impl_.launch_id_ = value; } inline void ExecutionOptions::set_launch_id(int32_t value) { _internal_set_launch_id(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.launch_id) } // bool use_spmd_partitioning = 11; inline void ExecutionOptions::clear_use_spmd_partitioning() { _impl_.use_spmd_partitioning_ = false; } inline bool ExecutionOptions::_internal_use_spmd_partitioning() const { return _impl_.use_spmd_partitioning_; } inline bool ExecutionOptions::use_spmd_partitioning() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.use_spmd_partitioning) return _internal_use_spmd_partitioning(); } inline void ExecutionOptions::_internal_set_use_spmd_partitioning(bool value) { _impl_.use_spmd_partitioning_ = value; } inline void ExecutionOptions::set_use_spmd_partitioning(bool value) { _internal_set_use_spmd_partitioning(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.use_spmd_partitioning) } // bool use_auto_spmd_partitioning = 15; inline void ExecutionOptions::clear_use_auto_spmd_partitioning() { _impl_.use_auto_spmd_partitioning_ = false; } inline bool ExecutionOptions::_internal_use_auto_spmd_partitioning() const { return _impl_.use_auto_spmd_partitioning_; } inline bool ExecutionOptions::use_auto_spmd_partitioning() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.use_auto_spmd_partitioning) return _internal_use_auto_spmd_partitioning(); } inline void ExecutionOptions::_internal_set_use_auto_spmd_partitioning(bool value) { _impl_.use_auto_spmd_partitioning_ = value; } inline void ExecutionOptions::set_use_auto_spmd_partitioning(bool value) { _internal_set_use_auto_spmd_partitioning(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.use_auto_spmd_partitioning) } // repeated int64 auto_spmd_partitioning_mesh_shape = 16; inline int ExecutionOptions::_internal_auto_spmd_partitioning_mesh_shape_size() const { return _impl_.auto_spmd_partitioning_mesh_shape_.size(); } inline int ExecutionOptions::auto_spmd_partitioning_mesh_shape_size() const { return _internal_auto_spmd_partitioning_mesh_shape_size(); } inline void ExecutionOptions::clear_auto_spmd_partitioning_mesh_shape() { _impl_.auto_spmd_partitioning_mesh_shape_.Clear(); } inline int64_t ExecutionOptions::_internal_auto_spmd_partitioning_mesh_shape(int index) const { return _impl_.auto_spmd_partitioning_mesh_shape_.Get(index); } inline int64_t ExecutionOptions::auto_spmd_partitioning_mesh_shape(int index) const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.auto_spmd_partitioning_mesh_shape) return _internal_auto_spmd_partitioning_mesh_shape(index); } inline void ExecutionOptions::set_auto_spmd_partitioning_mesh_shape(int index, int64_t value) { _impl_.auto_spmd_partitioning_mesh_shape_.Set(index, value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.auto_spmd_partitioning_mesh_shape) } inline void ExecutionOptions::_internal_add_auto_spmd_partitioning_mesh_shape(int64_t value) { _impl_.auto_spmd_partitioning_mesh_shape_.Add(value); } inline void ExecutionOptions::add_auto_spmd_partitioning_mesh_shape(int64_t value) { _internal_add_auto_spmd_partitioning_mesh_shape(value); // @@protoc_insertion_point(field_add:xla.ExecutionOptions.auto_spmd_partitioning_mesh_shape) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& ExecutionOptions::_internal_auto_spmd_partitioning_mesh_shape() const { return _impl_.auto_spmd_partitioning_mesh_shape_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& ExecutionOptions::auto_spmd_partitioning_mesh_shape() const { // @@protoc_insertion_point(field_list:xla.ExecutionOptions.auto_spmd_partitioning_mesh_shape) return _internal_auto_spmd_partitioning_mesh_shape(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* ExecutionOptions::_internal_mutable_auto_spmd_partitioning_mesh_shape() { return &_impl_.auto_spmd_partitioning_mesh_shape_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* ExecutionOptions::mutable_auto_spmd_partitioning_mesh_shape() { // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.auto_spmd_partitioning_mesh_shape) return _internal_mutable_auto_spmd_partitioning_mesh_shape(); } // repeated int64 auto_spmd_partitioning_mesh_ids = 17; inline int ExecutionOptions::_internal_auto_spmd_partitioning_mesh_ids_size() const { return _impl_.auto_spmd_partitioning_mesh_ids_.size(); } inline int ExecutionOptions::auto_spmd_partitioning_mesh_ids_size() const { return _internal_auto_spmd_partitioning_mesh_ids_size(); } inline void ExecutionOptions::clear_auto_spmd_partitioning_mesh_ids() { _impl_.auto_spmd_partitioning_mesh_ids_.Clear(); } inline int64_t ExecutionOptions::_internal_auto_spmd_partitioning_mesh_ids(int index) const { return _impl_.auto_spmd_partitioning_mesh_ids_.Get(index); } inline int64_t ExecutionOptions::auto_spmd_partitioning_mesh_ids(int index) const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.auto_spmd_partitioning_mesh_ids) return _internal_auto_spmd_partitioning_mesh_ids(index); } inline void ExecutionOptions::set_auto_spmd_partitioning_mesh_ids(int index, int64_t value) { _impl_.auto_spmd_partitioning_mesh_ids_.Set(index, value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.auto_spmd_partitioning_mesh_ids) } inline void ExecutionOptions::_internal_add_auto_spmd_partitioning_mesh_ids(int64_t value) { _impl_.auto_spmd_partitioning_mesh_ids_.Add(value); } inline void ExecutionOptions::add_auto_spmd_partitioning_mesh_ids(int64_t value) { _internal_add_auto_spmd_partitioning_mesh_ids(value); // @@protoc_insertion_point(field_add:xla.ExecutionOptions.auto_spmd_partitioning_mesh_ids) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& ExecutionOptions::_internal_auto_spmd_partitioning_mesh_ids() const { return _impl_.auto_spmd_partitioning_mesh_ids_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& ExecutionOptions::auto_spmd_partitioning_mesh_ids() const { // @@protoc_insertion_point(field_list:xla.ExecutionOptions.auto_spmd_partitioning_mesh_ids) return _internal_auto_spmd_partitioning_mesh_ids(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* ExecutionOptions::_internal_mutable_auto_spmd_partitioning_mesh_ids() { return &_impl_.auto_spmd_partitioning_mesh_ids_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* ExecutionOptions::mutable_auto_spmd_partitioning_mesh_ids() { // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.auto_spmd_partitioning_mesh_ids) return _internal_mutable_auto_spmd_partitioning_mesh_ids(); } // float exec_time_optimization_effort = 25; inline void ExecutionOptions::clear_exec_time_optimization_effort() { _impl_.exec_time_optimization_effort_ = 0; } inline float ExecutionOptions::_internal_exec_time_optimization_effort() const { return _impl_.exec_time_optimization_effort_; } inline float ExecutionOptions::exec_time_optimization_effort() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.exec_time_optimization_effort) return _internal_exec_time_optimization_effort(); } inline void ExecutionOptions::_internal_set_exec_time_optimization_effort(float value) { _impl_.exec_time_optimization_effort_ = value; } inline void ExecutionOptions::set_exec_time_optimization_effort(float value) { _internal_set_exec_time_optimization_effort(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.exec_time_optimization_effort) } // float memory_fitting_effort = 26; inline void ExecutionOptions::clear_memory_fitting_effort() { _impl_.memory_fitting_effort_ = 0; } inline float ExecutionOptions::_internal_memory_fitting_effort() const { return _impl_.memory_fitting_effort_; } inline float ExecutionOptions::memory_fitting_effort() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.memory_fitting_effort) return _internal_memory_fitting_effort(); } inline void ExecutionOptions::_internal_set_memory_fitting_effort(float value) { _impl_.memory_fitting_effort_ = value; } inline void ExecutionOptions::set_memory_fitting_effort(float value) { _internal_set_memory_fitting_effort(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.memory_fitting_effort) } // bool deduplicate_hlo = 12; inline void ExecutionOptions::clear_deduplicate_hlo() { _impl_.deduplicate_hlo_ = false; } inline bool ExecutionOptions::_internal_deduplicate_hlo() const { return _impl_.deduplicate_hlo_; } inline bool ExecutionOptions::deduplicate_hlo() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.deduplicate_hlo) return _internal_deduplicate_hlo(); } inline void ExecutionOptions::_internal_set_deduplicate_hlo(bool value) { _impl_.deduplicate_hlo_ = value; } inline void ExecutionOptions::set_deduplicate_hlo(bool value) { _internal_set_deduplicate_hlo(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.deduplicate_hlo) } // repeated bool allow_spmd_sharding_propagation_to_parameters = 23; inline int ExecutionOptions::_internal_allow_spmd_sharding_propagation_to_parameters_size() const { return _impl_.allow_spmd_sharding_propagation_to_parameters_.size(); } inline int ExecutionOptions::allow_spmd_sharding_propagation_to_parameters_size() const { return _internal_allow_spmd_sharding_propagation_to_parameters_size(); } inline void ExecutionOptions::clear_allow_spmd_sharding_propagation_to_parameters() { _impl_.allow_spmd_sharding_propagation_to_parameters_.Clear(); } inline bool ExecutionOptions::_internal_allow_spmd_sharding_propagation_to_parameters(int index) const { return _impl_.allow_spmd_sharding_propagation_to_parameters_.Get(index); } inline bool ExecutionOptions::allow_spmd_sharding_propagation_to_parameters(int index) const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_parameters) return _internal_allow_spmd_sharding_propagation_to_parameters(index); } inline void ExecutionOptions::set_allow_spmd_sharding_propagation_to_parameters(int index, bool value) { _impl_.allow_spmd_sharding_propagation_to_parameters_.Set(index, value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_parameters) } inline void ExecutionOptions::_internal_add_allow_spmd_sharding_propagation_to_parameters(bool value) { _impl_.allow_spmd_sharding_propagation_to_parameters_.Add(value); } inline void ExecutionOptions::add_allow_spmd_sharding_propagation_to_parameters(bool value) { _internal_add_allow_spmd_sharding_propagation_to_parameters(value); // @@protoc_insertion_point(field_add:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_parameters) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& ExecutionOptions::_internal_allow_spmd_sharding_propagation_to_parameters() const { return _impl_.allow_spmd_sharding_propagation_to_parameters_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& ExecutionOptions::allow_spmd_sharding_propagation_to_parameters() const { // @@protoc_insertion_point(field_list:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_parameters) return _internal_allow_spmd_sharding_propagation_to_parameters(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* ExecutionOptions::_internal_mutable_allow_spmd_sharding_propagation_to_parameters() { return &_impl_.allow_spmd_sharding_propagation_to_parameters_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* ExecutionOptions::mutable_allow_spmd_sharding_propagation_to_parameters() { // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_parameters) return _internal_mutable_allow_spmd_sharding_propagation_to_parameters(); } // repeated bool allow_spmd_sharding_propagation_to_output = 14; inline int ExecutionOptions::_internal_allow_spmd_sharding_propagation_to_output_size() const { return _impl_.allow_spmd_sharding_propagation_to_output_.size(); } inline int ExecutionOptions::allow_spmd_sharding_propagation_to_output_size() const { return _internal_allow_spmd_sharding_propagation_to_output_size(); } inline void ExecutionOptions::clear_allow_spmd_sharding_propagation_to_output() { _impl_.allow_spmd_sharding_propagation_to_output_.Clear(); } inline bool ExecutionOptions::_internal_allow_spmd_sharding_propagation_to_output(int index) const { return _impl_.allow_spmd_sharding_propagation_to_output_.Get(index); } inline bool ExecutionOptions::allow_spmd_sharding_propagation_to_output(int index) const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_output) return _internal_allow_spmd_sharding_propagation_to_output(index); } inline void ExecutionOptions::set_allow_spmd_sharding_propagation_to_output(int index, bool value) { _impl_.allow_spmd_sharding_propagation_to_output_.Set(index, value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_output) } inline void ExecutionOptions::_internal_add_allow_spmd_sharding_propagation_to_output(bool value) { _impl_.allow_spmd_sharding_propagation_to_output_.Add(value); } inline void ExecutionOptions::add_allow_spmd_sharding_propagation_to_output(bool value) { _internal_add_allow_spmd_sharding_propagation_to_output(value); // @@protoc_insertion_point(field_add:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_output) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& ExecutionOptions::_internal_allow_spmd_sharding_propagation_to_output() const { return _impl_.allow_spmd_sharding_propagation_to_output_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& ExecutionOptions::allow_spmd_sharding_propagation_to_output() const { // @@protoc_insertion_point(field_list:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_output) return _internal_allow_spmd_sharding_propagation_to_output(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* ExecutionOptions::_internal_mutable_allow_spmd_sharding_propagation_to_output() { return &_impl_.allow_spmd_sharding_propagation_to_output_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* ExecutionOptions::mutable_allow_spmd_sharding_propagation_to_output() { // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.allow_spmd_sharding_propagation_to_output) return _internal_mutable_allow_spmd_sharding_propagation_to_output(); } // repeated bool param_requires_broadcast_via_collectives = 18; inline int ExecutionOptions::_internal_param_requires_broadcast_via_collectives_size() const { return _impl_.param_requires_broadcast_via_collectives_.size(); } inline int ExecutionOptions::param_requires_broadcast_via_collectives_size() const { return _internal_param_requires_broadcast_via_collectives_size(); } inline void ExecutionOptions::clear_param_requires_broadcast_via_collectives() { _impl_.param_requires_broadcast_via_collectives_.Clear(); } inline bool ExecutionOptions::_internal_param_requires_broadcast_via_collectives(int index) const { return _impl_.param_requires_broadcast_via_collectives_.Get(index); } inline bool ExecutionOptions::param_requires_broadcast_via_collectives(int index) const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.param_requires_broadcast_via_collectives) return _internal_param_requires_broadcast_via_collectives(index); } inline void ExecutionOptions::set_param_requires_broadcast_via_collectives(int index, bool value) { _impl_.param_requires_broadcast_via_collectives_.Set(index, value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.param_requires_broadcast_via_collectives) } inline void ExecutionOptions::_internal_add_param_requires_broadcast_via_collectives(bool value) { _impl_.param_requires_broadcast_via_collectives_.Add(value); } inline void ExecutionOptions::add_param_requires_broadcast_via_collectives(bool value) { _internal_add_param_requires_broadcast_via_collectives(value); // @@protoc_insertion_point(field_add:xla.ExecutionOptions.param_requires_broadcast_via_collectives) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& ExecutionOptions::_internal_param_requires_broadcast_via_collectives() const { return _impl_.param_requires_broadcast_via_collectives_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& ExecutionOptions::param_requires_broadcast_via_collectives() const { // @@protoc_insertion_point(field_list:xla.ExecutionOptions.param_requires_broadcast_via_collectives) return _internal_param_requires_broadcast_via_collectives(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* ExecutionOptions::_internal_mutable_param_requires_broadcast_via_collectives() { return &_impl_.param_requires_broadcast_via_collectives_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* ExecutionOptions::mutable_param_requires_broadcast_via_collectives() { // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.param_requires_broadcast_via_collectives) return _internal_mutable_param_requires_broadcast_via_collectives(); } // bool allow_separate_sharding_programs = 19; inline void ExecutionOptions::clear_allow_separate_sharding_programs() { _impl_.allow_separate_sharding_programs_ = false; } inline bool ExecutionOptions::_internal_allow_separate_sharding_programs() const { return _impl_.allow_separate_sharding_programs_; } inline bool ExecutionOptions::allow_separate_sharding_programs() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.allow_separate_sharding_programs) return _internal_allow_separate_sharding_programs(); } inline void ExecutionOptions::_internal_set_allow_separate_sharding_programs(bool value) { _impl_.allow_separate_sharding_programs_ = value; } inline void ExecutionOptions::set_allow_separate_sharding_programs(bool value) { _internal_set_allow_separate_sharding_programs(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.allow_separate_sharding_programs) } // repeated .xla.ShardableValueUpdatePairProto shardable_value_update_pairs = 20; inline int ExecutionOptions::_internal_shardable_value_update_pairs_size() const { return _impl_.shardable_value_update_pairs_.size(); } inline int ExecutionOptions::shardable_value_update_pairs_size() const { return _internal_shardable_value_update_pairs_size(); } inline void ExecutionOptions::clear_shardable_value_update_pairs() { _impl_.shardable_value_update_pairs_.Clear(); } inline ::xla::ShardableValueUpdatePairProto* ExecutionOptions::mutable_shardable_value_update_pairs(int index) { // @@protoc_insertion_point(field_mutable:xla.ExecutionOptions.shardable_value_update_pairs) return _impl_.shardable_value_update_pairs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShardableValueUpdatePairProto >* ExecutionOptions::mutable_shardable_value_update_pairs() { // @@protoc_insertion_point(field_mutable_list:xla.ExecutionOptions.shardable_value_update_pairs) return &_impl_.shardable_value_update_pairs_; } inline const ::xla::ShardableValueUpdatePairProto& ExecutionOptions::_internal_shardable_value_update_pairs(int index) const { return _impl_.shardable_value_update_pairs_.Get(index); } inline const ::xla::ShardableValueUpdatePairProto& ExecutionOptions::shardable_value_update_pairs(int index) const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.shardable_value_update_pairs) return _internal_shardable_value_update_pairs(index); } inline ::xla::ShardableValueUpdatePairProto* ExecutionOptions::_internal_add_shardable_value_update_pairs() { return _impl_.shardable_value_update_pairs_.Add(); } inline ::xla::ShardableValueUpdatePairProto* ExecutionOptions::add_shardable_value_update_pairs() { ::xla::ShardableValueUpdatePairProto* _add = _internal_add_shardable_value_update_pairs(); // @@protoc_insertion_point(field_add:xla.ExecutionOptions.shardable_value_update_pairs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShardableValueUpdatePairProto >& ExecutionOptions::shardable_value_update_pairs() const { // @@protoc_insertion_point(field_list:xla.ExecutionOptions.shardable_value_update_pairs) return _impl_.shardable_value_update_pairs_; } // bytes fdo_profile = 21; inline void ExecutionOptions::clear_fdo_profile() { _impl_.fdo_profile_.ClearToEmpty(); } inline const std::string& ExecutionOptions::fdo_profile() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.fdo_profile) return _internal_fdo_profile(); } template inline PROTOBUF_ALWAYS_INLINE void ExecutionOptions::set_fdo_profile(ArgT0&& arg0, ArgT... args) { _impl_.fdo_profile_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.fdo_profile) } inline std::string* ExecutionOptions::mutable_fdo_profile() { std::string* _s = _internal_mutable_fdo_profile(); // @@protoc_insertion_point(field_mutable:xla.ExecutionOptions.fdo_profile) return _s; } inline const std::string& ExecutionOptions::_internal_fdo_profile() const { return _impl_.fdo_profile_.Get(); } inline void ExecutionOptions::_internal_set_fdo_profile(const std::string& value) { _impl_.fdo_profile_.Set(value, GetArenaForAllocation()); } inline std::string* ExecutionOptions::_internal_mutable_fdo_profile() { return _impl_.fdo_profile_.Mutable(GetArenaForAllocation()); } inline std::string* ExecutionOptions::release_fdo_profile() { // @@protoc_insertion_point(field_release:xla.ExecutionOptions.fdo_profile) return _impl_.fdo_profile_.Release(); } inline void ExecutionOptions::set_allocated_fdo_profile(std::string* fdo_profile) { if (fdo_profile != nullptr) { } else { } _impl_.fdo_profile_.SetAllocated(fdo_profile, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.fdo_profile_.IsDefault()) { _impl_.fdo_profile_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.ExecutionOptions.fdo_profile) } // int64 device_memory_size = 22; inline void ExecutionOptions::clear_device_memory_size() { _impl_.device_memory_size_ = int64_t{0}; } inline int64_t ExecutionOptions::_internal_device_memory_size() const { return _impl_.device_memory_size_; } inline int64_t ExecutionOptions::device_memory_size() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.device_memory_size) return _internal_device_memory_size(); } inline void ExecutionOptions::_internal_set_device_memory_size(int64_t value) { _impl_.device_memory_size_ = value; } inline void ExecutionOptions::set_device_memory_size(int64_t value) { _internal_set_device_memory_size(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.device_memory_size) } // bool use_shardy_partitioner = 24; inline void ExecutionOptions::clear_use_shardy_partitioner() { _impl_.use_shardy_partitioner_ = false; } inline bool ExecutionOptions::_internal_use_shardy_partitioner() const { return _impl_.use_shardy_partitioner_; } inline bool ExecutionOptions::use_shardy_partitioner() const { // @@protoc_insertion_point(field_get:xla.ExecutionOptions.use_shardy_partitioner) return _internal_use_shardy_partitioner(); } inline void ExecutionOptions::_internal_set_use_shardy_partitioner(bool value) { _impl_.use_shardy_partitioner_ = value; } inline void ExecutionOptions::set_use_shardy_partitioner(bool value) { _internal_set_use_shardy_partitioner(value); // @@protoc_insertion_point(field_set:xla.ExecutionOptions.use_shardy_partitioner) } // ------------------------------------------------------------------- // HloModuleConfigProto_BoolList // repeated bool vals = 1; inline int HloModuleConfigProto_BoolList::_internal_vals_size() const { return _impl_.vals_.size(); } inline int HloModuleConfigProto_BoolList::vals_size() const { return _internal_vals_size(); } inline void HloModuleConfigProto_BoolList::clear_vals() { _impl_.vals_.Clear(); } inline bool HloModuleConfigProto_BoolList::_internal_vals(int index) const { return _impl_.vals_.Get(index); } inline bool HloModuleConfigProto_BoolList::vals(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.BoolList.vals) return _internal_vals(index); } inline void HloModuleConfigProto_BoolList::set_vals(int index, bool value) { _impl_.vals_.Set(index, value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.BoolList.vals) } inline void HloModuleConfigProto_BoolList::_internal_add_vals(bool value) { _impl_.vals_.Add(value); } inline void HloModuleConfigProto_BoolList::add_vals(bool value) { _internal_add_vals(value); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.BoolList.vals) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& HloModuleConfigProto_BoolList::_internal_vals() const { return _impl_.vals_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& HloModuleConfigProto_BoolList::vals() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.BoolList.vals) return _internal_vals(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* HloModuleConfigProto_BoolList::_internal_mutable_vals() { return &_impl_.vals_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* HloModuleConfigProto_BoolList::mutable_vals() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.BoolList.vals) return _internal_mutable_vals(); } // ------------------------------------------------------------------- // HloModuleConfigProto_Int64List // repeated int64 vals = 1; inline int HloModuleConfigProto_Int64List::_internal_vals_size() const { return _impl_.vals_.size(); } inline int HloModuleConfigProto_Int64List::vals_size() const { return _internal_vals_size(); } inline void HloModuleConfigProto_Int64List::clear_vals() { _impl_.vals_.Clear(); } inline int64_t HloModuleConfigProto_Int64List::_internal_vals(int index) const { return _impl_.vals_.Get(index); } inline int64_t HloModuleConfigProto_Int64List::vals(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.Int64List.vals) return _internal_vals(index); } inline void HloModuleConfigProto_Int64List::set_vals(int index, int64_t value) { _impl_.vals_.Set(index, value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.Int64List.vals) } inline void HloModuleConfigProto_Int64List::_internal_add_vals(int64_t value) { _impl_.vals_.Add(value); } inline void HloModuleConfigProto_Int64List::add_vals(int64_t value) { _internal_add_vals(value); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.Int64List.vals) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& HloModuleConfigProto_Int64List::_internal_vals() const { return _impl_.vals_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& HloModuleConfigProto_Int64List::vals() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.Int64List.vals) return _internal_vals(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* HloModuleConfigProto_Int64List::_internal_mutable_vals() { return &_impl_.vals_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* HloModuleConfigProto_Int64List::mutable_vals() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.Int64List.vals) return _internal_mutable_vals(); } // ------------------------------------------------------------------- // HloModuleConfigProto_Int64ListList // repeated .xla.HloModuleConfigProto.Int64List lists = 1; inline int HloModuleConfigProto_Int64ListList::_internal_lists_size() const { return _impl_.lists_.size(); } inline int HloModuleConfigProto_Int64ListList::lists_size() const { return _internal_lists_size(); } inline void HloModuleConfigProto_Int64ListList::clear_lists() { _impl_.lists_.Clear(); } inline ::xla::HloModuleConfigProto_Int64List* HloModuleConfigProto_Int64ListList::mutable_lists(int index) { // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.Int64ListList.lists) return _impl_.lists_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_Int64List >* HloModuleConfigProto_Int64ListList::mutable_lists() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.Int64ListList.lists) return &_impl_.lists_; } inline const ::xla::HloModuleConfigProto_Int64List& HloModuleConfigProto_Int64ListList::_internal_lists(int index) const { return _impl_.lists_.Get(index); } inline const ::xla::HloModuleConfigProto_Int64List& HloModuleConfigProto_Int64ListList::lists(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.Int64ListList.lists) return _internal_lists(index); } inline ::xla::HloModuleConfigProto_Int64List* HloModuleConfigProto_Int64ListList::_internal_add_lists() { return _impl_.lists_.Add(); } inline ::xla::HloModuleConfigProto_Int64List* HloModuleConfigProto_Int64ListList::add_lists() { ::xla::HloModuleConfigProto_Int64List* _add = _internal_add_lists(); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.Int64ListList.lists) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_Int64List >& HloModuleConfigProto_Int64ListList::lists() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.Int64ListList.lists) return _impl_.lists_; } // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // HloModuleConfigProto // .xla.ProgramShapeProto entry_computation_layout = 1; inline bool HloModuleConfigProto::_internal_has_entry_computation_layout() const { return this != internal_default_instance() && _impl_.entry_computation_layout_ != nullptr; } inline bool HloModuleConfigProto::has_entry_computation_layout() const { return _internal_has_entry_computation_layout(); } inline const ::xla::ProgramShapeProto& HloModuleConfigProto::_internal_entry_computation_layout() const { const ::xla::ProgramShapeProto* p = _impl_.entry_computation_layout_; return p != nullptr ? *p : reinterpret_cast( ::xla::_ProgramShapeProto_default_instance_); } inline const ::xla::ProgramShapeProto& HloModuleConfigProto::entry_computation_layout() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.entry_computation_layout) return _internal_entry_computation_layout(); } inline void HloModuleConfigProto::unsafe_arena_set_allocated_entry_computation_layout( ::xla::ProgramShapeProto* entry_computation_layout) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entry_computation_layout_); } _impl_.entry_computation_layout_ = entry_computation_layout; if (entry_computation_layout) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleConfigProto.entry_computation_layout) } inline ::xla::ProgramShapeProto* HloModuleConfigProto::release_entry_computation_layout() { ::xla::ProgramShapeProto* temp = _impl_.entry_computation_layout_; _impl_.entry_computation_layout_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::xla::ProgramShapeProto* HloModuleConfigProto::unsafe_arena_release_entry_computation_layout() { // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.entry_computation_layout) ::xla::ProgramShapeProto* temp = _impl_.entry_computation_layout_; _impl_.entry_computation_layout_ = nullptr; return temp; } inline ::xla::ProgramShapeProto* HloModuleConfigProto::_internal_mutable_entry_computation_layout() { if (_impl_.entry_computation_layout_ == nullptr) { auto* p = CreateMaybeMessage<::xla::ProgramShapeProto>(GetArenaForAllocation()); _impl_.entry_computation_layout_ = p; } return _impl_.entry_computation_layout_; } inline ::xla::ProgramShapeProto* HloModuleConfigProto::mutable_entry_computation_layout() { ::xla::ProgramShapeProto* _msg = _internal_mutable_entry_computation_layout(); // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.entry_computation_layout) return _msg; } inline void HloModuleConfigProto::set_allocated_entry_computation_layout(::xla::ProgramShapeProto* entry_computation_layout) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entry_computation_layout_); } if (entry_computation_layout) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(entry_computation_layout)); if (message_arena != submessage_arena) { entry_computation_layout = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, entry_computation_layout, submessage_arena); } } else { } _impl_.entry_computation_layout_ = entry_computation_layout; // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.entry_computation_layout) } // uint64 seed = 2; inline void HloModuleConfigProto::clear_seed() { _impl_.seed_ = uint64_t{0u}; } inline uint64_t HloModuleConfigProto::_internal_seed() const { return _impl_.seed_; } inline uint64_t HloModuleConfigProto::seed() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.seed) return _internal_seed(); } inline void HloModuleConfigProto::_internal_set_seed(uint64_t value) { _impl_.seed_ = value; } inline void HloModuleConfigProto::set_seed(uint64_t value) { _internal_set_seed(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.seed) } // int32 launch_id = 3; inline void HloModuleConfigProto::clear_launch_id() { _impl_.launch_id_ = 0; } inline int32_t HloModuleConfigProto::_internal_launch_id() const { return _impl_.launch_id_; } inline int32_t HloModuleConfigProto::launch_id() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.launch_id) return _internal_launch_id(); } inline void HloModuleConfigProto::_internal_set_launch_id(int32_t value) { _impl_.launch_id_ = value; } inline void HloModuleConfigProto::set_launch_id(int32_t value) { _internal_set_launch_id(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.launch_id) } // int64 replica_count = 4; inline void HloModuleConfigProto::clear_replica_count() { _impl_.replica_count_ = int64_t{0}; } inline int64_t HloModuleConfigProto::_internal_replica_count() const { return _impl_.replica_count_; } inline int64_t HloModuleConfigProto::replica_count() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.replica_count) return _internal_replica_count(); } inline void HloModuleConfigProto::_internal_set_replica_count(int64_t value) { _impl_.replica_count_ = value; } inline void HloModuleConfigProto::set_replica_count(int64_t value) { _internal_set_replica_count(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.replica_count) } // int64 num_partitions = 5; inline void HloModuleConfigProto::clear_num_partitions() { _impl_.num_partitions_ = int64_t{0}; } inline int64_t HloModuleConfigProto::_internal_num_partitions() const { return _impl_.num_partitions_; } inline int64_t HloModuleConfigProto::num_partitions() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.num_partitions) return _internal_num_partitions(); } inline void HloModuleConfigProto::_internal_set_num_partitions(int64_t value) { _impl_.num_partitions_ = value; } inline void HloModuleConfigProto::set_num_partitions(int64_t value) { _internal_set_num_partitions(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.num_partitions) } // repeated bool param_requires_broadcast_via_collectives = 6; inline int HloModuleConfigProto::_internal_param_requires_broadcast_via_collectives_size() const { return _impl_.param_requires_broadcast_via_collectives_.size(); } inline int HloModuleConfigProto::param_requires_broadcast_via_collectives_size() const { return _internal_param_requires_broadcast_via_collectives_size(); } inline void HloModuleConfigProto::clear_param_requires_broadcast_via_collectives() { _impl_.param_requires_broadcast_via_collectives_.Clear(); } inline bool HloModuleConfigProto::_internal_param_requires_broadcast_via_collectives(int index) const { return _impl_.param_requires_broadcast_via_collectives_.Get(index); } inline bool HloModuleConfigProto::param_requires_broadcast_via_collectives(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.param_requires_broadcast_via_collectives) return _internal_param_requires_broadcast_via_collectives(index); } inline void HloModuleConfigProto::set_param_requires_broadcast_via_collectives(int index, bool value) { _impl_.param_requires_broadcast_via_collectives_.Set(index, value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.param_requires_broadcast_via_collectives) } inline void HloModuleConfigProto::_internal_add_param_requires_broadcast_via_collectives(bool value) { _impl_.param_requires_broadcast_via_collectives_.Add(value); } inline void HloModuleConfigProto::add_param_requires_broadcast_via_collectives(bool value) { _internal_add_param_requires_broadcast_via_collectives(value); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.param_requires_broadcast_via_collectives) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& HloModuleConfigProto::_internal_param_requires_broadcast_via_collectives() const { return _impl_.param_requires_broadcast_via_collectives_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& HloModuleConfigProto::param_requires_broadcast_via_collectives() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.param_requires_broadcast_via_collectives) return _internal_param_requires_broadcast_via_collectives(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* HloModuleConfigProto::_internal_mutable_param_requires_broadcast_via_collectives() { return &_impl_.param_requires_broadcast_via_collectives_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* HloModuleConfigProto::mutable_param_requires_broadcast_via_collectives() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.param_requires_broadcast_via_collectives) return _internal_mutable_param_requires_broadcast_via_collectives(); } // bool use_spmd_partitioning = 7; inline void HloModuleConfigProto::clear_use_spmd_partitioning() { _impl_.use_spmd_partitioning_ = false; } inline bool HloModuleConfigProto::_internal_use_spmd_partitioning() const { return _impl_.use_spmd_partitioning_; } inline bool HloModuleConfigProto::use_spmd_partitioning() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.use_spmd_partitioning) return _internal_use_spmd_partitioning(); } inline void HloModuleConfigProto::_internal_set_use_spmd_partitioning(bool value) { _impl_.use_spmd_partitioning_ = value; } inline void HloModuleConfigProto::set_use_spmd_partitioning(bool value) { _internal_set_use_spmd_partitioning(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.use_spmd_partitioning) } // bool use_auto_spmd_partitioning = 8; inline void HloModuleConfigProto::clear_use_auto_spmd_partitioning() { _impl_.use_auto_spmd_partitioning_ = false; } inline bool HloModuleConfigProto::_internal_use_auto_spmd_partitioning() const { return _impl_.use_auto_spmd_partitioning_; } inline bool HloModuleConfigProto::use_auto_spmd_partitioning() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.use_auto_spmd_partitioning) return _internal_use_auto_spmd_partitioning(); } inline void HloModuleConfigProto::_internal_set_use_auto_spmd_partitioning(bool value) { _impl_.use_auto_spmd_partitioning_ = value; } inline void HloModuleConfigProto::set_use_auto_spmd_partitioning(bool value) { _internal_set_use_auto_spmd_partitioning(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.use_auto_spmd_partitioning) } // repeated int64 auto_spmd_partitioning_mesh_shape = 9; inline int HloModuleConfigProto::_internal_auto_spmd_partitioning_mesh_shape_size() const { return _impl_.auto_spmd_partitioning_mesh_shape_.size(); } inline int HloModuleConfigProto::auto_spmd_partitioning_mesh_shape_size() const { return _internal_auto_spmd_partitioning_mesh_shape_size(); } inline void HloModuleConfigProto::clear_auto_spmd_partitioning_mesh_shape() { _impl_.auto_spmd_partitioning_mesh_shape_.Clear(); } inline int64_t HloModuleConfigProto::_internal_auto_spmd_partitioning_mesh_shape(int index) const { return _impl_.auto_spmd_partitioning_mesh_shape_.Get(index); } inline int64_t HloModuleConfigProto::auto_spmd_partitioning_mesh_shape(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_shape) return _internal_auto_spmd_partitioning_mesh_shape(index); } inline void HloModuleConfigProto::set_auto_spmd_partitioning_mesh_shape(int index, int64_t value) { _impl_.auto_spmd_partitioning_mesh_shape_.Set(index, value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_shape) } inline void HloModuleConfigProto::_internal_add_auto_spmd_partitioning_mesh_shape(int64_t value) { _impl_.auto_spmd_partitioning_mesh_shape_.Add(value); } inline void HloModuleConfigProto::add_auto_spmd_partitioning_mesh_shape(int64_t value) { _internal_add_auto_spmd_partitioning_mesh_shape(value); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_shape) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& HloModuleConfigProto::_internal_auto_spmd_partitioning_mesh_shape() const { return _impl_.auto_spmd_partitioning_mesh_shape_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& HloModuleConfigProto::auto_spmd_partitioning_mesh_shape() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_shape) return _internal_auto_spmd_partitioning_mesh_shape(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* HloModuleConfigProto::_internal_mutable_auto_spmd_partitioning_mesh_shape() { return &_impl_.auto_spmd_partitioning_mesh_shape_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* HloModuleConfigProto::mutable_auto_spmd_partitioning_mesh_shape() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_shape) return _internal_mutable_auto_spmd_partitioning_mesh_shape(); } // repeated int64 auto_spmd_partitioning_mesh_ids = 10; inline int HloModuleConfigProto::_internal_auto_spmd_partitioning_mesh_ids_size() const { return _impl_.auto_spmd_partitioning_mesh_ids_.size(); } inline int HloModuleConfigProto::auto_spmd_partitioning_mesh_ids_size() const { return _internal_auto_spmd_partitioning_mesh_ids_size(); } inline void HloModuleConfigProto::clear_auto_spmd_partitioning_mesh_ids() { _impl_.auto_spmd_partitioning_mesh_ids_.Clear(); } inline int64_t HloModuleConfigProto::_internal_auto_spmd_partitioning_mesh_ids(int index) const { return _impl_.auto_spmd_partitioning_mesh_ids_.Get(index); } inline int64_t HloModuleConfigProto::auto_spmd_partitioning_mesh_ids(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_ids) return _internal_auto_spmd_partitioning_mesh_ids(index); } inline void HloModuleConfigProto::set_auto_spmd_partitioning_mesh_ids(int index, int64_t value) { _impl_.auto_spmd_partitioning_mesh_ids_.Set(index, value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_ids) } inline void HloModuleConfigProto::_internal_add_auto_spmd_partitioning_mesh_ids(int64_t value) { _impl_.auto_spmd_partitioning_mesh_ids_.Add(value); } inline void HloModuleConfigProto::add_auto_spmd_partitioning_mesh_ids(int64_t value) { _internal_add_auto_spmd_partitioning_mesh_ids(value); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_ids) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& HloModuleConfigProto::_internal_auto_spmd_partitioning_mesh_ids() const { return _impl_.auto_spmd_partitioning_mesh_ids_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& HloModuleConfigProto::auto_spmd_partitioning_mesh_ids() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_ids) return _internal_auto_spmd_partitioning_mesh_ids(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* HloModuleConfigProto::_internal_mutable_auto_spmd_partitioning_mesh_ids() { return &_impl_.auto_spmd_partitioning_mesh_ids_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* HloModuleConfigProto::mutable_auto_spmd_partitioning_mesh_ids() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.auto_spmd_partitioning_mesh_ids) return _internal_mutable_auto_spmd_partitioning_mesh_ids(); } // float exec_time_optimization_effort = 36; inline void HloModuleConfigProto::clear_exec_time_optimization_effort() { _impl_.exec_time_optimization_effort_ = 0; } inline float HloModuleConfigProto::_internal_exec_time_optimization_effort() const { return _impl_.exec_time_optimization_effort_; } inline float HloModuleConfigProto::exec_time_optimization_effort() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.exec_time_optimization_effort) return _internal_exec_time_optimization_effort(); } inline void HloModuleConfigProto::_internal_set_exec_time_optimization_effort(float value) { _impl_.exec_time_optimization_effort_ = value; } inline void HloModuleConfigProto::set_exec_time_optimization_effort(float value) { _internal_set_exec_time_optimization_effort(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.exec_time_optimization_effort) } // float memory_fitting_effort = 37; inline void HloModuleConfigProto::clear_memory_fitting_effort() { _impl_.memory_fitting_effort_ = 0; } inline float HloModuleConfigProto::_internal_memory_fitting_effort() const { return _impl_.memory_fitting_effort_; } inline float HloModuleConfigProto::memory_fitting_effort() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.memory_fitting_effort) return _internal_memory_fitting_effort(); } inline void HloModuleConfigProto::_internal_set_memory_fitting_effort(float value) { _impl_.memory_fitting_effort_ = value; } inline void HloModuleConfigProto::set_memory_fitting_effort(float value) { _internal_set_memory_fitting_effort(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.memory_fitting_effort) } // bool deduplicate_hlo = 11; inline void HloModuleConfigProto::clear_deduplicate_hlo() { _impl_.deduplicate_hlo_ = false; } inline bool HloModuleConfigProto::_internal_deduplicate_hlo() const { return _impl_.deduplicate_hlo_; } inline bool HloModuleConfigProto::deduplicate_hlo() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.deduplicate_hlo) return _internal_deduplicate_hlo(); } inline void HloModuleConfigProto::_internal_set_deduplicate_hlo(bool value) { _impl_.deduplicate_hlo_ = value; } inline void HloModuleConfigProto::set_deduplicate_hlo(bool value) { _internal_set_deduplicate_hlo(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.deduplicate_hlo) } // int64 intra_op_parallelism_threads = 12; inline void HloModuleConfigProto::clear_intra_op_parallelism_threads() { _impl_.intra_op_parallelism_threads_ = int64_t{0}; } inline int64_t HloModuleConfigProto::_internal_intra_op_parallelism_threads() const { return _impl_.intra_op_parallelism_threads_; } inline int64_t HloModuleConfigProto::intra_op_parallelism_threads() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.intra_op_parallelism_threads) return _internal_intra_op_parallelism_threads(); } inline void HloModuleConfigProto::_internal_set_intra_op_parallelism_threads(int64_t value) { _impl_.intra_op_parallelism_threads_ = value; } inline void HloModuleConfigProto::set_intra_op_parallelism_threads(int64_t value) { _internal_set_intra_op_parallelism_threads(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.intra_op_parallelism_threads) } // string device_type = 13; inline void HloModuleConfigProto::clear_device_type() { _impl_.device_type_.ClearToEmpty(); } inline const std::string& HloModuleConfigProto::device_type() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.device_type) return _internal_device_type(); } template inline PROTOBUF_ALWAYS_INLINE void HloModuleConfigProto::set_device_type(ArgT0&& arg0, ArgT... args) { _impl_.device_type_.Set(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.device_type) } inline std::string* HloModuleConfigProto::mutable_device_type() { std::string* _s = _internal_mutable_device_type(); // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.device_type) return _s; } inline const std::string& HloModuleConfigProto::_internal_device_type() const { return _impl_.device_type_.Get(); } inline void HloModuleConfigProto::_internal_set_device_type(const std::string& value) { _impl_.device_type_.Set(value, GetArenaForAllocation()); } inline std::string* HloModuleConfigProto::_internal_mutable_device_type() { return _impl_.device_type_.Mutable(GetArenaForAllocation()); } inline std::string* HloModuleConfigProto::release_device_type() { // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.device_type) return _impl_.device_type_.Release(); } inline void HloModuleConfigProto::set_allocated_device_type(std::string* device_type) { if (device_type != nullptr) { } else { } _impl_.device_type_.SetAllocated(device_type, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.device_type_.IsDefault()) { _impl_.device_type_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.device_type) } // .xla.DebugOptions debug_options = 14; inline bool HloModuleConfigProto::_internal_has_debug_options() const { return this != internal_default_instance() && _impl_.debug_options_ != nullptr; } inline bool HloModuleConfigProto::has_debug_options() const { return _internal_has_debug_options(); } inline void HloModuleConfigProto::clear_debug_options() { if (GetArenaForAllocation() == nullptr && _impl_.debug_options_ != nullptr) { delete _impl_.debug_options_; } _impl_.debug_options_ = nullptr; } inline const ::xla::DebugOptions& HloModuleConfigProto::_internal_debug_options() const { const ::xla::DebugOptions* p = _impl_.debug_options_; return p != nullptr ? *p : reinterpret_cast( ::xla::_DebugOptions_default_instance_); } inline const ::xla::DebugOptions& HloModuleConfigProto::debug_options() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.debug_options) return _internal_debug_options(); } inline void HloModuleConfigProto::unsafe_arena_set_allocated_debug_options( ::xla::DebugOptions* debug_options) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.debug_options_); } _impl_.debug_options_ = debug_options; if (debug_options) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleConfigProto.debug_options) } inline ::xla::DebugOptions* HloModuleConfigProto::release_debug_options() { ::xla::DebugOptions* temp = _impl_.debug_options_; _impl_.debug_options_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::xla::DebugOptions* HloModuleConfigProto::unsafe_arena_release_debug_options() { // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.debug_options) ::xla::DebugOptions* temp = _impl_.debug_options_; _impl_.debug_options_ = nullptr; return temp; } inline ::xla::DebugOptions* HloModuleConfigProto::_internal_mutable_debug_options() { if (_impl_.debug_options_ == nullptr) { auto* p = CreateMaybeMessage<::xla::DebugOptions>(GetArenaForAllocation()); _impl_.debug_options_ = p; } return _impl_.debug_options_; } inline ::xla::DebugOptions* HloModuleConfigProto::mutable_debug_options() { ::xla::DebugOptions* _msg = _internal_mutable_debug_options(); // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.debug_options) return _msg; } inline void HloModuleConfigProto::set_allocated_debug_options(::xla::DebugOptions* debug_options) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.debug_options_; } if (debug_options) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(debug_options); if (message_arena != submessage_arena) { debug_options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, debug_options, submessage_arena); } } else { } _impl_.debug_options_ = debug_options; // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.debug_options) } // .xla.DeviceAssignmentProto static_device_assignment = 15; inline bool HloModuleConfigProto::_internal_has_static_device_assignment() const { return this != internal_default_instance() && _impl_.static_device_assignment_ != nullptr; } inline bool HloModuleConfigProto::has_static_device_assignment() const { return _internal_has_static_device_assignment(); } inline const ::xla::DeviceAssignmentProto& HloModuleConfigProto::_internal_static_device_assignment() const { const ::xla::DeviceAssignmentProto* p = _impl_.static_device_assignment_; return p != nullptr ? *p : reinterpret_cast( ::xla::_DeviceAssignmentProto_default_instance_); } inline const ::xla::DeviceAssignmentProto& HloModuleConfigProto::static_device_assignment() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.static_device_assignment) return _internal_static_device_assignment(); } inline void HloModuleConfigProto::unsafe_arena_set_allocated_static_device_assignment( ::xla::DeviceAssignmentProto* static_device_assignment) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.static_device_assignment_); } _impl_.static_device_assignment_ = static_device_assignment; if (static_device_assignment) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleConfigProto.static_device_assignment) } inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::release_static_device_assignment() { ::xla::DeviceAssignmentProto* temp = _impl_.static_device_assignment_; _impl_.static_device_assignment_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::unsafe_arena_release_static_device_assignment() { // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.static_device_assignment) ::xla::DeviceAssignmentProto* temp = _impl_.static_device_assignment_; _impl_.static_device_assignment_ = nullptr; return temp; } inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::_internal_mutable_static_device_assignment() { if (_impl_.static_device_assignment_ == nullptr) { auto* p = CreateMaybeMessage<::xla::DeviceAssignmentProto>(GetArenaForAllocation()); _impl_.static_device_assignment_ = p; } return _impl_.static_device_assignment_; } inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::mutable_static_device_assignment() { ::xla::DeviceAssignmentProto* _msg = _internal_mutable_static_device_assignment(); // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.static_device_assignment) return _msg; } inline void HloModuleConfigProto::set_allocated_static_device_assignment(::xla::DeviceAssignmentProto* static_device_assignment) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.static_device_assignment_); } if (static_device_assignment) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(static_device_assignment)); if (message_arena != submessage_arena) { static_device_assignment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, static_device_assignment, submessage_arena); } } else { } _impl_.static_device_assignment_ = static_device_assignment; // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.static_device_assignment) } // .xla.DeviceAssignmentProto pre_simulation_device_assignment = 35; inline bool HloModuleConfigProto::_internal_has_pre_simulation_device_assignment() const { return this != internal_default_instance() && _impl_.pre_simulation_device_assignment_ != nullptr; } inline bool HloModuleConfigProto::has_pre_simulation_device_assignment() const { return _internal_has_pre_simulation_device_assignment(); } inline const ::xla::DeviceAssignmentProto& HloModuleConfigProto::_internal_pre_simulation_device_assignment() const { const ::xla::DeviceAssignmentProto* p = _impl_.pre_simulation_device_assignment_; return p != nullptr ? *p : reinterpret_cast( ::xla::_DeviceAssignmentProto_default_instance_); } inline const ::xla::DeviceAssignmentProto& HloModuleConfigProto::pre_simulation_device_assignment() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.pre_simulation_device_assignment) return _internal_pre_simulation_device_assignment(); } inline void HloModuleConfigProto::unsafe_arena_set_allocated_pre_simulation_device_assignment( ::xla::DeviceAssignmentProto* pre_simulation_device_assignment) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pre_simulation_device_assignment_); } _impl_.pre_simulation_device_assignment_ = pre_simulation_device_assignment; if (pre_simulation_device_assignment) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleConfigProto.pre_simulation_device_assignment) } inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::release_pre_simulation_device_assignment() { ::xla::DeviceAssignmentProto* temp = _impl_.pre_simulation_device_assignment_; _impl_.pre_simulation_device_assignment_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::unsafe_arena_release_pre_simulation_device_assignment() { // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.pre_simulation_device_assignment) ::xla::DeviceAssignmentProto* temp = _impl_.pre_simulation_device_assignment_; _impl_.pre_simulation_device_assignment_ = nullptr; return temp; } inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::_internal_mutable_pre_simulation_device_assignment() { if (_impl_.pre_simulation_device_assignment_ == nullptr) { auto* p = CreateMaybeMessage<::xla::DeviceAssignmentProto>(GetArenaForAllocation()); _impl_.pre_simulation_device_assignment_ = p; } return _impl_.pre_simulation_device_assignment_; } inline ::xla::DeviceAssignmentProto* HloModuleConfigProto::mutable_pre_simulation_device_assignment() { ::xla::DeviceAssignmentProto* _msg = _internal_mutable_pre_simulation_device_assignment(); // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.pre_simulation_device_assignment) return _msg; } inline void HloModuleConfigProto::set_allocated_pre_simulation_device_assignment(::xla::DeviceAssignmentProto* pre_simulation_device_assignment) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.pre_simulation_device_assignment_); } if (pre_simulation_device_assignment) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pre_simulation_device_assignment)); if (message_arena != submessage_arena) { pre_simulation_device_assignment = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, pre_simulation_device_assignment, submessage_arena); } } else { } _impl_.pre_simulation_device_assignment_ = pre_simulation_device_assignment; // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.pre_simulation_device_assignment) } // bool allow_separate_sharding_programs = 30; inline void HloModuleConfigProto::clear_allow_separate_sharding_programs() { _impl_.allow_separate_sharding_programs_ = false; } inline bool HloModuleConfigProto::_internal_allow_separate_sharding_programs() const { return _impl_.allow_separate_sharding_programs_; } inline bool HloModuleConfigProto::allow_separate_sharding_programs() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.allow_separate_sharding_programs) return _internal_allow_separate_sharding_programs(); } inline void HloModuleConfigProto::_internal_set_allow_separate_sharding_programs(bool value) { _impl_.allow_separate_sharding_programs_ = value; } inline void HloModuleConfigProto::set_allow_separate_sharding_programs(bool value) { _internal_set_allow_separate_sharding_programs(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.allow_separate_sharding_programs) } // repeated .xla.ShardableValueUpdatePairProto shardable_value_update_pairs = 16; inline int HloModuleConfigProto::_internal_shardable_value_update_pairs_size() const { return _impl_.shardable_value_update_pairs_.size(); } inline int HloModuleConfigProto::shardable_value_update_pairs_size() const { return _internal_shardable_value_update_pairs_size(); } inline void HloModuleConfigProto::clear_shardable_value_update_pairs() { _impl_.shardable_value_update_pairs_.Clear(); } inline ::xla::ShardableValueUpdatePairProto* HloModuleConfigProto::mutable_shardable_value_update_pairs(int index) { // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.shardable_value_update_pairs) return _impl_.shardable_value_update_pairs_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShardableValueUpdatePairProto >* HloModuleConfigProto::mutable_shardable_value_update_pairs() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.shardable_value_update_pairs) return &_impl_.shardable_value_update_pairs_; } inline const ::xla::ShardableValueUpdatePairProto& HloModuleConfigProto::_internal_shardable_value_update_pairs(int index) const { return _impl_.shardable_value_update_pairs_.Get(index); } inline const ::xla::ShardableValueUpdatePairProto& HloModuleConfigProto::shardable_value_update_pairs(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.shardable_value_update_pairs) return _internal_shardable_value_update_pairs(index); } inline ::xla::ShardableValueUpdatePairProto* HloModuleConfigProto::_internal_add_shardable_value_update_pairs() { return _impl_.shardable_value_update_pairs_.Add(); } inline ::xla::ShardableValueUpdatePairProto* HloModuleConfigProto::add_shardable_value_update_pairs() { ::xla::ShardableValueUpdatePairProto* _add = _internal_add_shardable_value_update_pairs(); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.shardable_value_update_pairs) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShardableValueUpdatePairProto >& HloModuleConfigProto::shardable_value_update_pairs() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.shardable_value_update_pairs) return _impl_.shardable_value_update_pairs_; } // bool alias_passthrough_params = 17; inline void HloModuleConfigProto::clear_alias_passthrough_params() { _impl_.alias_passthrough_params_ = false; } inline bool HloModuleConfigProto::_internal_alias_passthrough_params() const { return _impl_.alias_passthrough_params_; } inline bool HloModuleConfigProto::alias_passthrough_params() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.alias_passthrough_params) return _internal_alias_passthrough_params(); } inline void HloModuleConfigProto::_internal_set_alias_passthrough_params(bool value) { _impl_.alias_passthrough_params_ = value; } inline void HloModuleConfigProto::set_alias_passthrough_params(bool value) { _internal_set_alias_passthrough_params(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.alias_passthrough_params) } // bool content_aware_computation_sorting = 18; inline void HloModuleConfigProto::clear_content_aware_computation_sorting() { _impl_.content_aware_computation_sorting_ = false; } inline bool HloModuleConfigProto::_internal_content_aware_computation_sorting() const { return _impl_.content_aware_computation_sorting_; } inline bool HloModuleConfigProto::content_aware_computation_sorting() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.content_aware_computation_sorting) return _internal_content_aware_computation_sorting(); } inline void HloModuleConfigProto::_internal_set_content_aware_computation_sorting(bool value) { _impl_.content_aware_computation_sorting_ = value; } inline void HloModuleConfigProto::set_content_aware_computation_sorting(bool value) { _internal_set_content_aware_computation_sorting(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.content_aware_computation_sorting) } // .xla.HloModuleConfigProto.FusionConfigCollection fusion_config_collection = 19; inline void HloModuleConfigProto::clear_fusion_config_collection() { _impl_.fusion_config_collection_ = 0; } inline ::xla::HloModuleConfigProto_FusionConfigCollection HloModuleConfigProto::_internal_fusion_config_collection() const { return static_cast< ::xla::HloModuleConfigProto_FusionConfigCollection >(_impl_.fusion_config_collection_); } inline ::xla::HloModuleConfigProto_FusionConfigCollection HloModuleConfigProto::fusion_config_collection() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.fusion_config_collection) return _internal_fusion_config_collection(); } inline void HloModuleConfigProto::_internal_set_fusion_config_collection(::xla::HloModuleConfigProto_FusionConfigCollection value) { _impl_.fusion_config_collection_ = value; } inline void HloModuleConfigProto::set_fusion_config_collection(::xla::HloModuleConfigProto_FusionConfigCollection value) { _internal_set_fusion_config_collection(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.fusion_config_collection) } // repeated .xla.HloModuleConfigProto.BoolList fusion_config = 20; inline int HloModuleConfigProto::_internal_fusion_config_size() const { return _impl_.fusion_config_.size(); } inline int HloModuleConfigProto::fusion_config_size() const { return _internal_fusion_config_size(); } inline void HloModuleConfigProto::clear_fusion_config() { _impl_.fusion_config_.Clear(); } inline ::xla::HloModuleConfigProto_BoolList* HloModuleConfigProto::mutable_fusion_config(int index) { // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.fusion_config) return _impl_.fusion_config_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_BoolList >* HloModuleConfigProto::mutable_fusion_config() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.fusion_config) return &_impl_.fusion_config_; } inline const ::xla::HloModuleConfigProto_BoolList& HloModuleConfigProto::_internal_fusion_config(int index) const { return _impl_.fusion_config_.Get(index); } inline const ::xla::HloModuleConfigProto_BoolList& HloModuleConfigProto::fusion_config(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.fusion_config) return _internal_fusion_config(index); } inline ::xla::HloModuleConfigProto_BoolList* HloModuleConfigProto::_internal_add_fusion_config() { return _impl_.fusion_config_.Add(); } inline ::xla::HloModuleConfigProto_BoolList* HloModuleConfigProto::add_fusion_config() { ::xla::HloModuleConfigProto_BoolList* _add = _internal_add_fusion_config(); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.fusion_config) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_BoolList >& HloModuleConfigProto::fusion_config() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.fusion_config) return _impl_.fusion_config_; } // map dot_config = 21; inline int HloModuleConfigProto::_internal_dot_config_size() const { return _impl_.dot_config_.size(); } inline int HloModuleConfigProto::dot_config_size() const { return _internal_dot_config_size(); } inline void HloModuleConfigProto::clear_dot_config() { _impl_.dot_config_.Clear(); } inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::HloModuleConfigProto_Int64List >& HloModuleConfigProto::_internal_dot_config() const { return _impl_.dot_config_.GetMap(); } inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::HloModuleConfigProto_Int64List >& HloModuleConfigProto::dot_config() const { // @@protoc_insertion_point(field_map:xla.HloModuleConfigProto.dot_config) return _internal_dot_config(); } inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::HloModuleConfigProto_Int64List >* HloModuleConfigProto::_internal_mutable_dot_config() { return _impl_.dot_config_.MutableMap(); } inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::xla::HloModuleConfigProto_Int64List >* HloModuleConfigProto::mutable_dot_config() { // @@protoc_insertion_point(field_mutable_map:xla.HloModuleConfigProto.dot_config) return _internal_mutable_dot_config(); } // repeated .xla.HloModuleConfigProto.Int64ListList layout_config = 22; inline int HloModuleConfigProto::_internal_layout_config_size() const { return _impl_.layout_config_.size(); } inline int HloModuleConfigProto::layout_config_size() const { return _internal_layout_config_size(); } inline void HloModuleConfigProto::clear_layout_config() { _impl_.layout_config_.Clear(); } inline ::xla::HloModuleConfigProto_Int64ListList* HloModuleConfigProto::mutable_layout_config(int index) { // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.layout_config) return _impl_.layout_config_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_Int64ListList >* HloModuleConfigProto::mutable_layout_config() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.layout_config) return &_impl_.layout_config_; } inline const ::xla::HloModuleConfigProto_Int64ListList& HloModuleConfigProto::_internal_layout_config(int index) const { return _impl_.layout_config_.Get(index); } inline const ::xla::HloModuleConfigProto_Int64ListList& HloModuleConfigProto::layout_config(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.layout_config) return _internal_layout_config(index); } inline ::xla::HloModuleConfigProto_Int64ListList* HloModuleConfigProto::_internal_add_layout_config() { return _impl_.layout_config_.Add(); } inline ::xla::HloModuleConfigProto_Int64ListList* HloModuleConfigProto::add_layout_config() { ::xla::HloModuleConfigProto_Int64ListList* _add = _internal_add_layout_config(); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.layout_config) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_Int64ListList >& HloModuleConfigProto::layout_config() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.layout_config) return _impl_.layout_config_; } // repeated uint64 memory_space_assignment_config = 23; inline int HloModuleConfigProto::_internal_memory_space_assignment_config_size() const { return _impl_.memory_space_assignment_config_.size(); } inline int HloModuleConfigProto::memory_space_assignment_config_size() const { return _internal_memory_space_assignment_config_size(); } inline void HloModuleConfigProto::clear_memory_space_assignment_config() { _impl_.memory_space_assignment_config_.Clear(); } inline uint64_t HloModuleConfigProto::_internal_memory_space_assignment_config(int index) const { return _impl_.memory_space_assignment_config_.Get(index); } inline uint64_t HloModuleConfigProto::memory_space_assignment_config(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.memory_space_assignment_config) return _internal_memory_space_assignment_config(index); } inline void HloModuleConfigProto::set_memory_space_assignment_config(int index, uint64_t value) { _impl_.memory_space_assignment_config_.Set(index, value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.memory_space_assignment_config) } inline void HloModuleConfigProto::_internal_add_memory_space_assignment_config(uint64_t value) { _impl_.memory_space_assignment_config_.Add(value); } inline void HloModuleConfigProto::add_memory_space_assignment_config(uint64_t value) { _internal_add_memory_space_assignment_config(value); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.memory_space_assignment_config) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& HloModuleConfigProto::_internal_memory_space_assignment_config() const { return _impl_.memory_space_assignment_config_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >& HloModuleConfigProto::memory_space_assignment_config() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.memory_space_assignment_config) return _internal_memory_space_assignment_config(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* HloModuleConfigProto::_internal_mutable_memory_space_assignment_config() { return &_impl_.memory_space_assignment_config_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >* HloModuleConfigProto::mutable_memory_space_assignment_config() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.memory_space_assignment_config) return _internal_mutable_memory_space_assignment_config(); } // repeated .xla.HloModuleConfigProto.BoolList phase_ordering_config = 24; inline int HloModuleConfigProto::_internal_phase_ordering_config_size() const { return _impl_.phase_ordering_config_.size(); } inline int HloModuleConfigProto::phase_ordering_config_size() const { return _internal_phase_ordering_config_size(); } inline void HloModuleConfigProto::clear_phase_ordering_config() { _impl_.phase_ordering_config_.Clear(); } inline ::xla::HloModuleConfigProto_BoolList* HloModuleConfigProto::mutable_phase_ordering_config(int index) { // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.phase_ordering_config) return _impl_.phase_ordering_config_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_BoolList >* HloModuleConfigProto::mutable_phase_ordering_config() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.phase_ordering_config) return &_impl_.phase_ordering_config_; } inline const ::xla::HloModuleConfigProto_BoolList& HloModuleConfigProto::_internal_phase_ordering_config(int index) const { return _impl_.phase_ordering_config_.Get(index); } inline const ::xla::HloModuleConfigProto_BoolList& HloModuleConfigProto::phase_ordering_config(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.phase_ordering_config) return _internal_phase_ordering_config(index); } inline ::xla::HloModuleConfigProto_BoolList* HloModuleConfigProto::_internal_add_phase_ordering_config() { return _impl_.phase_ordering_config_.Add(); } inline ::xla::HloModuleConfigProto_BoolList* HloModuleConfigProto::add_phase_ordering_config() { ::xla::HloModuleConfigProto_BoolList* _add = _internal_add_phase_ordering_config(); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.phase_ordering_config) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::HloModuleConfigProto_BoolList >& HloModuleConfigProto::phase_ordering_config() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.phase_ordering_config) return _impl_.phase_ordering_config_; } // int32 phase_index = 25; inline void HloModuleConfigProto::clear_phase_index() { _impl_.phase_index_ = 0; } inline int32_t HloModuleConfigProto::_internal_phase_index() const { return _impl_.phase_index_; } inline int32_t HloModuleConfigProto::phase_index() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.phase_index) return _internal_phase_index(); } inline void HloModuleConfigProto::_internal_set_phase_index(int32_t value) { _impl_.phase_index_ = value; } inline void HloModuleConfigProto::set_phase_index(int32_t value) { _internal_set_phase_index(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.phase_index) } // repeated bool allow_spmd_sharding_propagation_to_parameters = 33; inline int HloModuleConfigProto::_internal_allow_spmd_sharding_propagation_to_parameters_size() const { return _impl_.allow_spmd_sharding_propagation_to_parameters_.size(); } inline int HloModuleConfigProto::allow_spmd_sharding_propagation_to_parameters_size() const { return _internal_allow_spmd_sharding_propagation_to_parameters_size(); } inline void HloModuleConfigProto::clear_allow_spmd_sharding_propagation_to_parameters() { _impl_.allow_spmd_sharding_propagation_to_parameters_.Clear(); } inline bool HloModuleConfigProto::_internal_allow_spmd_sharding_propagation_to_parameters(int index) const { return _impl_.allow_spmd_sharding_propagation_to_parameters_.Get(index); } inline bool HloModuleConfigProto::allow_spmd_sharding_propagation_to_parameters(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_parameters) return _internal_allow_spmd_sharding_propagation_to_parameters(index); } inline void HloModuleConfigProto::set_allow_spmd_sharding_propagation_to_parameters(int index, bool value) { _impl_.allow_spmd_sharding_propagation_to_parameters_.Set(index, value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_parameters) } inline void HloModuleConfigProto::_internal_add_allow_spmd_sharding_propagation_to_parameters(bool value) { _impl_.allow_spmd_sharding_propagation_to_parameters_.Add(value); } inline void HloModuleConfigProto::add_allow_spmd_sharding_propagation_to_parameters(bool value) { _internal_add_allow_spmd_sharding_propagation_to_parameters(value); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_parameters) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& HloModuleConfigProto::_internal_allow_spmd_sharding_propagation_to_parameters() const { return _impl_.allow_spmd_sharding_propagation_to_parameters_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& HloModuleConfigProto::allow_spmd_sharding_propagation_to_parameters() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_parameters) return _internal_allow_spmd_sharding_propagation_to_parameters(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* HloModuleConfigProto::_internal_mutable_allow_spmd_sharding_propagation_to_parameters() { return &_impl_.allow_spmd_sharding_propagation_to_parameters_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* HloModuleConfigProto::mutable_allow_spmd_sharding_propagation_to_parameters() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_parameters) return _internal_mutable_allow_spmd_sharding_propagation_to_parameters(); } // repeated bool allow_spmd_sharding_propagation_to_output = 27; inline int HloModuleConfigProto::_internal_allow_spmd_sharding_propagation_to_output_size() const { return _impl_.allow_spmd_sharding_propagation_to_output_.size(); } inline int HloModuleConfigProto::allow_spmd_sharding_propagation_to_output_size() const { return _internal_allow_spmd_sharding_propagation_to_output_size(); } inline void HloModuleConfigProto::clear_allow_spmd_sharding_propagation_to_output() { _impl_.allow_spmd_sharding_propagation_to_output_.Clear(); } inline bool HloModuleConfigProto::_internal_allow_spmd_sharding_propagation_to_output(int index) const { return _impl_.allow_spmd_sharding_propagation_to_output_.Get(index); } inline bool HloModuleConfigProto::allow_spmd_sharding_propagation_to_output(int index) const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_output) return _internal_allow_spmd_sharding_propagation_to_output(index); } inline void HloModuleConfigProto::set_allow_spmd_sharding_propagation_to_output(int index, bool value) { _impl_.allow_spmd_sharding_propagation_to_output_.Set(index, value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_output) } inline void HloModuleConfigProto::_internal_add_allow_spmd_sharding_propagation_to_output(bool value) { _impl_.allow_spmd_sharding_propagation_to_output_.Add(value); } inline void HloModuleConfigProto::add_allow_spmd_sharding_propagation_to_output(bool value) { _internal_add_allow_spmd_sharding_propagation_to_output(value); // @@protoc_insertion_point(field_add:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_output) } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& HloModuleConfigProto::_internal_allow_spmd_sharding_propagation_to_output() const { return _impl_.allow_spmd_sharding_propagation_to_output_; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >& HloModuleConfigProto::allow_spmd_sharding_propagation_to_output() const { // @@protoc_insertion_point(field_list:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_output) return _internal_allow_spmd_sharding_propagation_to_output(); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* HloModuleConfigProto::_internal_mutable_allow_spmd_sharding_propagation_to_output() { return &_impl_.allow_spmd_sharding_propagation_to_output_; } inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >* HloModuleConfigProto::mutable_allow_spmd_sharding_propagation_to_output() { // @@protoc_insertion_point(field_mutable_list:xla.HloModuleConfigProto.allow_spmd_sharding_propagation_to_output) return _internal_mutable_allow_spmd_sharding_propagation_to_output(); } // map analysis_allowance_map = 28; inline int HloModuleConfigProto::_internal_analysis_allowance_map_size() const { return _impl_.analysis_allowance_map_.size(); } inline int HloModuleConfigProto::analysis_allowance_map_size() const { return _internal_analysis_allowance_map_size(); } inline void HloModuleConfigProto::clear_analysis_allowance_map() { _impl_.analysis_allowance_map_.Clear(); } inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >& HloModuleConfigProto::_internal_analysis_allowance_map() const { return _impl_.analysis_allowance_map_.GetMap(); } inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >& HloModuleConfigProto::analysis_allowance_map() const { // @@protoc_insertion_point(field_map:xla.HloModuleConfigProto.analysis_allowance_map) return _internal_analysis_allowance_map(); } inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >* HloModuleConfigProto::_internal_mutable_analysis_allowance_map() { return _impl_.analysis_allowance_map_.MutableMap(); } inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, int64_t >* HloModuleConfigProto::mutable_analysis_allowance_map() { // @@protoc_insertion_point(field_mutable_map:xla.HloModuleConfigProto.analysis_allowance_map) return _internal_mutable_analysis_allowance_map(); } // .xla.PrecisionConfig.Precision matrix_unit_operand_precision = 29; inline void HloModuleConfigProto::clear_matrix_unit_operand_precision() { _impl_.matrix_unit_operand_precision_ = 0; } inline ::xla::PrecisionConfig_Precision HloModuleConfigProto::_internal_matrix_unit_operand_precision() const { return static_cast< ::xla::PrecisionConfig_Precision >(_impl_.matrix_unit_operand_precision_); } inline ::xla::PrecisionConfig_Precision HloModuleConfigProto::matrix_unit_operand_precision() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.matrix_unit_operand_precision) return _internal_matrix_unit_operand_precision(); } inline void HloModuleConfigProto::_internal_set_matrix_unit_operand_precision(::xla::PrecisionConfig_Precision value) { _impl_.matrix_unit_operand_precision_ = value; } inline void HloModuleConfigProto::set_matrix_unit_operand_precision(::xla::PrecisionConfig_Precision value) { _internal_set_matrix_unit_operand_precision(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.matrix_unit_operand_precision) } // bytes fdo_profile = 31; inline void HloModuleConfigProto::clear_fdo_profile() { _impl_.fdo_profile_.ClearToEmpty(); } inline const std::string& HloModuleConfigProto::fdo_profile() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.fdo_profile) return _internal_fdo_profile(); } template inline PROTOBUF_ALWAYS_INLINE void HloModuleConfigProto::set_fdo_profile(ArgT0&& arg0, ArgT... args) { _impl_.fdo_profile_.SetBytes(static_cast(arg0), args..., GetArenaForAllocation()); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.fdo_profile) } inline std::string* HloModuleConfigProto::mutable_fdo_profile() { std::string* _s = _internal_mutable_fdo_profile(); // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.fdo_profile) return _s; } inline const std::string& HloModuleConfigProto::_internal_fdo_profile() const { return _impl_.fdo_profile_.Get(); } inline void HloModuleConfigProto::_internal_set_fdo_profile(const std::string& value) { _impl_.fdo_profile_.Set(value, GetArenaForAllocation()); } inline std::string* HloModuleConfigProto::_internal_mutable_fdo_profile() { return _impl_.fdo_profile_.Mutable(GetArenaForAllocation()); } inline std::string* HloModuleConfigProto::release_fdo_profile() { // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.fdo_profile) return _impl_.fdo_profile_.Release(); } inline void HloModuleConfigProto::set_allocated_fdo_profile(std::string* fdo_profile) { if (fdo_profile != nullptr) { } else { } _impl_.fdo_profile_.SetAllocated(fdo_profile, GetArenaForAllocation()); #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING if (_impl_.fdo_profile_.IsDefault()) { _impl_.fdo_profile_.Set("", GetArenaForAllocation()); } #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.fdo_profile) } // int64 device_memory_size = 32; inline void HloModuleConfigProto::clear_device_memory_size() { _impl_.device_memory_size_ = int64_t{0}; } inline int64_t HloModuleConfigProto::_internal_device_memory_size() const { return _impl_.device_memory_size_; } inline int64_t HloModuleConfigProto::device_memory_size() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.device_memory_size) return _internal_device_memory_size(); } inline void HloModuleConfigProto::_internal_set_device_memory_size(int64_t value) { _impl_.device_memory_size_ = value; } inline void HloModuleConfigProto::set_device_memory_size(int64_t value) { _internal_set_device_memory_size(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.device_memory_size) } // bool use_shardy_partitioner = 34; inline void HloModuleConfigProto::clear_use_shardy_partitioner() { _impl_.use_shardy_partitioner_ = false; } inline bool HloModuleConfigProto::_internal_use_shardy_partitioner() const { return _impl_.use_shardy_partitioner_; } inline bool HloModuleConfigProto::use_shardy_partitioner() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.use_shardy_partitioner) return _internal_use_shardy_partitioner(); } inline void HloModuleConfigProto::_internal_set_use_shardy_partitioner(bool value) { _impl_.use_shardy_partitioner_ = value; } inline void HloModuleConfigProto::set_use_shardy_partitioner(bool value) { _internal_set_use_shardy_partitioner(value); // @@protoc_insertion_point(field_set:xla.HloModuleConfigProto.use_shardy_partitioner) } // .xla.ShardingConfigProto sharding_config = 38; inline bool HloModuleConfigProto::_internal_has_sharding_config() const { return this != internal_default_instance() && _impl_.sharding_config_ != nullptr; } inline bool HloModuleConfigProto::has_sharding_config() const { return _internal_has_sharding_config(); } inline void HloModuleConfigProto::clear_sharding_config() { if (GetArenaForAllocation() == nullptr && _impl_.sharding_config_ != nullptr) { delete _impl_.sharding_config_; } _impl_.sharding_config_ = nullptr; } inline const ::xla::ShardingConfigProto& HloModuleConfigProto::_internal_sharding_config() const { const ::xla::ShardingConfigProto* p = _impl_.sharding_config_; return p != nullptr ? *p : reinterpret_cast( ::xla::_ShardingConfigProto_default_instance_); } inline const ::xla::ShardingConfigProto& HloModuleConfigProto::sharding_config() const { // @@protoc_insertion_point(field_get:xla.HloModuleConfigProto.sharding_config) return _internal_sharding_config(); } inline void HloModuleConfigProto::unsafe_arena_set_allocated_sharding_config( ::xla::ShardingConfigProto* sharding_config) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sharding_config_); } _impl_.sharding_config_ = sharding_config; if (sharding_config) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleConfigProto.sharding_config) } inline ::xla::ShardingConfigProto* HloModuleConfigProto::release_sharding_config() { ::xla::ShardingConfigProto* temp = _impl_.sharding_config_; _impl_.sharding_config_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::xla::ShardingConfigProto* HloModuleConfigProto::unsafe_arena_release_sharding_config() { // @@protoc_insertion_point(field_release:xla.HloModuleConfigProto.sharding_config) ::xla::ShardingConfigProto* temp = _impl_.sharding_config_; _impl_.sharding_config_ = nullptr; return temp; } inline ::xla::ShardingConfigProto* HloModuleConfigProto::_internal_mutable_sharding_config() { if (_impl_.sharding_config_ == nullptr) { auto* p = CreateMaybeMessage<::xla::ShardingConfigProto>(GetArenaForAllocation()); _impl_.sharding_config_ = p; } return _impl_.sharding_config_; } inline ::xla::ShardingConfigProto* HloModuleConfigProto::mutable_sharding_config() { ::xla::ShardingConfigProto* _msg = _internal_mutable_sharding_config(); // @@protoc_insertion_point(field_mutable:xla.HloModuleConfigProto.sharding_config) return _msg; } inline void HloModuleConfigProto::set_allocated_sharding_config(::xla::ShardingConfigProto* sharding_config) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.sharding_config_; } if (sharding_config) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(sharding_config); if (message_arena != submessage_arena) { sharding_config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, sharding_config, submessage_arena); } } else { } _impl_.sharding_config_ = sharding_config; // @@protoc_insertion_point(field_set_allocated:xla.HloModuleConfigProto.sharding_config) } // ------------------------------------------------------------------- // HloModuleProtoWithConfig // .xla.HloModuleProto hlo_module = 1; inline bool HloModuleProtoWithConfig::_internal_has_hlo_module() const { return this != internal_default_instance() && _impl_.hlo_module_ != nullptr; } inline bool HloModuleProtoWithConfig::has_hlo_module() const { return _internal_has_hlo_module(); } inline const ::xla::HloModuleProto& HloModuleProtoWithConfig::_internal_hlo_module() const { const ::xla::HloModuleProto* p = _impl_.hlo_module_; return p != nullptr ? *p : reinterpret_cast( ::xla::_HloModuleProto_default_instance_); } inline const ::xla::HloModuleProto& HloModuleProtoWithConfig::hlo_module() const { // @@protoc_insertion_point(field_get:xla.HloModuleProtoWithConfig.hlo_module) return _internal_hlo_module(); } inline void HloModuleProtoWithConfig::unsafe_arena_set_allocated_hlo_module( ::xla::HloModuleProto* hlo_module) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hlo_module_); } _impl_.hlo_module_ = hlo_module; if (hlo_module) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleProtoWithConfig.hlo_module) } inline ::xla::HloModuleProto* HloModuleProtoWithConfig::release_hlo_module() { ::xla::HloModuleProto* temp = _impl_.hlo_module_; _impl_.hlo_module_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::xla::HloModuleProto* HloModuleProtoWithConfig::unsafe_arena_release_hlo_module() { // @@protoc_insertion_point(field_release:xla.HloModuleProtoWithConfig.hlo_module) ::xla::HloModuleProto* temp = _impl_.hlo_module_; _impl_.hlo_module_ = nullptr; return temp; } inline ::xla::HloModuleProto* HloModuleProtoWithConfig::_internal_mutable_hlo_module() { if (_impl_.hlo_module_ == nullptr) { auto* p = CreateMaybeMessage<::xla::HloModuleProto>(GetArenaForAllocation()); _impl_.hlo_module_ = p; } return _impl_.hlo_module_; } inline ::xla::HloModuleProto* HloModuleProtoWithConfig::mutable_hlo_module() { ::xla::HloModuleProto* _msg = _internal_mutable_hlo_module(); // @@protoc_insertion_point(field_mutable:xla.HloModuleProtoWithConfig.hlo_module) return _msg; } inline void HloModuleProtoWithConfig::set_allocated_hlo_module(::xla::HloModuleProto* hlo_module) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hlo_module_); } if (hlo_module) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hlo_module)); if (message_arena != submessage_arena) { hlo_module = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, hlo_module, submessage_arena); } } else { } _impl_.hlo_module_ = hlo_module; // @@protoc_insertion_point(field_set_allocated:xla.HloModuleProtoWithConfig.hlo_module) } // .xla.HloModuleConfigProto config = 2; inline bool HloModuleProtoWithConfig::_internal_has_config() const { return this != internal_default_instance() && _impl_.config_ != nullptr; } inline bool HloModuleProtoWithConfig::has_config() const { return _internal_has_config(); } inline void HloModuleProtoWithConfig::clear_config() { if (GetArenaForAllocation() == nullptr && _impl_.config_ != nullptr) { delete _impl_.config_; } _impl_.config_ = nullptr; } inline const ::xla::HloModuleConfigProto& HloModuleProtoWithConfig::_internal_config() const { const ::xla::HloModuleConfigProto* p = _impl_.config_; return p != nullptr ? *p : reinterpret_cast( ::xla::_HloModuleConfigProto_default_instance_); } inline const ::xla::HloModuleConfigProto& HloModuleProtoWithConfig::config() const { // @@protoc_insertion_point(field_get:xla.HloModuleProtoWithConfig.config) return _internal_config(); } inline void HloModuleProtoWithConfig::unsafe_arena_set_allocated_config( ::xla::HloModuleConfigProto* config) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.config_); } _impl_.config_ = config; if (config) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.HloModuleProtoWithConfig.config) } inline ::xla::HloModuleConfigProto* HloModuleProtoWithConfig::release_config() { ::xla::HloModuleConfigProto* temp = _impl_.config_; _impl_.config_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::xla::HloModuleConfigProto* HloModuleProtoWithConfig::unsafe_arena_release_config() { // @@protoc_insertion_point(field_release:xla.HloModuleProtoWithConfig.config) ::xla::HloModuleConfigProto* temp = _impl_.config_; _impl_.config_ = nullptr; return temp; } inline ::xla::HloModuleConfigProto* HloModuleProtoWithConfig::_internal_mutable_config() { if (_impl_.config_ == nullptr) { auto* p = CreateMaybeMessage<::xla::HloModuleConfigProto>(GetArenaForAllocation()); _impl_.config_ = p; } return _impl_.config_; } inline ::xla::HloModuleConfigProto* HloModuleProtoWithConfig::mutable_config() { ::xla::HloModuleConfigProto* _msg = _internal_mutable_config(); // @@protoc_insertion_point(field_mutable:xla.HloModuleProtoWithConfig.config) return _msg; } inline void HloModuleProtoWithConfig::set_allocated_config(::xla::HloModuleConfigProto* config) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete _impl_.config_; } if (config) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(config); if (message_arena != submessage_arena) { config = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, config, submessage_arena); } } else { } _impl_.config_ = config; // @@protoc_insertion_point(field_set_allocated:xla.HloModuleProtoWithConfig.config) } // ------------------------------------------------------------------- // ScheduleProto_Instruction // int64 id = 1; inline void ScheduleProto_Instruction::clear_id() { _impl_.id_ = int64_t{0}; } inline int64_t ScheduleProto_Instruction::_internal_id() const { return _impl_.id_; } inline int64_t ScheduleProto_Instruction::id() const { // @@protoc_insertion_point(field_get:xla.ScheduleProto.Instruction.id) return _internal_id(); } inline void ScheduleProto_Instruction::_internal_set_id(int64_t value) { _impl_.id_ = value; } inline void ScheduleProto_Instruction::set_id(int64_t value) { _internal_set_id(value); // @@protoc_insertion_point(field_set:xla.ScheduleProto.Instruction.id) } // double start_timestamp_cycles = 2; inline void ScheduleProto_Instruction::clear_start_timestamp_cycles() { _impl_.start_timestamp_cycles_ = 0; } inline double ScheduleProto_Instruction::_internal_start_timestamp_cycles() const { return _impl_.start_timestamp_cycles_; } inline double ScheduleProto_Instruction::start_timestamp_cycles() const { // @@protoc_insertion_point(field_get:xla.ScheduleProto.Instruction.start_timestamp_cycles) return _internal_start_timestamp_cycles(); } inline void ScheduleProto_Instruction::_internal_set_start_timestamp_cycles(double value) { _impl_.start_timestamp_cycles_ = value; } inline void ScheduleProto_Instruction::set_start_timestamp_cycles(double value) { _internal_set_start_timestamp_cycles(value); // @@protoc_insertion_point(field_set:xla.ScheduleProto.Instruction.start_timestamp_cycles) } // double end_timestamp_cycles = 3; inline void ScheduleProto_Instruction::clear_end_timestamp_cycles() { _impl_.end_timestamp_cycles_ = 0; } inline double ScheduleProto_Instruction::_internal_end_timestamp_cycles() const { return _impl_.end_timestamp_cycles_; } inline double ScheduleProto_Instruction::end_timestamp_cycles() const { // @@protoc_insertion_point(field_get:xla.ScheduleProto.Instruction.end_timestamp_cycles) return _internal_end_timestamp_cycles(); } inline void ScheduleProto_Instruction::_internal_set_end_timestamp_cycles(double value) { _impl_.end_timestamp_cycles_ = value; } inline void ScheduleProto_Instruction::set_end_timestamp_cycles(double value) { _internal_set_end_timestamp_cycles(value); // @@protoc_insertion_point(field_set:xla.ScheduleProto.Instruction.end_timestamp_cycles) } // ------------------------------------------------------------------- // ScheduleProto // repeated .xla.ScheduleProto.Instruction instructions = 1; inline int ScheduleProto::_internal_instructions_size() const { return _impl_.instructions_.size(); } inline int ScheduleProto::instructions_size() const { return _internal_instructions_size(); } inline void ScheduleProto::clear_instructions() { _impl_.instructions_.Clear(); } inline ::xla::ScheduleProto_Instruction* ScheduleProto::mutable_instructions(int index) { // @@protoc_insertion_point(field_mutable:xla.ScheduleProto.instructions) return _impl_.instructions_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ScheduleProto_Instruction >* ScheduleProto::mutable_instructions() { // @@protoc_insertion_point(field_mutable_list:xla.ScheduleProto.instructions) return &_impl_.instructions_; } inline const ::xla::ScheduleProto_Instruction& ScheduleProto::_internal_instructions(int index) const { return _impl_.instructions_.Get(index); } inline const ::xla::ScheduleProto_Instruction& ScheduleProto::instructions(int index) const { // @@protoc_insertion_point(field_get:xla.ScheduleProto.instructions) return _internal_instructions(index); } inline ::xla::ScheduleProto_Instruction* ScheduleProto::_internal_add_instructions() { return _impl_.instructions_.Add(); } inline ::xla::ScheduleProto_Instruction* ScheduleProto::add_instructions() { ::xla::ScheduleProto_Instruction* _add = _internal_add_instructions(); // @@protoc_insertion_point(field_add:xla.ScheduleProto.instructions) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ScheduleProto_Instruction >& ScheduleProto::instructions() const { // @@protoc_insertion_point(field_list:xla.ScheduleProto.instructions) return _impl_.instructions_; } // int64 computation_id = 2; inline void ScheduleProto::clear_computation_id() { _impl_.computation_id_ = int64_t{0}; } inline int64_t ScheduleProto::_internal_computation_id() const { return _impl_.computation_id_; } inline int64_t ScheduleProto::computation_id() const { // @@protoc_insertion_point(field_get:xla.ScheduleProto.computation_id) return _internal_computation_id(); } inline void ScheduleProto::_internal_set_computation_id(int64_t value) { _impl_.computation_id_ = value; } inline void ScheduleProto::set_computation_id(int64_t value) { _internal_set_computation_id(value); // @@protoc_insertion_point(field_set:xla.ScheduleProto.computation_id) } // .xla.HloModuleProto hlo_module = 3; inline bool ScheduleProto::_internal_has_hlo_module() const { return this != internal_default_instance() && _impl_.hlo_module_ != nullptr; } inline bool ScheduleProto::has_hlo_module() const { return _internal_has_hlo_module(); } inline const ::xla::HloModuleProto& ScheduleProto::_internal_hlo_module() const { const ::xla::HloModuleProto* p = _impl_.hlo_module_; return p != nullptr ? *p : reinterpret_cast( ::xla::_HloModuleProto_default_instance_); } inline const ::xla::HloModuleProto& ScheduleProto::hlo_module() const { // @@protoc_insertion_point(field_get:xla.ScheduleProto.hlo_module) return _internal_hlo_module(); } inline void ScheduleProto::unsafe_arena_set_allocated_hlo_module( ::xla::HloModuleProto* hlo_module) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hlo_module_); } _impl_.hlo_module_ = hlo_module; if (hlo_module) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.ScheduleProto.hlo_module) } inline ::xla::HloModuleProto* ScheduleProto::release_hlo_module() { ::xla::HloModuleProto* temp = _impl_.hlo_module_; _impl_.hlo_module_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::xla::HloModuleProto* ScheduleProto::unsafe_arena_release_hlo_module() { // @@protoc_insertion_point(field_release:xla.ScheduleProto.hlo_module) ::xla::HloModuleProto* temp = _impl_.hlo_module_; _impl_.hlo_module_ = nullptr; return temp; } inline ::xla::HloModuleProto* ScheduleProto::_internal_mutable_hlo_module() { if (_impl_.hlo_module_ == nullptr) { auto* p = CreateMaybeMessage<::xla::HloModuleProto>(GetArenaForAllocation()); _impl_.hlo_module_ = p; } return _impl_.hlo_module_; } inline ::xla::HloModuleProto* ScheduleProto::mutable_hlo_module() { ::xla::HloModuleProto* _msg = _internal_mutable_hlo_module(); // @@protoc_insertion_point(field_mutable:xla.ScheduleProto.hlo_module) return _msg; } inline void ScheduleProto::set_allocated_hlo_module(::xla::HloModuleProto* hlo_module) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.hlo_module_); } if (hlo_module) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(hlo_module)); if (message_arena != submessage_arena) { hlo_module = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, hlo_module, submessage_arena); } } else { } _impl_.hlo_module_ = hlo_module; // @@protoc_insertion_point(field_set_allocated:xla.ScheduleProto.hlo_module) } // int64 cycles_per_microsecond = 4; inline void ScheduleProto::clear_cycles_per_microsecond() { _impl_.cycles_per_microsecond_ = int64_t{0}; } inline int64_t ScheduleProto::_internal_cycles_per_microsecond() const { return _impl_.cycles_per_microsecond_; } inline int64_t ScheduleProto::cycles_per_microsecond() const { // @@protoc_insertion_point(field_get:xla.ScheduleProto.cycles_per_microsecond) return _internal_cycles_per_microsecond(); } inline void ScheduleProto::_internal_set_cycles_per_microsecond(int64_t value) { _impl_.cycles_per_microsecond_ = value; } inline void ScheduleProto::set_cycles_per_microsecond(int64_t value) { _internal_set_cycles_per_microsecond(value); // @@protoc_insertion_point(field_set:xla.ScheduleProto.cycles_per_microsecond) } // ------------------------------------------------------------------- // NodeShardingConfigProto // .xla.OpSharding sharding = 1; inline bool NodeShardingConfigProto::_internal_has_sharding() const { return this != internal_default_instance() && _impl_.sharding_ != nullptr; } inline bool NodeShardingConfigProto::has_sharding() const { return _internal_has_sharding(); } inline const ::xla::OpSharding& NodeShardingConfigProto::_internal_sharding() const { const ::xla::OpSharding* p = _impl_.sharding_; return p != nullptr ? *p : reinterpret_cast( ::xla::_OpSharding_default_instance_); } inline const ::xla::OpSharding& NodeShardingConfigProto::sharding() const { // @@protoc_insertion_point(field_get:xla.NodeShardingConfigProto.sharding) return _internal_sharding(); } inline void NodeShardingConfigProto::unsafe_arena_set_allocated_sharding( ::xla::OpSharding* sharding) { if (GetArenaForAllocation() == nullptr) { delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sharding_); } _impl_.sharding_ = sharding; if (sharding) { } else { } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.NodeShardingConfigProto.sharding) } inline ::xla::OpSharding* NodeShardingConfigProto::release_sharding() { ::xla::OpSharding* temp = _impl_.sharding_; _impl_.sharding_ = nullptr; #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); if (GetArenaForAllocation() == nullptr) { delete old; } #else // PROTOBUF_FORCE_COPY_IN_RELEASE if (GetArenaForAllocation() != nullptr) { temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); } #endif // !PROTOBUF_FORCE_COPY_IN_RELEASE return temp; } inline ::xla::OpSharding* NodeShardingConfigProto::unsafe_arena_release_sharding() { // @@protoc_insertion_point(field_release:xla.NodeShardingConfigProto.sharding) ::xla::OpSharding* temp = _impl_.sharding_; _impl_.sharding_ = nullptr; return temp; } inline ::xla::OpSharding* NodeShardingConfigProto::_internal_mutable_sharding() { if (_impl_.sharding_ == nullptr) { auto* p = CreateMaybeMessage<::xla::OpSharding>(GetArenaForAllocation()); _impl_.sharding_ = p; } return _impl_.sharding_; } inline ::xla::OpSharding* NodeShardingConfigProto::mutable_sharding() { ::xla::OpSharding* _msg = _internal_mutable_sharding(); // @@protoc_insertion_point(field_mutable:xla.NodeShardingConfigProto.sharding) return _msg; } inline void NodeShardingConfigProto::set_allocated_sharding(::xla::OpSharding* sharding) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); if (message_arena == nullptr) { delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.sharding_); } if (sharding) { ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(sharding)); if (message_arena != submessage_arena) { sharding = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( message_arena, sharding, submessage_arena); } } else { } _impl_.sharding_ = sharding; // @@protoc_insertion_point(field_set_allocated:xla.NodeShardingConfigProto.sharding) } // repeated .xla.NodeShardingConfigProto nodes = 2; inline int NodeShardingConfigProto::_internal_nodes_size() const { return _impl_.nodes_.size(); } inline int NodeShardingConfigProto::nodes_size() const { return _internal_nodes_size(); } inline void NodeShardingConfigProto::clear_nodes() { _impl_.nodes_.Clear(); } inline ::xla::NodeShardingConfigProto* NodeShardingConfigProto::mutable_nodes(int index) { // @@protoc_insertion_point(field_mutable:xla.NodeShardingConfigProto.nodes) return _impl_.nodes_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::NodeShardingConfigProto >* NodeShardingConfigProto::mutable_nodes() { // @@protoc_insertion_point(field_mutable_list:xla.NodeShardingConfigProto.nodes) return &_impl_.nodes_; } inline const ::xla::NodeShardingConfigProto& NodeShardingConfigProto::_internal_nodes(int index) const { return _impl_.nodes_.Get(index); } inline const ::xla::NodeShardingConfigProto& NodeShardingConfigProto::nodes(int index) const { // @@protoc_insertion_point(field_get:xla.NodeShardingConfigProto.nodes) return _internal_nodes(index); } inline ::xla::NodeShardingConfigProto* NodeShardingConfigProto::_internal_add_nodes() { return _impl_.nodes_.Add(); } inline ::xla::NodeShardingConfigProto* NodeShardingConfigProto::add_nodes() { ::xla::NodeShardingConfigProto* _add = _internal_add_nodes(); // @@protoc_insertion_point(field_add:xla.NodeShardingConfigProto.nodes) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::NodeShardingConfigProto >& NodeShardingConfigProto::nodes() const { // @@protoc_insertion_point(field_list:xla.NodeShardingConfigProto.nodes) return _impl_.nodes_; } // ------------------------------------------------------------------- // ShardingConfigProto // repeated .xla.NodeShardingConfigProto nodes = 1; inline int ShardingConfigProto::_internal_nodes_size() const { return _impl_.nodes_.size(); } inline int ShardingConfigProto::nodes_size() const { return _internal_nodes_size(); } inline void ShardingConfigProto::clear_nodes() { _impl_.nodes_.Clear(); } inline ::xla::NodeShardingConfigProto* ShardingConfigProto::mutable_nodes(int index) { // @@protoc_insertion_point(field_mutable:xla.ShardingConfigProto.nodes) return _impl_.nodes_.Mutable(index); } inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::NodeShardingConfigProto >* ShardingConfigProto::mutable_nodes() { // @@protoc_insertion_point(field_mutable_list:xla.ShardingConfigProto.nodes) return &_impl_.nodes_; } inline const ::xla::NodeShardingConfigProto& ShardingConfigProto::_internal_nodes(int index) const { return _impl_.nodes_.Get(index); } inline const ::xla::NodeShardingConfigProto& ShardingConfigProto::nodes(int index) const { // @@protoc_insertion_point(field_get:xla.ShardingConfigProto.nodes) return _internal_nodes(index); } inline ::xla::NodeShardingConfigProto* ShardingConfigProto::_internal_add_nodes() { return _impl_.nodes_.Add(); } inline ::xla::NodeShardingConfigProto* ShardingConfigProto::add_nodes() { ::xla::NodeShardingConfigProto* _add = _internal_add_nodes(); // @@protoc_insertion_point(field_add:xla.ShardingConfigProto.nodes) return _add; } inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::NodeShardingConfigProto >& ShardingConfigProto::nodes() const { // @@protoc_insertion_point(field_list:xla.ShardingConfigProto.nodes) return _impl_.nodes_; } #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // ------------------------------------------------------------------- // @@protoc_insertion_point(namespace_scope) } // namespace xla PROTOBUF_NAMESPACE_OPEN template <> struct is_proto_enum< ::xla::DebugOptions_CollectiveOpType> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::xla::DebugOptions_CollectiveOpType>() { return ::xla::DebugOptions_CollectiveOpType_descriptor(); } template <> struct is_proto_enum< ::xla::DebugOptions_CommandBufferCmdType> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::xla::DebugOptions_CommandBufferCmdType>() { return ::xla::DebugOptions_CommandBufferCmdType_descriptor(); } template <> struct is_proto_enum< ::xla::DebugOptions_LibNvJitLinkMode> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::xla::DebugOptions_LibNvJitLinkMode>() { return ::xla::DebugOptions_LibNvJitLinkMode_descriptor(); } template <> struct is_proto_enum< ::xla::DebugOptions_PGLEStrictnessLevel> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::xla::DebugOptions_PGLEStrictnessLevel>() { return ::xla::DebugOptions_PGLEStrictnessLevel_descriptor(); } template <> struct is_proto_enum< ::xla::DebugOptions_ShapeChecks> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::xla::DebugOptions_ShapeChecks>() { return ::xla::DebugOptions_ShapeChecks_descriptor(); } template <> struct is_proto_enum< ::xla::DebugOptions_WhileLoopUnrolling> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::xla::DebugOptions_WhileLoopUnrolling>() { return ::xla::DebugOptions_WhileLoopUnrolling_descriptor(); } template <> struct is_proto_enum< ::xla::DebugOptions_XnnGraphFusionMode> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::xla::DebugOptions_XnnGraphFusionMode>() { return ::xla::DebugOptions_XnnGraphFusionMode_descriptor(); } template <> struct is_proto_enum< ::xla::DebugOptions_PipelineParallelismOptLevel> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::xla::DebugOptions_PipelineParallelismOptLevel>() { return ::xla::DebugOptions_PipelineParallelismOptLevel_descriptor(); } template <> struct is_proto_enum< ::xla::DebugOptions_StepMarkerLocation> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::xla::DebugOptions_StepMarkerLocation>() { return ::xla::DebugOptions_StepMarkerLocation_descriptor(); } template <> struct is_proto_enum< ::xla::DebugOptions_PartitioningAlgorithm> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::xla::DebugOptions_PartitioningAlgorithm>() { return ::xla::DebugOptions_PartitioningAlgorithm_descriptor(); } template <> struct is_proto_enum< ::xla::DebugOptions_AutotuneCacheMode> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::xla::DebugOptions_AutotuneCacheMode>() { return ::xla::DebugOptions_AutotuneCacheMode_descriptor(); } template <> struct is_proto_enum< ::xla::HloModuleConfigProto_FusionConfigCollection> : ::std::true_type {}; template <> inline const EnumDescriptor* GetEnumDescriptor< ::xla::HloModuleConfigProto_FusionConfigCollection>() { return ::xla::HloModuleConfigProto_FusionConfigCollection_descriptor(); } PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) #include #endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_xla_2fxla_2eproto