}

    def "prefers to stop less frequently used idle clients when releasing memory"() {
        def client1 = Mock(WorkerDaemonClient) { _ * getUses() >> 5 }
        def client2 = Mock(WorkerDaemonClient) { _ * getUses() >> 1 }
        def client3 = Mock(WorkerDaemonClient) { _ * getUses() >> 3 }
        starter.startDaemon(options) >>> [client1, client2, client3]

    llvm::MapVector<Operation*, llvm::SmallVector<unsigned int, 4>>*
        arguments_to_erase) {
  auto arg = region->getArgument(argument_index);
  for (auto& usage : arg.getUses()) {
    auto* user_op = usage.getOwner();
    int operand_index = usage.getOperandNumber();
    PropagateUsage(user_op, operand_index, value, work_list,
                   arguments_to_erase);
  }
}

        workerClient.stop();
    }

    public void kill() {
        workerClient.stopNow();
    }

    DaemonForkOptions getForkOptions() {
        return forkOptions;
    }

    public int getUses() {
        return uses;
    }

    public KeepAliveMode getKeepAliveMode() {
        return forkOptions.getKeepAliveMode();
    }

    public LogLevel getLogLevel() {
        return logLevel;
    }

    const ShapedType type = mlir::dyn_cast<ShapedType>(op.getType());
    if (!type || !type.getElementType().isF32()) return quantizable_ops;

    const Value value = op.getResult();

    for (OpOperand& use : value.getUses()) {
      Operation* user = use.getOwner();
      const int operand_num = use.getOperandNumber();
      quantizable_ops.insert({user, operand_num});
    }
    return quantizable_ops;
  }

template <typename T>
void ReplicateTensorListForUses(T tensor_list_op) {
  Value tensor_list = tensor_list_op.getResult();
  std::vector<OpOperand*> uses;
  for (auto& use : tensor_list.getUses()) {
    uses.emplace_back(&use);
  }
  OpBuilder builder(tensor_list_op.getOperation());
  for (OpOperand* operand : uses) {
    auto new_op = builder.clone(*tensor_list_op.getOperation());

    }
    OpBuilder builder(op);
    llvm::StringMap<mlir::Operation *> cloned_op_by_device;
    bool all_uses_replaced = true;

    for (mlir::OpOperand &use :
         llvm::make_early_inc_range(op.getResult().getUses())) {
      mlir::Operation *user_op = use.getOwner();
      StringAttr device_attr = user_op->getAttrOfType<StringAttr>(kDeviceAttr);
      if (!device_attr) {
        all_uses_replaced = false;
        continue;
      }

    while (!todo.empty()) {
      Value value = todo.front();
      todo.pop();
      // All operations that have all their inputs available are good to go.
      // Uses, not Users, in case getUsers ever dedups.
      for (OpOperand& operand : value.getUses()) {
        Operation* user = ancestor[operand.getOwner()];
        remaining_incoming_data_edges[user]--;
        if (remaining_incoming_data_edges[user] == 0 &&

    if (!function_name.starts_with(kDequantizeFunctionName)) return failure();

    llvm::SmallVector<Operation*> users(op->getUsers().begin(),
                                        op->getUsers().end());

    bool changed = false;
    for (auto& use : op->getUses()) {
      Operation* user_op = use.getOwner();
      int user_idx = use.getOperandNumber();
      if (!IsOpWithInt8TypeOperand(user_op)) continue;

  for (auto& use : uses_optional.value()) {
    if (llvm::isa<TF::WhileOp>(use.getUser())) {
      if (*while_op != nullptr) {
        use.getUser()->emitOpError() << "multiple users of function.";
        return LogicalResult::failure();
      } else {
        *while_op = llvm::cast<TF::WhileOp>(use.getUser());
      }
    } else {
      use.getUser()->emitOpError() << "non while use of function.";

// before or above the parallel_execute.
TF::AssignVariableOp GetSingleUseResourceWrite(
    tf_device::ParallelExecuteOp parallel_execute, Value result) {
  if (!result.hasOneUse()) return nullptr;

  OpOperand& use = *result.getUses().begin();
  auto assign_var = dyn_cast<TF::AssignVariableOp>(use.getOwner());
  if (!assign_var) return nullptr;

  if (use.get() != assign_var.getValue()) return nullptr;