Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/buffer_sharing.h

@@ -0,0 +1,36 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_BUFFER_SHARING_H_
+#define XLA_SERVICE_GPU_BUFFER_SHARING_H_
+
+#include <optional>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/shape_util.h"
+
+namespace xla {
+namespace gpu {
+std::optional<bool> FusionCanShareBufferHint(const HloInstruction* user,
+                                             const HloInstruction* operand,
+                                             const ShapeIndex& user_index);
+
+std::optional<bool> CanShareBufferHint(const HloInstruction* user,
+                                       const HloInstruction* operand,
+                                       const ShapeIndex& user_index);
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_BUFFER_SHARING_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/compile_module_to_llvm_ir.h

@@ -0,0 +1,81 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_COMPILE_MODULE_TO_LLVM_IR_H_
+#define XLA_SERVICE_GPU_COMPILE_MODULE_TO_LLVM_IR_H_
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/buffer_value.h"
+#include "xla/service/gpu/executable.pb.h"
+#include "xla/service/gpu/gpu_executable.h"
+#include "xla/service/hlo.pb.h"
+#include "xla/service/hlo_dataflow_analysis.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/util.h"
+
+namespace xla {
+namespace gpu {
+
+struct CompileModuleResults {
+  std::unique_ptr<llvm::Module> llvm_module;
+  std::unique_ptr<BufferAssignment> buffer_assignment;
+  std::vector<BufferAllocation> allocations;
+  std::variant<GpuExecutable::OwnedThunkSequence,
+               GpuExecutable::OwnedGpuRuntimeProgram,
+               GpuExecutable::OwnedGpu2RuntimeProgram>
+      executable;
+  EntryFunctionAttributes entry_func_attrs;
+  std::vector<GpuExecutable::ConstantInfo> constants;
+  absl::flat_hash_map<ShapeIndex, GpuExecutable::OutputInfo> output_info;
+  Shape output_shape;
+  std::string module_name;
+};
+
+// Removes all globals from the given module that are both uninitialized and
+// have no uses within that module.
+void RemoveUnusedAndUninitializedGlobals(
+    llvm::Module* llvm_module,
+    const std::vector<GpuExecutable::ConstantInfo>& constants);
+
+// Compile `hlo_module` using XLA GPU and return the LLVM module thus generated.
+// The GpuExecutable (and the Thunks that are part of it) are not returned.
+StatusOr<std::unique_ptr<llvm::Module>> CompileModuleToLlvmIr(
+    HloModule* hlo_module, llvm::LLVMContext* llvm_context,
+    const std::string& target_triple, const std::string& data_layout,
+    const std::string& platform_name, se::Platform::Id platform_id,
+    const se::DeviceDescription& gpu_device_info,
+    const BufferValue::SizeFunction& buffer_size_bytes_function);
+
+Status CompileModuleToLlvmIrImpl(
+    HloModule* hlo_module, llvm::LLVMContext* llvm_context,
+    const std::string& target_triple, const std::string& data_layout,
+    const std::string& platform_name, se::Platform::Id platform_id,
+    const se::DeviceDescription& gpu_device_info,
+    const HloDataflowAnalysis::CanShareBuffer& can_share_buffer_function,
+    const BufferValue::SizeFunction& buffer_size_bytes_function,
+    CompileModuleResults* results, se::StreamExecutor* stream_exec = nullptr);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_COMPILE_MODULE_TO_LLVM_IR_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/conditional_thunk.h

@@ -0,0 +1,72 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CONDITIONAL_THUNK_H_
+#define XLA_SERVICE_GPU_CONDITIONAL_THUNK_H_
+
+#include <memory>
+#include <vector>
+
+#include "absl/types/span.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/sequential_thunk.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+struct ConditionalThunkConfig {
+  bool branch_index_is_bool;
+  int64_t branch_count;
+  std::vector<std::unique_ptr<SequentialThunk>> branch_thunks;
+};
+
+// ConditionalThunk implements the conditional instruction on GPU by reading the
+// predicate of the conditional and executing the true or the false computation
+// depending on the value of the predicate.
+//
+// ConditionalThunk assumes that the buffers of the conditional result and the
+// result of the true and false computations share the same allocation. Also,
+// the buffers of the true operand of the conditional and that of the parameter
+// instruction of the true computation share the same allocation. Similarly, the
+// buffers of the false operand and that of the parameter instruction of the
+// false computation share the same allocation.
+class ConditionalThunk : public Thunk {
+ public:
+  ConditionalThunk(ThunkInfo thunk_info, ConditionalThunkConfig config,
+                   const BufferAllocation::Slice& branch_index_buffer_index);
+
+  ConditionalThunk(const ConditionalThunk&) = delete;
+  ConditionalThunk& operator=(const ConditionalThunk&) = delete;
+
+  Status Initialize(const GpuExecutable& executable,
+                    se::StreamExecutor* executor) override;
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+  absl::Span<const std::unique_ptr<SequentialThunk>> branch_thunks() {
+    return config_.branch_thunks;
+  }
+
+ private:
+  const ConditionalThunkConfig config_;
+  BufferAllocation::Slice branch_index_buffer_index_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CONDITIONAL_THUNK_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/conv_algorithm_picker.h

@@ -0,0 +1,164 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CONV_ALGORITHM_PICKER_H_
+#define XLA_SERVICE_GPU_CONV_ALGORITHM_PICKER_H_
+
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+#include "xla/autotune_results.pb.h"
+#include "xla/autotuning.pb.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/gpu/autotuner_util.h"
+#include "xla/service/gpu/gpu_conv_runner.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/service/service_executable_run_options.h"
+#include "xla/stream_executor/device_memory_allocator.h"
+#include "xla/stream_executor/stream_executor.h"
+
+#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA)
+#include "xla/stream_executor/gpu/redzone_allocator.h"
+#endif
+
+namespace xla {
+namespace gpu {
+
+// Choose the fastest algorithm for each conv.
+// Modifies CustomCalls to cudnn convolutions, choosing the best algorithm for
+// each and adding explicit scratch space to the CustomCalls.
+//
+// We pick the algorithm before fusion so that we can generate better HLO. After
+// GpuConvRewriter, our convolutions are CustomCalls which return a
+// tuple (conv_result, scratch_memory), and the each conv uses 0 bytes of
+// scratch:
+//
+//   customcall = (f32[...], f32[0])
+//   return gte(customcall, 0)
+//
+// The algorithm picker then chooses the best algorithm, and potentially
+// increases the scratch space.  It replaces customcall with new_tuple,
+// giving us the following:
+//
+//   new_customcall = (f32[...], f32[N])
+//   new_tuple = tuple(gte(new_customcall, 0), constant f32[0])
+//   return gte(new_tuple, 0)
+//
+// The new tuple and gte instructions can be simplified away, because
+// nobody is expected to use the scratch value.
+//
+// However, if we were to run GpuConvAlgorithmPicker after fusion
+// the gte(customcall, 0) would probably already be into a fusion node.  We
+// can't simplify across HloComputation boundaries, so in this case we
+// wouldn't be able to simplify away the new_tuple bits.
+//
+// It supports two modes: device and deviceless.
+// In device mode, we run autotuning on the device and store autotune results.
+//
+// In deviceless mode, we pass in some information related to the device and
+// use stored autotune results to rewrite convolutions. If the required autotune
+// result is not stored, then the performance of convolution will be suboptimal.
+class GpuConvAlgorithmPicker : public HloModulePass {
+ public:
+  explicit GpuConvAlgorithmPicker(AutotuneConfig config) : config_(config) {}
+
+  absl::string_view name() const override {
+    return "gpu-conv-algorithm-picker";
+  }
+
+  static bool IsEnabled(const HloModule* module) {
+    return module->config().debug_options().xla_gpu_autotune_level() != 0;
+  }
+
+  static bool IsCandidate(const HloInstruction* instr) {
+    return IsCustomCallToDnnConvolution(*instr);
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+  // Run autotuning on allocated buffers and pick the best algorithm.
+  StatusOr<AutotuneResult> PickBestAlgorithmWithAllocatedBuffer(
+      const AutotuneConfig& config, GpuConvConfig conv_config,
+      const ServiceExecutableRunOptions* run_options,
+      const DebugOptions& debug_options,
+      std::vector<se::DeviceMemoryBase> buffers,
+      std::vector<se::DeviceMemoryBase> result_buffers);
+
+ private:
+  StatusOr<bool> RunOnComputation(HloComputation* computation);
+  StatusOr<bool> RunOnInstruction(HloInstruction* instr);
+
+  StatusOr<AutotuneResult> PickBestAlgorithm(
+      const HloCustomCallInstruction* instr);
+  StatusOr<AutotuneResult> PickBestAlgorithmNoCache(
+      const HloCustomCallInstruction* instr);
+
+#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA)
+  // Simple bundle of an algorithm and its output, for comparing results across
+  // autotuned algorithms.
+  struct ReferenceResult {
+    stream_executor::dnn::AlgorithmDesc algorithm;
+    std::vector<stream_executor::DeviceMemoryBase> buffers;
+  };
+
+  // Execution environment for autotuning. Runtime autotuning requires runtime
+  // information such as input/output buffers in order to run. It can be
+  // constructed from the autotuned instruction by FromInstruction.
+  struct AutotuneRuntimeArguments {
+    const Shape result_shape;
+    const HloModuleConfig hlo_module_config;
+    std::vector<se::DeviceMemoryBase> operand_buffers;
+    std::vector<se::DeviceMemoryBase> result_buffers;
+    se::RedzoneAllocator* input_output_allocator;
+    const GpuConvConfig gpu_conv_config;
+    std::optional<std::string> canonical_hlo;
+
+    static StatusOr<AutotuneRuntimeArguments> FromInstruction(
+        const HloCustomCallInstruction* instr,
+        se::DeviceMemoryAllocator* allocator, se::StreamExecutor* stream,
+        se::RedzoneAllocator* input_output_allocator);
+  };
+
+  StatusOr<AutotuneResult> AutotuneOneConvRunner(
+      se::Stream* stream, GenericConvRunner* runner,
+      std::optional<ReferenceResult>* reference_result,
+      absl::Span<const stream_executor::dnn::AlgorithmDesc> disabled_algos,
+      std::optional<AutotuneCacheKey> instruction_info,
+      const AutotuneRuntimeArguments& runtime_arguments);
+
+  // Pick the best algorithm for CUDA platform.
+  StatusOr<AutotuneResult> PickBestAlgorithmNoCacheCuda(
+      const HloCustomCallInstruction* instr, se::Stream* stream,
+      std::optional<AutotuneCacheKey> instruction_info,
+      const AutotuneRuntimeArguments& runtime_arguments);
+#endif
+
+  StatusOr<AutotuneResult> PickBestAlgorithmNoCacheRocm(
+      const HloCustomCallInstruction* instr,
+      se::DeviceMemoryAllocator* allocator, se::Stream* stream);
+
+ private:
+  AutotuneConfig config_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+#endif  // XLA_SERVICE_GPU_CONV_ALGORITHM_PICKER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/conv_layout_normalization.h

@@ -0,0 +1,37 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CONV_LAYOUT_NORMALIZATION_H_
+#define XLA_SERVICE_GPU_CONV_LAYOUT_NORMALIZATION_H_
+
+#include <functional>
+#include <optional>
+#include <utility>
+
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+StatusOr<std::optional<HloInstruction*>> NormalizeLayoutForGpuCustomCalls(
+    HloCustomCallInstruction*);
+
+}  // end namespace gpu
+}  // end namespace xla
+
+#endif  // XLA_SERVICE_GPU_CONV_LAYOUT_NORMALIZATION_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/convolution_thunk.h

@@ -0,0 +1,95 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CONVOLUTION_THUNK_H_
+#define XLA_SERVICE_GPU_CONVOLUTION_THUNK_H_
+
+#include <memory>
+#include <optional>
+
+#include "absl/container/flat_hash_map.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/gpu_conv_runner.h"
+#include "xla/service/gpu/gpu_executable.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace gpu {
+
+// This class stores everything that StreamExecutor needs to launch a DNN
+// convolution. It is generated by IrEmitter.
+//
+// This is thread-compatible.
+class ConvolutionThunk : public Thunk {
+ public:
+  // Constructs a thunk for launching a DNN convolution.
+  //
+  // operand_slices should be in the same order as cudnn_call->operands().
+  ConvolutionThunk(ThunkInfo thunk_info, GpuConvConfig config,
+                   std::vector<BufferAllocation::Slice> operand_slices,
+                   std::vector<BufferAllocation::Slice> result_slices,
+                   BufferAllocation::Slice scratch_slice);
+
+  ConvolutionThunk(const ConvolutionThunk&) = delete;
+  ConvolutionThunk& operator=(const ConvolutionThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  std::vector<BufferAllocation::Slice> operand_buffers_;
+  std::vector<BufferAllocation::Slice> result_buffers_;
+  BufferAllocation::Slice scratch_buffer_;
+  GenericConvRunner& GetOrCreateRunner(const stream_executor::Stream* stream);
+
+  // Convolution config
+  const GpuConvConfig config_;
+  absl::Mutex mu_;
+  absl::flat_hash_map<const stream_executor::Stream*,
+                      std::unique_ptr<GenericConvRunner>>
+      runner_cache_ ABSL_GUARDED_BY(mu_);
+};
+
+// Launches the kernel that reorders input data for int8x32 convolutions.
+class ConvolutionReorderThunk : public Thunk {
+ public:
+  ConvolutionReorderThunk(ThunkInfo thunk_info, absl::Span<int64_t> filter_nchw,
+                          std::vector<BufferAllocation::Slice> operand_slices,
+                          std::vector<BufferAllocation::Slice> result_slices);
+
+  ConvolutionReorderThunk(const ConvolutionReorderThunk&) = delete;
+  ConvolutionReorderThunk& operator=(const ConvolutionReorderThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  static se::dnn::FilterDescriptor CreateFilterDescriptor(
+      absl::Span<int64_t> filter_nchw);
+
+  const se::dnn::FilterDescriptor filter_descriptor_;
+  std::vector<BufferAllocation::Slice> operand_buffers_;
+  std::vector<BufferAllocation::Slice> result_buffers_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CONVOLUTION_THUNK_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/copy_fusion.h

@@ -0,0 +1,46 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_COPY_FUSION_H_
+#define XLA_SERVICE_GPU_COPY_FUSION_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// CopyFusion checks if a fusion is followed by multiple copies and if so, adds
+// those copies to the fusion, replacing the copies with get_tuple_elements.
+class CopyFusion : public HloModulePass {
+ public:
+  CopyFusion() = default;
+
+  absl::string_view name() const override { return "copy_fusion"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  StatusOr<bool> DoCopyFusion(HloComputation* computation);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_COPY_FUSION_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/copy_thunk.h

@@ -0,0 +1,70 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_COPY_THUNK_H_
+#define XLA_SERVICE_GPU_COPY_THUNK_H_
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// A thunk that copies data from a device buffer to another device buffer.
+class DeviceToDeviceCopyThunk : public Thunk {
+ public:
+  // Constructs a CopyThunk that copies host data from `source_buffer` to the
+  // device buffer `destination_buffer`. `mem_size` is the size of the data in
+  // bytes.
+  DeviceToDeviceCopyThunk(ThunkInfo thunk_info,
+                          const BufferAllocation::Slice& source_buffer,
+                          const BufferAllocation::Slice& destination_buffer,
+                          uint64_t mem_size, mlir::Value source_value,
+                          mlir::Value destination_value);
+
+  DeviceToDeviceCopyThunk(const DeviceToDeviceCopyThunk&) = delete;
+  DeviceToDeviceCopyThunk& operator=(const DeviceToDeviceCopyThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+  void ClearCompileTimeInfo() override {
+    Thunk::ClearCompileTimeInfo();
+    source_value_ = nullptr;
+    destination_value_ = nullptr;
+  }
+
+  const BufferAllocation::Slice& source() const { return source_buffer_; }
+  const BufferAllocation::Slice& destination() const {
+    return destination_buffer_;
+  }
+  uint64_t size_bytes() const { return mem_size_; }
+  mlir::Value source_value() const { return source_value_; }
+  mlir::Value destination_value() const { return destination_value_; }
+
+ private:
+  const BufferAllocation::Slice source_buffer_;
+  const BufferAllocation::Slice destination_buffer_;
+  const uint64_t mem_size_;
+  mlir::Value source_value_;
+  mlir::Value destination_value_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_COPY_THUNK_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_cudnn.h

@@ -0,0 +1,205 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUBLAS_CUDNN_H_
+#define XLA_SERVICE_GPU_CUBLAS_CUDNN_H_
+
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "tsl/platform/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// Different types of convolutions supported by cudnn.
+//
+// A way to think about these is that a convolution is defined by three arrays
+// -- the "input", the "filter", and the "output" -- and given any two of these,
+// we can compute the third.  For example, a backward-input convolution takes as
+// input a filter and an "output" and produces an "input" such that if one were
+// to do a forward convolution of "input" using filter, the result would be
+// something with the same shape as "output".
+//
+// This way of thinking is not correct if you look at the values produced. For
+// example, a backward-input convolution is not actually the mathematical
+// inverse of a forward convolution.  But it's right as far as the shapes and
+// "connectivity" (i.e. which elements of the input affect which elements of
+// the output) are concerned.
+enum class CudnnConvKind {
+  kForward,            // input  + filter => output
+  kBackwardInput,      // filter + output => input
+  kBackwardFilter,     // input  + output => filter
+  kForwardActivation,  // activation(conv(input, filter) + broadcast(bias) +
+                       // (optionally) side_input) => output
+  kForwardGraph,       // pointwise(...pointwise(conv(input, filter))...)
+                       // => output
+};
+
+enum class CudnnfMHAKind {
+  kBmmBmm,
+  kScaleBiasMaskSoftmax,
+  kScaleBiasMaskSoftmaxDropout,
+  kScaleMaskSoftmax,
+  kScaleMaskSoftmaxDropout,
+  kSoftmaxDropout,
+  kSoftmax,
+  kScaleBiasSoftmax,
+  kScaleBiasSoftmaxDropout,
+  kBackwardBmmBmm,
+  kBackwardScaleBiasMaskSoftmax,
+  kBackwardScaleBiasMaskSoftmaxDropout,
+  kBackwardScaleMaskSoftmax,
+  kBackwardScaleMaskSoftmaxDropout,
+  kBackwardSoftmaxDropout,
+  kBackwardSoftmax,
+  kBackwardScaleBiasSoftmax,
+  kBackwardScaleBiasSoftmaxDropout,
+};
+
+StatusOr<CudnnConvKind> GetCudnnConvKind(const HloCustomCallInstruction* instr);
+
+// Converts a CudnnConvKind value to a string.
+std::string CudnnConvKindToString(CudnnConvKind kind);
+
+// Matrix multiplication rewritten into a GEMM custom call.
+// All matrix multiplications should be rewritten as such custom calls
+// after a GemmRewriter lowering pass.
+bool IsCublasGemm(const HloInstruction& hlo);
+
+// Matrix multiplication that calls into legacy cublas.
+bool IsLegacyCublasMatmul(const HloInstruction& hlo);
+
+// Matrix multiplication that calls into cublasLt.
+bool IsCublasLtMatmul(const HloInstruction& hlo);
+
+// Scaled matrix multiplication in FP8. Calls into cublasLt.
+bool IsCublasLtMatmulF8(const HloInstruction& hlo);
+
+// A call to cuBLAS general matrix multiplication API.
+extern const absl::string_view kGemmCallTarget;
+
+// A call to cuBLAS Lt API matrix multiplication.
+extern const absl::string_view kCublasLtMatmulCallTarget;
+
+// A call to cuBLASLt for scaled matrix multiplication in FP8.
+extern const absl::string_view kCublasLtMatmulF8CallTarget;
+
+// A call to cuBLAS for a triangular solve.
+//
+// Like cudnn convolutions, this op returns a tuple (result, scratch_memory).
+extern const absl::string_view kTriangularSolveCallTarget;
+
+// A call to cuDNN for convolution (forward, backward filter, or backward input)
+// is represented as a CustomCall HLO with a call target equal to one of these
+// strings.
+//
+// These CustomCalls have window() and convolution_dimension_numbers() set like
+// regular convolution ops.  They have the same LHS and RHS operands, plus two
+// additional constant operands: an int64_t operand for the cudnn algorithm and
+// a bool operand for whether tensor_ops is enabled. A value of -1 for the cudnn
+// algorithm means that the implementation is free to choose the best algorithm
+// it can.
+//
+// These calls output a tuple (conv_result, scratch_memory), where conv_result
+// is the actual result of the convolution, and scratch_memory is temporary
+// memory used by cudnn.  Callers shouldn't inspect scratch_memory, as its value
+// is not well-defined.
+//
+// GpuConvRewriter lowers kConvolution HLOs to these custom calls.
+// When it does so, it chooses algorithm -1 and 0 bytes of scratch space.  Later
+// on in the pipeline, CudnnConvAlgorithmChooser chooses an explicit
+// algorithm for each conv and sets the amount of scratch space needed.
+//
+// (Representing the scratch memory as an output may seem strange at first, but
+// it's quite sensible, from a certain point of view.  The scratch buffer is a
+// location in memory that the conv can write into, but which it can't legally
+// read from, at least until it's written something first.  But that's exactly
+// the definition of an output buffer.)
+extern const absl::string_view kCudnnConvForwardCallTarget;
+extern const absl::string_view kCudnnConvBackwardInputCallTarget;
+extern const absl::string_view kCudnnConvBackwardFilterCallTarget;
+extern const absl::string_view kCudnnConvBiasActivationForwardCallTarget;
+extern const absl::string_view kCudnnConvForwardGraphCallTarget;
+
+// cuDNN specific convolution helper (emitted together with a int8x32
+// convolution, if reordering is required).
+extern const absl::string_view kCudnnConvReorderFilterCallTarget;
+extern const absl::string_view kCudnnConvReorderFilterAndBiasCallTarget;
+
+// Returns true if `hlo` will be implemented as a call to a cuDNN convolution
+// routine.
+//
+// This returns true if `hlo` is a CustomCall HLO with a call target equal to
+// one of the kCudnnConvFoo constants above, but returns *false* for HLOs with a
+// kConvolution opcode.
+bool IsCustomCallToDnnConvolution(const HloInstruction& hlo);
+
+// Returns true if `hlo` will be implemented as a call to cuDNN convolution
+// reordering helper (required for int8x32 convolutions).
+bool IsCudnnConvolutionReorder(const HloInstruction& hlo);
+
+// The fused_mha_rewriter phase where each of the MHA signatures are pattern
+// matched and rewritten into a custom-call with specific custom-call target.
+// The custom-call target specifies the MHA signature. For example,  BMM1 - Bias
+// - Scale - Mask - Softmax - BMM2 pattern can have the target as
+// cudnn$fmhaBiasScaleMaskSoftmax.
+// The fMHA signatures currently supported by cudnn are:
+// 1.BMM1 - BMM2
+// 2. BMM1 - Scale - Bias - Mask - Softmax - BMM2
+// 3. BMM1 - Scale - Bias - Mask - Softmax - Dropout - BMM2
+// 4. BMM1 - Scale - Mask - Softmax - BMM2
+// 5. BMM1 - Scale - Mask - Softmax - Dropout - BMM2
+// 6. BMM1 - Softmax - Dropout - BMM2
+// 7. BMM1 - Softmax - BMM2
+// 8. BMM1 - scale - Bias - Softmax - BMM2
+// Forward calls
+extern const absl::string_view kCudnnfMHABmmBmmCallTarget;
+extern const absl::string_view kCudnnfMHASoftmaxCallTarget;
+extern const absl::string_view kCudnnfMHAScaleBiasMaskSoftmaxCallTarget;
+extern const absl::string_view kCudnnfMHAScaleBiasMaskSoftmaxDropoutCallTarget;
+extern const absl::string_view kCudnnfMHAScaleMaskSoftmaxCallTarget;
+extern const absl::string_view kCudnnfMHAScaleMaskSoftmaxDropoutCallTarget;
+extern const absl::string_view kCudnnfMHASoftmaxDropoutCallTarget;
+extern const absl::string_view kCudnnfMHAScaleBiasSoftmaxDropoutCallTarget;
+extern const absl::string_view kCudnnfMHAScaleBiasSoftmaxCallTarget;
+// Backward calls
+extern const absl::string_view kCudnnfMHABmmBmmBackwardCallTarget;
+extern const absl::string_view kCudnnfMHASoftmaxBackwardCallTarget;
+extern const absl::string_view kCudnnfMHAScaleBiasMaskSoftmaxBackwardCallTarget;
+extern const absl::string_view
+    kCudnnfMHAScaleBiasMaskSoftmaxDropoutBackwardCallTarget;
+extern const absl::string_view kCudnnfMHAScaleMaskSoftmaxBackwardCallTarget;
+extern const absl::string_view
+    kCudnnfMHAScaleMaskSoftmaxDropoutBackwardCallTarget;
+extern const absl::string_view kCudnnfMHASoftmaxDropoutBackwardCallTarget;
+extern const absl::string_view
+    kCudnnfMHAScaleBiasSoftmaxDropoutBackwardCallTarget;
+extern const absl::string_view kCudnnfMHAScaleBiasSoftmaxBackwardCallTarget;
+
+bool IsFwdCustomCallTofMHA(const HloInstruction& hlo);
+bool IsBwdCustomCallTofMHA(const HloInstruction& hlo);
+bool IsCustomCallTofMHA(const HloInstruction& hlo);
+
+StatusOr<CudnnfMHAKind> GetCudnnfMHAKind(const HloCustomCallInstruction* instr);
+
+std::string CudnnfMHAKindToString(CudnnfMHAKind kind);
+Status SetFMHAInstructionName(HloModule* module, HloInstruction* fmha);
+
+bool MHACallHasDropout(absl::string_view fmha_call_name);
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUBLAS_CUDNN_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_lt_matmul_thunk.h

@@ -0,0 +1,85 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUBLAS_LT_MATMUL_THUNK_H_
+#define XLA_SERVICE_GPU_CUBLAS_LT_MATMUL_THUNK_H_
+
+#include <memory>
+#include <optional>
+#include <utility>
+
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/matmul_utils.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/status.h"
+#include "tsl/platform/statusor.h"
+#if GOOGLE_CUDA
+#include "xla/stream_executor/cuda/cuda_blas_lt.h"
+#else
+#include "rocm/rocm_config.h"
+#include "xla/stream_executor/rocm/hip_blas_lt.h"
+#endif  // GOOGLE_CUDA
+
+namespace xla {
+namespace gpu {
+
+class CublasLtMatmulThunk : public Thunk {
+ public:
+  CublasLtMatmulThunk(ThunkInfo thunk_info, GemmConfig gemm_config,
+                      se::gpu::BlasLt::Epilogue epilogue, int64_t algorithm_idx,
+                      BufferAllocation::Slice a_buffer,
+                      BufferAllocation::Slice b_buffer,
+                      BufferAllocation::Slice c_buffer,
+                      BufferAllocation::Slice d_buffer,
+                      BufferAllocation::Slice bias_buffer /* may be null */,
+                      BufferAllocation::Slice aux_buffer /* may be null */,
+                      BufferAllocation::Slice a_scale_buffer /* may be null */,
+                      BufferAllocation::Slice b_scale_buffer /* may be null */,
+                      BufferAllocation::Slice c_scale_buffer /* may be null */,
+                      BufferAllocation::Slice d_scale_buffer /* may be null */,
+                      BufferAllocation::Slice d_amax_buffer /* may be null */);
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  StatusOr<cublas_lt::MatmulPlan*> GetMatmulPlan(
+      const stream_executor::Stream* stream);
+
+  absl::Mutex matmul_plans_cache_mutex_;
+  absl::flat_hash_map<const stream_executor::Stream*,
+                      std::unique_ptr<cublas_lt::MatmulPlan>>
+      matmul_plans_cache_ ABSL_GUARDED_BY(matmul_plans_cache_mutex_);
+
+  GemmConfig gemm_config_;
+  se::gpu::BlasLt::Epilogue epilogue_;
+  int64_t algorithm_idx_;
+  BufferAllocation::Slice a_buffer_;
+  BufferAllocation::Slice b_buffer_;
+  BufferAllocation::Slice c_buffer_;
+  BufferAllocation::Slice d_buffer_;
+  BufferAllocation::Slice bias_buffer_;
+  BufferAllocation::Slice aux_buffer_;
+  BufferAllocation::Slice a_scale_buffer_;
+  BufferAllocation::Slice b_scale_buffer_;
+  BufferAllocation::Slice c_scale_buffer_;
+  BufferAllocation::Slice d_scale_buffer_;
+  BufferAllocation::Slice d_amax_buffer_;
+  std::optional<se::gpu::BlasLt::MatmulAlgorithm> algorithm_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUBLAS_LT_MATMUL_THUNK_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_pad_for_gemms.h

@@ -0,0 +1,56 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUBLAS_PAD_FOR_GEMMS_H_
+#define XLA_SERVICE_GPU_CUBLAS_PAD_FOR_GEMMS_H_
+
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Adds padding to dot operations to make them run faster on GPUs.
+//
+//
+// This can be used to pad f16 dots on tensor cores, or s8 dots to multiples of
+// four.
+//
+// This pass depends on xla::DotDecomposer pass,
+// so it should go strictly later.
+class CublasPadForGemms : public HloModulePass {
+ public:
+  CublasPadForGemms(const se::CudaComputeCapability cuda_compute_capability,
+                    PrimitiveType datatype, int32_t pad_to_multiple_of)
+      : cuda_compute_capability_(cuda_compute_capability),
+        datatype_(datatype),
+        pad_to_multiple_of_(pad_to_multiple_of) {}
+
+  absl::string_view name() const override { return "cublas-pad-for-gemms"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  const se::CudaComputeCapability cuda_compute_capability_;
+  PrimitiveType datatype_;
+  int32_t pad_to_multiple_of_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUBLAS_PAD_FOR_GEMMS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cublas_padding_requirements.h

@@ -0,0 +1,47 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUBLAS_PADDING_REQUIREMENTS_H_
+#define XLA_SERVICE_GPU_CUBLAS_PADDING_REQUIREMENTS_H_
+
+#include <array>
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+struct CublasPaddingRequirement {
+  int min_compute_capability;
+  PrimitiveType data_type;
+  int multiple_of;
+};
+
+// List of padding requirements per compute capability and data type.
+constexpr std::array<CublasPaddingRequirement, 3> CublasPaddingRequirements{
+    {{se::CudaComputeCapability::VOLTA, S8, 4},
+     {se::CudaComputeCapability::VOLTA, F16, 8},
+     {se::CudaComputeCapability::AMPERE, BF16, 8}}};
+
+// Tell if either of the operands of the dot requires padding.
+bool CublasRequiresPadding(const HloDotInstruction& dot,
+                           se::CudaComputeCapability cc);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUBLAS_PADDING_REQUIREMENTS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_fused_conv_rewriter.h

@@ -0,0 +1,116 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_FUSED_CONV_REWRITER_H_
+#define XLA_SERVICE_GPU_CUDNN_FUSED_CONV_REWRITER_H_
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Rewrites custom-calls targeting cudnnConvolutionForward to
+// cudnnConvolutionBiasActivationForward by fusing operations following forward
+// convolution.  This transform must run after cudnn_conv_rewriter.
+//
+// Semantics of underlying cudnn ops:
+//
+// https://docs.nvidia.com/deeplearning/cudnn/api/index.html#cudnnConvolutionBiasActivationForward
+// https://docs.nvidia.com/deeplearning/cudnn/developer-guide/index.html#scaling-parameters
+//
+// ## Floating-point convs
+//
+// A "complete" fused floating-point conv has the form
+//
+//   max(0, alpha1 * conv(x, w) + alpha2 * side_input + broadcast(bias)),
+//
+// which we fuse to
+//
+//   cudnnConvolutionBiasActivationForward(x, w, bias, side_input).
+//
+// You can leave out side_input, bias, alpha1, alpha2, and max(x, 0) and still
+// get a fused convolution.  alpha1/2 must be broadcasts of scalar constants.
+//
+// f16 convs accumulate in f32.  We represent this in HLO as an f32 convolution
+// whose inputs can be converted to f16 without loss of precision and whose
+// output is immediately converted to f16.  A fused f16 conv must follow one of
+// the following idioms.
+//
+//   1. convert_f16(conv_f32(x_f32, w_f32)) +
+//      side_input_f16 + broadcast(bias_f16)
+//
+//   2. convert_f16(conv_f32(x_f32, w_f32) +
+//                  side_input_f32 + broadcast(bias_f32))
+//
+// (These are not strictly mathematically equivalent, but cudnn doesn't tell us
+// which one it does, and we deem them "close enough".)
+//
+// The foo_f32 HLOs must all be losslessly-convertible to f16.  Some valid
+// examples:
+//
+//   - foo_f32 = convert_f32(foo_f16)
+//   - foo_f32 = an f32 constant whose values all fit within f16
+//   - foo_f32 = broadcast/transpose/reshape(one of the above)
+//
+// If you have a relu, it can appear before or after the convert_f16.
+//
+// Note that here `bias` must be losslessly-convertible to f16; this is
+// different than for s8 convolutions, where bias is f32.
+//
+// ## Integer convs
+//
+// In pure HLO, a "complete" integer conv is spelled as one of the following
+// `result`s.
+//
+//   base = alpha1_f32 * convert_f32(conv_s32(input_s32, filter_s32)) +
+//          alpha2_f32 * side_input +
+//          bias_f32
+//
+//   result_f32        = max(result_f32, 0)
+//   result_s8_option1 = max(convert_s8(clamp(-128, base, 127)), 0)
+//   result_s8_option2 = convert_s8(clamp(-128, max(base, 0), 127))
+//
+// The foo_s32 HLOs must be losslessly-convertible to s8.  If the `result_s8`
+// case, side_input should be an f32 HLO that's losslessly-convertible to s8;
+// otherwise, it should be losslessly-convertible to f32.
+//
+// In the `result_s8` case where there's no bias, side-input, or alpha1, you can
+// skip the convert_f32 on conv.
+//
+// If you have an integer convolution that doesn't fit one of these idioms, this
+// pass returns an error -- cudnn will not be able to run it.
+class CudnnFusedConvRewriter : public HloModulePass {
+ public:
+  explicit CudnnFusedConvRewriter(se::CudaComputeCapability cc)
+      : compute_capability_(cc) {}
+
+  absl::string_view name() const override {
+    return "cudnn-fused-convolution-rewriter";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  const se::CudaComputeCapability compute_capability_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUDNN_FUSED_CONV_REWRITER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_fused_mha_rewriter.h

@@ -0,0 +1,54 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_FUSED_MHA_REWRITER_H_
+#define XLA_SERVICE_GPU_CUDNN_FUSED_MHA_REWRITER_H_
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/stream_executor/dnn.h"
+
+namespace xla {
+namespace gpu {
+
+class CudnnFusedMHARewriter : public HloModulePass {
+ public:
+  explicit CudnnFusedMHARewriter(se::CudaComputeCapability cc,
+                                 se::StreamExecutor* stream_executor)
+      : compute_capability_(cc), stream_executor_(stream_executor) {}
+
+  explicit CudnnFusedMHARewriter(se::CudaComputeCapability cc,
+                                 se::dnn::VersionInfo cudnn_version)
+      : compute_capability_(cc), cudnn_version_(cudnn_version) {}
+
+  absl::string_view name() const override {
+    return "cudnn-fused-multi-headed-attention-rewriter";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  const se::CudaComputeCapability compute_capability_;
+  se::StreamExecutor* stream_executor_ = nullptr;
+  const se::dnn::VersionInfo cudnn_version_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUDNN_FUSED_MHA_REWRITER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_fused_mha_transpose_fusion.h

@@ -0,0 +1,42 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_FUSED_MHA_TRANSPOSE_FUSION_H_
+#define XLA_SERVICE_GPU_CUDNN_FUSED_MHA_TRANSPOSE_FUSION_H_
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+class CudnnFusedMHATransposeFusion : public HloModulePass {
+ public:
+  CudnnFusedMHATransposeFusion() = default;
+
+  absl::string_view name() const override {
+    return "cudnn-fused-multi-headed-attention-transpose-fusion";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUDNN_FUSED_MHA_TRANSPOSE_FUSION_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_pad_for_convolutions.h

@@ -0,0 +1,53 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_PAD_FOR_CONVOLUTIONS_H_
+#define XLA_SERVICE_GPU_CUDNN_PAD_FOR_CONVOLUTIONS_H_
+
+#include "xla/hlo/ir/hlo_casting_utils.h"
+#include "xla/literal_util.h"
+#include "xla/service/gpu/ir_emission_utils.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/util.h"
+#include "xla/window_util.h"
+
+namespace xla {
+namespace gpu {
+
+// Two zero-paddings for CuDNN thunking are done in this transform: padding for
+// tensor cores and padding for integer convolutions.  This transform also
+// add slice instruction to remove unnecessary output features.
+class CudnnPadForConvolutions : public HloModulePass {
+ public:
+  explicit CudnnPadForConvolutions(se::CudaComputeCapability compute_capability)
+      : compute_capability_(compute_capability) {}
+
+  absl::string_view name() const override {
+    return "cudnn_pad_for_convolutions";
+  }
+  // Run PadForConvolutions on the given module and return if any change is made
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  const se::CudaComputeCapability compute_capability_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUDNN_PAD_FOR_CONVOLUTIONS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_simplify_padding.h

@@ -0,0 +1,64 @@
+/* Copyright 2022 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_SIMPLIFY_PADDING_H_
+#define XLA_SERVICE_GPU_CUDNN_SIMPLIFY_PADDING_H_
+
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla::gpu {
+
+// Simplifies or eliminates padding introduced by CudnnPadForConvolutions and
+// CudnnVectorizeConvolutions.
+//
+// CudnnVectorizeConvolutions will generate code that does the following.
+//  - pad input and output features to a multiple of 32 (or 4),
+//  - reshape input from [N,C,H,W] to [N,C/32,H,W,32] and reshape kernel from
+//    [I,O,H,W] to [I/32,32,O,H,W],
+//  - run the conv,
+//  - reshape output from [N,C/32,H,W,32] to [N,C,H,W], and finally
+//  - slice off the padding on the C channel.
+//
+// But if this is followed by another convolution (very common), then the slice
+// is immediately followed by another pad. This may be redundant; we know that
+// the trailing channels sliced off from the first conv are 0.
+//
+// Ideally we can eliminate the whole reshape+slice+pad+reshape sequence between
+// the two convolutions.
+//
+// Specifically, this pass tries to merge the slice at the end of the sequence
+// above into the pad from the next convolution (when we can prove that the
+// sliced-off elements are all 0). We then rely on algsimp to remove the pad if
+// it's a nop and then to merge and eliminate the remaining reshapes.
+//
+// This pass should run after CudnnVectorizeConvolutions and there should be no
+// simplification passes in between that modify the reshape-transpose-reshape
+// introduced by int8x32 convolution filter reordering.
+class CudnnSimplifyPadding : public HloModulePass {
+ public:
+  CudnnSimplifyPadding() = default;
+
+  absl::string_view name() const override { return "cudnn_simplify_padding"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace xla::gpu
+
+#endif  // XLA_SERVICE_GPU_CUDNN_SIMPLIFY_PADDING_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_support_utils.h

@@ -0,0 +1,74 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_SUPPORT_UTILS_H_
+#define XLA_SERVICE_GPU_CUDNN_SUPPORT_UTILS_H_
+
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/shape.h"
+#include "xla/stream_executor/device_description.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace gpu {
+
+// Indicates whether the `compute_capability` supports an optimized integer
+// implementation of the given `conv` operation vectorized to `vector_size`.
+//
+// This function does not guarantee that a convolution will be padded and/or
+// vectorized. It only checks that it is a valid candiate for such optimization.
+StatusOr<bool> CudnnSupportsOptimizedIntegerConvolution(
+    const se::CudaComputeCapability& compute_capability,
+    HloCustomCallInstruction& conv, int vector_size);
+
+// Represents configuration for the reshape-transpose-reshape operations that
+// are equivalent to `cudnnReorderFilterAndBias`. This is used by int8x32
+// vectorized convolutions.
+//
+// For filter reordering the equivalent HLO is:
+//   %reshape = s8[$S] reshape(%input)
+//   %transpose = s8[I/32,H,W,O/8,2,8,4,4] transpose(%reshape), dimensions={$D}
+//   %result = s8[O,I/32,H,W,32] reshape(%transpose)
+//
+// For bias reordering the HLO is similar, but the op shapes are s8[O/32,4,2,4]
+// for %transpose, and s8[O/32,2,4,4] for %result.
+//
+// The helper functions below calculate the shape $S (transpose_shape) and
+// dimensions $D (permutation) from the convolution dimensions numbers config.
+// The result_shape is fixed and is present for the convenience.
+struct CudnnReorderTransposeConfig {
+  Shape transpose_shape;
+  Shape result_shape;
+  std::vector<int64_t> permutation;
+};
+
+// Create a transposition for an int8x32 convolution filter that effectively
+// does the same thing as cudnnReorderFilterAndBias, but could also be constant
+// folded or fused.
+StatusOr<CudnnReorderTransposeConfig> CudnnInferTransposeForFilterReordering(
+    const Shape& shape, const ConvolutionDimensionNumbers& dimension_numbers);
+
+// Create a transposition for an int8x32 convolution bias that effectively
+// does the same thing as cudnnReorderFilterAndBias, but could also be constant
+// folded or fused.
+StatusOr<CudnnReorderTransposeConfig> CudnnInferTransposeForBiasReordering(
+    const Shape& shape);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUDNN_SUPPORT_UTILS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cudnn_vectorize_convolutions.h

@@ -0,0 +1,71 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUDNN_VECTORIZE_CONVOLUTIONS_H_
+#define XLA_SERVICE_GPU_CUDNN_VECTORIZE_CONVOLUTIONS_H_
+
+#include <utility>
+
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/dnn.h"
+
+namespace xla {
+namespace gpu {
+
+// Changes the shape of cudnn convolutions to allow faster "vectorized"
+// algorithms.
+//
+// On sm61+ will convert int8_t convolutions from
+//
+//   - [N, C, H, W] to [N, C/4, H, W, 4],
+//
+// assuming C is divisible by 4.
+//
+// On sm75+ will convert int8_t convolutions from
+//
+//   - [N, C, H, W]      to [N, C/32, H, W, 32],
+//   - [N, C/4, H, W, 4] to [N, C/32, H, W, 32], and
+//   - [N, C, H, W]      to [N,  C/4, H, W,  4] (same as sm61+),
+//
+// assuming C is divisible by 4 or 32.
+//
+// This pass will not pad the channel dim to a multiple of 4 or 32, so you
+// should run CudnnPadForConvolutions before this.
+class CudnnVectorizeConvolutions : public HloModulePass {
+ public:
+  explicit CudnnVectorizeConvolutions(
+      se::CudaComputeCapability compute_capability,
+      se::dnn::VersionInfo cudnn_version)
+      : compute_capability_(compute_capability),
+        cudnn_version_(cudnn_version) {}
+
+  absl::string_view name() const override {
+    return "cudnn_vectorize_convolutions";
+  }
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  const se::CudaComputeCapability compute_capability_;
+  const se::dnn::VersionInfo cudnn_version_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUDNN_VECTORIZE_CONVOLUTIONS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cusolver_context.h

@@ -0,0 +1,110 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUSOLVER_CONTEXT_H_
+#define XLA_SERVICE_GPU_CUSOLVER_CONTEXT_H_
+
+#include <complex>
+#include <memory>
+
+#define TENSORFLOW_USE_HIPSOLVER \
+  (TENSORFLOW_USE_ROCM && (TF_ROCM_VERSION >= 40500))
+#define TENSORFLOW_USE_ROCSOLVER \
+  (TENSORFLOW_USE_ROCM && (TF_ROCM_VERSION < 40500))
+#define TENSORFLOW_USE_CUSOLVER_OR_HIPSOLVER \
+  (!TENSORFLOW_USE_ROCM || TENSORFLOW_USE_HIPSOLVER)
+
+#if !TENSORFLOW_USE_ROCM
+#include "third_party/gpus/cuda/include/cusolverDn.h"
+using gpusolverHandle_t = cusolverDnHandle_t;
+#else
+#include "rocm/rocm_config.h"
+// Macros to ease the transition from rocsolver to hipsolver.
+#if TENSORFLOW_USE_HIPSOLVER
+#include "xla/stream_executor/rocm/hipsolver_wrapper.h"
+using gpusolverHandle_t = hipsolverHandle_t;
+#else  // TENSORFLOW_USE_ROCSOLVER
+#include "xla/stream_executor/rocm/rocblas_wrapper.h"
+#include "xla/stream_executor/rocm/rocsolver_wrapper.h"
+using gpusolverHandle_t = rocblas_handle;
+#endif  // TF_ROCM_VERSION >= 40500
+#endif  // TENSORFLOW_USE_ROCM
+
+#include "xla/statusor.h"
+#include "xla/stream_executor/blas.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace gpu {
+
+namespace se = ::stream_executor;
+
+class GpuSolverContext {
+ public:
+  static StatusOr<GpuSolverContext> Create();
+
+  Status SetStream(se::Stream* stream);
+
+  // Computes the Cholesky factorization of multiple matrices.  See
+  // https://docs.nvidia.com/cuda/cusolver/index.html#cuSolverDN-lt-t-gt-batchpotrf
+  //
+  // `as` is a list of pointers to the batch_size individual n x n matricies
+  // that make up the input array.
+  Status PotrfBatched(se::blas::UpperLower uplo, int n,
+                      se::DeviceMemory<float*> as, int lda,
+                      se::DeviceMemory<int> lapack_info, int batch_size);
+  Status PotrfBatched(se::blas::UpperLower uplo, int n,
+                      se::DeviceMemory<double*> as, int lda,
+                      se::DeviceMemory<int> lapack_info, int batch_size);
+  Status PotrfBatched(se::blas::UpperLower uplo, int n,
+                      se::DeviceMemory<std::complex<float>*> as, int lda,
+                      se::DeviceMemory<int> lapack_info, int batch_size);
+  Status PotrfBatched(se::blas::UpperLower uplo, int n,
+                      se::DeviceMemory<std::complex<double>*> as, int lda,
+                      se::DeviceMemory<int> lapack_info, int batch_size);
+
+  // Returns the max size of the `workspace` required by Potrf and PotrfBatched,
+  // in number of elements of `type`.
+  //
+  // (cusolver's PotrfBatched doesn't require a workspace per se -- it uses the
+  // input array as scratch.  But we do need to materialize the `as` input, and
+  // we do this in the workspace.)
+  //
+  // This is a bit of a hack; we could instead split it up into two functions.
+  // But at the moment, it's an implementation detail of CholeskyThunk whether
+  // it calls Potrf or PotrfBatched, so we need to allocate enough scratch space
+  // for either.
+  //
+  // In practice, this does not result in a notable increase in scratch space
+  // needed, because both cases require a relatively small amount of scratch.
+  StatusOr<int64_t> PotrfBufferSize(PrimitiveType type,
+                                    se::blas::UpperLower uplo, int n, int lda,
+                                    int batch_size);
+
+ private:
+  explicit GpuSolverContext(gpusolverHandle_t handle);
+
+  struct Deleter {
+    void operator()(gpusolverHandle_t handle);
+  };
+
+  std::unique_ptr<std::remove_pointer_t<gpusolverHandle_t>, Deleter> handle_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUSOLVER_CONTEXT_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/cusolver_rewriter.h

@@ -0,0 +1,47 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUSOLVER_REWRITER_H_
+#define XLA_SERVICE_GPU_CUSOLVER_REWRITER_H_
+
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/gpu/cusolver_context.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/stream_executor/device_memory_allocator.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// Rewrites Cholesky calls into CustomCall HLOs that call into cuSolver.
+class GpusolverRewriter : public HloModulePass {
+ public:
+  GpusolverRewriter();
+  absl::string_view name() const override { return "gpusolver-rewriter"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  StatusOr<bool> RunOnComputation(HloComputation* computation);
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUSOLVER_REWRITER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/custom_call_thunk.h

@@ -0,0 +1,70 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_CUSTOM_CALL_THUNK_H_
+#define XLA_SERVICE_GPU_CUSTOM_CALL_THUNK_H_
+
+#include "xla/service/custom_call_status_internal.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/thunk.h"
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+#include "xla/stream_executor/gpu/gpu_types.h"
+#endif
+
+namespace xla {
+namespace gpu {
+
+// Thunk to run a GPU custom call.
+//
+// This thunk's `ExecuteOnStream` implementation executes a host function
+// `call_target` which is expected to enqueue operations onto the GPU.
+//
+// Note that not all kCustomCall HLOs in XLA:GPU end up being run by this thunk.
+// XLA itself creates kCustomCall instructions when lowering kConvolution HLOs
+// into calls to cudnn.  These internally-created custom-calls are run using
+// ConvolutionThunk, not CustomCallThunk.  There's no ambiguity because they
+// have special call target names (e.g. "__cudnn$convForward") that only the
+// compiler is allowed to create.
+class CustomCallThunk : public Thunk {
+ public:
+  using OptionalSlice = ::std::optional<BufferAllocation::Slice>;
+
+#if GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+  using Stream = stream_executor::gpu::GpuStreamHandle;
+#else   //  GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+  using Stream = void*;
+#endif  //  GOOGLE_CUDA || TENSORFLOW_USE_ROCM
+
+  using CustomCallTarget = std::function<void(Stream, void**, const char*,
+                                              size_t, XlaCustomCallStatus*)>;
+  CustomCallThunk(ThunkInfo thunk_info, CustomCallTarget call_target,
+                  std::vector<OptionalSlice> operands,
+                  std::vector<OptionalSlice> results,
+                  const std::string& opaque);
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  const CustomCallTarget call_target_;
+  const std::vector<OptionalSlice> operands_;
+  const std::vector<OptionalSlice> results_;
+  const std::string opaque_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_CUSTOM_CALL_THUNK_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/dot_dimension_sorter.h

@@ -0,0 +1,49 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_DOT_DIMENSION_SORTER_H_
+#define XLA_SERVICE_GPU_DOT_DIMENSION_SORTER_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Sorts contracting dimensions of dot() operands when this reduces the
+// number of transposes. Example:
+// dot(p0, p1), lhs_contracting_dims={3,2}, rhs_contracting_dims={2,1}  ->
+// dot(p0, p1), lhs_contracting_dims={2,3}, rhs_contracting_dims={1,2}
+// The first case gets transposes inserted by dot_decomposer, the second one
+// does not and thus is generally more efficient.
+
+// TODO(b/265688934): do the same for batch dimensions?
+
+class DotDimensionSorter : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "dot_dimension_sorter"; }
+
+  // Run the pass on computations in 'module'.
+  // Returns whether the 'module' was changed.
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_DOT_DIMENSION_SORTER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/elemental_ir_emitter.h

@@ -0,0 +1,137 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_ELEMENTAL_IR_EMITTER_H_
+#define XLA_SERVICE_GPU_ELEMENTAL_IR_EMITTER_H_
+
+#include <string>
+
+#include "absl/types/span.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/Value.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/elemental_ir_emitter.h"
+#include "xla/service/gpu/ir_emitter_context.h"
+#include "xla/service/gpu/target_util.h"
+#include "xla/service/hlo_module_config.h"
+#include "xla/statusor.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace gpu {
+
+class GpuElementalIrEmitter : public ElementalIrEmitter {
+ public:
+  GpuElementalIrEmitter(IrEmitterContext& ir_emitter_context,
+                        llvm::IRBuilder<>* b);
+
+ protected:
+  llvm_ir::IrArray::Index GetSourceIndexOfBitcast(
+      const llvm_ir::IrArray::Index& index, const HloInstruction* hlo) override;
+
+  StatusOr<llvm::Value*> EmitFloatBinaryOp(const HloInstruction* op,
+                                           llvm::Value* lhs_value,
+                                           llvm::Value* rhs_value) override;
+
+  StatusOr<llvm::Value*> EmitLog(PrimitiveType prim_type,
+                                 llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitLog1p(PrimitiveType prim_type,
+                                   llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitSin(PrimitiveType prim_type,
+                                 llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitCos(PrimitiveType prim_type,
+                                 llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitTan(PrimitiveType prim_type,
+                                 llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitExp(PrimitiveType prim_type, llvm::Value* value,
+                                 absl::string_view name) override;
+
+  StatusOr<llvm::Value*> EmitExpm1(PrimitiveType prim_type,
+                                   llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitSqrt(PrimitiveType prim_type,
+                                  llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitRsqrt(PrimitiveType prim_type,
+                                   llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitPow(PrimitiveType prim_type, llvm::Value* lhs,
+                                 llvm::Value* rhs,
+                                 absl::string_view name) override;
+
+  StatusOr<llvm::Value*> EmitAtan2(PrimitiveType prim_type, llvm::Value* lhs,
+                                   llvm::Value* rhs,
+                                   absl::string_view name) override;
+
+  StatusOr<llvm::Value*> EmitTanh(PrimitiveType prim_type,
+                                  llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitComplexAbs(PrimitiveType prim_type,
+                                        llvm::Value* value) override;
+
+  StatusOr<llvm::Value*> EmitCbrt(PrimitiveType prim_type,
+                                  llvm::Value* value) override;
+
+  StatusOr<std::vector<llvm::Value*>> EmitThreadLocalCall(
+      const HloComputation& callee, absl::Span<llvm::Value* const> parameters,
+      absl::string_view, bool /*is_reducer*/) override;
+
+  llvm::Value* EmitThreadId() override;
+
+  bool fast_min_max() override {
+    return ir_emitter_context_.debug_options().xla_gpu_enable_fast_min_max();
+  }
+
+ private:
+  // Emits IR for op, which must have opcode kPower.
+  StatusOr<llvm::Value*> EmitPowerOp(const HloInstruction* op,
+                                     llvm::Value* lhs_value,
+                                     llvm::Value* rhs_value);
+
+  // Emits IR to call an LLVM intrinsic of type [T] -> T.  Adjusts
+  // callee_name according to T.  Returns the IR value that represents the
+  // return value of the function.
+  StatusOr<llvm::Value*> EmitLlvmIntrinsicMathCall(
+      const std::string& callee_name, absl::Span<llvm::Value* const> operands,
+      absl::Span<const PrimitiveType> input_types, PrimitiveType output_type);
+
+  // Emits IR to call a device function of type [T] -> T.  Adjusts
+  // callee_name according to T.  Returns the IR value that represents the
+  // return value of the function.
+  StatusOr<llvm::Value*> EmitDeviceMathCall(
+      TargetDeviceFunctionID funcid, absl::Span<llvm::Value* const> operands,
+      absl::Span<const PrimitiveType> input_types, PrimitiveType output_type,
+      absl::string_view name = "");
+
+  // Emits IR to call a function of type [T] -> T.  Does not munge callee_name.
+  // Returns the IR value that represents the return value of the function.
+  StatusOr<llvm::Value*> EmitMathCall(
+      const std::string& callee_name, absl::Span<llvm::Value* const> operands,
+      absl::Span<const PrimitiveType> input_types, PrimitiveType output_type,
+      absl::string_view name = "");
+
+  IrEmitterContext& ir_emitter_context_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_ELEMENTAL_IR_EMITTER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/executable.pb.h

@@ -0,0 +1,935 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: xla/service/gpu/executable.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fexecutable_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fexecutable_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#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 <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "xla/service/hlo.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_xla_2fservice_2fgpu_2fexecutable_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_xla_2fservice_2fgpu_2fexecutable_2eproto;
+namespace xla {
+namespace gpu {
+class XlaRuntimeGpuExecutableProto;
+struct XlaRuntimeGpuExecutableProtoDefaultTypeInternal;
+extern XlaRuntimeGpuExecutableProtoDefaultTypeInternal _XlaRuntimeGpuExecutableProto_default_instance_;
+class XlaRuntimeGpuExecutableProto_ConstantInfoProto;
+struct XlaRuntimeGpuExecutableProto_ConstantInfoProtoDefaultTypeInternal;
+extern XlaRuntimeGpuExecutableProto_ConstantInfoProtoDefaultTypeInternal _XlaRuntimeGpuExecutableProto_ConstantInfoProto_default_instance_;
+}  // namespace gpu
+}  // namespace xla
+PROTOBUF_NAMESPACE_OPEN
+template<> ::xla::gpu::XlaRuntimeGpuExecutableProto* Arena::CreateMaybeMessage<::xla::gpu::XlaRuntimeGpuExecutableProto>(Arena*);
+template<> ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* Arena::CreateMaybeMessage<::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace xla {
+namespace gpu {
+
+// ===================================================================
+
+class XlaRuntimeGpuExecutableProto_ConstantInfoProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto) */ {
+ public:
+  inline XlaRuntimeGpuExecutableProto_ConstantInfoProto() : XlaRuntimeGpuExecutableProto_ConstantInfoProto(nullptr) {}
+  ~XlaRuntimeGpuExecutableProto_ConstantInfoProto() override;
+  explicit PROTOBUF_CONSTEXPR XlaRuntimeGpuExecutableProto_ConstantInfoProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  XlaRuntimeGpuExecutableProto_ConstantInfoProto(const XlaRuntimeGpuExecutableProto_ConstantInfoProto& from);
+  XlaRuntimeGpuExecutableProto_ConstantInfoProto(XlaRuntimeGpuExecutableProto_ConstantInfoProto&& from) noexcept
+    : XlaRuntimeGpuExecutableProto_ConstantInfoProto() {
+    *this = ::std::move(from);
+  }
+
+  inline XlaRuntimeGpuExecutableProto_ConstantInfoProto& operator=(const XlaRuntimeGpuExecutableProto_ConstantInfoProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline XlaRuntimeGpuExecutableProto_ConstantInfoProto& operator=(XlaRuntimeGpuExecutableProto_ConstantInfoProto&& 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 XlaRuntimeGpuExecutableProto_ConstantInfoProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const XlaRuntimeGpuExecutableProto_ConstantInfoProto* internal_default_instance() {
+    return reinterpret_cast<const XlaRuntimeGpuExecutableProto_ConstantInfoProto*>(
+               &_XlaRuntimeGpuExecutableProto_ConstantInfoProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(XlaRuntimeGpuExecutableProto_ConstantInfoProto& a, XlaRuntimeGpuExecutableProto_ConstantInfoProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(XlaRuntimeGpuExecutableProto_ConstantInfoProto* 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(XlaRuntimeGpuExecutableProto_ConstantInfoProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  XlaRuntimeGpuExecutableProto_ConstantInfoProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<XlaRuntimeGpuExecutableProto_ConstantInfoProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const XlaRuntimeGpuExecutableProto_ConstantInfoProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const XlaRuntimeGpuExecutableProto_ConstantInfoProto& from) {
+    XlaRuntimeGpuExecutableProto_ConstantInfoProto::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(XlaRuntimeGpuExecutableProto_ConstantInfoProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto";
+  }
+  protected:
+  explicit XlaRuntimeGpuExecutableProto_ConstantInfoProto(::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 {
+    kSymbolNameFieldNumber = 1,
+    kContentFieldNumber = 2,
+    kAllocationIndexFieldNumber = 3,
+  };
+  // string symbol_name = 1;
+  void clear_symbol_name();
+  const std::string& symbol_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_symbol_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_symbol_name();
+  PROTOBUF_NODISCARD std::string* release_symbol_name();
+  void set_allocated_symbol_name(std::string* symbol_name);
+  private:
+  const std::string& _internal_symbol_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_symbol_name(const std::string& value);
+  std::string* _internal_mutable_symbol_name();
+  public:
+
+  // bytes content = 2;
+  void clear_content();
+  const std::string& content() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content();
+  PROTOBUF_NODISCARD std::string* release_content();
+  void set_allocated_content(std::string* content);
+  private:
+  const std::string& _internal_content() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content(const std::string& value);
+  std::string* _internal_mutable_content();
+  public:
+
+  // int32 allocation_index = 3;
+  void clear_allocation_index();
+  int32_t allocation_index() const;
+  void set_allocation_index(int32_t value);
+  private:
+  int32_t _internal_allocation_index() const;
+  void _internal_set_allocation_index(int32_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr symbol_name_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_;
+    int32_t allocation_index_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto;
+};
+// -------------------------------------------------------------------
+
+class XlaRuntimeGpuExecutableProto final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.XlaRuntimeGpuExecutableProto) */ {
+ public:
+  inline XlaRuntimeGpuExecutableProto() : XlaRuntimeGpuExecutableProto(nullptr) {}
+  ~XlaRuntimeGpuExecutableProto() override;
+  explicit PROTOBUF_CONSTEXPR XlaRuntimeGpuExecutableProto(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  XlaRuntimeGpuExecutableProto(const XlaRuntimeGpuExecutableProto& from);
+  XlaRuntimeGpuExecutableProto(XlaRuntimeGpuExecutableProto&& from) noexcept
+    : XlaRuntimeGpuExecutableProto() {
+    *this = ::std::move(from);
+  }
+
+  inline XlaRuntimeGpuExecutableProto& operator=(const XlaRuntimeGpuExecutableProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline XlaRuntimeGpuExecutableProto& operator=(XlaRuntimeGpuExecutableProto&& 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 XlaRuntimeGpuExecutableProto& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const XlaRuntimeGpuExecutableProto* internal_default_instance() {
+    return reinterpret_cast<const XlaRuntimeGpuExecutableProto*>(
+               &_XlaRuntimeGpuExecutableProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(XlaRuntimeGpuExecutableProto& a, XlaRuntimeGpuExecutableProto& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(XlaRuntimeGpuExecutableProto* 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(XlaRuntimeGpuExecutableProto* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  XlaRuntimeGpuExecutableProto* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<XlaRuntimeGpuExecutableProto>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const XlaRuntimeGpuExecutableProto& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const XlaRuntimeGpuExecutableProto& from) {
+    XlaRuntimeGpuExecutableProto::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(XlaRuntimeGpuExecutableProto* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.XlaRuntimeGpuExecutableProto";
+  }
+  protected:
+  explicit XlaRuntimeGpuExecutableProto(::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 XlaRuntimeGpuExecutableProto_ConstantInfoProto ConstantInfoProto;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kConstantsFieldNumber = 5,
+    kGpuAsmTextFieldNumber = 3,
+    kGpuBinaryFieldNumber = 4,
+    kXlaRuntimeExecutableFieldNumber = 1,
+    kEntryFuncAttrsFieldNumber = 2,
+  };
+  // repeated .xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto constants = 5;
+  int constants_size() const;
+  private:
+  int _internal_constants_size() const;
+  public:
+  void clear_constants();
+  ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* mutable_constants(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto >*
+      mutable_constants();
+  private:
+  const ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto& _internal_constants(int index) const;
+  ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* _internal_add_constants();
+  public:
+  const ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto& constants(int index) const;
+  ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* add_constants();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto >&
+      constants() const;
+
+  // string gpu_asm_text = 3;
+  void clear_gpu_asm_text();
+  const std::string& gpu_asm_text() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_gpu_asm_text(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_gpu_asm_text();
+  PROTOBUF_NODISCARD std::string* release_gpu_asm_text();
+  void set_allocated_gpu_asm_text(std::string* gpu_asm_text);
+  private:
+  const std::string& _internal_gpu_asm_text() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gpu_asm_text(const std::string& value);
+  std::string* _internal_mutable_gpu_asm_text();
+  public:
+
+  // bytes gpu_binary = 4;
+  void clear_gpu_binary();
+  const std::string& gpu_binary() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_gpu_binary(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_gpu_binary();
+  PROTOBUF_NODISCARD std::string* release_gpu_binary();
+  void set_allocated_gpu_binary(std::string* gpu_binary);
+  private:
+  const std::string& _internal_gpu_binary() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_gpu_binary(const std::string& value);
+  std::string* _internal_mutable_gpu_binary();
+  public:
+
+  // .xla.XlaRuntimeExecutableProto xla_runtime_executable = 1;
+  bool has_xla_runtime_executable() const;
+  private:
+  bool _internal_has_xla_runtime_executable() const;
+  public:
+  void clear_xla_runtime_executable();
+  const ::xla::XlaRuntimeExecutableProto& xla_runtime_executable() const;
+  PROTOBUF_NODISCARD ::xla::XlaRuntimeExecutableProto* release_xla_runtime_executable();
+  ::xla::XlaRuntimeExecutableProto* mutable_xla_runtime_executable();
+  void set_allocated_xla_runtime_executable(::xla::XlaRuntimeExecutableProto* xla_runtime_executable);
+  private:
+  const ::xla::XlaRuntimeExecutableProto& _internal_xla_runtime_executable() const;
+  ::xla::XlaRuntimeExecutableProto* _internal_mutable_xla_runtime_executable();
+  public:
+  void unsafe_arena_set_allocated_xla_runtime_executable(
+      ::xla::XlaRuntimeExecutableProto* xla_runtime_executable);
+  ::xla::XlaRuntimeExecutableProto* unsafe_arena_release_xla_runtime_executable();
+
+  // .xla.EntryFunctionAttributes entry_func_attrs = 2;
+  bool has_entry_func_attrs() const;
+  private:
+  bool _internal_has_entry_func_attrs() const;
+  public:
+  void clear_entry_func_attrs();
+  const ::xla::EntryFunctionAttributes& entry_func_attrs() const;
+  PROTOBUF_NODISCARD ::xla::EntryFunctionAttributes* release_entry_func_attrs();
+  ::xla::EntryFunctionAttributes* mutable_entry_func_attrs();
+  void set_allocated_entry_func_attrs(::xla::EntryFunctionAttributes* entry_func_attrs);
+  private:
+  const ::xla::EntryFunctionAttributes& _internal_entry_func_attrs() const;
+  ::xla::EntryFunctionAttributes* _internal_mutable_entry_func_attrs();
+  public:
+  void unsafe_arena_set_allocated_entry_func_attrs(
+      ::xla::EntryFunctionAttributes* entry_func_attrs);
+  ::xla::EntryFunctionAttributes* unsafe_arena_release_entry_func_attrs();
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.XlaRuntimeGpuExecutableProto)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto > constants_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gpu_asm_text_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr gpu_binary_;
+    ::xla::XlaRuntimeExecutableProto* xla_runtime_executable_;
+    ::xla::EntryFunctionAttributes* entry_func_attrs_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fexecutable_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// XlaRuntimeGpuExecutableProto_ConstantInfoProto
+
+// string symbol_name = 1;
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::clear_symbol_name() {
+  _impl_.symbol_name_.ClearToEmpty();
+}
+inline const std::string& XlaRuntimeGpuExecutableProto_ConstantInfoProto::symbol_name() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.symbol_name)
+  return _internal_symbol_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void XlaRuntimeGpuExecutableProto_ConstantInfoProto::set_symbol_name(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.symbol_name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.symbol_name)
+}
+inline std::string* XlaRuntimeGpuExecutableProto_ConstantInfoProto::mutable_symbol_name() {
+  std::string* _s = _internal_mutable_symbol_name();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.symbol_name)
+  return _s;
+}
+inline const std::string& XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_symbol_name() const {
+  return _impl_.symbol_name_.Get();
+}
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_set_symbol_name(const std::string& value) {
+  
+  _impl_.symbol_name_.Set(value, GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_mutable_symbol_name() {
+  
+  return _impl_.symbol_name_.Mutable(GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto_ConstantInfoProto::release_symbol_name() {
+  // @@protoc_insertion_point(field_release:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.symbol_name)
+  return _impl_.symbol_name_.Release();
+}
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::set_allocated_symbol_name(std::string* symbol_name) {
+  if (symbol_name != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.symbol_name_.SetAllocated(symbol_name, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.symbol_name_.IsDefault()) {
+    _impl_.symbol_name_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.symbol_name)
+}
+
+// bytes content = 2;
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::clear_content() {
+  _impl_.content_.ClearToEmpty();
+}
+inline const std::string& XlaRuntimeGpuExecutableProto_ConstantInfoProto::content() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.content)
+  return _internal_content();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void XlaRuntimeGpuExecutableProto_ConstantInfoProto::set_content(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.content_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.content)
+}
+inline std::string* XlaRuntimeGpuExecutableProto_ConstantInfoProto::mutable_content() {
+  std::string* _s = _internal_mutable_content();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.content)
+  return _s;
+}
+inline const std::string& XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_content() const {
+  return _impl_.content_.Get();
+}
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_set_content(const std::string& value) {
+  
+  _impl_.content_.Set(value, GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_mutable_content() {
+  
+  return _impl_.content_.Mutable(GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto_ConstantInfoProto::release_content() {
+  // @@protoc_insertion_point(field_release:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.content)
+  return _impl_.content_.Release();
+}
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::set_allocated_content(std::string* content) {
+  if (content != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.content_.SetAllocated(content, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.content_.IsDefault()) {
+    _impl_.content_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.content)
+}
+
+// int32 allocation_index = 3;
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::clear_allocation_index() {
+  _impl_.allocation_index_ = 0;
+}
+inline int32_t XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_allocation_index() const {
+  return _impl_.allocation_index_;
+}
+inline int32_t XlaRuntimeGpuExecutableProto_ConstantInfoProto::allocation_index() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.allocation_index)
+  return _internal_allocation_index();
+}
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::_internal_set_allocation_index(int32_t value) {
+  
+  _impl_.allocation_index_ = value;
+}
+inline void XlaRuntimeGpuExecutableProto_ConstantInfoProto::set_allocation_index(int32_t value) {
+  _internal_set_allocation_index(value);
+  // @@protoc_insertion_point(field_set:xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto.allocation_index)
+}
+
+// -------------------------------------------------------------------
+
+// XlaRuntimeGpuExecutableProto
+
+// .xla.XlaRuntimeExecutableProto xla_runtime_executable = 1;
+inline bool XlaRuntimeGpuExecutableProto::_internal_has_xla_runtime_executable() const {
+  return this != internal_default_instance() && _impl_.xla_runtime_executable_ != nullptr;
+}
+inline bool XlaRuntimeGpuExecutableProto::has_xla_runtime_executable() const {
+  return _internal_has_xla_runtime_executable();
+}
+inline const ::xla::XlaRuntimeExecutableProto& XlaRuntimeGpuExecutableProto::_internal_xla_runtime_executable() const {
+  const ::xla::XlaRuntimeExecutableProto* p = _impl_.xla_runtime_executable_;
+  return p != nullptr ? *p : reinterpret_cast<const ::xla::XlaRuntimeExecutableProto&>(
+      ::xla::_XlaRuntimeExecutableProto_default_instance_);
+}
+inline const ::xla::XlaRuntimeExecutableProto& XlaRuntimeGpuExecutableProto::xla_runtime_executable() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.xla_runtime_executable)
+  return _internal_xla_runtime_executable();
+}
+inline void XlaRuntimeGpuExecutableProto::unsafe_arena_set_allocated_xla_runtime_executable(
+    ::xla::XlaRuntimeExecutableProto* xla_runtime_executable) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xla_runtime_executable_);
+  }
+  _impl_.xla_runtime_executable_ = xla_runtime_executable;
+  if (xla_runtime_executable) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.xla_runtime_executable)
+}
+inline ::xla::XlaRuntimeExecutableProto* XlaRuntimeGpuExecutableProto::release_xla_runtime_executable() {
+  
+  ::xla::XlaRuntimeExecutableProto* temp = _impl_.xla_runtime_executable_;
+  _impl_.xla_runtime_executable_ = 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::XlaRuntimeExecutableProto* XlaRuntimeGpuExecutableProto::unsafe_arena_release_xla_runtime_executable() {
+  // @@protoc_insertion_point(field_release:xla.gpu.XlaRuntimeGpuExecutableProto.xla_runtime_executable)
+  
+  ::xla::XlaRuntimeExecutableProto* temp = _impl_.xla_runtime_executable_;
+  _impl_.xla_runtime_executable_ = nullptr;
+  return temp;
+}
+inline ::xla::XlaRuntimeExecutableProto* XlaRuntimeGpuExecutableProto::_internal_mutable_xla_runtime_executable() {
+  
+  if (_impl_.xla_runtime_executable_ == nullptr) {
+    auto* p = CreateMaybeMessage<::xla::XlaRuntimeExecutableProto>(GetArenaForAllocation());
+    _impl_.xla_runtime_executable_ = p;
+  }
+  return _impl_.xla_runtime_executable_;
+}
+inline ::xla::XlaRuntimeExecutableProto* XlaRuntimeGpuExecutableProto::mutable_xla_runtime_executable() {
+  ::xla::XlaRuntimeExecutableProto* _msg = _internal_mutable_xla_runtime_executable();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.xla_runtime_executable)
+  return _msg;
+}
+inline void XlaRuntimeGpuExecutableProto::set_allocated_xla_runtime_executable(::xla::XlaRuntimeExecutableProto* xla_runtime_executable) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.xla_runtime_executable_);
+  }
+  if (xla_runtime_executable) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(xla_runtime_executable));
+    if (message_arena != submessage_arena) {
+      xla_runtime_executable = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, xla_runtime_executable, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.xla_runtime_executable_ = xla_runtime_executable;
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.xla_runtime_executable)
+}
+
+// .xla.EntryFunctionAttributes entry_func_attrs = 2;
+inline bool XlaRuntimeGpuExecutableProto::_internal_has_entry_func_attrs() const {
+  return this != internal_default_instance() && _impl_.entry_func_attrs_ != nullptr;
+}
+inline bool XlaRuntimeGpuExecutableProto::has_entry_func_attrs() const {
+  return _internal_has_entry_func_attrs();
+}
+inline const ::xla::EntryFunctionAttributes& XlaRuntimeGpuExecutableProto::_internal_entry_func_attrs() const {
+  const ::xla::EntryFunctionAttributes* p = _impl_.entry_func_attrs_;
+  return p != nullptr ? *p : reinterpret_cast<const ::xla::EntryFunctionAttributes&>(
+      ::xla::_EntryFunctionAttributes_default_instance_);
+}
+inline const ::xla::EntryFunctionAttributes& XlaRuntimeGpuExecutableProto::entry_func_attrs() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.entry_func_attrs)
+  return _internal_entry_func_attrs();
+}
+inline void XlaRuntimeGpuExecutableProto::unsafe_arena_set_allocated_entry_func_attrs(
+    ::xla::EntryFunctionAttributes* entry_func_attrs) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entry_func_attrs_);
+  }
+  _impl_.entry_func_attrs_ = entry_func_attrs;
+  if (entry_func_attrs) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.entry_func_attrs)
+}
+inline ::xla::EntryFunctionAttributes* XlaRuntimeGpuExecutableProto::release_entry_func_attrs() {
+  
+  ::xla::EntryFunctionAttributes* temp = _impl_.entry_func_attrs_;
+  _impl_.entry_func_attrs_ = 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::EntryFunctionAttributes* XlaRuntimeGpuExecutableProto::unsafe_arena_release_entry_func_attrs() {
+  // @@protoc_insertion_point(field_release:xla.gpu.XlaRuntimeGpuExecutableProto.entry_func_attrs)
+  
+  ::xla::EntryFunctionAttributes* temp = _impl_.entry_func_attrs_;
+  _impl_.entry_func_attrs_ = nullptr;
+  return temp;
+}
+inline ::xla::EntryFunctionAttributes* XlaRuntimeGpuExecutableProto::_internal_mutable_entry_func_attrs() {
+  
+  if (_impl_.entry_func_attrs_ == nullptr) {
+    auto* p = CreateMaybeMessage<::xla::EntryFunctionAttributes>(GetArenaForAllocation());
+    _impl_.entry_func_attrs_ = p;
+  }
+  return _impl_.entry_func_attrs_;
+}
+inline ::xla::EntryFunctionAttributes* XlaRuntimeGpuExecutableProto::mutable_entry_func_attrs() {
+  ::xla::EntryFunctionAttributes* _msg = _internal_mutable_entry_func_attrs();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.entry_func_attrs)
+  return _msg;
+}
+inline void XlaRuntimeGpuExecutableProto::set_allocated_entry_func_attrs(::xla::EntryFunctionAttributes* entry_func_attrs) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.entry_func_attrs_);
+  }
+  if (entry_func_attrs) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(entry_func_attrs));
+    if (message_arena != submessage_arena) {
+      entry_func_attrs = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, entry_func_attrs, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.entry_func_attrs_ = entry_func_attrs;
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.entry_func_attrs)
+}
+
+// string gpu_asm_text = 3;
+inline void XlaRuntimeGpuExecutableProto::clear_gpu_asm_text() {
+  _impl_.gpu_asm_text_.ClearToEmpty();
+}
+inline const std::string& XlaRuntimeGpuExecutableProto::gpu_asm_text() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_asm_text)
+  return _internal_gpu_asm_text();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void XlaRuntimeGpuExecutableProto::set_gpu_asm_text(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.gpu_asm_text_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_asm_text)
+}
+inline std::string* XlaRuntimeGpuExecutableProto::mutable_gpu_asm_text() {
+  std::string* _s = _internal_mutable_gpu_asm_text();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_asm_text)
+  return _s;
+}
+inline const std::string& XlaRuntimeGpuExecutableProto::_internal_gpu_asm_text() const {
+  return _impl_.gpu_asm_text_.Get();
+}
+inline void XlaRuntimeGpuExecutableProto::_internal_set_gpu_asm_text(const std::string& value) {
+  
+  _impl_.gpu_asm_text_.Set(value, GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto::_internal_mutable_gpu_asm_text() {
+  
+  return _impl_.gpu_asm_text_.Mutable(GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto::release_gpu_asm_text() {
+  // @@protoc_insertion_point(field_release:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_asm_text)
+  return _impl_.gpu_asm_text_.Release();
+}
+inline void XlaRuntimeGpuExecutableProto::set_allocated_gpu_asm_text(std::string* gpu_asm_text) {
+  if (gpu_asm_text != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.gpu_asm_text_.SetAllocated(gpu_asm_text, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.gpu_asm_text_.IsDefault()) {
+    _impl_.gpu_asm_text_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_asm_text)
+}
+
+// bytes gpu_binary = 4;
+inline void XlaRuntimeGpuExecutableProto::clear_gpu_binary() {
+  _impl_.gpu_binary_.ClearToEmpty();
+}
+inline const std::string& XlaRuntimeGpuExecutableProto::gpu_binary() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_binary)
+  return _internal_gpu_binary();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void XlaRuntimeGpuExecutableProto::set_gpu_binary(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.gpu_binary_.SetBytes(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_binary)
+}
+inline std::string* XlaRuntimeGpuExecutableProto::mutable_gpu_binary() {
+  std::string* _s = _internal_mutable_gpu_binary();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_binary)
+  return _s;
+}
+inline const std::string& XlaRuntimeGpuExecutableProto::_internal_gpu_binary() const {
+  return _impl_.gpu_binary_.Get();
+}
+inline void XlaRuntimeGpuExecutableProto::_internal_set_gpu_binary(const std::string& value) {
+  
+  _impl_.gpu_binary_.Set(value, GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto::_internal_mutable_gpu_binary() {
+  
+  return _impl_.gpu_binary_.Mutable(GetArenaForAllocation());
+}
+inline std::string* XlaRuntimeGpuExecutableProto::release_gpu_binary() {
+  // @@protoc_insertion_point(field_release:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_binary)
+  return _impl_.gpu_binary_.Release();
+}
+inline void XlaRuntimeGpuExecutableProto::set_allocated_gpu_binary(std::string* gpu_binary) {
+  if (gpu_binary != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.gpu_binary_.SetAllocated(gpu_binary, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.gpu_binary_.IsDefault()) {
+    _impl_.gpu_binary_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.XlaRuntimeGpuExecutableProto.gpu_binary)
+}
+
+// repeated .xla.gpu.XlaRuntimeGpuExecutableProto.ConstantInfoProto constants = 5;
+inline int XlaRuntimeGpuExecutableProto::_internal_constants_size() const {
+  return _impl_.constants_.size();
+}
+inline int XlaRuntimeGpuExecutableProto::constants_size() const {
+  return _internal_constants_size();
+}
+inline void XlaRuntimeGpuExecutableProto::clear_constants() {
+  _impl_.constants_.Clear();
+}
+inline ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* XlaRuntimeGpuExecutableProto::mutable_constants(int index) {
+  // @@protoc_insertion_point(field_mutable:xla.gpu.XlaRuntimeGpuExecutableProto.constants)
+  return _impl_.constants_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto >*
+XlaRuntimeGpuExecutableProto::mutable_constants() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.XlaRuntimeGpuExecutableProto.constants)
+  return &_impl_.constants_;
+}
+inline const ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto& XlaRuntimeGpuExecutableProto::_internal_constants(int index) const {
+  return _impl_.constants_.Get(index);
+}
+inline const ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto& XlaRuntimeGpuExecutableProto::constants(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.XlaRuntimeGpuExecutableProto.constants)
+  return _internal_constants(index);
+}
+inline ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* XlaRuntimeGpuExecutableProto::_internal_add_constants() {
+  return _impl_.constants_.Add();
+}
+inline ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* XlaRuntimeGpuExecutableProto::add_constants() {
+  ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto* _add = _internal_add_constants();
+  // @@protoc_insertion_point(field_add:xla.gpu.XlaRuntimeGpuExecutableProto.constants)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::XlaRuntimeGpuExecutableProto_ConstantInfoProto >&
+XlaRuntimeGpuExecutableProto::constants() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.XlaRuntimeGpuExecutableProto.constants)
+  return _impl_.constants_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace gpu
+}  // namespace xla
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fexecutable_2eproto

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fft_thunk.h

@@ -0,0 +1,100 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_FFT_THUNK_H_
+#define XLA_SERVICE_GPU_FFT_THUNK_H_
+
+#include <optional>
+
+#include "absl/container/flat_hash_map.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace gpu {
+
+struct FftPlan {
+  // CuFFT thread-safety requires that separate host threads not share plans;
+  // protect each plan with a mutex.
+  absl::Mutex mu;
+  std::unique_ptr<se::fft::Plan> plan ABSL_GUARDED_BY(mu);
+  float scale_factor ABSL_GUARDED_BY(mu);
+};
+
+class FftPlanCache {
+ public:
+  // Returnes Fft plan cached for the given device ordinal or creates a new one.
+  FftPlan* GetOrCreate(int device_ordinal) {
+    absl::MutexLock lock(&mu_);
+    std::unique_ptr<FftPlan>& plan = fft_plans_[device_ordinal];
+    if (!plan) plan = std::make_unique<FftPlan>();
+    return plan.get();
+  }
+
+ private:
+  absl::Mutex mu_;
+  absl::flat_hash_map<int, std::unique_ptr<FftPlan>> fft_plans_
+      ABSL_GUARDED_BY(mu_);
+};
+
+// This class stores everything that StreamExecutor needs to launch an FFT.
+// It is generated by IrEmitter.
+//
+// This is thread-compatible.
+class FftThunk : public Thunk {
+ public:
+  // Constructs a thunk for launching an FFT on a stream.
+  // Semantics of null hlo_instruction argument are as in Thunk.
+  FftThunk(ThunkInfo thunk_info, FftType fft_type,
+           absl::Span<const int64_t> fft_length,
+           const BufferAllocation::Slice& input_buffer,
+           const BufferAllocation::Slice& output_buffer,
+           const Shape& input_shape, const Shape& output_shape);
+
+  FftThunk(const FftThunk&) = delete;             // Cannot share fft_plan_
+  FftThunk& operator=(const FftThunk&) = delete;  // Cannot share fft_plan_
+
+  // Does the FFT for the thunk on "stream".
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  const se::fft::Type fft_type_;
+  const std::vector<int64_t> fft_length_;
+
+  FftPlanCache fft_plan_cache_;
+
+  const BufferAllocation::Slice input_buffer_;
+  const BufferAllocation::Slice output_buffer_;
+
+  const Shape input_shape_;
+  const Shape output_shape_;
+};
+
+Status RunFft(se::DeviceMemoryBase input, const Shape& input_shape,
+              se::DeviceMemoryBase output, const Shape& output_shape,
+              se::fft::Type fft_type, absl::Span<const int64_t> fft_length,
+              int device_ordinal, FftPlanCache* fft_plan_cache,
+              se::Stream* stream, se::DeviceMemoryAllocator* memory_allocator);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FFT_THUNK_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/for_thunk.h

@@ -0,0 +1,52 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_FOR_THUNK_H_
+#define XLA_SERVICE_GPU_FOR_THUNK_H_
+
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/sequential_thunk.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// ForThunk executes 'loop_limit' invocations of 'body_thunk_sequence'.
+class ForThunk : public Thunk {
+ public:
+  ForThunk(ThunkInfo thunk_info, int64_t loop_limit,
+           std::unique_ptr<ThunkSequence> body_thunk_sequence);
+  ForThunk(const ForThunk&) = delete;
+  ForThunk& operator=(const ForThunk&) = delete;
+
+  Status Initialize(const GpuExecutable& executable,
+                    se::StreamExecutor* executor) override;
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+  SequentialThunk* body_thunk_sequence() { return body_thunk_sequence_.get(); }
+
+ private:
+  const int64_t loop_limit_;
+  std::unique_ptr<SequentialThunk> body_thunk_sequence_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FOR_THUNK_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fused_mha_thunk.h

@@ -0,0 +1,129 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_FUSED_MHA_THUNK_H_
+#define XLA_SERVICE_GPU_FUSED_MHA_THUNK_H_
+
+#include <memory>
+#include <optional>
+
+#include "absl/container/flat_hash_map.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/buffer_allocations.h"
+#include "xla/service/gpu/gpu_executable.h"
+#include "xla/service/gpu/gpu_fused_mha_runner.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/stream_executor/stream_executor.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+#include "tsl/platform/status.h"
+
+namespace xla {
+namespace gpu {
+
+// This class stores everything that StreamExecutor needs to launch a DNN
+// fMHA. It is generated by IrEmitter.
+//
+// This is thread-compatible.
+class FusedMHAThunk : public Thunk {
+ public:
+  // Constructs a thunk for launching a DNN FMHA.
+  FusedMHAThunk(ThunkInfo thunk_info, GpufMHAConfig config,
+                BufferAllocation::Slice lhs_bmm1_slice,
+                BufferAllocation::Slice rhs_bmm1_slice,
+                BufferAllocation::Slice rhs_bmm2_slice,
+                BufferAllocation::Slice output_slice,
+                BufferAllocation::Slice scratch_slice,
+                BufferAllocation::Slice mask_slice, /* may be null */
+                BufferAllocation::Slice bias_slice /* may be null */,
+                BufferAllocation::Slice activation_slice /* may be null */);
+
+  FusedMHAThunk(const FusedMHAThunk&) = delete;
+  FusedMHAThunk& operator=(const FusedMHAThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  BufferAllocation::Slice lhs_bmm1_buffer_;
+  BufferAllocation::Slice rhs_bmm1_buffer_;
+  BufferAllocation::Slice rhs_bmm2_buffer_;
+  BufferAllocation::Slice output_buffer_;
+  BufferAllocation::Slice scratch_buffer_;
+  BufferAllocation::Slice mask_buffer_;
+  BufferAllocation::Slice bias_buffer_;
+  BufferAllocation::Slice activation_buffer_;
+
+  FusedMultiHeadedAttentionRunner& GetOrCreateRunner(
+      const stream_executor::Stream* stream);
+
+  // FusedMHA config
+  const GpufMHAConfig config_;
+  absl::Mutex mu_;
+  absl::flat_hash_map<const stream_executor::Stream*,
+                      std::unique_ptr<FusedMultiHeadedAttentionRunner>>
+      runner_cache_ ABSL_GUARDED_BY(mu_);
+};
+
+class FusedMHABackwardThunk : public Thunk {
+ public:
+  // Constructs a thunk for launching a DNN FMHA backward.
+  FusedMHABackwardThunk(ThunkInfo thunk_info, GpufMHABackwardConfig config,
+                        BufferAllocation::Slice bmm1_grad_gemm1_rhs_slice,
+                        BufferAllocation::Slice bmm1_grad_gemm2_rhs_slice,
+                        BufferAllocation::Slice bmm2_grad_gemm1_lhs_slice,
+                        BufferAllocation::Slice bmm2_grad_gemm2_rhs_slice,
+                        BufferAllocation::Slice d_output_slice,
+                        BufferAllocation::Slice scratch_slice,
+                        BufferAllocation::Slice d_bmm1_lhs_slice,
+                        BufferAllocation::Slice d_bmm1_rhs_slice,
+                        BufferAllocation::Slice d_bmm2_rhs_slice,
+                        BufferAllocation::Slice d_S_slice,
+                        BufferAllocation::Slice mask_slice,
+                        BufferAllocation::Slice d_bias_slice);
+
+  FusedMHABackwardThunk(const FusedMHABackwardThunk&) = delete;
+  FusedMHABackwardThunk& operator=(const FusedMHABackwardThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+
+ private:
+  BufferAllocation::Slice bmm1_grad_gemm1_rhs_buffer_;
+  BufferAllocation::Slice bmm1_grad_gemm2_rhs_buffer_;
+  BufferAllocation::Slice bmm2_grad_gemm1_lhs_buffer_;
+  BufferAllocation::Slice bmm2_grad_gemm2_rhs_buffer_;
+  BufferAllocation::Slice d_output_buffer_;
+  BufferAllocation::Slice scratch_buffer_;
+  BufferAllocation::Slice d_bmm1_lhs_buffer_;
+  BufferAllocation::Slice d_bmm1_rhs_buffer_;
+  BufferAllocation::Slice d_bmm2_rhs_buffer_;
+  BufferAllocation::Slice d_s_buffer_;
+  BufferAllocation::Slice mask_buffer_;
+  BufferAllocation::Slice d_bias_buffer_;
+
+  FusedMultiHeadedAttentionBackwardRunner& GetOrCreateRunner(
+      const stream_executor::Stream* stream);
+
+  // FusedMHA backward config
+  const GpufMHABackwardConfig config_;
+  absl::Mutex mu_;
+  absl::flat_hash_map<const stream_executor::Stream*,
+                      std::unique_ptr<FusedMultiHeadedAttentionBackwardRunner>>
+      runner_cache_ ABSL_GUARDED_BY(mu_);
+};
+}  // namespace gpu
+}  // namespace xla
+#endif  // XLA_SERVICE_GPU_FUSED_MHA_THUNK_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusion_merger.h

@@ -0,0 +1,82 @@
+/* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_FUSION_MERGER_H_
+#define XLA_SERVICE_GPU_FUSION_MERGER_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/gpu/gpu_hlo_cost_analysis.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+// An HLO pass that attempts to merge fusion instructions to reduce memory
+// bandwidth requirements and kernel launch overhead.
+//
+// Consider the example below. On the left-hand side, op A is the producer and
+// ops B and C are its consumers. FusionMerger duplicates producer ops and fuses
+// them into all consumers. The result is depicted on the right-hand side below.
+//
+//        p                    p
+//        |                  /   \
+//        v                 /     \
+//        A            +fusion+  +fusion+
+//      /   \          |  A'  |  |  A"  |
+//     |     |         |  |   |  |  |   |
+//     v     v         |  v   |  |  v   |
+//     B     C         |  B   |  |  C   |
+//                     +------+  +------+
+//
+// Op A has been cloned twice and fused with B and C. The kernel launch overhead
+// is reduced from 3 to 2. The memory bandwidth requirements may be reduced.
+// We trade 1 read of input(A) + 1 write and 2 reads of output(A) for 2 reads of
+// input(A). In general the achieveable savings in memory bandwidth depend on
+// the differences in memory read and written and the number of consumers. The
+// FusionMeger pass takes this into account when making fusion decisions.
+//
+// The pass traverses the HLO module in reverse post-order (defs before uses).
+// Fusion instructions are merged into their users if some conditions are met:
+// * The result of merging the fusion instruction into its users would not
+//   increase bytes transferred.
+// * Producer ops are fusible with _all_ consumers. If they are not fusible with
+//   at least one consumers, they won't be fused at all.
+// * Producers are kLoop fusion ops.
+//
+// None of these restrictions are necessary for correctness. In fact, lifting
+// the latter two could be beneficial.
+
+class FusionMerger : public HloModulePass {
+ public:
+  explicit FusionMerger(const se::DeviceDescription& d,
+                        HloCostAnalysis::ShapeSizeFunction f)
+      : gpu_device_info_(d), shape_size_function_(f) {}
+  absl::string_view name() const override { return "fusion_merger"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  se::DeviceDescription gpu_device_info_;
+  HloCostAnalysis::ShapeSizeFunction shape_size_function_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSION_MERGER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusion_pipeline.h

@@ -0,0 +1,40 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_FUSION_PIPELINE_H_
+#define XLA_SERVICE_GPU_FUSION_PIPELINE_H_
+
+#include "xla/service/hlo_cost_analysis.h"
+#include "xla/service/hlo_pass_pipeline.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/xla.pb.h"
+
+namespace xla {
+namespace gpu {
+
+// Function wrapper around the (non-horizontal) XLA GPU fusion pipeline.
+HloPassPipeline FusionPipeline(
+    const DebugOptions& debug_options,
+    HloCostAnalysis::ShapeSizeFunction shape_size_bytes_function,
+    const se::DeviceDescription& gpu_device_info);
+
+// Function wrapper around the horizontal XLA GPU fusion pipeline.
+HloPassPipeline HorizontalFusionPipeline(
+    const se::DeviceDescription& gpu_device_info);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSION_PIPELINE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusion_wrapper.h

@@ -0,0 +1,42 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSION_WRAPPER_H_
+#define XLA_SERVICE_GPU_FUSION_WRAPPER_H_
+
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// Wraps leftover unfused instruction that are in the entry computation that
+// have no LHLO equivalent in fusions containing just that instruction.
+class FusionWrapper : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "fusion-wrapper"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSION_WRAPPER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/copy.h

@@ -0,0 +1,45 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_COPY_H_
+#define XLA_SERVICE_GPU_FUSIONS_COPY_H_
+
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/ir_emitter_context.h"
+
+namespace xla {
+namespace gpu {
+
+// Special case of a fusion consisting only of a kCopy instruction that can be
+// implemented using a memcpy.
+class MemcpyFusion : public FusionInterface {
+ public:
+  MemcpyFusion(mlir::Value src, mlir::Value dst) : src_(src), dst_(dst) {}
+
+  StatusOr<FusionEmissionResult> Emit(IrEmitterContext& ir_emitter_context,
+                                      ElementalIrEmitter& elemental_emitter,
+                                      mlir::lmhlo::FusionOp fusion_op,
+                                      const HloFusionInstruction& fusion,
+                                      KernelReuseCache& kernel_cache,
+                                      llvm::IRBuilder<>*) const final;
+
+ private:
+  mlir::Value src_;
+  mlir::Value dst_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_COPY_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/fusion_emitter.h

@@ -0,0 +1,88 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_FUSION_EMITTER_H_
+#define XLA_SERVICE_GPU_FUSIONS_FUSION_EMITTER_H_
+
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/mlir_hlo/lhlo/IR/lhlo_ops.h"
+#include "xla/service/elemental_ir_emitter.h"
+#include "xla/service/gpu/ir_emitter_context.h"
+#include "xla/service/gpu/kernel_reuse_cache.h"
+#include "xla/service/gpu/launch_dimensions.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/service/llvm_ir/ir_array.h"
+
+namespace xla {
+namespace gpu {
+
+struct FusionEmissionResult {
+  std::vector<std::unique_ptr<Thunk>> thunks;
+};
+
+class FusionInterface {
+ public:
+  virtual ~FusionInterface() = default;
+
+  virtual StatusOr<FusionEmissionResult> Emit(
+      IrEmitterContext& ir_emitter_context,
+      ElementalIrEmitter& elemental_emitter, mlir::lmhlo::FusionOp fusion_op,
+      const HloFusionInstruction& fusion, KernelReuseCache& kernel_cache,
+      llvm::IRBuilder<>* builder) const = 0;
+};
+
+class KernelFusionEmitterBase : public FusionInterface {
+ public:
+  // The downstream code that is used by this emitter operates on a mix of MLIR
+  // and HLO classes. Ideally this would not be the case, but it's hard to
+  // change.
+  StatusOr<FusionEmissionResult> Emit(IrEmitterContext& ir_emitter_context,
+                                      ElementalIrEmitter& elemental_emitter,
+                                      mlir::lmhlo::FusionOp fusion_op,
+                                      const HloFusionInstruction& fusion,
+                                      KernelReuseCache& kernel_cache,
+                                      llvm::IRBuilder<>* builder) const final;
+  virtual StatusOr<LaunchDimensions> launch_dimensions(
+      IrEmitterContext& ir_emitter_context, int kernel_index) const = 0;
+
+ protected:
+  virtual Status EmitKernel(IrEmitterContext& ir_emitter_context,
+                            ElementalIrEmitter& elemental_emitter,
+                            mlir::lmhlo::FusionOp fusion_op,
+                            const HloFusionInstruction& fusion,
+                            const LaunchDimensions& launch_dims,
+                            std::vector<llvm_ir::IrArray> inputs,
+                            std::vector<llvm_ir::IrArray> outputs,
+                            llvm::IRBuilder<>* builder,
+                            int kernel_index) const = 0;
+  virtual int num_kernels() const { return 1; }
+};
+
+std::tuple<llvm::Function*, std::vector<llvm_ir::IrArray /*inputs*/>,
+           std::vector<llvm_ir::IrArray> /*outputs*/>
+BuildKernelPrototype(IrEmitterContext& ir_emitter_context,
+                     const std::string& suggested_name,
+                     absl::Span<const KernelArgument> arguments,
+                     size_t num_inputs,
+                     const LaunchDimensions& launch_dimensions,
+                     llvm::IRBuilder<>* builder);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_FUSION_EMITTER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/fusions.h

@@ -0,0 +1,41 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_FUSIONS_H_
+#define XLA_SERVICE_GPU_FUSIONS_FUSIONS_H_
+
+#include <memory>
+#include <optional>
+
+#include "absl/types/span.h"
+#include "xla/mlir_hlo/lhlo/IR/lhlo_ops.h"
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+
+namespace xla {
+namespace gpu {
+
+// Returns the emitter for the given fusion. Returns nullopt if the fusion
+// type is not yet supported.
+// `allocations` may be empty and `fusion_op` may be nullptr if buffer
+// assignment didn't run yet.
+std::optional<std::unique_ptr<FusionInterface>> GetFusionEmitter(
+    HloFusionAnalysis& analysis, absl::Span<const BufferAllocation> allocations,
+    mlir::lmhlo::FusionOp fusion_op);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_FUSIONS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/in_place_dynamic_update_slice.h

@@ -0,0 +1,77 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_IN_PLACE_DYNAMIC_UPDATE_SLICE_H_
+#define XLA_SERVICE_GPU_FUSIONS_IN_PLACE_DYNAMIC_UPDATE_SLICE_H_
+
+#include <vector>
+
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+#include "xla/service/gpu/ir_emission_utils.h"
+
+namespace xla {
+namespace gpu {
+
+// Fusion node where the root is either:
+// 1. a dynamic-update-slice op
+// 2. a bitcast of a dynamic-update-slice op
+// 3. a tuple op returning the result of several dynamic-update-slice ops
+// 4. a tuple op returning the result of several bitcast
+//    dynamic-update-slice ops
+//
+// Additionally, all the dynamic-update-slice ops have exactly one user. The
+// fusion parameter that they update can have users (in addition to the
+// dynamic-update-slice op) that read in either
+// a. a dynamic-slice corresponding exactly to the slice of the parameter that
+//    is updated by the dynamic-update-slice op
+// b. a dynamic-slice reading in a single element anywhere in the parameter.
+//    This is only allowed if the dynamic-update-slice op updates a single
+//    element
+//
+// In both cases, the additional users must not flow into any other output
+// than the dynamic-slice-update corresponding to that particular slice of the
+// parameter.
+//
+// The assumption is that each op's input (i.e. array to update) shares the
+// same slice as its output. In this case, we have a special algorithm that
+// modifies the output in place without touching the un-updated elements. The
+// update slice is assumed to be the exact same for all the
+// dynamic-update-slice ops.
+class InPlaceDynamicUpdateSliceEmitter : public KernelFusionEmitterBase {
+ public:
+  explicit InPlaceDynamicUpdateSliceEmitter(const HloFusionAnalysis& analysis)
+      : dus_ops_(
+            GetOutputDefiningDynamicUpdateSlices(analysis.fusion_roots())) {}
+  StatusOr<LaunchDimensions> launch_dimensions(
+      IrEmitterContext& ir_emitter_context, int kernel_index) const override;
+
+ protected:
+  Status EmitKernel(IrEmitterContext& ir_emitter_context,
+                    ElementalIrEmitter& elemental_emitter,
+                    mlir::lmhlo::FusionOp fusion_op,
+                    const HloFusionInstruction& fusion,
+                    const LaunchDimensions& launch_dims,
+                    std::vector<llvm_ir::IrArray> inputs,
+                    std::vector<llvm_ir::IrArray> outputs,
+                    llvm::IRBuilder<>* builder,
+                    int kernel_index) const override;
+
+  std::vector<const HloInstruction*> dus_ops_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_IN_PLACE_DYNAMIC_UPDATE_SLICE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/input_slices.h

@@ -0,0 +1,58 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_INPUT_SLICES_H_
+#define XLA_SERVICE_GPU_FUSIONS_INPUT_SLICES_H_
+
+#include <vector>
+
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+
+namespace xla {
+namespace gpu {
+
+// Generates code for input-fusible slices.
+//
+// Prerequisite: ROOT is either a slice or a tuple of slices. The input shapes
+// of all ROOT slices need to be the same while their output shapes can be
+// different. On the other hand, the input ranges of slices can be
+// overlapping. Further generalization/specialization when the needs are seen
+// in the future.
+class InputSlicesFusion : public KernelFusionEmitterBase {
+ public:
+  explicit InputSlicesFusion(HloFusionAnalysis& analysis)
+      : analysis_(analysis) {}
+  StatusOr<LaunchDimensions> launch_dimensions(
+      IrEmitterContext& ir_emitter_context, int kernel_index) const override;
+
+ protected:
+  Status EmitKernel(IrEmitterContext& ir_emitter_context,
+                    ElementalIrEmitter& elemental_emitter,
+                    mlir::lmhlo::FusionOp fusion_op,
+                    const HloFusionInstruction& fusion,
+                    const LaunchDimensions& launch_dims,
+                    std::vector<llvm_ir::IrArray> inputs,
+                    std::vector<llvm_ir::IrArray> outputs,
+                    llvm::IRBuilder<>* builder,
+                    int kernel_index) const override;
+
+ private:
+  HloFusionAnalysis& analysis_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_INPUT_SLICES_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/loop.h

@@ -0,0 +1,55 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_LOOP_H_
+#define XLA_SERVICE_GPU_FUSIONS_LOOP_H_
+
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/mlir_hlo/lhlo/IR/lhlo_ops.h"
+#include "xla/service/elemental_ir_emitter.h"
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+#include "xla/service/gpu/ir_emitter_context.h"
+
+namespace xla {
+namespace gpu {
+
+// Generic loop fusion.
+class LoopFusion : public KernelFusionEmitterBase {
+ public:
+  explicit LoopFusion(HloFusionAnalysis& analysis) : analysis_(analysis) {}
+  StatusOr<LaunchDimensions> launch_dimensions(
+      IrEmitterContext& ir_emitter_context, int kernel_index) const override;
+
+ protected:
+  Status EmitKernel(IrEmitterContext& ir_emitter_context,
+                    ElementalIrEmitter& elemental_emitter,
+                    mlir::lmhlo::FusionOp fusion_op,
+                    const HloFusionInstruction& fusion,
+                    const LaunchDimensions& launch_dims,
+                    std::vector<llvm_ir::IrArray> inputs,
+                    std::vector<llvm_ir::IrArray> outputs,
+                    llvm::IRBuilder<>* builder,
+                    int kernel_index) const override;
+
+ private:
+  HloFusionAnalysis& analysis_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_LOOP_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/reduction.h

@@ -0,0 +1,107 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_REDUCTION_H_
+#define XLA_SERVICE_GPU_FUSIONS_REDUCTION_H_
+
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+
+namespace xla {
+namespace gpu {
+
+// Generates code for reduction to contiguous dimensions.
+//
+// Row reduction uses the following algorithm described in CUDA-like
+// pseudocode:
+//
+// ```
+//  __global__ void reduce(int num_rows, float *in, float out) {
+//    __shared__ float[32] cache;
+//    int offset = blockDim.x * blockIdx.x + threadIdx.x;
+//    if (offset >= num_rows) return;
+//    int tile_bound = std::min(offset + kTileSizeX, num_rows);
+//    float accum = 0;
+//    for (int i=offset; i<num_rows; i+= blockDim.x) {
+//      accum += in[i];
+//    }
+//    accum = warp_reduce(accum);
+//    if (threadIdx.x % WarpSize == 0) {
+//      cache[threadIdx.x / WarpSize] = accum;
+//    }
+//    __syncthreads();
+//    if (threadIdx.x / WarpSize == 0) {
+//      bool warp_exists = threadIdx.x < (blockDim.x / WarpSize);
+//      float block_accum = warp_exists ? cache[threadIdx.x % WarpSize] : 0;
+//      block_accum = warp_reduce(accum);
+//      if (threadIdx.x == 0) {
+//        out += block_accum;
+//      }
+//    }
+//  }
+// ```
+//
+// Column reduction uses the following algorithm:
+//
+// ```
+// void reduce(float** in, float* out) {
+//   __shared__ float[32][33] cache;
+//   int thread_id = GetThreadId();
+//   int block_id = GetBlockId();
+//   int tile_size = 128;
+//
+//   float accum = 0;
+//   for (int i=0; i<tile_size; i++) {
+//     accum += in[thread_id.y * tile_size + i][block_id * 32 + thread_id.x];
+//   }
+//   cache[thread_id.x][thread_id.y] = accum;
+//
+//   __syncthreads();
+//   accum = cache[thread_id.y][thread_id.x];
+//   accum = warp_reduce(accum); // Sum all the values of `accum` in the same
+//                               // warp.
+//
+//   if (thread_id.y % 32 == 0) {
+//     out[block_id * 32 + thread_id.x] = accum;
+//   }
+// }
+// ```
+//
+// Moreover, a heuristic is implemented to divide the reduce instructions
+// into groups for parallelization (see `DivideOutputInstructionsIntoGroups`
+// for details about the heuristic.) Reduce instructions in the same group
+// will run sequentially while different groups will run in parallel.
+//
+// we use raw block_id_y to select the reduce groups for execution without
+// complicating the index calculation in the code generation of the reduce
+// instructions. In other words, a block_id_y is assigned to a group and so
+// different groups can be run in parallel.
+class ReductionFusion : public FusionInterface {
+ public:
+  explicit ReductionFusion(HloFusionAnalysis& analysis) : analysis_(analysis) {}
+
+  StatusOr<FusionEmissionResult> Emit(
+      IrEmitterContext& ir_emitter_context,
+      ElementalIrEmitter& elemental_emitter, mlir::lmhlo::FusionOp fusion_op,
+      const HloFusionInstruction& fusion, KernelReuseCache& kernel_cache,
+      llvm::IRBuilder<>* builder) const override;
+
+ private:
+  HloFusionAnalysis& analysis_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_REDUCTION_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/thunk_util.h

@@ -0,0 +1,37 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_THUNK_UTIL_H_
+#define XLA_SERVICE_GPU_FUSIONS_THUNK_UTIL_H_
+
+#include <memory>
+#include <optional>
+
+#include "xla/service/gpu/ir_emitter_context.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/statusor.h"
+
+namespace xla {
+namespace gpu {
+
+// Attempts to build an initializer constant for the given value. Returns an
+// empty optional if the value is not a constant.
+StatusOr<std::optional<std::unique_ptr<Thunk>>> BuildConstantInitializerThunk(
+    IrEmitterContext& ir_emitter_context, mlir::Operation* op,
+    mlir::Value init_value, mlir::Value dest);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_THUNK_UTIL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/tiling_util.h

@@ -0,0 +1,149 @@
+/*Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_TILING_UTIL_H_
+#define XLA_SERVICE_GPU_FUSIONS_TILING_UTIL_H_
+
+#include <functional>
+
+#include "xla/service/gpu/kernel_mapping_scheme.h"
+#include "xla/service/llvm_ir/ir_array.h"
+
+namespace xla {
+namespace gpu {
+
+// Contains threading information. Note that for performance we might apply
+// thread id "scaling" where the physical thread id (to achieve good SM
+// occupancy) will differ from logical thread id. This struct contains
+// logical thread ids, along with meta-information about the scaling applied.
+struct TilingThreadIdInfo {
+  TilingThreadIdInfo(llvm::Value* thread_id, llvm::Value* thread_id_x,
+                     llvm::Value* thread_id_y, llvm::Value* lane_id,
+                     llvm::Value* block_id, llvm::Value* scaling)
+      : thread_id(thread_id),
+        thread_id_x(thread_id_x),
+        thread_id_y(thread_id_y),
+        lane_id(lane_id),
+        block_id(block_id),
+        scaling(scaling) {}
+
+  llvm::Value* thread_id;
+
+  // X-coordinate calculated from thread id: `thread_id % num_threads_x`
+  llvm::Value* thread_id_x;
+
+  // Y-coordinate calculated from thread id: `thread_id / num_threads_x`
+  llvm::Value* thread_id_y;
+
+  // Lane id: `thread_id % WarpSize`
+  llvm::Value* lane_id;
+
+  // Block id.
+  llvm::Value* block_id;
+
+  // Emits GEP into a shared memory, taking virtual thread scaling into
+  // account. Automatically inserts the first zero required by LLVM GEP.
+  // Defined on ThreadIdInfo to keep `scaling` private.
+  //
+  // Same semantics as CreateInBoundsGEP.
+  llvm::Value* GEPIntoSharedMemory(
+      llvm::IRBuilder<>* b, llvm::GlobalVariable* shared,
+      absl::Span<llvm::Value* const> idx_major_to_minor,
+      const llvm::Twine& name = "") const;
+
+  // Calculate the pointee type of the llvm::Value returned by
+  // GEPIntoSharedMemory
+  llvm::Type* GEPIntoSharedMemoryType(
+      llvm::GlobalVariable* shared,
+      absl::Span<llvm::Value* const> idx_major_to_minor) const;
+
+ private:
+  llvm::Value* scaling;
+};
+
+struct TilingKernelInfo {
+  // Tiling bounds.
+  std::array<llvm::Value*, 2> output_tile_bounds;
+
+  // Starting tile, as calculated from block id only.
+  llvm_ir::IrArray::Index tile_origin;
+
+  // Thread meta-info.
+  TilingThreadIdInfo thread_id_info;
+};
+
+// A function to generate the code to emit the entire tile.
+//
+// index: Absolute coordinate of the start of the tile in input.
+// tile_dimensions: Size of the tile
+using TileElementGenerator =
+    std::function<void(const TilingThreadIdInfo& thread_id_info,
+                       const llvm_ir::IrArray::Index& index,
+                       std::array<llvm::Value*, 2> tile_dimensions)>;
+
+// A function object to generate code to process one element in a tile.
+//
+// index: the index for the first output element of the current thread.
+// y_loc: The y coordinate within a tile.
+// x_loc: The x coordinate within a tile.
+using EmitTileElementFunction =
+    std::function<void(const TilingThreadIdInfo& thread_id_info,
+                       const llvm_ir::IrArray::Index& index, llvm::Value* y_loc,
+                       llvm::Value* x_loc)>;
+
+// Emits code to iterate through a 2-dimensional tile with a given tile
+// dimensions and given strides, and call the callback at each iteration.,
+//
+// thread_id_y` and `thread_id_x` are the intra-tile coordinates for
+// the first element to process, and `index` is the index for the origin of
+// the tile. Emits bounds check to ensure that each processed element
+// is within the boundary defined by `tile_dimensions`.
+//
+// Rough pseudocode:
+//
+// Given: tile_dimensions, x_offset, y_offset
+//
+// for (y = 0; y < tile_dimensions[0]; y += num_threads_y) {
+//   for (x = 0; x < tile_dimensions[1]; x++) {
+//
+//     y_pos = y_offset + y
+//     x_pos = x_offset + x * stride
+//
+//     if (x_loc < tile_width) {
+//       emit_elem_function(y_offset + y, x_loc);
+//     }
+//   }
+// }
+//
+void EmitTile(llvm::IRBuilder<>* builder, const TilingScheme& tiling_scheme,
+              const llvm_ir::IrArray::Index& tile_origin_index,
+              const TilingThreadIdInfo& thread_id_info,
+              std::array<llvm::Value*, 2> tile_dimensions,
+              const EmitTileElementFunction& emit_elem_function);
+
+// Emits a kernel for the hlo instruction using the given kernel mapping
+// scheme.
+StatusOr<TilingKernelInfo> EmitTilingKernel(
+    llvm::IRBuilder<>* builder, const TilingScheme& tiling_scheme,
+    llvm::Type* index_ty, const TileElementGenerator& tile_element_generator);
+
+llvm_ir::IrArray::Index GetUnnormalizedIndex(
+    const llvm_ir::IrArray::Index& normalized_shape_index,
+    const Shape& unnormalized_shape, llvm::IRBuilder<>* builder,
+    absl::Span<const int64_t> dims_in_elems);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_TILING_UTIL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/fusions/transpose.h

@@ -0,0 +1,79 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_FUSIONS_TRANSPOSE_H_
+#define XLA_SERVICE_GPU_FUSIONS_TRANSPOSE_H_
+
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/mlir_hlo/lhlo/IR/lhlo_ops.h"
+#include "xla/service/elemental_ir_emitter.h"
+#include "xla/service/gpu/fusions/fusion_emitter.h"
+#include "xla/service/gpu/hlo_fusion_analysis.h"
+#include "xla/service/gpu/ir_emitter_context.h"
+
+namespace xla {
+namespace gpu {
+
+// Emits a kernel for the given hlo instruction using a tiled 0-2-1 transpose
+// algorithm to improve the memory access patterns for the input parameters
+// with a shape that is a 0-2-1 transpose of the output tensor shape. The
+// caller is responsible for making sure that it is safe to apply the shared
+// memory transpose on the input parameters.
+//
+// For the purpose of tiling, the output tensors have a logical shape of three
+// components 0-2-1 while the relevant input parameters have a logical shape
+// of three components 0-1-2 in the order major to minor. The x- and y-
+// dimensions of the tensors are tiled in square tiles with an edge length
+// `kTileSize`. Each thread block of `kTileSize` x `kNumRows` threads
+// transposes one tile: each thread copies kTileSize/kNumRows elements from
+// the input to a shared memory tile, then the otherwise "regular HLO kernel"
+// reads from the shared memory instead of the original input.
+//
+// This is similar to the following CUDA algorithm in TensorFlow:
+// https://goo.gl/MStRV6.
+//
+// `kTileSize` should usually be same as warp size. We currently choose 32 for
+// `kTileSize` and 4 for `kNumRows`. The CUDA algorithm uses 8 for `kNumRows`.
+//
+// TODO(b/33320379): Here each block transposes 1 tile. It may be more
+// efficient to launch fewer blocks so each transposes many tiles.
+class TransposeFusion : public KernelFusionEmitterBase {
+ public:
+  explicit TransposeFusion(HloFusionAnalysis& analysis) : analysis_(analysis) {}
+  StatusOr<LaunchDimensions> launch_dimensions(
+      IrEmitterContext& ir_emitter_context, int kernel_index) const override {
+    return analysis_.GetLaunchDimensions();
+  }
+
+ protected:
+  Status EmitKernel(IrEmitterContext& ir_emitter_context,
+                    ElementalIrEmitter& elemental_emitter,
+                    mlir::lmhlo::FusionOp fusion_op,
+                    const HloFusionInstruction& fusion,
+                    const LaunchDimensions& launch_dims,
+                    std::vector<llvm_ir::IrArray> inputs,
+                    std::vector<llvm_ir::IrArray> outputs,
+                    llvm::IRBuilder<>* builder,
+                    int kernel_index) const override;
+
+ private:
+  HloFusionAnalysis& analysis_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_FUSIONS_TRANSPOSE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_algorithm_picker.h

@@ -0,0 +1,78 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_GEMM_ALGORITHM_PICKER_H_
+#define XLA_SERVICE_GPU_GEMM_ALGORITHM_PICKER_H_
+
+#include <functional>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <variant>
+
+#include "absl/strings/string_view.h"
+#include "xla/autotune_results.pb.h"
+#include "xla/autotuning.pb.h"
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/gpu/autotuner_util.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/stream_executor/device_memory_allocator.h"
+#include "xla/stream_executor/stream_executor.h"
+
+#if (defined(GOOGLE_CUDA) && GOOGLE_CUDA)
+#include "xla/service/gpu/gpu_conv_runner.h"
+#include "xla/stream_executor/cuda/cuda_blas_lt.h"
+#include "xla/stream_executor/gpu/redzone_allocator.h"
+#endif
+
+namespace xla {
+namespace gpu {
+
+StatusOr<AutotuneResult> GetBestBlasAlgorithm(
+    se::Stream* stream, se::RedzoneAllocator& allocator,
+    std::optional<std::string_view> gemm_str,
+    const AutotuneConfig& autotune_config, se::DeviceMemoryBase lhs_buffer,
+    se::DeviceMemoryBase rhs_buffer, se::DeviceMemoryBase output_buffer,
+    absl::Span<const se::blas::AlgorithmType> algorithms,
+    const Shape& output_shape, const HloModuleConfig& hlo_module_config,
+    double beta,
+    const std::function<StatusOr<se::blas::ProfileResult>(
+        const se::blas::AlgorithmType&)>& run_benchmark);
+
+// GemmAlgorithmPicker supports two modes: device and deviceless.
+// In device mode, we run autotuning on the device and store autotune results.
+// In deviceless mode, we pass in some information related to the device and
+// use stored autotune results to rewrite Gemm instructions. If the required
+// autotune result is not stored, then algorithm is set to kRuntimeAutotuning.
+class GemmAlgorithmPicker : public HloModulePass {
+ public:
+  explicit GemmAlgorithmPicker(AutotuneConfig config) : config_(config) {}
+
+  absl::string_view name() const override { return "gemm-algorithm-picker"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  AutotuneConfig config_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GEMM_ALGORITHM_PICKER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_broadcast_folding_rewriter.h

@@ -0,0 +1,51 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_GEMM_BROADCAST_FOLDING_REWRITER_H_
+#define XLA_SERVICE_GPU_GEMM_BROADCAST_FOLDING_REWRITER_H_
+
+#include <optional>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// cuBLAS GEMM has support for strided batched calls, where the stride is used
+// to determine the offset between the batches.
+//
+// This allows (kCustomCall:gemm A kBroadcast(B)) or
+//             (kCustomCall:gemm kBroadcast(A) B)
+// to be rewritten as (kCustomCall:gemm A B) with a zero stride for the
+// broadcasted operand if the broadcast operates on all the batch dimensions.
+//
+// This pattern matches the above case and removes the unnecessary broadcast.
+class GemmBroadcastFoldingRewriter : public HloModulePass {
+ public:
+  absl::string_view name() const override {
+    return "cublas-gemm-broadcast-folding-rewriter";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GEMM_BROADCAST_FOLDING_REWRITER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_rewriter.h

@@ -0,0 +1,62 @@
+/* Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_GEMM_REWRITER_H_
+#define XLA_SERVICE_GPU_GEMM_REWRITER_H_
+
+#include <optional>
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/stream_executor/device_description.h"
+
+namespace xla {
+namespace gpu {
+
+// cuBLAS GEMM in the most general form can run the following operation:
+//
+// (kAdd
+//    (kMultiply (kDot A B) alpha)
+//    (kMultiply C beta))
+//
+// where A, B, C are matrixes and `alpha` and `beta` are host constants.
+// The additional requirement is that C has no other users (otherwise,
+// it does not make sense to fuse it inside the custom call).
+//
+// Both multiplication and addition can be avoided (equivalent to setting
+// `alpha` to one and `beta` to zero).
+//
+// This pass pattern-matches the most general form of this instruction
+// (we assume transposes are already folded), and rewrites it into a custom call
+// where (A, B, C) are three operands respectively, and `alpha` and `beta` are
+// stored in the backend config.
+class GemmRewriter : public HloModulePass {
+ public:
+  explicit GemmRewriter(se::GpuComputeCapability gpu_version);
+  absl::string_view name() const override { return "cublas-gemm-rewriter"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  se::GpuComputeCapability gpu_version_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GEMM_REWRITER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_rewriter_triton.h

@@ -0,0 +1,173 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef XLA_SERVICE_GPU_GEMM_REWRITER_TRITON_H_
+#define XLA_SERVICE_GPU_GEMM_REWRITER_TRITON_H_
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/strings/string_view.h"
+#include "xla/autotuning.pb.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/hlo/ir/hlo_opcode.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/service/instruction_fusion.h"
+#include "xla/status.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_description.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace gpu {
+
+// Tells if f(a+b) == f(a) + f(b).
+bool IsDistributiveOverAddition(const HloInstruction& hlo);
+
+// Allowlist of unary elementwise operations supported by Triton GEMM codegen.
+std::vector<HloOpcode> TritonSupportedUnaryElementwise(PrimitiveType);
+
+// Allowlist of binary elementwise operations supported by Triton GEMM codegen.
+std::vector<HloOpcode> TritonSupportedBinaryElementwise(PrimitiveType);
+
+// Allowlist of ternary elementwise operations supported by Triton GEMM codegen.
+std::vector<HloOpcode> TritonSupportedTernaryElementwise(PrimitiveType);
+
+// Data types that are supported by the Triton emitters.
+bool IsTritonSupportedDataType(PrimitiveType, se::GpuComputeCapability);
+
+// Checks elementwise operation against all supported by Triton GEMM codegen.
+bool IsTritonSupportedElementwise(HloOpcode, PrimitiveType);
+
+// Filters GEMMs which can be handled using Triton.
+FusionDecision CanTritonHandleGEMM(const HloInstruction&,
+                                   se::GpuComputeCapability gpu_version);
+
+// Filters GEMMs which are better to handle using Triton.
+bool ShouldTritonHandleGEMM(HloInstruction&,
+                            se::GpuComputeCapability gpu_version);
+
+class TensorIterationSpec {
+ public:
+  // Description of basic iteration: `count` elements separated by `stride`.
+  struct IterationSpecFragment {
+    int64_t stride;
+    int64_t count;
+    int64_t slice_start;
+    int64_t slice_limit;
+    // Logical subfragments when this iteration is composed
+    // of several HLO dimensions.
+    std::vector<int64_t> subfragments;
+
+    bool is_sliced() const { return count != slice_limit - slice_start; }
+    bool operator!=(const IterationSpecFragment& other) const;
+    std::string ToString() const;
+  };
+  // Description of complex iteration over a sequence of several strides.
+  // Describes a logically contiguous dimension of a tensor physically
+  // separated into multiple fragments by other dimensions.
+  using DimIterationSpec = std::vector<IterationSpecFragment>;
+
+  using StorageType = absl::flat_hash_map<int, DimIterationSpec>;
+  const DimIterationSpec& operator[](const int dimension) const {
+    return dim_iteration_specs_.at(dimension);
+  }
+  DimIterationSpec& operator[](const int dimension) {
+    return dim_iteration_specs_[dimension];
+  }
+  const StorageType& Storage() const { return dim_iteration_specs_; }
+  void RemoveEmptyDimensions() {
+    absl::erase_if(dim_iteration_specs_,
+                   [](const auto& it) { return it.second.empty(); });
+  }
+
+  // Compares physical layouts of tensors ignoring subfragments of dimensions.
+  bool operator==(const TensorIterationSpec& other) const;
+
+  std::string ToString() const;
+
+ private:
+  StorageType dim_iteration_specs_;
+};
+
+// Analysis of tensor iteration orders within tiled fusions.
+class TritonFusionAnalysis {
+  Status ExecuteForDotFusion(const HloInstruction& dot, int split_k);
+  Status ExecuteForSoftmaxFusion(const HloInstruction& root);
+
+ public:
+  // Execute the analysis of a fusion computation.
+  // `split_k` indicates whether this operation was converted to the split-K
+  // form and tells the analysis how to interpret the batch dimensions.
+  static StatusOr<TritonFusionAnalysis> Execute(
+      const HloComputation& computation, int split_k = 1);
+
+  // A scope is an HLO graph that can be tiled efficiently using same or
+  // compatible tile shapes on all operations. GEMM fusion has 3 scopes
+  // defined by left operand, right operand and output.
+  enum class Scope { LHS = 0, RHS = 1, OUTPUT = 2 };
+
+  using IterationSpecByInstructionMap =
+      ConstHloInstructionMap<TensorIterationSpec>;
+  using IterationSpecByInstructionByScopeMap =
+      std::map<Scope, IterationSpecByInstructionMap>;
+
+  // Every parameter requires a separate piece of shared memory for asynchronous
+  // loads. Multiple parameters are approximately equivalent to multiple
+  // pipeline stages.
+  static constexpr int kMaxParameterPerScope = 4;
+
+  // Scope -> HLO -> dot dimension number -> iteration spec at the HLO's output.
+  const TensorIterationSpec::DimIterationSpec* IterSpec(Scope scope,
+                                                        const HloInstruction*,
+                                                        int dimension) const;
+  // Parameter HLO instructions used in a scope of `dot`.
+  const ConstHloInstructionSet& ScopeParameters(const Scope scope) const {
+    return parameters_.at(scope);
+  }
+
+  std::string ToString() const;
+
+ private:
+  IterationSpecByInstructionByScopeMap iter_specs_;
+  // HLO computation parameters per scope.
+  std::map<Scope, ConstHloInstructionSet> parameters_;
+};
+
+// Rewrite compatible dot() calls into custom calls with fused computations
+// that target Triton-based matmul emitter.
+class GemmRewriterTriton : public HloModulePass {
+ public:
+  explicit GemmRewriterTriton(se::GpuComputeCapability gpu_version)
+      : gpu_version_(gpu_version) {}
+  absl::string_view name() const override { return "triton-gemm-rewriter"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  se::GpuComputeCapability gpu_version_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GEMM_REWRITER_TRITON_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gemm_thunk.h

@@ -0,0 +1,57 @@
+/* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GEMM_THUNK_H_
+#define XLA_SERVICE_GPU_GEMM_THUNK_H_
+
+#include "xla/service/buffer_assignment.h"
+#include "xla/service/gpu/matmul_utils.h"
+#include "xla/service/gpu/thunk.h"
+#include "xla/status.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace xla {
+namespace gpu {
+
+// This is thread-compatible.
+class GemmThunk : public Thunk {
+ public:
+  // Constructs a thunk that computes "output = (lhs <dot> rhs) * alpha" using
+  // BLAS gemm (alpha is stored in the instruction GemmBackendConfig).
+  GemmThunk(ThunkInfo thunk_info, GemmConfig config,
+            const BufferAllocation::Slice& lhs_buffer,
+            const BufferAllocation::Slice& rhs_buffer,
+            const BufferAllocation::Slice& output_buffer, bool deterministic);
+
+  GemmThunk(const GemmThunk&) = delete;
+  GemmThunk& operator=(const GemmThunk&) = delete;
+
+  Status ExecuteOnStream(const ExecuteParams& params) override;
+  Status Initialize(const GpuExecutable& executable,
+                    se::StreamExecutor* executor) override;
+
+ private:
+  const GemmConfig config_;
+  const BufferAllocation::Slice lhs_buffer_;
+  const BufferAllocation::Slice rhs_buffer_;
+  const BufferAllocation::Slice output_buffer_;
+  // Whether to run deterministically.
+  const bool deterministic_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GEMM_THUNK_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_all_gather_optimizer.h

@@ -0,0 +1,42 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_ALL_GATHER_OPTIMIZER_H_
+#define XLA_SERVICE_GPU_GPU_ALL_GATHER_OPTIMIZER_H_
+
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Transforms binary_op(all-gather(reduce_scatter(a)),
+// all-gather(reduce_scatter(b))) to allgather(binary_op(reduce_scatter(a),
+// reduce_scatter(b)))
+
+class AllGatherOptimizer : public HloModulePass {
+ public:
+  AllGatherOptimizer() = default;
+  absl::string_view name() const override { return "all-gather-optimizer"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_ALL_GATHER_OPTIMIZER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_asm_opts_util.h

@@ -0,0 +1,32 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_ASM_OPTS_UTIL_H_
+#define XLA_SERVICE_GPU_GPU_ASM_OPTS_UTIL_H_
+
+#include "xla/stream_executor/gpu/gpu_asm_opts.h"
+#include "xla/xla.pb.h"
+
+namespace xla {
+namespace gpu {
+
+// Create GpuAsmOpts out of DebugOptions.
+stream_executor::GpuAsmOpts PtxOptsFromDebugOptions(
+    const DebugOptions& debug_options);
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_ASM_OPTS_UTIL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_async_collective_annotator.h

@@ -0,0 +1,47 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef XLA_SERVICE_GPU_GPU_ASYNC_COLLECTIVE_ANNOTATOR_H_
+#define XLA_SERVICE_GPU_GPU_ASYNC_COLLECTIVE_ANNOTATOR_H_
+
+#include <utility>
+
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+namespace gpu {
+
+// Annotate async collectives with CollectiveBackendConfig.
+class GpuAsyncCollectiveAnnotator : public HloModulePass {
+ public:
+  explicit GpuAsyncCollectiveAnnotator(HloPredicate is_collective_async)
+      : is_collective_async_(std::move(is_collective_async)) {}
+  absl::string_view name() const override {
+    return "gpu-async-collective-annotator";
+  }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  HloPredicate is_collective_async_;
+};
+
+}  // namespace gpu
+}  // namespace xla
+
+#endif  // XLA_SERVICE_GPU_GPU_ASYNC_COLLECTIVE_ANNOTATOR_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/tensorflow/compiler/xla/service/gpu/gpu_autotuning.pb.h

@@ -0,0 +1,1494 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: xla/service/gpu/gpu_autotuning.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#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 <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "xla/autotuning.pb.h"
+#include "xla/service/hlo.pb.h"
+#include "xla/xla_data.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto;
+namespace xla {
+namespace gpu {
+class AlgorithmDenylist;
+struct AlgorithmDenylistDefaultTypeInternal;
+extern AlgorithmDenylistDefaultTypeInternal _AlgorithmDenylist_default_instance_;
+class AlgorithmDenylistEntry;
+struct AlgorithmDenylistEntryDefaultTypeInternal;
+extern AlgorithmDenylistEntryDefaultTypeInternal _AlgorithmDenylistEntry_default_instance_;
+class ConvInstructionLog;
+struct ConvInstructionLogDefaultTypeInternal;
+extern ConvInstructionLogDefaultTypeInternal _ConvInstructionLog_default_instance_;
+class DenylistedAlgorithm;
+struct DenylistedAlgorithmDefaultTypeInternal;
+extern DenylistedAlgorithmDefaultTypeInternal _DenylistedAlgorithm_default_instance_;
+}  // namespace gpu
+}  // namespace xla
+PROTOBUF_NAMESPACE_OPEN
+template<> ::xla::gpu::AlgorithmDenylist* Arena::CreateMaybeMessage<::xla::gpu::AlgorithmDenylist>(Arena*);
+template<> ::xla::gpu::AlgorithmDenylistEntry* Arena::CreateMaybeMessage<::xla::gpu::AlgorithmDenylistEntry>(Arena*);
+template<> ::xla::gpu::ConvInstructionLog* Arena::CreateMaybeMessage<::xla::gpu::ConvInstructionLog>(Arena*);
+template<> ::xla::gpu::DenylistedAlgorithm* Arena::CreateMaybeMessage<::xla::gpu::DenylistedAlgorithm>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace xla {
+namespace gpu {
+
+// ===================================================================
+
+class ConvInstructionLog final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.ConvInstructionLog) */ {
+ public:
+  inline ConvInstructionLog() : ConvInstructionLog(nullptr) {}
+  ~ConvInstructionLog() override;
+  explicit PROTOBUF_CONSTEXPR ConvInstructionLog(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ConvInstructionLog(const ConvInstructionLog& from);
+  ConvInstructionLog(ConvInstructionLog&& from) noexcept
+    : ConvInstructionLog() {
+    *this = ::std::move(from);
+  }
+
+  inline ConvInstructionLog& operator=(const ConvInstructionLog& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ConvInstructionLog& operator=(ConvInstructionLog&& 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 ConvInstructionLog& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ConvInstructionLog* internal_default_instance() {
+    return reinterpret_cast<const ConvInstructionLog*>(
+               &_ConvInstructionLog_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ConvInstructionLog& a, ConvInstructionLog& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ConvInstructionLog* 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(ConvInstructionLog* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  ConvInstructionLog* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<ConvInstructionLog>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ConvInstructionLog& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const ConvInstructionLog& from) {
+    ConvInstructionLog::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(ConvInstructionLog* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.ConvInstructionLog";
+  }
+  protected:
+  explicit ConvInstructionLog(::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 {
+    kOperandShapesFieldNumber = 2,
+    kResultAddressesFieldNumber = 3,
+    kOperandAddressesFieldNumber = 4,
+    kInstructionFieldNumber = 1,
+  };
+  // repeated .xla.ShapeProto operand_shapes = 2;
+  int operand_shapes_size() const;
+  private:
+  int _internal_operand_shapes_size() const;
+  public:
+  void clear_operand_shapes();
+  ::xla::ShapeProto* mutable_operand_shapes(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto >*
+      mutable_operand_shapes();
+  private:
+  const ::xla::ShapeProto& _internal_operand_shapes(int index) const;
+  ::xla::ShapeProto* _internal_add_operand_shapes();
+  public:
+  const ::xla::ShapeProto& operand_shapes(int index) const;
+  ::xla::ShapeProto* add_operand_shapes();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto >&
+      operand_shapes() const;
+
+  // repeated uint64 result_addresses = 3;
+  int result_addresses_size() const;
+  private:
+  int _internal_result_addresses_size() const;
+  public:
+  void clear_result_addresses();
+  private:
+  uint64_t _internal_result_addresses(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      _internal_result_addresses() const;
+  void _internal_add_result_addresses(uint64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      _internal_mutable_result_addresses();
+  public:
+  uint64_t result_addresses(int index) const;
+  void set_result_addresses(int index, uint64_t value);
+  void add_result_addresses(uint64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      result_addresses() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      mutable_result_addresses();
+
+  // repeated uint64 operand_addresses = 4;
+  int operand_addresses_size() const;
+  private:
+  int _internal_operand_addresses_size() const;
+  public:
+  void clear_operand_addresses();
+  private:
+  uint64_t _internal_operand_addresses(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      _internal_operand_addresses() const;
+  void _internal_add_operand_addresses(uint64_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      _internal_mutable_operand_addresses();
+  public:
+  uint64_t operand_addresses(int index) const;
+  void set_operand_addresses(int index, uint64_t value);
+  void add_operand_addresses(uint64_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+      operand_addresses() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+      mutable_operand_addresses();
+
+  // .xla.HloInstructionProto instruction = 1;
+  bool has_instruction() const;
+  private:
+  bool _internal_has_instruction() const;
+  public:
+  void clear_instruction();
+  const ::xla::HloInstructionProto& instruction() const;
+  PROTOBUF_NODISCARD ::xla::HloInstructionProto* release_instruction();
+  ::xla::HloInstructionProto* mutable_instruction();
+  void set_allocated_instruction(::xla::HloInstructionProto* instruction);
+  private:
+  const ::xla::HloInstructionProto& _internal_instruction() const;
+  ::xla::HloInstructionProto* _internal_mutable_instruction();
+  public:
+  void unsafe_arena_set_allocated_instruction(
+      ::xla::HloInstructionProto* instruction);
+  ::xla::HloInstructionProto* unsafe_arena_release_instruction();
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.ConvInstructionLog)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto > operand_shapes_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > result_addresses_;
+    mutable std::atomic<int> _result_addresses_cached_byte_size_;
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > operand_addresses_;
+    mutable std::atomic<int> _operand_addresses_cached_byte_size_;
+    ::xla::HloInstructionProto* instruction_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DenylistedAlgorithm final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.DenylistedAlgorithm) */ {
+ public:
+  inline DenylistedAlgorithm() : DenylistedAlgorithm(nullptr) {}
+  ~DenylistedAlgorithm() override;
+  explicit PROTOBUF_CONSTEXPR DenylistedAlgorithm(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DenylistedAlgorithm(const DenylistedAlgorithm& from);
+  DenylistedAlgorithm(DenylistedAlgorithm&& from) noexcept
+    : DenylistedAlgorithm() {
+    *this = ::std::move(from);
+  }
+
+  inline DenylistedAlgorithm& operator=(const DenylistedAlgorithm& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DenylistedAlgorithm& operator=(DenylistedAlgorithm&& 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 DenylistedAlgorithm& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DenylistedAlgorithm* internal_default_instance() {
+    return reinterpret_cast<const DenylistedAlgorithm*>(
+               &_DenylistedAlgorithm_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(DenylistedAlgorithm& a, DenylistedAlgorithm& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DenylistedAlgorithm* 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(DenylistedAlgorithm* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  DenylistedAlgorithm* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<DenylistedAlgorithm>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DenylistedAlgorithm& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const DenylistedAlgorithm& from) {
+    DenylistedAlgorithm::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(DenylistedAlgorithm* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.DenylistedAlgorithm";
+  }
+  protected:
+  explicit DenylistedAlgorithm(::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,
+    kTensorOpsFieldNumber = 2,
+  };
+  // 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:
+
+  // bool tensor_ops = 2;
+  void clear_tensor_ops();
+  bool tensor_ops() const;
+  void set_tensor_ops(bool value);
+  private:
+  bool _internal_tensor_ops() const;
+  void _internal_set_tensor_ops(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.DenylistedAlgorithm)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    int64_t id_;
+    bool tensor_ops_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AlgorithmDenylistEntry final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.AlgorithmDenylistEntry) */ {
+ public:
+  inline AlgorithmDenylistEntry() : AlgorithmDenylistEntry(nullptr) {}
+  ~AlgorithmDenylistEntry() override;
+  explicit PROTOBUF_CONSTEXPR AlgorithmDenylistEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AlgorithmDenylistEntry(const AlgorithmDenylistEntry& from);
+  AlgorithmDenylistEntry(AlgorithmDenylistEntry&& from) noexcept
+    : AlgorithmDenylistEntry() {
+    *this = ::std::move(from);
+  }
+
+  inline AlgorithmDenylistEntry& operator=(const AlgorithmDenylistEntry& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AlgorithmDenylistEntry& operator=(AlgorithmDenylistEntry&& 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 AlgorithmDenylistEntry& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AlgorithmDenylistEntry* internal_default_instance() {
+    return reinterpret_cast<const AlgorithmDenylistEntry*>(
+               &_AlgorithmDenylistEntry_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(AlgorithmDenylistEntry& a, AlgorithmDenylistEntry& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AlgorithmDenylistEntry* 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(AlgorithmDenylistEntry* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AlgorithmDenylistEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AlgorithmDenylistEntry>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AlgorithmDenylistEntry& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const AlgorithmDenylistEntry& from) {
+    AlgorithmDenylistEntry::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(AlgorithmDenylistEntry* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.AlgorithmDenylistEntry";
+  }
+  protected:
+  explicit AlgorithmDenylistEntry(::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 {
+    kAlgosFieldNumber = 4,
+    kHloFieldNumber = 1,
+    kBlasVersionFieldNumber = 5,
+    kCcFieldNumber = 2,
+    kCudnnVersionFieldNumber = 3,
+  };
+  // repeated .xla.gpu.DenylistedAlgorithm algos = 4;
+  int algos_size() const;
+  private:
+  int _internal_algos_size() const;
+  public:
+  void clear_algos();
+  ::xla::gpu::DenylistedAlgorithm* mutable_algos(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::DenylistedAlgorithm >*
+      mutable_algos();
+  private:
+  const ::xla::gpu::DenylistedAlgorithm& _internal_algos(int index) const;
+  ::xla::gpu::DenylistedAlgorithm* _internal_add_algos();
+  public:
+  const ::xla::gpu::DenylistedAlgorithm& algos(int index) const;
+  ::xla::gpu::DenylistedAlgorithm* add_algos();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::DenylistedAlgorithm >&
+      algos() const;
+
+  // string hlo = 1;
+  void clear_hlo();
+  const std::string& hlo() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_hlo(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_hlo();
+  PROTOBUF_NODISCARD std::string* release_hlo();
+  void set_allocated_hlo(std::string* hlo);
+  private:
+  const std::string& _internal_hlo() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_hlo(const std::string& value);
+  std::string* _internal_mutable_hlo();
+  public:
+
+  // string blas_version = 5;
+  void clear_blas_version();
+  const std::string& blas_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_blas_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_blas_version();
+  PROTOBUF_NODISCARD std::string* release_blas_version();
+  void set_allocated_blas_version(std::string* blas_version);
+  private:
+  const std::string& _internal_blas_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_blas_version(const std::string& value);
+  std::string* _internal_mutable_blas_version();
+  public:
+
+  // .xla.ComputeCapability cc = 2;
+  bool has_cc() const;
+  private:
+  bool _internal_has_cc() const;
+  public:
+  void clear_cc();
+  const ::xla::ComputeCapability& cc() const;
+  PROTOBUF_NODISCARD ::xla::ComputeCapability* release_cc();
+  ::xla::ComputeCapability* mutable_cc();
+  void set_allocated_cc(::xla::ComputeCapability* cc);
+  private:
+  const ::xla::ComputeCapability& _internal_cc() const;
+  ::xla::ComputeCapability* _internal_mutable_cc();
+  public:
+  void unsafe_arena_set_allocated_cc(
+      ::xla::ComputeCapability* cc);
+  ::xla::ComputeCapability* unsafe_arena_release_cc();
+
+  // .xla.CudnnVersion cudnn_version = 3;
+  bool has_cudnn_version() const;
+  private:
+  bool _internal_has_cudnn_version() const;
+  public:
+  void clear_cudnn_version();
+  const ::xla::CudnnVersion& cudnn_version() const;
+  PROTOBUF_NODISCARD ::xla::CudnnVersion* release_cudnn_version();
+  ::xla::CudnnVersion* mutable_cudnn_version();
+  void set_allocated_cudnn_version(::xla::CudnnVersion* cudnn_version);
+  private:
+  const ::xla::CudnnVersion& _internal_cudnn_version() const;
+  ::xla::CudnnVersion* _internal_mutable_cudnn_version();
+  public:
+  void unsafe_arena_set_allocated_cudnn_version(
+      ::xla::CudnnVersion* cudnn_version);
+  ::xla::CudnnVersion* unsafe_arena_release_cudnn_version();
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.AlgorithmDenylistEntry)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::DenylistedAlgorithm > algos_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hlo_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr blas_version_;
+    ::xla::ComputeCapability* cc_;
+    ::xla::CudnnVersion* cudnn_version_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AlgorithmDenylist final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.gpu.AlgorithmDenylist) */ {
+ public:
+  inline AlgorithmDenylist() : AlgorithmDenylist(nullptr) {}
+  ~AlgorithmDenylist() override;
+  explicit PROTOBUF_CONSTEXPR AlgorithmDenylist(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AlgorithmDenylist(const AlgorithmDenylist& from);
+  AlgorithmDenylist(AlgorithmDenylist&& from) noexcept
+    : AlgorithmDenylist() {
+    *this = ::std::move(from);
+  }
+
+  inline AlgorithmDenylist& operator=(const AlgorithmDenylist& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AlgorithmDenylist& operator=(AlgorithmDenylist&& 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 AlgorithmDenylist& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AlgorithmDenylist* internal_default_instance() {
+    return reinterpret_cast<const AlgorithmDenylist*>(
+               &_AlgorithmDenylist_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(AlgorithmDenylist& a, AlgorithmDenylist& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AlgorithmDenylist* 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(AlgorithmDenylist* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  AlgorithmDenylist* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<AlgorithmDenylist>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AlgorithmDenylist& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const AlgorithmDenylist& from) {
+    AlgorithmDenylist::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(AlgorithmDenylist* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.gpu.AlgorithmDenylist";
+  }
+  protected:
+  explicit AlgorithmDenylist(::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 {
+    kEntriesFieldNumber = 1,
+  };
+  // repeated .xla.gpu.AlgorithmDenylistEntry entries = 1;
+  int entries_size() const;
+  private:
+  int _internal_entries_size() const;
+  public:
+  void clear_entries();
+  ::xla::gpu::AlgorithmDenylistEntry* mutable_entries(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::AlgorithmDenylistEntry >*
+      mutable_entries();
+  private:
+  const ::xla::gpu::AlgorithmDenylistEntry& _internal_entries(int index) const;
+  ::xla::gpu::AlgorithmDenylistEntry* _internal_add_entries();
+  public:
+  const ::xla::gpu::AlgorithmDenylistEntry& entries(int index) const;
+  ::xla::gpu::AlgorithmDenylistEntry* add_entries();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::AlgorithmDenylistEntry >&
+      entries() const;
+
+  // @@protoc_insertion_point(class_scope:xla.gpu.AlgorithmDenylist)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::AlgorithmDenylistEntry > entries_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ConvInstructionLog
+
+// .xla.HloInstructionProto instruction = 1;
+inline bool ConvInstructionLog::_internal_has_instruction() const {
+  return this != internal_default_instance() && _impl_.instruction_ != nullptr;
+}
+inline bool ConvInstructionLog::has_instruction() const {
+  return _internal_has_instruction();
+}
+inline const ::xla::HloInstructionProto& ConvInstructionLog::_internal_instruction() const {
+  const ::xla::HloInstructionProto* p = _impl_.instruction_;
+  return p != nullptr ? *p : reinterpret_cast<const ::xla::HloInstructionProto&>(
+      ::xla::_HloInstructionProto_default_instance_);
+}
+inline const ::xla::HloInstructionProto& ConvInstructionLog::instruction() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.ConvInstructionLog.instruction)
+  return _internal_instruction();
+}
+inline void ConvInstructionLog::unsafe_arena_set_allocated_instruction(
+    ::xla::HloInstructionProto* instruction) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.instruction_);
+  }
+  _impl_.instruction_ = instruction;
+  if (instruction) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.ConvInstructionLog.instruction)
+}
+inline ::xla::HloInstructionProto* ConvInstructionLog::release_instruction() {
+  
+  ::xla::HloInstructionProto* temp = _impl_.instruction_;
+  _impl_.instruction_ = 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::HloInstructionProto* ConvInstructionLog::unsafe_arena_release_instruction() {
+  // @@protoc_insertion_point(field_release:xla.gpu.ConvInstructionLog.instruction)
+  
+  ::xla::HloInstructionProto* temp = _impl_.instruction_;
+  _impl_.instruction_ = nullptr;
+  return temp;
+}
+inline ::xla::HloInstructionProto* ConvInstructionLog::_internal_mutable_instruction() {
+  
+  if (_impl_.instruction_ == nullptr) {
+    auto* p = CreateMaybeMessage<::xla::HloInstructionProto>(GetArenaForAllocation());
+    _impl_.instruction_ = p;
+  }
+  return _impl_.instruction_;
+}
+inline ::xla::HloInstructionProto* ConvInstructionLog::mutable_instruction() {
+  ::xla::HloInstructionProto* _msg = _internal_mutable_instruction();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.ConvInstructionLog.instruction)
+  return _msg;
+}
+inline void ConvInstructionLog::set_allocated_instruction(::xla::HloInstructionProto* instruction) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.instruction_);
+  }
+  if (instruction) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(instruction));
+    if (message_arena != submessage_arena) {
+      instruction = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, instruction, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.instruction_ = instruction;
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.ConvInstructionLog.instruction)
+}
+
+// repeated .xla.ShapeProto operand_shapes = 2;
+inline int ConvInstructionLog::_internal_operand_shapes_size() const {
+  return _impl_.operand_shapes_.size();
+}
+inline int ConvInstructionLog::operand_shapes_size() const {
+  return _internal_operand_shapes_size();
+}
+inline ::xla::ShapeProto* ConvInstructionLog::mutable_operand_shapes(int index) {
+  // @@protoc_insertion_point(field_mutable:xla.gpu.ConvInstructionLog.operand_shapes)
+  return _impl_.operand_shapes_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto >*
+ConvInstructionLog::mutable_operand_shapes() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.ConvInstructionLog.operand_shapes)
+  return &_impl_.operand_shapes_;
+}
+inline const ::xla::ShapeProto& ConvInstructionLog::_internal_operand_shapes(int index) const {
+  return _impl_.operand_shapes_.Get(index);
+}
+inline const ::xla::ShapeProto& ConvInstructionLog::operand_shapes(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.ConvInstructionLog.operand_shapes)
+  return _internal_operand_shapes(index);
+}
+inline ::xla::ShapeProto* ConvInstructionLog::_internal_add_operand_shapes() {
+  return _impl_.operand_shapes_.Add();
+}
+inline ::xla::ShapeProto* ConvInstructionLog::add_operand_shapes() {
+  ::xla::ShapeProto* _add = _internal_add_operand_shapes();
+  // @@protoc_insertion_point(field_add:xla.gpu.ConvInstructionLog.operand_shapes)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::ShapeProto >&
+ConvInstructionLog::operand_shapes() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.ConvInstructionLog.operand_shapes)
+  return _impl_.operand_shapes_;
+}
+
+// repeated uint64 result_addresses = 3;
+inline int ConvInstructionLog::_internal_result_addresses_size() const {
+  return _impl_.result_addresses_.size();
+}
+inline int ConvInstructionLog::result_addresses_size() const {
+  return _internal_result_addresses_size();
+}
+inline void ConvInstructionLog::clear_result_addresses() {
+  _impl_.result_addresses_.Clear();
+}
+inline uint64_t ConvInstructionLog::_internal_result_addresses(int index) const {
+  return _impl_.result_addresses_.Get(index);
+}
+inline uint64_t ConvInstructionLog::result_addresses(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.ConvInstructionLog.result_addresses)
+  return _internal_result_addresses(index);
+}
+inline void ConvInstructionLog::set_result_addresses(int index, uint64_t value) {
+  _impl_.result_addresses_.Set(index, value);
+  // @@protoc_insertion_point(field_set:xla.gpu.ConvInstructionLog.result_addresses)
+}
+inline void ConvInstructionLog::_internal_add_result_addresses(uint64_t value) {
+  _impl_.result_addresses_.Add(value);
+}
+inline void ConvInstructionLog::add_result_addresses(uint64_t value) {
+  _internal_add_result_addresses(value);
+  // @@protoc_insertion_point(field_add:xla.gpu.ConvInstructionLog.result_addresses)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+ConvInstructionLog::_internal_result_addresses() const {
+  return _impl_.result_addresses_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+ConvInstructionLog::result_addresses() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.ConvInstructionLog.result_addresses)
+  return _internal_result_addresses();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+ConvInstructionLog::_internal_mutable_result_addresses() {
+  return &_impl_.result_addresses_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+ConvInstructionLog::mutable_result_addresses() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.ConvInstructionLog.result_addresses)
+  return _internal_mutable_result_addresses();
+}
+
+// repeated uint64 operand_addresses = 4;
+inline int ConvInstructionLog::_internal_operand_addresses_size() const {
+  return _impl_.operand_addresses_.size();
+}
+inline int ConvInstructionLog::operand_addresses_size() const {
+  return _internal_operand_addresses_size();
+}
+inline void ConvInstructionLog::clear_operand_addresses() {
+  _impl_.operand_addresses_.Clear();
+}
+inline uint64_t ConvInstructionLog::_internal_operand_addresses(int index) const {
+  return _impl_.operand_addresses_.Get(index);
+}
+inline uint64_t ConvInstructionLog::operand_addresses(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.ConvInstructionLog.operand_addresses)
+  return _internal_operand_addresses(index);
+}
+inline void ConvInstructionLog::set_operand_addresses(int index, uint64_t value) {
+  _impl_.operand_addresses_.Set(index, value);
+  // @@protoc_insertion_point(field_set:xla.gpu.ConvInstructionLog.operand_addresses)
+}
+inline void ConvInstructionLog::_internal_add_operand_addresses(uint64_t value) {
+  _impl_.operand_addresses_.Add(value);
+}
+inline void ConvInstructionLog::add_operand_addresses(uint64_t value) {
+  _internal_add_operand_addresses(value);
+  // @@protoc_insertion_point(field_add:xla.gpu.ConvInstructionLog.operand_addresses)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+ConvInstructionLog::_internal_operand_addresses() const {
+  return _impl_.operand_addresses_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&
+ConvInstructionLog::operand_addresses() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.ConvInstructionLog.operand_addresses)
+  return _internal_operand_addresses();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+ConvInstructionLog::_internal_mutable_operand_addresses() {
+  return &_impl_.operand_addresses_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*
+ConvInstructionLog::mutable_operand_addresses() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.ConvInstructionLog.operand_addresses)
+  return _internal_mutable_operand_addresses();
+}
+
+// -------------------------------------------------------------------
+
+// DenylistedAlgorithm
+
+// int64 id = 1;
+inline void DenylistedAlgorithm::clear_id() {
+  _impl_.id_ = int64_t{0};
+}
+inline int64_t DenylistedAlgorithm::_internal_id() const {
+  return _impl_.id_;
+}
+inline int64_t DenylistedAlgorithm::id() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.DenylistedAlgorithm.id)
+  return _internal_id();
+}
+inline void DenylistedAlgorithm::_internal_set_id(int64_t value) {
+  
+  _impl_.id_ = value;
+}
+inline void DenylistedAlgorithm::set_id(int64_t value) {
+  _internal_set_id(value);
+  // @@protoc_insertion_point(field_set:xla.gpu.DenylistedAlgorithm.id)
+}
+
+// bool tensor_ops = 2;
+inline void DenylistedAlgorithm::clear_tensor_ops() {
+  _impl_.tensor_ops_ = false;
+}
+inline bool DenylistedAlgorithm::_internal_tensor_ops() const {
+  return _impl_.tensor_ops_;
+}
+inline bool DenylistedAlgorithm::tensor_ops() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.DenylistedAlgorithm.tensor_ops)
+  return _internal_tensor_ops();
+}
+inline void DenylistedAlgorithm::_internal_set_tensor_ops(bool value) {
+  
+  _impl_.tensor_ops_ = value;
+}
+inline void DenylistedAlgorithm::set_tensor_ops(bool value) {
+  _internal_set_tensor_ops(value);
+  // @@protoc_insertion_point(field_set:xla.gpu.DenylistedAlgorithm.tensor_ops)
+}
+
+// -------------------------------------------------------------------
+
+// AlgorithmDenylistEntry
+
+// string hlo = 1;
+inline void AlgorithmDenylistEntry::clear_hlo() {
+  _impl_.hlo_.ClearToEmpty();
+}
+inline const std::string& AlgorithmDenylistEntry::hlo() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.AlgorithmDenylistEntry.hlo)
+  return _internal_hlo();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void AlgorithmDenylistEntry::set_hlo(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.hlo_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:xla.gpu.AlgorithmDenylistEntry.hlo)
+}
+inline std::string* AlgorithmDenylistEntry::mutable_hlo() {
+  std::string* _s = _internal_mutable_hlo();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.AlgorithmDenylistEntry.hlo)
+  return _s;
+}
+inline const std::string& AlgorithmDenylistEntry::_internal_hlo() const {
+  return _impl_.hlo_.Get();
+}
+inline void AlgorithmDenylistEntry::_internal_set_hlo(const std::string& value) {
+  
+  _impl_.hlo_.Set(value, GetArenaForAllocation());
+}
+inline std::string* AlgorithmDenylistEntry::_internal_mutable_hlo() {
+  
+  return _impl_.hlo_.Mutable(GetArenaForAllocation());
+}
+inline std::string* AlgorithmDenylistEntry::release_hlo() {
+  // @@protoc_insertion_point(field_release:xla.gpu.AlgorithmDenylistEntry.hlo)
+  return _impl_.hlo_.Release();
+}
+inline void AlgorithmDenylistEntry::set_allocated_hlo(std::string* hlo) {
+  if (hlo != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.hlo_.SetAllocated(hlo, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.hlo_.IsDefault()) {
+    _impl_.hlo_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.AlgorithmDenylistEntry.hlo)
+}
+
+// .xla.ComputeCapability cc = 2;
+inline bool AlgorithmDenylistEntry::_internal_has_cc() const {
+  return this != internal_default_instance() && _impl_.cc_ != nullptr;
+}
+inline bool AlgorithmDenylistEntry::has_cc() const {
+  return _internal_has_cc();
+}
+inline const ::xla::ComputeCapability& AlgorithmDenylistEntry::_internal_cc() const {
+  const ::xla::ComputeCapability* p = _impl_.cc_;
+  return p != nullptr ? *p : reinterpret_cast<const ::xla::ComputeCapability&>(
+      ::xla::_ComputeCapability_default_instance_);
+}
+inline const ::xla::ComputeCapability& AlgorithmDenylistEntry::cc() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.AlgorithmDenylistEntry.cc)
+  return _internal_cc();
+}
+inline void AlgorithmDenylistEntry::unsafe_arena_set_allocated_cc(
+    ::xla::ComputeCapability* cc) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cc_);
+  }
+  _impl_.cc_ = cc;
+  if (cc) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.AlgorithmDenylistEntry.cc)
+}
+inline ::xla::ComputeCapability* AlgorithmDenylistEntry::release_cc() {
+  
+  ::xla::ComputeCapability* temp = _impl_.cc_;
+  _impl_.cc_ = 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::ComputeCapability* AlgorithmDenylistEntry::unsafe_arena_release_cc() {
+  // @@protoc_insertion_point(field_release:xla.gpu.AlgorithmDenylistEntry.cc)
+  
+  ::xla::ComputeCapability* temp = _impl_.cc_;
+  _impl_.cc_ = nullptr;
+  return temp;
+}
+inline ::xla::ComputeCapability* AlgorithmDenylistEntry::_internal_mutable_cc() {
+  
+  if (_impl_.cc_ == nullptr) {
+    auto* p = CreateMaybeMessage<::xla::ComputeCapability>(GetArenaForAllocation());
+    _impl_.cc_ = p;
+  }
+  return _impl_.cc_;
+}
+inline ::xla::ComputeCapability* AlgorithmDenylistEntry::mutable_cc() {
+  ::xla::ComputeCapability* _msg = _internal_mutable_cc();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.AlgorithmDenylistEntry.cc)
+  return _msg;
+}
+inline void AlgorithmDenylistEntry::set_allocated_cc(::xla::ComputeCapability* cc) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cc_);
+  }
+  if (cc) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cc));
+    if (message_arena != submessage_arena) {
+      cc = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, cc, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.cc_ = cc;
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.AlgorithmDenylistEntry.cc)
+}
+
+// .xla.CudnnVersion cudnn_version = 3;
+inline bool AlgorithmDenylistEntry::_internal_has_cudnn_version() const {
+  return this != internal_default_instance() && _impl_.cudnn_version_ != nullptr;
+}
+inline bool AlgorithmDenylistEntry::has_cudnn_version() const {
+  return _internal_has_cudnn_version();
+}
+inline const ::xla::CudnnVersion& AlgorithmDenylistEntry::_internal_cudnn_version() const {
+  const ::xla::CudnnVersion* p = _impl_.cudnn_version_;
+  return p != nullptr ? *p : reinterpret_cast<const ::xla::CudnnVersion&>(
+      ::xla::_CudnnVersion_default_instance_);
+}
+inline const ::xla::CudnnVersion& AlgorithmDenylistEntry::cudnn_version() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.AlgorithmDenylistEntry.cudnn_version)
+  return _internal_cudnn_version();
+}
+inline void AlgorithmDenylistEntry::unsafe_arena_set_allocated_cudnn_version(
+    ::xla::CudnnVersion* cudnn_version) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cudnn_version_);
+  }
+  _impl_.cudnn_version_ = cudnn_version;
+  if (cudnn_version) {
+    
+  } else {
+    
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:xla.gpu.AlgorithmDenylistEntry.cudnn_version)
+}
+inline ::xla::CudnnVersion* AlgorithmDenylistEntry::release_cudnn_version() {
+  
+  ::xla::CudnnVersion* temp = _impl_.cudnn_version_;
+  _impl_.cudnn_version_ = 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::CudnnVersion* AlgorithmDenylistEntry::unsafe_arena_release_cudnn_version() {
+  // @@protoc_insertion_point(field_release:xla.gpu.AlgorithmDenylistEntry.cudnn_version)
+  
+  ::xla::CudnnVersion* temp = _impl_.cudnn_version_;
+  _impl_.cudnn_version_ = nullptr;
+  return temp;
+}
+inline ::xla::CudnnVersion* AlgorithmDenylistEntry::_internal_mutable_cudnn_version() {
+  
+  if (_impl_.cudnn_version_ == nullptr) {
+    auto* p = CreateMaybeMessage<::xla::CudnnVersion>(GetArenaForAllocation());
+    _impl_.cudnn_version_ = p;
+  }
+  return _impl_.cudnn_version_;
+}
+inline ::xla::CudnnVersion* AlgorithmDenylistEntry::mutable_cudnn_version() {
+  ::xla::CudnnVersion* _msg = _internal_mutable_cudnn_version();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.AlgorithmDenylistEntry.cudnn_version)
+  return _msg;
+}
+inline void AlgorithmDenylistEntry::set_allocated_cudnn_version(::xla::CudnnVersion* cudnn_version) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.cudnn_version_);
+  }
+  if (cudnn_version) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(cudnn_version));
+    if (message_arena != submessage_arena) {
+      cudnn_version = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, cudnn_version, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  _impl_.cudnn_version_ = cudnn_version;
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.AlgorithmDenylistEntry.cudnn_version)
+}
+
+// string blas_version = 5;
+inline void AlgorithmDenylistEntry::clear_blas_version() {
+  _impl_.blas_version_.ClearToEmpty();
+}
+inline const std::string& AlgorithmDenylistEntry::blas_version() const {
+  // @@protoc_insertion_point(field_get:xla.gpu.AlgorithmDenylistEntry.blas_version)
+  return _internal_blas_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void AlgorithmDenylistEntry::set_blas_version(ArgT0&& arg0, ArgT... args) {
+ 
+ _impl_.blas_version_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:xla.gpu.AlgorithmDenylistEntry.blas_version)
+}
+inline std::string* AlgorithmDenylistEntry::mutable_blas_version() {
+  std::string* _s = _internal_mutable_blas_version();
+  // @@protoc_insertion_point(field_mutable:xla.gpu.AlgorithmDenylistEntry.blas_version)
+  return _s;
+}
+inline const std::string& AlgorithmDenylistEntry::_internal_blas_version() const {
+  return _impl_.blas_version_.Get();
+}
+inline void AlgorithmDenylistEntry::_internal_set_blas_version(const std::string& value) {
+  
+  _impl_.blas_version_.Set(value, GetArenaForAllocation());
+}
+inline std::string* AlgorithmDenylistEntry::_internal_mutable_blas_version() {
+  
+  return _impl_.blas_version_.Mutable(GetArenaForAllocation());
+}
+inline std::string* AlgorithmDenylistEntry::release_blas_version() {
+  // @@protoc_insertion_point(field_release:xla.gpu.AlgorithmDenylistEntry.blas_version)
+  return _impl_.blas_version_.Release();
+}
+inline void AlgorithmDenylistEntry::set_allocated_blas_version(std::string* blas_version) {
+  if (blas_version != nullptr) {
+    
+  } else {
+    
+  }
+  _impl_.blas_version_.SetAllocated(blas_version, GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  if (_impl_.blas_version_.IsDefault()) {
+    _impl_.blas_version_.Set("", GetArenaForAllocation());
+  }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+  // @@protoc_insertion_point(field_set_allocated:xla.gpu.AlgorithmDenylistEntry.blas_version)
+}
+
+// repeated .xla.gpu.DenylistedAlgorithm algos = 4;
+inline int AlgorithmDenylistEntry::_internal_algos_size() const {
+  return _impl_.algos_.size();
+}
+inline int AlgorithmDenylistEntry::algos_size() const {
+  return _internal_algos_size();
+}
+inline void AlgorithmDenylistEntry::clear_algos() {
+  _impl_.algos_.Clear();
+}
+inline ::xla::gpu::DenylistedAlgorithm* AlgorithmDenylistEntry::mutable_algos(int index) {
+  // @@protoc_insertion_point(field_mutable:xla.gpu.AlgorithmDenylistEntry.algos)
+  return _impl_.algos_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::DenylistedAlgorithm >*
+AlgorithmDenylistEntry::mutable_algos() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.AlgorithmDenylistEntry.algos)
+  return &_impl_.algos_;
+}
+inline const ::xla::gpu::DenylistedAlgorithm& AlgorithmDenylistEntry::_internal_algos(int index) const {
+  return _impl_.algos_.Get(index);
+}
+inline const ::xla::gpu::DenylistedAlgorithm& AlgorithmDenylistEntry::algos(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.AlgorithmDenylistEntry.algos)
+  return _internal_algos(index);
+}
+inline ::xla::gpu::DenylistedAlgorithm* AlgorithmDenylistEntry::_internal_add_algos() {
+  return _impl_.algos_.Add();
+}
+inline ::xla::gpu::DenylistedAlgorithm* AlgorithmDenylistEntry::add_algos() {
+  ::xla::gpu::DenylistedAlgorithm* _add = _internal_add_algos();
+  // @@protoc_insertion_point(field_add:xla.gpu.AlgorithmDenylistEntry.algos)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::DenylistedAlgorithm >&
+AlgorithmDenylistEntry::algos() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.AlgorithmDenylistEntry.algos)
+  return _impl_.algos_;
+}
+
+// -------------------------------------------------------------------
+
+// AlgorithmDenylist
+
+// repeated .xla.gpu.AlgorithmDenylistEntry entries = 1;
+inline int AlgorithmDenylist::_internal_entries_size() const {
+  return _impl_.entries_.size();
+}
+inline int AlgorithmDenylist::entries_size() const {
+  return _internal_entries_size();
+}
+inline void AlgorithmDenylist::clear_entries() {
+  _impl_.entries_.Clear();
+}
+inline ::xla::gpu::AlgorithmDenylistEntry* AlgorithmDenylist::mutable_entries(int index) {
+  // @@protoc_insertion_point(field_mutable:xla.gpu.AlgorithmDenylist.entries)
+  return _impl_.entries_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::AlgorithmDenylistEntry >*
+AlgorithmDenylist::mutable_entries() {
+  // @@protoc_insertion_point(field_mutable_list:xla.gpu.AlgorithmDenylist.entries)
+  return &_impl_.entries_;
+}
+inline const ::xla::gpu::AlgorithmDenylistEntry& AlgorithmDenylist::_internal_entries(int index) const {
+  return _impl_.entries_.Get(index);
+}
+inline const ::xla::gpu::AlgorithmDenylistEntry& AlgorithmDenylist::entries(int index) const {
+  // @@protoc_insertion_point(field_get:xla.gpu.AlgorithmDenylist.entries)
+  return _internal_entries(index);
+}
+inline ::xla::gpu::AlgorithmDenylistEntry* AlgorithmDenylist::_internal_add_entries() {
+  return _impl_.entries_.Add();
+}
+inline ::xla::gpu::AlgorithmDenylistEntry* AlgorithmDenylist::add_entries() {
+  ::xla::gpu::AlgorithmDenylistEntry* _add = _internal_add_entries();
+  // @@protoc_insertion_point(field_add:xla.gpu.AlgorithmDenylist.entries)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::xla::gpu::AlgorithmDenylistEntry >&
+AlgorithmDenylist::entries() const {
+  // @@protoc_insertion_point(field_list:xla.gpu.AlgorithmDenylist.entries)
+  return _impl_.entries_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace gpu
+}  // namespace xla
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fgpu_2fgpu_5fautotuning_2eproto