Example:
      %tensor = tfrt_fallback_async.const_string_tensor {shape = [1, 2], value = ["const", "string"]}

    Note: if the entries in `value` are all the same, we can just keep one copy.
      In other words, the following two lines are effectively the same.
      %tensor = tfrt_fallback_async.const_string_tensor {shape = [1, 2], value = ["string", "string"]}

//===----------------------------------------------------------------------===//

namespace {

// Simplifies pattern containing a corert const tensor op followed by a
// `tfrt_fallback_async.corert_tensorhandle_to_fallback_tensor` op to a single
// tfrt_fallback_async const tensor.
struct ConstCoreRTTensorHandleToFallbackTensorCanonicalization
    : public OpRewritePattern<CoreRTTensorHandleToFallbackTensorOp> {
  using OpRewritePattern<

 public:
  explicit FallbackAsyncDialect(MLIRContext *context);
  static StringRef getDialectNamespace() { return "tfrt_fallback_async"; }
};

}  // namespace fallback_async
}  // namespace tfrt

#define GET_OP_CLASSES
#include "tensorflow/compiler/mlir/tfrt/ir/tfrt_fallback_async.h.inc"

  // CHECK: tfrt_fallback_async.executeop key(0) cost(100) device("cpu") "tf.Relu"(%{{.*}}) {T = f32} : 1
  %2 = tfrt_fallback_async.executeop key(0) cost(100) device("cpu") "tf.Relu"(%1) {T = f32} : 1
  // CHECK: tfrt_fallback_async.fallback_tensor_to_corert_tensorhandle

  // CHECK: [[b:%.*]] = tfrt_fallback_async.const_dense_tensor dense<[false, true]> : tensor<2xi1>
  // CHECK-NEXT:      [[a:%.*]] = tfrt_fallback_async.const_dense_tensor dense<[true, false]> : tensor<2xi1>
  // CHECK-NEXT: tfrt_fallback_async.corert_tensorhandle_to_fallback_tensor [[arg0]]
  // CHECK-NEXT: tfrt_fallback_async.corert_tensorhandle_to_fallback_tensor [[arg1]]

  %a2 = tfrt_fallback_async.const_dense_tensor dense<[[3, 3], [3, 3]]> : tensor<2x2xi32>
  %b = tfrt_fallback_async.const_dense_tensor dense<[[1, 1], [1, 1]]> : tensor<2x2xi32>

  // Two batch_size=2 batches get concatenated.
  %result_1 = tfrt_fallback_async.batch_function device("/device:CPU:0") @matmul_cpu (%a1, %b) {
      num_batch_threads = 1,
      max_batch_size = 4,
      allowed_batch_sizes = [4],
      batch_timeout_micros = 1000000,

  // CHECK: [[value:%.*]] = tfrt_fallback_async.executeop key({{.*}}) {{.*}} "tf.AddV2"([[arg]], [[arg]])
  %0 = tfrt_fallback_async.executeop key(0) cost(1024) device("/job:localhost/replica:0/task:0/device:CPU:0") "tf.AddV2"(%arg, %arg) {T = f32} : 1
  // CHECK: [[copy:%.*]] = tfrt_fallback_async.copy_if_small [[value]]
  // CHECK: tfrt_fallback_async.executeop key({{.*}}) {{.*}} "tf.AddV2"([[copy]], [[copy]])

    tbl_outs = [
        (
            ["-gen-op-decls"],
            "tfrt_fallback_async.h.inc",
        ),
        (
            ["-gen-op-defs"],
            "tfrt_fallback_async.cpp.inc",
        ),
    ],
    tblgen = "@llvm-project//mlir:mlir-tblgen",
    td_file = "tfrt_fallback_async.td",
    deps = [":tfrt_fallback_td_files"],
)

gentbl_cc_library(

  %ch0 = tfrt.new.chain

  %ch1 = tfrt_fallback_async.createop(%ch0) key(0) device("/CPU:0") "tf.Const"()
         { dtype = i32, value = dense<[2]> : tensor<1xi32> } num_args(0)
  %ch2 = tfrt_fallback_async.createop(%ch1) key(1) device("/CPU:0")
         "tf.TestAsyncTfrtAsyncThread"() {T = i32} num_args(1)
  %ch3 = tfrt_fallback_async.createop(%ch2) key(2) device("/CPU:0")
         "tf.TestPrintThreadName"() num_args(0)

    // The predicate function should be inlined.
    // CHECK-DAG: tfrt_fallback_async.const_dense_tensor dense<9> : tensor<i32>
    // CHECK-DAG: tfrt_fallback_async.const_dense_tensor dense<0> : tensor<i32>
    // CHECK-NEXT: tfrt_fallback_async.executeop key({{.*}}) cost({{.*}}) device("/device:CPU:0") "tf.Less"
    // CHECK-NEXT: [[pred:%.*]] = tfrt_fallback_async.predicate