// RUN: tf-opt %s -split-input-file -tf-device-launch-outlining | FileCheck %s

// Tests simple case of a single `tf_device.launch`.

// CHECK-LABEL: func @single_launch
// CHECK-SAME: (%[[ARG_0:[a-z0-9]*]]: tensor<?xi32>)
func.func @single_launch(%arg0: tensor<?xi32>) -> tensor<?xi32> {
  %0 = tf_executor.graph {
    %1:2 = tf_executor.island {
      // CHECK: %[[A_OUTPUT:[0-9]*]] = "tf.A"(%[[ARG_0]])

// RUN: tf-opt %s -split-input-file -tf-device-cluster-outlining | FileCheck %s

// Tests simple case of a single `tf_device.cluster`.

// CHECK-LABEL: func @single_cluster
// CHECK-SAME: (%[[ARG_0:[a-z0-9]*]]: tensor<?xi32>)
func.func @single_cluster(%arg0: tensor<?xi32>) -> tensor<?xi32> {
  %0 = tf_executor.graph {
    %1:2 = tf_executor.island {
      // CHECK: %[[A_OUTPUT:[0-9]*]] = "tf.A"(%[[ARG_0]])

	"unicode/utf8"
)

// foldName returns a folded string such that foldName(x) == foldName(y)
// is identical to bytes.EqualFold(x, y).
func foldName(in []byte) []byte {
	// This is inlinable to take advantage of "function outlining".
	var arr [32]byte // large enough for most JSON names
	return appendFoldedName(arr[:0], in)
}

func appendFoldedName(out, in []byte) []byte {
	for i := 0; i < len(in); {
		// Handle single-byte ASCII.

  }
  return true;
}

// Summary information for trivially transforming region based op's to
// functional ops. A trivial transformation can be done when the regions are
// just calls to functions, in which case no outlining is needed.
struct TrivialTransformInfo {
  // Can the op be transformed trivially?
  bool can_transform = false;

  // List of callee names (one for each region).
  llvm::SmallVector<StringRef, 2> callee_names;

// Test to verify loop outlining.

// RUN: tf-opt --split-input-file --tfl-while-loop-outline %s | FileCheck %s
// Check that while loop outlining is nop if re-ran.
// RUN: tf-opt --tfl-while-loop-outline %s -o %t1
// RUN: tf-opt --tfl-while-loop-outline %t1 -o %t2
// RUN: diff %t1 %t2

// CHECK-LABEL: func @while
func.func @while() -> tensor<1xf32>
    attributes {tf.entry_function = {outputs = "result"}} {

    "_xla_outside_compilation";
// device attr
inline constexpr llvm::StringRef kDeviceAttr = "device";
// Function attribute to signal that a function should be skipped from TPU
// island outlining. The attribute is set in
// `TpuV1BridgeExecutorIslandCoarsening` and removed in the subsequent
// `TPUBridgeExecutorIslandOutlining` pass.
inline constexpr llvm::StringRef kSkipIslandOutlining =
    "_skip_island_outlining";

// This is a V1 backward compatibility.
std::unique_ptr<OperationPass<ModuleOp>>
CreateTFExecutorTPUV1IslandCoarseningPass();

// Creates a pass to outlining TPU clusters from single IslandOp into a nested
// module suitable for being processed as-if it was a V2 module.
// This is a V1 backward compatibility.
std::unique_ptr<OperationPass<ModuleOp>>

  let summary = [{
The `tf_device.cluster_func` launches a function containing the body of a
cluster.
  }];

  let description = [{
This op is used for outlining a cluster.
  }];

  let arguments = (ins
    FlatSymbolRefAttr:$func,
    Variadic<AnyType>:$args
  );

  let results = (outs
    Variadic<AnyType>:$results
  );

    TPU-annotated operations and intended to preserve backward compatibility with
    TFv1.
  }];
}

def TPUBridgeExecutorIslandOutliningPass : Pass<"tf-executor-tpu-v1-island-outlining", "ModuleOp"> {
  let summary = "Outline TPU clusters from island into a nested module, so it can "
           "be processed like a V2 module, intended for V1 compatibility mode";

    tf_device.return %4 : tensor<?xi32>
  }) {device = "tpu0"} : () -> tensor<?xi32>
  %2 = "tf.D"(%1) : (tensor<?xi32>) -> tensor<?xi32>
  return %2 : tensor<?xi32>
```
### `-tf-device-cluster-outlining`

_Outlines regions of tf_device.cluster operations_

This pass outlines the body of a `tf_device.cluster` into a function and
replaces the `tf_device.cluster` op with an equivalent `tf_device.cluster_func`