[NFC][mlir] Adding some helpful EDSC intrinsics

[ftynse]

mlir/include/mlir/EDSC/Intrinsics.h

124

Please make sure the name corresponds to the instruction name, e.g. ConstantOp should be just constant.

[kernhanda]

constant_data -> constant

[kernhanda]

Someone will have to commit this on my behalf.

[nicolasvasilache]

mlir/include/mlir/EDSC/Intrinsics.h

124

this breaks the build, please fix the other use case:

llvm-project/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp: In member function ‘virtual mlir::PatternMatchResult {anonymous}::SliceOpConversion::matchAndRewrite(mlir::Operation*, llvm::ArrayRef<mlir::Value>, mlir::ConversionPatternRewriter&) const’:
llvm-project/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp:268:9: error: reference to ‘constant’ is ambiguous
  268 |         constant(int64Ty, rewriter.getIntegerAttr(rewriter.getIndexType(), 0));
      |         ^~~~~~~~
In file included from llvm-project/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp:20:
llvm-project/mlir/include/mlir/EDSC/Intrinsics.h:203:7: note: candidates are: ‘using constant = struct mlir::edsc::intrinsics::ValueBuilder<mlir::ConstantOp>’
  203 | using constant = ValueBuilder<ConstantOp>;
      |       ^~~~~~~~
llvm-project/mlir/lib/Conversion/LinalgToLLVM/LinalgToLLVM.cpp:54:7: note:                 ‘using constant = struct mlir::edsc::intrinsics::ValueBuilder<mlir::LLVM::ConstantOp>’
   54 | using constant = ValueBuilder<mlir::LLVM::ConstantOp>;
      |       ^~~~~~~~

[kernhanda]

fixing build fix

[kernhanda]

ran clang-format

[kernhanda]

mlir/include/mlir/EDSC/Intrinsics.h

124

Thanks for catching this.

[kernhanda]

Ping. :) Someone will also have to commit this on my behalf.

[nicolasvasilache]

My apologies for the delay..
Also, please note that https://github.com/llvm/llvm-project/commit/75394e1301dd1d4739a24d440e9996c52e5b5570#diff-6635fa1a5b0b10edf6e511585c7c986d refactored things significantly on the EDSC front so this would need a rebase.

[kernhanda]

Rebased

[nicolasvasilache]

Thank you!

mlir/include/mlir/Dialect/StandardOps/EDSC/Intrinsics.h

ValueBuilder(OperationFolder *folder, T1 t1, T2 t2, ArrayRef<ValueHandle> vs,
             folder, detail::unpack(t1), detail::unpack(t2), detail::unpack(vs),
             detail::unpack(args)...)) {}
 };
 } // namespace folded
 
 using std_addf = ValueBuilder<AddFOp>;
 using std_alloc = ValueBuilder<AllocOp>;
 using std_call = OperationBuilder<CallOp>;
+using std_constant = ValueBuilder<ConstantOp>;
 using std_constant_float = ValueBuilder<ConstantFloatOp>;
 using std_constant_index = ValueBuilder<ConstantIndexOp>;
 using std_constant_int = ValueBuilder<ConstantIntOp>;
 using std_dealloc = OperationBuilder<DeallocOp>;
 using std_dim = ValueBuilder<DimOp>;
+using std_extract_element = ValueBuilder<ExtractElementOp>;
+using std_index_cast = ValueBuilder<IndexCastOp>;
 using std_muli = ValueBuilder<MulIOp>;
 using std_mulf = ValueBuilder<MulFOp>;
 using std_memref_cast = ValueBuilder<MemRefCastOp>;
 using std_ret = OperationBuilder<ReturnOp>;
 using std_select = ValueBuilder<SelectOp>;
 using std_load = ValueBuilder<LoadOp>;
 using std_store = OperationBuilder<StoreOp>;
 using std_subi = ValueBuilder<SubIOp>;
+using std_sub_view = ValueBuilder<SubViewOp>;
 using std_tanh = ValueBuilder<TanhOp>;
