std::vector<std::unique_ptr<tac::TargetHardware>> InstantiateBackends();

  std::unique_ptr<TacImporter> importer_;
  std::unique_ptr<TacExporter> exporter_;
  // Owned list of all target hardware backends.
  std::vector<std::unique_ptr<tac::TargetHardware>> backends_;
  // Holder for const pointers for the data in 'backends_'
  std::vector<const tac::TargetHardware*> const_backends_;

// define static member variable that retrieves string identifying the Target
// Hardware. Example,
// class MyType : public TargetHardware {
//  public:
//   static constexpr char kId[] = "MyHardware";
// };
class TargetHardware {
 public:
  virtual ~TargetHardware() = default;

  // Initializes all TargetHardwareOperation registered for this hardware.

class GpuHardware : public TargetHardware {
 public:
  static constexpr char kId[] = "GPU";
  mlir::RewritePatternSet GetTransformations(
      MLIRContext* context) const override;

  mlir::TypeID GetTypeId() const override {
    return mlir::TypeID::get<GpuHardware>();
  }

  double GetHardwareSwitchingCost(const TargetHardware* from,

namespace tac {

bool SimpleHardware::IsOpSupported(mlir::Operation* op) const {
  if (IsNotSupportedOp(op)) {
    return false;
  }
  const TargetHardware* cpu = GetTargetHardware("CPU");
  return cpu->IsOpSupported(op);
}

double SimpleHardware::GetHardwareSwitchingCost(const TargetHardware* from,
                                                size_t buffer_size) const {
  auto from_type = from->GetTypeId();
  auto to_type = GetTypeId();

  if (failed(pm.run(*module))) {
    return absl::InternalError("conversion error");
  }
  return absl::OkStatus();
}

std::vector<std::unique_ptr<tac::TargetHardware>>
TacModule::InstantiateBackends() {
  std::vector<std::unique_ptr<tac::TargetHardware>> backends;
  for (const auto& hardware_name : options_.hardware_backends) {
    auto factory = tac::GetTargetHardwareFactory(hardware_name);

// can also specify the advantage over CPU.
//
// If you need more customization, e.g., if you have your own hardware dialect,
// please consider use TargetHardware directly.
class SimpleHardware : public TargetHardware {
 public:
  // This is essentially a denylist.
  // TODO(renjieliu): Consider whether we want an allowlist for custom op as
  // well.

// This is used by TAC to get op supported/ op cost estimates on CPU.
class CpuHardware : public TargetHardware {
 public:
  MLIR_DEFINE_EXPLICIT_INTERNAL_INLINE_TYPE_ID(CpuHardware)

  // String Identifier for CPU hardware.
  static constexpr char kId[] = "CPU";

  double GetHardwareSwitchingCost(const TargetHardware* from,
                                  size_t buffer_size) const override {

  mlir::RewritePatternSet patterns(context);

  patterns.add<LowerPackIntoConcatReshape, UnrollSplit, UnrollSplitV, PadSlice,
               PadConcat>(context);
  return patterns;
}

std::unique_ptr<TargetHardware> CreateExampleHardware() {
  return std::make_unique<ExampleHardware>();
}

TargetHardwareRegistration<ExampleHardware> example_hardware(
    "Example device", CreateExampleHardware);

}  // namespace tac

               EnsureBiasForConv2d, PadSlice, FullyConnectedToConv, PadConcat,
               SquaredDifference>(context);
  return patterns;
}

double GpuHardware::GetHardwareSwitchingCost(const TargetHardware* from,
                                             size_t buffer_size) const {
  auto from_type = from->GetTypeId();
  auto to_type = GetTypeId();
  if (from_type == to_type) return 0.0f;

  explicit TacPass(const TacModule* module)
      : OperationPass<T>::OperationPass(mlir::TypeID::get<T>()),
        module_(module) {}

  ~TacPass() override = default;

  const TargetHardware* GetTargetHardware(
      const std::string& hardware_name) const {
    return module_ != nullptr
               ? module_->GetTargetHardware(hardware_name)
               : mlir::TFL::tac::GetTargetHardware(hardware_name);