//
// 1. Add a XLA computation key placeholder node (it will be used as input for
//    XlaRecvAtHost and XlaSendFromHost);
// 2. Replace all _Arg nodes with one single XlaRecvAtHost node;
// 3. Replace all _Retval nodes with one single XlaSendFromHost node;
// 4. Mark all nodes except key placeholder with attr `xla_cluster_attr_name`
//    and `outside_compilation_attr_name`;
// 5. For nodes marked with attr kXlaConnectedToXlaComputationAttrName, add a

	zones    []string            // a list of all the zones in the tree (keys)
	numNodes int
}

// newNodeTree creates a NodeTree from nodes.
func newNodeTree(logger klog.Logger, nodes []*v1.Node) *nodeTree {
	nt := &nodeTree{
		tree: make(map[string][]string, len(nodes)),
	}
	for _, n := range nodes {
		nt.addNode(logger, n)
	}
	return nt
}

            producer.addDependencySuccessor(destroyerLocations);
        }
    }

    private void maybeSchedule(Consumer<Node> ordinalNodeConsumer, OrdinalNode node) {
        if (requiredNodes.add(node)) {
            node.require();
            for (Node successor : node.getDependencySuccessors()) {
                if (successor instanceof OrdinalNode) {

    if (IsInPlaceOp(n->type_string())) {
      return absl::OkStatus();
    }
    nodes.push_back(n);
  }

  // Iterate over a copy of the nodes to avoid iterating over g->nodes() while
  // creating more nodes.
  for (Node* n : nodes) {
    TF_RETURN_IF_ERROR(CloneSmallConstantInputs(name_set, n));
  }
  return absl::OkStatus();
}

    }

    def appendChild(Node node) {
        if (!current) {
            elements << (Element) document.importNode(node, true)
        } else  {
            current.appendChild(document.importNode(node, true))
        }
    }

    def appendChildren(Iterable<? extends Node> nodes) {
        nodes.each { appendChild(it) }
    }

    def appendChildren(NodeList nodes) {
        nodes.each { appendChild(it) }

  NUMNODES=${NUMNODES:-2}
fi

NODES=$(cat <<-EOM
nodes:
- role: control-plane
EOM
)

if [[ -n "${NUMNODES}" ]]; then
for _ in $(seq 1 "${NUMNODES}"); do
  NODES+=$(printf "\n%s" "- role: worker")
done
fi

CONFIG=$(cat <<-EOM
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
${FEATURES}
name: ${CLUSTERNAME}
${NODES}
networking:
  ipFamily: ${IPFAMILY}
EOM
)

        }

        public void collectNodes(Collection<Node> nodes) {
            for (Node node : nodes) {
                ToPlannedNodeConverter converter = converterRegistry.getConverter(node);
                if (converter != null && converter.isInSamePlan(node)) {
                    List<? extends NodeIdentity> nodeDependencies = findNodeDependencies(node);

			fc := kube.NewFakeClient(&v1.Node{
				ObjectMeta: metav1.ObjectMeta{Name: "fake", Labels: map[string]string{
					NodeRegionLabelGA:          loc.Region,
					NodeZoneLabel:              loc.Zone,
					label.TopologySubzone.Name: loc.SubZone,
				}},
				Spec:   v1.NodeSpec{},
				Status: v1.NodeStatus{},
			})
			nodes := kclient.New[*v1.Node](fc)
			fc.RunAndWait(test.NewStop(t))

apiVersion: release-notes/v2
kind: feature
area: installation
releaseNotes:
  - |

kind: ConfigMap
apiVersion: v1
metadata:
  name: calico-node-vertical-autoscaler
  namespace: kube-system
  labels:
    addonmanager.kubernetes.io/mode: Reconcile
data:
  node-autoscaler: |-
    {
      "calico-node": {
        "requests": {
          "cpu": {
            "base": "80m",
            "step": "20m",
            "nodesPerStep": 10,
            "max": "500m"
          }
        }
      }