+using std_tensor_load = ValueBuilder<TensorLoadOp>;
+using std_tensor_store = OperationBuilder<TensorStoreOp>;
 using std_view = ValueBuilder<ViewOp>;
 using std_zero_extendi = ValueBuilder<ZeroExtendIOp>;
 using std_sign_extendi = ValueBuilder<SignExtendIOp>;
 
 /// Branches into the mlir::Block* captured by BlockHandle `b` with `operands`.
 ///
 /// Prerequisites:
 ///   All Handles have already captured previously constructed IR objects.
-OperationHandle br(BlockHandle bh, ArrayRef<ValueHandle> operands);
+OperationHandle std_br(BlockHandle bh, ArrayRef<ValueHandle> operands);
 
 /// Creates a new mlir::Block* and branches to it from the current block.
 /// Argument types are specified by `operands`.
 /// Captures the new block in `bh` and the actual `operands` in `captures`. To
 /// insert the new mlir::Block*, a local ScopedContext is constructed and
 /// released to the current block. The branch operation is then added to the
 /// new block.
 ///
 /// Prerequisites:
 ///   `b` has not yet captured an mlir::Block*.
 ///   No `captures` have captured any mlir::Value.
 ///   All `operands` have already captured an mlir::Value
 ///   captures.size() == operands.size()
 ///   captures and operands are pairwise of the same type.
