tf_executor.yield %4 : tensor<?xi32>
      }
      tf_executor.fetch %1#0 : tensor<?xi32>
    }
    func.return %0 : tensor<?xi32>
  }
}

// -----

// Multiple clusters of different devices. Clusters depend on each other.

module {
  // CHECK-LABEL: func @multiplerelatedclusters
  // CHECK-SAME: (%[[ARG_0:[a-z0-9]*]]: tensor<?xi32>)

	framework.NewTest(t).
		Run(func(t framework.TestContext) {
			testNS := apps.EchoNamespace.Namespace

			t.ConfigIstio().YAML(testNS.Name(), POLICY).ApplyOrFail(t)

			for _, cluster := range t.Clusters() {
				t.NewSubTest(fmt.Sprintf("From %s", cluster.StableName())).Run(func(t framework.TestContext) {
					verify := func(ctx framework.TestContext, from echo.Instance, to echo.Instances, s scheme.Instance, success bool) {
						want := "success"

											expectedClusters := cluster.Clusters{from.Config().Cluster}
											if !check.IsDNSCaptureEnabled(t) && opts.To.Config().Headless {
												opts.Check = check.And(opts.Check, check.ReachedSourceCluster(t.Clusters()))
											} else {
												opts.Check = check.And(opts.Check, check.ReachedClusters(t.Clusters(), expectedClusters))
											}
										}
									} else {

		Addresses: m.GetAddresses(),
	}
}

// GetAddresses returns the mapping of clusters to addresses.
func (m *AddressMap) GetAddresses() map[cluster.ID][]string {
	if m == nil {
		return nil
	}

	m.mutex.RLock()
	defer m.mutex.RUnlock()

	if m.Addresses == nil {
		return nil
	}

	out := make(map[cluster.ID][]string)
	for k, v := range m.Addresses {
		if v == nil {
			out[k] = nil
		} else {

    return signalPassFailure();

  OpBuilder builder(&getContext());
  llvm::SmallVector<mlir::tf_device::ClusterOp, 4> clusters;
  module.walk(
      [&](mlir::tf_device::ClusterOp cluster) { clusters.push_back(cluster); });

  for (mlir::tf_device::ClusterOp cluster : clusters) {
    std::string host_device;
    bool cluster_updated = false;

			Listeners: []*envoy_listener.Listener{},
			Clusters: []*envoy_cluster.Cluster{
				{
					Name:     "dynamic_forward_proxy_cluster",
					LbPolicy: envoy_cluster.Cluster_CLUSTER_PROVIDED,
					ClusterDiscoveryType: &envoy_cluster.Cluster_ClusterType{
						ClusterType: &envoy_cluster.Cluster_CustomClusterType{
							Name: "envoy.clusters.dynamic_forward_proxy",

			webhooks := []string{vwcName, "istiod-default-validator"}

			// clear the updated fields and verify istiod updates them
			cluster := t.Clusters().Default()
			for _, vwcName := range webhooks {
				retry.UntilSuccessOrFail(t, func() error {
					got, err := getValidatingWebhookConfiguration(cluster.Kube(), vwcName)
					if err != nil {
						return fmt.Errorf("error getting initial webhook: %v", err)
					}

# Legacy Cluster add-ons

For more information on add-ons see [the documentation](https://kubernetes.io/docs/concepts/cluster-administration/addons/).

## Overview

Cluster add-ons are resources like Services and Deployments (with pods) that are
shipped with the Kubernetes binaries and are considered an inherent part of the
Kubernetes clusters.

There are currently two classes of add-ons:
- Add-ons that will be reconciled.

apiVersion: release-notes/v2
kind: bug-fix
area: installation
issue:
- 35068
releaseNotes:
- |

apiVersion: release-notes/v2
kind: feature
area: traffic-management

releaseNotes:
- |
  **Added** an experimental feature to enable cluster creation on worker threads inline during requests.
  This will save memory and CPU cycles in cases where there are lots of inactive clusters and > 1 worker thread.