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

 protected:
  const TacModule* module_ = nullptr;  // Not owned.
};

// A FunctionPass but with access to TAC module.

  // large functions (and maybe other metadata as well).
}

const tac::TargetHardware* TacModule::GetTargetHardware(
    const std::string& hardware_name) const {
  for (auto& hardware : backends_) {
    if (GetHardwareName(hardware.get()) == hardware_name) return hardware.get();
  }
  return nullptr;
}

absl::Status TacModule::RunTacPasses(mlir::ModuleOp* module, bool debug_mode) {

    total_cost += GetOpCost(op);
  });
  return total_cost;
}

const TargetHardware* GetTargetHardware(const std::string& hardware_name) {
  const std::string canonical_name = GetCanonicalHardwareName(hardware_name);
  // Just loop for now, we don't expect number of hardwares to be huge.
  // Revisit to have map if number of elements increased.

  std::vector<std::unique_ptr<TargetHardwareOperation>> hardware_ops_;
};

// Returns pointer to the Hardware identified by 'hardware_name'.
// If not found nullptr is returned.
// DEPRECATED: Do not use, prefer GetTargetHardwareFactory instead.
const TargetHardware* GetTargetHardware(const std::string& hardware_name);

// Returns the factory method for the requested hardware if present.

//  }
// }
table HardwareMetadata {
  // List of different hardwares this model can use.
  hardware_name:[string];
}

// Metadata for a single Op.
table OpMetadata {
  // Node index in the corresponding subgraph.
  index:int;
  // The hardware suggested for inference.
  // This will correspond to the index in the hardware_name field in the
  // hardware metadata.
  hardware:uint8;
  // The estimated costs for the given op.

    exporter_ = std::move(exporter);
  }

  // Returns pointer to the TargetHardware that is identified by 'hardware_name'
  // Returns NULL If no hardware with this name found.
  const tac::TargetHardware* GetTargetHardware(
      const std::string& hardware_name) const;

  // Runs the TAC workflow, configured as in the options provided during
  // construction.

// TODO(b/177376459): Remove this in favor of the string defined by hardwares
// MyHardware::kId.
inline std::string GetCanonicalHardwareName(const std::string& hardware_name) {
  std::string name = hardware_name;
  std::transform(
      name.begin(), name.end(), name.begin(),
      [](unsigned char c) -> unsigned char { return std::toupper(c); });
  return name;
}

  static const char* hardware_name = "TestName";
  static const char* vendor = "TestVendor";
  static const char* pci_bus_id = "TestPCIBusId";
  platform_fns_.create_device = [](const SP_Platform* platform,
                                   SE_CreateDeviceParams* params,
                                   TF_Status* status) {
    params->device->hardware_name = hardware_name;
    params->device->device_vendor = vendor;

      const override {
    OwnedTFStatus c_status(TF_NewStatus());

    internal::DeviceDescriptionBuilder builder;
    if (device_.hardware_name != nullptr) {
      builder.set_name(device_.hardware_name);
    }
    if (device_.device_vendor != nullptr) {
      builder.set_device_vendor(device_.device_vendor);
    }
    if (device_.pci_bus_id != nullptr) {

  // Device vendor can store handle to their device representation
  // here.
  void* device_handle;

  // [Optional]
  // Device hardware name. Used for printing.
  // Must be null-terminated.
  const char* hardware_name;

  // [Optional]
  // Device vendor name. Used for printing.
  // Must be null-terminated.
  const char* device_vendor;

  // [Optional]
  // Returns the PCI bus identifier for this device, of the form