Add files using upload-large-folder tool

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/cpu_event.h

@@ -0,0 +1,31 @@
+/* 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_RUNTIME_CPU_EVENT_H_
+#define XLA_RUNTIME_CPU_EVENT_H_
+
+namespace xla {
+namespace runtime {
+
+// Typical use case: AsyncValueRef<CpuEvent> is used to indicate the
+// completion of a CPU operation, e.g., data transfer or running a program.
+struct CpuEvent {
+  CpuEvent() = default;
+};
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_CPU_EVENT_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/custom_call.h

@@ -0,0 +1,1893 @@
+/* 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_RUNTIME_CUSTOM_CALL_H_
+#define XLA_RUNTIME_CUSTOM_CALL_H_
+
+#include <algorithm>
+#include <any>
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <iterator>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/base/dynamic_annotations.h"
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/types/span.h"
+#include "Eigen/Core"  // from @eigen_archive
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringExtras.h"
+#include "xla/primitive_util.h"
+#include "xla/runtime/async_runtime.h"
+#include "xla/runtime/diagnostics.h"
+#include "xla/runtime/errors.h"
+#include "xla/runtime/ffi/ffi_abi.h"
+#include "xla/runtime/logical_result.h"
+#include "xla/runtime/map_by_type.h"
+#include "xla/runtime/memref_view.h"
+#include "xla/runtime/state.h"
+#include "xla/runtime/type_id.h"
+#include "tfrt/concurrency/async_value_ref.h"  // from @tf_runtime
+#include "tfrt/concurrency/chain.h"  // from @tf_runtime
+
+namespace xla {
+namespace runtime {
+
+// Forward declare.
+struct ExecutionContext;
+
+// Forward declare template defined below.
+template <typename... Ts>
+class CustomCallBinding;
+
+// Registers mappings from TypeIDs supported by the custom calls to their unique
+// names in the given registry.
+void PopulateCustomCallTypeIdNames(TypeIDNameRegistry& registry);
+
+// A type tag to declare MLIR TypeID specializations for types passed to the
+// custom calls. We don't want to declare specializations for scalar types
+// directly in this translation unit, so we rely on a tag to wrap them.
+//
+// See explicit TypeID declarations at the end of this file.
+template <typename T>
+struct Tagged {};
+
+class CustomCall {
+ public:
+  // Container for passing data between XLA user and the custom call handler.
+  using UserData = PtrMapByType<CustomCall>;
+
+  // A type for matching all remaining custom call arguments.
+  class RemainingArgs;
+
+  // A type for passing an argument of different types at the same position,
+  // and the handler will do the decoding.
+  class VariantArg;
+  class VariantAttr;
+
+  // A type for representing tensors with shapes.
+  template <typename T>
+  struct TensorRef {
+    absl::Span<const int64_t> shape;
+    absl::Span<const T> data;
+  };
+
+  // An ordinal of a function exported from executable.
+  struct FunctionOrdinal {
+    unsigned ordinal;
+  };
+
+  // Custom call handler can check arguments and attributes types and names
+  // at runtime, however this comes at extra cost and can be optionally
+  // disabled. If the version of the compiler that generated the XLA executable
+  // doesn't match the custom call handler, it can lead to undefined behavior.
+  enum class RuntimeChecks : uint8_t {
+    // Check arguments and attributes types, also check attribute names. It is
+    // safe to pass extra attributes (if `exact_attrs` is false) to the custom
+    // call when name checking is enabled, because it will safely skip
+    // irrelevant attributes.
+    kDefault = 0,
+
+    // Check only the types of the arguments and attributes. At this check level
+    // custom calls never check the names of the attributes because it can be
+    // too expensive, however type checking should prevent catastrophic
+    // segfaults. This is the recommended checks level in optimized builds.
+    kLess = 1,
+
+    // Do not check the number of arguments and attributes and their types, and
+    // do not check that the user data was passed to the custom call. This is
+    // the most dangerous option, because it blindly reinterprets opaque memory
+    // passed to the handler, and can easily lead to segfaults if the data
+    // doesn't match the expected custom call signature.
+    kNone = 2
+  };
+
+  struct Options {
+    // Check that attributes passed at run time exactly match the attributes
+    // defined by the custom call binding. If `false` then custom call handler
+    // will happily ignore any additional attributes passed at run time. It is
+    // unsafe to disable run-time checks for custom calls that support non-exact
+    // attributes, as the custom call handler uses pre-computed attributes
+    // offsets based on the binding specification.
+    bool exact_attrs = true;
+  };
+
+  static constexpr bool CheckNames(RuntimeChecks checks) {
+    return checks == RuntimeChecks::kDefault;
+  }
+
+  static constexpr bool CheckTypes(RuntimeChecks checks) {
+    return checks != RuntimeChecks::kNone;
+  }
+
+  static constexpr bool CheckUserData(RuntimeChecks checks) {
+    return checks != RuntimeChecks::kNone;
+  }
+
+  template <typename T>
+  static bool Isa(RuntimeChecks checks, TypeID type_id) {
+    return !CheckTypes(checks) || type_id == TypeID::get<Tagged<T>>();
+  }
+
+  template <typename T, typename U, typename... Ts>
+  static bool Isa(RuntimeChecks checks, TypeID type_id) {
+    return !CheckTypes(checks) || type_id == TypeID::get<Tagged<T>>() ||
+           Isa<U, Ts...>(checks, type_id);
+  }
+
+  virtual ~CustomCall() = default;
+
+  virtual std::string_view name() const = 0;
+  virtual LogicalResult call(void** args, void** attrs, void** rets,
+                             const UserData* user_data,
+                             const DiagnosticEngine* diagnostic) const = 0;
+
+  static CustomCallBinding<> Bind(std::string callee);
+  static CustomCallBinding<> Bind(std::string callee, const Options& opts);
+
+  // This is a helper template that allows to convert functions pointers from
+  // the run time values to compile time values (template arguments) with
+  // automatic template arguments inference.
+  //
+  // Example:
+  //
+  //   static LogicalResult Foo(int32_t arg) {... }
+  //
+  //   template<typename Callable>
+  //   void call(Callable callable) { callable(42); }
+  //
+  //   call(Foo);                     // `Foo` passed as a runtime value
+  //   call(FunctionWrapper<Foo>())   // `Foo` passed as a template argument
+  //
+  // In the first case compiler will not be able to inline `Foo` into the `call`
+  // body. However in the second case it can do that, because function pointer
+  // is a statically known value (template non-type argument).
+  template <auto fn>
+  struct FunctionWrapper;
+
+  template <typename Ret, typename... Args, Ret (*fn)(Args...)>
+  struct FunctionWrapper<fn> {
+    ABSL_ATTRIBUTE_ALWAYS_INLINE Ret operator()(Args... args) const {
+      return fn(args...);
+    }
+  };
+};
+
+// Forward declare template defined below.
+template <CustomCall::RuntimeChecks checks, typename Fn, typename... Ts>
+class CustomCallHandler;
+
+namespace internal {
+
+// A type tag to distinguish arguments tied to the attributes in the
+// `CustomCallBinding` variadic template argument.
+template <typename T>
+struct Attr {};
+
+// A type tag to distinguish arguments tied to the return in the
+// `CustomCallBinding` variadic template argument.
+template <typename T>
+struct Ret {};
+
+// A type tag to distinguish arguments tied to the user data in the
+// `CustomCallBinding` variadic template argument.
+template <typename T>
+struct UserData {};
+
+// A type tag to distinguish arguments tied to the state in the
+// `CustomCallBinding` variadic template argument.
+template <typename T>
+struct StateTag {};
+
+// A type tag to distinguish arguments tied to the constant values in the
+// `CustomCallBinding` variadic template argument.
+template <typename T>
+struct Value {};
+
+// A template for checking if type is a regular argument or one of the special
+// arguments wrapped in a type tag (e.g. attr, user data, etc...).
+template <typename>
+struct IsWrapped : std::false_type {};
+
+template <typename T>
+struct IsWrapped<internal::Attr<T>> : std::true_type {};
+
+template <typename T>
+struct IsWrapped<internal::Ret<T>> : std::true_type {};
+
+template <typename T>
+struct IsWrapped<internal::UserData<T>> : std::true_type {};
+
+template <typename T>
+struct IsWrapped<internal::StateTag<T>> : std::true_type {};
+
+template <typename T>
+struct IsWrapped<internal::Value<T>> : std::true_type {};
+
+template <typename T>
+struct IsResult : std::false_type {};
+
+template <typename T>
+struct IsResult<internal::Ret<T>> : std::true_type {};
+
+// Checks if remaining arguments are in the parameter pack.
+template <typename... Ts>
+using HasRemainingArgs =
+    std::disjunction<std::is_same<CustomCall::RemainingArgs, Ts>...>;
+
+}  // namespace internal
+
+// Custom call binding describes the function signature of the expected custom
+// call handler using its variadic template parameter.
+//
+//   Custom call binding:
+//     CustomCallBinding<int32_t, MemrefView>
+//
+//   Function signature:
+//     LogicalResult MyHandle(int32_t algo, MemrefView memref);
+//
+template <typename... Ts>
+class CustomCallBinding {
+ public:
+  using Options = CustomCall::Options;
+  using RuntimeChecks = CustomCall::RuntimeChecks;
+
+  template <typename T>
+  CustomCallBinding<Ts..., T> Arg() && {
+    return {std::move(*this)};
+  }
+
+  CustomCallBinding<Ts..., CustomCall::RemainingArgs> RemainingArgs() && {
+    static_assert(!internal::HasRemainingArgs<Ts...>::value,
+                  "remaining arguments can be passed just once");
+    return {std::move(*this)};
+  }
+
+  template <typename T>
+  CustomCallBinding<Ts..., internal::Attr<T>> Attr(std::string attr) && {
+    attrs_.push_back(std::move(attr));
+    return {std::move(*this)};
+  }
+
+  template <typename T>
+  CustomCallBinding<Ts..., internal::Ret<T>> Ret() && {
+    return {std::move(*this)};
+  }
+
+  template <typename T>
+  CustomCallBinding<Ts..., internal::UserData<T>> UserData() && {
+    static_assert(std::is_pointer<T>::value, "user data must be a pointer");
+    return {std::move(*this)};
+  }
+
+  template <typename T>
+  CustomCallBinding<Ts..., internal::StateTag<T>> State(std::string id) && {
+    attrs_.push_back(std::move(id));
+    return {std::move(*this)};
+  }
+
+  template <typename T>
+  CustomCallBinding<Ts..., internal::Value<T>> Value(T value) && {
+    values_.push_back(std::move(value));
+    return {std::move(*this)};
+  }
+
+  template <RuntimeChecks checks = RuntimeChecks::kDefault, typename Fn>
+  std::unique_ptr<CustomCallHandler<checks, Fn, Ts...>> To(Fn fn) {
+    return std::unique_ptr<CustomCallHandler<checks, Fn, Ts...>>(
+        new CustomCallHandler<checks, Fn, Ts...>(
+            std::forward<Fn>(fn), std::move(callee_), std::move(attrs_),
+            std::move(values_), opts_));
+  }
+
+ private:
+  template <typename...>
+  friend class CustomCallBinding;
+  friend class CustomCall;
+
+  CustomCallBinding(std::string callee, const Options& opts)
+      : callee_(std::move(callee)), opts_(opts) {
+    static_assert(sizeof...(Ts) == 0, "custom call arguments must be empty");
+  }
+
+  template <typename... TTs>
+  CustomCallBinding(CustomCallBinding<TTs...>&& other)  // NOLINT
+      : callee_(std::move(other.callee_)),
+        attrs_(std::move(other.attrs_)),
+        values_(std::move(other.values_)),
+        opts_(other.opts_) {}
+
+  CustomCallBinding(CustomCallBinding&) = delete;
+
+  std::string callee_;              // custom call target
+  std::vector<std::string> attrs_;  // names of bound attributes
+  std::vector<std::any> values_;    // values bound to arguments
+  Options opts_;
+};
+
+inline CustomCallBinding<> CustomCall::Bind(std::string callee) {
+  return Bind(std::move(callee), Options());
+}
+
+inline CustomCallBinding<> CustomCall::Bind(std::string callee,
+                                            const Options& opts) {
+  return CustomCallBinding<>(std::move(callee), opts);
+}
+
+// Custom calls return results to the caller through the template
+// specializations of the `Result`. Each template specialization is responsible
+// for definining the result encoding/decoding to/from opaque memory.
+template <typename T>
+class Result;
+
+// Custom call arguments decoding must be defined by specializing this template.
+//
+// Example: decoding for the `MyType` arguments
+//
+//   template <CustomCall::RuntimeChecks checks>
+//   struct CustomCallArgDecoding<MyType, checks> {
+//    static FailureOr<MyType> Decode(TypeID type_id, void* value);
+//   };
+//
+template <typename T, CustomCall::RuntimeChecks>
+struct CustomCallArgDecoding;
+
+// Custom call attribute decoding must be defined by specializing this template.
+//
+// Example: decoding for the `MyType` attributes
+//
+//   template <CustomCall::RuntimeChecks checks>
+//   struct CustomCallAttrDecoding<MyType, checks> {
+//    static FailureOr<MyType> Decode(std::string_view name,
+//                                    TypeID type_id, void* value);
+//   }
+//
+template <typename T, CustomCall::RuntimeChecks>
+struct CustomCallAttrDecoding;
+
+// Custom call returns decoding must be defined by specializing this template.
+//
+// Example: decoding for the `MyType` arguments
+//
+//   template <CustomCall::RuntimeChecks checks>
+//   struct CustomCallRetDecoding<MyType, checks> {
+//    static FailureOr<Result<MyType>> Decode(TypeID type_id, void* value);
+//   };
+//
+template <typename T, CustomCall::RuntimeChecks>
+struct CustomCallRetDecoding;
+
+//===----------------------------------------------------------------------===//
+// Helpers for decoding opaque arguments and attributes memory.
+//===----------------------------------------------------------------------===//
+
+namespace internal {
+
+// Decoded pair of an argument type and opaque value.
+struct DecodedArg {
+  TypeID type_id;
+  void* value;
+};
+
+// Decoded triple of an attribute name, type and opaque value.
+struct DecodedAttr {
+  std::string_view name;
+  TypeID type_id;
+  void* value;
+};
+
+// A convenience wrapper around opaque arguments memory.
+class DecodedArgs {
+ public:
+  explicit DecodedArgs(void** args) {
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(args, sizeof(void*));
+    size_ = *reinterpret_cast<int64_t*>(args[0]);
+    if (size_) {
+      ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(args + 1, sizeof(void*));
+      type_table_ = reinterpret_cast<void**>(args[1]);
+      ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(type_table_, size_ * sizeof(void*));
+      values_ = args + 2;
+      ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(values_, size_ * sizeof(void*));
+    }
+  }
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE int64_t size() const { return size_; }
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE DecodedArg operator[](size_t i) const {
+    DecodedArg arg;
+    arg.type_id = TypeID::getFromOpaquePointer(type_table_[i]);
+    arg.value = values_[i];
+    return arg;
+  }
+
+ private:
+  int64_t size_;
+  void** type_table_ = nullptr;
+  void** values_ = nullptr;
+};
+
+// A convenience wrapper around opaque attributes memory.
+class DecodedAttrs {
+ public:
+  explicit DecodedAttrs(void** attrs) : encoded_(attrs + 1) {
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(attrs, sizeof(void*));
+    size_ = *reinterpret_cast<int64_t*>(attrs[0]);
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(encoded_, 3 * size_ * sizeof(void*));
+  }
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE int64_t size() const { return size_; }
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE DecodedAttr operator[](size_t i) const {
+    void** attr_base = encoded_ + i * 3;
+
+    DecodedAttr attr;
+    auto* name = reinterpret_cast<internal::EncodedArray<char>*>(attr_base[0]);
+    attr.name = std::string_view(name->data, name->size);
+    attr.type_id = TypeID::getFromOpaquePointer(attr_base[1]);
+    attr.value = attr_base[2];
+
+    return attr;
+  }
+
+ private:
+  void** encoded_;
+  int64_t size_;
+};
+
+// Using the same class for decoded returns
+using DecodedRet = DecodedArg;
+using DecodedRets = DecodedArgs;
+
+}  // namespace internal
+
+//===----------------------------------------------------------------------===//
+// CustomCall remaining arguments wraps the type-erased `DecodedArg` container,
+// and provides a type-safe API for accessing individual arguments.
+//===----------------------------------------------------------------------===//
+
+class CustomCall::RemainingArgs {
+ public:
+  using RuntimeChecks = CustomCall::RuntimeChecks;
+
+  RemainingArgs(internal::DecodedArgs args, size_t offset)
+      : args_(args), offset_(offset) {
+    assert(offset <= args_.size() && "illegal remaining args offset");
+  }
+
+  size_t size() const { return args_.size() - offset_; }
+  bool empty() const { return size() == 0; }
+
+  template <typename T>
+  bool isa(size_t index) const {
+    return args_[index + offset_].type_id == TypeID::get<Tagged<T>>();
+  }
+
+  template <typename T, RuntimeChecks checks = RuntimeChecks::kDefault>
+  FailureOr<T> get(size_t index) const {
+    internal::DecodedArg arg = args_[index + offset_];
+    return CustomCallArgDecoding<T, checks>::Decode(arg.type_id, arg.value);
+  }
+
+ private:
+  internal::DecodedArgs args_;
+  size_t offset_;
+};
+
+class CustomCall::VariantArg {
+ public:
+  using RuntimeChecks = CustomCall::RuntimeChecks;
+
+  VariantArg(internal::DecodedArgs args, size_t offset)
+      : args_(args), offset_(offset) {
+    assert(offset <= args_.size() && "illegal remaining args offset");
+  }
+
+  template <typename T>
+  bool isa() const {
+    return args_[offset_].type_id == TypeID::get<Tagged<T>>();
+  }
+
+  template <typename T, RuntimeChecks checks = RuntimeChecks::kDefault>
+  FailureOr<T> get() const {
+    internal::DecodedArg arg = args_[offset_];
+    return CustomCallArgDecoding<T, checks>::Decode(arg.type_id, arg.value);
+  }
+
+ private:
+  internal::DecodedArgs args_;
+  size_t offset_;
+};
+
+class CustomCall::VariantAttr {
+ public:
+  using RuntimeChecks = CustomCall::RuntimeChecks;
+
+  VariantAttr(std::string_view name, TypeID type_id, void* value)
+      : name_(name), type_id_(type_id), value_(value) {}
+
+  template <typename T>
+  bool isa() const {
+    return type_id_ == TypeID::get<Tagged<T>>();
+  }
+
+  template <typename T, RuntimeChecks checks = RuntimeChecks::kDefault>
+  FailureOr<T> get() const {
+    return CustomCallAttrDecoding<T, checks>::Decode(name_, type_id_, value_);
+  }
+
+ private:
+  std::string_view name_;
+  TypeID type_id_;
+  void* value_;
+};
+
+//===----------------------------------------------------------------------===//
+// A little bit of template metaprogramming to implement type safe binding
+// of custom calls to C++ functions. This is internal implementation details,
+// and must not be relied on in any of the client code.
+//===----------------------------------------------------------------------===//
+
+namespace internal {
+
+// A helper struct to extract the type of the handler argument.
+template <typename T>
+struct FnArgType {
+  using Type = T;
+};
+
+// Extracts the underlying type from the attribute type tag.
+template <typename T>
+struct FnArgType<internal::Attr<T>> {
+  using Type = T;
+};
+
+// Extracts the underlying type from the return type tag.
+template <typename T>
+struct FnArgType<internal::Ret<T>> {
+  using Type = Result<T>;
+};
+
+// Extracts the underlying type from the user data type tag.
+template <typename T>
+struct FnArgType<internal::UserData<T>> {
+  using Type = T;
+};
+
+// Extracts the underlying type from the state type tag.
+template <typename T>
+struct FnArgType<internal::StateTag<T>> {
+  using Type = State<T>;
+};
+
+// Extracts the underlying type from the value type tag.
+template <typename T>
+struct FnArgType<internal::Value<T>> {
+  using Type = T;
+};
+
+// A template for counting regular arguments in the Ts pack.
+template <typename... Ts>
+struct NumArgs;
+
+template <typename T, typename... Ts>
+struct NumArgs<T, Ts...> {
+  static constexpr int64_t value = !IsWrapped<T>::value + NumArgs<Ts...>::value;
+};
+
+template <>
+struct NumArgs<> {
+  static constexpr int64_t value = 0;
+};
+
+// A template for counting returns in the Ts pack.
+template <typename... Ts>
+struct NumRets;
+
+template <typename T, typename... Ts>
+struct NumRets<T, Ts...> {
+  static constexpr int64_t value = IsResult<T>::value + NumRets<Ts...>::value;
+};
+
+template <>
+struct NumRets<> {
+  static constexpr int64_t value = 0;
+};
+
+// Unwrap return type to get the type expected by result `Set` method.
+//
+// TODO(ezhulenev): Result template itself should define what type `T` it
+// expects to see in the `Set` method, because it's not necessery the same as
+// the template type of the result.
+template <typename T>
+struct UnwrapRet;
+
+template <typename T>
+struct UnwrapRet<Result<T>> {
+  using Type = T;
+};
+
+// A helper template to concatenate index + index sequence.
+template <size_t, typename>
+struct ConsIdx;
+
+template <size_t idx, size_t... Is>
+struct ConsIdx<idx, std::index_sequence<Is...>> {
+  using Type = std::index_sequence<idx, Is...>;
+};
+
+// Get indices of the variadic template type parameters corresponding to
+// results. This template will produce an `std::index_sequence` type with
+// indices of custom call result arguments.
+template <size_t idx, typename... Ts>
+struct IndexRets;
+
+template <size_t idx>
+struct IndexRets<idx> {
+  using Is = std::index_sequence<>;
+};
+
+template <size_t idx, typename T, typename... Ts>
+struct IndexRets<idx, T, Ts...> {
+  using Is = std::conditional_t<
+      IsResult<T>::value,
+      typename ConsIdx<idx, typename IndexRets<idx + 1, Ts...>::Is>::Type,
+      typename IndexRets<idx + 1, Ts...>::Is>;
+};
+
+// Get indices of the variadic template type parameters corresponding to
+// all arguments excluding results.
+template <size_t idx, typename... Ts>
+struct IndexArgs;
+
+template <size_t idx>
+struct IndexArgs<idx> {
+  using Is = std::index_sequence<>;
+};
+
+template <size_t idx, typename T, typename... Ts>
+struct IndexArgs<idx, T, Ts...> {
+  using Is = std::conditional_t<
+      !IsResult<T>::value,
+      typename ConsIdx<idx, typename IndexArgs<idx + 1, Ts...>::Is>::Type,
+      typename IndexArgs<idx + 1, Ts...>::Is>;
+};
+
+template <size_t... FnArgsIs, size_t... ResultIs, typename FnArgs,
+          typename Result>
+void SetResultsFromTuple(std::index_sequence<ResultIs...>, FnArgs fn_args,
+                         Result tuple) {
+  ((*std::get<FnArgsIs>(fn_args)).Set(std::get<ResultIs>(tuple)), ...);
+}
+
+// When decoding input data we need to keep track of how many arguments,
+// attributes, and returns we decoded so far to index into the correct data
+// structure.
+struct DecodingOffsets {
+  int64_t args = 0;
+  int64_t attrs = 0;
+  int64_t rets = 0;
+  int64_t values = 0;
+};
+
+struct DecodingContext {
+  internal::DecodedArgs args;
+  internal::DecodedRets rets;
+  internal::DecodedAttrs attrs;
+
+  // Attributes' names and mapping from attrs' offsets to indices in `attrs`.
+  absl::Span<const std::string> attrs_names;
+  absl::Span<const size_t> attrs_idx;
+
+  // Values bound to arguments at handler construction time.
+  absl::Span<const std::any> values;
+
+  // User-provided auxiliary data.
+  const CustomCall::UserData* user_data;
+
+  // User-provided diagnostic engine for reporting detailed errors.
+  const DiagnosticEngine* diagnostic;
+};
+
+template <typename T, CustomCall::RuntimeChecks checks>
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline FailureOr<T*> DecodeUserData(
+    const CustomCall::UserData* user_data) {
+  if (!CustomCall::CheckUserData(checks)) return user_data->get<T>();
+
+  // TODO(ezhulenev): Add an option to request nullable user data, because
+  // right now we do not distinguish between a user data pointer that doesn't
+  // exist, and a null pointer passed by the user.
+
+  // Get the requested value if user data was passed to the custom call.
+  auto* ptr = user_data ? user_data->getIfExists<T>() : nullptr;
+  if (LLVM_UNLIKELY(!ptr)) return failure();
+  return ptr;
+}
+
+template <typename T, CustomCall::RuntimeChecks checks>
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline FailureOr<T> DecodeAttr(
+    DecodingOffsets& offsets, absl::Span<const std::string> attrs_names,
+    absl::Span<const size_t> attrs_idx, internal::DecodedAttrs attrs) {
+  // Find decoded attribute corresponding for the given attribute index.
+  int64_t idx = offsets.attrs++;
+
+  // Do not check the attribute name, and decode attribute at the given index.
+  if (!CustomCall::CheckNames(checks)) {
+    size_t i = attrs_idx[idx];
+    return CustomCallAttrDecoding<T, checks>::Decode(
+        attrs[i].name, attrs[i].type_id, attrs[i].value);
+  }
+
+  std::string_view attr_name = attrs_names[idx];
+
+  // Given that attributes are passed to the custom call handler
+  // lexicographically sorted by name, we can find the attribute we are
+  // looking for only between the `attrs_idx` offset and the end of the
+  // attributes array.
+  for (size_t i = attrs_idx[idx]; i < attrs.size(); ++i) {
+    if (LLVM_LIKELY(attrs[i].name == attr_name))
+      return CustomCallAttrDecoding<T, checks>::Decode(
+          attrs[i].name, attrs[i].type_id, attrs[i].value);
+  }
+
+  // Attribute we were looking for was not passed as an argument.
+  return failure();
+}
+
+template <typename T, CustomCall::RuntimeChecks checks>
+struct Decode {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<T> call(
+      DecodingOffsets& offsets, DecodingContext& ctx) {
+    internal::DecodedArg arg = ctx.args[offsets.args++];
+    return CustomCallArgDecoding<T, checks>::Decode(arg.type_id, arg.value);
+  }
+};
+
+template <typename T, CustomCall::RuntimeChecks checks>
+struct Decode<internal::Ret<T>, checks> {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<Result<T>> call(
+      DecodingOffsets& offsets, DecodingContext& ctx) {
+    internal::DecodedRet ret = ctx.rets[offsets.rets++];
+    return CustomCallRetDecoding<T, checks>::Decode(ret.type_id, ret.value);
+  }
+};
+
+template <typename T, CustomCall::RuntimeChecks checks>
+struct Decode<internal::Attr<T>, checks> {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<T> call(
+      DecodingOffsets& offsets, DecodingContext& ctx) {
+    return DecodeAttr<T, checks>(offsets, ctx.attrs_names, ctx.attrs_idx,
+                                 ctx.attrs);
+  }
+};
+
+template <typename T, CustomCall::RuntimeChecks checks>
+struct Decode<internal::UserData<T>, checks> {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<T> call(
+      DecodingOffsets& offsets, DecodingContext& ctx) {
+    using UserDataT = std::remove_pointer_t<T>;
+    if (auto decoded = DecodeUserData<UserDataT, checks>(ctx.user_data);
+        LLVM_LIKELY(succeeded(decoded)))
+      return decoded;
+    return ctx.diagnostic->EmitError(InternalError(
+        "failed to decode UserData of type %s", typeid(T).name()));
+  }
+};
+
+template <typename T, CustomCall::RuntimeChecks checks>
+struct Decode<internal::StateTag<T>, checks> {
+  using Snapshot = typename StateVector<T>::Snapshot;
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<runtime::State<T>> call(
+      DecodingOffsets& offsets, DecodingContext& ctx) {
+    // Get the state snapshot and state id from user data and attributes.
+    FailureOr<Snapshot*> snapshot =
+        DecodeUserData<Snapshot, checks>(ctx.user_data);
+    FailureOr<int64_t> id = DecodeAttr<int64_t, checks>(
+        offsets, ctx.attrs_names, ctx.attrs_idx, ctx.attrs);
+    if (LLVM_UNLIKELY(failed(snapshot) || failed(id))) return failure();
+
+    return (*snapshot)->state(*id);
+  }
+};
+
+template <typename T, CustomCall::RuntimeChecks checks>
+struct Decode<internal::Value<T>, checks> {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<T> call(
+      DecodingOffsets& offsets, DecodingContext& ctx) {
+    return std::any_cast<T>(ctx.values[offsets.values++]);
+  }
+};
+
+template <CustomCall::RuntimeChecks checks>
+struct Decode<CustomCall::RemainingArgs, checks> {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<CustomCall::RemainingArgs> call(
+      DecodingOffsets& offsets, DecodingContext& ctx) {
+    return CustomCall::RemainingArgs(ctx.args, offsets.args);
+  }
+};
+
+template <CustomCall::RuntimeChecks checks>
+struct Decode<CustomCall::VariantArg, checks> {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<CustomCall::VariantArg> call(
+      DecodingOffsets& offsets, DecodingContext& ctx) {
+    return CustomCall::VariantArg(ctx.args, offsets.args++);
+  }
+};
+
+}  // namespace internal
+
+// Custom call handler binds concrete custom call implementation of type `Fn` to
+// the custom call function signature. `Fn` can be a function pointer, or a
+// lambda.
+//
+// Custom call handler uses the variadic template parameter `Ts` to decode the
+// opaque pointers passed to the `call` function into the C++ types that are
+// forwarded to the custom call implementation.
+template <CustomCall::RuntimeChecks checks, typename Fn, typename... Ts>
+class CustomCallHandler : public CustomCall {
+  static constexpr int64_t kSize = sizeof...(Ts);
+  static constexpr int64_t kNumArgs = internal::NumArgs<Ts...>::value;
+  static constexpr int64_t kNumRets = internal::NumRets<Ts...>::value;
+
+  template <typename T>
+  using FnArgType = typename internal::FnArgType<T>::Type;
+
+  template <typename T>
+  using UnwrapRet = typename internal::UnwrapRet<T>::Type;
+
+  // Custom call can signal error using a LogicalError result.
+  static constexpr bool kIsLogicalErr =
+      std::is_invocable_r_v<LogicalResult, Fn, FnArgType<Ts>...>;
+
+  // Custom call can signal error together with a detailed error message.
+  static constexpr bool kIsStatusErr =
+      std::is_invocable_r_v<absl::Status, Fn, FnArgType<Ts>...>;
+
+  // Custom call returns results as `absl::StatusOr<std::tuple<Ts...>>`
+  // (multiple results) or `absl::StatusOr<T>` (single result).
+  template <size_t... RetsIs, size_t... ArgsIs>
+  static constexpr bool IsStatusOrInvocable(std::index_sequence<RetsIs...>,
+                                            std::index_sequence<ArgsIs...>) {
+    // Define a tuple to help extracting type by index.
+    using ArgsTuple = std::tuple<FnArgType<Ts>...>;
+
+    // Custom call doesn't have any results.
+    if constexpr (sizeof...(RetsIs) == 0) return false;
+
+    // Custom call returns a single result.
+    if constexpr (sizeof...(RetsIs) == 1) {
+      using StatusOr =
+          absl::StatusOr<UnwrapRet<std::tuple_element_t<RetsIs, ArgsTuple>>...>;
+      return std::is_invocable_r_v<StatusOr, Fn,
+                                   std::tuple_element_t<ArgsIs, ArgsTuple>...>;
+    }
+
+    // Custom call returns multiple results as a tuple.
+    if constexpr (sizeof...(RetsIs) > 1) {
+      using StatusOr = absl::StatusOr<
+          std::tuple<UnwrapRet<std::tuple_element_t<RetsIs, ArgsTuple>>...>>;
+      return std::is_invocable_r_v<StatusOr, Fn,
+                                   std::tuple_element_t<ArgsIs, ArgsTuple>...>;
+    }
+
+    llvm_unreachable("unsupported result rank");
+  }
+
+  static constexpr bool kIsStatusOrResult =
+      IsStatusOrInvocable(typename internal::IndexRets<0, Ts...>::Is{},
+                          typename internal::IndexArgs<0, Ts...>::Is{});
+
+  static_assert(kIsLogicalErr || kIsStatusErr || kIsStatusOrResult,
+                "incompatible custom call handler types");
+
+ public:
+  std::string_view name() const final { return callee_; }
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE LogicalResult
+  call(void** args, void** attrs, void** rets, const UserData* user_data,
+       const DiagnosticEngine* diagnostic) const final {
+    // Decode arguments and attributes from the opaque pointers.
+    internal::DecodedArgs decoded_args(args);
+    internal::DecodedAttrs decoded_attrs(attrs);
+    internal::DecodedRets decoded_rets(rets);
+
+    int64_t num_args = decoded_args.size();
+    int64_t num_attrs = decoded_attrs.size();
+    int64_t num_rets = decoded_rets.size();
+
+    if (LLVM_UNLIKELY(diagnostic == nullptr))
+      diagnostic = DiagnosticEngine::DefaultDiagnosticEngine();
+
+    // If all runtime checks are disabled we are just reinterpreting opaque
+    // `args`, `attrs` and `rets` memory according to the custom call handler
+    // signature and skip all checks (these checks will be optimized out).
+    auto eval = [](bool condition) {
+      return checks == RuntimeChecks::kNone ? false : condition;
+    };
+
+    // Check that the number of passed arguments matches the signature. Each
+    // individual argument decoding will check the actual type.
+    if (internal::HasRemainingArgs<Ts...>::value) {
+      if (LLVM_UNLIKELY(eval(num_args < kNumArgs - 1)))
+        return diagnostic->EmitError(InvalidArgument(
+            "Wrong number of arguments: expected at least %d got %d",
+            kNumArgs - 1, num_args));
+    } else {
+      if (LLVM_UNLIKELY(eval(num_args != kNumArgs)))
+        return diagnostic->EmitError(
+            InvalidArgument("Wrong number of arguments: expected %d got %d",
+                            kNumArgs, num_args));
+    }
+
+    // Check that the number of returns matches the signature. The return
+    // decoding will check the actual type.
+    if (LLVM_UNLIKELY(eval(num_rets != kNumRets)))
+      return diagnostic->EmitError(InvalidArgument(
+          "Wrong number of returns: expected %d got %d", kNumRets, num_rets));
+
+    // Check that we have a correct number of attributes passed to the custom
+    // call. Each individual attribute decoding will check the name and the
+    // type of the attribute.
+    if (LLVM_UNLIKELY(eval(opts_.exact_attrs ? num_attrs != num_encoded_attrs_
+                                             : num_attrs < num_encoded_attrs_)))
+      return diagnostic->EmitError(InvalidArgument(
+          "Wrong number of attributes: expected %s%d got %d",
+          opts_.exact_attrs ? "" : "at least ", num_encoded_attrs_, num_attrs));
+
+    // Define index sequences to access custom call operands.
+    using Is = std::make_index_sequence<kSize>;
+    using ArgsIs = typename internal::IndexArgs<0, Ts...>::Is;
+    using RetsIs = typename internal::IndexRets<0, Ts...>::Is;
+
+    return call(decoded_args, decoded_attrs, decoded_rets, user_data,
+                diagnostic, Is{}, ArgsIs{}, RetsIs{});
+  }
+
+  template <size_t... Is, size_t... ArgsIs, size_t... RetsIs>
+  ABSL_ATTRIBUTE_ALWAYS_INLINE LogicalResult
+  call(internal::DecodedArgs args, internal::DecodedAttrs attrs,
+       internal::DecodedRets rets, const UserData* user_data,
+       const DiagnosticEngine* diagnostic, std::index_sequence<Is...>,
+       std::index_sequence<ArgsIs...>, std::index_sequence<RetsIs...>) const {
+    // A helper structure to allow each decoder find the correct offset in the
+    // arguments, attributes or results.
+    internal::DecodingOffsets offsets;
+
+    // Package all the data required for decoding custom call operands.
+    internal::DecodingContext ctx{args,       rets,    attrs,     attrs_,
+                                  attrs_idx_, values_, user_data, diagnostic};
+
+    // Decode all operands into FailureOr containers. It is guaranteed
+    // that initializer list will be evaluated left-to-right, and we can rely
+    // on correct offsets computation.
+    std::tuple<FailureOr<FnArgType<Ts>>...> fn_args = {
+        internal::Decode<Ts, checks>::call(offsets, ctx)...};
+
+    // Check if all operands and results were decoded.
+    bool all_decoded = (succeeded(std::get<Is>(fn_args)) && ...);
+
+    if (LLVM_UNLIKELY(!all_decoded)) {
+      std::array<bool, kSize> decoded = {succeeded(std::get<Is>(fn_args))...};
+      auto bad_args = llvm::make_filter_range(
+          llvm::enumerate(decoded), [](auto pair) { return !pair.value(); });
+      auto to_str = [](auto pair) { return std::to_string(pair.index()); };
+
+      return diagnostic->EmitError(InvalidArgument(
+          "Failed to decode all custom call operands (bad operads at: %s)",
+          llvm::join(llvm::map_range(bad_args, to_str), ", ")));
+    }
+
+    // Custom call returns logical result to signal failures.
+    if constexpr (kIsLogicalErr) {
+      return fn_(std::move(*std::get<Is>(fn_args))...);
+    }
+
+    // Custom call returns detailed error to signal failures.
+    if constexpr (kIsStatusErr) {
+      if (auto st = fn_(std::move(*std::get<Is>(fn_args))...); !st.ok()) {
+        return diagnostic->EmitError(std::move(st));
+      }
+      return success();
+    }
+
+    // Custom call returns result(s) as `absl::StatusOr`.
+    if constexpr (kIsStatusOrResult) {
+      auto status_or = fn_(std::move(*std::get<ArgsIs>(fn_args))...);
+      if (!status_or.ok()) {
+        return diagnostic->EmitError(status_or.status());
+      }
+
+      static_assert(sizeof...(RetsIs) >= 1, "unsupported number or results");
+
+      if constexpr (sizeof...(RetsIs) == 1) {
+        (*std::get<RetsIs...>(fn_args)).Set(status_or.value());
+        return success();
+      }
+
+      if constexpr (sizeof...(RetsIs) > 1) {
+        using ResultIs = std::make_index_sequence<kNumRets>;
+        internal::SetResultsFromTuple<RetsIs...>(ResultIs{}, std::move(fn_args),
+                                                 std::move(status_or.value()));
+        return success();
+      }
+    }
+
+    llvm_unreachable("unexpected custom call type");
+  }
+
+ private:
+  template <typename...>
+  friend class CustomCallBinding;
+
+  CustomCallHandler(Fn fn, std::string callee, std::vector<std::string> attrs,
+                    std::vector<std::any> values, const Options& opts)
+      : fn_(std::move(fn)),
+        callee_(std::move(callee)),
+        attrs_(std::move(attrs)),
+        values_(std::move(values)),
+        opts_(opts),
+        attrs_idx_(attrs_.size()) {
+    // Sort attributes names and remove duplicates. These unique attributes are
+    // what we'll be looking for in the encoded custom call attributes.
+    std::vector<std::string> sorted = attrs_;
+    std::sort(sorted.begin(), sorted.end());
+    sorted.erase(
+        std::unique(sorted.begin(), sorted.end(), std::equal_to<std::string>()),
+        sorted.end());
+    num_encoded_attrs_ = sorted.size();
+
+    // Find index or every attribute in the sorted attributes vector.
+    for (size_t i = 0; i < attrs_.size(); ++i) {
+      std::string_view attr = attrs_[i];
+      attrs_idx_[i] = std::distance(sorted.begin(), llvm::find(sorted, attr));
+    }
+  }
+
+  Fn fn_;
+  std::string callee_;
+  std::vector<std::string> attrs_;
+  std::vector<std::any> values_;
+  Options opts_;
+
+  // A mapping from the attribute index to its index in the lexicographically
+  // sorter vector of attribute names. Attributes passed in the custom call
+  // handler sorted by the name, we use this index to efficiently find the
+  // decoded attribute entry.
+  std::vector<size_t> attrs_idx_;
+
+  // The number of attributes we expect in the encoded custom call arguments.
+  // This is not the same as `attrs_.size()` because of potential duplicates,
+  // e.g. attribute corresponding to state id might be used multiple times.
+  size_t num_encoded_attrs_;
+};
+
+template <CustomCall::RuntimeChecks checks, typename Fn, typename... Ts>
+constexpr int64_t CustomCallHandler<checks, Fn, Ts...>::kSize;
+
+template <CustomCall::RuntimeChecks checks, typename Fn, typename... Ts>
+constexpr int64_t CustomCallHandler<checks, Fn, Ts...>::kNumArgs;
+
+template <CustomCall::RuntimeChecks checks, typename Fn, typename... Ts>
+constexpr int64_t CustomCallHandler<checks, Fn, Ts...>::kNumRets;
+
+//===----------------------------------------------------------------------===//
+// Custom arguments decoding.
+//===----------------------------------------------------------------------===//
+
+llvm::raw_ostream& operator<<(llvm::raw_ostream& os, const StridedMemrefView&);
+llvm::raw_ostream& operator<<(llvm::raw_ostream& os, const MemrefView&);
+llvm::raw_ostream& operator<<(llvm::raw_ostream& os, const FlatMemrefView&);
+
+template <CustomCall::RuntimeChecks checks>
+struct CustomCallArgDecoding<StridedMemrefView, checks> {
+  using EncodedMemref = internal::EncodedMemref;
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE
+  static FailureOr<StridedMemrefView> Decode(TypeID type_id, void* value) {
+    if (!CustomCall::Isa<MemrefView, StridedMemrefView>(checks, type_id)) {
+      return failure();
+    }
+
+    auto* encoded = reinterpret_cast<EncodedMemref*>(value);
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(encoded, sizeof(EncodedMemref));
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(
+        encoded, sizeof(EncodedMemref) + encoded->rank * sizeof(int64_t));
+
+    PrimitiveType dtype = static_cast<PrimitiveType>(encoded->dtype);
+    return StridedMemrefView{dtype,
+                             encoded->data,
+                             {encoded->dims, encoded->rank},
+                             {encoded->dims + encoded->rank, encoded->rank}};
+  }
+};
+
+template <CustomCall::RuntimeChecks checks>
+struct CustomCallArgDecoding<MemrefView, checks> {
+  using EncodedMemref = internal::EncodedMemref;
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE
+  static FailureOr<MemrefView> Decode(TypeID type_id, void* value) {
+    if (!CustomCall::Isa<MemrefView>(checks, type_id)) {
+      return failure();
+    }
+
+    auto* encoded = reinterpret_cast<EncodedMemref*>(value);
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(encoded, sizeof(EncodedMemref));
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(
+        encoded, sizeof(EncodedMemref) + encoded->rank * sizeof(int64_t));
+
+    PrimitiveType dtype = static_cast<PrimitiveType>(encoded->dtype);
+    return MemrefView{dtype, encoded->data, {encoded->dims, encoded->rank}};
+  }
+};
+
+template <CustomCall::RuntimeChecks checks>
+struct CustomCallArgDecoding<FlatMemrefView, checks> {
+  using EncodedMemref = internal::EncodedMemref;
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE
+  static FailureOr<FlatMemrefView> Decode(TypeID type_id, void* value) {
+    if (!CustomCall::Isa<MemrefView>(checks, type_id)) {
+      return failure();
+    }
+
+    auto* encoded = reinterpret_cast<EncodedMemref*>(value);
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(encoded, sizeof(EncodedMemref));
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(
+        encoded, sizeof(EncodedMemref) + encoded->rank * sizeof(int64_t));
+
+    PrimitiveType dtype = static_cast<PrimitiveType>(encoded->dtype);
+    int64_t size_in_bytes = primitive_util::ByteWidth(dtype);
+    for (int d = 0; d < encoded->rank; ++d) size_in_bytes *= encoded->dims[d];
+    return FlatMemrefView{dtype, encoded->data, size_in_bytes};
+  }
+};
+
+#define XLA_RUNTIME_REGISTER_SCALAR_ARG_DECODING(T)                         \
+  template <CustomCall::RuntimeChecks checks>                               \
+  struct CustomCallArgDecoding<T, checks> {                                 \
+    ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<T> Decode(TypeID type_id, \
+                                                            void* value) {  \
+      if (!CustomCall::Isa<T>(checks, type_id)) {                           \
+        return failure();                                                   \
+      }                                                                     \
+                                                                            \
+      ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(value, sizeof(T));                \
+      return *reinterpret_cast<T*>(value);                                  \
+    }                                                                       \
+  }
+
+XLA_RUNTIME_REGISTER_SCALAR_ARG_DECODING(bool);
+XLA_RUNTIME_REGISTER_SCALAR_ARG_DECODING(int8_t);
+XLA_RUNTIME_REGISTER_SCALAR_ARG_DECODING(int16_t);
+XLA_RUNTIME_REGISTER_SCALAR_ARG_DECODING(int32_t);
+XLA_RUNTIME_REGISTER_SCALAR_ARG_DECODING(int64_t);
+XLA_RUNTIME_REGISTER_SCALAR_ARG_DECODING(float);
+XLA_RUNTIME_REGISTER_SCALAR_ARG_DECODING(double);
+
+#undef XLA_RUNTIME_REGISTER_SCALAR_ARG_DECODING
+
+// Register decoding for special floating point types defined in Eigen.
+#define XLA_RUNTIME_REGISTER_EIGEN_FP_ARG_DECODING(T, STORAGE)              \
+  template <CustomCall::RuntimeChecks checks>                               \
+  struct CustomCallArgDecoding<T, checks> {                                 \
+    ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<T> Decode(TypeID type_id, \
+                                                            void* value) {  \
+      if (!CustomCall::Isa<T>(checks, type_id)) {                           \
+        return failure();                                                   \
+      }                                                                     \
+                                                                            \
+      auto* src = reinterpret_cast<STORAGE*>(value);                        \
+      ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(value, sizeof(STORAGE));          \
+      return Eigen::numext::bit_cast<T>(*src);                              \
+    }                                                                       \
+  }
+
+XLA_RUNTIME_REGISTER_EIGEN_FP_ARG_DECODING(Eigen::bfloat16, uint16_t);
+XLA_RUNTIME_REGISTER_EIGEN_FP_ARG_DECODING(Eigen::half, uint16_t);
+
+#undef XLA_RUNTIME_REGISTER_EIGEN_FP_ARG_DECODING
+
+//===----------------------------------------------------------------------===//
+// Opaque arguments at run time passed as pointers and decoded by wrapping them
+// into a reference type, for example `AsyncValue *` pointer can be wrapped into
+// a typed `AsyncValuePtr<T>` pointer wrapper.
+//===----------------------------------------------------------------------===//
+
+#define XLA_RUNTIME_REGISTER_OPAQUE_ARG_DECODING(T, PTR)                    \
+  template <CustomCall::RuntimeChecks checks>                               \
+  struct CustomCallArgDecoding<T, checks> {                                 \
+    static_assert(std::is_pointer_v<PTR>, "must be a pointer");             \
+    static_assert(std::is_trivially_destructible_v<T>,                      \
+                  "must be a trivially destructible reference type");       \
+                                                                            \
+    ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<T> Decode(TypeID type_id, \
+                                                            void* value) {  \
+      if (!CustomCall::Isa<T>(checks, type_id)) {                           \
+        return failure();                                                   \
+      }                                                                     \
+                                                                            \
+      auto* src = reinterpret_cast<PTR*>(value);                            \
+      ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(value, sizeof(PTR));              \
+      T ref{*src};                                                          \
+      return std::move(ref);                                                \
+    }                                                                       \
+  }
+
+XLA_RUNTIME_REGISTER_OPAQUE_ARG_DECODING(void*, void*);
+
+//===----------------------------------------------------------------------===//
+// Custom call results decoding.
+//===----------------------------------------------------------------------===//
+
+#define XLA_RUNTIME_REGISTER_SCALAR_RET_DECODING(T)                  \
+  template <>                                                        \
+  class Result<T> {                                                  \
+   public:                                                           \
+    explicit Result(T* storage) : storage_(storage) {}               \
+    void Set(T value) { *storage_ = value; }                         \
+                                                                     \
+   private:                                                          \
+    T* storage_;                                                     \
+  };                                                                 \
+                                                                     \
+  template <CustomCall::RuntimeChecks checks>                        \
+  struct CustomCallRetDecoding<T, checks> {                          \
+    ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<Result<T>> Decode( \
+        TypeID type_id, void* value) {                               \
+      if (!CustomCall::Isa<T>(checks, type_id)) {                    \
+        return failure();                                            \
+      }                                                              \
+                                                                     \
+      return Result<T>(reinterpret_cast<T*>(value));                 \
+    }                                                                \
+  };
+
+XLA_RUNTIME_REGISTER_SCALAR_RET_DECODING(bool);
+XLA_RUNTIME_REGISTER_SCALAR_RET_DECODING(int8_t);
+XLA_RUNTIME_REGISTER_SCALAR_RET_DECODING(int16_t);
+XLA_RUNTIME_REGISTER_SCALAR_RET_DECODING(int32_t);
+XLA_RUNTIME_REGISTER_SCALAR_RET_DECODING(int64_t);
+XLA_RUNTIME_REGISTER_SCALAR_RET_DECODING(float);
+XLA_RUNTIME_REGISTER_SCALAR_RET_DECODING(double);
+
+#undef XLA_RUNTIME_REGISTER_SCALAR_RET_DECODING
+
+//===----------------------------------------------------------------------===//
+// Opaque results at run time passed as pointers, and a typed wrapper binds
+// together the reference type and the underlying pointer type.
+//===----------------------------------------------------------------------===//
+
+#define XLA_RUNTIME_REGISTER_OPAQUE_RET_DECODING(T, PTR)             \
+  template <>                                                        \
+  class Result<T> {                                                  \
+    static_assert(std::is_pointer_v<PTR>, "must be a pointer type"); \
+                                                                     \
+   public:                                                           \
+    explicit Result(PTR* storage) : storage_(storage) {}             \
+    void Set(PTR value) { *storage_ = value; }                       \
+                                                                     \
+   private:                                                          \
+    PTR* storage_;                                                   \
+  };                                                                 \
+                                                                     \
+  template <CustomCall::RuntimeChecks checks>                        \
+  struct CustomCallRetDecoding<T, checks> {                          \
+    static_assert(std::is_pointer_v<PTR>, "must be a pointer type"); \
+                                                                     \
+    ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<Result<T>> Decode( \
+        TypeID type_id, void* value) {                               \
+      if (!CustomCall::Isa<T>(checks, type_id)) {                    \
+        return failure();                                            \
+      }                                                              \
+                                                                     \
+      return Result<T>(reinterpret_cast<PTR*>(value));               \
+    }                                                                \
+  };
+
+XLA_RUNTIME_REGISTER_OPAQUE_RET_DECODING(void*, void*);
+
+//===----------------------------------------------------------------------===//
+
+// Custom call memref result decoding
+template <>
+class Result<MemrefView> {
+  using EncodedMemref = internal::EncodedMemref;
+
+ public:
+  explicit Result(EncodedMemref* storage) : storage_(storage) {}
+  void Set(MemrefView value) {
+    assert(IsCompatible(value) &&
+           "Custom call return types is not compatible with types in MLIR");
+    storage_->data = value.data;
+    for (unsigned i = 0; i < storage_->rank; ++i) {
+      storage_->dims[i] = value.sizes[i];
+    }
+  }
+
+  PrimitiveType GetDType() { return PrimitiveType{storage_->dtype}; }
+  absl::Span<const int64_t> GetDims() {
+    return absl::Span<const int64_t>(storage_->dims, storage_->rank);
+  }
+
+ private:
+  bool IsCompatible(MemrefView value) {
+    bool is_compatible =
+        storage_->dtype == value.dtype && storage_->rank == value.sizes.size();
+    if (!is_compatible) return false;
+
+    for (unsigned i = 0; i < storage_->rank; ++i) {
+      is_compatible = (storage_->dims[i] == value.sizes[i]) ||
+                      (storage_->dims[i] == /*MemrefType::kDynamic=*/-1);
+    }
+    return is_compatible;
+  }
+
+  EncodedMemref* storage_;
+};
+
+template <CustomCall::RuntimeChecks checks>
+struct CustomCallRetDecoding<MemrefView, checks> {
+  using EncodedMemref = internal::EncodedMemref;
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE
+  static FailureOr<Result<MemrefView>> Decode(TypeID type_id, void* value) {
+    if (!CustomCall::Isa<MemrefView>(checks, type_id)) return failure();
+
+    auto* encoded = reinterpret_cast<EncodedMemref*>(value);
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(encoded, sizeof(EncodedMemref));
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(
+        encoded, sizeof(EncodedMemref) + encoded->rank * sizeof(int64_t));
+    return Result<MemrefView>(encoded);
+  }
+};
+
+//===----------------------------------------------------------------------===//
+
+// Custom call AsyncValueRef result decoding
+#define XLA_RUNTIME_REGISTER_ASYNC_SCALAR_VALUE_RET_DECODING(T)              \
+  template <>                                                                \
+  class Result<tsl::AsyncValueRef<T>> {                                      \
+   public:                                                                   \
+    explicit Result(void** storage) : storage_(storage) {}                   \
+    void Set(tsl::AsyncValueRef<T> value) {                                  \
+      auto write = [](const T* v, std::byte* store) {                        \
+        T* store_t = reinterpret_cast<T*>(store);                            \
+        *store_t = *v;                                                       \
+      };                                                                     \
+      *storage_ = runtime::AsyncRuntime::AsValue<T>(                         \
+          value, sizeof(T), alignof(std::max_align_t), write);               \
+    }                                                                        \
+                                                                             \
+   private:                                                                  \
+    void** storage_;                                                         \
+  };                                                                         \
+                                                                             \
+  template <CustomCall::RuntimeChecks checks>                                \
+  struct CustomCallRetDecoding<tsl::AsyncValueRef<T>, checks> {              \
+    LLVM_ATTRIBUTE_ALWAYS_INLINE                                             \
+    static FailureOr<Result<tsl::AsyncValueRef<T>>> Decode(TypeID type_id,   \
+                                                           void* value) {    \
+      if (!CustomCall::Isa<tsl::AsyncValueRef<T>>(checks, type_id))          \
+        return failure();                                                    \
+      return Result<tsl::AsyncValueRef<T>>(reinterpret_cast<void**>(value)); \
+    }                                                                        \
+  };
+
+XLA_RUNTIME_REGISTER_ASYNC_SCALAR_VALUE_RET_DECODING(bool);
+XLA_RUNTIME_REGISTER_ASYNC_SCALAR_VALUE_RET_DECODING(int8_t);
+XLA_RUNTIME_REGISTER_ASYNC_SCALAR_VALUE_RET_DECODING(int16_t);
+XLA_RUNTIME_REGISTER_ASYNC_SCALAR_VALUE_RET_DECODING(int32_t);
+XLA_RUNTIME_REGISTER_ASYNC_SCALAR_VALUE_RET_DECODING(int64_t);
+XLA_RUNTIME_REGISTER_ASYNC_SCALAR_VALUE_RET_DECODING(float);
+XLA_RUNTIME_REGISTER_ASYNC_SCALAR_VALUE_RET_DECODING(double);
+
+#undef XLA_RUNTIME_REGISTER_ASYNC_SCALAR_VALUE_RET_DECODING
+
+template <>
+class Result<tsl::AsyncValueRef<tsl::Chain>> {
+ public:
+  explicit Result(void** storage) : storage_(storage) {}
+  void Set(tsl::AsyncValueRef<tsl::Chain> value) {
+    *storage_ = runtime::AsyncRuntime::AsToken(value);
+  }
+
+ private:
+  void** storage_;
+};
+
+template <CustomCall::RuntimeChecks checks>
+struct CustomCallRetDecoding<tsl::AsyncValueRef<tsl::Chain>, checks> {
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  static FailureOr<Result<tsl::AsyncValueRef<tsl::Chain>>> Decode(
+      TypeID type_id, void* value) {
+    if (!CustomCall::Isa<tsl::AsyncValueRef<tsl::Chain>>(checks, type_id))
+      return failure();
+
+    return Result<tsl::AsyncValueRef<tsl::Chain>>(
+        reinterpret_cast<void**>(value));
+  }
+};
+
+template <>
+class Result<tsl::AsyncValueRef<MemrefView>> {
+  using EncodedMemref = internal::EncodedMemref;
+
+  struct MemrefDescriptor {
+    void* allocated_ptr;
+    void* aligned_ptr;
+    int64_t offset;
+    int64_t dims[];
+  };
+
+ public:
+  explicit Result(EncodedMemref* storage) : storage_(storage) {}
+  void Set(tsl::AsyncValueRef<MemrefView> value) {
+    auto write = [this](const MemrefView* view, std::byte* store) {
+      assert(IsCompatible(*view) &&
+             "Custom call return types is not compatible with types in MLIR");
+      MemrefDescriptor* store_t = reinterpret_cast<MemrefDescriptor*>(store);
+      store_t->allocated_ptr = view->data;
+      store_t->aligned_ptr = view->data;
+      store_t->offset = 0;
+      for (unsigned i = 0; i < storage_->rank; ++i) {
+        store_t->dims[i] = view->sizes[i];
+      }
+    };
+    storage_->data = runtime::AsyncRuntime::AsValue<MemrefView>(
+        value, 3 * sizeof(int64_t) + 2 * storage_->rank * sizeof(int64_t),
+        alignof(std::max_align_t), write);
+  }
+
+  PrimitiveType GetDType() { return PrimitiveType{storage_->dtype}; }
+  absl::Span<const int64_t> GetDims() {
+    return absl::Span<const int64_t>(storage_->dims, storage_->rank);
+  }
+
+ private:
+  bool IsCompatible(MemrefView value) {
+    bool is_compatible =
+        storage_->dtype == value.dtype && storage_->rank == value.sizes.size();
+    if (!is_compatible) return false;
+
+    for (unsigned i = 0; i < storage_->rank; ++i) {
+      is_compatible = (storage_->dims[i] == value.sizes[i]) ||
+                      (storage_->dims[i] == /*MemrefType::kDynamic=*/-1);
+    }
+
+    return is_compatible;
+  }
+
+  EncodedMemref* storage_;
+};
+
+template <CustomCall::RuntimeChecks checks>
+struct CustomCallRetDecoding<tsl::AsyncValueRef<MemrefView>, checks> {
+  using EncodedMemref = internal::EncodedMemref;
+
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  static FailureOr<Result<tsl::AsyncValueRef<MemrefView>>> Decode(
+      TypeID type_id, void* value) {
+    if (!CustomCall::Isa<tsl::AsyncValueRef<MemrefView>>(checks, type_id))
+      return failure();
+
+    auto* encoded = reinterpret_cast<EncodedMemref*>(value);
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(encoded, sizeof(EncodedMemref));
+    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(
+        encoded, sizeof(EncodedMemref) + encoded->rank * sizeof(int64_t));
+
+    return Result<tsl::AsyncValueRef<MemrefView>>(encoded);
+  }
+};
+
+// XLA_RUNTIME_REGISTER_ASYNC_VALUE_RET_DECODING(MemrefView);
+
+//===----------------------------------------------------------------------===//
+// Custom call attributes decoding.
+//===----------------------------------------------------------------------===//
+
+template <CustomCall::RuntimeChecks checks>
+struct CustomCallAttrDecoding<std::string_view, checks> {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<std::string_view> Decode(
+      std::string_view name, TypeID type_id, void* value) {
+    if (!CustomCall::Isa<std::string_view>(checks, type_id)) {
+      return failure();
+    }
+
+    auto* encoded = reinterpret_cast<internal::EncodedArray<char>*>(value);
+    return std::string_view(encoded->data, encoded->size);
+  }
+};
+
+template <CustomCall::RuntimeChecks checks>
+struct CustomCallAttrDecoding<CustomCall::FunctionOrdinal, checks> {
+  using FunctionOrdinal = CustomCall::FunctionOrdinal;
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<FunctionOrdinal> Decode(
+      std::string_view name, TypeID type_id, void* value) {
+    if (!CustomCall::Isa<FunctionOrdinal>(checks, type_id)) {
+      return failure();
+    }
+
+    unsigned ordinal = *reinterpret_cast<int32_t*>(value);
+    return FunctionOrdinal{ordinal};
+  }
+};
+
+template <typename T, CustomCall::RuntimeChecks checks>
+struct CustomCallAttrDecoding<std::optional<T>, checks> {
+  using ValueDecoding = CustomCallAttrDecoding<T, checks>;
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<std::optional<T>> Decode(
+      std::string_view name, TypeID type_id, void* value) {
+    // Convert nullptr to empty optional.
+    bool is_nullopt = CustomCall::Isa<std::nullopt_t>(checks, type_id);
+    if (is_nullopt && value == nullptr) return std::optional<T>();
+
+    // Try to decode the underlying value if it is present.
+    if (auto decoded = ValueDecoding::Decode(name, type_id, value);
+        succeeded(decoded)) {
+      return std::optional<T>(std::move(*decoded));
+    }
+    return failure();
+  }
+};
+
+template <CustomCall::RuntimeChecks checks>
+struct CustomCallAttrDecoding<CustomCall::VariantAttr, checks> {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<CustomCall::VariantAttr> Decode(
+      std::string_view name, TypeID type_id, void* value) {
+    return CustomCall::VariantAttr(name, type_id, value);
+  }
+};
+
+#define XLA_RUNTIME_REGISTER_SCALAR_ATTR_DECODING(T)          \
+  template <CustomCall::RuntimeChecks checks>                 \
+  struct CustomCallAttrDecoding<T, checks> {                  \
+    ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<T> Decode(  \
+        std::string_view name, TypeID type_id, void* value) { \
+      if (!CustomCall::Isa<T>(checks, type_id)) {             \
+        return failure();                                     \
+      }                                                       \
+                                                              \
+      return *reinterpret_cast<T*>(value);                    \
+    }                                                         \
+  }
+
+XLA_RUNTIME_REGISTER_SCALAR_ATTR_DECODING(bool);
+XLA_RUNTIME_REGISTER_SCALAR_ATTR_DECODING(int32_t);
+XLA_RUNTIME_REGISTER_SCALAR_ATTR_DECODING(int64_t);
+XLA_RUNTIME_REGISTER_SCALAR_ATTR_DECODING(float);
+XLA_RUNTIME_REGISTER_SCALAR_ATTR_DECODING(double);
+
+#undef XLA_RUNTIME_REGISTER_SCALAR_ATTR_DECODING
+
+// A type tag to represent empty arrays of unknown element type.
+struct EmptyArray {};
+
+// Both EncodedArray and 1-D EncodedDenseElements can be decoded as an
+// absl::Span. Pointers to both EncodedArray and 1-D EncodedDenseElements
+// can be dereferenced as a pointer to EncodedArray.
+#define XLA_RUNTIME_REGISTER_ARRAY_ATTR_DECODING(T)                            \
+  template <CustomCall::RuntimeChecks checks>                                  \
+  struct CustomCallAttrDecoding<absl::Span<const T>, checks> {                 \
+    ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<absl::Span<const T>> Decode( \
+        std::string_view name, TypeID type_id, void* value) {                  \
+      if (!CustomCall::Isa<absl::Span<const T>, CustomCall::TensorRef<T>,      \
+                           EmptyArray>(checks, type_id)) {                     \
+        return failure();                                                      \
+      }                                                                        \
+                                                                               \
+      auto* encoded = reinterpret_cast<internal::EncodedArray<T>*>(value);     \
+      return absl::Span<const T>(encoded->data, encoded->size);                \
+    }                                                                          \
+  }
+
+XLA_RUNTIME_REGISTER_ARRAY_ATTR_DECODING(int32_t);
+XLA_RUNTIME_REGISTER_ARRAY_ATTR_DECODING(int64_t);
+XLA_RUNTIME_REGISTER_ARRAY_ATTR_DECODING(float);
+XLA_RUNTIME_REGISTER_ARRAY_ATTR_DECODING(double);
+
+#undef XLA_RUNTIME_REGISTER_ARRAY_ATTR_DECODING
+
+#define XLA_RUNTIME_REGISTER_DENSE_ELEMENTS_ATTR_DECODING(T)                \
+  template <CustomCall::RuntimeChecks checks>                               \
+  struct CustomCallAttrDecoding<CustomCall::TensorRef<T>, checks> {         \
+    ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<CustomCall::TensorRef<T>> \
+    Decode(std::string_view name, TypeID type_id, void* value) {            \
+      if (!CustomCall::Isa<CustomCall::TensorRef<T>>(checks, type_id)) {    \
+        return failure();                                                   \
+      }                                                                     \
+                                                                            \
+      auto* encoded =                                                       \
+          reinterpret_cast<internal::EncodedDenseElements<T>*>(value);      \
+      auto payload = encoded->payload;                                      \
+      absl::Span<const T> data(payload.data, payload.size);                 \
+      absl::Span<const int64_t> shape(encoded->shape, encoded->rank);       \
+      return CustomCall::TensorRef<T>({shape, data});                       \
+    }                                                                       \
+  }
+
+XLA_RUNTIME_REGISTER_DENSE_ELEMENTS_ATTR_DECODING(int32_t);
+XLA_RUNTIME_REGISTER_DENSE_ELEMENTS_ATTR_DECODING(int64_t);
+XLA_RUNTIME_REGISTER_DENSE_ELEMENTS_ATTR_DECODING(float);
+XLA_RUNTIME_REGISTER_DENSE_ELEMENTS_ATTR_DECODING(double);
+
+#undef XLA_RUNTIME_REGISTER_DENSE_ELEMENTS_ATTR_DECODING
+
+//===----------------------------------------------------------------------===//
+// Register an XLA custom call attribute decoding for enum class. At runtime the
+// value should be passed as the underlying enum type.
+//===----------------------------------------------------------------------===//
+
+// Example: register decoding for a user-defined enum class
+//
+//   enum class MyEnumType { kFoo, kBar, kBaz };
+//
+//   XLA_RUNTIME_REGISTER_ENUM_ATTR_DECODING(MyEnumType);
+//
+#define XLA_RUNTIME_REGISTER_ENUM_ATTR_DECODING(T)                \
+  template <CustomCall::RuntimeChecks checks>                     \
+  struct CustomCallAttrDecoding<T, checks> {                      \
+    static_assert(std::is_enum<T>::value, "expected enum class"); \
+    using U = std::underlying_type_t<T>;                          \
+                                                                  \
+    ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<T> Decode(      \
+        std::string_view name, TypeID type_id, void* value) {     \
+      if (!CustomCall::Isa<T>(checks, type_id)) {                 \
+        return failure();                                         \
+      }                                                           \
+                                                                  \
+      return static_cast<T>(*reinterpret_cast<U*>(value));        \
+    }                                                             \
+  }
+
+//===----------------------------------------------------------------------===//
+// Register an XLA custom call attribute decoding for aggregate attributes.
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+struct AggregateMember {
+  using Type = T;
+
+  explicit AggregateMember(std::string_view name) : name(name) {}
+  std::string_view name;
+};
+
+// Example: register decoding for a user-defined struct
+//
+//   struct PairOfI64 { int64_t a; int64_t b; };
+//
+//   XLA_RUNTIME_REGISTER_AGGREGATE_ATTR_DECODING(
+//     PairOfI64,
+//     AggregateMember<int64_t>("a"),
+//     AggregateMember<int64_t>("b"));
+//
+#define XLA_RUNTIME_REGISTER_AGGREGATE_ATTR_DECODING(T, ...)                   \
+  template <CustomCall::RuntimeChecks checks>                                  \
+  struct CustomCallAttrDecoding<T, checks> {                                   \
+    ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<T> Decode(                   \
+        std::string_view name, TypeID type_id, void* value) {                  \
+      if (!CustomCall::Isa<T>(checks, type_id)) {                              \
+        return failure();                                                      \
+      }                                                                        \
+                                                                               \
+      auto decoder = internal::AggregateDecoder<T, checks>(__VA_ARGS__);       \
+      return decltype(decoder)::Decode(reinterpret_cast<void**>(value),        \
+                                       internal::AggregateNames(__VA_ARGS__)); \
+    }                                                                          \
+  }
+
+namespace internal {
+// Decodes aggregate attribute into the object of type `T` that must be
+// constructible from the `Ts` types.
+template <typename T, CustomCall::RuntimeChecks checks, typename... Ts>
+struct DecodeAggregateAttr {
+  static constexpr size_t kSize = sizeof...(Ts);
+
+  using RuntimeChecks = CustomCall::RuntimeChecks;
+
+  ABSL_ATTRIBUTE_ALWAYS_INLINE
+  static FailureOr<T> Decode(void** value,
+                             std::array<std::string_view, kSize> names) {
+    internal::DecodedAttrs attrs(value);
+    return Decode(attrs, names, std::make_index_sequence<kSize>{});
+  }
+
+  template <size_t... Is>
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<T> Decode(
+      internal::DecodedAttrs attrs, std::array<std::string_view, kSize> names,
+      std::index_sequence<Is...>) {
+    // Check that the number of encoded attributes matches the signature.
+    if (checks != RuntimeChecks::kNone && kSize != attrs.size())
+      return failure();
+
+    // Check that aggregate member names match the expected names.
+    if (CustomCall::CheckNames(checks)) {
+      for (unsigned i = 0; i < kSize; ++i)
+        if (attrs[i].name != names[i]) return failure();
+    }
+
+    // Decode all arguments into FailureOr containers. It is guaranteed
+    // that initializer list will be evaluated left-to-right, and we can rely
+    // on correct offsets computation.
+    std::tuple<FailureOr<Ts>...> members = {
+        CustomCallAttrDecoding<Ts, checks>::Decode(
+            attrs[Is].name, attrs[Is].type_id, attrs[Is].value)...};
+
+    bool all_decoded = (succeeded(std::get<Is>(members)) && ...);
+    if (LLVM_UNLIKELY(!all_decoded)) return failure();
+
+    // Forward unpacked members to the type constructor.
+    return T{std::move(*std::get<Is>(members))...};
+  }
+};
+
+template <typename... Members>
+auto AggregateNames(Members... m) {
+  return std::array<std::string_view, sizeof...(Members)>{m.name...};
+}
+
+template <typename T, CustomCall::RuntimeChecks checks, typename... Members>
+auto AggregateDecoder(Members... m) {
+  return DecodeAggregateAttr<T, checks, typename Members::Type...>();
+}
+
+}  // namespace internal
+
+//===----------------------------------------------------------------------===//
+// Register an XLA custom call attribute decoding for dictionary attributes.
+//===----------------------------------------------------------------------===//
+
+// Dictionary attributes are encoded using the same scheme as aggregate
+// attributes and as custom call attributes: <type_id, name, data> x length.
+class Dictionary {
+  using RuntimeChecks = CustomCall::RuntimeChecks;
+
+ public:
+  explicit Dictionary(internal::DecodedAttrs attrs) : attrs_(attrs) {}
+
+  int64_t size() { return attrs_.size(); }
+
+  std::vector<std::string_view> keys() {
+    std::vector<std::string_view> attr_keys(attrs_.size());
+    for (int64_t i = 0; i < attrs_.size(); ++i) {
+      attr_keys[i] = attrs_[i].name;
+    }
+    return attr_keys;
+  }
+
+  template <typename T, RuntimeChecks checks = RuntimeChecks::kDefault>
+  ABSL_ATTRIBUTE_ALWAYS_INLINE FailureOr<T> get(std::string_view name) const {
+    // TODO(ezhulenev): Use `std::binary_search` because it's guaranteed that
+    // encoded attributes are sorted by name.
+    for (int64_t i = 0; i < attrs_.size(); ++i) {
+      if (auto attr = attrs_[i]; attr.name == name)
+        return CustomCallAttrDecoding<T, checks>::Decode(
+            attr.name, attr.type_id, attr.value);
+    }
+    return failure();
+  }
+
+ private:
+  internal::DecodedAttrs attrs_;
+};
+
+template <CustomCall::RuntimeChecks checks>
+struct CustomCallAttrDecoding<Dictionary, checks> {
+  ABSL_ATTRIBUTE_ALWAYS_INLINE static FailureOr<Dictionary> Decode(
+      std::string_view name, TypeID type_id, void* value) {
+    if (!CustomCall::Isa<Dictionary>(checks, type_id)) return failure();
+    return Dictionary(internal::DecodedAttrs(reinterpret_cast<void**>(value)));
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// XLA Custom Call helper macro for registering custom call handlers.
+//===----------------------------------------------------------------------===//
+
+#define XLA_RUNTIME_DEFINE_CUSTOM_CALL(fn, impl, checks, bind)             \
+  static bool fn(::xla::runtime::ExecutionContext* ctx, void** args,       \
+                 void** attrs, void** rets) {                              \
+    static auto* handler = bind.To<checks>(impl).release();                \
+    return ::xla::runtime::succeeded(                                      \
+        xla::runtime::Executable::Call(ctx, *handler, args, attrs, rets)); \
+  }
+
+#define XLA_RUNTIME_DEFINE_CUSTOM_CALL_TEMPLATE(param, fn, impl, checks, bind) \
+  template <param>                                                             \
+  static bool fn(::xla::runtime::ExecutionContext* ctx, void** args,           \
+                 void** attrs, void** rets) {                                  \
+    static auto* handler = bind.To<checks>(impl).release();                    \
+    return ::xla::runtime::succeeded(                                          \
+        xla::runtime::Executable::Call(ctx, *handler, args, attrs, rets));     \
+  }
+
+//===----------------------------------------------------------------------===//
+// Declare/define an explicit specialization for TypeID for types used
+// by the custom calls. This forces the compiler to emit a strong definition for
+// a class and controls which translation unit and shared object will actually
+// have it.
+//
+// See TypeID for more documentation.
+//
+// Because custom calls do not "own" the types passed across the function
+// boundary, we declare/define specializations for tagged types to avoid
+// potential conflicts with other libraries.
+//===----------------------------------------------------------------------===//
+
+#define XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(T) \
+  MLIR_DECLARE_EXPLICIT_TYPE_ID(::xla::runtime::Tagged<T>)
+
+#define XLA_RUNTIME_DEFINE_EXPLICIT_TYPE_ID(T) \
+  MLIR_DEFINE_EXPLICIT_TYPE_ID(::xla::runtime::Tagged<T>)
+
+}  // namespace runtime
+}  // namespace xla
+
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(std::string_view);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(xla::runtime::StridedMemrefView);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(xla::runtime::MemrefView);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(xla::runtime::FlatMemrefView);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(xla::runtime::EmptyArray);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(xla::runtime::Dictionary);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(int32_t);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(int64_t);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(float);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(double);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(absl::Span<const int32_t>);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(absl::Span<const int64_t>);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(absl::Span<const float>);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(absl::Span<const double>);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(tsl::AsyncValueRef<bool>);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(tsl::AsyncValueRef<int8_t>);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(tsl::AsyncValueRef<int16_t>);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(tsl::AsyncValueRef<int32_t>);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(tsl::AsyncValueRef<int64_t>);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(tsl::AsyncValueRef<float>);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(tsl::AsyncValueRef<double>);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(
+    tsl::AsyncValueRef<xla::runtime::MemrefView>);
+XLA_RUNTIME_DECLARE_EXPLICIT_TYPE_ID(tsl::AsyncValueRef<tsl::Chain>);
+
+#endif  // XLA_RUNTIME_CUSTOM_CALL_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/custom_call_registry.h

@@ -0,0 +1,76 @@
+/* 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_RUNTIME_CUSTOM_CALL_REGISTRY_H_
+#define XLA_RUNTIME_CUSTOM_CALL_REGISTRY_H_
+
+#include <functional>
+#include <memory>
+#include <string_view>
+
+#include "llvm/ADT/StringMap.h"
+#include "xla/runtime/custom_call.h"
+
+namespace xla {
+namespace runtime {
+
+// Dynamic custom call registry is a container for the custom calls that looks
+// up the handler implementing the custom call by name at run time. It is used
+// to implement a generic `rt.custom_call` runtime intrinsic.
+//
+// For low overhead custom calls prefer direct custom calls that linked with the
+// compiled executable and bypass by-name look up.
+class DynamicCustomCallRegistry {
+ public:
+  // The type for custom call registration functions.
+  using RegistrationFunction = void (*)(DynamicCustomCallRegistry*);
+
+  void Register(std::unique_ptr<class CustomCall> custom_call);
+
+  class CustomCall* Find(std::string_view callee) const;
+
+ private:
+  llvm::StringMap<std::unique_ptr<CustomCall>> custom_calls_;
+};
+
+// Direct custom call is a custom call that can be linked directly with the
+// compiled executable, and doesn't have to go through the custom call look up
+// by name at run time (see CustomCallRegistry).
+//
+// Direct custom call is a preferred way of implemenenting custom calls with
+// low run time overheads, as they will become just an indirect function calls
+// once LLVM ORC links them with the executable.
+//
+// See `ToSymbolsBinding` (in executor.h header) to convert direct custom call
+// registry and type name registry to symbols binding.
+class DirectCustomCallRegistry {
+ public:
+  // Function type corresponding to the direct custom call (custom calls
+  // linked directly with the compiled executable).
+  using DirectCustomCall = bool (*)(ExecutionContext* ctx, void** args,
+                                    void** attrs, void** rets);
+
+  void Register(std::string_view name, DirectCustomCall custom_call);
+
+  void ForEach(std::function<void(std::string_view, DirectCustomCall)> f) const;
+
+ private:
+  llvm::StringMap<DirectCustomCall> custom_calls_;
+};
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_CUSTOM_CALL_REGISTRY_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/default/async_values_cache.h

@@ -0,0 +1,113 @@
+/* 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_RUNTIME_DEFAULT_ASYNC_VALUES_CACHE_H_
+#define XLA_RUNTIME_DEFAULT_ASYNC_VALUES_CACHE_H_
+
+#include "absl/synchronization/mutex.h"
+#include "llvm/ADT/DenseMap.h"
+#include "tfrt/concurrency/async_value.h"  // from @tf_runtime
+#include "tfrt/concurrency/async_value_ref.h"  // from @tf_runtime
+#include "tfrt/concurrency/chain.h"  // from @tf_runtime
+
+namespace xla {
+namespace runtime {
+
+using tsl::AsyncValue;
+using tsl::AsyncValuePtr;
+using tsl::AsyncValueRef;
+using tsl::Chain;
+using tsl::MakeConstructedAsyncValueRef;
+using tsl::MakeUnconstructedAsyncValueRef;
+using tsl::RunWhenReady;
+
+template <typename Key, typename Value>
+class AsyncValuesCache {
+ public:
+  struct Entry;
+
+  AsyncValuesCache() = default;
+
+  // Returns a pointer to the cached value if it exists, otherwise returns
+  // nullptr. It is the caller's responsibility to form an async reference and
+  // extend its lifetime if the lifetime of the cached async value can be
+  // larger than the lifetime of the cache.
+  AsyncValuePtr<Value> Find(Key key) const;
+
+  // Allocates an async value in the unconstructed state to store the cached
+  // value with the given key.
+  //
+  // The `entry.allocated` value is `true` if the new async value was allocated,
+  // and the caller is responsible for eventually setting the error or emplacing
+  // the value. If it is false, then it means that the storage was already
+  // allocated, and someone else will eventually update it.
+  //
+  // The returned `entry.size` value is equal to the size of the cache. If the
+  // new async value was allocated, it will be reflected in the size.
+  Entry Allocate(Key key);
+
+  // Returns an async value that becomes available once all entries added to
+  // the cache are available.
+  AsyncValueRef<Chain> AllAvailable() const;
+
+  struct Entry {
+    AsyncValuePtr<Value> ptr;
+    bool allocated;
+    size_t size;
+  };
+
+ private:
+  mutable absl::Mutex mu_;
+  llvm::DenseMap<Key, AsyncValueRef<Value>> cache_ ABSL_GUARDED_BY(mu_);
+};
+
+template <typename Key, typename Value>
+AsyncValuePtr<Value> AsyncValuesCache<Key, Value>::Find(Key key) const {
+  absl::MutexLock lock(&mu_);
+  auto it = cache_.find(key);
+  return it != cache_.end() ? it->getSecond().AsPtr() : AsyncValuePtr<Value>();
+}
+
+template <typename Key, typename Value>
+auto AsyncValuesCache<Key, Value>::Allocate(Key key) -> Entry {
+  absl::MutexLock lock(&mu_);
+  auto it = cache_.find(key);
+  if (it != cache_.end())
+    return {it->getSecond().AsPtr(), false, cache_.size()};
+
+  AsyncValueRef<Value> allocated = MakeUnconstructedAsyncValueRef<Value>();
+
+  auto emplaced = cache_.try_emplace(key, std::move(allocated));
+  assert(emplaced.second && "emplace must be successful");
+  return {emplaced.first->getSecond().AsPtr(), true, cache_.size()};
+}
+
+template <typename Key, typename Value>
+AsyncValueRef<Chain> AsyncValuesCache<Key, Value>::AllAvailable() const {
+  absl::MutexLock lock(&mu_);
+
+  llvm::SmallVector<AsyncValue*> avs;
+  avs.reserve(cache_.size());
+  for (auto& it : cache_) avs.push_back(it.getSecond().GetAsyncValue());
+
+  AsyncValueRef<Chain> chain = MakeConstructedAsyncValueRef<Chain>();
+  RunWhenReady(avs, [chain]() { chain.SetStateConcrete(); });
+  return chain;
+}
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_DEFAULT_ASYNC_VALUES_CACHE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/default/memory_mapper.h

@@ -0,0 +1,38 @@
+/* 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_RUNTIME_DEFAULT_MEMORY_MAPPER_H_
+#define XLA_RUNTIME_DEFAULT_MEMORY_MAPPER_H_
+
+#include <errno.h>
+
+namespace xla {
+namespace runtime {
+
+// Some syscalls can be interrupted by a signal handler; retry if that happens.
+template <typename FunctionType>
+static auto RetryOnEINTR(FunctionType func, decltype(func()) failure_value) {
+  using ReturnType = decltype(func());
+  ReturnType ret;
+  do {
+    ret = func();
+  } while (ret == failure_value && errno == EINTR);
+  return ret;
+}
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_DEFAULT_MEMORY_MAPPER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/diagnostics.h

@@ -0,0 +1,174 @@
+/* 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_RUNTIME_DIAGNOSTICS_H_
+#define XLA_RUNTIME_DIAGNOSTICS_H_
+
+#include <functional>
+#include <optional>
+#include <string>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "xla/runtime/logical_result.h"
+#include "tsl/platform/logging.h"
+
+namespace xla {
+namespace runtime {
+
+// Forward declare.
+class DiagnosticEngine;
+
+// XLA runtime diagnostic engine enables XLA runtime custom calls and compiled
+// programs to pass diagnostic information (e.g. detailed run time error
+// information attached to the absl::Status) to the caller via the side channel,
+// because the API (and ABI) of the compiled executable is very simple, and
+// doesn't allow to pass complex C++ tyopes.
+//
+// XLA runtime diagnostics borrows a lot of ideas from the MLIR compile time
+// diagnostics (which is largely based on the Swift compiler diagnostics),
+// however in contrast to MLIR compilation pipelines we need to emit diagnostics
+// for the run time events (vs compile time) and correlate them back to the
+// location in the input module.
+//
+// See MLIR Diagnostics documentation: https://mlir.llvm.org/docs/Diagnostics.
+
+//===----------------------------------------------------------------------===//
+// Diagnostic
+//===----------------------------------------------------------------------===//
+
+// TODO(ezhulenev): Add location tracking to diagnostic, so that we can
+// correlate emitted diagnostic to the location in the input module, and from
+// there rely on the MLIR location to correlate events back to the user program
+// (e.g. original JAX program written in Python).
+class Diagnostic {
+ public:
+  explicit Diagnostic(absl::Status status) : status_(std::move(status)) {}
+
+  Diagnostic(Diagnostic &&) = default;
+  Diagnostic &operator=(Diagnostic &&) = default;
+
+  absl::Status status() const { return status_; }
+
+ private:
+  Diagnostic(const Diagnostic &rhs) = delete;
+  Diagnostic &operator=(const Diagnostic &rhs) = delete;
+
+  absl::Status status_;
+};
+
+//===----------------------------------------------------------------------===//
+// InFlightDiagnostic
+//===----------------------------------------------------------------------===//
+
+// RAII wrapper around constructed, but but not yet emitted diagnostic. In
+// flight diagnostic gives an opportunity to build a diagnostic before reporting
+// it to the engine, similar to the builder pattern.
+class InFlightDiagnostic {
+ public:
+  InFlightDiagnostic(InFlightDiagnostic &&other)
+      : engine_(other.engine_), diagnostic_(std::move(other.diagnostic_)) {
+    other.diagnostic_.reset();
+    other.Abandon();
+  }
+
+  ~InFlightDiagnostic() {
+    if (IsInFlight()) Report();
+  }
+
+  void Report();
+  void Abandon();
+
+  // Allow a diagnostic to be converted to 'failure'.
+  //
+  // Example:
+  //
+  //   LogicalResult call(DiagnosticEngine diag, ...) {
+  //     if (<check failed>) return diag.EmitError(InternalError("oops"));
+  //     ...
+  //   }
+  //
+  operator LogicalResult() const {  // NOLINT
+    return failure();
+  }
+  template <typename T>
+  operator FailureOr<T>() const {  // NOLINT
+    return failure();
+  }
+
+ private:
+  friend class DiagnosticEngine;
+
+  InFlightDiagnostic(const DiagnosticEngine *engine, Diagnostic diagnostic)
+      : engine_(engine), diagnostic_(std::move(diagnostic)) {}
+
+  InFlightDiagnostic &operator=(const InFlightDiagnostic &) = delete;
+  InFlightDiagnostic &operator=(InFlightDiagnostic &&) = delete;
+
+  bool IsActive() const { return diagnostic_.has_value(); }
+  bool IsInFlight() const { return engine_ != nullptr; }
+
+  // Diagnostic engine that will report this diagnostic once its ready.
+  const DiagnosticEngine *engine_ = nullptr;
+  std::optional<Diagnostic> diagnostic_;
+};
+
+//===----------------------------------------------------------------------===//
+// DiagnosticEngine
+//===----------------------------------------------------------------------===//
+
+// Diagnostic engine is responsible for passing diagnostics to the user.
+//
+// XLA runtime users must set up diagnostic engine to report errors back to the
+// caller, e.g. the handler can collect all of the emitted diagnostics into the
+// string message, and pass it to the caller as the async error.
+//
+// Unhandled error diagnostics will be logged with the warning level.
+class DiagnosticEngine {
+ public:
+  // Diagnostic handler must return success if it consumed the diagnostic, and
+  // failure if the engine should pass it to the next registered handler.
+  using HandlerTy = std::function<LogicalResult(Diagnostic &)>;
+
+  // Returns the default instance of the diagnostic engine.
+  static const DiagnosticEngine *DefaultDiagnosticEngine();
+
+  InFlightDiagnostic EmitError(absl::Status status) const {
+    return InFlightDiagnostic(this, Diagnostic(std::move(status)));
+  }
+
+  void AddHandler(HandlerTy handler) {
+    handlers_.push_back(std::move(handler));
+  }
+
+  void Emit(Diagnostic diagnostic) const {
+    for (auto &handler : llvm::reverse(handlers_)) {
+      if (succeeded(handler(diagnostic))) return;
+    }
+
+    // Log unhandled errors to the warning log.
+    LOG(WARNING) << "XLA runtime error: " << diagnostic.status();
+  }
+
+ private:
+  llvm::SmallVector<HandlerTy> handlers_;
+};
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_DIAGNOSTICS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/errors.h

@@ -0,0 +1,42 @@
+/* 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_RUNTIME_ERRORS_H_
+#define XLA_RUNTIME_ERRORS_H_
+
+#include <string>
+
+#include "absl/status/status.h"
+#include "absl/strings/str_format.h"
+
+namespace xla {
+namespace runtime {
+
+template <typename... Args>
+absl::Status InvalidArgument(const absl::FormatSpec<Args...>& format,
+                             const Args&... args) {
+  return absl::InvalidArgumentError(absl::StrFormat(format, args...));
+}
+
+template <typename... Args>
+absl::Status InternalError(const absl::FormatSpec<Args...>& format,
+                           const Args&... args) {
+  return absl::InternalError(absl::StrFormat(format, args...));
+}
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_ERRORS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/executable.h

@@ -0,0 +1,439 @@
+/* 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_RUNTIME_EXECUTABLE_H_
+#define XLA_RUNTIME_EXECUTABLE_H_
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "absl/status/statusor.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "xla/runtime/arguments.h"
+#include "xla/runtime/async_runtime.h"
+#include "xla/runtime/custom_call.h"
+#include "xla/runtime/custom_call_registry.h"
+#include "xla/runtime/diagnostics.h"
+#include "xla/runtime/execution_engine.h"
+#include "xla/runtime/logical_result.h"
+#include "xla/runtime/memory_mapper.h"
+#include "xla/runtime/results.h"
+#include "xla/runtime/type_id.h"
+#include "xla/runtime/types.h"
+
+namespace xla {
+namespace runtime {
+
+struct ExecutionContext;
+
+struct DestroyExecutionContext {
+  void operator()(ExecutionContext* ctx);
+};
+
+// If executable has async results, ExecutionReference keeps that
+// execution context alive. For sync executables `Execute` always returns
+// ExecutionReference with nullptr.
+class ExecutionReference
+    : public std::unique_ptr<ExecutionContext, DestroyExecutionContext> {
+  // Bring std::unique_ptr constructors in scope.
+  using std::unique_ptr<ExecutionContext, DestroyExecutionContext>::unique_ptr;
+};
+
+class FunctionRef;
+class JitCompiler;
+
+// Returns a symbols binding for running XLA executable with a custom symbols
+// provided by the user.
+ExecutionEngine::SymbolsBinding RuntimeSymbolsBinding(
+    ExecutionEngine::SymbolsBinding custom_binding);
+
+// Converts a direct custom call and custom type id name registration functions
+// (types required by the library) to the execution engine symbols binding.
+// Returned symbols binding always includes type id symbols for all
+// canonical types supported by the XLA runtime custom calls.
+ExecutionEngine::SymbolsBinding ToSymbolsBinding(
+    std::function<void(DirectCustomCallRegistry&)> custom_calls = {},
+    std::function<void(TypeIDNameRegistry&)> types = {});
+
+class Executable {
+ public:
+  // Forward declare types defined below.
+  struct ArgumentsMemoryLayout;
+  struct ResultsMemoryLayout;
+  struct CallFrame;
+  struct ExecuteOpts;
+
+  // Initializes call frame by adding all arguments according to the exported
+  // function ABI. Also allocates storage for the returned values according to
+  // the results memory layout.
+  //
+  // If `verify_arguments` is true (in debug mode it's always on, independent of
+  // the argument value) this function also verifies that arguments passed at
+  // run time matches the exported function signature (e.g. all statically known
+  // dimensions of the memrefs matches the arguments). Returns an error if finds
+  // a mismatch.
+  //
+  // This function leaves the execution context argument (the first argument of
+  // an exported function) uninitialized. It will be initialized in the
+  // `Execute` function right before the actual execution.
+  absl::Status InitializeCallFrame(unsigned ordinal, ArgumentsRef arguments,
+                                   CallFrame* call_frame,
+                                   bool verify_arguments = true) const;
+
+  absl::Status InitializeCallFrame(ArgumentsRef arguments,
+                                   CallFrame* call_frame,
+                                   bool verify_arguments = true) const {
+    return InitializeCallFrame(0, arguments, call_frame, verify_arguments);
+  }
+
+  // Converts returned values owned by the call frame using provided result
+  // converter. If exported function execution finished with an error (error
+  // flag is `true` in the call frame) returns error for all results (see
+  // `ResultConverter::ReturnError` documentation).
+  absl::Status ReturnResults(unsigned ordinal, const ResultConverter& results,
+                             CallFrame* call_frame) const;
+
+  absl::Status ReturnResults(const ResultConverter& results,
+                             CallFrame* call_frame) const {
+    return ReturnResults(0, results, call_frame);
+  }
+
+  // Executes exported function exported with given arguments.
+  //
+  // If `verify_arguments` is true (in debug mode it's always on, independent of
+  // the argument value) this function also verifies that arguments passed at
+  // run time matches the exported function signature. If some of the
+  // arguments do not match the expected type, this function allocates error
+  // async values for all results and returns an error.
+  //
+  // Returns exported function results via the user-provided results converter.
+  // If execution completed in the error state, returns error for all results.
+  absl::StatusOr<ExecutionReference> Execute(
+      unsigned ordinal, ArgumentsRef arguments, const ResultConverter& results,
+      const ExecuteOpts& opts, bool verify_arguments = true) const;
+
+  absl::StatusOr<ExecutionReference> Execute(
+      ArgumentsRef arguments, const ResultConverter& results,
+      const ExecuteOpts& opts, bool verify_arguments = true) const {
+    return Execute(0, arguments, results, opts, verify_arguments);
+  }
+
+  // Executes exported function using user provided call frame.
+  //
+  // It is the caller responsibility to handle the compiled function results
+  // stored in the call frame.
+  ExecutionReference Execute(unsigned ordinal, CallFrame& call_frame,
+                             const ExecuteOpts& opts) const;
+
+  void Execute(CallFrame& call_frame, const ExecuteOpts& opts) const {
+    Execute(0, call_frame, opts);
+  }
+
+  std::string_view name() const { return name_; }
+
+  std::optional<size_t> specialization() const { return specialization_; }
+
+  // Returns the number of exported functions. Functions are indexed by their
+  // ordinal number in the [0, num_functions) range.
+  size_t num_functions() const { return functions_.size(); }
+
+  // Returns a function reference to an exported function with given ordinal.
+  FunctionRef function_ref(unsigned ordinal) const;
+
+  // Returns true if exported function with given ordinal has async results.
+  bool IsAsync(unsigned ordinal) const;
+  bool IsAsync() const { return IsAsync(0); }
+
+  // Returns the name of the exported function with the given ordinal.
+  std::string_view function_name(unsigned ordinal) const;
+  std::string_view function_name() const { return function_name(0); }
+
+  // Returns the number of results of the exported function with given ordinal.
+  unsigned num_results(unsigned ordinal) const;
+  unsigned num_results() const { return num_results(0); }
+
+  // Signature of the exported function with the given ordinal before lowering
+  // to the runtime dialects. See JitExecutable::Function's `signature` for
+  // more details.
+  const FunctionType& signature(unsigned ordinal) const;
+  const FunctionType& signature() const { return signature(0); }
+
+  // Signature of the exported function with the given ordinal after lowering it
+  // from high level dialects to the dialects supported by the XLA runtime. See
+  // JitExecutable::Function's `signature` for more details.
+  const FunctionType& runtime_signature(unsigned ordinal) const;
+  const FunctionType& runtime_signature() const { return runtime_signature(0); }
+
+  std::chrono::milliseconds time_to_compile() const;
+
+  // Get the object file behind this executable (on linux for example, it will
+  // be https://en.wikipedia.org/wiki/Executable_and_Linkable_Format
+  // executable). Can be null.
+  std::unique_ptr<llvm::MemoryBuffer> obj_file() const;
+
+  // CallFrame provides a pointer-stable storage for packed function arguments
+  // and storage for returned values.
+  struct CallFrame {
+    // Pointers to executable arguments.
+    llvm::SmallVector<void*, 32> args;
+
+    // We use single block of memory to store executable results. We need to be
+    // able to store pointers to async values and tokens, and strided memrefs
+    // which at runtime are represented as StridedMemrefType<T, rank>.
+    //
+    // Currently we only need to provide result storage for pointers and memref
+    // sizes and strides (int64_t type). If we'll need to support more complex
+    // return types we'll have to be more careful about alignment requirements.
+    static_assert(sizeof(uintptr_t) == sizeof(int64_t),
+                  "uintptr_t size must be the same as int64_t");
+
+    // Memory where the executable will write its results.
+    llvm::SmallVector<uint8_t, 128> results;
+
+    // Tracks whether any of the outputs were set.
+    bool has_set_outputs = false;
+
+    // Indicates whether the execution finished with an error.
+    bool is_error = false;
+
+    // The error message which is available only if `is_error` is true. The
+    // assumption is that the error message string is owned by the compiled
+    // binary and the call frame can safely keep a non-owning pointer.
+    std::string_view error;
+  };
+
+  // Requirements for passing arguments to the compiled function.
+  struct ArgumentsMemoryLayout {
+    size_t num_args_ptrs = 0;            // total number of required pointers
+    llvm::SmallVector<size_t> num_ptrs;  // num_ptrs for each argument
+    llvm::SmallVector<size_t> offsets;   // offsets into the args array
+  };
+
+  // Requirements for the contiguous block of memory to store compiled function
+  // results. When we invoke a compiled fuction we allocate a block of memory,
+  // and pass pointers to pre-computed offsets as output arguments to the
+  // function.
+  struct ResultsMemoryLayout {
+    bool has_async_results = false;     // true iff returns async results
+    size_t size = 0;                    // number of bytes required
+    llvm::SmallVector<size_t> offsets;  // offsets in the block of memory
+  };
+
+  struct ExecuteOpts {
+    // Async task runner for executing async runtime tasks. Typically it
+    // schedules async tasks into the underlying thread pool. It's the caller's
+    // responsibility to guarantee that it will outlive the execution of all
+    // async tasks started by the executable.
+    AsyncTaskRunner* async_task_runner = nullptr;
+
+    // A container for passing arbitrary user-provided data to the custom call
+    // handlers. Must outlive all async tasks launched by this executable.
+    const CustomCall::UserData* custom_call_data = nullptr;
+
+    // Dynamically registered custom calls library. These custom calls resolved
+    // at run time by name. In contrast to custom calls defined by the
+    // `DirectCustomCallRegistry` which are linked directly with the executable
+    // at compile time.
+    const DynamicCustomCallRegistry* custom_call_registry = nullptr;
+
+    // Diagnostic engine is responsible for passing runtime diagnostics back
+    // to the caller through the diagnostic handler.
+    const DiagnosticEngine* diagnostic_engine = nullptr;
+  };
+
+  // Function specification for loading from the object file.
+  struct LoadFunction {
+    std::string name;
+    FunctionType signature;
+    FunctionType runtime_signature;
+  };
+
+  // Loads executable from an object file. It is the caller responsibility to
+  // guarantee that signatures do match the compiled function in the object
+  // file, otherwise it will surely lead to crash.
+  static absl::StatusOr<Executable> LoadFromObjFile(
+      std::string_view name, std::unique_ptr<llvm::MemoryBuffer> obj_file,
+      std::vector<LoadFunction> load_functions,
+      ExecutionEngine::SymbolsBinding symbols_binding = {},
+      std::string_view memory_region_name = "");
+
+  // Verifies that all arguments types in the exported function signature are
+  // supported at run time. Returns a pre-computed layout for the function
+  // arguments. If some arguments are not supported returns an error.
+  static absl::StatusOr<ArgumentsMemoryLayout> GetArgumentsMemoryLayout(
+      const FunctionType& signature);
+
+  // Verifies that all results types in the exported function signature are
+  // supported at run time . Returns a pre-computed layout for the function
+  // results. If some results are not supported returns an error.
+  static absl::StatusOr<ResultsMemoryLayout> GetResultsMemoryLayout(
+      const FunctionType& signature);
+
+  // TODO(ezhulenev): The following three functions should be decoupled from
+  // the executable header file (maybe move them to runtime.h?) so that custom
+  // call implementations do not have to depend on the `executable` target.
+
+  // Returns the user data passed via the ExecuteOpts to the executable.
+  static const CustomCall::UserData* GetUserData(ExecutionContext* ctx);
+
+  // Returns the diagnostic engine passed via the ExecuteOpts to the executable.
+  static const DiagnosticEngine* GetDiagnosticEngine(ExecutionContext* ctx);
+
+  // Calls the custom call handler with the given runtime context, arguments,
+  // attributes and results.
+  static LogicalResult Call(ExecutionContext* ctx, CustomCall& call,
+                            void** args, void** attrs, void** rets);
+
+  bool RequiresBlas(int ordinal) const {
+    return functions_[ordinal].requires_blas;
+  }
+
+ private:
+  friend class JitCompiler;  // see `mlir/runtime/transforms/jit_compiler.h`
+
+  // Executable exports multiple functions available for users to call into. At
+  // run time they are referenced by their ordinal, so that we don't depend on
+  // expensive by-name lookup on the hot path. We keep function name only for
+  // debugging. Function ordinal is defined by its index in the `functions_`
+  // vector.
+  struct Function {
+    Function(std::string_view name, ExecutionEngine::ExportedFunctionPtr fptr,
+             FunctionType signature, FunctionType runtime_signature,
+             ArgumentsMemoryLayout arguments_memory_layout,
+             ResultsMemoryLayout results_memory_layout, bool requires_blas)
+        : name(name),
+          fptr(std::move(fptr)),
+          signature(std::move(signature)),
+          runtime_signature(std::move(runtime_signature)),
+          arguments_memory_layout(std::move(arguments_memory_layout)),
+          results_memory_layout(std::move(results_memory_layout)),
+          requires_blas(requires_blas) {}
+    Function(const Function&) = delete;
+    Function(Function&&) = default;
+
+    // Exported function name.
+    std::string name;
+
+    // Pointer to an exported function owned by the execution engine.
+    ExecutionEngine::ExportedFunctionPtr fptr;
+
+    // Signature of the exported function function before lowering to the
+    // runtime dialects (see JitExecutable::Function's `signature`).
+    FunctionType signature;
+
+    // Signature of the exported function after lowering it from high level
+    // dialects to the dialects supported by the XLA runtime.
+    //
+    // - Operands and results types converted to the types with well-defined ABI
+    //   (e.g. tensors converted to memrefs).
+    //
+    // - First argument is always an execution context added to the function by
+    //   the lowering pipeline.
+    //
+    // From this signatur, Executable infers how to pack runtime arguments
+    // according to the expected memory layout, and how to convert results
+    // returned from the JIT-compiled function into high level types (e.g. how
+    // to convert StridedMemrefType into Tensorflow Tensor).
+    //
+    // To infer the type of the returned value, Executable looks at the type
+    // defined by the `runtime_signature` to get the memory layout of the
+    // returned value, and at the type defined by the `signature` to get the
+    // type expected by the runtime.
+    FunctionType runtime_signature;
+
+    // Memory layout required for passing function arguments.
+    ArgumentsMemoryLayout arguments_memory_layout;
+
+    // Memory layout for returning function results.
+    ResultsMemoryLayout results_memory_layout;
+
+    // If this flag is true, then this function is outlined for cuda graph, and
+    // cuBlas should be initiated when capturing the cuda graph.
+    bool requires_blas;
+  };
+
+  Executable(std::string_view name,
+             std::unique_ptr<XlaRuntimeMemoryMapper> memory_mapper,
+             std::unique_ptr<ExecutionEngine> engine,
+             std::vector<Function> functions,
+             std::optional<size_t> specialization,
+             std::chrono::milliseconds time_to_compile)
+      : name_(name),
+        memory_mapper_(std::move(memory_mapper)),
+        engine_(std::move(engine)),
+        functions_(std::move(functions)),
+        specialization_(specialization),
+        time_to_compile_(time_to_compile) {
+    // All exported functions must have a non-null function pointer.
+    assert(llvm::all_of(functions_, [](const Function& f) { return f.fptr; }));
+  }
+
+  std::string name_;  // name of the compiled executable
+
+  // Called by `engine_`'s destructor; must appear before it.
+  std::unique_ptr<XlaRuntimeMemoryMapper> memory_mapper_;  // optional
+
+  // XLA runtime execution engine owns the LLVM ORC jit compilation stack.
+  std::unique_ptr<ExecutionEngine> engine_;
+
+  // Functions exported by this executable, indexed by function ordinal.
+  std::vector<Function> functions_;
+
+  // Specialization id if this executable is a specialization, or an empty
+  // optional if this executable is a default one.
+  std::optional<size_t> specialization_;
+
+  // The time it took to compile this binary.
+  std::chrono::milliseconds time_to_compile_;
+};
+
+// Function reference provides a function-like API for a function exported from
+// the executabled with the given ordinal.
+class FunctionRef {
+ public:
+  FunctionRef(const Executable* executable, unsigned ordinal);
+
+  absl::StatusOr<ExecutionReference> operator()(
+      ArgumentsRef arguments, const ResultConverter& results,
+      const Executable::ExecuteOpts& opts, bool verify_arguments = true) const;
+
+  bool RequiresBlas() const { return executable_->RequiresBlas(ordinal_); }
+
+  unsigned ordinal() const { return ordinal_; }
+
+ private:
+  const Executable* executable_;
+  unsigned ordinal_;
+};
+
+// Escape slashes, substituting them with double underscores to get a memory
+// region name for the XlaRuntimeMemoryMapper.
+//
+// The profiler's UI might interpret slashes as callchain separators,
+// whereas we want the region name to be shown in full.
+inline std::string EscapeMemRegionName(std::string_view memory_region_name) {
+  return llvm::join(llvm::split(memory_region_name, '/'), "__");
+}
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_EXECUTABLE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/execution_engine.h

@@ -0,0 +1,187 @@
+/* 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_RUNTIME_EXECUTION_ENGINE_H_
+#define XLA_RUNTIME_EXECUTION_ENGINE_H_
+
+#include <functional>
+#include <memory>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "absl/status/statusor.h"
+#include "llvm/ExecutionEngine/JITEventListener.h"
+#include "llvm/ExecutionEngine/Orc/LLJIT.h"
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+namespace xla {
+namespace runtime {
+
+// A pre-fabricated wrapper around ORC JIT stack for running XLA executables.
+//
+// It allows to run jit-compiled XLA executables, AOT compile them or load
+// previously AOT compiled executables.
+//
+// XLA executable itself is responsible for the function signature verification,
+// arguments packing according to the ABI, results decoding and linking the
+// executable with runtime intrinsics. Execution engine only helps with setting
+// up ORC JIT stack to support the execution, but itself doesn't know what it is
+// executing.
+class ExecutionEngine {
+ public:
+  // Pointer to a function exported to the Xla executable.
+  //
+  // Xla exported function expects all arguments to be passed as an array of
+  // opaque pointers to the actual values. In C++ it would look like this:
+  //
+  //   void compute(int32_t arg0, float arg1, ...);
+  //
+  //   void __xla_compute(void** args) {
+  //      int32_t arg0 = *reinterpret_cast<int32_t*>(args[0]);
+  //      float arg1 = *reinterpret_cast<float*>(args[1]);
+  //      ...
+  //      compute(arg0, arg1, ...);
+  //   }
+  //
+  // This is required to avoid dealing with ABI of the compiled function. See
+  // `SetUpExportedFunction` for implementation details.
+  using ExportedFunctionPtr = void (*)(void **);
+
+  // Callback to register symbols with the execution engine (e.g. to register
+  // custom runtime intrinsics for Gpu integration).
+  using SymbolsBinding =
+      std::function<llvm::orc::SymbolMap(llvm::orc::MangleAndInterner)>;
+
+  // Callback to run optimization passes on the compiled LLVM module.
+  using OptimizingTransformer = std::function<llvm::Error(llvm::Module *)>;
+
+  // Callback to construct an optimizing transformer for the given options.
+  using MakeOptimizingTransformer =
+      std::function<OptimizingTransformer(llvm::TargetMachine *targetMachine)>;
+
+  // Compose multiple symbol bindings into a single symbol binding function.
+  static SymbolsBinding BindAll(std::vector<SymbolsBinding> bindings);
+
+  //------------------------------------------------------------------------- //
+  // Options for creating execution engine from an LLVM module.
+  //------------------------------------------------------------------------- //
+
+  struct JitOptions {
+    // User-provided codegen optimization level.
+    llvm::CodeGenOptLevel opt_level = llvm::CodeGenOptLevel::Default;
+
+    // User-provided target machine specification.
+    std::shared_ptr<llvm::TargetMachine> target_machine = nullptr;
+
+    // User-provided builder for the optimizing transformer.
+    MakeOptimizingTransformer make_optimizing_transformer;
+
+    // User-provided memory mapper for allocating memory for executables.
+    llvm::SectionMemoryManager::MemoryMapper *section_memory_mapper = nullptr;
+
+    // User-provided bindings for symbols.
+    SymbolsBinding symbols_binding = nullptr;
+
+    // Notify the llvm's global GDB notifications listener.
+    bool enable_gdb_listener = false;
+
+    // Notify the llvm's global Perf notifications listener.
+    bool enable_perf_listener = false;
+
+    // Save compiled object file.
+    bool save_compiled_obj_file = true;
+  };
+
+  // Creates a new execution engine by compiling the provided LLVM module to
+  // a native executable using LLVM ORC stack.
+  static absl::StatusOr<std::unique_ptr<ExecutionEngine>> CreateFromModule(
+      std::unique_ptr<llvm::LLVMContext> ctx,
+      std::unique_ptr<llvm::Module> module, JitOptions options,
+      absl::Span<const std::string_view> exported);
+
+  //------------------------------------------------------------------------- //
+  // Options for creating execution engine from an AOT compiled object file.
+  //------------------------------------------------------------------------- //
+
+  struct AotOptions {
+    // User-provided memory mapper for allocating memory for executables.
+    llvm::SectionMemoryManager::MemoryMapper *section_memory_mapper = nullptr;
+
+    // User-provided bindings for symbols.
+    SymbolsBinding symbols_binding = nullptr;
+
+    // Notify the llvm's global GDB notifications listener.
+    bool enable_gdb_listener = true;
+
+    // Notify the llvm's global Perf notifications listener.
+    bool enable_perf_listener = true;
+  };
+
+  // Creates a new execution engine by loading AOT compiled XLA executable
+  // object file.
+  static absl::StatusOr<std::unique_ptr<ExecutionEngine>> CreateFromObjFile(
+      std::unique_ptr<llvm::MemoryBuffer>, AotOptions options,
+      absl::Span<const std::string_view> exported);
+
+  //------------------------------------------------------------------------- //
+
+  // Returns a pointer to the exported function.
+  absl::Span<const ExportedFunctionPtr> exported() const { return exported_; }
+
+  ExportedFunctionPtr exported(unsigned ordinal) const {
+    return exported_[ordinal];
+  }
+
+  // Return a memory buffer with a object file behind this execution engine. Can
+  // be null if execution engine didn't save the compiled object file.
+  std::unique_ptr<llvm::MemoryBuffer> obj_file() const;
+
+ private:
+  ExecutionEngine(bool enable_gdb_listener, bool enable_perf_listener);
+
+  // We build execution engine on top of the ORC LLJIT API, which owns all
+  // compiled/loaded object files and does the linking at run time.
+  //
+  // TODO(ezhulenev): Instead of keeping LLJIT alive we should be able to keep
+  // only llvm::orc::JITDylibSP owning main dylib and the object layer owning
+  // memory-mapped regions holding object files. Once we are done with
+  // executable compilation this jit is defunct because it holds an expired
+  // weak_ptr to an llvm::orc::TargetMachine instance.
+  std::unique_ptr<llvm::orc::LLJIT> jit_;
+
+  // Pointers to resolved exported functions. Indexed by function ordinal.
+  std::vector<ExportedFunctionPtr> exported_;
+
+  // Object file behind the compiled executable. Can be null.
+  std::unique_ptr<llvm::MemoryBuffer> obj_file_;
+
+  llvm::JITEventListener *gdb_listener_ = nullptr;
+  llvm::JITEventListener *perf_listener_ = nullptr;
+};
+
+// Emits an interface function ('exported_name') that wraps all arguments
+// of a function ('original_name') into a single pointer to a ptr**,
+// thereby exposing a trivial ABI. The original function is also inlined,
+// if possible.
+absl::Status ExportWithXlaRuntimeAbi(llvm::Module &module,
+                                     std::string_view original_name,
+                                     std::string_view exported_name);
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_EXECUTION_ENGINE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/ffi.h

@@ -0,0 +1,97 @@
+/* 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_RUNTIME_FFI_H_
+#define XLA_RUNTIME_FFI_H_
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "xla/runtime/ffi/ffi_c_api.h"
+#include "xla/runtime/module.h"
+
+namespace xla {
+namespace runtime {
+namespace ffi {
+
+// Returns FFI modules registered with an XLA runtime.
+std::vector<const runtime::Module*> FfiModules();
+
+// Exports registered FFI modules to the given custom call registry.
+void ExportFfiModules(DynamicCustomCallRegistry& registry);
+
+// XLA runtime wrapper around FFI module.
+class FfiModule;
+
+//===----------------------------------------------------------------------===//
+// RAII helpers for the state instantiated by the FFI modules.
+//===----------------------------------------------------------------------===//
+
+// Deletes the FFI module `state` instantiated by the `module`.
+struct FfiStateDeleter {
+  void operator()(XLA_FFI_Module_State* state);
+  const FfiModule* module;
+};
+
+// A smart pointer owning `state` instantiated by the `module`.
+struct OwnedFfiState
+    : public std::unique_ptr<XLA_FFI_Module_State, FfiStateDeleter> {
+  using Base = std::unique_ptr<XLA_FFI_Module_State, FfiStateDeleter>;
+  OwnedFfiState(const FfiModule* module, XLA_FFI_Module_State* state);
+};
+
+//===----------------------------------------------------------------------===//
+// FFI modules <-> XLA runtime integration via UserData.
+//===----------------------------------------------------------------------===//
+
+// A vector of opaque pointers to FFI modules state that is passed around inside
+// `UserData` and enables FFI functions to find their state.
+struct FfiStateVector {
+  std::vector<XLA_FFI_Module_State*> state;  // indexed by module id
+
+  // If FFI module instantiates state for each execution, the state vector will
+  // be the owner of that state for the duration of execution.
+  std::vector<OwnedFfiState> per_execution_state;
+};
+
+// FfiModulesState is a container that owns the FFI modules state.
+class FfiModulesState {
+ public:
+  FfiModulesState() = default;
+
+  // Instantiates `FfiModulesState` from the registered FFI module.
+  static absl::StatusOr<FfiModulesState> Instantiate();
+
+  absl::StatusOr<FfiStateVector> state_vector() const;
+
+ private:
+  explicit FfiModulesState(std::vector<std::unique_ptr<Module::State>> state);
+
+  std::vector<std::unique_ptr<Module::State>> state_;
+};
+
+// Gets the underlying FFI stream from the `user_data`.
+XLA_FFI_Stream* GetXlaFfiStream(const CustomCall::UserData* user_data,
+                                const DiagnosticEngine* diagnostic);
+
+void RegisterXlaFfiStreamProvider(
+    XLA_FFI_Stream* (*)(const CustomCall::UserData*, const DiagnosticEngine*));
+
+}  // namespace ffi
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_FFI_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/ffi/ffi_abi.h

@@ -0,0 +1,62 @@
+/* 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_RUNTIME_FFI_FFI_ABI_H_
+#define XLA_RUNTIME_FFI_FFI_ABI_H_
+
+#include <cstdint>
+
+namespace xla {
+namespace runtime {
+namespace internal {
+
+//===----------------------------------------------------------------------===//
+// C structures that XLA uses internally to encode arguments and attributes.
+//===----------------------------------------------------------------------===//
+
+// When XLA compiles host-side executable via lowering to LLVM (see `rt-to-llvm`
+// pass) it encodes arguments and attributes as `!llvm.struct<...>` types stored
+// as LLVM global constants (attributes and statically known arguments) or as
+// allocas on the stack. We rely on standard layout C++ structs to reinterpret
+// cast arguments and attributes pointers, and convert them to user-friendly C++
+// types (e.g. `EncodedMemref` to `StridedBufferArg`).
+//
+// See: https://en.cppreference.com/w/cpp/types/is_standard_layout
+
+struct EncodedMemref {
+  uint8_t dtype;
+  uint8_t rank;
+  void* data;
+  int64_t dims[];
+};
+
+template <typename T>
+struct EncodedArray {
+  int64_t size;
+  const T* data;
+};
+
+template <typename T>
+struct EncodedDenseElements {
+  struct EncodedArray<T> payload;
+  int64_t rank;
+  int64_t shape[];
+};
+
+}  // namespace internal
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_FFI_FFI_ABI_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/ffi/ffi_api.h

@@ -0,0 +1,1270 @@
+/* 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_RUNTIME_FFI_FFI_API_H_
+#define XLA_RUNTIME_FFI_FFI_API_H_
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <iostream>
+#include <iterator>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <sstream>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "xla/runtime/ffi/ffi_abi.h"
+#include "xla/runtime/ffi/ffi_c_api.h"
+
+namespace xla {
+namespace runtime {
+namespace ffi {
+
+// Forward declare template defined below.
+template <typename... Ts>
+class FfiBinding;
+
+// Forward declare template defined below.
+template <typename Fn, typename... Ts>
+class FfiHandler;
+
+// FFI arguments allocated by the jit-compiled code and we need to mark all
+// memory initialized to suppress memory sanitizer errors.
+#if defined(MEMORY_SANITIZER)
+#define XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
+  __msan_unpoison(address, size)
+#else
+#define XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(address, size)  // empty
+#endif  // MEMORY_SANITIZER
+
+//===----------------------------------------------------------------------===//
+// Check struct sizes passed across the C API to detect mismatched versions.
+//===----------------------------------------------------------------------===//
+
+namespace internal {
+inline void CheckStructSize(std::string_view struct_name, size_t expected_size,
+                            size_t actual_size) {
+  if (expected_size != actual_size) {
+    std::cerr << "Unexpected " << struct_name << " size: expected "
+              << expected_size << " << got " << actual_size
+              << ". Check installed software versions." << std::endl;
+    std::abort();
+  }
+}
+}  // namespace internal
+
+#define CHECK_ARGS_SIZE(name, args)                            \
+  internal::CheckStructSize("XLA_FFI_##name##_Args",           \
+                            XLA_FFI_##name##_Args_STRUCT_SIZE, \
+                            args->struct_size)
+
+//===----------------------------------------------------------------------===//
+// Span is non-owning view into contiguous values of type `T`.
+//===----------------------------------------------------------------------===//
+
+// TODO(ezhulenev): Replace with `std::span` when C++20 is available.
+template <typename T>
+class Span {
+ public:
+  Span(T* data, size_t size) : data_(data), size_(size) {}
+  Span(const std::vector<std::remove_const_t<T>>& vec)  // NOLINT
+      : Span(vec.data(), vec.size()) {}
+
+  T& operator[](size_t index) const { return data_[index]; }
+
+  size_t size() const { return size_; }
+
+  T* begin() const { return data_; }
+  T* end() const { return data_ + size_; }
+
+ private:
+  T* data_;
+  size_t size_;
+};
+
+// A type for representing shaped tensors.
+// TODO(ecg): expand API to be compatible with `std::mdspan`, and eventually
+// (when C++23 is available) replace with `std::mdspan`.
+template <typename T>
+struct MdSpan {
+  Span<const int64_t> shape;
+  Span<const T> data;
+};
+
+//===----------------------------------------------------------------------===//
+// XLA FFI status wrapper around error reporting APIs.
+//===----------------------------------------------------------------------===//
+
+class FfiStatus {
+ public:
+  static FfiStatus Ok() { return FfiStatus(); }
+
+  static FfiStatus Internal(std::string message) {
+    XLA_FFI_Error_Code errc = XLA_FFI_Error_Code_INTERNAL;
+    return FfiStatus(errc, message);
+  }
+
+  static FfiStatus InvalidArgument(std::string message) {
+    XLA_FFI_Error_Code errc = XLA_FFI_Error_Code_INVALID_ARGUMENT;
+    return FfiStatus(errc, message);
+  }
+
+  std::optional<XLA_FFI_Error_Code> errc() const { return errc_; }
+
+  std::string_view message() const {
+    return message_.has_value() ? *message_ : std::string_view();
+  }
+
+  const char* message_c_str() const {
+    return message_.has_value() ? message_->c_str() : "";
+  }
+
+ private:
+  FfiStatus() = default;
+
+  FfiStatus(XLA_FFI_Error_Code errc, std::string message)
+      : errc_(errc), message_(std::move(message)) {}
+
+  std::optional<XLA_FFI_Error_Code> errc_;
+  std::optional<std::string> message_;
+};
+
+//===----------------------------------------------------------------------===//
+// XLA FFI virtual base for implementing FFI functions.
+//===----------------------------------------------------------------------===//
+
+class Ffi {
+ public:
+  virtual ~Ffi() = default;
+
+  virtual XLA_FFI_Error* operator()(const XLA_FFI_Api* api,
+                                    XLA_FFI_ExecutionContext* ctx, void** args,
+                                    void** attrs, void** rets) const = 0;
+
+  static FfiBinding<> Binding();
+
+  template <typename T>
+  static bool Isa(const XLA_FFI_Api* api, XLA_FFI_TypeId type_id);
+
+  template <typename T, typename U, typename... Ts>
+  static bool Isa(const XLA_FFI_Api* api, XLA_FFI_TypeId type_id) {
+    return Isa<T>(api, type_id) || Isa<U, Ts...>(api, type_id);
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// XLA FFI module is a base class for stateful and stateless FFI modules.
+//===----------------------------------------------------------------------===//
+
+class Module {
+ public:
+  virtual ~Module() = default;
+
+  struct ExportedFunction {
+    std::string target;
+    XLA_FFI_Function* function;
+  };
+
+ protected:
+  Module(const XLA_FFI_Api* api, std::string module_name,
+         std::vector<ExportedFunction> exported_functions,
+         XLA_FFI_Module_StateType state_type,
+         XLA_FFI_Module_CreateState* create_state,
+         XLA_FFI_Module_DestroyState* destroy_state)
+      : api_(api),
+        module_name_(std::move(module_name)),
+        exported_functions_(std::move(exported_functions)) {
+    Register(state_type, create_state, destroy_state);
+  }
+
+ private:
+  // Register `this` module with the XLA runtime.
+  void Register(XLA_FFI_Module_StateType state_type,
+                XLA_FFI_Module_CreateState* create_state,
+                XLA_FFI_Module_DestroyState* destroy_state) {
+    XLA_FFI_Module_Register_Args args;
+    args.struct_size = XLA_FFI_Module_Register_Args_STRUCT_SIZE;
+    args.priv = nullptr;
+    args.name = module_name_.c_str();
+    args.module = reinterpret_cast<XLA_FFI_Module*>(this);
+    args.state_type = state_type;
+    args.create_state = create_state;
+    args.destroy_state = destroy_state;
+
+    std::vector<const char*> exported_names;
+    std::vector<XLA_FFI_Function*> exported_functions;
+    for (auto& fn : exported_functions_) {
+      exported_names.push_back(fn.target.c_str());
+      exported_functions.push_back(fn.function);
+    }
+
+    args.num_exported_functions = exported_functions_.size();
+    args.exported_names = exported_names.data();
+    args.exported_functions = exported_functions.data();
+
+    api_->XLA_FFI_Module_Register(&args);
+  }
+
+  // Module is registered with the XLA runtime behind this API instance, and any
+  // module manipulation (e.g. export functions) must be done through it.
+  const XLA_FFI_Api* api_;
+
+  std::string module_name_;
+  std::vector<ExportedFunction> exported_functions_;
+};
+
+//===----------------------------------------------------------------------===//
+// XLA FFI stateful module is a collection of FFI functions and a state.
+//===----------------------------------------------------------------------===//
+
+template <typename State>
+class StatefulModule : public Module {
+ public:
+  // TODO(ezhulenev): To gracefully fail if state can't be created, this has to
+  // return `FfiStatusOr<std::unique_ptr<State>>`, but we do not have a
+  // `StatusOr` implementation yet and we can't depend on absl.
+  virtual std::unique_ptr<State> CreateState() = 0;
+
+ protected:
+  StatefulModule(const XLA_FFI_Api* api, std::string module_name,
+                 std::vector<ExportedFunction> exported_functions,
+                 bool per_execution_state = false)
+      : Module(api, std::move(module_name), std::move(exported_functions),
+               per_execution_state ? XLA_FFI_Module_State_PER_EXECUTION
+                                   : XLA_FFI_Module_State_PER_EXECUTABLE,
+               CreateState, DestroyState) {}
+
+ private:
+  // Implements `XLA_FFI_Module_CreateState` API function.
+  static XLA_FFI_Error* CreateState(XLA_FFI_Module_CreateState_Args* args);
+
+  // Implements `XLA_FFI_Module_DestroyState` API function.
+  static void DestroyState(XLA_FFI_Module_DestroyState_Args* args);
+};
+
+template <typename State>
+XLA_FFI_Error* StatefulModule<State>::CreateState(
+    XLA_FFI_Module_CreateState_Args* args) {
+  CHECK_ARGS_SIZE(Module_CreateState, args);
+
+  auto* module = reinterpret_cast<StatefulModule*>(args->module);
+  auto* state = module->CreateState().release();
+  args->state = reinterpret_cast<XLA_FFI_Module_State*>(state);
+  return nullptr;  // success
+}
+
+template <typename State>
+void StatefulModule<State>::DestroyState(
+    XLA_FFI_Module_DestroyState_Args* args) {
+  CHECK_ARGS_SIZE(Module_DestroyState, args);
+
+  delete reinterpret_cast<State*>(args->state);
+}
+
+//===----------------------------------------------------------------------===//
+// XLA FFI stateless module is a collection of FFI functions without a state.
+//===----------------------------------------------------------------------===//
+
+class StatelessModule : public Module {
+ protected:
+  StatelessModule(const XLA_FFI_Api* api, std::string module_name,
+                  std::vector<ExportedFunction> exported_functions)
+      : Module(api, std::move(module_name), std::move(exported_functions),
+               /*state_type=*/XLA_FFI_Module_State_PER_EXECUTABLE,
+               /*create_state=*/nullptr, /*destroy_state=*/nullptr) {}
+};
+
+//===----------------------------------------------------------------------===//
+// Helper macro to define a static module registration.
+//===----------------------------------------------------------------------===//
+
+#define XLA_REGISTER_FFI_MODULE(FUNC) \
+  XLA_REGISTER_FFI_MODULE_IMPL(FUNC, __COUNTER__)
+
+#define XLA_REGISTER_FFI_MODULE_IMPL(FUNC, N)           \
+  static bool xla_ffi_module_##N##_registered_ = []() { \
+    static auto* module = FUNC.release();               \
+    return module != nullptr;                           \
+  }()
+
+//===----------------------------------------------------------------------===//
+// Arguments supported by the FFI handlers.
+//===----------------------------------------------------------------------===//
+
+// This enum corresponds to xla::PrimitiveType enum defined in `hlo.proto`.
+enum class PrimitiveType : uint8_t {
+  // Invalid primitive type to serve as default.
+  PRIMITIVE_TYPE_INVALID = 0,
+
+  // Predicates are two-state booleans.
+  PRED = 1,
+
+  // Signed integral values of fixed width.
+  S8 = 2,
+  S16 = 3,
+  S32 = 4,
+  S64 = 5,
+
+  // Unsigned integral values of fixed width.
+  U8 = 6,
+  U16 = 7,
+  U32 = 8,
+  U64 = 9,
+
+  // Floating-point values of fixed width.
+  //
+  // Note: if f16s are not natively supported on the device, they will be
+  // converted to f16 from f32 at arbitrary points in the computation.
+  F16 = 10,
+  F32 = 11,
+
+  // Truncated 16 bit floating-point format. This is similar to IEEE's 16 bit
+  // floating-point format, but uses 1 bit for the sign, 8 bits for the exponent
+  // and 7 bits for the mantissa.
+  BF16 = 16,
+
+  F64 = 12,
+};
+
+constexpr int ByteWidth(PrimitiveType type) {
+  switch (type) {
+    case PrimitiveType::PRED:
+      return 1;
+
+    case PrimitiveType::S8:
+    case PrimitiveType::U8:
+      return 1;
+
+    case PrimitiveType::S16:
+    case PrimitiveType::U16:
+    case PrimitiveType::F16:
+    case PrimitiveType::BF16:
+      return 2;
+
+    case PrimitiveType::S32:
+    case PrimitiveType::U32:
+    case PrimitiveType::F32:
+      return 4;
+
+    case PrimitiveType::S64:
+    case PrimitiveType::U64:
+    case PrimitiveType::F64:
+      return 8;
+
+    case PrimitiveType::PRIMITIVE_TYPE_INVALID:
+      assert(false && "Unsupported type");
+      return 0;
+  }
+}
+
+constexpr std::string_view PrimitiveTypeToString(PrimitiveType type) {
+  switch (type) {
+    case PrimitiveType::PRIMITIVE_TYPE_INVALID:
+      return "invalid";
+    case PrimitiveType::PRED:
+      return "pred";
+    case PrimitiveType::S8:
+      return "s8";
+    case PrimitiveType::S16:
+      return "s16";
+    case PrimitiveType::S32:
+      return "s32";
+    case PrimitiveType::S64:
+      return "s64";
+    case PrimitiveType::U8:
+      return "u8";
+    case PrimitiveType::U16:
+      return "u16";
+    case PrimitiveType::U32:
+      return "u32";
+    case PrimitiveType::U64:
+      return "u64";
+    case PrimitiveType::F16:
+      return "f16";
+    case PrimitiveType::F32:
+      return "f32";
+    case PrimitiveType::BF16:
+      return "bf16";
+    case PrimitiveType::F64:
+      return "f64";
+  }
+}
+
+// A view into the buffer argument. Buffers with non-identity layouts can be
+// decoded only as a StridedBufferArg.
+struct StridedBufferArg {
+  std::string ToString() const;
+
+  PrimitiveType dtype;
+  void* data;
+  Span<const int64_t> sizes;
+  Span<const int64_t> strides;
+};
+
+// A view into the buffer argument with an identity (row major) layout.
+struct BufferArg {
+  std::string ToString() const;
+
+  PrimitiveType dtype;
+  void* data;
+  Span<const int64_t> sizes;
+};
+
+// A flat view into the buffer argument with an identity (row major) layout.
+// If the memref shape and strides are not required, it is cheaper to pass the
+// flat buffer argument.
+struct FlatBufferArg {
+  std::string ToString() const;
+
+  PrimitiveType dtype;
+  void* data;
+  int64_t size_in_bytes;
+};
+
+// A type tag to represent dictionary attributes that can be decoded into
+// structs using aggregate attribute decoding.
+struct Dictionary {};
+
+template <typename T>
+bool Ffi::Isa(const XLA_FFI_Api* api, XLA_FFI_TypeId type_id) {
+#define ISA(type, name)                  \
+  if constexpr (std::is_same_v<T, type>) \
+    return api->XLA_FFI_Get_##name##_TypeId() == type_id;
+
+  ISA(std::string_view, String);
+
+  ISA(float, Float);
+  ISA(double, Double);
+  ISA(bool, Int1);
+  ISA(int32_t, Int32);
+  ISA(int64_t, Int64);
+
+  ISA(Span<const float>, FloatArray);
+  ISA(Span<const double>, DoubleArray);
+  ISA(Span<const int32_t>, Int32Array);
+  ISA(Span<const int64_t>, Int64Array);
+
+  ISA(MdSpan<float>, FloatTensor);
+  ISA(MdSpan<double>, DoubleTensor);
+  ISA(MdSpan<int32_t>, Int32Tensor);
+  ISA(MdSpan<int64_t>, Int64Tensor);
+
+  ISA(StridedBufferArg, StridedBufferArg);
+  ISA(BufferArg, BufferArg);
+  ISA(Dictionary, Dictionary);
+
+  assert(false && "Unsupported type");
+  return false;
+
+#undef ISA
+}
+
+//===----------------------------------------------------------------------===//
+// Pretty printing for buffers.
+//===----------------------------------------------------------------------===//
+
+static void PrintArray(std::stringstream& ss, Span<const int64_t> arr) {
+  ss << "[";
+  for (unsigned i = 0; i < arr.size(); ++i)
+    (i > 0) ? ss << ", " << arr[i] : ss << arr[i];
+  ss << "]";
+}
+
+inline std::string StridedBufferArg::ToString() const {
+  std::stringstream ss;
+  ss << "Buffer: dtype=" << PrimitiveTypeToString(dtype);
+  ss << " sizes=";
+  PrintArray(ss, sizes);
+  ss << " strides=";
+  PrintArray(ss, strides);
+  return ss.str();
+}
+
+inline std::string BufferArg::ToString() const {
+  std::stringstream ss;
+  ss << "Buffer: dtype=" << PrimitiveTypeToString(dtype);
+  ss << " sizes=";
+  PrintArray(ss, sizes);
+  return ss.str();
+}
+
+inline std::string FlatBufferArg::ToString() const {
+  std::stringstream ss;
+  ss << "Buffer: dtype=" << PrimitiveTypeToString(dtype);
+  ss << " size=" << size_in_bytes;
+  return ss.str();
+}
+
+//===----------------------------------------------------------------------===//
+// FFI binding describes the function signature expected by the FFI handler
+// using its variadic template parameter.
+//
+//   FFI binding:
+//     FfiBinding<int32_t, float>
+//
+//   Corresponds to the function signature:
+//     FfiStatus MyHandler(int32_t arg0, float arg1);
+//
+//===----------------------------------------------------------------------===//
+
+namespace internal {
+
+// A type tag to distinguish arguments tied to the attributes in the
+// `FfiBinding` variadic template argument.
+template <typename T>
+struct AttrTag {};
+
+// A type tag to distinguish argument tied to FFI module state.
+template <typename T>
+struct StateTag {};
+
+// A type tag to distinguish argument tied to XLA runtime stream.
+template <typename T>
+struct StreamTag {};
+
+// Type tag to distinguish an argument tied to an "ApiPriv" argument
+// to `Ffi::Binding`. This is necessary to obtain `XLA_FFI_Api.priv`
+// from the foreign function. For example:
+//
+// static ffi::FfiStatus FooFfi(MyStruct* bar, ffi::BufferArg input) { ... }
+//
+// XLA_FFI_DEFINE_FUNCTION(
+//     FFI_Foo, FooFfi, ffi::Ffi::Binding()
+//     .ApriPriv<MyStruct*>
+//     .Arg<ffi::BufferArg>);
+template <typename T>
+struct ApiPrivTag {};
+
+// A template for checking if type is a wrapped attribute or user data.
+// clang-format off
+template <typename>   struct IsWrapped                : std::false_type {};
+template <typename T> struct IsWrapped<AttrTag<T>>    : std::true_type {};
+template <typename T> struct IsWrapped<StateTag<T>>   : std::true_type {};
+template <typename T> struct IsWrapped<StreamTag<T>>  : std::true_type {};
+template <typename T> struct IsWrapped<ApiPrivTag<T>> : std::true_type {};
+// clang-format on
+
+}  // namespace internal
+
+template <typename... Ts>
+class FfiBinding {
+ public:
+  template <typename T>
+  FfiBinding<Ts..., T> Arg() && {
+    return {std::move(*this)};
+  }
+
+  template <typename T>
+  FfiBinding<Ts..., internal::AttrTag<T>> Attr(std::string attr) && {
+    attrs_.push_back(std::move(attr));
+    return {std::move(*this)};
+  }
+
+  template <typename T>
+  FfiBinding<Ts..., internal::StateTag<T>> State() && {
+    return {std::move(*this)};
+  }
+
+  template <typename T>
+  FfiBinding<Ts..., internal::StreamTag<T>> Stream() && {
+    static_assert(std::is_pointer_v<T>,
+                  "T must be a pointer type, e.g. for GPU platform it must be "
+                  "se::gpu::GpuStreamHandle");
+    return {std::move(*this)};
+  }
+
+  template <typename T>
+  FfiBinding<Ts..., internal::ApiPrivTag<T>> ApiPriv() && {
+    static_assert(std::is_pointer_v<T>, "T must be a pointer type");
+    return {std::move(*this)};
+  }
+
+  template <typename Fn>
+  std::unique_ptr<FfiHandler<Fn, Ts...>> To(Fn fn) {
+    return std::unique_ptr<FfiHandler<Fn, Ts...>>(
+        new FfiHandler<Fn, Ts...>(std::forward<Fn>(fn), std::move(attrs_)));
+  }
+
+ private:
+  template <typename...>
+  friend class FfiBinding;
+  friend class Ffi;
+
+  explicit FfiBinding() {
+    static_assert(sizeof...(Ts) == 0, "ffi arguments must be empty");
+  }
+
+  template <typename... TTs>
+  FfiBinding(FfiBinding<TTs...>&& other)  // NOLINT
+      : attrs_(std::move(other.attrs_)) {}
+
+  FfiBinding(FfiBinding&) = delete;
+
+  std::vector<std::string> attrs_;  // names of bound attributes
+};
+
+inline FfiBinding<> Ffi::Binding() { return FfiBinding<>(); }
+
+//===----------------------------------------------------------------------===//
+// Helpers for decoding opaque arguments and attributes' memory.
+//===----------------------------------------------------------------------===//
+
+namespace internal {
+
+using runtime::internal::EncodedArray;
+using runtime::internal::EncodedMemref;
+
+// Decoded pair of argument type and opaque value.
+struct DecodedArg {
+  XLA_FFI_TypeId type_id;
+  void* value;
+};
+
+// Decoded triple of attribute name, type and opaque value.
+struct DecodedAttr {
+  std::string_view name;
+  XLA_FFI_TypeId type_id;
+  void* value;
+};
+
+// A convenience wrapper around opaque arguments memory.
+class DecodedArgs {
+ public:
+  explicit DecodedArgs(void** args) {
+    XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(args, sizeof(void*));
+    size_ = *reinterpret_cast<int64_t*>(args[0]);
+    if (size_) {
+      XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(args + 1, sizeof(void*));
+      types_ = reinterpret_cast<void**>(args[1]);
+      values_ = args + 2;
+      XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(types_, size_ * sizeof(void*));
+      XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(values_, size_ * sizeof(void*));
+    }
+  }
+
+  int64_t size() const { return size_; }
+
+  DecodedArg operator[](size_t i) const {
+    DecodedArg arg;
+    arg.type_id = types_[i];
+    arg.value = values_[i];
+    return arg;
+  }
+
+ private:
+  int64_t size_;
+  void** types_ = nullptr;
+  void** values_ = nullptr;
+};
+
+// A convenience wrapper around opaque attributes' memory.
+class DecodedAttrs {
+ public:
+  explicit DecodedAttrs(void** attrs) : encoded_(attrs + 1) {
+    XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(attrs, sizeof(void*));
+    size_ = *reinterpret_cast<int64_t*>(attrs[0]);
+    XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(encoded_, 3 * size_ * sizeof(void*));
+  }
+
+  int64_t size() const { return size_; }
+
+  DecodedAttr operator[](size_t i) const {
+    void** attr_base = encoded_ + i * 3;
+
+    DecodedAttr attr;
+    auto* name = reinterpret_cast<internal::EncodedArray<char>*>(attr_base[0]);
+    attr.name = std::string_view(name->data, name->size);
+    attr.type_id = attr_base[1];
+    attr.value = attr_base[2];
+
+    return attr;
+  }
+
+ private:
+  void** encoded_;
+  int64_t size_;
+};
+
+}  // namespace internal
+
+//===----------------------------------------------------------------------===//
+// XLA FFI arguments decoding implementation.
+//===----------------------------------------------------------------------===//
+
+// XLA FFI arguments decoding must be defined by specializing this template.
+//
+// Example: decoding for the `MyType` arguments
+//
+//   template <>
+//   struct FfiArgDecoding<MyType> {
+//    static std::optional<MyType> Decode(ExecutionContext* ctx, TypeId type_id,
+//                                        void* value);
+//   };
+//
+template <typename T>
+struct FfiArgDecoding;
+
+// XLA FFI attribute decoding must be defined by specializing this template.
+//
+// Example: decoding for the `MyType` attributes
+//
+//   template <>
+//   struct FfiAttrDecoding<MyType> {
+//    static std::optional<MyType> Decode(ExecutionContext* ctx,
+//                                        std::string_view name,
+//                                        TypeId type_id, void* value);
+//   }
+//
+template <typename T>
+struct FfiAttrDecoding;
+
+namespace internal {
+
+// When decoding input data we need to keep track of how many arguments,
+// attributes, and returns we decoded so far to index into the correct data
+// structure.
+struct DecodingOffsets {
+  int64_t args = 0;
+  int64_t attrs = 0;
+  int64_t rets = 0;
+  int64_t values = 0;
+};
+
+template <typename T>
+struct Decode {
+  static std::optional<T> call(const XLA_FFI_Api* api,
+                               XLA_FFI_ExecutionContext* ctx,
+                               DecodingOffsets& offsets,
+                               internal::DecodedArgs args,
+                               const std::vector<std::string>& attrs_names,
+                               const std::vector<size_t>& attrs_idx,
+                               internal::DecodedAttrs attrs) {
+    internal::DecodedArg arg = args[offsets.args++];
+    return FfiArgDecoding<T>::Decode(api, arg.type_id, arg.value);
+  }
+};
+
+template <typename T>
+struct Decode<AttrTag<T>> {
+  static std::optional<T> call(const XLA_FFI_Api* api,
+                               XLA_FFI_ExecutionContext* ctx,
+                               DecodingOffsets& offsets,
+                               internal::DecodedArgs args,
+                               const std::vector<std::string>& attrs_names,
+                               const std::vector<size_t>& attrs_idx,
+                               internal::DecodedAttrs attrs) {
+    // Find decoded attribute corresponding to the given attribute index.
+    int64_t idx = offsets.attrs++;
+
+    // Get mapping from the attribute to its index in the sorted array.
+    size_t i = attrs_idx[idx];
+
+    // Attribute name does not match.
+    if (attrs[i].name != attrs_names[idx]) return std::nullopt;
+
+    return FfiAttrDecoding<T>::Decode(api, attrs[i].name, attrs[i].type_id,
+                                      attrs[i].value);
+  }
+};
+
+template <typename T>
+struct Decode<StateTag<T>> {
+  static std::optional<T*> call(const XLA_FFI_Api* api,
+                                XLA_FFI_ExecutionContext* ctx,
+                                DecodingOffsets& offsets, internal::DecodedArgs,
+                                const std::vector<std::string>& attrs_names,
+                                const std::vector<size_t>& attrs_idx,
+                                internal::DecodedAttrs attrs) {
+    XLA_FFI_ExecutionContext_GetModuleState_Args args;
+    args.struct_size = XLA_FFI_ExecutionContext_GetModuleState_Args_STRUCT_SIZE;
+    args.priv = nullptr;
+    args.ctx = ctx;
+
+    XLA_FFI_Module_State* state =
+        api->XLA_FFI_ExecutionContext_GetModuleState(&args);
+    return reinterpret_cast<T*>(state);
+  }
+};
+
+template <typename T>
+struct Decode<StreamTag<T>> {
+  static std::optional<T> call(const XLA_FFI_Api* api,
+                               XLA_FFI_ExecutionContext* ctx,
+                               DecodingOffsets& offsets, internal::DecodedArgs,
+                               const std::vector<std::string>& attrs_names,
+                               const std::vector<size_t>& attrs_idx,
+                               internal::DecodedAttrs attrs) {
+    XLA_FFI_ExecutionContext_GetStream_Args args;
+    args.struct_size = XLA_FFI_ExecutionContext_GetStream_Args_STRUCT_SIZE;
+    args.priv = nullptr;
+    args.ctx = ctx;
+
+    XLA_FFI_Stream* stream = api->XLA_FFI_ExecutionContext_GetStream(&args);
+    return reinterpret_cast<T>(stream);
+  }
+};
+
+template <typename T>
+struct Decode<ApiPrivTag<T>> {
+  static std::optional<T> call(const XLA_FFI_Api* api,
+                               XLA_FFI_ExecutionContext* ctx,
+                               DecodingOffsets& offsets, internal::DecodedArgs,
+                               const std::vector<std::string>& attrs_names,
+                               const std::vector<size_t>& attrs_idx,
+                               internal::DecodedAttrs attrs) {
+    return reinterpret_cast<T>(api->priv);
+  }
+};
+
+}  // namespace internal
+
+//===----------------------------------------------------------------------===//
+// Ffi handler binds concrete ffi implementation of type `Fn` to the ffi
+// function signature. `Fn` can be a function pointer or a lambda.
+//
+// Ffi handler uses the variadic template parameter `Ts` to decode the
+// opaque pointers passed to the `call` function into the C++ types that are
+// forwarded to the ffi implementation.
+//===----------------------------------------------------------------------===//
+
+namespace internal {
+
+// A helper template to extract the type of the handler argument.
+// clang-format off
+template <typename T> struct FnArgType                { using Type = T;  };
+template <typename T> struct FnArgType<AttrTag<T>>    { using Type = T;  };
+template <typename T> struct FnArgType<StateTag<T>>   { using Type = T*; };
+template <typename T> struct FnArgType<StreamTag<T>>  { using Type = T;  };
+template <typename T> struct FnArgType<ApiPrivTag<T>> { using Type = T;  };
+// clang-format on
+
+// A template for counting regular arguments in the Ts pack.
+template <typename... Ts>
+struct NumArgs;
+template <>
+struct NumArgs<> {
+  static constexpr int64_t value = 0;
+};
+
+template <typename T, typename... Ts>
+struct NumArgs<T, Ts...> {
+  static constexpr int64_t value = !IsWrapped<T>::value + NumArgs<Ts...>::value;
+};
+
+}  // namespace internal
+
+template <typename Fn, typename... Ts>
+class FfiHandler : public Ffi {
+  static constexpr int64_t kSize = sizeof...(Ts);
+  static constexpr int64_t kNumArgs = internal::NumArgs<Ts...>::value;
+
+  template <typename T>
+  using FnArgType = typename internal::FnArgType<T>::Type;
+
+  // Check if FFI function returns `FfiStatus`.
+  static constexpr bool kIsFfiStatusHandler =
+      std::is_invocable_r_v<FfiStatus, Fn, FnArgType<Ts>...>;
+  static_assert(kIsFfiStatusHandler, "unsupported FFI handler type");
+
+  static XLA_FFI_Error* ToError(const XLA_FFI_Api* api, FfiStatus status) {
+    if (!status.errc().has_value()) return nullptr;
+
+    XLA_FFI_Error_Create_Args args;
+    args.struct_size = XLA_FFI_Error_Create_Args_STRUCT_SIZE;
+    args.priv = nullptr;
+    args.errc = *status.errc();
+    args.message = status.message_c_str();
+
+    return api->XLA_FFI_Error_Create(&args);
+  }
+
+ public:
+  XLA_FFI_Error* operator()(const XLA_FFI_Api* api,
+                            XLA_FFI_ExecutionContext* ctx, void** args,
+                            void** attrs, void** rets) const final {
+    // Decode arguments and attributes from the opaque pointers.
+    internal::DecodedArgs decoded_args(args);
+    internal::DecodedAttrs decoded_attrs(attrs);
+
+    int64_t num_args = decoded_args.size();
+    int64_t num_attrs = decoded_attrs.size();
+
+    // Check that we have the correct number of arguments passed to the handler.
+    if (num_args != kNumArgs) {
+      std::ostringstream err;
+      err << "Wrong number of arguments: expected " << kNumArgs << " got "
+          << num_args;
+      return ToError(api, FfiStatus::InvalidArgument(err.str()));
+    }
+
+    // Check that we have the correct number of attributes passed to the
+    // handler. Each individual attribute decoding will check the name and the
+    // type of the attribute.
+    if (num_attrs != attrs_.size()) {
+      std::ostringstream err;
+      err << "Wrong number of attributes: expected " << attrs_.size() << " got "
+          << num_attrs;
+      return ToError(api, FfiStatus::InvalidArgument(err.str()));
+    }
+
+    // Define index sequence to access ffi handler arguments.
+    using Is = std::make_index_sequence<kSize>;
+    return call(api, ctx, decoded_args, decoded_attrs, Is{});
+  }
+
+ private:
+  template <typename...>
+  friend class FfiBinding;
+
+  template <size_t... Is>
+  XLA_FFI_Error* call(const XLA_FFI_Api* api, XLA_FFI_ExecutionContext* ctx,
+                      internal::DecodedArgs args, internal::DecodedAttrs attrs,
+                      std::index_sequence<Is...>) const {
+    // A helper structure to allow each decoder find the correct offset in the
+    // arguments, attributes or results.
+    internal::DecodingOffsets offsets;
+
+    // Decode all operands into `std::optional` containers. It is guaranteed
+    // that initializer list will be evaluated left-to-right, and we can rely
+    // on correct offsets computation.
+    std::tuple<std::optional<FnArgType<Ts>>...> fn_args = {
+        internal::Decode<Ts>::call(api, ctx, offsets, args, attrs_, attrs_idx_,
+                                   attrs)...};
+
+    // Check if all arguments, attributes and results were decoded;
+    bool all_decoded = (std::get<Is>(fn_args).has_value() && ...);
+    if (!all_decoded) {
+      std::array<bool, kSize> decoded = {std::get<Is>(fn_args).has_value()...};
+      std::string err = "Failed to decode all FFI operands (bad operands at: ";
+      for (size_t cnt = 0, idx = 0; idx < kSize; ++idx) {
+        if (!decoded[idx]) {
+          if (cnt++) err.append(", ");
+          err.append(std::to_string(idx));
+        }
+      }
+      err.append(")");
+      return ToError(api, FfiStatus::InvalidArgument(err));
+    }
+
+    // Custom call returns `FfiStatus`, we can call it directly.
+    if constexpr (kIsFfiStatusHandler) {
+      return ToError(api, fn_(std::move(*std::get<Is>(fn_args))...));
+    }
+
+    return ToError(api, FfiStatus::Ok());
+  }
+
+  FfiHandler(Fn fn, std::vector<std::string> attrs)
+      : fn_(std::move(fn)),
+        attrs_(std::move(attrs)),
+        attrs_idx_(attrs_.size()) {
+    // Sort attributes names.
+    std::vector<std::string> sorted = attrs_;
+    std::sort(sorted.begin(), sorted.end());
+
+    // Find the index of every attribute in the sorted attributes vector.
+    for (size_t i = 0; i < attrs_.size(); ++i) {
+      const std::string& attr = attrs_[i];
+      attrs_idx_[i] = std::distance(
+          sorted.begin(), std::find(sorted.begin(), sorted.end(), attr));
+    }
+  }
+
+  Fn fn_;
+
+  std::vector<std::string> attrs_;
+
+  // A mapping from the attribute index to its index in the lexicographically
+  // sorted vector of attribute names. Attributes are passed to the ffi handler
+  // sorted by the name, we use this index to efficiently find the decoded
+  // attribute entry.
+  std::vector<size_t> attrs_idx_;
+};
+
+//===----------------------------------------------------------------------===//
+// XLA FFI arguments decoding.
+//===----------------------------------------------------------------------===//
+
+#define XLA_FFI_REGISTER_SCALAR_ARG_DECODING(T)                           \
+  template <>                                                             \
+  struct FfiArgDecoding<T> {                                              \
+    static std::optional<T> Decode(const XLA_FFI_Api* api,                \
+                                   XLA_FFI_TypeId type_id, void* value) { \
+      if (!Ffi::Isa<T>(api, type_id)) {                                   \
+        return std::nullopt;                                              \
+      }                                                                   \
+                                                                          \
+      XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(value, sizeof(T));           \
+      return *reinterpret_cast<T*>(value);                                \
+    }                                                                     \
+  }
+
+XLA_FFI_REGISTER_SCALAR_ARG_DECODING(int32_t);
+
+#undef XLA_FFI_REGISTER_SCALAR_ARG_DECODING
+
+template <>
+struct FfiArgDecoding<StridedBufferArg> {
+  using EncodedMemref = internal::EncodedMemref;
+
+  static std::optional<StridedBufferArg> Decode(const XLA_FFI_Api* api,
+                                                XLA_FFI_TypeId type_id,
+                                                void* value) {
+    if (!Ffi::Isa<BufferArg, StridedBufferArg>(api, type_id)) {
+      return std::nullopt;
+    }
+
+    auto* encoded = reinterpret_cast<EncodedMemref*>(value);
+    XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(encoded, sizeof(EncodedMemref));
+    XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(
+        encoded, sizeof(EncodedMemref) + encoded->rank * sizeof(int64_t));
+
+    PrimitiveType dtype = static_cast<PrimitiveType>(encoded->dtype);
+    return StridedBufferArg{dtype,
+                            encoded->data,
+                            {encoded->dims, encoded->rank},
+                            {encoded->dims + encoded->rank, encoded->rank}};
+  }
+};
+
+template <>
+struct FfiArgDecoding<BufferArg> {
+  using EncodedMemref = internal::EncodedMemref;
+
+  static std::optional<BufferArg> Decode(const XLA_FFI_Api* api,
+                                         XLA_FFI_TypeId type_id, void* value) {
+    if (!Ffi::Isa<BufferArg>(api, type_id)) {
+      return std::nullopt;
+    }
+
+    auto* encoded = reinterpret_cast<EncodedMemref*>(value);
+    XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(encoded, sizeof(EncodedMemref));
+    XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(
+        encoded, sizeof(EncodedMemref) + encoded->rank * sizeof(int64_t));
+
+    PrimitiveType dtype = static_cast<PrimitiveType>(encoded->dtype);
+    return BufferArg{dtype, encoded->data, {encoded->dims, encoded->rank}};
+  }
+};
+
+template <>
+struct FfiArgDecoding<FlatBufferArg> {
+  using EncodedMemref = internal::EncodedMemref;
+
+  static std::optional<FlatBufferArg> Decode(const XLA_FFI_Api* api,
+                                             XLA_FFI_TypeId type_id,
+                                             void* value) {
+    if (!Ffi::Isa<BufferArg>(api, type_id)) {
+      return std::nullopt;
+    }
+
+    auto* encoded = reinterpret_cast<EncodedMemref*>(value);
+    XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(encoded, sizeof(EncodedMemref));
+    XLA_FFI_ANNOTATE_MEMORY_IS_INITIALIZED(
+        encoded, sizeof(EncodedMemref) + encoded->rank * sizeof(int64_t));
+
+    auto dtype = static_cast<PrimitiveType>(encoded->dtype);
+    int64_t size_in_bytes = ByteWidth(dtype);
+    for (int d = 0; d < encoded->rank; ++d) {
+      size_in_bytes *= encoded->dims[d];
+    }
+    return FlatBufferArg{dtype, encoded->data, size_in_bytes};
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// XLA FFI attributes decoding.
+//===----------------------------------------------------------------------===//
+
+#define XLA_FFI_REGISTER_SCALAR_ATTR_DECODING(T)                          \
+  template <>                                                             \
+  struct FfiAttrDecoding<T> {                                             \
+    static std::optional<T> Decode(const XLA_FFI_Api* api,                \
+                                   std::string_view name,                 \
+                                   XLA_FFI_TypeId type_id, void* value) { \
+      if (!Ffi::Isa<T>(api, type_id)) {                                   \
+        return std::nullopt;                                              \
+      }                                                                   \
+                                                                          \
+      return *reinterpret_cast<T*>(value);                                \
+    }                                                                     \
+  }
+
+XLA_FFI_REGISTER_SCALAR_ATTR_DECODING(float);
+XLA_FFI_REGISTER_SCALAR_ATTR_DECODING(double);
+XLA_FFI_REGISTER_SCALAR_ATTR_DECODING(bool);
+XLA_FFI_REGISTER_SCALAR_ATTR_DECODING(int32_t);
+XLA_FFI_REGISTER_SCALAR_ATTR_DECODING(int64_t);
+
+#undef XLA_FFI_REGISTER_SCALAR_ATTR_DECODING
+
+// Both EncodedArray and 1-D EncodedDenseElements can be decoded as a Span.
+// Pointers to both EncodedArray and 1-D EncodedDenseElements can be
+// dereferenced as a pointer to EncodedArray.
+#define XLA_FFI_REGISTER_ARRAY_ATTR_DECODING(T)                            \
+  template <>                                                              \
+  struct FfiAttrDecoding<Span<const T>> {                                  \
+    static std::optional<Span<const T>> Decode(const XLA_FFI_Api* api,     \
+                                               std::string_view name,      \
+                                               XLA_FFI_TypeId type_id,     \
+                                               void* value) {              \
+      if (!Ffi::Isa<Span<const T>, MdSpan<T>>(api, type_id)) {             \
+        return std::nullopt;                                               \
+      }                                                                    \
+                                                                           \
+      auto* encoded = reinterpret_cast<internal::EncodedArray<T>*>(value); \
+      return Span<const T>(encoded->data, encoded->size);                  \
+    }                                                                      \
+  }
+
+XLA_FFI_REGISTER_ARRAY_ATTR_DECODING(float);
+XLA_FFI_REGISTER_ARRAY_ATTR_DECODING(double);
+XLA_FFI_REGISTER_ARRAY_ATTR_DECODING(bool);
+XLA_FFI_REGISTER_ARRAY_ATTR_DECODING(int32_t);
+XLA_FFI_REGISTER_ARRAY_ATTR_DECODING(int64_t);
+
+#undef XLA_FFI_REGISTER_ARRAY_ATTR_DECODING
+
+template <>
+struct FfiAttrDecoding<std::string_view> {
+  static std::optional<std::string_view> Decode(const XLA_FFI_Api* api,
+                                                std::string_view name,
+                                                XLA_FFI_TypeId type_id,
+                                                void* value) {
+    if (!Ffi::Isa<std::string_view>(api, type_id)) {
+      return std::nullopt;
+    }
+
+    auto* encoded = reinterpret_cast<internal::EncodedArray<char>*>(value);
+    return std::string_view(encoded->data, encoded->size);
+  }
+};
+
+//===----------------------------------------------------------------------===//
+// Register an XLA FFI attribute decoding from dictionaries to structs.
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+struct AggregateMember {
+  using Type = T;
+
+  explicit AggregateMember(std::string_view name) : name(name) {}
+  std::string_view name;
+};
+
+// Example: register decoding for a user-defined struct
+//
+//   struct PairOfI64 { int64_t a; int64_t b; };
+//
+//   XLA_FFI_REGISTER_AGGREGATE_ATTR_DECODING(
+//     PairOfI64,
+//     AggregateMember<int64_t>("a"),
+//     AggregateMember<int64_t>("b"));
+//
+#define XLA_FFI_REGISTER_AGGREGATE_ATTR_DECODING(T, ...)                       \
+  template <>                                                                  \
+  struct FfiAttrDecoding<T> {                                                  \
+    static std::optional<T> Decode(const XLA_FFI_Api* api,                     \
+                                   std::string_view name,                      \
+                                   XLA_FFI_TypeId type_id, void* value) {      \
+      if (!Ffi::Isa<Dictionary>(api, type_id)) {                               \
+        return std::nullopt;                                                   \
+      }                                                                        \
+                                                                               \
+      auto decoder = internal::AggregateDecoder<T>(__VA_ARGS__);               \
+      return decltype(decoder)::Decode(api, reinterpret_cast<void**>(value),   \
+                                       internal::AggregateNames(__VA_ARGS__)); \
+    }                                                                          \
+  }
+
+namespace internal {
+// Decodes aggregate attribute into the object of type `T` that must be
+// constructible from the `Ts` types.
+template <typename T, typename... Ts>
+struct DecodeAggregateAttr {
+  static constexpr size_t kSize = sizeof...(Ts);
+
+  static std::optional<T> Decode(const XLA_FFI_Api* api, void** value,
+                                 std::array<std::string_view, kSize> names) {
+    internal::DecodedAttrs attrs(value);
+    return Decode(api, attrs, names, std::make_index_sequence<kSize>{});
+  }
+
+  template <size_t... Is>
+  static std::optional<T> Decode(const XLA_FFI_Api* api,
+                                 internal::DecodedAttrs attrs,
+                                 std::array<std::string_view, kSize> names,
+                                 std::index_sequence<Is...>) {
+    // Check that the number of encoded attributes matches the signature.
+    if (kSize != attrs.size()) return std::nullopt;
+
+    // Check that aggregate member names match the expected names.
+    for (unsigned i = 0; i < kSize; ++i)
+      if (attrs[i].name != names[i]) return std::nullopt;
+
+    // Decode all arguments into std::optional containers. It is guaranteed
+    // that initializer list will be evaluated left-to-right, and we can rely
+    // on correct offsets computation.
+    std::tuple<std::optional<Ts>...> members = {FfiAttrDecoding<Ts>::Decode(
+        api, attrs[Is].name, attrs[Is].type_id, attrs[Is].value)...};
+
+    bool all_decoded = (std::get<Is>(members).has_value() && ...);
+    if (!all_decoded) return std::nullopt;
+
+    // Forward unpacked members to the type constructor.
+    return T{std::move(*std::get<Is>(members))...};
+  }
+};
+
+template <typename... Members>
+auto AggregateNames(Members... m) {
+  return std::array<std::string_view, sizeof...(Members)>{m.name...};
+}
+
+template <typename T, typename... Members>
+auto AggregateDecoder(Members... m) {
+  return DecodeAggregateAttr<T, typename Members::Type...>();
+}
+
+}  // namespace internal
+
+//===----------------------------------------------------------------------===//
+// XLA FFI helper macro for registering FFI implementations.
+//===----------------------------------------------------------------------===//
+
+#define XLA_FFI_DEFINE_FUNCTION(fn, impl, binding)                   \
+  static XLA_FFI_Error* fn(XLA_FFI_Function_Args* args) {            \
+    ::xla::runtime::ffi::internal::CheckStructSize(                  \
+        "XLA_FFI_Function_Args", XLA_FFI_Function_Args_STRUCT_SIZE,  \
+        args->struct_size);                                          \
+    static auto* handler = binding.To(impl).release();               \
+    return (*handler)(args->api, args->ctx, args->args, args->attrs, \
+                      args->rets);                                   \
+  }
+
+#undef CHECK_ARGS_SIZE
+
+}  // namespace ffi
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_FFI_FFI_API_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/ffi/ffi_c_api.h

@@ -0,0 +1,276 @@
+/* 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_RUNTIME_FFI_FFI_C_API_H_
+#define XLA_RUNTIME_FFI_FFI_C_API_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+// Every struct passed across the C API boundary has its size as a member, and
+// we use it as a sanity check for API compatibility.
+#define XLA_FFI_STRUCT_SIZE(struct_type, last_field) \
+  offsetof(struct_type, last_field) + sizeof(((struct_type*)0)->last_field)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Forward declare.
+typedef struct XLA_FFI_Api XLA_FFI_Api;
+
+//===----------------------------------------------------------------------===//
+// XLA FFI Type checking.
+//===----------------------------------------------------------------------===//
+
+// XLA FFI passes type ids along with all arguments and attributes so that it
+// should be possible to check types at run time inside the FFI handler.
+typedef const void* XLA_FFI_TypeId;
+
+typedef XLA_FFI_TypeId XLA_FFI_Get_TypeId();
+
+//===----------------------------------------------------------------------===//
+// XLA FFI Error handling.
+//===----------------------------------------------------------------------===//
+
+// XLA FFI handler must return a XLA_FFI_Error*, which is NULL if there is no
+// error and set if there is. Caller allocates any returned XLA_FFI_Errors, and
+// the XLA FFI is responsible for freeing them.
+typedef struct XLA_FFI_Error XLA_FFI_Error;
+
+// Codes are based on https://abseil.io/docs/cpp/guides/status-codes
+typedef enum {
+  XLA_FFI_Error_Code_CANCELLED = 1,
+  XLA_FFI_Error_Code_UNKNOWN = 2,
+  XLA_FFI_Error_Code_INVALID_ARGUMENT = 3,
+  XLA_FFI_Error_Code_DEADLINE_EXCEEDED = 4,
+  XLA_FFI_Error_Code_NOT_FOUND = 5,
+  XLA_FFI_Error_Code_ALREADY_EXISTS = 6,
+  XLA_FFI_Error_Code_PERMISSION_DENIED = 7,
+  XLA_FFI_Error_Code_RESOURCE_EXHAUSTED = 8,
+  XLA_FFI_Error_Code_FAILED_PRECONDITION = 9,
+  XLA_FFI_Error_Code_ABORTED = 10,
+  XLA_FFI_Error_Code_OUT_OF_RANGE = 11,
+  XLA_FFI_Error_Code_UNIMPLEMENTED = 12,
+  XLA_FFI_Error_Code_INTERNAL = 13,
+  XLA_FFI_Error_Code_UNAVAILABLE = 14,
+  XLA_FFI_Error_Code_DATA_LOSS = 15,
+  XLA_FFI_Error_Code_UNAUTHENTICATED = 16
+} XLA_FFI_Error_Code;
+
+//===----------------------------------------------------------------------===//
+// XLA FFI module defines a set of exported FFI functions and their state.
+//===----------------------------------------------------------------------===//
+
+// XLA FFI module is a way to structure FFI functions together with a state
+// required for calling them. XLA runtime executable can be linked with multiple
+// of such modules at run time.
+typedef struct XLA_FFI_Module XLA_FFI_Module;
+
+// XLA FFI module state can be instantiated once for each XLA executable, and
+// its life time will be bound to the executable iself, or it can be
+// instantiated for each separate execution.
+typedef enum {
+  XLA_FFI_Module_State_PER_EXECUTABLE = 1,
+  XLA_FFI_Module_State_PER_EXECUTION = 2,
+} XLA_FFI_Module_StateType;
+
+// Exported FFI functions will have access to the state object that they can
+// use to share data between different function invocations. If the state is
+// instantiated for each executable, it is the user's responsibility to
+// guarantee that it is thread-safe to use from multiple concurrent executions.
+typedef struct XLA_FFI_Module_State XLA_FFI_Module_State;
+
+// Creates a new per-executable module state.
+typedef struct {
+  size_t struct_size;
+  void* priv;
+  XLA_FFI_Module* module;
+  XLA_FFI_Module_State* state;  // out
+} XLA_FFI_Module_CreateState_Args;
+
+const size_t XLA_FFI_Module_CreateState_Args_STRUCT_SIZE =
+    XLA_FFI_STRUCT_SIZE(XLA_FFI_Module_CreateState_Args, state);
+
+typedef XLA_FFI_Error* XLA_FFI_Module_CreateState(
+    XLA_FFI_Module_CreateState_Args* args);
+
+// Destroys a module state.
+typedef struct {
+  size_t struct_size;
+  void* priv;
+  XLA_FFI_Module* module;
+  XLA_FFI_Module_State* state;
+} XLA_FFI_Module_DestroyState_Args;
+
+const size_t XLA_FFI_Module_DestroyState_Args_STRUCT_SIZE =
+    XLA_FFI_STRUCT_SIZE(XLA_FFI_Module_DestroyState_Args, state);
+
+typedef void XLA_FFI_Module_DestroyState(
+    XLA_FFI_Module_DestroyState_Args* args);
+
+//===----------------------------------------------------------------------===//
+// XLA FFI Error Reporting APIs.
+//===----------------------------------------------------------------------===//
+
+typedef struct {
+  size_t struct_size;
+  void* priv;
+  const char* message;
+  XLA_FFI_Error_Code errc;
+} XLA_FFI_Error_Create_Args;
+
+const size_t XLA_FFI_Error_Create_Args_STRUCT_SIZE =
+    XLA_FFI_STRUCT_SIZE(XLA_FFI_Error_Create_Args, message);
+
+typedef XLA_FFI_Error* XLA_FFI_Error_Create(XLA_FFI_Error_Create_Args* args);
+
+//===----------------------------------------------------------------------===//
+// XLA FFI Stream.
+//===----------------------------------------------------------------------===//
+
+// XLA FFI stream is an opaque handle to the underlying stream executor `Stream`
+// implementation. In XLA:GPU it is `se::gpu::GpuStreamHandle` (when running on
+// CUDA platform it is a `CUstream`).
+typedef struct XLA_FFI_Stream XLA_FFI_Stream;
+
+//===----------------------------------------------------------------------===//
+// XLA FFI Execution Context.
+//===----------------------------------------------------------------------===//
+
+typedef struct XLA_FFI_ExecutionContext XLA_FFI_ExecutionContext;
+
+// Get `XLA_FFI_Module_State` from the execution context.
+typedef struct {
+  size_t struct_size;
+  void* priv;
+  XLA_FFI_ExecutionContext* ctx;
+} XLA_FFI_ExecutionContext_GetModuleState_Args;
+
+const size_t XLA_FFI_ExecutionContext_GetModuleState_Args_STRUCT_SIZE =
+    XLA_FFI_STRUCT_SIZE(XLA_FFI_ExecutionContext_GetModuleState_Args, ctx);
+
+typedef XLA_FFI_Module_State* XLA_FFI_ExecutionContext_GetModuleState(
+    XLA_FFI_ExecutionContext_GetModuleState_Args* args);
+
+// Get `XLA_FFI_Stream` from the execution context.
+typedef struct {
+  size_t struct_size;
+  void* priv;
+  XLA_FFI_ExecutionContext* ctx;
+} XLA_FFI_ExecutionContext_GetStream_Args;
+
+const size_t XLA_FFI_ExecutionContext_GetStream_Args_STRUCT_SIZE =
+    XLA_FFI_STRUCT_SIZE(XLA_FFI_ExecutionContext_GetStream_Args, ctx);
+
+typedef XLA_FFI_Stream* XLA_FFI_ExecutionContext_GetStream(
+    XLA_FFI_ExecutionContext_GetStream_Args* args);
+
+//===----------------------------------------------------------------------===//
+// XLA FFI Function API.
+//===----------------------------------------------------------------------===//
+
+// Arguments passed to an FFI function.
+typedef struct {
+  size_t struct_size;
+  void* priv;
+  const XLA_FFI_Api* api;
+  XLA_FFI_ExecutionContext* ctx;
+  void** args;
+  void** attrs;
+  void** rets;
+} XLA_FFI_Function_Args;
+
+const size_t XLA_FFI_Function_Args_STRUCT_SIZE =
+    XLA_FFI_STRUCT_SIZE(XLA_FFI_Function_Args, rets);
+
+// XLA FFI function type that can be exported to a runtime.
+typedef XLA_FFI_Error* XLA_FFI_Function(XLA_FFI_Function_Args* args);
+
+//===----------------------------------------------------------------------===//
+// XLA FFI Api.
+//===----------------------------------------------------------------------===//
+
+// Register FFI module with an XLA runtime.
+typedef struct {
+  size_t struct_size;
+  void* priv;
+  const char* name;
+  XLA_FFI_Module* module;
+  XLA_FFI_Module_StateType state_type;
+  XLA_FFI_Module_CreateState* create_state;
+  XLA_FFI_Module_DestroyState* destroy_state;
+  int64_t num_exported_functions;
+  const char** exported_names;            // length == num_exported_functions
+  XLA_FFI_Function** exported_functions;  // length == num_exported_functions
+} XLA_FFI_Module_Register_Args;
+
+const size_t XLA_FFI_Module_Register_Args_STRUCT_SIZE =
+    XLA_FFI_STRUCT_SIZE(XLA_FFI_Module_Register_Args, exported_functions);
+
+typedef void XLA_FFI_Module_Register(XLA_FFI_Module_Register_Args* args);
+
+#define XLA_FFI_API_STRUCT_FIELD(fn_type) fn_type* fn_type
+
+#define XLA_FFI_API_TYPEID_FIELD(type) \
+  XLA_FFI_Get_TypeId* XLA_FFI_Get_##type##_TypeId
+
+typedef struct XLA_FFI_Api {
+  size_t struct_size;
+  void* priv;
+
+  XLA_FFI_API_STRUCT_FIELD(XLA_FFI_Module_Register);
+
+  XLA_FFI_API_STRUCT_FIELD(XLA_FFI_ExecutionContext_GetModuleState);
+  XLA_FFI_API_STRUCT_FIELD(XLA_FFI_ExecutionContext_GetStream);
+
+  XLA_FFI_API_STRUCT_FIELD(XLA_FFI_Error_Create);
+
+  XLA_FFI_API_TYPEID_FIELD(String);
+  XLA_FFI_API_TYPEID_FIELD(Float);
+  XLA_FFI_API_TYPEID_FIELD(Double);
+  XLA_FFI_API_TYPEID_FIELD(Int1);
+  XLA_FFI_API_TYPEID_FIELD(Int32);
+  XLA_FFI_API_TYPEID_FIELD(Int64);
+
+  XLA_FFI_API_TYPEID_FIELD(FloatArray);
+  XLA_FFI_API_TYPEID_FIELD(DoubleArray);
+  XLA_FFI_API_TYPEID_FIELD(Int32Array);
+  XLA_FFI_API_TYPEID_FIELD(Int64Array);
+
+  XLA_FFI_API_TYPEID_FIELD(FloatTensor);
+  XLA_FFI_API_TYPEID_FIELD(DoubleTensor);
+  XLA_FFI_API_TYPEID_FIELD(Int32Tensor);
+  XLA_FFI_API_TYPEID_FIELD(Int64Tensor);
+
+  XLA_FFI_API_TYPEID_FIELD(BufferArg);
+  XLA_FFI_API_TYPEID_FIELD(StridedBufferArg);
+  XLA_FFI_API_TYPEID_FIELD(Dictionary);
+} XLA_FFI_Api;
+
+#undef XLA_FFI_API_STRUCT_FIELD
+#undef XLA_FFI_API_TYPEID_FIELD
+
+const size_t XLA_FFI_Api_STRUCT_SIZE =
+    XLA_FFI_STRUCT_SIZE(XLA_FFI_Api, XLA_FFI_Get_StridedBufferArg_TypeId);
+
+// Does not pass ownership of returned XLA_FFI_Api* to caller.
+const XLA_FFI_Api* GetXlaFfiApi();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // XLA_RUNTIME_FFI_FFI_C_API_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/jit_executable.h

@@ -0,0 +1,240 @@
+/* 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_RUNTIME_JIT_EXECUTABLE_H_
+#define XLA_RUNTIME_JIT_EXECUTABLE_H_
+
+#include <any>
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <utility>
+#include <vector>
+
+#include "absl/status/statusor.h"
+#include "xla/mlir/runtime/transforms/jit_compiler.h"
+#include "xla/runtime/async_values_cache.h"  // IWYU pragma: keep
+#include "xla/runtime/constraints.h"
+#include "tfrt/concurrency/async_value_ref.h"  // from @tf_runtime
+#include "tfrt/concurrency/chain.h"  // from @tf_runtime
+
+namespace xla {
+namespace runtime {
+
+// JitExecutable owns a default executable compiled from the MLIR module (if
+// operands constraints allow that), and orchestrates on-demand re-compilation
+// for specific argument ranks, shapes or values depending on the operands
+// constraints.
+class JitExecutable {
+ public:
+  using UserData = std::any;
+
+  // XLA program can be specialized and recompiled at runtime to the concrete
+  // input shapes and sometimes values (e.g. reduction dimension).
+  enum class Specialization {
+    // Recompile specialized executables when needed.
+    kEnabled,
+    // Completely disable specialized executables (always call default
+    // executable).
+    kDisabled,
+    // Always use specialized executables, and never call default executable
+    // (only required for getting reproducible results in benchmarks).
+    kAlways,
+  };
+
+  struct Options {
+    // What level of specialization is enabled at runtime.
+    Specialization specialization = Specialization::kAlways;
+
+    // Options for the XLA runtime JitCompiler.
+    JitCompiler::Options compiler;
+  };
+
+  // We use `llvm::unique_function` to represent compilation task because it
+  // allows to capture move-only values.
+  using CompilationTask = llvm::unique_function<void()>;
+
+  // Compilation task runner called at runtime when specialization compilation
+  // is required with the `TaskFunction` that does the compilation, and updates
+  // the internal state of the `JitExecutable`. This runner can be used by the
+  // caller to offload compilation task to the specialized thread pool and
+  // add tracing events (e.g. add Tensorflow profiler tracing). Task runner must
+  // call the `TaskFunction`, otherwise it will lead to deadlock.
+  //
+  // Caller can pass arbitrary user data to the `GetExecutable` method, and it
+  // will be passed to the runner if recompilation is required. It is guaranteed
+  // that the runner will be called in the same thread as `GetExecutable`.
+  //
+  using CompilationTaskRunner =
+      llvm::unique_function<void(size_t, absl::Span<const ArgumentConstraint>,
+                                 ArgumentsRef, CompilationTask, UserData)>;
+
+  // Inline compilation task runner runs compilation task in the caller thread.
+  static void InlineCompilationTaskRunner(
+      size_t num_specializations,
+      absl::Span<const ArgumentConstraint> constraints, ArgumentsRef arguments,
+      CompilationTask task, UserData user_data);
+
+  // TODO(ezhulenev): Currently exported functions must be defined explicitly by
+  // the user. It should be possible to define exported functions implicitly by
+  // having `rt.export` operations in the compiled module, and export new
+  // functions while running compilation pipeline. Also `Executable` potentially
+  // might have more exported functions than the `JitExecutable` that
+  // instantiated it. Consider adding "private" exported functions, that are not
+  // visible through the `Executable` API (e.g. function references might be
+  // passed to custom calls, but they should not be visible to the client).
+  static absl::StatusOr<JitExecutable> Instantiate(
+      std::string_view mlir_module, Options opts,
+      absl::Span<const std::string_view> exported,
+      std::string_view memory_region_name = "",
+      CompilationTaskRunner runner = InlineCompilationTaskRunner);
+
+  static absl::StatusOr<JitExecutable> Instantiate(
+      std::string_view mlir_module, std::string_view exported, Options opts,
+      std::string_view memory_region_name = "",
+      CompilationTaskRunner runner = InlineCompilationTaskRunner) {
+    return Instantiate(mlir_module, opts, {exported}, memory_region_name,
+                       std::move(runner));
+  }
+
+  // Returns default executable that accepts all compatible operands
+  // (operands rank and all static dimensions should match the operands).
+  tsl::AsyncValuePtr<Executable> DefaultExecutable() const;
+
+  // Returns an executable that may be specialized for the arguments. Can return
+  // default executable if no specialization is required, or if the specialized
+  // executable is not yet available.
+  //
+  // Caller can pass arbitrary data via the `user_data` argument, and it will be
+  // available to the compilation task runner. This can be used for tracing,
+  // e.g. to track what user-level requests triggered recompilation.
+  //
+  // Returns an error if the arguments do not match the expected function
+  // signature and specialization is not possible (without trying to compile).
+  // If specialization is disabled, returns the default executable without
+  // checking the arguments (the default executable itself will check arguments
+  // when called).
+  //
+  // Async values holding compilation results (executables) cached in the
+  // JitExecutable, and successive calls with the same arguments are cheap (the
+  // definition of "same" depend on the argument type specialization and chosen
+  // hash function, e.g. shaped arguments compared using their symbolic shape).
+  // If compilation fails, then the returned async value will hold a compilation
+  // error message. Compilation errors are never retried.
+  //
+  // Note: This function never falls back on the default executable if
+  // specialization compilation fails.
+  //
+  // TODO(ezhulenev): Add support for specifying exported function ordinal,
+  // currently this will always specialize exported function with ordinal 0.
+  absl::StatusOr<tsl::AsyncValuePtr<Executable>> GetExecutable(
+      ArgumentsRef arguments, UserData user_data = {},
+      const SpecializationListener* listener = nullptr);
+
+  // Returns an async value that becomes ready when all executables owned by
+  // this JitExecutable are compiled (no pending compilation tasks).
+  tsl::AsyncValueRef<tsl::Chain> AllExecutablesCompiled() const;
+
+  // JitExecutable is move-only type.
+  JitExecutable(const JitExecutable&) = delete;
+  JitExecutable(JitExecutable&&) = default;
+
+  std::string_view mlir_module() { return mlir_module_; }
+
+  unsigned num_functions() const { return functions_.size(); }
+
+ private:
+  // JitExecutable defines multiple exported functions that could be compiled
+  // into the executable. At run time they are referenced by their ordinal, so
+  // that we don't depend on expensive by-name lookup on the hot path. Function
+  // ordinal is defined by its index in the `functions_` vector.
+  //
+  // TODO(ezhulenev): Today when JitExecutable instantiates specialized
+  // executable via call to `GetExecutable` it can only specialize the function
+  // with ordinal 0. It should be possible to specialize multiple functions, and
+  // select which functions should be compiled at all.
+  struct Function {
+    Function(std::string_view name, FunctionType signature,
+             absl::Span<const ArgumentConstraint> constraints);
+
+    Function(const Function&) = delete;
+    Function(Function&&) = default;
+
+    // Exported function name.
+    std::string name;
+
+    // Signature of the exported function.
+    //
+    // This function signature is allowed to have operands and results types
+    // without a well-defined ABI (e.g. it can have tensors when compiled module
+    // defined in Tensorflow dialect), and it corresponds to the executable
+    // definition in one of the high level dialects (e.g. Tensorflow or mHLO).
+    //
+    // When compiled module prepared for execution, function operands and
+    // results are mapped to the types with well-defined ABI (e.g. tensors
+    // mapped to memrefs). See `runtime_signature` documentation in the
+    // `Executable::Function` type.
+    FunctionType signature;
+
+    // Exported function arguments constraints after resolving them using the
+    // statically known information in the function signature. If constraint
+    // specified by the argument attribute known to be statically satisfied by
+    // the argument type (e.g. rank constraint with an operand of statically
+    // known rank), then the constraint value for that operand will be updated
+    // to `kResolved`.
+    llvm::SmallVector<ArgumentConstraint> constraints;
+
+    // True if any of the arguments has `ArgumentConstraint::kValue` constraint.
+    bool has_value_constraints;
+
+    // Symbolic shape resolver assigns symbolic dimensions to runtime operands
+    // based on the exported function signature.
+    SymbolicShapesResolver symbolic_shapes_resolver;
+  };
+
+  JitExecutable(std::string_view mlir_module, Options opts,
+                std::vector<Function> functions,
+                std::optional<Executable> default_executable,
+                std::string_view memory_region_name,
+                CompilationTaskRunner runner);
+
+  std::string mlir_module_;
+  Options opts_;
+
+  // Functions exported by this jit executable, indexed by function ordinal.
+  std::vector<Function> functions_;
+
+  // Default executable that was not specialized to any of the arguments.
+  AsyncValueRef<Executable> default_executable_;
+  bool has_default_executable_;
+
+  // Name of the memory region where JIT'ed code is compiled to.
+  // This allows profilers to correctly label JIT-executed code.
+  // Note: this feature might only be available on some platforms, e.g. Linux.
+  std::string memory_region_name_;
+
+  // A custom runner for compiling specializations.
+  CompilationTaskRunner runner_;
+
+  // Executables specialized for the arguments shapes or/and values.
+  using Specializations = AsyncValuesCache<llvm::hash_code, Executable>;
+  std::unique_ptr<Specializations> specializations_;
+};
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_JIT_EXECUTABLE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/logical_result.h

@@ -0,0 +1,36 @@
+/* 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_RUNTIME_LOGICAL_RESULT_H_
+#define XLA_RUNTIME_LOGICAL_RESULT_H_
+
+#include "mlir/Support/LogicalResult.h"  // from @llvm-project
+
+namespace xla {
+namespace runtime {
+
+using ::mlir::failure;  // NOLINT
+using ::mlir::success;  // NOLINT
+
+using ::mlir::failed;     // NOLINT
+using ::mlir::succeeded;  // NOLINT
+
+using ::mlir::FailureOr;      // NOLINT
+using ::mlir::LogicalResult;  // NOLINT
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_LOGICAL_RESULT_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/map_by_type.h

@@ -0,0 +1,110 @@
+/* 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_RUNTIME_MAP_BY_TYPE_H_
+#define XLA_RUNTIME_MAP_BY_TYPE_H_
+
+#include <algorithm>
+#include <vector>
+
+#include "llvm/ADT/SmallVector.h"
+#include "xla/runtime/type_id.h"
+
+namespace xla {
+namespace runtime {
+
+// An optimized map container for storing pointers of different types.
+//
+// Example:
+//
+//   PtrMapByType<IdSet> map;
+//
+//   int32_t i32 = 0;
+//   int64_t i64 = 1;
+//
+//   map.insert(&i32);
+//   map.insert(&i64);
+//
+//   assert(map.contains<int32_t*>());
+//   assert(map.contains<int64_t*>());
+//
+template <typename IdSet, unsigned n = 16>
+class PtrMapByType {
+ public:
+  PtrMapByType() = default;
+
+  template <typename... Ts>
+  explicit PtrMapByType(Ts*... values) {
+    insert_all<Ts...>(values..., std::make_index_sequence<sizeof...(Ts)>{});
+  }
+
+  template <typename T>
+  T* insert(T* value) {
+    size_t id = GetDenseTypeId<T>();
+    if (id >= data_.size()) {
+      data_.resize(id + 1);
+    }
+    data_[id] = const_cast<std::decay_t<T>*>(value);
+    return value;
+  }
+
+  template <typename... Ts>
+  void insert_all(Ts*... values) {
+    insert_all<Ts...>(values..., std::make_index_sequence<sizeof...(Ts)>{});
+  }
+
+  template <typename T>
+  T* get() const {
+    size_t id = GetDenseTypeId<T>();
+    assert(id < data_.size());
+    return reinterpret_cast<T*>(data_[id]);
+  }
+
+  template <typename T>
+  T* getIfExists() const {
+    size_t id = GetDenseTypeId<T>();
+    return LLVM_LIKELY(id < data_.size()) ? reinterpret_cast<T*>(data_[id])
+                                          : nullptr;
+  }
+
+  template <typename T>
+  bool contains() const {
+    size_t id = GetDenseTypeId<T>();
+    return id < data_.size() && data_[id] != nullptr;
+  }
+
+ private:
+  template <typename T>
+  static size_t GetDenseTypeId() {
+    return DenseTypeId<IdSet>::template get<T>();
+  }
+
+  template <typename... Ts, size_t... Is>
+  void insert_all(Ts*... values, std::index_sequence<Is...>) {
+    static constexpr size_t kNumInserted = sizeof...(Ts);
+    if constexpr (kNumInserted > 0) {
+      std::array<size_t, kNumInserted> ids = {GetDenseTypeId<Ts>()...};
+      data_.resize(1 + *std::max_element(ids.begin(), ids.end()), nullptr);
+      ((data_[ids[Is]] = const_cast<std::decay_t<Ts>*>(values)), ...);
+    }
+  }
+
+  llvm::SmallVector<void*, n> data_;
+};
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_MAP_BY_TYPE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/memory_mapper.h

@@ -0,0 +1,65 @@
+/* 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_RUNTIME_MEMORY_MAPPER_H_
+#define XLA_RUNTIME_MEMORY_MAPPER_H_
+
+#include <memory>
+#include <string>
+#include <string_view>
+#include <system_error>  // NOLINT
+
+#include "tsl/platform/platform.h"
+
+#if defined(PLATFORM_GOOGLE)
+#include "xla/runtime/google/memory_mapper.h"
+#else
+#include "xla/runtime/default/memory_mapper.h"
+#endif
+
+#include "llvm/ExecutionEngine/SectionMemoryManager.h"
+
+namespace xla {
+namespace runtime {
+
+// XLA runtime memory mapper allocates memory for XLA executables (object files)
+// using `memfd_create` system call, and gives the user-friendly name to the
+// file descriptor, so that for example in `perf` it should be possible to
+// identify input XLA programs by name.
+class XlaRuntimeMemoryMapper final
+    : public llvm::SectionMemoryManager::MemoryMapper {
+ public:
+  static std::unique_ptr<XlaRuntimeMemoryMapper> Create(std::string_view name);
+
+  llvm::sys::MemoryBlock allocateMappedMemory(
+      llvm::SectionMemoryManager::AllocationPurpose purpose, size_t len,
+      const llvm::sys::MemoryBlock* const near_block, unsigned prot_flags,
+      std::error_code& error_code) final;
+
+  std::error_code protectMappedMemory(const llvm::sys::MemoryBlock& block,
+                                      unsigned prot_flags) final;
+
+  std::error_code releaseMappedMemory(llvm::sys::MemoryBlock& block) final;
+
+ private:
+  explicit XlaRuntimeMemoryMapper(std::string_view name) : name_(name) {}
+
+  std::string name_;
+};
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_MEMORY_MAPPER_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/memref_view.h

@@ -0,0 +1,56 @@
+/* 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_RUNTIME_MEMREF_VIEW_H_
+#define XLA_RUNTIME_MEMREF_VIEW_H_
+
+#include <cstdint>
+
+#include "absl/types/span.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace runtime {
+
+// A view into the memref argument. Corresponds to the MemrefDesc, however it
+// doesn't own the sizes/strides vectors, and cheap to pass around. Memrefs with
+// non-identity layouts can be decoded only as a StridedMemrefView.
+struct StridedMemrefView {
+  PrimitiveType dtype;
+  void* data;
+  absl::Span<const int64_t> sizes;
+  absl::Span<const int64_t> strides;
+};
+
+// A view into the memref argument with an identity (row major) layout.
+struct MemrefView {
+  PrimitiveType dtype;
+  void* data;
+  absl::Span<const int64_t> sizes;
+};
+
+// A flat view into memref argument with an identity (row major) layout. If the
+// memref shape and strides are not required for the custom call, it's cheaper
+// to pass the flat view.
+struct FlatMemrefView {
+  PrimitiveType dtype;
+  void* data;
+  int64_t size_in_bytes;
+};
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_MEMREF_VIEW_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/module.h

@@ -0,0 +1,185 @@
+/* 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_RUNTIME_MODULE_H_
+#define XLA_RUNTIME_MODULE_H_
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "xla/runtime/custom_call_registry.h"
+
+namespace xla {
+namespace runtime {
+
+template <typename S, typename R>
+class StatefulModule;
+class StatelessModule;
+
+//===---------------------------------------------------------------------===///
+// Xla runtime module.
+//===---------------------------------------------------------------------===///
+
+// Xla runtime module is a way to structure custom calls (external functions)
+// together with the state required for calling them. Xla runtime executable can
+// be linked with multiple of such modules at run time.
+//
+// As an example Xla Gpu has a StreamExecutor-based HAL (hardware abstraction
+// layer) implemented as a runtime module. Different Xla backends can require
+// different sets of modules for running executables, and some of the modules
+// can be shared between backends (e.g. XProf integration).
+//
+// User-defined modules must inherit from `StatefulModule` or `StatelessModule`.
+class Module {
+ public:
+  // When a module is instantiated for each runtime executable it can optionally
+  // create a state object that can be used to implement stateful functions,
+  // to keep a state between exported functions invocations. State can be
+  // accessed from different executable invocations running concurrently.
+  struct State {
+    virtual ~State() = default;
+  };
+
+  // StateRef is a potentially long-lived reference held by the runtime that
+  // must guarantee that all pointers added to the user data container are
+  // pointing to live objects (see `InitializeUserData` for more details).
+  struct StateRef {
+    virtual ~StateRef() = default;
+  };
+
+  virtual ~Module() = default;
+
+  virtual std::string_view name() const = 0;
+
+  // Creates a new per-executable module state.
+  virtual absl::StatusOr<std::unique_ptr<State>> CreateState() const = 0;
+
+  // Initializes `user_data` with values required for calling functions exported
+  // from the module. If initializing `user_data` requires creating temporaries,
+  // then the returned `StateRef` should guarantee their lifetime. Runtime
+  // itself guarantees that `state` is alive when it calls any of the exported
+  // functions; this means that `user_data` can safely point to `state`'s
+  // members.
+  virtual absl::StatusOr<std::unique_ptr<StateRef>> InitializeUserData(
+      State* state, CustomCall::UserData& user_data) const = 0;
+
+  // Exports direct custom calls provided by this module to the registry.
+  virtual void Export(DirectCustomCallRegistry& registry) const {}
+
+  // Exports dynamic custom calls provided by this module to the registry.
+  virtual void Export(DynamicCustomCallRegistry& registry) const {}
+
+ private:
+  template <typename S, typename R>
+  friend class StatefulModule;
+  friend class StatelessModule;
+
+  Module() = default;
+};
+
+//===---------------------------------------------------------------------===///
+// Stateful and typed Xla runtime module.
+//===---------------------------------------------------------------------===///
+
+template <typename S, typename R = void>
+class StatefulModule : public Module {
+  static_assert(std::is_base_of_v<State, S>,
+                "State must be derived from Module::State");
+
+  static_assert(std::is_base_of_v<StateRef, R> || std::is_void_v<R>,
+                "State ref must be `void` or derived from Module::StateRef");
+
+ public:
+  std::string_view name() const final { return name_; }
+
+  // Creates a new per-executable module State.
+  virtual absl::StatusOr<std::unique_ptr<S>> CreateModuleState() const = 0;
+
+  // If state ref is void then UserData initialization must return
+  // `absl::Status`, otherwise it must return `absl::StatusOr` with a state
+  // reference value.
+  virtual std::conditional_t<std::is_void_v<R>, absl::Status,
+                             absl::StatusOr<std::unique_ptr<R>>>
+  InitializeUserData(S* state, CustomCall::UserData& user_data) const {
+    if constexpr (std::is_void_v<R>) {
+      return absl::OkStatus();
+    } else {
+      return nullptr;
+    }
+  }
+
+ protected:
+  explicit StatefulModule(std::string name) : name_(std::move(name)) {}
+
+ private:
+  absl::StatusOr<std::unique_ptr<State>> CreateState() const final {
+    return CreateModuleState();
+  }
+
+  absl::StatusOr<std::unique_ptr<StateRef>> InitializeUserData(
+      State* state, CustomCall::UserData& user_data) const final {
+    auto initialized = InitializeUserData(dynamic_cast<S*>(state), user_data);
+
+    // Convert `absl::OkStatus` to an `absl::StatusOr` with an empty state ref.
+    if constexpr (std::is_void_v<R>) {
+      if (initialized.ok()) return nullptr;
+    }
+
+    return initialized;
+  }
+
+  std::string name_;
+};
+
+//===---------------------------------------------------------------------===///
+// Stateless Xla runtime module.
+//===---------------------------------------------------------------------===///
+
+class StatelessModule : public Module {
+ public:
+  std::string_view name() const final { return name_; }
+
+  virtual absl::Status InitializeUserData(
+      CustomCall::UserData& user_data) const {
+    return absl::OkStatus();
+  }
+
+ protected:
+  explicit StatelessModule(std::string name) : name_(std::move(name)) {}
+
+ private:
+  absl::StatusOr<std::unique_ptr<State>> CreateState() const final {
+    return nullptr;
+  }
+
+  absl::StatusOr<std::unique_ptr<StateRef>> InitializeUserData(
+      State* state, CustomCall::UserData& user_data) const final {
+    if (auto init = InitializeUserData(user_data); !init.ok()) return init;
+    return nullptr;
+  }
+
+  std::string name_;
+};
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_MODULE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/module_registry.h

@@ -0,0 +1,75 @@
+/* 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_RUNTIME_MODULE_REGISTRY_H_
+#define XLA_RUNTIME_MODULE_REGISTRY_H_
+
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "xla/runtime/module.h"
+
+namespace xla {
+namespace runtime {
+
+// Registers Xla runtime module with a global modules registry.
+//
+// TODO(ezhulenev): We need to support modules restricted for different
+// platforms, e.g. we should not instantiate state for GPU modules when
+// compiling a CPU executable. Xla today uses a "platform name" (Host,
+// CUDA, etc...) for this.
+void RegisterModule(std::unique_ptr<Module> module);
+
+// Exports registered modules to the given custom call registry.
+//
+// TODO(ezhulenev): We also need to support exporting direct custom calls.
+void ExportModules(DynamicCustomCallRegistry& registry);
+
+// Helper macro to define a static module registration.
+#define XLA_REGISTER_RUNTIME_MODULE(FUNC) \
+  XLA_REGISTER_RUNTIME_MODULE_IMPL(FUNC, __COUNTER__)
+
+#define XLA_REGISTER_RUNTIME_MODULE_IMPL(FUNC, N)           \
+  static bool xla_runtime_module_##N##_registered_ = []() { \
+    ::xla::runtime::RegisterModule(FUNC);                   \
+    return true;                                            \
+  }()
+
+// Container that owns the state of all registered modules.
+class ModulesState {
+ public:
+  ModulesState() = default;
+
+  // Instantiates `ModulesState` from the registered module.
+  //
+  // TODO(ezhulenev): Take module's platform.
+  static absl::StatusOr<ModulesState> Instantiate();
+
+  // Initializes `UserData` from the module's state.
+  absl::StatusOr<std::vector<std::unique_ptr<Module::StateRef>>>
+  InitializeUserData(CustomCall::UserData& user_data);
+
+ private:
+  explicit ModulesState(
+      std::vector<std::pair<Module*, std::unique_ptr<Module::State>>> state);
+
+  std::vector<std::pair<Module*, std::unique_ptr<Module::State>>> state_;
+};
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_MODULE_REGISTRY_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/results.h

@@ -0,0 +1,186 @@
+/* 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_RUNTIME_RESULTS_H_
+#define XLA_RUNTIME_RESULTS_H_
+
+#include <type_traits>
+
+#include "xla/runtime/logical_result.h"
+#include "xla/runtime/types.h"
+
+namespace xla {
+namespace runtime {
+
+//===----------------------------------------------------------------------===//
+// Conversions from XLA executable results to C++ types.
+//===----------------------------------------------------------------------===//
+
+// The result type defines its own ABI as a required number of bytes and
+// alignment, and executable returns results by writing into the requested
+// memory allocated in the call frame. The user is responsible for providing
+// a conversion function that converts this opaque memory back to the C++
+// data type. For example memrefs returned as a `StridedMemrefType` structure,
+// and it is the user responsibiity to define a conversion function that can
+// convert a memref to the run time Tensor/Buffer type.
+//
+// It is important that the type that is written into the call frame memory has
+// a standard memory layout, because we rely on `reinterpret_cast` to reinterpet
+// the opaque bytes to a C struct.
+//
+// See https://en.cppreference.com/w/cpp/types/is_standard_layout
+
+// Result converter is responsible for taking a pointer to the memory location
+// where the executable wrote the result, and converting it to the corresponding
+// run time value expected by the caller (e.g. memref descriptor to Tensor).
+class ResultConverter {
+ public:
+  virtual ~ResultConverter() = default;
+
+  // Converts value `ret` of type `runtime_type` (runtime type derived from the
+  // original `type`) returned from the executable at `result_index` result
+  // position using registered conversion functions. Returns a logical result
+  // telling if the conversion was successful.
+  virtual LogicalResult ReturnValue(unsigned result_index, const Type* type,
+                                    const Type* runtime_type,
+                                    void* ret) const = 0;
+
+  // Returns error for all results. This function is called if the runtime
+  // fails to run the executable, or if the executable returns an error.
+  //
+  // This function is not called if an individual `ReturnValue` conversion
+  // fails.
+  //
+  // It is the user's responsibility to handle the case where the return value
+  // conversion fails, and some error value has to be returned for unhandled
+  // results, e.g. error async value for unconverted results.
+  virtual void ReturnError(const absl::Status& error) const = 0;
+};
+
+//===----------------------------------------------------------------------===//
+// Result converter for functions without results (returning void).
+//===----------------------------------------------------------------------===//
+
+struct NoResultConverter : public ResultConverter {
+  LLVM_ATTRIBUTE_ALWAYS_INLINE
+  LogicalResult ReturnValue(unsigned, const Type*, const Type*,
+                            void*) const final {
+    assert(false && "no result converter must never be called");
+    return failure();
+  }
+
+  void ReturnError(const absl::Status&) const final {}
+};
+
+//===----------------------------------------------------------------------===//
+// Returns results using user-provided set of conversion functions.
+//===----------------------------------------------------------------------===//
+
+template <typename RetError, typename... RetValue>
+class ResultConverterSet : public ResultConverter {
+  static_assert(sizeof...(RetValue), "result converters must be non-empty");
+
+  static_assert(std::is_invocable_v<RetError, const absl::Status&>);
+
+  static_assert(std::conjunction_v<
+                std::is_invocable_r<LogicalResult, RetValue, unsigned,
+                                    const Type*, const Type*, void*>...>);
+
+ public:
+  explicit ResultConverterSet(RetError ret_error, RetValue... ret_value)
+      : ret_error_(std::move(ret_error)),
+        ret_value_(std::forward<RetValue>(ret_value)...) {}
+
+  LogicalResult ReturnValue(unsigned result_index, const Type* type,
+                            const Type* runtime_type, void* ret) const final {
+    return ReturnValue<0>(result_index, type, runtime_type, ret);
+  }
+
+  void ReturnError(const absl::Status& error) const final { ret_error_(error); }
+
+ private:
+  template <size_t idx>
+  LogicalResult ReturnValue(unsigned result_index, const Type* type,
+                            const Type* runtime_type, void* ret) const {
+    // Try to call the user-provided converter.
+    auto& converter = std::get<idx>(ret_value_);
+    if (succeeded(converter(result_index, type, runtime_type, ret)))
+      return success();
+
+    // If conversion failed try the next one if available.
+    if constexpr (idx + 1 < sizeof...(RetValue))
+      return ReturnValue<idx + 1>(result_index, type, runtime_type, ret);
+
+    return failure();
+  }
+
+  RetError ret_error_;
+  std::tuple<RetValue...> ret_value_;
+};
+
+template <typename RetError, typename... RetValue>
+ResultConverterSet(RetError, RetValue...)
+    -> ResultConverterSet<RetError, RetValue...>;
+
+//===----------------------------------------------------------------------===//
+// Helper functions for converting results of canonical types.
+//===----------------------------------------------------------------------===//
+
+namespace internal {
+
+// This struct corresponds to the `llvm.struct` used by memref to llvm lowering
+// pass to represent memref descriptors in the compilation pipeline. It is a
+// type-erased version of `::mlir::StridedMemRefType<T>` template.
+struct MemrefDescriptor {
+  void* base_ptr;
+  void* data_ptr;
+  int64_t offset;
+  int64_t sizes_and_strides[];
+};
+
+}  // namespace internal
+
+// Converts returned memref using user-provided converter. Converter must
+// satisfy this concept:
+//
+//   struct Converter {
+//     ResultType operator()(PrimitiveType element_type, void* base_ptr,
+//                           void* data_ptr, int64_t offset,
+//                           absl::Span<const int64_t> dims,
+//                           absl::Span<const int64_t> strides);
+//   };
+//
+template <typename T, typename Converter>
+FailureOr<T> ConvertReturnedMemref(const Converter& converter,
+                                   const Type* memref_type, void* ret) {
+  // Check if the runtime type is a valid memref.
+  auto* memref = llvm::dyn_cast<MemrefType>(memref_type);
+  if (!memref) return failure();
+
+  PrimitiveType element_type = memref->element_type();
+  size_t rank = memref->rank();
+
+  auto* desc = reinterpret_cast<internal::MemrefDescriptor*>(ret);
+  absl::Span<const int64_t> dims(desc->sizes_and_strides, rank);
+  absl::Span<const int64_t> strides(desc->sizes_and_strides + rank, rank);
+
+  return converter(element_type, desc->base_ptr, desc->data_ptr, desc->offset,
+                   dims, strides);
+}
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_RESULTS_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/runtime.h

@@ -0,0 +1,66 @@
+/* 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_RUNTIME_RUNTIME_H_
+#define XLA_RUNTIME_RUNTIME_H_
+
+#include <stdint.h>
+
+namespace xla {
+namespace runtime {
+
+//===----------------------------------------------------------------------===//
+// XLA Runtime <-> XLA Executable integration API.
+//===----------------------------------------------------------------------===//
+
+// This API enables compiled XLA executables to call back into the XLA runtime
+// for:
+//
+//  - Returning results back to the caller by writing to result storage
+//    allocated in the call frame.
+//  - User friendly error reporting integrated with the high level execution
+//    model (errors do not crash the compiled binary).
+//  - Invoking custom calls registered with the XLA runtime.
+//
+// XLA compilation pipeline sets up passes to convert the regular functions
+// to the so called "XLA entrypoint functions" integrated with the runtime using
+// the API defined below, e.g. instead of conventional returns all results are
+// returned via the `GetResultStorage` API. At MLIR level these operations
+// correspond to the `rt` dialect, and converted to LLVM using the `rt-to-llvm`
+// conversion pass.
+//
+// Runtime errors are reported back to the runtime via the `SetError` API.
+// The compilation pipeline will automatically convert assertions in the
+// entrypoint function into run-time errors.
+
+// Opaque runtime execution context passed as the first argument to compiled
+// executables and passed back to all runtime API methods.
+using ExecutionContext = struct ExecutionContext;
+
+// Returns a pointer to the memory location of the result at the given index.
+void *GetResultStorage(ExecutionContext *, int64_t);
+
+// Sets execution context to an error state.
+void SetError(ExecutionContext *, const char *);
+
+// Calls the custom call function registered with the runtime. Returns true
+// if the custom call was successful.
+bool CustomCall(ExecutionContext *, const char *target, void **args,
+                void **attrs, void **rets);
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_RUNTIME_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/state.h

@@ -0,0 +1,218 @@
+/* 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_RUNTIME_STATE_H_
+#define XLA_RUNTIME_STATE_H_
+
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/synchronization/mutex.h"
+
+namespace xla {
+namespace runtime {
+
+// Forward declare.
+template <typename T>
+class State;
+
+// StateVector is a container for keeping the state between custom call
+// invocations (within same or concurrent calls to `Executable::Execute`).
+//
+// Every instance of the custom call in the executable must be assigned a unique
+// id (dense i64 integer in the [0, num_instances) range), and the state vector
+// enables efficient access to value of type `T`, with lazy initialization done
+// by the custom call itself.
+//
+// Custom calls implement special bindings for state arguments:
+//
+//   CustomCall::Bind("foo")
+//     .State<FooState>("id_attr_name")
+//     .To([](State<FooState> state) {
+//       FooState foo = state.GetOrCreate(...);
+//       ...
+//     });
+//
+// State snapshot must be passed via UserData:
+//
+//   StateVector<FooState>::Snapshot snapshot = ...;
+//   CustomCall::UserData user_data(&snapshot, ...);
+//
+// See `custom_call.h` and `custom_call_test.cc` for more examples.
+template <typename T>
+class StateVector {
+ public:
+  explicit StateVector(size_t reserve = 0);
+
+  // Snapshot wraps the read-only state snapshot (potentially obsolete) and
+  // falls back on synchronized state access if it can't find an entry in its
+  // read-only state snapshot.
+  class Snapshot {
+   public:
+    // Returns a state for the given id if it's already available, or tries to
+    // create a new one using the user-provided `create` function. Returns an
+    // error if state creation fails. Failures are not cached and always
+    // retried.
+    template <typename F>
+    absl::StatusOr<T*> GetOrCreate(size_t id, F&& create);
+
+    absl::StatusOr<T*> Get(size_t id);
+
+    absl::Status Erase(size_t id);
+
+    // Returns a state constructed from this snapshot for a given id.
+    State<T> state(size_t id) { return State<T>(id, this); }
+
+   private:
+    friend StateVector;
+    Snapshot(StateVector& state, std::shared_ptr<std::vector<T*>> snapshot);
+
+    // State vector that this snapshot was taken from.
+    StateVector& owning_state_;
+
+    // State vector snapshot captured at construction time. It might not contain
+    // all the latest data available in the `owning_state_`.
+    std::shared_ptr<std::vector<T*>> maybe_obsolete_snapshot_;
+  };
+
+  Snapshot snapshot();
+  T* operator[](size_t id);
+
+ private:
+  mutable absl::Mutex mu_;
+
+  // StateVector owns the values of type `T` indexed by the key.
+  std::vector<std::unique_ptr<T>> vector_ ABSL_GUARDED_BY(mu_);
+
+  // A read-only snapshot of `vector_` that is updated every time a new entry
+  // is added to the state vector.
+  std::shared_ptr<std::vector<T*>> vector_snapshot_ ABSL_GUARDED_BY(mu_);
+};
+
+template <typename T>
+class State {
+  using Snapshot = typename StateVector<T>::Snapshot;
+
+ public:
+  template <typename F>
+  absl::StatusOr<T*> GetOrCreate(F&& create) {
+    return snapshot_->GetOrCreate(id_, std::forward<F>(create));
+  }
+
+ private:
+  friend Snapshot;
+  State(size_t id, Snapshot* snapshot) : id_(id), snapshot_(snapshot) {}
+
+  size_t id_;
+  Snapshot* snapshot_;
+};
+
+//===----------------------------------------------------------------------===//
+
+template <typename T>
+StateVector<T>::StateVector(size_t reserve)
+    : vector_(reserve), vector_snapshot_(new std::vector<T*>(reserve)) {}
+
+template <typename T>
+StateVector<T>::Snapshot::Snapshot(StateVector& state,
+                                   std::shared_ptr<std::vector<T*>> snapshot)
+    : owning_state_(state), maybe_obsolete_snapshot_(std::move(snapshot)) {}
+
+template <typename T>
+auto StateVector<T>::snapshot() -> Snapshot {
+  absl::MutexLock lock(&mu_);
+  return Snapshot(*this, vector_snapshot_);
+}
+
+template <typename T>
+T* StateVector<T>::operator[](size_t id) {
+  absl::MutexLock lock(&mu_);
+  return id < vector_.size() ? vector_[id].get() : nullptr;
+}
+
+template <typename T>
+template <typename F>
+absl::StatusOr<T*> StateVector<T>::Snapshot::GetOrCreate(size_t id,
+                                                         F&& create) {
+  static_assert(std::is_invocable_r_v<absl::StatusOr<T>, F>);
+
+  // If snapshot already contains the entry, just return it.
+  std::vector<T*>& snapshot = *maybe_obsolete_snapshot_;
+  if (id < snapshot.size() && snapshot[id]) return snapshot[id];
+
+  // Otherwise go through the slow synchronized code path.
+  absl::MutexLock lock(&owning_state_.mu_);
+
+  // Check if value is present in the state vector, and was not captured in
+  // the snapshot that we have.
+  std::vector<std::unique_ptr<T>>& state = owning_state_.vector_;
+  if (id < state.size() && state[id].get()) return state[id].get();
+
+  // Try to insert a new entry.
+  absl::StatusOr<T> value = create();
+  if (!value.ok()) return value.status();
+
+  // Update the state vector.
+  if (id >= state.size()) state.resize(id + 1);
+  state[id] = std::make_unique<T>(*std::move(value));
+
+  // And take the new snapshot.
+  auto new_snapshot = std::make_shared<std::vector<T*>>(state.size());
+  for (size_t i = 0; i < state.size(); ++i) (*new_snapshot)[i] = state[i].get();
+
+  // Update the snapshot owned by the state.
+  owning_state_.vector_snapshot_ = std::move(new_snapshot);
+
+  return state[id].get();
+}
+
+template <typename T>
+absl::StatusOr<T*> StateVector<T>::Snapshot::Get(size_t id) {
+  // If snapshot already contains the entry, just return it.
+  std::vector<T*>& snapshot = *maybe_obsolete_snapshot_;
+  if (id < snapshot.size() && snapshot[id]) return snapshot[id];
+
+  // Otherwise go through the slow synchronized code path.
+  absl::MutexLock lock(&owning_state_.mu_);
+
+  // Check if value is present in the state vector, and was not captured in
+  // the snapshot that we have.
+  std::vector<std::unique_ptr<T>>& state = owning_state_.vector_;
+  if (id < state.size() && state[id].get()) return state[id].get();
+
+  return absl::InternalError("Value not found in state vector");
+}
+
+template <typename T>
+absl::Status StateVector<T>::Snapshot::Erase(size_t id) {
+  absl::MutexLock lock(&owning_state_.mu_);
+
+  std::vector<std::unique_ptr<T>>& state = owning_state_.vector_;
+  if (id < state.size() && state[id].get()) {
+    state[id].reset(nullptr);
+    return absl::OkStatus();
+  }
+
+  return absl::InternalError("Value not found in state vector");
+}
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_STATE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/symbolic_shape.h

@@ -0,0 +1,117 @@
+/* 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_RUNTIME_SYMBOLIC_SHAPE_H_
+#define XLA_RUNTIME_SYMBOLIC_SHAPE_H_
+
+#include <optional>
+
+#include "absl/status/statusor.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/SmallVector.h"
+#include "xla/runtime/arguments.h"
+#include "xla/runtime/constraints.h"
+
+namespace xla {
+namespace runtime {
+
+// Symbolic shapes resolver computes the symbolic shapes of the arguments based
+// on the function signature, and concrete shapes of the arguments at runtime.
+//
+// Example: dimensions that have the same symbolic shape at runtime.
+//
+//   signature: func @compute(%arg0: tensor<?xf32>, %arg1: tensor<?xf32)
+//                            ^                     ^
+//   arguments:               memref<123xf32>       memref<123xf32>
+//                            ^                     ^
+//   symbolic shapes:         [-2xf32]              [-2xf32]
+//
+// Each unknown dimension in the function signature will be assigned a symbolic
+// dimension. If multiple shaped arguments have unknown dimensions that are the
+// same at runtime, they will be assigned the same symbolic dimensions value
+// (e.g. `-2` in the example above).
+//
+// If an unknown dimension at runtime is equal to some statically known
+// dimension in the function signature (of any shaped argument), it will be
+// resolved to that statically known constant value:
+//
+// Example: in this example unknown dimension of `arg0` replaced with a `32`.
+//
+//  signature:  func @compute(%arg0: tensor<?xf32>, %arg1: tensor<32xf32>)
+//                            ^                     ^
+//  arguments:                memref<32xf32>        memref<32xf32>
+//                            ^                     ^
+//  symbolic shapes:          [32xf32]              [32xf32]
+//
+// Unknown dimensions that are `1` at runtime are always materialized as a
+// statically known `1` in the symbolic shape.
+class SymbolicShapesResolver {
+ public:
+  // Dimension size can be symbolic (<= -2) or static.
+  using SymbolicShape = llvm::SmallVector<int64_t>;
+  // Dimension size can be dynamic (ShapedType::kDynamic) or static.
+  using StaticShape = llvm::SmallVector<int64_t>;
+
+  SymbolicShapesResolver(const FunctionType& signature,
+                         absl::Span<const ArgumentConstraint> constraints);
+
+  // Resolves symbolic shapes from the runtime arguments. Returns failure if
+  // runtime dimensions do not match the statically known dimensions.
+  absl::StatusOr<llvm::SmallVector<SymbolicShape>> Resolve(
+      ArgumentsRef arguments) const;
+
+  // Resolves symbolic shapes and computes the hash value from the runtime
+  // arguments. Returns failure if runtime dimensions do not match the
+  // statically known dimensions.
+  //
+  // This function might not return the same hash value as calling `Resolve` and
+  // then `Hash`, because it might use more efficient hashing algorithm.
+  absl::StatusOr<llvm::hash_code> ResolveHash(ArgumentsRef arguments) const;
+
+  // Replaces all symbolic dimensions with dynamic dimension.
+  static StaticShape Normalize(const SymbolicShape& shape);
+
+  // Computes a hash value of the symbolic shapes.
+  static llvm::hash_code Hash(absl::Span<const SymbolicShape> symbolic_shapes);
+
+  ArgumentConstraint constraint(size_t index) const;
+  size_t num_arguments() const;
+  bool has_argument_sizes(size_t index) const;
+  const StaticShape& argument_sizes(size_t index) const;
+  bool seen_static_size(size_t dim) const;
+
+ private:
+  // Constraints on the function arguments.
+  llvm::SmallVector<ArgumentConstraint> constraints_;
+
+  // Statically known sizes of shaped arguments from the function signature. For
+  // non-shaped arguments (e.g. opaque pointers) we keep empty shape value.
+  llvm::SmallVector<std::optional<StaticShape>> arguments_sizes_;
+
+  // Values of statically known dimensions sizes in the function signature.
+  llvm::DenseSet<int64_t> seen_static_sizes_;
+
+  // The iteration order for the arguments when resolving symbolic shapes.
+  llvm::SmallVector<size_t> iteration_order_;
+
+  // The iteration order for the arguments when resolving symbolic shapes hash.
+  llvm::SmallVector<size_t> hash_iteration_order_;
+};
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_SYMBOLIC_SHAPE_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/tracing.h

@@ -0,0 +1,44 @@
+/* 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_RUNTIME_TRACING_H_
+#define XLA_RUNTIME_TRACING_H_
+
+#include <string_view>
+
+#include "xla/runtime/custom_call.h"
+#include "xla/runtime/type_id.h"
+
+namespace xla {
+namespace runtime {
+
+// XLA run-time representation of the `!rt.hlo_trace` attribute.
+struct HloTrace {
+  std::string_view hlo_op;
+};
+
+// Registers type id names for tracing attributes.
+inline void PopulateTraceTypeIdNames(TypeIDNameRegistry& registry) {
+  registry.Register<Tagged<HloTrace>>("__type_id_hlo_trace");
+}
+
+// Register XLA runtime custom calls attribute decoding.
+XLA_RUNTIME_REGISTER_AGGREGATE_ATTR_DECODING(
+    HloTrace, AggregateMember<std::string_view>("hlo_op"));
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_TRACING_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/type_id.h

@@ -0,0 +1,173 @@
+/* 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_RUNTIME_TYPE_ID_H_
+#define XLA_RUNTIME_TYPE_ID_H_
+
+#include <atomic>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <string>
+#include <string_view>
+
+#include "absl/container/flat_hash_map.h"
+#include "mlir/Support/TypeID.h"  // from @llvm-project
+
+namespace mlir {
+// Allow TypeID to be used as a key in ABSL map containers.
+template <typename H>
+H AbslHashValue(H h, const TypeID& type_id) {
+  return H::combine(std::move(h), type_id.getAsOpaquePointer());
+}
+}  // namespace mlir
+
+namespace xla {
+namespace runtime {
+
+using ::mlir::TypeID;  // NOLINT
+
+//===----------------------------------------------------------------------===//
+// Mapping from TypeID to unique symbol name.
+//===----------------------------------------------------------------------===//
+
+// A mapping from TypeID to unique type name, because we do not have any
+// standard tools to get a type name in C++. We rely on this mapping to declare
+// external symbols corresponding to type ids in compiled XLA executables.
+class TypeIDNameRegistry {
+ public:
+  TypeIDNameRegistry() = default;
+  ~TypeIDNameRegistry() = default;
+
+  template <typename T>
+  void Register(std::string_view type_name) {
+    auto inserted = type_id_name_map_.try_emplace(TypeID::get<T>(), type_name);
+    assert((inserted.second || inserted.first->second == type_name) &&
+           "conflicting typeid name registration");
+    (void)inserted;
+  }
+
+  std::string_view FindTypeIDSymbolName(TypeID type_id);
+
+  void ForEach(std::function<void(std::string_view, TypeID)> f) const {
+    for (auto& kv : type_id_name_map_) f(kv.second, kv.first);
+  }
+
+ private:
+  absl::flat_hash_map<TypeID, std::string> type_id_name_map_;
+};
+
+//===----------------------------------------------------------------------===//
+// DenseTypeID for generating sequential type ids.
+//===----------------------------------------------------------------------===//
+
+// Forward declare
+template <typename IdSet>
+class DenseTypeId;
+
+namespace internal {
+template <typename IdSet, typename T>
+class DenseTypeIdResolver {
+  friend DenseTypeId<IdSet>;
+  static size_t get();
+};
+}  // namespace internal
+
+// Use this as DenseTypeId<some_type_specific_to_your_use>, that way you are
+// guaranteed to get contiguous IDs starting at 0 unique to your particular
+// use case, as would be appropriate to use for indexes into a vector.
+// 'some_type_specific_to_your_use' could (e.g.) be the class that contains
+// that particular vector.
+template <typename IdSet>
+class DenseTypeId {
+ public:
+  template <typename T>
+  static size_t get() {
+    return internal::DenseTypeIdResolver<IdSet, T>::get();
+  }
+
+ private:
+  // Partial template specialization can't be declared as a friend, so we
+  // declare all `DenseTypeIdResolver` as a friend.
+  template <typename OtherIdSet, typename T>
+  friend class internal::DenseTypeIdResolver;
+
+  static size_t next_id() {
+    return next_id_.fetch_add(1, std::memory_order_relaxed);
+  }
+
+  static std::atomic<size_t> next_id_;
+};
+
+template <typename IdSet>
+std::atomic<size_t> DenseTypeId<IdSet>::next_id_;
+
+namespace internal {
+template <typename IdSet, typename T>
+size_t DenseTypeIdResolver<IdSet, T>::get() {
+  static const size_t id = DenseTypeId<IdSet>::next_id();
+  return id;
+}
+}  // namespace internal
+
+}  // namespace runtime
+}  // namespace xla
+
+// Declare/define an explicit specialization for DenseTypeId.
+//
+// This forces the compiler to assign a dense type id for the given type and
+// avoids checking the static initialization guard if the type id defined as a
+// static variable (default implementation of the DenseTypeIdResolver).
+//
+//  Example:
+//
+//  // Foo.h
+//  struct FooIdSet {};
+//
+//  XLA_RUNTIME_DECLARE_EXPLICIT_DENSE_TYPE_ID(FooIdSet, int32_t);
+//
+//  // Foo.cpp
+//  XLA_RUNTIME_DEFINE_EXPLICIT_DENSE_TYPE_ID(FooIdSet, int32_t);
+//
+#define XLA_RUNTIME_DECLARE_EXPLICIT_DENSE_TYPE_ID(ID_SET, T) \
+  namespace xla {                                             \
+  namespace runtime {                                         \
+  namespace internal {                                        \
+                                                              \
+  template <>                                                 \
+  class DenseTypeIdResolver<ID_SET, T> {                      \
+   public:                                                    \
+    static size_t get() { return id; }                        \
+                                                              \
+   private:                                                   \
+    static size_t id;                                         \
+  };                                                          \
+                                                              \
+  } /* namespace internal */                                  \
+  } /* namespace runtime */                                   \
+  } /* namespace xla */
+
+#define XLA_RUNTIME_DEFINE_EXPLICIT_DENSE_TYPE_ID(ID_SET, T)                  \
+  namespace xla {                                                             \
+  namespace runtime {                                                         \
+  namespace internal {                                                        \
+                                                                              \
+  size_t DenseTypeIdResolver<ID_SET, T>::id = DenseTypeId<ID_SET>::next_id(); \
+                                                                              \
+  } /* namespace internal */                                                  \
+  } /* namespace runtime */                                                   \
+  } /* namespace xla */
+
+#endif  // XLA_RUNTIME_TYPE_ID_H_

miniconda3/envs/active_proaction/lib/python3.10/site-packages/tensorflow/include/xla/runtime/types.h

@@ -0,0 +1,326 @@
+/* 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_RUNTIME_TYPES_H_
+#define XLA_RUNTIME_TYPES_H_
+
+#include <functional>
+#include <limits>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "llvm/Support/ExtensibleRTTI.h"
+#include "llvm/Support/raw_ostream.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+namespace runtime {
+
+//===----------------------------------------------------------------------===//
+// Canonical XLA runtime types for the executable arguments.
+//===----------------------------------------------------------------------===//
+
+// Types supported by the compiled function signature. We do rely on the LLVM
+// style RTTI (https://llvm.org/docs/HowToSetUpLLVMStyleRTTI.html) to avoid
+// dependency on the MLIR types at runtime, because we don't want to depend
+// on any of the compiler implementation details at runtime and we want to
+// support lightweight loading and execution of AOT compiled programs.
+//
+// We rely on the RTTI for the open class hierarchies, because we want to allow
+// users to define their own types for the arguments.
+//
+// If the type can be passed to the compiled function as an argument or returned
+// as a result, it must define its own ABI. The ABI is defined by the MLIR to
+// LLVM lowering pipeline and the runtime integration (see `runtime.h`).
+class Type : public llvm::RTTIExtends<Type, llvm::RTTIRoot> {
+ public:
+  static constexpr char ID = 0;  // NOLINT
+
+  // Arguments to compiled functions passed as a set of pointers. For example
+  // memref descriptor passed in as a set of pointers to data, sizes and
+  // strides. See `Argument::Pack` implementation for details (in `argument.h`).
+  struct ArgumentAbi {
+    size_t num_ptrs;
+  };
+
+  // Compiled function returns results by writing into the pre-allocated storage
+  // of the given size with the requested alignment. Runtime pre-allocates
+  // memory required for all results in the call frame.
+  struct ResultAbi {
+    size_t size;
+
+    // TODO(ezhulenev): Add alignment to the result ABI. Alignment is an
+    // important part of the result ABI that we ignore today. It all doesn't
+    // crash only because all results happen to have a size that is multiple of
+    // 8 bytes, and because of that all of the results are properly aligned.
+    // Results memory layout in the call frame should take in account base
+    // pointer alignment and alignment requirements of all results.
+  };
+
+  // Returns an Abi if the type can be used as an argument.
+  virtual absl::StatusOr<ArgumentAbi> AsArgument() const {
+    return absl::UnimplementedError("argument ABI is not implemented");
+  }
+
+  // Returns an Abi if the type can be returned as a result.
+  virtual absl::StatusOr<ResultAbi> AsResult() const {
+    return absl::UnimplementedError("result ABI is not implemented");
+  }
+
+  virtual std::string ToString() const = 0;
+
+ protected:
+  Type() = default;
+};
+
+inline llvm::raw_ostream& operator<<(llvm::raw_ostream& os, const Type& type) {
+  return os << type.ToString();
+}
+
+//===----------------------------------------------------------------------===//
+// Async Token type corresponding to the mlir::async::TokenType
+//===----------------------------------------------------------------------===//
+
+class AsyncTokenType : public llvm::RTTIExtends<AsyncTokenType, Type> {
+ public:
+  static constexpr char ID = 0;  // NOLINT
+
+  absl::StatusOr<ArgumentAbi> AsArgument() const final;
+  absl::StatusOr<ResultAbi> AsResult() const final;
+
+  std::string ToString() const final;
+};
+
+//===----------------------------------------------------------------------===//
+// Async Value type corresponding to the mlir::async::ValueType.
+//===----------------------------------------------------------------------===//
+
+class AsyncValueType : public llvm::RTTIExtends<AsyncValueType, Type> {
+ public:
+  static constexpr char ID = 0;  // NOLINT
+
+  explicit AsyncValueType(std::unique_ptr<Type> value_type)
+      : value_type_(std::move(value_type)) {}
+
+  const Type& value_type() const { return *value_type_; }
+
+  absl::StatusOr<ArgumentAbi> AsArgument() const final;
+  absl::StatusOr<ResultAbi> AsResult() const final;
+
+  std::string ToString() const final;
+
+ private:
+  std::unique_ptr<Type> value_type_;
+};
+
+//===----------------------------------------------------------------------===//
+// Scalar type corresponding to mlir::IntegerType or mlir::FloatType.
+//===----------------------------------------------------------------------===//
+
+class ScalarType : public llvm::RTTIExtends<ScalarType, Type> {
+ public:
+  static constexpr char ID = 0;  // NOLINT
+
+  explicit ScalarType(PrimitiveType type) : type_(type) {}
+
+  PrimitiveType type() const { return type_; }
+
+  absl::StatusOr<ArgumentAbi> AsArgument() const final;
+  absl::StatusOr<ResultAbi> AsResult() const final;
+
+  std::string ToString() const final;
+
+ private:
+  PrimitiveType type_;
+};
+
+//===----------------------------------------------------------------------===//
+// Tuple type corresponding to mlir::TupleType.
+//===----------------------------------------------------------------------===//
+
+class TupleType : public llvm::RTTIExtends<TupleType, Type> {
+ public:
+  static constexpr char ID = 0;  // NOLINT
+
+  explicit TupleType(llvm::SmallVector<std::unique_ptr<Type>> elems)
+      : elems_(std::move(elems)) {}
+
+  std::string ToString() const final;
+
+  // Note: the AsArgument() and AsResult() methods are unimplemented, because
+  // this type is not meant to be used without expansion at run time.
+
+ private:
+  llvm::SmallVector<std::unique_ptr<Type>> elems_;
+};
+
+//===----------------------------------------------------------------------===//
+// Ranked Tensor type corresponding to the mlir::RankedTensorType.
+//===----------------------------------------------------------------------===//
+
+class RankedTensorType : public llvm::RTTIExtends<RankedTensorType, Type> {
+ public:
+  static constexpr char ID = 0;  // NOLINT
+  static constexpr int64_t kDynamic = std::numeric_limits<int64_t>::min();
+
+  static constexpr bool IsDynamic(int64_t dim) { return dim == kDynamic; }
+
+  RankedTensorType(absl::Span<const int64_t> sizes, PrimitiveType element_type)
+      : sizes_(sizes.begin(), sizes.end()), element_type_(element_type) {}
+
+  absl::Span<const int64_t> sizes() const { return sizes_; }
+  unsigned rank() const { return sizes_.size(); }
+  PrimitiveType element_type() const { return element_type_; }
+
+  std::string ToString() const final;
+
+ private:
+  std::vector<int64_t> sizes_;
+  PrimitiveType element_type_;
+};
+
+//===----------------------------------------------------------------------===//
+// Unranked Tensor type corresponding to the mlir::UnrankedTensorType.
+//===----------------------------------------------------------------------===//
+
+class UnrankedTensorType : public llvm::RTTIExtends<UnrankedTensorType, Type> {
+ public:
+  static constexpr char ID = 0;  // NOLINT
+
+  explicit UnrankedTensorType(PrimitiveType element_type)
+      : element_type_(element_type) {}
+
+  PrimitiveType element_type() const { return element_type_; }
+
+  std::string ToString() const final;
+
+ private:
+  PrimitiveType element_type_;
+};
+
+//===----------------------------------------------------------------------===//
+// Ranked Memref type corresponding to the mlir::MemrefType.
+//===----------------------------------------------------------------------===//
+
+class MemrefType : public llvm::RTTIExtends<MemrefType, Type> {
+ public:
+  static constexpr char ID = 0;  // NOLINT
+  static constexpr int64_t kDynamic = std::numeric_limits<int64_t>::min();
+
+  static constexpr bool IsDynamic(int64_t dim) { return dim == kDynamic; }
+
+  MemrefType(absl::Span<const int64_t> sizes, PrimitiveType element_type)
+      : sizes_(sizes.begin(), sizes.end()), element_type_(element_type) {}
+
+  absl::Span<const int64_t> sizes() const { return sizes_; }
+  int64_t size(size_t dim) const { return sizes_[dim]; }
+  unsigned rank() const { return sizes_.size(); }
+  PrimitiveType element_type() const { return element_type_; }
+
+  absl::StatusOr<ArgumentAbi> AsArgument() const final;
+  absl::StatusOr<ResultAbi> AsResult() const final;
+
+  std::string ToString() const final;
+
+ private:
+  std::vector<int64_t> sizes_;
+  PrimitiveType element_type_;
+};
+
+//===----------------------------------------------------------------------===//
+// Unranked Memref type corresponding to the mlir::UnrankedMemrefType.
+//===----------------------------------------------------------------------===//
+
+class UnrankedMemrefType : public llvm::RTTIExtends<UnrankedMemrefType, Type> {
+ public:
+  static constexpr char ID = 0;  // NOLINT
+
+  explicit UnrankedMemrefType(PrimitiveType element_type)
+      : element_type_(element_type) {}
+
+  PrimitiveType element_type() const { return element_type_; }
+
+  std::string ToString() const final;
+
+ private:
+  PrimitiveType element_type_;
+};
+
+//===----------------------------------------------------------------------===//
+// Corresponds to the RT dialect's ExecutionContextType.
+//===----------------------------------------------------------------------===//
+
+class ExecutionContextOperandType
+    : public llvm::RTTIExtends<ExecutionContextOperandType, Type> {
+ public:
+  static constexpr char ID = 0;  // NOLINT
+
+  absl::StatusOr<ArgumentAbi> AsArgument() const final;
+
+  std::string ToString() const final;
+};
+
+//===----------------------------------------------------------------------===//
+// Corresponds to the RT dialect's OpaqueType.
+//===----------------------------------------------------------------------===//
+
+class OpaqueOperandType : public llvm::RTTIExtends<OpaqueOperandType, Type> {
+ public:
+  static constexpr char ID = 0;  // NOLINT
+
+  absl::StatusOr<ArgumentAbi> AsArgument() const final;
+
+  std::string ToString() const final;
+};
+
+//===----------------------------------------------------------------------===//
+// Compiled function signature type corresponding to the mlir::FunctionType.
+//===----------------------------------------------------------------------===//
+
+// TODO(ezhulenev): Make function type copyable (replace std::unique_ptr with
+// std::shared ptr).
+class FunctionType {
+ public:
+  const Type* operand(unsigned index) const { return operands_[index].get(); }
+  const Type* result(unsigned index) const { return results_[index].get(); }
+
+  unsigned num_operands() const { return operands_.size(); }
+  unsigned num_results() const { return results_.size(); }
+
+  FunctionType(std::vector<std::unique_ptr<Type>> operands,
+               std::vector<std::unique_ptr<Type>> results)
+      : operands_(std::move(operands)), results_(std::move(results)) {}
+
+  void insert_operand(unsigned index, std::unique_ptr<Type> operand) {
+    operands_.insert(operands_.begin() + index, std::move(operand));
+  }
+
+  void insert_result(unsigned index, std::unique_ptr<Type> result) {
+    results_.insert(results_.begin() + index, std::move(result));
+  }
+
+ private:
+  std::vector<std::unique_ptr<Type>> operands_;
+  std::vector<std::unique_ptr<Type>> results_;
+};
+
+}  // namespace runtime
+}  // namespace xla
+
+#endif  // XLA_RUNTIME_TYPES_H_

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

@@ -0,0 +1,617 @@
+/* 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_ALGEBRAIC_SIMPLIFIER_H_
+#define XLA_SERVICE_ALGEBRAIC_SIMPLIFIER_H_
+
+#include <array>
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+#include "absl/container/inlined_vector.h"
+#include "xla/hlo/ir/dfs_hlo_visitor_with_default.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/util.h"
+
+namespace xla {
+
+class AlgebraicSimplifierOptions {
+ public:
+  // Platform dependent callback to determine if a reshape `from_shape` to
+  // `to_shape` is a bitcast.
+  using ReshapeIsBitcastCallback =
+      std::function<bool(const Shape& from_shape, const Shape& to_shape)>;
+  // Platform dependent callback to determine if a set of reverse dimensions is
+  // lowerable
+  using ConvIsLowerableCallback = std::function<bool(HloInstruction* window)>;
+
+  explicit AlgebraicSimplifierOptions(
+      ReshapeIsBitcastCallback reshape_is_bitcast_callback = {},
+      ConvIsLowerableCallback conv_is_lowerable_callback = {})
+      : reshape_is_bitcast_callback_(std::move(reshape_is_bitcast_callback)),
+        conv_is_lowerable_callback_(std::move(conv_is_lowerable_callback)) {}
+
+  // Use the platform specific callback if set. It is not sensible to return
+  // true here if the options are not layout sensitive.
+  bool ReshapeIsBitcast(const Shape& from_shape, const Shape& to_shape) const {
+    if (!is_layout_sensitive_) {
+      return false;
+    }
+    if (!reshape_is_bitcast_callback_) {
+      return ShapeUtil::ReshapeIsBitcast(from_shape, to_shape);
+    }
+    return reshape_is_bitcast_callback_(from_shape, to_shape);
+  }
+
+  // Use the platform specific callback if set. Otherwise, return true.
+  bool ConvIsLowerable(HloInstruction* reverse_dims) const {
+    if (!conv_is_lowerable_callback_) {
+      return true;
+    }
+    return conv_is_lowerable_callback_(reverse_dims);
+  }
+
+  // If is_layout_sensitive is true, then the simplifier preserves layout during
+  // transformation. Otherwise, layout is ignored.
+  void set_is_layout_sensitive(bool is_layout_sensitive) {
+    is_layout_sensitive_ = is_layout_sensitive;
+  }
+
+  bool is_layout_sensitive() const { return is_layout_sensitive_; }
+
+  void set_use_associative_reordering(bool use_associative_reordering) {
+    use_associative_reordering_ = use_associative_reordering;
+  }
+
+  bool use_associative_reordering() const {
+    return use_associative_reordering_;
+  }
+
+  void set_associative_reordering_threshold(
+      double associative_reordering_threshold) {
+    associative_reordering_threshold_ = associative_reordering_threshold;
+  }
+
+  double associative_reordering_threshold() const {
+    return associative_reordering_threshold_;
+  }
+
+  // Enable dot simplification on platforms where it is profitable.
+  void set_enable_dot_strength_reduction(bool enable_dot_strength_reduction) {
+    enable_dot_strength_reduction_ = enable_dot_strength_reduction;
+  }
+
+  bool enable_dot_strength_reduction() const {
+    return enable_dot_strength_reduction_;
+  }
+
+  // Enable dot->multiple rewrite for dot as an outer-product
+  void set_enable_dot_to_multiply_rewrite(bool enable_dot_to_multiply_rewrite) {
+    enable_dot_to_multiply_rewrite_ = enable_dot_to_multiply_rewrite;
+  }
+
+  bool enable_dot_to_multiply_rewrite() const {
+    return enable_dot_to_multiply_rewrite_;
+  }
+
+  // This platform will not run the DotDecomposer to canonicalize dots.
+  void set_supports_non_canonical_dots(bool supports_non_canonical_dots) {
+    supports_non_canonical_dots_ = supports_non_canonical_dots;
+  }
+  bool supports_non_canonical_dots() const {
+    return supports_non_canonical_dots_;
+  }
+
+  // Enable convolution simplification on platforms where it is profitable.
+  void set_enable_conv_simplification(bool enable_conv_simplification) {
+    enable_conv_simplification_ = enable_conv_simplification;
+  }
+  bool enable_conv_simplification() const {
+    return enable_conv_simplification_;
+  }
+
+  // Enable convolution operand swapping on platforms where it is supported.
+  void set_enable_conv_operand_swap(bool enable_conv_operand_swap) {
+    enable_conv_operand_swap_ = enable_conv_operand_swap;
+  }
+  bool enable_conv_operand_swap() const { return enable_conv_operand_swap_; }
+
+  // Move constant scalar multiply to one operand or output of convolutions with
+  // the smallest tensor size, to reduce the number of scalar multiply.
+  void set_enable_scalar_multiply_reduction(
+      bool enable_scalar_multiply_reduction) {
+    enable_scalar_multiply_reduction_ = enable_scalar_multiply_reduction;
+  }
+
+  bool enable_scalar_multiply_reduction() const {
+    return enable_scalar_multiply_reduction_;
+  }
+
+  // Also the algebraic simplifer to treat floating point values like real
+  // numbers.
+  void set_enable_floats_are_real(bool enable_floats_are_real) {
+    enable_floats_are_real_ = enable_floats_are_real;
+  }
+
+  bool enable_floats_are_real() const { return enable_floats_are_real_; }
+
+  // If enable_window_reduce_replacement is true, the kReduceWindow instruction
+  // can be optimized by replacement with simpler operations.
+  void set_enable_window_reduce_to_reduce_replacement(
+      bool enable_window_reduce_to_reduce_replacement) {
+    enable_window_reduce_to_reduce_replacement_ =
+        enable_window_reduce_to_reduce_replacement;
+  }
+
+  bool enable_window_reduce_to_reduce_replacement() const {
+    return enable_window_reduce_to_reduce_replacement_;
+  }
+
+  // Sets the size of a gather operand that can be unrolled into many selects.
+  void set_very_small_gather_size(int64_t size) {
+    very_small_gather_size_ = size;
+  }
+
+  int64_t very_small_gather_size() const { return very_small_gather_size_; }
+
+  void set_cudnn_batchnorm_forward_training_metadata(const std::string& c) {
+    metadata_.cudnn_batchnorm_forward_training_metadata = c;
+  }
+
+  const std::string& get_cudnn_batchnorm_forward_training_metadata() const {
+    return metadata_.cudnn_batchnorm_forward_training_metadata;
+  }
+
+  void set_enable_reduce_of_reshape(bool enable_reduce_of_reshape) {
+    enable_reduce_of_reshape_ = enable_reduce_of_reshape;
+  }
+
+  bool enable_reduce_of_reshape() const { return enable_reduce_of_reshape_; }
+
+  void set_enable_negative_padding_replacement(
+      bool enable_negative_padding_replacement) {
+    enable_negative_padding_replacement_ = enable_negative_padding_replacement;
+  }
+
+  bool enable_negative_padding_replacement() const {
+    return enable_negative_padding_replacement_;
+  }
+
+  void set_enable_sink_broadcast(bool enable_sink_broadcast) {
+    enable_sink_broadcast_ = enable_sink_broadcast;
+  }
+
+  bool enable_sink_broadcast() const { return enable_sink_broadcast_; }
+
+  // If true, always simplify reduce(transpose(x)) and reduce(reshape(x)), even
+  // if the transpose/reshape has multiple users.  This can be beneficial
+  // on platforms where the extra transpose/reshape isn't as expensive as
+  // the optimization benefits brought about by simplifying the graph.
+  bool unconditionally_simplify_reduce_of_transpose_or_reshape() const {
+    return unconditionally_simplify_reduce_of_transpose_or_reshape_;
+  }
+  void set_unconditionally_simplify_reduce_of_transpose_or_reshape(bool val) {
+    unconditionally_simplify_reduce_of_transpose_or_reshape_ = val;
+  }
+
+  // If true, min(x, NaN) = NaN.  If false, min(x, NaN) = x.
+  //
+  // TODO(b/209827141): Remove this and make minmax_propagate_nan
+  // unconditionally true.
+  bool minmax_propagate_nan() const { return minmax_propagate_nan_; }
+  void set_minmax_propagate_nan(bool val) { minmax_propagate_nan_ = val; }
+
+  // When true, always replaces Reduce(concat({a,b,...})) with
+  // map(reduce(a),map(reduce(b),...,)). If false, only does the replacement if
+  // the shapes of a,b,... have the same dimensions.
+  bool enable_unconditional_reduce_of_concat_replacement() const {
+    return enable_unconditional_reduce_of_concat_replacement_;
+  }
+  void set_enable_unconditional_reduce_of_concat_replacement(
+      bool enable_unconditional_reduce_of_concat_replacement) {
+    enable_unconditional_reduce_of_concat_replacement_ =
+        enable_unconditional_reduce_of_concat_replacement;
+  }
+
+ private:
+  // Metadata struct can be used to store any metadata information encapsulated
+  // with the AlgebraicSimplierOptions that can be later used in an
+  // AlgebraicSimplifier pass. For example,
+  // cudnn_batchnorm_forward_training_metadata can be used to store the name of
+  // a custom call. If the custom call is
+  // __cudnn$batchNormalizationForwardTraining, the output with index 2 is
+  // guaranteed to be positive. This property has been used to recursively
+  // determine if the operand of an instruction is always positive.
+  struct Metadata {
+    std::string cudnn_batchnorm_forward_training_metadata{""};
+    Metadata() {}
+  };
+  ReshapeIsBitcastCallback reshape_is_bitcast_callback_;
+  ConvIsLowerableCallback conv_is_lowerable_callback_;
+  bool is_layout_sensitive_{false};
+  bool enable_dot_strength_reduction_{true};
+  bool supports_non_canonical_dots_{true};
+  bool enable_dot_to_multiply_rewrite_{true};
+  bool enable_conv_simplification_{true};
+  bool enable_conv_operand_swap_{true};
+  bool enable_scalar_multiply_reduction_{false};
+  bool enable_floats_are_real_{false};
+  bool enable_window_reduce_to_reduce_replacement_{true};
+  bool enable_reduce_of_reshape_{true};
+  bool enable_negative_padding_replacement_{true};
+  bool enable_sink_broadcast_{true};
+  bool unconditionally_simplify_reduce_of_transpose_or_reshape_{false};
+  int64_t very_small_gather_size_{4};
+  bool minmax_propagate_nan_{true};
+  bool enable_unconditional_reduce_of_concat_replacement_{true};
+  bool use_associative_reordering_{false};
+  double associative_reordering_threshold_{2.0};
+  Metadata metadata_;
+};
+
+// A pass which performs algebraic simplifications.
+class AlgebraicSimplifier : public HloModulePass {
+ public:
+  // If is_layout_sensitive is true, then the simplifier preserves layout during
+  // transformation. Otherwise, layout is ignored.
+  explicit AlgebraicSimplifier(const AlgebraicSimplifierOptions& options)
+      : options_(options) {}
+  ~AlgebraicSimplifier() override = default;
+  absl::string_view name() const override { return "algsimp"; }
+
+  // Run algebraic simplification on the given computation. Returns whether the
+  // computation was changed.
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+  // Create constant from literal with tiles and element size updated in the
+  // constant's layout.
+  std::unique_ptr<HloInstruction> CreateConstantWithLayoutUpdated(
+      Literal literal) {
+    auto constant = HloInstruction::CreateConstant(std::move(literal));
+    UpdateLayout(constant->mutable_shape());
+    return constant;
+  }
+
+ protected:
+  AlgebraicSimplifierOptions options_;
+};
+
+// AlgebraicSimplifierVisitor traverses the HLO computation and reduces certain
+// algebraic expressions to simplified forms. Note: This only supports
+// simplifications that simply look at the operands of an instruction. For the
+// more general case a worklist based approach would be needed.
+class AlgebraicSimplifierVisitor : public DfsHloRewriteVisitor {
+ public:
+  explicit AlgebraicSimplifierVisitor(const AlgebraicSimplifierOptions& options,
+                                      AlgebraicSimplifier* simplifier)
+      : options_(options), simplifier_(simplifier) {}
+
+  Status HandleAbs(HloInstruction* abs) override;
+
+  Status HandleAdd(HloInstruction* add) override;
+
+  Status HandleAnd(HloInstruction* logical_and) override;
+
+  Status HandleBitcast(HloInstruction* bitcast) override;
+
+  Status HandleBitcastConvert(HloInstruction* bitcast) override;
+
+  Status HandleBroadcast(HloInstruction* broadcast) override;
+
+  Status HandleCompare(HloInstruction* compare) override;
+
+  Status HandleConcatenate(HloInstruction* concatenate) override;
+
+  Status HandleConstant(HloInstruction* constant) override;
+
+  Status HandleCopy(HloInstruction* copy) override;
+
+  Status HandleConvert(HloInstruction* convert) override;
+
+  Status HandleComplex(HloInstruction* complex) override;
+
+  Status HandleReal(HloInstruction* real) override;
+
+  Status HandleImag(HloInstruction* imag) override;
+
+  Status HandleIota(HloInstruction* instruction) override;
+
+  Status HandleConvolution(HloInstruction* convolution) override;
+
+  Status HandleDivide(HloInstruction* divide) override;
+
+  Status HandleDot(HloInstruction* dot) override;
+
+  Status HandleGather(HloInstruction* gather) override;
+
+  Status HandleGetTupleElement(HloInstruction* get_tuple_element) override;
+
+  Status HandleLog(HloInstruction* log) override;
+
+  Status HandleMaximum(HloInstruction* maximum) override;
+
+  Status HandleMinimum(HloInstruction* minimum) override;
+
+  Status HandleClamp(HloInstruction* clamp) override;
+
+  Status HandleMultiply(HloInstruction* multiply) override;
+
+  Status HandleNegate(HloInstruction* negate) override;
+
+  Status HandleNot(HloInstruction* logical_not) override;
+
+  Status HandleOptimizationBarrier(HloInstruction* barrier) override;
+
+  Status HandleOr(HloInstruction* logical_or) override;
+
+  Status HandlePad(HloInstruction* pad) override;
+
+  Status HandlePower(HloInstruction* power) override;
+
+  Status HandleRemainder(HloInstruction* remainder) override;
+
+  Status HandleReshape(HloInstruction* reshape) override;
+
+  Status HandleReduce(HloInstruction* hlo) override;
+
+  Status HandleReduceWindow(HloInstruction* hlo) override;
+
+  Status HandleReverse(HloInstruction* reverse) override;
+
+  Status HandleRsqrt(HloInstruction* rsqrt) override;
+
+  Status HandleSlice(HloInstruction* slice) override;
+
+  Status HandleSqrt(HloInstruction* sqrt) override;
+
+  Status HandleDynamicSlice(HloInstruction* dynamic_slice) override;
+
+  Status HandleDynamicUpdateSlice(
+      HloInstruction* dynamic_update_slice) override;
+  Status HandleScatter(HloInstruction* hlo) override;
+
+  Status HandleSelect(HloInstruction* select) override;
+
+  Status HandleSort(HloInstruction* sort) override;
+
+  Status HandleTranspose(HloInstruction* transpose) override;
+
+  Status HandleSubtract(HloInstruction* sub) override;
+
+  Status HandleMap(HloInstruction* map) override;
+
+  // Runs the visitor on a computation.
+  bool Run(HloComputation* computation,
+           const AlgebraicSimplifierOptions& options,
+           AlgebraicSimplifier* simplifier);
+
+  // Compute a function that maps from bitcasted dimensions to the resulting
+  // ones. Returns the function as a vector if successful; std::optional
+  // otherwise.
+  static std::optional<std::vector<std::vector<int64_t>>> ComputeBitcastDimMap(
+      const Shape& bitcast_shape, const Shape& operand_shape);
+  // Invert the directions of the given bitcast dimension map.
+  static std::vector<std::vector<int64_t>> InvertBitcastDimMap(
+      const Shape& original_shape, const Shape& bitcast_shape,
+      const std::vector<std::vector<int64_t>>& original_map);
+
+  // Modify the layout dimensions of result_shape, so that it becomes the
+  // re-shaped result of applying bitcast to the original_shape, by using
+  // dim_map to re-shape layout dimensions of original_shape. Returns the
+  // result_shape with modified layout if the conversion succeeds; Returns
+  // std::nullopt if fails.
+  static std::optional<Shape> ReshapeLayoutDimensions(
+      const Shape& original_shape, const Shape& result_shape,
+      const std::vector<std::vector<int64_t>>& original_map,
+      const std::vector<std::vector<int64_t>>& result_map);
+
+  // Allow backend constraints on tiling etc. to invalidate optimizations.
+  virtual bool IsValidLayout(const Shape& shape) { return true; }
+  // Allow backend targets to determine whether a layout is inefficient.
+  virtual bool ShouldStrengthReduceDotToReduce(const HloInstruction* hlo) {
+    return true;
+  }
+
+ protected:
+  // The backend-specific options selected for the algebraic simplifier.
+  const AlgebraicSimplifierOptions& options_;
+
+ private:
+  // Removes degenerate dimension from dot.
+  StatusOr<bool> RemoveDegenerateDimensionFromDot(HloInstruction* dot);
+
+  // Moves the transpose to the broadcast if possible. Can also be called with a
+  // bitcast transpose.
+  Status SimplifyTransposeOfBroadcast(HloInstruction* transpose,
+                                      absl::Span<const int64_t> dimensions);
+
+  // Converts to primitive type if the input hlo is not that type, otherwise
+  // returns the original hlo.
+  HloInstruction* AsType(HloInstruction* hlo,
+                         const PrimitiveType element_type) {
+    if (hlo->shape().element_type() == element_type) {
+      return hlo;
+    }
+    Shape changed_shape =
+        ShapeUtil::ChangeElementType(hlo->shape(), element_type);
+    simplifier_->UpdateLayout(&changed_shape);
+    return computation_->AddInstruction(
+        HloInstruction::CreateConvert(changed_shape, hlo));
+  }
+
+  // Transposes a dot operand such that the batch dimensions are the most major,
+  // and the contracting dimensions are most minor.
+  StatusOr<HloInstruction*> NormalizeDotOperandToBatchMajorAndContractingMinor(
+      HloInstruction* dot_operand, absl::Span<const int64_t> batch_dimensions,
+      absl::Span<const int64_t> contracting_dimensions);
+
+  // Simplify dot(transpose(a), transpose(b)) to transpose(dot(b,a)) (or
+  // transpose(dot(a,b)) if only the batch dims are transposed).
+  //
+  // Requires the dot has been canonicalized by DotDecomposer into
+  //
+  //   LHS [batch dims..., non-contracting dim, contracting dim]
+  //   RHS [batch dims..., contracting dim, non-contracting dim].
+  StatusOr<bool> RemoveTransposesFromDotOperands(HloInstruction* dot);
+
+  // Helper method to perform and add reduction on a list of dimensions.
+  HloInstruction* AddReduce(HloInstruction* hlo, absl::Span<const int64_t> dims,
+                            PrimitiveType type);
+
+  // Move scalar multiply to the smallest side of convolution to
+  // reduce multiply computations.
+  Status ScalarMultiplyReduction(HloInstruction* dot);
+
+  // Convenience method for replacing an instruction with a bitcast. If operand
+  // is not null, then the bitcast will use the specified operand instead of the
+  // operand of the instruction.
+  void ReplaceWithBitcast(HloInstruction* instruction,
+                          HloInstruction* operand = nullptr);
+
+  // Change copy(bitcast...(copy)) into copy(bitcast) or bitcast(copy) so that
+  // the replicated copies are combined when allowed by layout/tiling assignment
+  // constraints.
+  bool SwapCopyBitcastCopy(HloInstruction* root_copy);
+
+  // Replace old instruction with new instruction if old and new instructions
+  // are compatible (have the same shape and replacement preserves sharding).
+  // Updates uses and root instruction. Returns whether a replacement was made.
+  bool ReplaceInstructionIfCompatible(HloInstruction* old_instruction,
+                                      HloInstruction* new_instruction);
+  // Similar to above but tuplizes `new_instructions` if there are more than 1
+  // instructions.
+  bool ReplaceInstructionIfCompatible(
+      HloInstruction* old_instruction,
+      absl::Span<HloInstruction* const> new_instructions);
+
+  // Returns whether the shape of the output of the given instructions are the
+  // same for the purposes of simplification. If options_.is_layout_sensitive()
+  // is true, then this tests shape equality including layout
+  // (ShapeUtil::Equal). If options_.is_layout_sensitive() is false, then the
+  // tests shape compatibility (ShapeUtil::Compatible).
+  bool SameShape(const HloInstruction* lhs, const HloInstruction* rhs) const;
+
+  // Same as above but takes shape arguments directly.
+  bool SameShape(const Shape& lhs, const Shape& rhs) const;
+
+  // A Broadcast that feeds an element-wise operation with a unique non-scalar
+  // operand can sink to after the operation.
+  StatusOr<bool> TryToSinkBroadcastAfterOpWithUniqueNonScalarOperand(
+      HloInstruction* broadcast);
+
+  StatusOr<HloInstruction*> OptimizeDotOfConcat(HloInstruction* dot);
+  StatusOr<HloInstruction*> OptimizeDotOfConcatHelper(
+      HloInstruction* dot, HloInstruction* lhs, int64_t lhs_contracting_dim,
+      HloInstruction* rhs, int64_t rhs_contracting_dim, bool swapped);
+
+  StatusOr<HloInstruction*> OptimizeDotOfGather(HloInstruction* dot);
+
+  StatusOr<HloInstruction*> OptimizeDotOfReorderContractingDims(
+      HloInstruction* dot);
+
+  StatusOr<HloInstruction*> AssociativeReorderDotOperator(HloInstruction* dot);
+
+  HloComputation* GetOrCreateScalarAddComputation(PrimitiveType type) {
+    HloComputation*& scalar_add_computation = scalar_add_computations_[type];
+    if (scalar_add_computation) {
+      return scalar_add_computation;
+    }
+
+    HloComputation::Builder b("scalar_add_computation");
+    Shape shape = ShapeUtil::MakeShape(type, {});
+    simplifier_->UpdateLayout(&shape);
+    auto scalar_lhs = b.AddInstruction(
+        HloInstruction::CreateParameter(0, shape, "scalar_lhs"));
+    auto scalar_rhs = b.AddInstruction(
+        HloInstruction::CreateParameter(1, shape, "scalar_rhs"));
+    auto scalar_op = b.AddInstruction(HloInstruction::CreateBinary(
+        shape, HloOpcode::kAdd, scalar_lhs, scalar_rhs));
+    scalar_add_computation =
+        computation_->parent()->AddEmbeddedComputation(b.Build(scalar_op));
+    return scalar_add_computation;
+  }
+
+  // Tries to fold a kPad in the input or filter into the convolution
+  // instruction's window.
+  virtual StatusOr<bool> FoldConvInputPad(HloInstruction* convolution);
+  StatusOr<bool> FoldConvFilterPad(HloInstruction* convolution);
+
+  // Tries to swap convolution operands if they would result in a more efficient
+  // convolution.
+  StatusOr<bool> SwapConvOperands(HloInstruction* convolution);
+
+  // Tries to use a kDot in place of the given convolution.
+  StatusOr<bool> SimplifyConvToDot(HloInstruction* convolution);
+  // Tries to use a multiplication in place of the given convolution.
+  StatusOr<bool> SimplifyConvToMultiply(HloInstruction* convolution);
+
+  // Tries to simplify a slice where the result of the slice is a scalar.
+  StatusOr<bool> TrySimplifyScalarSlice(HloInstruction* slice);
+
+  // Tries to convert slice(reshape(X)) into reshape(slice(X))
+  StatusOr<bool> TryToReorderSliceAndReshape(HloInstruction* slice);
+
+  // Tries to convert slice(reverse(X)) into reverse(slice(X))
+  StatusOr<bool> TryToReorderSliceAndReverse(HloInstruction* slice);
+
+  // Tries to simplify `(and (< a N) (< a K))` in cases where `N <= K` into
+  // `(< a N)`. This is crucial for being able to figure out the loop trip
+  // count.
+  //
+  // Assumes that the input is conjunction.
+  StatusOr<bool> TrySimplifyTautologicalCompare(HloInstruction* conjunction);
+
+  // Tries to simlplify (bitcast-convert (concat (bitcast-convert A) ...)) where
+  // the types of inner and outer bitcast-convert cancel out.
+  StatusOr<bool> TrySimplifyTautologicalBitcastConvert(HloInstruction* bitcast);
+
+  // Tries to remove surrounding converts around a binary op where the op has a
+  // more precise type than its inputs and output.
+  //
+  // convert<TS>(bin_op<TL>(convert<TL>(data1<TS>),
+  //                        convert<TL>(data2<TS>)))
+  //  where TS is a smaller point type than TL (ex, TS=fp16, TL=fp32)
+  // ->
+  // bin_op<TS>(data1<TS>, data2<TS>)
+  Status TryRemoveUpcastAndDowncastSurroundingBinaryOp(
+      HloInstruction* convert_instruction);
+
+  // Useful when we want to use the same visitor over multiple computations.
+  void ResetState(HloComputation* computation);
+
+  // Current HloComputation instance the AlgebraicSimplifierVisitor is
+  // traversing.
+  HloComputation* computation_;
+
+  // Cached computation for adding two scalars of a given type.
+  absl::flat_hash_map<PrimitiveType, HloComputation*> scalar_add_computations_;
+
+  AlgebraicSimplifier* simplifier_ = nullptr;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_ALGEBRAIC_SIMPLIFIER_H_

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

@@ -0,0 +1,41 @@
+/* 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_ALL_GATHER_BROADCAST_REORDER_H_
+#define XLA_SERVICE_ALL_GATHER_BROADCAST_REORDER_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla {
+
+// A pass that reorders all-gather(broadcast(x)) -> broadcast(all-gather(x)).
+// The intent is to reduce the size of all-gather when possible by doing an
+// all-gather on the (smaller) pre-broadcasted data and then applying the
+// broadcast.
+class AllGatherBroadcastReorder : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "all-gather-bcast-reorder"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_ALL_GATHER_BROADCAST_REORDER_H_

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

@@ -0,0 +1,56 @@
+/* Copyright 2020 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_ALL_GATHER_COMBINER_H_
+#define XLA_SERVICE_ALL_GATHER_COMBINER_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"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+
+// Combines small non-dependent AllGather ops into larger combined
+// AllGather ops. A typical AllGather implementation has a minimum
+// latency-induced time for a AllGather op so a single combined op can be
+// more efficient than many small ones.
+class AllGatherCombiner : public HloModulePass {
+ public:
+  AllGatherCombiner(int64_t combine_threshold_in_bytes,
+                    int64_t combine_threshold_count, bool combine_by_dim);
+
+  absl::string_view name() const override { return "all-gather-combiner"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  // Combine all gather ops up to this threshold.
+  int64_t combine_threshold_in_bytes_;
+
+  // Combine all gather ops up to this threshold (number of operands).
+  int64_t combine_threshold_count_;
+
+  // Combine all-gather ops with the same gather dimension.
+  bool combine_by_dim_;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_ALL_GATHER_COMBINER_H_

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

@@ -0,0 +1,50 @@
+/* Copyright 2020 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_ALL_GATHER_DECOMPOSER_H_
+#define XLA_SERVICE_ALL_GATHER_DECOMPOSER_H_
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+
+// AllGatherDecomposer is a pass which converts unsupported all-gathers into
+// dynamic-update-slices and all-reduces.
+class AllGatherDecomposer : public HloModulePass {
+ public:
+  explicit AllGatherDecomposer(
+      std::function<bool(const HloAllGatherInstruction&)> should_decompose)
+      : should_decompose_(std::move(should_decompose)) {}
+  AllGatherDecomposer()
+      : should_decompose_(
+            [](const HloAllGatherInstruction& ag) { return true; }) {}
+  absl::string_view name() const override { return "all_gather_decomposer"; }
+
+  // Run AllGatherDecomposer 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;
+
+ private:
+  std::function<bool(const HloAllGatherInstruction&)> should_decompose_;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_ALL_GATHER_DECOMPOSER_H_

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

@@ -0,0 +1,54 @@
+/* Copyright 2020 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_ALL_REDUCE_COMBINER_H_
+#define XLA_SERVICE_ALL_REDUCE_COMBINER_H_
+
+#include "absl/strings/string_view.h"
+#include "xla/array2d.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+
+// Combines small non-dependent AllReduce ops into larger combined
+// AllReduce ops. A typical AllReduce implementation has a minimum
+// latency-induced time for a AllReduce op so a single combined op can be
+// more efficient than many small ones.
+class AllReduceCombiner : public HloModulePass {
+ public:
+  AllReduceCombiner(int64_t combine_threshold_in_bytes,
+                    int64_t combine_threshold_count);
+
+  absl::string_view name() const override { return "all-reduce-combiner"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  // Combine all reduce ops up to this threshold.
+  int64_t combine_threshold_in_bytes_;
+
+  // Combine all reduce ops up to this threshold (number of operands).
+  int64_t combine_threshold_count_;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_ALL_REDUCE_COMBINER_H_

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

@@ -0,0 +1,39 @@
+/* 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_ALL_REDUCE_CONTIGUOUS_H_
+#define XLA_SERVICE_ALL_REDUCE_CONTIGUOUS_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla {
+
+// Concatenates all-reduce operands together, so the all-reduce is performed
+// over a single, contiguous buffer.
+class AllReduceContiguous : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "all-reduce-contiguous"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_ALL_REDUCE_CONTIGUOUS_H_

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

@@ -0,0 +1,48 @@
+/* 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_ALL_REDUCE_FOLDER_H_
+#define XLA_SERVICE_ALL_REDUCE_FOLDER_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla {
+
+// A pass that folds an all-reduce feeding into another all-reduce by expanding
+// the replica groups. As an example:
+//
+//   ar0 = all-reduce(x) replica_groups={{0,1},{2,3},{4,5},{6,7}}
+//   ar1 = all-reduce(all-reduce0) replica_groups={{0,2},{1,3},{4,6},{5,7}}
+//
+//  Can be combined into a single all-reduce:
+//
+//   ar1 = all-reduce(x) replica_groups={{0,1,2,3},{4,5,6,7}}
+//
+
+class AllReduceFolder : public HloModulePass {
+ public:
+  absl::string_view name() const override { return "all-reduce-folder"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_ALL_REDUCE_FOLDER_H_

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

@@ -0,0 +1,43 @@
+/* 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_ALL_REDUCE_KEY_H_
+#define XLA_SERVICE_ALL_REDUCE_KEY_H_
+
+#include <tuple>
+#include <vector>
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/hlo_domain_map.h"
+
+namespace xla {
+
+// Encapsulates all of the properties which must match for two all-reduce
+// instructions to be compatible with each other (and hence be possible to
+// combine the instructions).
+using AllReduceKey =
+    std::tuple<HloOpcode, PrimitiveType,
+               /*domain metadata id*/ int64_t,
+               /*has channel id*/ bool,
+               /*use_global_device_ids*/ bool,
+               /*replica_groups*/ std::vector<std::vector<int64_t>>>;
+
+std::optional<AllReduceKey> GetAllReduceKey(
+    const HloInstruction* instruction, const HloDomainMap* domain_map = nullptr,
+    bool ignore_replica_groups = false);
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_ALL_REDUCE_KEY_H_

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

@@ -0,0 +1,40 @@
+/* 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_ALL_REDUCE_PROMOTION_H_
+#define XLA_SERVICE_ALL_REDUCE_PROMOTION_H_
+
+#include <utility>
+#include "xla/service/change_op_data_type.h"
+
+namespace xla {
+
+class AllReducePromotion : public HloModulePass {
+ public:
+  explicit AllReducePromotion(
+      absl::Span<std::pair<PrimitiveType, PrimitiveType> const> from_to_types);
+  absl::string_view name() const override { return "all-reduce-promotion"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  ChangeOpDataType pass_;
+};
+
+}  // namespace xla
+#endif  // XLA_SERVICE_ALL_REDUCE_PROMOTION_H_

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

@@ -0,0 +1,53 @@
+/* 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_ALL_REDUCE_REASSOCIATE_H_
+#define XLA_SERVICE_ALL_REDUCE_REASSOCIATE_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/statusor.h"
+
+namespace xla {
+
+// A pass that reassociates all-reduce feeding into compatible elementwise
+// operations. As an example: add(all-reduce(x), all-reduce(y)) will be replaced
+// with all-reduce(add(x,y)). Mathematically, this is replacing
+//   add(x0, x1, ... xk) + add(y0, y1, ... yk) with
+//   add((x0+y0), (x1+y), ... (xk+yk)
+//
+//  i.e., reassociating the reduction operation.
+
+class AllReduceReassociate : public HloModulePass {
+ public:
+  explicit AllReduceReassociate(bool reassociate_converted_ar = false)
+      : reassociate_converted_ar_(reassociate_converted_ar) {}
+
+  absl::string_view name() const override { return "all-reduce-reassociate"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  // Specify whether we should reassociate allreduces that are consumed by
+  // Convert nodes.
+  bool reassociate_converted_ar_;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_ALL_REDUCE_REASSOCIATE_H_

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

@@ -0,0 +1,46 @@
+/* Copyright 2020 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_ALL_TO_ALL_DECOMPOSER_H_
+#define XLA_SERVICE_ALL_TO_ALL_DECOMPOSER_H_
+
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/op_expander_pass.h"
+
+namespace xla {
+
+// AllToAllDecomposer is a pass which converts unsupported array all_to_all
+// into tuple all_to_all or array all_to_all with a minimum rank where the split
+// dimension is the size of the replica_groups.
+class AllToAllDecomposer : public OpExpanderPass {
+ public:
+  explicit AllToAllDecomposer(bool decompose_to_tuple = true,
+                              int64_t min_array_rank = 0)
+      : decompose_to_tuple_(decompose_to_tuple),
+        min_array_rank_(min_array_rank) {}
+  ~AllToAllDecomposer() override = default;
+  absl::string_view name() const override { return "all_to_all_decomposer"; }
+
+ private:
+  bool InstructionMatchesPattern(HloInstruction* instruction) override;
+  StatusOr<HloInstruction*> ExpandInstruction(
+      HloInstruction* instruction) override;
+  bool decompose_to_tuple_;
+  int64_t min_array_rank_;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_ALL_TO_ALL_DECOMPOSER_H_

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

@@ -0,0 +1,154 @@
+/* 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_ALLOCATION_TRACKER_H_
+#define XLA_SERVICE_ALLOCATION_TRACKER_H_
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "xla/service/backend.h"
+#include "xla/statusor.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+
+namespace xla {
+
+// Tracks allocations for the XLA service; allocations can be registered
+// with shape/device/tag and resolved from a handle for later use.
+class AllocationTracker {
+ public:
+  // The allocator is used for deallocating memory when allocations are
+  // deregistered. All registered allocations must have the same platform as the
+  // allocator.
+  AllocationTracker(Backend* backend) : backend_(backend), next_handle_(1) {}
+
+  // Registers a shaped buffer of device memory, and returns a corresponding
+  // handle that can be used for talking to XLA clients. The given shaped buffer
+  // will be treated as the buffer corresponding to the only replica.
+  StatusOr<GlobalDataHandle> Register(ScopedShapedBuffer shaped_buffer,
+                                      const std::string& tag);
+
+  // Registers a vector of shaped buffers of device memory, one per replica, and
+  // returns a corresponding handle that can be used for talking to XLA clients.
+  StatusOr<GlobalDataHandle> RegisterReplicatedBuffers(
+      std::vector<ScopedShapedBuffer> replicated_buffers,
+      const std::string& tag);
+
+  // Unregister the allocation for the given data handle.
+  Status Unregister(const GlobalDataHandle& data);
+
+  // Returns a vector of global data handles that point to the tuple elements.
+  StatusOr<std::vector<GlobalDataHandle>> DeconstructTuple(
+      const GlobalDataHandle& Data);
+
+  // Resolve a handle from an XLA client to a vector of shaped buffers, one per
+  // replica, or provide an error status to say whether any of those buffers
+  // were not found (or found, but found deallocated).
+  StatusOr<std::vector<const ShapedBuffer*>> Resolve(
+      const GlobalDataHandle& data) const;
+
+  // Resolves a handle from an XLA client and replica id to a shaped buffer, or
+  // provide an error status to say whether it was not found (or found, but
+  // found deallocated).
+  StatusOr<const ShapedBuffer*> ResolveForReplica(const GlobalDataHandle& data,
+                                                  int replica_id) const;
+
+ private:
+  // Data structure encapsulating single memory allocation on the device.
+  struct Allocation {
+    // The pointer to this allocation.
+    se::OwningDeviceMemory device_memory;
+
+    // This is the number of times this memory allocation is referred to by
+    // registered data handles.
+    int ref_count;
+  };
+
+  // Internal helper which resolves the given GlobalDataHandle to a
+  // list of ScopedShapedBuffers.
+  StatusOr<std::vector<const ShapedBuffer*>> ResolveInternal(
+      const GlobalDataHandle& data) const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Internal helper which registers a vector of shaped buffers, one per
+  // replica.  ShapedBufferTy is either ScopedShapedBuffer or ShapedBuffer.  If
+  // it's ShapedBuffer, all of the given buffers must already be tracked by this
+  // object -- presumably this is a call from DeconstructTuple.
+  template <typename ShapedBufferTy>
+  StatusOr<GlobalDataHandle> RegisterInternal(
+      std::vector<ShapedBufferTy> replicated_buffers, const std::string& tag)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Adds the given device address to the allocation tracker, or if it already
+  // exists, then increment its reference count.
+  void AddAllocationOrIncrementRefCount(se::DeviceMemoryBase device_memory,
+                                        int device_ordinal)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Decrements the reference count of the given device memory. Then, if it is
+  // zero, deallocate the memory.
+  Status DecrementRefCount(se::DeviceMemoryBase device_memory,
+                           int device_ordinal)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // A map from device memory opaque value to allocation. One such map is
+  // maintained per device ordinal.
+  using AllocationMap = absl::flat_hash_map<const void*, Allocation>;
+
+  mutable absl::Mutex mutex_;
+
+  // Backend to use with this tracker. The backend supplies the memory allocator
+  // to use when deallocating memory.
+  Backend* backend_;
+
+  // The next handle to assign to an allocation, guarded by the same mutex as
+  // the mapping as they'll be mutated at the same time.
+  int64_t next_handle_ ABSL_GUARDED_BY(mutex_);
+
+  // A map from device ordinal to AllocationMap.
+  absl::flat_hash_map<int, AllocationMap> opaque_to_allocation_map_
+      ABSL_GUARDED_BY(mutex_);
+
+  // A map from data handle to a vector of shaped buffers that represent the
+  // buffers for different replicas.
+  //
+  // The ShapedBuffers in this map's vectors need to be unique_ptrs, because our
+  // public API returns pointers to them.  We expect the concrete class to be
+  // ShapedBuffer and never ScopedShapedBuffer; deallocation of buffers is
+  // handled by opaque_to_allocation_map_.
+  //
+  // The elements of the vectors need to be unique_ptrs because we return
+  // pointers to them.  (In theory we could use std::list or something instead,
+  // but we also want to be able to null out these elements.)
+  //
+  // The reason that the elements can't be unique_ptr<ScopedShapedBuffer>s is
+  // the existence of DeconstructTuple().  This function allows us to create a
+  // non-owning "view" into a tuple's sub-buffers.  The sub-buffers are then
+  // free'd when both the view *and* the original tuple are Unregistered.  This
+  // refcounting is managed in opaque_to_allocation_map_.
+  absl::flat_hash_map<int64_t, std::vector<std::unique_ptr<ShapedBuffer>>>
+      handle_to_shaped_buffers_ ABSL_GUARDED_BY(mutex_);
+
+  AllocationTracker(const AllocationTracker&) = delete;
+  AllocationTracker& operator=(const AllocationTracker&) = delete;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_ALLOCATION_TRACKER_H_

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

@@ -0,0 +1,60 @@
+/* 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_ASYNC_COLLECTIVE_CREATOR_H_
+#define XLA_SERVICE_ASYNC_COLLECTIVE_CREATOR_H_
+
+#include <functional>
+#include <utility>
+#include <vector>
+
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+
+// Transforms each all-reduce instruction to a pair of all-reduce-start and
+// all-reduce-done.
+class AsyncCollectiveCreator : public HloModulePass {
+ public:
+  // Function to query the shape of the "context" for collectives that use
+  // HLO async-start/async-done.
+  using ContextShapeQuery =
+      std::function<std::vector<Shape>(const HloInstruction*)>;
+  struct CollectiveCreatorConfig {
+    HloPredicate convert_all_reduce = HloPredicateFalse;
+    HloPredicate convert_all_gather = HloPredicateFalse;
+    HloPredicate convert_collective_permute = HloPredicateFalse;
+    HloPredicate convert_all_to_all = HloPredicateFalse;
+    HloPredicate convert_reduce_scatter = HloPredicateFalse;
+    ContextShapeQuery get_context_shapes = [](const HloInstruction*) {
+      return std::vector<Shape>{};
+    };
+  };
+  explicit AsyncCollectiveCreator(CollectiveCreatorConfig creator_config)
+      : config_(std::move(creator_config)) {}
+  absl::string_view name() const override { return "async-collective-creator"; }
+
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  CollectiveCreatorConfig config_;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_ASYNC_COLLECTIVE_CREATOR_H_

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

@@ -0,0 +1,208 @@
+/* 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_BACKEND_H_
+#define XLA_SERVICE_BACKEND_H_
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/strings/str_cat.h"
+#include "absl/types/span.h"
+#include "xla/service/compiler.h"
+#include "xla/service/computation_placer.h"
+#include "xla/service/stream_pool.h"
+#include "xla/service/transfer_manager.h"
+#include "xla/statusor.h"
+#include "xla/stream_executor/device_memory_allocator.h"
+#include "xla/stream_executor/stream_executor.h"
+
+namespace Eigen {
+struct ThreadPoolDevice;
+}
+
+namespace xla {
+
+// Options to configure the backend when it is created.
+class BackendOptions {
+ public:
+  // Set the platform backing the backend, or nullptr for the default platform.
+  BackendOptions& set_platform(se::Platform* platform);
+  se::Platform* platform() const;
+
+  // Sets the thread pool size for parallel execution of an individual operator.
+  // The default value of -1 will result in initializing the thread pool with
+  // the number of threads equal to the number of cores in the system.
+  BackendOptions& set_intra_op_parallelism_threads(int num_threads);
+  int intra_op_parallelism_threads() const;
+
+  // Sets the allowed_devices for selectively constructing stream executors
+  // on the platform.
+  BackendOptions& set_allowed_devices(
+      const std::optional<std::set<int>>& allowed_devices);
+  const std::optional<std::set<int>>& allowed_devices() const;
+
+ private:
+  se::Platform* platform_ = nullptr;
+  int intra_op_parallelism_threads_ = -1;
+  std::optional<std::set<int>> allowed_devices_;
+};
+
+// Class which encapsulates an XLA backend. It includes everything necessary
+// to compile and execute computations on a particular platform.
+//
+// It also offers a pooling API for creation/use of initialized streams:
+//
+//    StreamPool::Ptr stream = backend->BorrowStream().value();
+class Backend {
+ public:
+  // Creates a new backend.
+  static StatusOr<std::unique_ptr<Backend>> CreateBackend(
+      const BackendOptions& options);
+
+  // Creates a backend for the default platform. The default platform is defined
+  // in PlatformUtil.
+  static StatusOr<std::unique_ptr<Backend>> CreateDefaultBackend();
+
+  ~Backend();
+
+  // Accessors for the various objects.
+  se::Platform* platform() const { return platform_; }
+  Compiler* compiler() const { return compiler_; }
+  se::DeviceMemoryAllocator* memory_allocator() const {
+    return memory_allocator_.get();
+  }
+  std::shared_ptr<se::DeviceMemoryAllocator> shared_memory_allocator() const {
+    return memory_allocator_;
+  }
+  TransferManager* transfer_manager() const { return transfer_manager_; }
+  ComputationPlacer* computation_placer() const { return computation_placer_; }
+
+  // Returns the number of devices of the platform type which are visible. Not
+  // all of these devices may be usable by XLA.
+  int device_count() const { return stream_executors_.size(); }
+
+  // Returns the device ordinal number of the default device.
+  int default_device_ordinal() const;
+
+  // Returns stream executors of all supported devices for this backend. The
+  // executors are ordered by the device ordinal.
+  const std::vector<se::StreamExecutor*>& stream_executors() const {
+    return stream_executors_;
+  }
+
+  // Returns the stream executor for the given device ordinal.
+  StatusOr<se::StreamExecutor*> stream_executor(int device_ordinal) const;
+
+  // Returns the stream executor for the default device ordinal. This stream
+  // executor can only be used when the number of computations is 1 (replication
+  // can be > 1).
+  se::StreamExecutor* default_stream_executor() const {
+    CHECK(!stream_executors_.empty());
+    return stream_executors_[0];
+  }
+
+  // Borrows a stream for use by the caller with a given priority, either by
+  // grabbing it from an internal pool, or by constructing/initializating it,
+  // and returns the result to the caller.
+  StatusOr<StreamPool::Ptr> BorrowStream(
+      int device_ordinal,
+      se::StreamPriority priority = se::StreamPriority::Default);
+  StatusOr<StreamPool::Ptr> BorrowStream(
+      se::StreamExecutor* executor,
+      se::StreamPriority priority = se::StreamPriority::Default);
+  StatusOr<std::vector<StreamPool::Ptr>> BorrowStreams(
+      int device_ordinal, int num_streams,
+      se::StreamPriority priority = se::StreamPriority::Default);
+
+  // Returns a function to borrow streams with a given priority,
+  // as `BorrowStreams` above does.
+  // Purely for convenience, the caller could rather make this anonymous
+  // function itself.
+  std::function<StatusOr<std::vector<StreamPool::Ptr>>(int, int,
+                                                       se::StreamPriority)>
+  StreamBorrowerWithPriority() {
+    return [this](int device_ordinal, int num_streams,
+                  se::StreamPriority priority) {
+      return BorrowStreams(device_ordinal, num_streams, priority);
+    };
+  }
+
+  // Returns whether the given device ordinal of the backend is supported.
+  bool device_ordinal_supported(int device_ordinal) const {
+    return (device_ordinal >= 0 && device_ordinal < device_count() &&
+            stream_executors_[device_ordinal] != nullptr);
+  }
+
+  // Return a string identifier for the given device, eg: "GPU:3".
+  std::string device_name(int device_ordinal) const {
+    return absl::StrCat(platform_->Name(), ":", device_ordinal);
+  }
+
+  // Returns true if the devices with the given ordinals are equivalent from
+  // XLA's perspective. That is, an executable compiled for one device would
+  // be equivalent to an executable compiled for the other.
+  StatusOr<bool> devices_equivalent(int device_ordinal_a, int device_ordinal_b);
+
+  // For the host platform, returns the configured eigen threadpool device to be
+  // used for scheduling work. For other platforms, returns NULL.
+  const Eigen::ThreadPoolDevice* eigen_intra_op_thread_pool_device() const;
+  tsl::thread::ThreadPool* eigen_intra_op_thread_pool() const;
+
+  // Resets the devices associated with this backend.
+  Status ResetDevices();
+
+ private:
+  Backend(se::Platform* platform, Compiler* compiler,
+          absl::Span<se::StreamExecutor* const> stream_executors,
+          TransferManager* transfer_manager,
+          ComputationPlacer* computation_placer,
+          int intra_op_parallelism_threads);
+  Backend(const Backend&) = delete;
+  Backend& operator=(const Backend&) = delete;
+
+  se::Platform* platform_;
+  Compiler* compiler_;
+  TransferManager* transfer_manager_;
+  ComputationPlacer* computation_placer_;
+
+  // Vector of stream executors. stream_executors_[0] is the default executor.
+  std::vector<se::StreamExecutor*> stream_executors_;
+
+  absl::Mutex mu_;
+
+  // Mapping from stream executor to stream pools, used by `BorrowStream` above.
+  absl::flat_hash_map<se::StreamExecutor*, std::unique_ptr<StreamPool>>
+      stream_pools_ ABSL_GUARDED_BY(mu_);
+
+  // The default memory allocator to use.
+  // This must be a shared_ptr, as this is passed all the way down to the
+  // cluster compilation. This allows asynchronous compilation to hold a
+  // referecence until the compilation is finished.
+  std::shared_ptr<se::StreamExecutorMemoryAllocator> memory_allocator_;
+
+  // For the CPU backend, an Eigen threadpool device for use by Eigen code.
+  struct IntraOpThreadPool;
+  std::unique_ptr<IntraOpThreadPool> intra_op_thread_pool_;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_BACKEND_H_

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

@@ -0,0 +1,42 @@
+/* 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_BATCH_DOT_SIMPLIFICATION_H_
+#define XLA_SERVICE_BATCH_DOT_SIMPLIFICATION_H_
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+// Simplifies batch dot operations.
+//
+// Normally these would live in the algebraic simplifier, but we want to run
+// this to fixpoint (this pass reaches fixed point in one execution) before we
+// run the DotDecomposer.
+class BatchDotSimplification : public HloModulePass {
+ public:
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+  absl::string_view name() const override;
+
+ private:
+  StatusOr<bool> ElideDegenerateBatchDimensionFromBatchDot(
+      HloInstruction* batch_dot);
+};
+}  // namespace xla
+
+#endif  // XLA_SERVICE_BATCH_DOT_SIMPLIFICATION_H_

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

@@ -0,0 +1,56 @@
+/* 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_BATCHNORM_EXPANDER_H_
+#define XLA_SERVICE_BATCHNORM_EXPANDER_H_
+
+#include <utility>
+
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+
+// A pass which rewrites batch norm operations into more operations. Breaking a
+// big operation into smaller operations helps leverage our generic fusion
+// logic.
+class BatchNormExpander : public HloModulePass {
+ public:
+  // When use_fusion is set, a multi-output fusion node is created.
+  explicit BatchNormExpander(bool rewrite_training_op = false,
+                             bool rewrite_inference_op = false,
+                             bool rewrite_grad_op = false)
+      : rewrite_training_op_(rewrite_training_op),
+        rewrite_inference_op_(rewrite_inference_op),
+        rewrite_grad_op_(rewrite_grad_op) {}
+  ~BatchNormExpander() override = default;
+  absl::string_view name() const override { return "batchnorm_expander"; }
+
+  // Run operation expander on the given computation. Returns whether the
+  // computation was changed.
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+
+ private:
+  bool rewrite_training_op_;
+  bool rewrite_inference_op_;
+  bool rewrite_grad_op_;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_BATCHNORM_EXPANDER_H_

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

@@ -0,0 +1,45 @@
+/* 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.
+==============================================================================*/
+
+#include "xla/hlo/ir/hlo_instructions.h"
+#include "xla/hlo/ir/hlo_module.h"
+#include "xla/service/hlo_pass_interface.h"
+#include "xla/service/op_expander_pass.h"
+#include "xla/statusor.h"
+
+#ifndef XLA_SERVICE_BITCAST_DTYPES_EXPANDER_H_
+#define XLA_SERVICE_BITCAST_DTYPES_EXPANDER_H_
+
+namespace xla {
+
+// A pass which expands bitcast-convert between differently sized dtypes to a
+// reduction.
+class BitcastDtypesExpander : public OpExpanderPass {
+ public:
+  absl::string_view name() const override { return "bitcast_dtypes_expander"; }
+
+ protected:
+  bool InstructionMatchesPattern(HloInstruction* instruction) override;
+
+  StatusOr<HloInstruction*> ExpandInstruction(
+      HloInstruction* instruction) override;
+
+ private:
+  absl::flat_hash_map<std::string, HloComputation*> computation_cache_;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_BITCAST_DTYPES_EXPANDER_H_

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

@@ -0,0 +1,40 @@
+/* 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_BROADCAST_CANONICALIZER_H_
+#define XLA_SERVICE_BROADCAST_CANONICALIZER_H_
+
+#include <optional>
+
+#include "xla/service/hlo_pass_interface.h"
+
+namespace xla {
+
+// This transform ensures that dimensions in all broadcast operations are
+// sorted.
+class BroadcastCanonicalizer : public HloModulePass {
+ public:
+  explicit BroadcastCanonicalizer();
+
+  absl::string_view name() const override { return "broadcast_canonicalizer"; }
+  using HloPassInterface::Run;
+  StatusOr<bool> Run(
+      HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads) override;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_BROADCAST_CANONICALIZER_H_

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

@@ -0,0 +1,793 @@
+/* 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_BUFFER_ASSIGNMENT_H_
+#define XLA_SERVICE_BUFFER_ASSIGNMENT_H_
+
+#include <functional>
+#include <iosfwd>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/types/span.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/utils/hlo_live_range.h"
+#include "xla/service/buffer_assignment.pb.h"
+#include "xla/service/heap_simulator.h"
+#include "xla/service/hlo.pb.h"
+#include "xla/service/hlo_alias_analysis.h"
+#include "xla/service/hlo_dataflow_analysis.h"
+#include "xla/service/logical_buffer.h"
+#include "xla/service/memory_space_assignment/memory_space_assignment.h"
+#include "xla/service/tuple_points_to_analysis.h"
+#include "xla/statusor.h"
+#include "xla/types.h"
+#include "tsl/platform/logging.h"
+
+namespace xla {
+
+// Walk the call graph of the HLO module and place each computation into either
+// thread_local_computations or global_computations depending upon whether the
+// computation requires thread-local allocations or global allocations. The
+// elements in thread_local_computations and global_computations are in post
+// order (if computation A has an instruction which calls computation B, then A
+// will appear after B in the vector).
+Status GatherComputationsByAllocationType(
+    const HloModule* module,
+    std::vector<const HloComputation*>* thread_local_computations,
+    std::vector<const HloComputation*>* global_computations);
+
+// This class abstracts an allocation of contiguous memory which can hold the
+// values described by LogicalBuffers. Each LogicalBuffer occupies a sub-range
+// of the allocation, represented by a Slice. A single BufferAllocation may hold
+// LogicalBuffers with disjoint liveness, which may have overlapping Slices. A
+// single BufferAllocation may also hold LogicalBuffers with overlapping
+// liveness, which must have disjoint Slices.
+//
+// The abstraction includes information required by the backends for allocation,
+// use, and deallocation of the buffer. This includes the LogicalBuffers which
+// are held in this allocation through the execution of the computation.
+class BufferAllocation {
+ public:
+  // Holds a unique identifier for each allocation. Values are assigned
+  // contiguously and can be used as array indexes.
+  using Index = int64_t;
+
+  BufferAllocation(Index index, int64_t size, LogicalBuffer::Color color)
+      : index_(index), size_(size), color_(color) {}
+  ~BufferAllocation() {}
+
+  // Returns the index of this allocation.
+  Index index() const { return index_; }
+
+  // Whether this allocation is used in a parallel calling context such as
+  // inside of a map or reduce computation. Such allocations need to be thread
+  // local.
+  bool is_thread_local() const { return is_thread_local_; }
+  void set_is_thread_local(bool is_thread_local) {
+    is_thread_local_ = is_thread_local;
+  }
+
+  // Whether this allocation can be used by more than one logical buffer.
+  bool is_reusable() const {
+    // We do not reuse thread-local buffers for now, because they are
+    // dynamically allocated and their lifetimes are hard to compute.
+    //
+    // TODO(b/34669761): Don't reuse tuple buffers because the GPU backend
+    // assumes longer buffer liveness than indicated by the analysis.
+    return !is_thread_local() && !is_tuple();
+  }
+
+  // Whether this allocation is readonly i.e. backed by memory we cannot write
+  // to.
+  bool is_readonly() const {
+    // Entry parameters are generally readonly, except when they are aliased
+    // with any output.
+    return (is_entry_computation_parameter() &&
+            !is_parameter_aliased_with_output_) ||
+           is_constant();
+  }
+
+  bool is_tuple() const { return is_tuple_; }
+  void set_is_tuple(bool is_tuple) { is_tuple_ = is_tuple; }
+
+  // Whether this allocation holds a LogicalBuffer from a parameter of the entry
+  // computation. These buffers have lifetimes which may be longer than the
+  // XLA computation.
+  bool is_entry_computation_parameter() const {
+    return is_entry_computation_parameter_;
+  }
+
+  // Whether this allocation holds a constant.  On the CPU and GPU backends
+  // constant allocations are not allocated dynamically, instead we resolve
+  // references to these buffer allocations to a global in the readonly section
+  // of the binary.
+  bool is_constant() const { return is_constant_; }
+
+  // If this allocation holds a Buffer from a parameter of the entry
+  // computation, this methods returns the parameter number. CHECKs otherwise.
+  int64_t parameter_number() const {
+    CHECK(is_entry_computation_parameter_);
+    return parameter_number_;
+  }
+
+  // If this allocation is for a parameter of the entry computation, this
+  // function returns which subshape of the parameter the allocation is for.
+  const ShapeIndex& param_shape_index() const {
+    CHECK(is_entry_computation_parameter_);
+    return param_shape_index_;
+  }
+
+  // Returns whether this allocation is assigned a LogicalBuffer which may
+  // be live out of the entry computation.
+  bool maybe_live_out() const { return maybe_live_out_; }
+
+  void set_maybe_live_out(bool value) { maybe_live_out_ = value; }
+
+  // Returns the size of the allocation. Necessarily this must be at least as
+  // large as any LogicalBuffer assigned to this allocation.
+  int64_t size() const { return size_; }
+
+  // Returns the color of the allocation. Only logical buffers with a matching
+  // color can reside in this allocation.
+  LogicalBuffer::Color color() const { return color_; }
+
+  struct OffsetSize {
+    int64_t offset = 0;
+    int64_t size = 0;
+  };
+
+  // Access to the logical buffers assigned to this allocation, and their
+  // associated logical offsets and sizes.
+  const absl::flat_hash_map<const HloValue*, OffsetSize>& assigned_buffers()
+      const {
+    return assigned_buffers_;
+  }
+
+  // A Slice represents a contiguous portion of a memory allocation. It is used
+  // to identify the memory range that a LogicalBuffer corresponds to.
+  class Slice {
+   public:
+    Slice() {}
+    Slice(const BufferAllocation* allocation, int64_t offset, int64_t size)
+        : allocation_(allocation), offset_(offset), size_(size) {}
+
+    const BufferAllocation* allocation() const { return allocation_; }
+    Index index() const { return allocation_->index(); }
+    int64_t offset() const { return offset_; }
+    int64_t size() const { return size_; }
+
+    bool operator==(const Slice& other) const {
+      return index() == other.index() && offset_ == other.offset_ &&
+             size_ == other.size_;
+    }
+    bool operator!=(const Slice& other) const { return !(*this == other); }
+    bool operator<(const Slice& other) const {
+      if (index() != other.index()) return index() < other.index();
+      if (offset_ != other.offset_) return offset_ < other.offset_;
+      return size_ < other.size_;
+    }
+
+    // Returns true iff this slice's memory range has a non-empty intersection
+    // with the other slice's memory range.
+    bool OverlapsWith(const Slice& other) const {
+      const int64_t end = offset_ + size_;
+      const int64_t other_end = other.offset_ + other.size_;
+      return index() == other.index() && offset_ < other_end &&
+             end > other.offset_;
+    }
+
+    template <typename H>
+    friend H AbslHashValue(H h, const Slice& s) {
+      return H::combine(std::move(h), s.index(), s.offset(), s.size());
+    }
+
+    std::string ToString() const;
+
+   private:
+    const BufferAllocation* allocation_ = nullptr;
+    int64_t offset_ = 0;
+    int64_t size_ = 0;
+  };
+
+  // GetSlice returns the Slice of contiguous memory that holds the value
+  // described by the given 'buffer'.
+  // REQUIRES: 'buffer' must be assigned to this allocation.
+  Slice GetSlice(const HloValue& buffer) const;
+
+  std::string ToString() const;
+  BufferAllocationProto ToProto() const;
+
+  // Whether the buffer is a parameter to or live out of the entry computation.
+  bool IsInputOrOutput() const {
+    return is_entry_computation_parameter() || maybe_live_out();
+  }
+
+  // Whether the buffer is a temporary buffer allocated before
+  // Executable::ExecuteOnStream.
+  bool IsPreallocatedTempBuffer() const {
+    // Parameters do not need temporary buffers.
+    return !is_entry_computation_parameter() &&
+           // LogicalBuffers that maybe pointed to by the output should live out
+           // of the computation.
+           !maybe_live_out() &&
+           // Thread-local buffers are allocated using `alloca`s.
+           !is_thread_local() &&
+           // Constant buffers are allocated as global values.
+           !is_constant();
+  }
+
+  // Add a heap trace which was used to assign slices to logical buffers in this
+  // allocation. A single BufferAllocation may include multiple heap traces
+  // in the case of the temporary block where there is a heap trace per
+  // computation.
+  void AddHeapTrace(const HeapSimulatorTrace& heap_trace) {
+    heap_traces_.push_back(heap_trace);
+    heap_traces_.back().set_buffer_allocation_index(index());
+  }
+
+  // Return the set of heap traces used to assign slices to logical buffers in
+  // this allocation.
+  const std::vector<HeapSimulatorTrace> HeapTraces() const {
+    return heap_traces_;
+  }
+
+  // Returns the LogicalBuffers which are live at the point of peak memory usage
+  // for this allocation. The point of peak memory usage is the point at which
+  // the total size of all live logical buffers is maximal. If peak memory is
+  // reached at multiple points, the set of logical buffers live at the earliest
+  // maximal point is returned. The vector is stably sorted by
+  // BufferValue::Index.
+  const std::vector<const HloValue*>& PeakMemoryLogicalBuffers() const {
+    return peak_buffers_;
+  }
+
+  // Get the number of bytes lost to fragmentation. This is equal to the
+  // difference between the size of the allocation and the size of the maximal
+  // live set.
+  int64_t fragmentation_bytes() const { return fragmentation_bytes_; }
+
+  bool operator==(const BufferAllocation& other) const {
+    return index_ == other.index_;
+  }
+  bool operator!=(const BufferAllocation& other) const {
+    return !(*this == other);
+  }
+  bool operator<(const BufferAllocation& other) const {
+    return index() < other.index();
+  }
+
+  void set_entry_computation_parameter(int64_t parameter_number,
+                                       ShapeIndex param_shape_index,
+                                       bool parameter_aliased_with_output) {
+    is_entry_computation_parameter_ = true;
+    is_parameter_aliased_with_output_ = parameter_aliased_with_output;
+    parameter_number_ = parameter_number;
+    param_shape_index_ = std::move(param_shape_index);
+  }
+
+  void set_constant(bool is_constant) { is_constant_ = is_constant; }
+
+ private:
+  // Only BufferAssigner and BufferAssignment can modify BufferAllocation.
+  friend class BufferAssigner;
+  friend class BufferAssignment;
+
+  // Adds a LogicalBuffer to the set assigned to this buffer.
+  void AddAssignment(const HloValue& buffer, int64_t offset, int64_t size);
+
+  void set_index(Index index) { index_ = index; }
+  void set_size(int64_t size) { size_ = size; }
+
+  // The index of the allocation in the BufferAssignment.
+  Index index_;
+
+  // Size of the allocation in bytes.
+  int64_t size_;
+
+  // Whether this buffer needs to be thread-local.
+  bool is_thread_local_ = false;
+
+  // Whether this buffer holds a tuple.
+  bool is_tuple_ = false;
+
+  // Color of the allocation.
+  LogicalBuffer::Color color_;
+
+  // Whether this allocation holds an entry computation parameter. Entry
+  // computation parameters are special because they have lifetimes which may
+  // outlast the computation.
+  bool is_entry_computation_parameter_ = false;
+
+  // Whether this entry computation parameter is aliased with output.
+  bool is_parameter_aliased_with_output_ = false;
+
+  // If this allocation holds an entry computation parameter, this field
+  // indicates the index (starting from 0) of the parameter.
+  int64_t parameter_number_ = 0;
+
+  // If this buffer is for an entry computation parameter, which subshape of the
+  // parameter is it for?
+  ShapeIndex param_shape_index_;
+
+  // Whether the allocation contains a LogicalBuffer which may be live-out of
+  // the entry computation. Note that this flag is conservatively computed by
+  // TuplePointsToAnalysis.  That is, an allocation marked `maybe_live_out_`
+  // might not actually escape.
+  bool maybe_live_out_ = false;
+
+  // See comment on the is_constant() accessor.
+  bool is_constant_ = false;
+
+  // Mapping from the set of buffers assigned to this allocation to their
+  // logical offsets and sizes.
+  absl::flat_hash_map<const HloValue*, OffsetSize> assigned_buffers_;
+
+  int64_t fragmentation_bytes_ = 0;
+  std::vector<HeapSimulatorTrace> heap_traces_;
+
+  // Set of buffers live at the point of peak memory usage for this allocation.
+  std::vector<const HloValue*> peak_buffers_;
+};
+
+// Add stream operators for nicer output of CHECK/RET_CHECK failures.
+std::ostream& operator<<(std::ostream& out, const BufferAllocation& s);
+std::ostream& operator<<(std::ostream& out, const BufferAllocation::Slice& s);
+
+// This class encapsulates an assignment of the LogicalBuffers in an XLA
+// module to a set of BufferAllocations.
+class BufferAssignment {
+ public:
+  // This is a think wrapper around BufferIsolationConfig. Please see the
+  // documentation for BufferIsolationConfig for details on how buffer isolation
+  // works. hlo_value_compare is the concrete implementation of the HloValue
+  // comparison that uses the isolation_order_salt value in the
+  // BufferIsolationConfig.
+  struct BufferIsolationOptions {
+    std::function<bool(const HloValue*, const HloValue*)> hlo_value_compare;
+    buffer_assignment::BufferIsolationConfig config;
+  };
+
+  // Returns the vector containing all buffer allocations in this assignment.
+  const std::vector<BufferAllocation>& Allocations() const {
+    return allocations_;
+  }
+
+  // This is similar to copying Allocations(), but since it's moved out, it
+  // preserves the addresses. Since BufferAllocation::Slice keeps a
+  // BufferAllocation*, and some backends keep BufferAllocation::Slice in
+  // xla::Executables, migrating off the use of addresses can be hard.
+  std::vector<BufferAllocation> ReleaseAllocations() {
+    return std::move(allocations_);
+  }
+
+  // Returns the total size allocation holding all temporary buffers.
+  int64_t temp_allocation_total_size() const {
+    return temp_allocation_total_size_;
+  }
+
+  uint64_t multiheap_size_constraint_per_heap() const {
+    return multiheap_size_constraint_per_heap_;
+  }
+
+  // Returns whether the given buffer has been assigned an allocation.
+  bool HasAllocation(const HloValue& value) const;
+
+  // Returns whether the given (logical) buffer with the id has been assigned an
+  // allocation.
+  bool HasAllocation(HloValue::Id value_id) const;
+
+  bool HasAllocation(const HloBuffer& buffer) const;
+
+  // Returns the allocation that a particular LogicalBuffer has been assigned
+  // to. CHECKs if buffer has not been assigned an allocation.
+  const BufferAllocation& GetAssignedAllocation(const HloValue& value) const;
+
+  const BufferAllocation& GetAssignedAllocation(
+      const HloBuffer& hlo_buffer) const;
+
+  // Returns the allocation with the given index. CHECKs if no allocation exists
+  // with the given index.
+  const BufferAllocation& GetAllocation(BufferAllocation::Index index) const;
+
+  // Returns the allocation with the given instruction and shape index. nullptr
+  // if no allocation exists.
+  const BufferAllocation* GetInstructionAllocation(
+      const HloInstruction* hlo, const ShapeIndex& shape_index) const;
+
+  // Builds and returns a vector containing the slices which might contain the
+  // subvalue at the given index of given instruction.
+  std::set<BufferAllocation::Slice> GetAllSlices(
+      const HloInstruction* instruction, const ShapeIndex& index) const;
+
+  // Convenience function which returns whether the buffer of the
+  // instruction at the given index is assigned an allocation.
+  bool HasAllocationAt(const HloInstruction* instruction,
+                       const ShapeIndex& index) const;
+
+  // Convenience function which returns whether the top-level buffer of the
+  // instruction (index == {}) is assigned an allocation.
+  bool HasTopLevelAllocation(const HloInstruction* instruction) const;
+
+  // Convenience function which returns the unique slice containing the buffer
+  // at the given index of the given instruction. If a slice is not assigned or
+  // the slice cannot be determined at compile time then an error is returned.
+  StatusOr<BufferAllocation::Slice> GetUniqueSlice(
+      const HloInstruction* instruction, const ShapeIndex& index) const;
+  // Like GetUniqueSlice but fixes the index to the top-level of the shape
+  // (index = {}).
+  StatusOr<BufferAllocation::Slice> GetUniqueTopLevelSlice(
+      const HloInstruction* instruction) const;
+  // Like GetUniqueTopLevelSlice but returns the slice for the output of the
+  // entry computation of the HLO module (ie, the result of the XLA
+  // computation).
+  StatusOr<BufferAllocation::Slice> GetUniqueTopLevelOutputSlice() const;
+
+  // Returns the set BufferValues which may be the source of the value at the
+  // given index and instruction.
+  const std::vector<const HloValue*>& GetSourceBuffers(
+      const HloInstruction* instruction, const ShapeIndex& index) const {
+    return dataflow_analysis().GetValueSet(instruction, index).values();
+  }
+
+  // Returns true if 'hlo_a{shape_index_a}' and 'hlo_b{shape_index_b}'
+  // share the same BufferAllocation::Slice.
+  // Returns false otherwise.
+  // REQUIRES: BufferAssignment assigned allocations to both instructions.
+  bool SharesSliceAtIndex(const HloInstruction* hlo_a,
+                          const ShapeIndex& shape_index_a,
+                          const HloInstruction* hlo_b,
+                          const ShapeIndex& shape_index_b) const;
+
+  // Returns true if the top-level buffers of hlo_a and hlo_b are the same.
+  // REQUIRES: HasTopLevelAllocation(hlo_a) && HasTopLevelAllocation(hlo_b).
+  bool SharesTopLevelSlice(const HloInstruction* hlo_a,
+                           const HloInstruction* hlo_b) const {
+    return SharesSliceAtIndex(hlo_a, {}, hlo_b, {});
+  }
+
+  // Returns true if hlo_a and hlo_b both have at least one buffer assigned for
+  // their top-level and each of their nested shape indices, and if hlo_a's
+  // buffers are all different from hlo_b's buffers.
+  bool HaveDisjointSlices(const HloInstruction* hlo_a,
+                          const HloInstruction* hlo_b) const;
+
+  const HloDataflowAnalysis& dataflow_analysis() const {
+    return alias_analysis_->dataflow_analysis();
+  }
+
+  HloAliasAnalysis& alias_analysis() const { return *alias_analysis_; }
+
+  const HloOrdering& hlo_ordering() const { return *hlo_ordering_; }
+
+  // Returns the HloLiveRange object used to construct this assignment.
+  const HloLiveRange& hlo_live_range() const { return *hlo_live_range_; }
+
+  std::string ToString() const;
+  // Verbose string tailored to debugging OOMs, includes the Hlo op metadata for
+  // every buffer associated with each allocation.
+  std::string ToVerboseString(size_t max_buffers_to_show) const;
+  std::string BufferInfoString() const;
+
+  // Convert BufferAssignment to or from a proto.
+  BufferAssignmentProto ToProto() const;
+  static StatusOr<std::unique_ptr<BufferAssignment>> FromProto(
+      const BufferAssignmentProto& proto, const HloModule* module,
+      BufferValue::SizeFunction buffer_size,
+      HloDataflowAnalysis::CanShareBuffer can_share_buffer);
+
+  // Statistics for the assignment.  Values initialized to -1 are not always
+  // collected; fragmentation is only collected for instructions that have a
+  // sequential total ordering.
+  struct Stats {
+    int64_t parameter_allocation_count = 0;
+    int64_t parameter_allocation_bytes = 0;
+    int64_t constant_allocation_count = 0;
+    int64_t constant_allocation_bytes = 0;
+    int64_t maybe_live_out_allocation_count = 0;
+    int64_t maybe_live_out_allocation_bytes = 0;
+    int64_t preallocated_temp_allocation_count = 0;
+    int64_t preallocated_temp_allocation_bytes = 0;
+    int64_t preallocated_temp_fragmentation_bytes = -1;
+    int64_t total_allocation_count = 0;
+    int64_t total_allocation_bytes = 0;
+    int64_t total_fragmentation_bytes = -1;
+
+    std::string ToString() const;
+  };
+  const Stats& GetStats() const { return stats_; }
+
+ private:
+  // Only BufferAssigner can build or modify BufferAssignments.
+  friend class BufferAssigner;
+
+  BufferAssignment(const HloModule* module,
+                   std::unique_ptr<HloOrdering> hlo_ordering,
+                   BufferValue::SizeFunction buffer_size,
+                   LogicalBuffer::AlignmentFunction color_alignment,
+                   std::unique_ptr<HloAliasAnalysis> alias_analysis,
+                   std::unique_ptr<HloLiveRange> hlo_live_range)
+      : module_(module),
+        hlo_ordering_(std::move(hlo_ordering)),
+        buffer_size_(std::move(buffer_size)),
+        color_alignment_(std::move(color_alignment)),
+        alias_analysis_(std::move(alias_analysis)),
+        hlo_live_range_(std::move(hlo_live_range)) {
+    int32_t raw_value = module->config()
+                            .debug_options()
+                            .xla_multiheap_size_constraint_per_heap();
+    // -1 means no constraint.
+    multiheap_size_constraint_per_heap_ =
+        (raw_value == -1) ? UINT64_MAX : raw_value;
+  }
+
+  // Creates and returns a new BufferAllocation, with no assigned
+  // LogicalBuffers. Ownership is maintained internally.
+  BufferAllocation* NewEmptyAllocation(int64_t size,
+                                       LogicalBuffer::Color color);
+
+  // Helper that calls NewEmptyAllocation and AddAssignment in one call,
+  // creating an allocation containing a single LogicalBuffer.
+  BufferAllocation* NewAllocation(const HloBuffer& buffer, int64_t size);
+
+  // Adds a LogicalBuffer to the set assigned to the given allocation.
+  void AddAssignment(BufferAllocation* allocation, const HloBuffer& buffer,
+                     int64_t offset, int64_t size);
+
+  void AddAssignment(BufferAllocation* allocation, const HloValue& value,
+                     int64_t offset, int64_t size);
+
+  // Returns the HloModule used to construct this assignment.
+  const HloModule& module() const { return *module_; }
+
+  // Mutable accessors for allocations.
+  BufferAllocation* GetMutableAssignedAllocation(const HloBuffer& buffer);
+  BufferAllocation* GetMutableAllocation(BufferAllocation::Index index);
+
+  int64_t HloBufferSize(const HloBuffer& buffer) {
+    auto iter = cached_buffer_sizes_.find(buffer.id());
+    if (iter != cached_buffer_sizes_.end()) return iter->second;
+    int64_t result = 0;
+    for (const HloValue* value : buffer.values()) {
+      result = std::max(result, buffer_size_(*value));
+    }
+    cached_buffer_sizes_.insert({buffer.id(), result});
+    return result;
+  }
+
+  // Combines allocations of temporary buffers into one big BufferAllocation.
+  void CombineTempAllocations(
+      const absl::flat_hash_set<BufferValue::Color>& private_stack_colors);
+
+  // Computes stats for the assignment, to be retrieved by GetStats.
+  Status ComputeSummaryStats();
+
+  // The vector of buffer allocations. Indexed by BufferAllocation::Index.
+  std::vector<BufferAllocation> allocations_;
+
+  // The total size of all temporary buffers.
+  int64_t temp_allocation_total_size_ = 0;
+
+  uint64_t multiheap_size_constraint_per_heap_;
+
+  // Maps Buffers to the index of the BufferAllocation which holds the buffer.
+  absl::flat_hash_map<const HloValue*, BufferAllocation::Index>
+      allocation_index_for_value_;
+
+  const HloModule* module_;
+
+  const std::unique_ptr<HloOrdering> hlo_ordering_;
+
+  // Function which returns the buffer size for a given logical buffer (shape).
+  BufferValue::SizeFunction buffer_size_;
+
+  // Function which returns the alignment for a given logical buffer color.
+  LogicalBuffer::AlignmentFunction color_alignment_;
+
+  std::unique_ptr<HloAliasAnalysis> alias_analysis_;
+
+  std::unique_ptr<HloLiveRange> hlo_live_range_;
+
+  Stats stats_;
+
+  absl::flat_hash_map<HloBuffer::Id, int64_t> cached_buffer_sizes_;
+
+  BufferAssignment(const BufferAssignment&) = delete;
+  BufferAssignment& operator=(const BufferAssignment&) = delete;
+};
+
+// A class which constructs a buffer assignment.
+class BufferAssigner {
+ public:
+  using Colorer = std::function<Status(HloAliasAnalysis*, const HloOrdering&)>;
+  using MustNotLiveOut =
+      std::function<bool(const HloInstruction*, const ShapeIndex&)>;
+  using PrivateStacks = absl::flat_hash_map<BufferValue::Color,
+                                            std::vector<const HloComputation*>>;
+
+  static Colorer DefaultColorer() {
+    return [](HloAliasAnalysis* alias_analysis, const HloOrdering&) {
+      for (HloValue* value : alias_analysis->dataflow_analysis().values()) {
+        const HloPosition& defining_position = value->defining_position();
+        if (defining_position.shape().has_layout()) {
+          value->set_color(BufferValue::Color(
+              defining_position.shape().layout().memory_space()));
+        } else {
+          value->set_color(BufferValue::Color(0));
+        }
+      }
+      return OkStatus();
+    };
+  }
+
+  // Returns false if a buffer cannot be assigned to given allocation.
+
+  // Build and return a BufferAssignment for the given module. The given
+  // HloOrdering is used to determine buffer liveness. buffer_size and
+  // color_alignment are functions which returns the size and alignment of a
+  // LogicalBuffer. If preset_assignments is provided, those pre-set assignment
+  // offsets will be used. The caller guarantees that those assignments are
+  // valid and they do not overwrite each other.
+  static StatusOr<std::unique_ptr<BufferAssignment>> Run(
+      const HloModule* module, std::unique_ptr<HloOrdering> hlo_ordering,
+      BufferValue::SizeFunction buffer_size,
+      LogicalBuffer::AlignmentFunction color_alignment,
+      bool allocate_buffers_for_constants = false,
+      Colorer colorer = DefaultColorer(),
+      std::optional<MustNotLiveOut> must_not_live_out = std::nullopt,
+      HloDataflowAnalysis::CanShareBuffer can_share_buffer = nullptr,
+      std::unique_ptr<memory_space_assignment::PresetAssignments>
+          preset_assignments = {},
+      const PrivateStacks& private_stacks = {},
+      GlobalDecreasingSizeBestFitHeap<HloValue>::BufferIntervalCompare
+          heap_buffer_interval_compare = nullptr,
+      std::optional<BufferAssignment::BufferIsolationOptions>
+          isolation_options = std::nullopt);
+
+ private:
+  BufferAssigner(bool allocate_buffers_for_constants, Colorer colorer,
+                 std::optional<MustNotLiveOut> must_not_live_out,
+                 std::unique_ptr<memory_space_assignment::PresetAssignments>
+                     preset_assignments)
+      : allocate_buffers_for_constants_(allocate_buffers_for_constants),
+        colorer_(colorer),
+        must_not_live_out_(must_not_live_out),
+        preset_assignments_(std::move(preset_assignments)) {}
+  virtual ~BufferAssigner() = default;
+
+  // Create a buffer assignment.
+  StatusOr<std::unique_ptr<BufferAssignment>> CreateAssignment(
+      const HloModule* module, std::unique_ptr<HloOrdering> hlo_ordering,
+      BufferValue::SizeFunction buffer_size,
+      LogicalBuffer::AlignmentFunction color_alignment,
+      HloDataflowAnalysis::CanShareBuffer can_share_buffer,
+      const PrivateStacks& private_stacks,
+      GlobalDecreasingSizeBestFitHeap<HloValue>::BufferIntervalCompare
+          heap_buffer_interval_compare,
+      std::optional<BufferAssignment::BufferIsolationOptions>
+          isolation_options);
+
+  // Assigns buffers to the instructions in the given computations. "assignment"
+  // is modified to reflect the new buffer assignments. If is_thread_local is
+  // true, then all assigned buffers have the is_thread_local flag set to
+  // true.
+  Status AssignBuffersForComputations(
+      const std::vector<const HloComputation*>& computations,
+      bool is_thread_local,
+      absl::flat_hash_map<const HloComputation*,
+                          absl::flat_hash_set<const HloValue*>>*
+          buffers_to_assign_sequentially,
+      BufferAssignment* assignment);
+
+  // Returns true if buffer's live range interferences with buffer2's.
+  bool LiveRangeInterferes(const HloValue* buffer1, const HloValue* buffer2,
+                           BufferAssignment* assignment);
+
+  // Assigns pre-set assignments, if provided. These assignments will be added
+  // to assigned_buffers and skip buffer allocation.
+  Status AssignPresetBuffers(
+      absl::flat_hash_set<const HloBuffer*>* assigned_buffers,
+      BufferAssignment* assignment);
+
+  // Assigns a single hlo buffer to an HLO allocation.
+  Status AssignSingleHloBuffer(
+      const HloBuffer* hlo_buffer, bool is_thread_local,
+      absl::flat_hash_map<const HloComputation*,
+                          absl::flat_hash_set<const HloValue*>>*
+          buffers_to_assign_sequentially,
+      std::vector<BufferAllocation::Index>* allocation_indices,
+      BufferAssignment* assignment);
+
+  // Assigns 'buffers_to_assign_sequentially' using heap simulation, assuming
+  // the HLO instructions will be executed in the sequential order given by
+  // assignment->liveness().hlo_ordering().SequentialOrder. If
+  // 'run_whole_module_heap_simulation' is true, the heap simulation will be run
+  // assuming all global computations are sequentially ordered.
+  Status AssignBuffersWithSequentialOrdering(
+      const absl::flat_hash_map<const HloComputation*,
+                                absl::flat_hash_set<const HloValue*>>&
+          buffers_to_assign_sequentially,
+      bool run_whole_module_heap_simulation, BufferAssignment* assignment,
+      const PrivateStacks& private_stacks,
+      GlobalDecreasingSizeBestFitHeap<HloValue>::BufferIntervalCompare
+          heap_buffer_interval_compare,
+      std::optional<BufferAssignment::BufferIsolationOptions>
+          isolation_options);
+
+  // Isolates the buffers packed by heap simulator using the provided isolation
+  // options. Please see the documentation for BufferIsolationConfig for more
+  // details.
+  void IsolateHeapBuffers(
+      std::optional<BufferAssignment::BufferIsolationOptions> isolation_options,
+      const BufferAssignment* assignment, LogicalBuffer::Color color,
+      HeapSimulator::Result<HloValue>& result) const;
+
+  // Uses the results of the heap simulator to create a single allocation, with
+  // LogicalBuffers packed to specific offsets.
+  void AssignBuffersFromHeapSimulator(
+      HeapSimulator::Result<HloValue>& result, BufferAssignment* assignment,
+      LogicalBuffer::Color color,
+      std::optional<BufferAssignment::BufferIsolationOptions>
+          isolation_options);
+
+  // Tries to assign the given instruction to the given buffer. Returns if the
+  // assignment was successful.
+  bool MaybeAssignBuffer(BufferAllocation* allocation, const HloBuffer& buffer,
+                         BufferAssignment* assignment);
+
+  // Split a set of buffers into several sets, each of which contains buffers
+  // colored with the same color.
+  absl::flat_hash_map<LogicalBuffer::Color,
+                      absl::flat_hash_set<const HloValue*>>
+  SplitBuffersByColor(
+      const absl::flat_hash_set<const HloValue*>& buffers) const;
+
+  // Split a set of buffers into several sets, each of which contains buffers
+  // with defining instructions that are dominated by the given private stack
+  // computation. This function CHECK-fails if there are outstanding buffers
+  // that do not have a dominating private stack computation.
+  absl::flat_hash_map<const HloComputation*,
+                      absl::flat_hash_set<const HloValue*>>
+  SplitBuffersByPrivateStackComputation(
+      const absl::flat_hash_set<const HloValue*>& buffers,
+      absl::Span<const HloComputation* const> private_stack_computations,
+      const CallGraph& call_graph) const;
+
+  // If true, allocate buffers for constant instructions.
+  bool allocate_buffers_for_constants_;
+
+  // Functor used to assign colors to newly allocated logical buffers.
+  Colorer colorer_;
+
+  // An optional function that returns true if the given instruction can't live
+  // out of a computation.
+  std::optional<MustNotLiveOut> must_not_live_out_;
+
+  // Description of any buffer offsets that are already set by an earlier pass.
+  std::unique_ptr<memory_space_assignment::PresetAssignments>
+      preset_assignments_;
+
+  BufferAssigner(const BufferAssigner&) = delete;
+  BufferAssigner& operator=(const BufferAssigner&) = delete;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_BUFFER_ASSIGNMENT_H_

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

@@ -0,0 +1,416 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: xla/service/buffer_assignment.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fbuffer_5fassignment_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fbuffer_5fassignment_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>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_xla_2fservice_2fbuffer_5fassignment_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_2fbuffer_5fassignment_2eproto {
+  static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_xla_2fservice_2fbuffer_5fassignment_2eproto;
+namespace xla {
+namespace buffer_assignment {
+class BufferIsolationConfig;
+struct BufferIsolationConfigDefaultTypeInternal;
+extern BufferIsolationConfigDefaultTypeInternal _BufferIsolationConfig_default_instance_;
+}  // namespace buffer_assignment
+}  // namespace xla
+PROTOBUF_NAMESPACE_OPEN
+template<> ::xla::buffer_assignment::BufferIsolationConfig* Arena::CreateMaybeMessage<::xla::buffer_assignment::BufferIsolationConfig>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace xla {
+namespace buffer_assignment {
+
+// ===================================================================
+
+class BufferIsolationConfig final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:xla.buffer_assignment.BufferIsolationConfig) */ {
+ public:
+  inline BufferIsolationConfig() : BufferIsolationConfig(nullptr) {}
+  ~BufferIsolationConfig() override;
+  explicit PROTOBUF_CONSTEXPR BufferIsolationConfig(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  BufferIsolationConfig(const BufferIsolationConfig& from);
+  BufferIsolationConfig(BufferIsolationConfig&& from) noexcept
+    : BufferIsolationConfig() {
+    *this = ::std::move(from);
+  }
+
+  inline BufferIsolationConfig& operator=(const BufferIsolationConfig& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline BufferIsolationConfig& operator=(BufferIsolationConfig&& 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 BufferIsolationConfig& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const BufferIsolationConfig* internal_default_instance() {
+    return reinterpret_cast<const BufferIsolationConfig*>(
+               &_BufferIsolationConfig_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(BufferIsolationConfig& a, BufferIsolationConfig& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(BufferIsolationConfig* 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(BufferIsolationConfig* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  BufferIsolationConfig* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+    return CreateMaybeMessage<BufferIsolationConfig>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const BufferIsolationConfig& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom( const BufferIsolationConfig& from) {
+    BufferIsolationConfig::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(BufferIsolationConfig* other);
+
+  private:
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "xla.buffer_assignment.BufferIsolationConfig";
+  }
+  protected:
+  explicit BufferIsolationConfig(::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 {
+    kIsolationColorsFieldNumber = 5,
+    kBaseOffsetBytesFieldNumber = 1,
+    kIsolationFuelFieldNumber = 2,
+    kIsolationPaddingBytesFieldNumber = 3,
+    kIsolationOrderSaltFieldNumber = 4,
+  };
+  // repeated int32 isolation_colors = 5;
+  int isolation_colors_size() const;
+  private:
+  int _internal_isolation_colors_size() const;
+  public:
+  void clear_isolation_colors();
+  private:
+  int32_t _internal_isolation_colors(int index) const;
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      _internal_isolation_colors() const;
+  void _internal_add_isolation_colors(int32_t value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      _internal_mutable_isolation_colors();
+  public:
+  int32_t isolation_colors(int index) const;
+  void set_isolation_colors(int index, int32_t value);
+  void add_isolation_colors(int32_t value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+      isolation_colors() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+      mutable_isolation_colors();
+
+  // int64 base_offset_bytes = 1;
+  void clear_base_offset_bytes();
+  int64_t base_offset_bytes() const;
+  void set_base_offset_bytes(int64_t value);
+  private:
+  int64_t _internal_base_offset_bytes() const;
+  void _internal_set_base_offset_bytes(int64_t value);
+  public:
+
+  // int64 isolation_fuel = 2;
+  void clear_isolation_fuel();
+  int64_t isolation_fuel() const;
+  void set_isolation_fuel(int64_t value);
+  private:
+  int64_t _internal_isolation_fuel() const;
+  void _internal_set_isolation_fuel(int64_t value);
+  public:
+
+  // int64 isolation_padding_bytes = 3;
+  void clear_isolation_padding_bytes();
+  int64_t isolation_padding_bytes() const;
+  void set_isolation_padding_bytes(int64_t value);
+  private:
+  int64_t _internal_isolation_padding_bytes() const;
+  void _internal_set_isolation_padding_bytes(int64_t value);
+  public:
+
+  // uint64 isolation_order_salt = 4;
+  void clear_isolation_order_salt();
+  uint64_t isolation_order_salt() const;
+  void set_isolation_order_salt(uint64_t value);
+  private:
+  uint64_t _internal_isolation_order_salt() const;
+  void _internal_set_isolation_order_salt(uint64_t value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:xla.buffer_assignment.BufferIsolationConfig)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  struct Impl_ {
+    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > isolation_colors_;
+    mutable std::atomic<int> _isolation_colors_cached_byte_size_;
+    int64_t base_offset_bytes_;
+    int64_t isolation_fuel_;
+    int64_t isolation_padding_bytes_;
+    uint64_t isolation_order_salt_;
+    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  };
+  union { Impl_ _impl_; };
+  friend struct ::TableStruct_xla_2fservice_2fbuffer_5fassignment_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// BufferIsolationConfig
+
+// int64 base_offset_bytes = 1;
+inline void BufferIsolationConfig::clear_base_offset_bytes() {
+  _impl_.base_offset_bytes_ = int64_t{0};
+}
+inline int64_t BufferIsolationConfig::_internal_base_offset_bytes() const {
+  return _impl_.base_offset_bytes_;
+}
+inline int64_t BufferIsolationConfig::base_offset_bytes() const {
+  // @@protoc_insertion_point(field_get:xla.buffer_assignment.BufferIsolationConfig.base_offset_bytes)
+  return _internal_base_offset_bytes();
+}
+inline void BufferIsolationConfig::_internal_set_base_offset_bytes(int64_t value) {
+  
+  _impl_.base_offset_bytes_ = value;
+}
+inline void BufferIsolationConfig::set_base_offset_bytes(int64_t value) {
+  _internal_set_base_offset_bytes(value);
+  // @@protoc_insertion_point(field_set:xla.buffer_assignment.BufferIsolationConfig.base_offset_bytes)
+}
+
+// int64 isolation_fuel = 2;
+inline void BufferIsolationConfig::clear_isolation_fuel() {
+  _impl_.isolation_fuel_ = int64_t{0};
+}
+inline int64_t BufferIsolationConfig::_internal_isolation_fuel() const {
+  return _impl_.isolation_fuel_;
+}
+inline int64_t BufferIsolationConfig::isolation_fuel() const {
+  // @@protoc_insertion_point(field_get:xla.buffer_assignment.BufferIsolationConfig.isolation_fuel)
+  return _internal_isolation_fuel();
+}
+inline void BufferIsolationConfig::_internal_set_isolation_fuel(int64_t value) {
+  
+  _impl_.isolation_fuel_ = value;
+}
+inline void BufferIsolationConfig::set_isolation_fuel(int64_t value) {
+  _internal_set_isolation_fuel(value);
+  // @@protoc_insertion_point(field_set:xla.buffer_assignment.BufferIsolationConfig.isolation_fuel)
+}
+
+// int64 isolation_padding_bytes = 3;
+inline void BufferIsolationConfig::clear_isolation_padding_bytes() {
+  _impl_.isolation_padding_bytes_ = int64_t{0};
+}
+inline int64_t BufferIsolationConfig::_internal_isolation_padding_bytes() const {
+  return _impl_.isolation_padding_bytes_;
+}
+inline int64_t BufferIsolationConfig::isolation_padding_bytes() const {
+  // @@protoc_insertion_point(field_get:xla.buffer_assignment.BufferIsolationConfig.isolation_padding_bytes)
+  return _internal_isolation_padding_bytes();
+}
+inline void BufferIsolationConfig::_internal_set_isolation_padding_bytes(int64_t value) {
+  
+  _impl_.isolation_padding_bytes_ = value;
+}
+inline void BufferIsolationConfig::set_isolation_padding_bytes(int64_t value) {
+  _internal_set_isolation_padding_bytes(value);
+  // @@protoc_insertion_point(field_set:xla.buffer_assignment.BufferIsolationConfig.isolation_padding_bytes)
+}
+
+// uint64 isolation_order_salt = 4;
+inline void BufferIsolationConfig::clear_isolation_order_salt() {
+  _impl_.isolation_order_salt_ = uint64_t{0u};
+}
+inline uint64_t BufferIsolationConfig::_internal_isolation_order_salt() const {
+  return _impl_.isolation_order_salt_;
+}
+inline uint64_t BufferIsolationConfig::isolation_order_salt() const {
+  // @@protoc_insertion_point(field_get:xla.buffer_assignment.BufferIsolationConfig.isolation_order_salt)
+  return _internal_isolation_order_salt();
+}
+inline void BufferIsolationConfig::_internal_set_isolation_order_salt(uint64_t value) {
+  
+  _impl_.isolation_order_salt_ = value;
+}
+inline void BufferIsolationConfig::set_isolation_order_salt(uint64_t value) {
+  _internal_set_isolation_order_salt(value);
+  // @@protoc_insertion_point(field_set:xla.buffer_assignment.BufferIsolationConfig.isolation_order_salt)
+}
+
+// repeated int32 isolation_colors = 5;
+inline int BufferIsolationConfig::_internal_isolation_colors_size() const {
+  return _impl_.isolation_colors_.size();
+}
+inline int BufferIsolationConfig::isolation_colors_size() const {
+  return _internal_isolation_colors_size();
+}
+inline void BufferIsolationConfig::clear_isolation_colors() {
+  _impl_.isolation_colors_.Clear();
+}
+inline int32_t BufferIsolationConfig::_internal_isolation_colors(int index) const {
+  return _impl_.isolation_colors_.Get(index);
+}
+inline int32_t BufferIsolationConfig::isolation_colors(int index) const {
+  // @@protoc_insertion_point(field_get:xla.buffer_assignment.BufferIsolationConfig.isolation_colors)
+  return _internal_isolation_colors(index);
+}
+inline void BufferIsolationConfig::set_isolation_colors(int index, int32_t value) {
+  _impl_.isolation_colors_.Set(index, value);
+  // @@protoc_insertion_point(field_set:xla.buffer_assignment.BufferIsolationConfig.isolation_colors)
+}
+inline void BufferIsolationConfig::_internal_add_isolation_colors(int32_t value) {
+  _impl_.isolation_colors_.Add(value);
+}
+inline void BufferIsolationConfig::add_isolation_colors(int32_t value) {
+  _internal_add_isolation_colors(value);
+  // @@protoc_insertion_point(field_add:xla.buffer_assignment.BufferIsolationConfig.isolation_colors)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+BufferIsolationConfig::_internal_isolation_colors() const {
+  return _impl_.isolation_colors_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
+BufferIsolationConfig::isolation_colors() const {
+  // @@protoc_insertion_point(field_list:xla.buffer_assignment.BufferIsolationConfig.isolation_colors)
+  return _internal_isolation_colors();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+BufferIsolationConfig::_internal_mutable_isolation_colors() {
+  return &_impl_.isolation_colors_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
+BufferIsolationConfig::mutable_isolation_colors() {
+  // @@protoc_insertion_point(field_mutable_list:xla.buffer_assignment.BufferIsolationConfig.isolation_colors)
+  return _internal_mutable_isolation_colors();
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace buffer_assignment
+}  // namespace xla
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_xla_2fservice_2fbuffer_5fassignment_2eproto

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

@@ -0,0 +1,183 @@
+/* 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_BUFFER_VALUE_H_
+#define XLA_SERVICE_BUFFER_VALUE_H_
+
+#include <functional>
+#include <string>
+
+#include "absl/types/span.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/service/hlo.pb.h"
+#include "xla/shape_util.h"
+#include "xla/types.h"
+#include "xla/xla_data.pb.h"
+#include "tsl/platform/logging.h"
+
+namespace xla {
+
+// Abstract class describing a value used by one of the dataflow analyses -
+// TuplePointsToAnalysis or HloDataflowAnalysis.
+// TODO(b/78906445) Delete this class when TuplePointsToAnalysis is unused.
+//
+// XLA arrays are trivially a single BufferValue. Tuples are made up of more
+// than one BufferValue: an BufferValue for the pointer vector, and an
+// BufferValue for each child element.
+//
+// Every BufferValue is defined by a particular instruction and most
+// instructions define only a single BufferValue. Instructions which define a
+// single BufferValue include array-shaped instructions such as Add but also
+// includes Tuple-shaped instructions such as Tuple. The Tuple instruction
+// defines a single BufferValue which is a vector of pointers to the values
+// containing the Tuple instruction's operands. Though the result of the Tuple
+// instruction includes multiple values only the top-level BufferValue (the
+// vector of pointers) is defined by the Tuple instruction. The values
+// containing the tuple elements are defined by earlier instructions, usually
+// the operands of the Tuple instruction.
+//
+// Instructions which construct both the tuple *and* the tuple elements define
+// more than one BufferValue. This includes (at least) tuple-shaped Constant,
+// Parameter, Infeed and While instructions. These tuple-shaped instructions do
+// not assemble a tuple from existing BufferValues like the Tuple instruction
+// does, but rather define all the BufferValues in the tuple.
+//
+// Some instructions, such as Bitcast, define no buffers. These instructions
+// simply forward buffers from their operands.
+//
+// The BufferValue object describes which HLO instruction defines a buffer and
+// where within that instruction's output shape the buffer is defined. The
+// location within the output shape is indicated by BufferValue::index() which
+// is defined identically to the index used in ShapeUtil::GetSubshape().
+// Examples:
+//
+// %add = Add(%foo, %bar)
+// %tuple_constant = Constant({1, {42, 43}})
+//
+// %add defines a single array-shaped buffer BufferValue(%add, {}) which holds
+// the array result of the add operation. The nested-tuple-shaped
+// %tuple_constant defines 5 buffers described by the following BufferValue
+// objects:
+//
+//   BufferValue(%tuple_constant, {})      // "Top-level" buffer: vector of
+//                                         //  pointers to BufferValues at
+//                                         //  indices {0} and {1}
+//   BufferValue(%tuple_constant, {0})     // Holds value "1"
+//   BufferValue(%tuple_constant, {1})     // Holds nested tuple: vector of
+//                                         //  pointers to BufferValues at
+//                                         //  indices {1, 0} and {1, 1}
+//   BufferValue(%tuple_constant, {1, 0})  // Holds value "42"
+//   BufferValue(%tuple_constant, {1, 1})  // Holds value "43"
+
+class BufferValue {
+ public:
+  using Color = int64_t;
+
+  // Id is a unique identifier for the BufferValue to facilitate efficient
+  // collections of BufferValues with stable iteration order.
+  using Id = int64_t;
+
+  // Functions which return the size and alignment of a logical buffer in bytes.
+  using SizeFunction = std::function<int64_t(const BufferValue&)>;
+  using AlignmentFunction = std::function<int64_t(BufferValue::Color)>;
+
+  // Prevent value being copied, allowing comparison by pointer,
+  BufferValue(const BufferValue&) = delete;
+  BufferValue& operator=(const BufferValue&) = delete;
+  // ... but allow moves.
+  BufferValue(BufferValue&&) = default;
+  BufferValue& operator=(BufferValue&&) = default;
+
+  virtual ~BufferValue() {}
+
+  Id id() const { return id_; }
+
+  // Return the instruction that defines the buffer.
+  virtual HloInstruction* instruction() const = 0;
+
+  // Return the index within the output of the instruction where the buffer is
+  // defined. Index used defined as in ShapeUtil::GetSubshape()
+  virtual const ShapeIndex& index() const = 0;
+
+  // Return the color of the BufferValue. Differently colored buffers can not be
+  // parts of the same allocation.
+  ABSL_DEPRECATED("Use Layout::memory_space instead.")
+  Color color() const {
+    CHECK_NE(color_, kInvalidColor)
+        << "Should not query the color of a buffer that was never colored";
+    return color_;
+  }
+
+  ABSL_DEPRECATED("Use Layout::memory_space instead.")
+  void set_color(Color color) {
+    CHECK_NE(color, kInvalidColor)
+        << "Should not set the color of a buffer to the invalid color";
+    color_ = color;
+  }
+
+  ABSL_DEPRECATED("Use Layout::memory_space instead.")
+  bool has_color() const { return color_ != kInvalidColor; }
+
+  // Return the shape of the buffer. This reference points into the shape field
+  // of the instruction defining the buffer.  Therefore, the returned shape will
+  // contain the layout of instruction, if any.
+  virtual const Shape& shape() const = 0;
+
+  // Returns true if this buffer is the top-level output buffer of the defining
+  // HLO instruction. This is equivalent to index == {}.
+  bool IsTopLevel() const { return index().empty(); }
+
+  // Whether this buffer contains a tuple.
+  bool IsTuple() const { return is_tuple_; }
+
+  // Whether this buffer contains an array.
+  bool IsArray() const { return is_array_; }
+
+  bool operator<(const BufferValue& other) const { return id_ < other.id_; }
+
+  virtual std::string ToString() const = 0;
+
+  // TODO(lauj) rename LogicalBufferProto to BufferValueProto.
+  LogicalBufferProto ToProto(const SizeFunction& size_fn) const;
+
+  // Returns the LogicalBufferProto::Location that serializes the given
+  // instruction and index.
+  static LogicalBufferProto::Location ToLocationProto(
+      const HloInstruction& instruction, const ShapeIndex& index);
+
+  static constexpr Color kInvalidColor = -1;
+
+ protected:
+  BufferValue(HloInstruction* instruction, const ShapeIndex& index, Id id);
+
+ private:
+  // The defining instruction and index are not stored here; they can be found
+  // in the LogicalBuffer and HloValue subclasses. This class exists only to
+  // support migrations from TuplePointsToAnalysis to HloDataflowAnalysis, by
+  // allowing abstract use of LogicalBuffer or HloValue. After those migrations
+  // are complete, this class should be deleted (b/78906445). Because we plan to
+  // delete LogicalBuffer and this class, we don't refactor all the shared
+  // features from LogicalBuffer and HloValue into this class.
+  Id id_ : 62;
+  bool is_array_ : 1;
+  bool is_tuple_ : 1;
+  Color color_ = kInvalidColor;
+};
+
+std::ostream& operator<<(std::ostream& out, const BufferValue& buffer);
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_BUFFER_VALUE_H_

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

@@ -0,0 +1,55 @@
+/* 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_BUFFER_VALUE_CONTAINERS_H_
+#define XLA_SERVICE_BUFFER_VALUE_CONTAINERS_H_
+
+#include "absl/container/flat_hash_set.h"
+#include "xla/service/buffer_value.h"
+#include "xla/service/logical_buffer.h"
+#include "tsl/lib/gtl/compactptrset.h"
+
+namespace xla {
+
+// Define various containers of BufferValues, and utilities to convert from
+// containers of LogicalBuffers to containers of BufferValues.
+
+using BufferValueCompactPointerSet =
+    tsl::gtl::CompactPointerSet<const BufferValue*>;
+template <class LogicalBufferContainerT>
+BufferValueCompactPointerSet ToBufferValueCompactPointerSet(
+    const LogicalBufferContainerT& logical_buffer_container) {
+  BufferValueCompactPointerSet output;
+  for (const LogicalBuffer* buffer : logical_buffer_container) {
+    output.insert(buffer);
+  }
+  return output;
+}
+
+using BufferValueFlatSet = absl::flat_hash_set<const BufferValue*>;
+template <class LogicalBufferContainerT>
+BufferValueFlatSet ToBufferValueFlatSet(
+    const LogicalBufferContainerT& logical_buffer_container) {
+  BufferValueFlatSet output;
+  output.reserve(logical_buffer_container.size());
+  for (const LogicalBuffer* buffer : logical_buffer_container) {
+    output.insert(buffer);
+  }
+  return output;
+}
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_BUFFER_VALUE_CONTAINERS_H_

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

@@ -0,0 +1,386 @@
+/* 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.
+==============================================================================*/
+
+// Call graph for an HLO module.
+
+#ifndef XLA_SERVICE_CALL_GRAPH_H_
+#define XLA_SERVICE_CALL_GRAPH_H_
+
+#include <memory>
+#include <ostream>
+
+#include "absl/container/flat_hash_map.h"
+#include "absl/container/flat_hash_set.h"
+#include "absl/functional/function_ref.h"
+#include "xla/hlo/ir/hlo_computation.h"
+#include "xla/hlo/ir/hlo_instruction.h"
+#include "xla/hlo/ir/hlo_module.h"
+
+namespace xla {
+
+// The context in which a computation is called by another computation.
+enum class CallContext {
+  // In an embedded call context, the body of the function cannot allocate
+  // buffers.
+  kEmbedded,
+
+  // A control flow call context can allocate buffers.
+  kControlFlow,
+
+  // A computation is called from both an embedded and control flow context.
+  kBoth,
+
+  // During call graph construction kNone is used to indicate that the context
+  // has not been determined. This is the top value for the context
+  // lattice. After construction, no call sites or call graph nodes should have
+  // this value.
+  kNone
+};
+
+std::string CallContextToString(CallContext context);
+std::ostream& operator<<(std::ostream& out, const CallContext& context);
+
+CallContext GetInstructionCallContext(HloOpcode opcode);
+
+// Represents an HLO instruction which calls one or more computations.
+class CallSite {
+ public:
+  CallSite(HloInstruction* instruction,
+           absl::Span<HloComputation* const> called_computations,
+           CallContext context)
+      : instruction_(CHECK_NOTNULL(instruction)),
+        called_computations_(called_computations.begin(),
+                             called_computations.end()),
+        context_(context) {}
+
+  // Returns the instruction associated with this call site.
+  HloInstruction* instruction() const { return instruction_; }
+
+  // Returns the computations called at this call site.
+  absl::Span<HloComputation* const> called_computations() const {
+    return called_computations_;
+  }
+
+  // Returns the context in which computations are called at this call site.
+  CallContext context() const { return context_; }
+
+  std::string ToString() const;
+
+ private:
+  // The calling instruction.
+  HloInstruction* instruction_;
+
+  // The computations called by this callsite.
+  const absl::InlinedVector<HloComputation*, 2> called_computations_;
+
+  // The context in which the computations are called.
+  const CallContext context_;
+};
+
+// A node in the call graph representing an HLO computation.
+class CallGraphNode {
+ public:
+  explicit CallGraphNode(HloComputation* computation);
+
+  // Returns the computation represented by this call graph node.
+  HloComputation* computation() const { return computation_; }
+
+  // Returns the call sites in this computation. These are the instructions in
+  // this computation which call other computations.
+  absl::Span<const CallSite> callsites() const { return callsites_; }
+
+  // Returns the callsite associated with the given instruction. If this
+  // instruction calls no computations nullptr is returned.
+  // Prerequisite: instruction is in the computation associated with this call
+  // graph node.
+  const CallSite* GetCallSite(const HloInstruction* instruction) const;
+
+  // Returns the computations called by this computation.
+  absl::Span<HloComputation* const> callees() const { return callees_; }
+
+  // Returns the call sites in other computations which call this computation.
+  absl::Span<const CallSite> caller_callsites() const {
+    return caller_callsites_;
+  }
+
+  // Returns the computations which call this computation.
+  absl::Span<HloComputation* const> callers() const { return callers_; }
+
+  // Returns the context in which this computation is called.
+  CallContext context() const { return context_; }
+
+  // Returns the depth of this node in the call graph. The depth is defined as
+  // the length of the longest call chain from a computation with no callers
+  // (usually the entry computation node) to this node.
+  int depth() const { return depth_; }
+
+  absl::string_view ToString() const;
+
+  CallGraphNode(const CallGraphNode&) = delete;
+  CallGraphNode& operator=(const CallGraphNode&) = delete;
+  CallGraphNode(CallGraphNode&&) = default;
+  CallGraphNode& operator=(CallGraphNode&&) = default;
+
+ private:
+  // Only CallGraph can modify CallGraphNode.
+  friend class CallGraph;
+
+  // Sets the context in which this computation is called.
+  void set_context(CallContext value) { context_ = value; }
+
+  // Sets the depth of this node in the graph.
+  void set_depth(int value) { depth_ = value; }
+
+  // Adds a callsite which calls this computation. Updates callers to include
+  // the calling computation.
+  void AddCallerCallSite(const CallSite& caller_callsite);
+
+  // If instruction calls any computations adds a call site for this instruction
+  // to the call graph node. If the instruction calls no computations then no
+  // call site is added.
+  void AddCallSiteForInstruction(
+      HloInstruction* instruction,
+      const absl::flat_hash_set<absl::string_view>& execution_threads = {});
+
+  // Computation represented by this call graph node.
+  HloComputation* computation_;
+
+  // The computations called by this computation. The vector is used for a
+  // stable ordering and the set enables fast membership testing.
+  absl::InlinedVector<HloComputation*, 1> callees_;
+  absl::flat_hash_set<HloComputation*> callee_set_;
+
+  // The computations which call this computation. The vector is used for a
+  // stable ordering and the set enables fast membership testing.
+  absl::InlinedVector<HloComputation*, 1> callers_;
+  absl::flat_hash_set<HloComputation*> caller_set_;
+
+  // The call sites in this computation
+  absl::InlinedVector<CallSite, 1> callsites_;
+
+  // The map from instruction to index in callsites_ for looking up the callsite
+  // (if any) associated with a particular instruction in this computation.
+  absl::flat_hash_map<const HloInstruction*, int64_t> callsite_instructions_;
+
+  // The call sites in other computations which call this computation.
+  absl::InlinedVector<CallSite, 1> caller_callsites_;
+
+  // The context in which this computation is called.
+  CallContext context_ = CallContext::kNone;
+
+  // The depth of this node in the call graph.
+  int depth_ = 0;
+};
+
+// The call graph for an HLO module. The graph includes a node for each
+// computation in the module.
+class CallGraph {
+ public:
+  using VisitorFunction = absl::FunctionRef<Status(const CallGraphNode&)>;
+
+  // Builds and returns a call graph for the given HLO module. If a non-empty
+  // execution_threads is provided, only computations that are in
+  // execution_threads will be part of the returned call graph.
+  static std::unique_ptr<CallGraph> Build(
+      const HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads = {});
+
+  // Returns the node associated with the given computation.
+  const CallGraphNode& GetNode(const HloComputation* computation) const;
+  CallGraphNode& GetNode(const HloComputation* computation);
+
+  // Returns the vector of all nodes in the call graph.
+  const std::vector<CallGraphNode>& nodes() const { return nodes_; }
+
+  // Calls the given function on each node in the call graph. Nodes are visited
+  // in post order (callees before callers). If visit_unreachable_nodes is true
+  // then all nodes in the call graph are visited. Otherwise only those nodes
+  // reachable from the entry computation are visited.
+  Status VisitNodes(VisitorFunction visitor_func,
+                    bool visit_unreachable_nodes = true) const;
+
+  // Returns true if 'a' dominates 'b' in the call graph. Computation 'a'
+  // dominates computation 'b' iff all callgraph paths in the caller-to-callee
+  // direction from a root computation to 'b' pass through computation
+  // 'a'. Trivially, a computation dominates itself.
+  bool Dominates(const HloComputation* a, const HloComputation* b) const;
+
+  // Returns whether 'instruction' is contained in 'computation' either directly
+  // ('instruction->parent' is 'computation') or indirectly ('computation'
+  // dominates 'instruction->parent' in the call graph).
+  bool InstructionIsNestedIn(const HloInstruction* instruction,
+                             const HloComputation* computation) const {
+    return Dominates(computation, instruction->parent());
+  }
+
+  // Returns the nearest call graph ancestors of instructions 'a' and 'b' for
+  // which the ancestors are in the same computation. An instruction is an call
+  // graph ancestor of 'a' if the instruction calls the computation containing
+  // 'a' either directly or transitively. Degeneratively an instruction is an
+  // ancestor of itself. nullptr is returned if there is no common ancestor or
+  // if the caller chain of 'a' or 'b' diverges (has multiple callers) before
+  // the nearest common ancestor.
+  //
+  // Example:
+  //
+  // Entry computation:
+  //   %x = Call(A, {Constant(42.0)})
+  //   %y = Call(B, {%x})
+  //
+  // Computation A:
+  //   %a = Negate(Param())
+  //
+  // Computation B:
+  //   %b = Exp(Param());
+  //
+  // If called with %a and %b, this function would return (%x, %y). %x is an
+  // ancestor of %a, and %y is an ancestor of %b, and %x and %y are in the same
+  // computation.
+  std::pair<HloInstruction*, HloInstruction*> NearestAncestorsInSameComputation(
+      HloInstruction* a, HloInstruction* b) const;
+
+  // Given a set of instructions within a computation, returns nearest common
+  // ancestors as Hlo instructions (There could be multiple nearest common
+  // ancestors in a DAG). If the given instructions are not in the same
+  // computation, this function would report FAILURE.
+  //
+  // Unlike the `NearestAncestorsInSameComputation` defined above, it:
+  //
+  // (1) Only compute the nearest common ancestors within a computation, instead
+  // of across computations (that's the function
+  // `ComputationsNearestCommonAncestors` that defined below).
+  //
+  // (2) Takes in **a set of** Hlo instructions, instead of two Hlo
+  // instructions, and find their nearest common ancestors.
+  //
+  // Example:
+  //
+  // Computation A:
+  //   %p0   = Param(0)
+  //   %p1   = Param(1)
+  //   %p2   = Param(2)
+  //   %add0 = Add(%p0, %p1)
+  //   %mul0 = Mul(%p1, %p2)
+  //   %sub0 = Sub(%add0, %mul0)
+  //
+  // If called with {%p0, %p1}, this function would return {%add0}.
+  //
+  // Please check the detailed example in
+  // `CallGraphTest.NearestCommonAncestorInstructions`.
+  absl::flat_hash_set<const HloInstruction*> NearestCommonAncestorInstructions(
+      std::vector<const HloInstruction*> instructions);
+
+  // Given a set of computations within a module, returns nearest common
+  // ancestors as Hlo computations (There could be multiple nearest common
+  // ancestors in a DAG).
+  //
+  // Entry_computation:
+  //   %x = Call(A, {Constant(42.0)})
+  //   %y = Call(B, {%x})
+  //
+  // Computation_A:
+  //   %a = Negate(Param())
+  //
+  // Computation_B:
+  //   %b = Exp(Param());
+  //
+  // If called with {Computation_A, Computation_B}, this function would return
+  // {Entry_computation}.
+  //
+  // Please check the detailed example in
+  // `CallGraphTest.NearestCommonAncestorComputations`.
+  absl::flat_hash_set<const HloComputation*> NearestCommonAncestorComputations(
+      std::vector<const HloComputation*> computations);
+
+  // A template helper function that computes the nearest common ancestors among
+  // instructions/computations. `T` can be either `HloInstruction` or
+  // `HloComputation`. Computing nearest common ancestors are basically the same
+  // for HloInstruction and HloComputation. The only difference is that they
+  // require different ways to access the ancestors of one node. Specifically,
+  // the ancestors are users_instruction for instructions, and are
+  // caller_computations for computations.
+  //
+  // The overall idea is to conduct BFS from the `starting_nodes`, and keep
+  // track of the visited ancestors of each node. For each BFS step, we check if
+  // there is a common node in all the visited ancestors, and if yes, that
+  // common node is the nearest ancestor we are looking for. Note that, since we
+  // are traversing DAG, there could be multiple nearest common ancestors. And
+  // there must be at least one common ancestor (i.e., entry computations among
+  // computations or root instruction among instructions).
+  template <typename T>
+  absl::flat_hash_set<const T*> NearestCommonAncestorsHelper(
+      std::vector<const T*>& starting_nodes);
+
+  // Returns whether the call graph is flattened. A call graph is flattened if
+  // every computation called in a sequential context (eg, kWhile or kCall) has
+  // zero or one callsite, and no computation is called from both a parallel and
+  // sequential context. The call graph of a module can be flattened with
+  // FlattenCallGraph.
+  bool IsFlattened() const;
+
+  // Returns a vector of instructions calling the passed computation.
+  // (Often a vector of size 1.)
+  std::vector<HloInstruction*> GetComputationCallers(
+      const HloComputation* c) const;
+
+  std::string ToString() const;
+
+ private:
+  explicit CallGraph(
+      const HloModule* module,
+      const absl::flat_hash_set<absl::string_view>& execution_threads = {});
+
+  // Not copyable.
+  CallGraph(const CallGraph&) = delete;
+  CallGraph& operator=(const CallGraph&) = delete;
+
+  // Sets the call contexts for every node in the graph.
+  void SetCallContexts();
+
+  // Sets the call node depths for every node in the graph.
+  void SetNodeDepths();
+
+  // Helper method for VisitNodes(). Traverses the call graph from 'node' in DFS
+  // post order (callee before caller) calling visitor_func on each node. Adds
+  // nodes to 'visited' as each node is visited. Skips nodes already in
+  // 'visited'.
+  Status VisitNodesInternal(
+      VisitorFunction visitor_func, const CallGraphNode& node,
+      absl::flat_hash_set<const CallGraphNode*>* visited) const;
+
+  // Recursive helper for computing whether 'a' dominates 'b' in the call
+  // graph. 'b_ancestor' is the currently visited node (which starts at 'b'),
+  // and 'visited' is the set of computations which have been visited.
+  bool DominatesHelper(
+      const HloComputation* a, const HloComputation* b,
+      absl::flat_hash_set<const HloComputation*>* visited) const;
+
+  // The HLO module represented by this call graph.
+  const HloModule* module_ = nullptr;
+
+  // Vector of all nodes in the call graph.
+  std::vector<CallGraphNode> nodes_;
+
+  // Map from HLO computation to the index of the corresponding call graph node
+  // in nodes_.
+  absl::flat_hash_map<const HloComputation*, int64_t> node_indices_;
+
+  // The execution threads that the call graph is built for.
+  absl::flat_hash_set<absl::string_view> execution_threads_;
+};
+
+}  // namespace xla
+
+#endif  // XLA_SERVICE_CALL_GRAPH_H_