// By default this is the sum of the cost of individual cost for each op.
  virtual double GetFuncCost(func::FuncOp* func) const;

  // Returns true if 'op' can run on this Hardware.
  virtual bool IsOpSupported(mlir::Operation* op) const;

  // Switching cost between from hardware and this hardware.
  // If both the hardwares are the same, the transfer cost is basically 0.

  return GetInferenceTypeEnum(device_name_str);
}

// InferenceDeviceType is a combination of the hardware with inference type.
struct InferenceDeviceType {
  std::string hardware;
  InferenceType inference_type;

  bool operator==(const InferenceDeviceType& other) const {
    return (hardware == other.hardware) &&
           (inference_type == other.inference_type);
  }

      auto* hardware = this->GetTargetHardware(device);
      if (hardware == nullptr) continue;
      if (hardware->IsOpSupported(op)) {
        SetAnnotation(op, kDevice, device, builder);
        device_is_set = true;
        break;
      }
    }
  } else {
    for (const auto* hardware : module_->GetAvailableHardwares()) {
      if (hardware == nullptr) continue;

      auto hardware = GetTargetAnnotation(op);
      if (!hardware) return;
      float cost = GetCostForOp(op, *hardware);
      UpdateCost(op, cost, &builder);
    }
  });
}

}  // namespace

float GetCostForOp(Operation* op, const std::string& hardware) {
  auto* device_hardware = GetTargetHardware(hardware);
  if (device_hardware == nullptr) {

      }
    });
  }

  // Build the flatbuffer.
  std::vector<flatbuffers::Offset<flatbuffers::String>> hardwares;
  for (const auto& kv : *hardware_names) {
    hardwares.push_back(builder->CreateString(kv.first));
  }

  return CreateHardwareMetadata(*builder, builder->CreateVector(hardwares));
}

}  // namespace

std::optional<std::string> ExportRuntimeMetadata(mlir::ModuleOp module) {

// Get the estimated cost for the op under the given hardware spec senario.
float GetCostForOp(Operation* op, const std::string& hardware);

// Get the estimated cost for the whole function under the given hardware.
float GetCostForFunc(func::FuncOp* func, const std::string& hardware);

// Get the transfer cost given from & to hardware info.
// We will only calculate for the "necessary" tensor transferred.

namespace TFL {
namespace tac {

// Returns true if 'op' is supported to run on 'hardware'.
bool IsSupported(Operation* op, const std::string& hardware);

// Return proper rewriter patterns for different hardwares.
RewritePatternSet GetHardwareRewritePatterns(MLIRContext* context,
                                             const std::string& hardware);

// Convert quantized ops to float, this will essentially insert dequantize &

// A list of filters for TAC users to run ops/functions on ML hardwares. The
// intuition is that, for ops/functions that can be run on ML hardware (e.g.
// EdgeTPU) and TFLite CPU, TAC users give a hint that they're more performant
// to run on TFLite CPU. These filters give the TAC users freedom to specify the
// parts that they want to use other hardware to accelerate.
message TacFilters {

  absl::Status RunTacPasses(mlir::ModuleOp* module, bool debug_mode = false);

  // Create instances of all registered hardwares.
  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_;

	// reflect the CPU capabilities. Assume that every Android arm device
	// has the necessary floating point hardware available.
	if GOOS == "android" {
		return
	}
	if cpu.HWCap&_HWCAP_VFP == 0 && goarmsoftfp == 0 {
		print("runtime: this CPU has no floating point hardware, so it cannot run\n")
		print("a binary compiled for hard floating point. Recompile adding ,softfloat\n")
		print("to GOARM.\n")
		exit(1)