op->emitError() << "TPUCopyWithDynamicShapeOp is not in a launch";
  }
  std::string device_str = launch_op.getDeviceAttr().getValue().str();
  std::string cpu0_device;
  if (failed(tensorflow::GetNonReplicatedCPU0(op, &cpu0_device)))
    return failure();
  if (device_str != tensorflow::GetDeviceAliasForHostOfLogicalCore(0) &&
      device_str != cpu0_device) {
    op->emitError()

  auto device_attr = op->getAttrOfType<StringAttr>("device");
  if (!device_attr || device_attr.getValue().empty()) return device_ordinal_str;

  // TODO(b/229028654) Remove string conversion once implicit conversion between
  // llvm::StringRef and absl::string_view works.
  absl::string_view device_str(device_attr.data(), device_attr.size());

                       SP_DeviceMemoryBase* const device_dst,
                       const SP_DeviceMemoryBase* const device_src,
                       uint64_t size, TF_Status* const status) {
    TF_SetStatus(status, TF_OK, "");
    std::memcpy(device_dst->opaque, device_src->opaque, size);
  };

  StreamExecutor* executor = GetExecutor(0);

                      ::testing::EquivToProto(original_graph_def)));
#endif
  }

  void InitGraphOptions() {
    session_options_.config = config_proto_;
    graph_optimization_pass_options_.device_set = &device_set_;
    graph_optimization_pass_options_.session_options = &session_options_;
    graph_optimization_pass_options_.graph = &graph_;
    graph_optimization_pass_options_.flib_def = flib_.get();
  }

      // If op already has a TPU device set, simply propagate its device.
      auto device_attr = op_to_update->getAttrOfType<StringAttr>(kDeviceAttr);
      const bool has_device = device_attr && !device_attr.getValue().empty();
      if (has_device && tensorflow::IsTPUDevice(device_attr.getValue())) {
        PopulateDeviceForOpResults(*op_to_update, device_attr.getValue(),
                                   value_to_device);
        continue;

                        string* result) {
  jit::DeviceInfoCache cache;
  jit::DeviceSet device_set;
  for (absl::string_view name : device_names) {
    TF_ASSIGN_OR_RETURN(jit::DeviceId device_id, cache.GetIdFor(name));
    device_set.Insert(device_id);
  }

  TF_ASSIGN_OR_RETURN(
      jit::DeviceId result_id,
      PickDeviceForXla(cache, device_set, allow_mixing_unknown_and_cpu));
  *result = string(cache.GetNameFor(result_id));

}

}  // namespace

void AddDevicesToOp(mlir::Operation* op, const DeviceSet* device_set) {
  if (!device_set) return;

  mlir::MLIRContext* ctx = op->getContext();
  mlir::Builder builder(ctx);

  // Collect devices with attached metadata.
  llvm::SmallVector<mlir::NamedAttribute, 8> devices;
  devices.reserve(device_set->devices().size());

  }
  return mlir_module;
}

std::string GetDevice(Operation* op) {
  auto device_attr = op->getAttrOfType<StringAttr>("device");
  return device_attr ? device_attr.getValue().str() : "";
}

bool CanBeIgnoredInCluster(Operation* op) {
  auto device_attr = op->getAttrOfType<StringAttr>("device");
  return !device_attr || device_attr.getValue().empty();
}

llvm::StringMap<SmallVector<Cluster>> GetClusters(ModuleOp module) {

      op->setAttr(TF::kParallelExecAnnotation, parallel_group_attr);
    }
    auto device_attr = op->getAttr(kDeviceAttr);
    if (!device_attr) {
      op->setAttr(kDeviceAttr, launch.getDeviceAttr());
      return WalkResult::advance();
    }

    if (auto device_str_attr = mlir::dyn_cast<StringAttr>(device_attr)) {
      if (device_str_attr.getValue().empty()) {
        op->setAttr(kDeviceAttr, launch.getDeviceAttr());

        mlir::cast<ShapedType>(variable_v2_op.getResult().getType());
    TensorType tensor_type = mlir::cast<TensorType>(DropRefType(shaped_type));
    StringAttr device_attr =
        variable_v2_op->getAttrOfType<StringAttr>("device");
    if (!device_attr) device_attr = builder.getStringAttr("");
    StringRef variable_name =
        GetNodeNameFromClassAttrOrSharedNameAttr(variable_v2_op);
    if (variable_name.empty()) {