return std::make_unique<CpuHardware>();
}

TargetHardwareRegistration<CpuHardware> cpu_hardware("Target device for CPU",
                                                     CreateCpuHardware);

#define TAC_REGISTER_CPU_OP(Op, Create)                                    \
  TargetHardwareOpRegistration<CpuHardware, Op> Op##_CpuHardware_hardware( \
      Create);

// Operation costs on CPU

// Currently used for these ops:

std::unique_ptr<TargetHardware> CreateGpuHardware() {
  return std::make_unique<GpuHardware>();
}

TargetHardwareRegistration<GpuHardware> gpu_hardware("Target device for GPU",
                                                     CreateGpuHardware);

#define TAC_REGISTER_GPU_OP(Op, Create)                                    \
  TargetHardwareOpRegistration<GpuHardware, Op> Op##_GpuHardware_hardware( \
      Create);

// This is used by TAC to get op supported/ op cost estimates on GPU.
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,

  (void)applyPatternsAndFoldGreedily(func, std::move(patterns));
}

}  // namespace

RewritePatternSet GetHardwareRewritePatternsGPU(MLIRContext* context) {
  GpuHardware gpu_hardware;
  return gpu_hardware.GetTransformations(context);
}

std::unique_ptr<OperationPass<func::FuncOp>> CreateDeviceTransformGPUPass() {
  return std::make_unique<DeviceTransformGPUPass>();
}