const absl::string_view name1 = device_info_cache.GetNameFor(d1->value());

    DeviceNameUtils::ParsedName parsed0, parsed1;
    if (!DeviceNameUtils::ParseFullName(name0, &parsed0) ||
        !DeviceNameUtils::ParseFullName(name1, &parsed1) ||
        !DeviceNameUtils::AreCompatibleDevNames(parsed0, parsed1)) {
      return true;
    }

    if (DeviceNameUtils::IsSpecification(parsed0, parsed1)) {

    if (!string_attr)
      return op->emitOpError(llvm::formatv(
          "bad '{0}' attribute at index {1}, not a string", kDevicesAttr, idx));

    if (DeviceNameUtils::ParseFullName(string_attr.getValue().str(), &device)) {
      devices->AddDevice(device);
    } else {
      return op->emitOpError(
          llvm::formatv("bad '{0}' attribute, '{1}', not a valid device",

  DeviceNameUtils::ParsedName parsed_name;
  DeviceNameUtils::ParseFullName(gpu0, &parsed_name);
  auto meta_0 = devices.GetGpuDeviceMetadata(parsed_name);
  ASSERT_TRUE(meta_0.has_value());
  ASSERT_EQ(meta_0->getCcMajor(), 1);
  ASSERT_EQ(meta_0->getCcMinor(), 2);

  DeviceNameUtils::ParseFullName(gpu1, &parsed_name);
  auto meta_1 = devices.GetGpuDeviceMetadata(parsed_name);

  if (!device || device.getValue().empty()) {
    return std::nullopt;
  }
  tensorflow::DeviceNameUtils::ParsedName parsed_name;
  if (!tensorflow::DeviceNameUtils::ParseFullName(device.str(), &parsed_name)) {
    return std::nullopt;
  }
  if (!parsed_name.has_type) {
    return std::nullopt;
  }
  return parsed_name.type;
}

}  // namespace

                                                      kFuncDeviceAttr)) {
      std::string device = attr.getValue().str();
      tensorflow::DeviceNameUtils::ParsedName parsed_name;
      if (!tensorflow::DeviceNameUtils::ParseFullName(device, &parsed_name)) {
        return read->emitOpError() << "invalid device '" << device << "'";
      }
      is_cpu_read = parsed_name.type == kCpuDeviceType;
      return success();
    }
  }

  auto caller_device = call->getAttrOfType<StringAttr>(device_id);
  if (!caller_device) return;

  DeviceNameUtils::ParsedName caller_parsed_device;
  if (!DeviceNameUtils::ParseFullName(caller_device.getValue().str(),
                                      &caller_parsed_device))
    return;

  MLIRContext *context = call->getContext();
  auto node_device = [&](Operation *n) -> StringAttr {

  for (const Node* node : graph.nodes()) {
    if (node->type_string() == nodeType) {
      auto device_name = node->assigned_device_name();
      DeviceNameUtils::ParsedName device;
      if (DeviceNameUtils::ParseFullName(device_name, &device) &&
          device.has_job && device.job == jobType) {
        for (const auto& attr : node->attrs()) {
          auto attr_key = attr.first;
          auto attr_value = attr.second;

      device = alias.getDefiningOp()->getAttrOfType<StringAttr>(kDeviceAttr);
    }

    if (!device) return false;
    tensorflow::DeviceNameUtils::ParsedName parsed_device;
    if (!tensorflow::DeviceNameUtils::ParseFullName(device.getValue().str(),
                                                    &parsed_device)) {
      return false;
    }
    return parsed_device.has_type && parsed_device.type == kDeviceCPU;
  });
}

  DLDevice ctx;
  const char* device_name =
      tensorflow::unwrap(h)->BackingDeviceName(&status->status);
  DeviceNameUtils::ParsedName parsed_name;
  tensorflow::DeviceNameUtils::ParseFullName(device_name, &parsed_name);
  std::string device_type = parsed_name.type;
  int device_id = 0;
  if (parsed_name.has_id) {
    device_id = parsed_name.id;
  }

  ctx.device_id = device_id;

    if (!TryGetNodeAttr(n->attrs(), kXlaClusterIdAttr, &name)) continue;
    // Early return for any node with a device that is not a CPU or GPU.
    DeviceNameUtils::ParsedName parsed;
    if (DeviceNameUtils::ParseFullName(n->requested_device(), &parsed)) {
      if (parsed.type != DEVICE_CPU && parsed.type != DEVICE_GPU) {
        return false;
      }
    }
  }
  return true;
}