public:
  BFloat16TypeConverter() {
    addConversion([](const Type type) -> Type {
      return IsLargeFloatType(type) ? ToBfloat16Type(type) : type;
    });
  }
};

// This helper function makes legality check easier. Both convert ops in the
// patterns below are considered legal:
//  - `BitcastConvertOp` (i32 -> f32) + `ConvertOp` (f32 -> bf16)
//  - `ConvertOp` (bf16 -> f32) -> `BitcastConvertOp` (f32 -> i32)

auto *mlir_failed_legalization_count = tensorflow::monitoring::Counter<2>::New(
    "/tensorflow/core/tf2xla/v1/mlir_failed_xla_legalize_tf_pass_count",
    "Counts the failure of legalization of ops", "op_name", "legality");

class LegalizeTF : public impl::LegalizeTFBase<LegalizeTF> {
 public:
  explicit LegalizeTF(bool legalize_chlo,
                      std::optional<StringRef> tf2xla_fallback_device_type,

  // attached to a TF Device operation.
  bool isLegalToInline(Region* dest, Region* src, bool wouldBeCloned,
                       IRMapping& valueMapping) const final {
    return true;
  }

  // Defines the legality of inlining TF Device operations into a region.
  bool isLegalToInline(Operation* call, Region*, bool, IRMapping&) const final {
    return true;
  }

//  limitations under the License.

package locality

import (
	"fmt"
	"strings"
)

type Instance struct {
	Zone   string
	Region string
}

func (l Instance) String() string {
	return fmt.Sprintf("%s/%s", l.Region, l.Zone)
}

func Parse(s string) Instance {
	parts := strings.Split(s, "/")
	if len(parts) != 2 {
		panic("invalid locality string: " + s)
	}
	return Instance{

        //  b. A and B cannot be placed in the same cluster.
        //  c. There is no path from B to A in the cycles graph (but there may
        //     be a path from A to B).
        //
        // So check the legality of the edge contraction by checking if any of
        // the n^2 pairs of resource variable operations are forbidden.
        if (unsafe_resource_deps_.contains(
                {resource_var_from, resource_var_to})) {

apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: locality
  namespace: default
spec:
  host: locality.cluster.local
  trafficPolicy:
    outlierDetection:
      interval: 1s
      baseEjectionTime: 3m

// RUN: tf-opt --tfl-legalize-tf-while %s -o - | FileCheck %s
// RUN: tf-opt --tfl-legalize-tf-while %s -o - --tfl-legalize-tf-while --inline='default-pipeline=''' | FileCheck %s --check-prefix=INLINE
// RUN: tf-opt --tfl-legalize-tf-while %s -o - --tfl-legalize-tf-while --inline | FileCheck %s --check-prefix=CANON

apiVersion: release-notes/v2
kind: feature
area: documentation
releaseNotes:
  - |
    **Added** The locality load balancing docs have been re-written into a
    formal traffic management task. The new docs describe in more detail
    how locality load balancing works as well as how to configure both
    failover and weighted distribution. In addition, the new docs are now

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

// RUN: tf-opt %s -split-input-file -tfl-legalize-variables-tf --cse | FileCheck %s

// Test for case with no session initialize op.
module attributes {tf_saved_model.semantics} {
  // CHECK-LABEL: serving_default
  func.func @serving_default(%arg0: tensor<1x10xf32> {tf_saved_model.index_path = ["x"]}) ->