}

  // Build a map of node names to their corresponding nodes.
  //
  // See `GetGraphDefNode` for more details.
  const auto& nodes =
      tf_package.saved_model_proto_.meta_graphs(0).graph_def().node();
  for (const auto& node : nodes) {
    tf_package.graph_def_nodes_by_name_[node.name()] = &node;
  }
  return tf_package;
}

			ResourceVersion: "1",
		},
		StorageClassName: "bar",
		NodeTopology: &metav1.LabelSelector{
			MatchExpressions: []metav1.LabelSelectorRequirement{
				{
					Key:      "node",
					Operator: metav1.LabelSelectorOpIn,
					Values: []string{
						"node1",
					},
				},
			},
		},
		Capacity: &mib,
	}
	if capacityStr != "" {
		capacityQuantity := resource.MustParse(capacityStr)
		c.Capacity = &capacityQuantity

)

const (
	// maxAllowableNUMANodes specifies the maximum number of NUMA Nodes that
	// the TopologyManager supports on the underlying machine.
	//
	// At present, having more than this number of NUMA Nodes will result in a
	// state explosion when trying to enumerate possible NUMAAffinity masks and
	// generate hints for them. As such, if more NUMA Nodes than this are
	// present on a machine and the TopologyManager is enabled, an error will

#include "tensorflow/core/lib/core/status.h"

namespace tensorflow {

struct ArrayInfoBase {
  // The node type when the input node is imported. Typically needs to be
  // specified when passing arbitrary nodes (some node attributes are removed).
  DataType imported_dtype;

  // Node "shape" attribute value.
  TensorShapeProto shape;
};

struct ArrayInfo : public ArrayInfoBase {

If they have changed, Gradle will execute the task.
Otherwise, it will skip execution.

Incremental builds are always enabled, and the best way to see them in action is to turn on _verbose mode_.
With verbose mode, each task state is labeled during a build:

[source,text]
----
$ ./gradlew compileJava --console=verbose

> Task :buildSrc:generateExternalPluginSpecBuilders UP-TO-DATE

import java.util.Set;
import java.util.TreeSet;

public final class NodeSets {

    public static NavigableSet<Node> newSortedNodeSet() {
        return new TreeSet<>(NodeComparator.INSTANCE);
    }

    public static List<Node> sortedListOf(Set<Node> nodes) {
        List<Node> sorted = new ArrayList<>(nodes);
        sorted.sort(NodeComparator.INSTANCE);
        return sorted;
    }

    private NodeSets() {
    }

  // Retrieves a specific GraphDef node by name.
  //
  // GraphDef nodes are stored as a repeating list of nodes.  At module load
  // time, a module may have constants that need to be restored.  To restore
  // these constants, they are looked up in the GraphDef's nodes by their name.
  // Since we may need to load many constants, we create a hash map of these
  // names to their corresponding nodes at load time in order to look them up

// subgraphs pass and that should in turn be compiled via XlaLaunch operators.
extern const char* const kXlaCompiledKernelAttr;

// Does `node` have the kXlaCompiledKernelAttr attribute?
bool IsXlaCompiledKernel(const Node& node);

// Functions produced by the EncapsulateSubgraphs pass have their arguments in
// the order:
// 1) compile-time constant arguments, in host memory,

      "Cannot add self-loop edge on node %s, as self-loops are not allowed. To construct a graph "
          + "that allows self-loops, call allowsSelfLoops(true) on the Builder.";
  static final String NOT_AVAILABLE_ON_UNDIRECTED =
      "Cannot call source()/target() on a EndpointPair from an undirected graph. Consider calling "
          + "adjacentNode(node) if you already have a node, or nodeU()/nodeV() if you don't.";

  - apiGroups: ["coordination.k8s.io"]
    resources: ["leases"]
    resourceNames: ["cluster-autoscaler"]
    verbs: ["get", "update", "patch", "delete"]
  # accessing & modifying cluster state (nodes & pods)
  - apiGroups: [""]
    resources: ["nodes"]
    verbs: ["get", "list", "watch", "update", "patch"]
  - apiGroups: [""]
    resources: ["pods"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["pods/eviction"]