[tvm][arithmetic] Should we use the empty_value as base for ComputeReduce?

zhiics · February 8, 2019, 9:38pm

Is there any reasons we only use the empty_value when values is empty?

dmlc/tvm/blob/master/src/arithmetic/compute_expr.h#L98


inline Expr ComputeExpr<ir::Max>(Expr a, Expr b) {
return HalideIR::Internal::Interval::make_max(a, b);
}


template<>
inline Expr ComputeExpr<ir::Min>(Expr a, Expr b) {
return HalideIR::Internal::Interval::make_min(a, b);
}


template<typename Op>
inline Expr ComputeReduce(const Array<Expr>& values, Expr empty_value) {
if (values.size() == 0U) {
  CHECK(empty_value.defined());
  return empty_value;
}
Expr res = values[0];
for (size_t i = 1; i < values.size(); ++i) {
  res = ComputeExpr<Op>(res, values[i]);
}
return res;
}

Should we do it like the following?

  template<typename Op>
  inline Expr ComputeReduce(const Array<Expr>& values, Expr empty_value) {
    if (values.size() == 0U) {
      CHECK(empty_value.defined());
      return empty_value;
    }
    Expr res = empty_value;
    for (size_t i = 0; i < values.size(); ++i) {
      res = ComputeExpr<Op>(res, values[i]);
    }
    return res;
  }

The reason why I am asking is sometime we might need to cast the reduced value to empty_value. For example, we can have int64_t empty_value and cast the product of Array<int32>values to int64 when needed.

@tqchen @yzhliu @wweic

yzhliu · February 9, 2019, 2:55am

@tqchen Could you comment? I think it is more natural to make it have the same semantic as foldleft or std::accumulate

tqchen · February 9, 2019, 6:12pm

The main reason is to avoid additional expressions in the case of sum. Because otherwise sum([x]) will results in 0 + x, which is not very ideal

zhiics · February 9, 2019, 9:39pm

sorry, what’s the problem for 0 + x?

tqchen · February 10, 2019, 6:48pm

Just to keep the symbolic expression minimum

yzhliu · February 12, 2019, 6:52pm

but we can do ir::simplify, right?

tqchen · February 12, 2019, 7:05pm

That is true, however in simple cases as such, being able to eagerly simplify things help us to avoid symbolic expression when possible.