cluster_result_types.size() *
                                        num_cores_per_replica);
  for (mlir::Region& region : old_parallel_execute.getRegions()) {
    if (!llvm::isa<tf_device::ClusterFuncOp>(region.front().front())) {
      for (Type t : region.front().front().getResultTypes())
        concatenated_output_types.emplace_back(t);
    }
  }

		want     *core.Locality
	}{
		{
			"error",
			map[string]handlerFunc{"/placement/region": errorHandler, "/placement/availability-zone": errorHandler},
			&core.Locality{},
		},
		{
			"locality",
			map[string]handlerFunc{"/placement/region": regionHandler, "/placement/availability-zone": zoneHandler},
			&core.Locality{Region: "us-west-2", Zone: "us-west-2b"},
		},
	}

	for _, v := range cases {

// CHECK-LABEL: func @sink_const
func.func @sink_const(%arg0 : tensor<16xf32>) -> (tensor<16xf32>, tensor<f32>) {
  // Verify that the constant are sunk in the tf_device.cluster region using them
  // and removed if no other use is left.

  // Only the 2.0 and 3.0 constants are removed, the 4.0 has a use in the return
  // CHECK-NOT:"tf.Const"2.0
  // CHECK-NOT:"tf.Const"3.0

}

func (tm testMetrics) String() string {
	out := ""
	out += fmt.Sprintf("      Requests: %d\n", tm.totalRequests())
	out += fmt.Sprintf("      Topology: Same Zone=%d, Same Region=%d, Other Region=%d\n", tm.nodesSameZone, tm.nodesSameRegion, tm.nodesOtherRegion)
	out += fmt.Sprintf("Latency  (min): %8.3fs\n", tm.latencyMin)
	out += fmt.Sprintf("Latency  (avg): %8.3fs\n", tm.latencyAvg)

// By definition, a region starts and ends in the same goroutine.
// Regions can be nested to represent subintervals.
// For example, the following code records four regions in the execution
// trace to trace the durations of sequential steps in a cappuccino making
// operation.
//
//	trace.WithRegion(ctx, "makeCappuccino", func() {
//
//	   // orderID allows to identify a specific order
//	   // among many cappuccino order region records.

       // Condition region
       // CHECK: ^bb
       // CHECK: "tf.Yield"
       ^bb0(%carg0: tensor<i32>):
          %c0 = "tf.Const"() {value = dense<0> : tensor<i32>} : () -> tensor<i32>
          %c1 = "tf.GreaterEqual"(%carg0, %0) {T = i32, device = ""} : (tensor<i32>, tensor<i32>) -> tensor<i1>
          "tf.Yield"(%c1) : (tensor<i1>) -> ()
      }, {
       // Body region
       // CHECK: ^bb0

	for _, x := range part {
		switch v := x.(type) {
		case Tag:
			b.SetTag(v.tag())
		case Base:
			b.Tag.LangID = v.langID
		case Script:
			b.Tag.ScriptID = v.scriptID
		case Region:
			b.Tag.RegionID = v.regionID
		case Variant:
			if v.variant == "" {
				err = errInvalidArgument
				break
			}
			b.AddVariant(v.variant)
		case Extension:
			if v.s == "" {
				err = errInvalidArgument

  // Registered hook to check if the given region, which is attached to an
  // operation that is *not* isolated from above (i.e. no internal regions
  // reference values defined in an enclosing region), should be used when
  // materializing constants.
  // In the executor dialect we materialize inside an island.
  bool shouldMaterializeInto(Region *region) const final {
    return isa<tf_executor::IslandOp>(region->getParentOp());

The `tf_executor.island` region allows implicit capture. If any value captured
by a `tf_executor.island` is dead, the whole region does not execute and every
produced value is marked as dead as well.

An arbitrary number of `tf_executor.control` operands are accepted by a
`tf_executor.island` operation. If any operand is dead, the region is not
executed and dead values are immediately returned for every result.

	if !globalAPIConfig.permitRootAccess() {
		region := globalSite.Region()
		if region == "" {
			region = "us-east-1"
		}
		clnt, err = minio.New(globalLocalNodeName, &minio.Options{
			Creds:     credentials.NewStaticV4(opts.creds.AccessKey, opts.creds.SecretKey, opts.creds.SessionToken),
			Secure:    globalIsTLS,
			Transport: globalRemoteTargetTransport,
			Region:    region,
		})
		if err != nil {
			return res, err