%max_size = "tf.Const"() {value = dense<10> : tensor<i32>} : () -> tensor<i32>
  %stack = "tf.StackV2"(%max_size) {elem_type = f32, stack_name = "s"} : (tensor<i32>) -> tensor<!tf_type.resource>
  %stack2 = "tf.StackV2"(%max_size) {elem_type = f32, stack_name = "s2"} : (tensor<i32>) -> tensor<!tf_type.resource>
  %if_op = "tf.If"(%arg0, %stack, %stack2) {then_branch = @if_then, else_branch = @if_else, is_stateless = false}

// Tests loop with resource that is unique per iteration.
//
// In cases where a resource-allocating op creates a new unique resource per
// loop iteration (ops with `TF_UniqueResourceAllocation` trait, in this case:
// `tf.StackV2`), make sure that we don't create data dependencies between
// different iterations for such resources. This is in line with the behavior
// for the same loop unrolled. In this particular case, no data chain and token

func.func @unique_resource_allocation(%arg0: tensor<i32>) {
  // expected-remark@below {{Result #0, ID 0 : 0}}
  %stack_handle1 = "tf.StackV2"(%arg0) {elem_type = f32, stack_name = "s"} : (tensor<i32>) -> tensor<!tf_type.resource>
  // expected-remark@below {{Result #0, ID 1 : 1}}
  %stack_handle2 = "tf.StackV2"(%arg0) {elem_type = f32, stack_name = "s"} : (tensor<i32>) -> tensor<!tf_type.resource>
  func.return
}

// -----

 Minimum 43
 Mul 8
 NextIteration 136
 RandomUniform 14
 Range 9
 RefSwitch 166
 Reshape 2
 ScatterAdd 4
 Shape 6
 ShapeN 10
 Size 2
 Snapshot 1
 StackPopV2 314
 StackPushV2 314
 StackV2 314
 StridedSlice 12
 Sub 5
 Sum 2
 Switch 247
 TensorArrayGatherV3 8
 TensorArrayGradV3 17
 TensorArrayReadV3 9
 TensorArrayScatterV3 8
 TensorArraySizeV3 4
 TensorArrayV3 8
 TensorArrayWriteV3 9

  func.return
}

// CHECK-LABEL: func @ignore_stack_ops
func.func @ignore_stack_ops(%arg0: tensor<i32>) -> () {
  "tf_device.cluster"() ({
    // CHECK: "tf.StackV2"
    // CHECK-NOT: _xla_outside_compilation
    %0 = "tf.StackV2"(%arg0) {elem_type = f32, stack_name = "s"} : (tensor<i32>) -> tensor<!tf_type.resource>
    tf_device.return

  %2 = "tf.Const"() {value = dense<1> : tensor<i32>} : () -> tensor<i32>
  %3 = "tf.Const"() {value = dense<2> : tensor<i32>} : () -> tensor<i32>
  %4 = "tf.StackV2"(%3) {elem_type = f32, stack_name = "s"} : (tensor<i32>) -> tensor<!tf_type.resource>
  %5:5 = "tfl.while"(%2, %3, %2, %4, %0) ({

    // expected-remark@above {{ID: 5}}
    // expected-remark@above {{Successors: {6}}}
        %stack_handle1 = "tf.StackV2"(%arg0) {elem_type = f32, stack_name = "s"} : (tensor<i32>) -> tensor<!tf_type.resource>
        // expected-remark@above {{ID: 0}}
        %stack_handle2 = "tf.StackV2"(%arg0) {elem_type = f32, stack_name = "s"} : (tensor<i32>) -> tensor<!tf_type.resource>
        // expected-remark@above {{ID: 1}}

      "SpaceToBatch",
      "SpaceToBatchND",
      "SpaceToDepth",
      "SparseMatMul",
      "SparseToDense",
      "StackCloseV2",
      "StackPopV2",
      "StackPushV2",
      "StackV2",
      "StatefulPartitionedCall",
      "StatefulStandardNormalV2",
      "StatefulTruncatedNormal",
      "StatefulUniform",
      "StatefulUniformFullInt",
      "StatefulUniformInt",

    maximum size needs to be a constant and 2) a push op can be found with a
    known shape, and all push ops need to have the same shape.

    A stack creation op "tf.StackV2" will be turned in to two zero-initialized
    variables, for the buffer and current size. Each push will be turned into
    ```mlir
      %old_val = "tf.ReadVariableOp"(%buffer)
      %old_size = "tf.ReadVariableOp"(%size)

// allocation won't accidentally count as in bounds of the first stack
#define STACK_SIZE	(64ull << 10)

static ucontext_t uctx_save, uctx_switch;

extern void stackSwitchCallback(void);

char *stack2;

static void *stackSwitchThread(void *arg) {
	// Simple test: callback works from the normal system stack.
	stackSwitchCallback();

	// Next, verify that switching stacks doesn't break callbacks.