includePathConfiguration.getAttributes().attribute(OPTIMIZED_ATTRIBUTE, identity.isOptimized());
        includePathConfiguration.getAttributes().attribute(OperatingSystemFamily.OPERATING_SYSTEM_ATTRIBUTE, identity.getTargetMachine().getOperatingSystemFamily());
        includePathConfiguration.getAttributes().attribute(MachineArchitecture.ARCHITECTURE_ATTRIBUTE, identity.getTargetMachine().getArchitecture());

        private final Identity identity;
        private final OriginMetadata originMetadata;

        public DefaultExecuteDeferredWorkProgressDetails(
            @Nullable String workType,
            Identity identity,
            OriginMetadata originMetadata
        ) {
            this.workType = workType;
            this.identity = identity;
            this.originMetadata = originMetadata;

    // Scalar identity is broadcastable to any operand shape, we only need to
    // check that operand has the same shape as a result.
    bool scalar_identity = identity_ty.hasRank() && identity_ty.getRank() == 0;
    if (scalar_identity) return operand_ty == result_ty;

    // If identity is not a scalar, we must verify that identity shape is

        }
    }

    private static void validateIdentity(@Nullable String identity) {
        if (identity == null || identity.isEmpty() || !identity.chars().allMatch(Character::isLetterOrDigit)) {
            throw new IllegalArgumentException("Identity may contain only letters and digits, received: " + identity);
        }
    }

    // CHECK:      "tf_device.cluster"
    // CHECK-NEXT:   "tf.Identity"
    // CHECK-NEXT:   "tf.B"
    // CHECK-NEXT:   "tf.Identity"
    // CHECK-NEXT:   tf_device.return
    "tf_device.cluster"() ({
      %a = "tf.Identity"(%arg0) : (tensor<i32>) -> tensor<i32>
      %b = "tf.B"(%a) {_xla_outside_compilation = "cluster1"} : (tensor<i32>) -> tensor<i32>
      %c = "tf.Identity"(%b) : (tensor<i32>) -> tensor<i32>
      tf_device.return

    private final PlannedTransformStepIdentity identity;
    private final List<? extends NodeIdentity> dependencies;

    public DefaultPlannedTransformStep(
        PlannedTransformStepIdentity identity,
        List<? extends NodeIdentity> dependencies
    ) {
        this.identity = identity;
        this.dependencies = dependencies;
    }

    @Override

  %1 = "tf.BiasAdd"(%0, %arg0) {data_format = "NHWC"} : (tensor<*xf32>, tensor<128xf32>) -> tensor<*xf32>
  %2 = "tf.Elu"(%1) : (tensor<*xf32>) -> tensor<*xf32>
  %3 = "tf.Identity"(%2) : (tensor<*xf32>) -> tensor<*xf32>
  %4 = "tf.Identity"(%0) : (tensor<*xf32>) -> tensor<*xf32>
  func.return %3, %4 : tensor<*xf32>, tensor<*xf32>
}

// CHECK-LABEL: conv2DBiasAdd_biasAddMultipleUse

                                               device_attr, op, result);
      if (failed(res)) return WalkResult::interrupt();
    } else if (auto identity = dyn_cast<IdentityOp>(op)) {
      LLVM_DEBUG(dump("Visiting ", identity));
      // Try to construct IdentityOp's attribute from recorded assignment.
      if (!GetDeviceAttr(op).empty()) return WalkResult::advance();

      %2 = "tf.Identity"(%arg0) : (tensor<f32>) -> tensor<f32> loc("identity@some_function")
      "tf_executor.yield"(%2) : (tensor<f32>) -> () loc("identity@some_function")
    }) : () -> (tensor<f32>, !tf_executor.control) loc("identity@some_function")
    "tf_executor.fetch"(%1#0) : (tensor<f32>) -> () loc(unknown)
  }) : () -> tensor<f32> loc(unknown)
  "func.return"(%0) : (tensor<f32>) -> () loc(unknown)
} loc(unknown)

    return %1 : tensor<*xbf16>
  }

// CHECK-LABEL: func @propagate_xladotv2_bf16
// CHECK: %[[IDENTITY:.*]] = "tf.Identity"(%cst) : (tensor<2x1024xi8>) -> tensor<2x1024xi8>
// CHECK: %[[MATMUL:.*]] = "tf.XlaDotV2"(%arg0, %[[IDENTITY]]) <{dimension_numbers = "\12\01\00\0A\01\03", precision_config = ""}> {device = ""} : (tensor<1x2x2x2xbf16>, tensor<2x1024xi8>) -> tensor<1x2x2x1024xbf16>