-OperationHandle br(BlockHandle *bh, ArrayRef<ValueHandle *> captures,
+OperationHandle std_br(BlockHandle *bh, ArrayRef<ValueHandle *> captures,
                        ArrayRef<ValueHandle> operands);
 
 /// Branches into the mlir::Block* captured by BlockHandle `trueBranch` with
 /// `trueOperands` if `cond` evaluates to `true` (resp. `falseBranch` and
 /// `falseOperand` if `cond` evaluates to `false`).
 ///
 /// Prerequisites:
 ///   All Handles have captured previously constructed IR objects.
-OperationHandle cond_br(ValueHandle cond, BlockHandle trueBranch,
+OperationHandle std_cond_br(ValueHandle cond, BlockHandle trueBranch,
                             ArrayRef<ValueHandle> trueOperands,
                             BlockHandle falseBranch,
                             ArrayRef<ValueHandle> falseOperands);
 
 /// Eagerly creates new mlir::Block* with argument types specified by
 /// `trueOperands`/`falseOperands`.
 /// Captures the new blocks in `trueBranch`/`falseBranch` and the arguments in
 /// `trueCaptures/falseCaptures`.
 /// To insert the new mlir::Block*, a local ScopedContext is constructed and
 /// released. The branch operation is then added in the original location and
 /// targeting the eagerly constructed blocks.
 ///
 /// Prerequisites:
 ///   `trueBranch`/`falseBranch` has not yet captured an mlir::Block*.
 ///   No `trueCaptures`/`falseCaptures` have captured any mlir::Value.
 ///   All `trueOperands`/`trueOperands` have already captured an mlir::Value
 ///   `trueCaptures`.size() == `trueOperands`.size()
 ///   `falseCaptures`.size() == `falseOperands`.size()
 ///   `trueCaptures` and `trueOperands` are pairwise of the same type
 ///   `falseCaptures` and `falseOperands` are pairwise of the same type.
-OperationHandle cond_br(ValueHandle cond, BlockHandle *trueBranch,
+OperationHandle std_cond_br(ValueHandle cond, BlockHandle *trueBranch,
                             ArrayRef<ValueHandle *> trueCaptures,
                             ArrayRef<ValueHandle> trueOperands,
                             BlockHandle *falseBranch,
                             ArrayRef<ValueHandle *> falseCaptures,
                             ArrayRef<ValueHandle> falseOperands);
 
 /// Provide an index notation around sdt_load and std_store.
 using StdIndexedValue =
     TemplatedIndexedValue<intrinsics::std_load, intrinsics::std_store>;
 
 using folded_std_constant_index = folded::ValueBuilder<ConstantIndexOp>;
 using folded_std_constant_float = folded::ValueBuilder<ConstantFloatOp>;
 using folded_std_dim = folded::ValueBuilder<DimOp>;
 using folded_std_muli = folded::ValueBuilder<MulIOp>;
 } // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_STANDARDOPS_EDSC_INTRINSICS_H_

mlir/include/mlir/EDSC/Builders.h

struct OperationHandle : public CapturableHandle {
 
   OperationHandle(const OperationHandle &) = default;
   OperationHandle &operator=(const OperationHandle &) = default;
 
   /// Generic mlir::Op create. This is the key to being extensible to the whole
   /// of MLIR without duplicating the type system or the op definitions.
   template <typename Op, typename... Args>
   static OperationHandle create(Args... args);
-  template <typename Op, typename... Args> static Op createOp(Args... args);
+  template <typename Op, typename... Args>
+  static Op createOp(Args... args);
 
   /// Generic create for a named operation.
   static OperationHandle create(StringRef name, ArrayRef<ValueHandle> operands,
                                 ArrayRef<Type> resultTypes,
                                 ArrayRef<NamedAttribute> attributes = {});
 
   operator Operation *() { return op; }
   Operation *getOperation() const { return op; }
 
 private:
   Operation *op;
 };
 
 /// Simple wrapper to build a generic operation without successor blocks.
-template <typename HandleType> struct CustomOperation {
+template <typename HandleType>
+struct CustomOperation {
   CustomOperation(StringRef name) : name(name) {
     static_assert(std::is_same<HandleType, ValueHandle>() ||
                       std::is_same<HandleType, OperationHandle>(),
                   "Only CustomOperation<ValueHandle> or "
                   "CustomOperation<OperationHandle> can be constructed.");
   }
   HandleType operator()(ArrayRef<ValueHandle> operands = {},
                         ArrayRef<Type> resultTypes = {},
for (auto v : values)
     res.push_back(ValueHandle(v));
   return res;
 }
 
 /// A TemplatedIndexedValue brings an index notation over the template Load and
 /// Store parameters. Assigning to an IndexedValue emits an actual `Store`
 /// operation, while converting an IndexedValue to a ValueHandle emits an actual
 /// `Load` operation.
-template <typename Load, typename Store> class TemplatedIndexedValue {
+template <typename Load, typename Store>
+class TemplatedIndexedValue {
 public:
   explicit TemplatedIndexedValue(Type t) : base(t) {}
   explicit TemplatedIndexedValue(Value v)
       : TemplatedIndexedValue(ValueHandle(v)) {}
   explicit TemplatedIndexedValue(ValueHandle v) : base(v) {}
 
   TemplatedIndexedValue(const TemplatedIndexedValue &rhs) = default;
 
public:
   }
 
   /// Emits a `load` when converting to a ValueHandle.
   operator ValueHandle() const {
     return Load(getBase(), {indices.begin(), indices.end()});
   }
 
   /// Emits a `load` when converting to a Value.
-  Value operator*(void) const {
+  Value operator*(void)const {
     return Load(getBase(), {indices.begin(), indices.end()}).getValue();
   }
 
   ValueHandle getBase() const { return base; }
 
   /// Operator overloadings.
   ValueHandle operator+(ValueHandle e);
   ValueHandle operator-(ValueHandle e);

mlir/include/mlir/EDSC/Intrinsics.h

public:
   }
   operator ArrayRef<Value>() { return values; }
 
 private:
   ValueHandleArray() = default;
   SmallVector<Value, 8> values;
 };
 
-template <typename T> inline T unpack(T value) { return value; }
+template <typename T>
+inline T unpack(T value) {
+  return value;
+}
 
 inline detail::ValueHandleArray unpack(ArrayRef<ValueHandle> values) {
   return detail::ValueHandleArray(values);
 }
 
 } // namespace detail
 
 /// Helper variadic abstraction to allow extending to any MLIR op without
 /// boilerplate or Tablegen.
 /// Arguably a builder is not a ValueHandle but in practice it is only used as
 /// an alias to a notional ValueHandle<Op>.
 /// Implementing it as a subclass allows it to compose all the way to Value.
 /// Without subclassing, implicit conversion to Value would fail when composing
 /// in patterns such as: `select(a, b, select(c, d, e))`.
-template <typename Op> struct ValueBuilder : public ValueHandle {
+template <typename Op>
+struct ValueBuilder : public ValueHandle {
   // Builder-based
   template <typename... Args>
   ValueBuilder(Args... args)
       : ValueHandle(ValueHandle::create<Op>(detail::unpack(args)...)) {}
   ValueBuilder(ArrayRef<ValueHandle> vs)
       : ValueBuilder(ValueBuilder::create<Op>(detail::unpack(vs))) {}
   template <typename... Args>
   ValueBuilder(ArrayRef<ValueHandle> vs, Args... args)
       : ValueHandle(ValueHandle::create<Op>(detail::unpack(vs),
                                             detail::unpack(args)...)) {}
   template <typename T, typename... Args>
   ValueBuilder(T t, ArrayRef<ValueHandle> vs, Args... args)
       : ValueHandle(ValueHandle::create<Op>(
             detail::unpack(t), detail::unpack(vs), detail::unpack(args)...)) {}
   template <typename T1, typename T2, typename... Args>
   ValueBuilder(T1 t1, T2 t2, ArrayRef<ValueHandle> vs, Args... args)
       : ValueHandle(ValueHandle::create<Op>(
             detail::unpack(t1), detail::unpack(t2), detail::unpack(vs),
             detail::unpack(args)...)) {}
 
   ValueBuilder() : ValueHandle(ValueHandle::create<Op>()) {}
 };
 
-template <typename Op> struct OperationBuilder : public OperationHandle {
+template <typename Op>
+struct OperationBuilder : public OperationHandle {
   template <typename... Args>
   OperationBuilder(Args... args)
       : OperationHandle(OperationHandle::create<Op>(detail::unpack(args)...)) {}
   OperationBuilder(ArrayRef<ValueHandle> vs)
       : OperationHandle(OperationHandle::create<Op>(detail::unpack(vs))) {}
   template <typename... Args>
   OperationBuilder(ArrayRef<ValueHandle> vs, Args... args)
       : OperationHandle(OperationHandle::create<Op>(detail::unpack(vs),
                                                     detail::unpack(args)...)) {}
   template <typename T, typename... Args>
   OperationBuilder(T t, ArrayRef<ValueHandle> vs, Args... args)
       : OperationHandle(OperationHandle::create<Op>(
             detail::unpack(t), detail::unpack(vs), detail::unpack(args)...)) {}
   template <typename T1, typename T2, typename... Args>
   OperationBuilder(T1 t1, T2 t2, ArrayRef<ValueHandle> vs, Args... args)
       : OperationHandle(OperationHandle::create<Op>(
             detail::unpack(t1), detail::unpack(t2), detail::unpack(vs),
             detail::unpack(args)...)) {}
   OperationBuilder() : OperationHandle(OperationHandle::create<Op>()) {}
 };
 
 } // namespace intrinsics
 } // namespace edsc
 } // namespace mlir
 
 #endif // MLIR_EDSC_INTRINSICS_H_

mlir/lib/Dialect/StandardOps/EDSC/Intrinsics.cpp

 //===- Intrinsics.cpp - MLIR Operations for Declarative Builders ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/StandardOps/EDSC/Intrinsics.h"
 #include "mlir/IR/AffineExpr.h"
 
 using namespace mlir;
 using namespace mlir::edsc;
 
-OperationHandle mlir::edsc::intrinsics::br(BlockHandle bh,
+OperationHandle mlir::edsc::intrinsics::std_br(BlockHandle bh,
                                                ArrayRef<ValueHandle> operands) {
   assert(bh && "Expected already captured BlockHandle");
   for (auto &o : operands) {
     (void)o;
     assert(o && "Expected already captured ValueHandle");
   }
   SmallVector<Value, 4> ops(operands.begin(), operands.end());
   return OperationHandle::create<BranchOp>(bh.getBlock(), ops);
 }
+
 static void enforceEmptyCapturesMatchOperands(ArrayRef<ValueHandle *> captures,
                                               ArrayRef<ValueHandle> operands) {
   assert(captures.size() == operands.size() &&
          "Expected same number of captures as operands");
   for (auto it : llvm::zip(captures, operands)) {
     (void)it;
     assert(!std::get<0>(it)->hasValue() &&
            "Unexpected already captured ValueHandle");
     assert(std::get<1>(it) && "Expected already captured ValueHandle");
     assert(std::get<0>(it)->getType() == std::get<1>(it).getType() &&
            "Expected the same type for capture and operand");
   }
 }
 
-OperationHandle mlir::edsc::intrinsics::br(BlockHandle *bh,
+OperationHandle mlir::edsc::intrinsics::std_br(BlockHandle *bh,
                                                ArrayRef<ValueHandle *> captures,
                                                ArrayRef<ValueHandle> operands) {
   assert(!*bh && "Unexpected already captured BlockHandle");
   enforceEmptyCapturesMatchOperands(captures, operands);
   BlockBuilder(bh, captures)(/* no body */);
   SmallVector<Value, 4> ops(operands.begin(), operands.end());
   return OperationHandle::create<BranchOp>(bh->getBlock(), ops);
 }
 
 OperationHandle
-mlir::edsc::intrinsics::cond_br(ValueHandle cond, BlockHandle trueBranch,
+mlir::edsc::intrinsics::std_cond_br(ValueHandle cond, BlockHandle trueBranch,
                                     ArrayRef<ValueHandle> trueOperands,
                                     BlockHandle falseBranch,
                                     ArrayRef<ValueHandle> falseOperands) {
   SmallVector<Value, 4> trueOps(trueOperands.begin(), trueOperands.end());
   SmallVector<Value, 4> falseOps(falseOperands.begin(), falseOperands.end());
   return OperationHandle::create<CondBranchOp>(
       cond, trueBranch.getBlock(), trueOps, falseBranch.getBlock(), falseOps);
 }
 
-OperationHandle mlir::edsc::intrinsics::cond_br(
+OperationHandle mlir::edsc::intrinsics::std_cond_br(
     ValueHandle cond, BlockHandle *trueBranch,
     ArrayRef<ValueHandle *> trueCaptures, ArrayRef<ValueHandle> trueOperands,
     BlockHandle *falseBranch, ArrayRef<ValueHandle *> falseCaptures,
     ArrayRef<ValueHandle> falseOperands) {
   assert(!*trueBranch && "Unexpected already captured BlockHandle");
   assert(!*falseBranch && "Unexpected already captured BlockHandle");
   enforceEmptyCapturesMatchOperands(trueCaptures, trueOperands);
   enforceEmptyCapturesMatchOperands(falseCaptures, falseOperands);
   BlockBuilder(trueBranch, trueCaptures)(/* no body */);
   BlockBuilder(falseBranch, falseCaptures)(/* no body */);
   SmallVector<Value, 4> trueOps(trueOperands.begin(), trueOperands.end());
   SmallVector<Value, 4> falseOps(falseOperands.begin(), falseOperands.end());
   return OperationHandle::create<CondBranchOp>(
       cond, trueBranch->getBlock(), trueOps, falseBranch->getBlock(), falseOps);
 }

mlir/test/EDSC/builder-api-test.cpp

TEST_FUNC(builder_blocks) {
   ValueHandle arg1(c1.getType()), arg2(c1.getType()), arg3(c1.getType()),
       arg4(c1.getType()), r(c1.getType());
 
   BlockHandle b1, b2, functionBlock(&f.front());
   BlockBuilder(&b1, {&arg1, &arg2})(
       // b2 has not yet been constructed, need to come back later.
       // This is a byproduct of non-structured control-flow.
   );
-  BlockBuilder(&b2, {&arg3, &arg4})([&] { br(b1, {arg3, arg4}); });
+  BlockBuilder(&b2, {&arg3, &arg4})([&] { std_br(b1, {arg3, arg4}); });
   // The insertion point within the toplevel function is now past b2, we will
   // need to get back the entry block.
   // This is what happens with unstructured control-flow..
   BlockBuilder(b1, Append())([&] {
     r = arg1 + arg2;
-    br(b2, {arg1, r});
+    std_br(b2, {arg1, r});
   });
   // Get back to entry block and add a branch into b1
-  BlockBuilder(functionBlock, Append())([&] { br(b1, {c1, c2}); });
+  BlockBuilder(functionBlock, Append())([&] { std_br(b1, {c1, c2}); });
 
   // clang-format off
   // CHECK-LABEL: @builder_blocks
   // CHECK:        %{{.*}} = constant 42 : i32
   // CHECK-NEXT:   %{{.*}} = constant 1234 : i32
   // CHECK-NEXT:   br ^bb1(%{{.*}}, %{{.*}} : i32, i32)
   // CHECK-NEXT: ^bb1(%{{.*}}: i32, %{{.*}}: i32):   // 2 preds: ^bb0, ^bb2
   // CHECK-NEXT:   %{{.*}} = addi %{{.*}}, %{{.*}} : i32
ValueHandle c1(ValueHandle::create<ConstantIntOp>(42, 32)),
       c2(ValueHandle::create<ConstantIntOp>(1234, 32));
   ValueHandle arg1(c1.getType()), arg2(c1.getType()), arg3(c1.getType()),
       arg4(c1.getType()), r(c1.getType());
 
   // clang-format off
   BlockHandle b1, b2;
   { // Toplevel function scope.
     // Build a new block for b1 eagerly.
-    br(&b1, {&arg1, &arg2}, {c1, c2});
+    std_br(&b1, {&arg1, &arg2}, {c1, c2});
     // Construct a new block b2 explicitly with a branch into b1.
     BlockBuilder(&b2, {&arg3, &arg4})([&]{
-        br(b1, {arg3, arg4});
+        std_br(b1, {arg3, arg4});
     });
     /// And come back to append into b1 once b2 exists.
     BlockBuilder(b1, Append())([&]{
         r = arg1 + arg2;
-        br(b2, {arg1, r});
+        std_br(b2, {arg1, r});
     });
   }
 
   // CHECK-LABEL: @builder_blocks_eager
   // CHECK:        %{{.*}} = constant 42 : i32
   // CHECK-NEXT:   %{{.*}} = constant 1234 : i32
   // CHECK-NEXT:   br ^bb1(%{{.*}}, %{{.*}} : i32, i32)
   // CHECK-NEXT: ^bb1(%{{.*}}: i32, %{{.*}}: i32):   // 2 preds: ^bb0, ^bb2
ValueHandle c32(ValueHandle::create<ConstantIntOp>(32, 32)),
       c42(ValueHandle::create<ConstantIntOp>(42, 32));
   ValueHandle arg1(c32.getType()), arg2(c64.getType()), arg3(c32.getType());
 
   BlockHandle b1, b2, functionBlock(&f.front());
   BlockBuilder(&b1, {&arg1})([&] { std_ret(); });
   BlockBuilder(&b2, {&arg2, &arg3})([&] { std_ret(); });
   // Get back to entry block and add a conditional branch
   BlockBuilder(functionBlock, Append())([&] {
-    cond_br(funcArg, b1, {c32}, b2, {c64, c42});
+    std_cond_br(funcArg, b1, {c32}, b2, {c64, c42});
   });
 
   // clang-format off
   // CHECK-LABEL: @builder_cond_branch
   // CHECK:   %{{.*}} = constant 32 : i32
   // CHECK-NEXT:   %{{.*}} = constant 64 : i64
   // CHECK-NEXT:   %{{.*}} = constant 42 : i32
   // CHECK-NEXT:   cond_br %{{.*}}, ^bb1(%{{.*}} : i32), ^bb2(%{{.*}}, %{{.*}} : i64, i32)
TEST_FUNC(builder_cond_branch_eager) {
   ValueHandle funcArg(f.getArgument(0));
   ValueHandle c32(ValueHandle::create<ConstantIntOp>(32, 32)),
       c64(ValueHandle::create<ConstantIntOp>(64, 64)),
       c42(ValueHandle::create<ConstantIntOp>(42, 32));
   ValueHandle arg1(c32.getType()), arg2(c64.getType()), arg3(c32.getType());
 
   // clang-format off
   BlockHandle b1, b2;
-  cond_br(funcArg, &b1, {&arg1}, {c32}, &b2, {&arg2, &arg3}, {c64, c42});
+  std_cond_br(funcArg, &b1, {&arg1}, {c32}, &b2, {&arg2, &arg3}, {c64, c42});
   BlockBuilder(b1, Append())([]{
       std_ret();
   });
   BlockBuilder(b2, Append())([]{
       std_ret();
   });
 
   // CHECK-LABEL: @builder_cond_branch_eager