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.

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

// 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);

  patterns.add<SquaredDifference, LowerPackIntoConcatReshape,
               ReduceMeanToAvgPool, InsertRequantForReduceMean>(context);
  return patterns;
}

std::unique_ptr<TargetHardware> CreateNNAPIHardware() {
  return std::make_unique<NNAPIHardware>();
}

TargetHardwareRegistration<NNAPIHardware> nnapi_hardware(
    "Target device for NNAPI", CreateNNAPIHardware);