Why is ceil implemented differently in TVM and HalideIR

yzhliu · April 16, 2019, 6:13am

tvm::ceil:

dmlc/tvm/blob/master/src/lang/expr_operator.cc#L436


return ir::Call::make(x.type(), "fmod", { x, y }, ir::Call::PureIntrinsic);
}


Expr floor(Expr x) {
using ir::FloatImm;
const FloatImm* fx = x.as<FloatImm>();
if (fx) return FloatImm::make(x.type(), std::floor(fx->value));
return ir::Call::make(x.type(), "floor", {x}, ir::Call::PureIntrinsic);
}


Expr ceil(Expr x) {
using ir::FloatImm;
const FloatImm* fx = x.as<FloatImm>();
if (fx) return FloatImm::make(x.type(), std::ceil(fx->value));
return ir::Call::make(x.type(), "ceil", {x}, ir::Call::PureIntrinsic);
}


Expr round(Expr x) {
using ir::FloatImm;
const FloatImm* fx = x.as<FloatImm>();
if (fx) return FloatImm::make(x.type(), std::nearbyint(fx->value));

HalideIR::Internal::ceil:

github.com

dmlc/HalideIR/blob/55ba1778fd264c7507953552d8e51212ed11f748/src/ir/IROperator.h#L1223


   else {
       Type t = Float(32, x.type().lanes());
       return Internal::Call::make(t, "floor_f32", {cast(t, x)}, Internal::Call::PureExtern);
   }
}


/** Return the least whole number greater than or equal to a
* floating-point expression. If the argument is not floating-point,
* it is cast to Float(32). The return value is still in floating
* point, despite being a whole number. Vectorizes cleanly. */
inline Expr ceil(const Expr &x) {
   user_assert(x.defined()) << "ceil of undefined Expr\n";
   if (x.type().element_of() == Float(64)) {
       return Internal::Call::make(x.type(), "ceil_f64", {x}, Internal::Call::PureExtern);
   }
   else if (x.type().element_of() == Float(16)) {
       return Internal::Call::make(Float(16), "ceil_f16", {x}, Internal::Call::PureExtern);
   }
   else {
       Type t = Float(32, x.type().lanes());
       return Internal::Call::make(t, "ceil_f32", {cast(t, x)}, Internal::Call::PureExtern);

Such difference effectively prevent from simplifying properly:

github.com

dmlc/HalideIR/blob/master/src/arithmetic/Simplify.cpp#L4208


    const double *f0 = as_const_float(arg0);
    const double *f1 = as_const_float(arg1);
    if (f0 && f1) {
        expr = FloatImm::make(arg0.type(), std::pow(*f0, *f1));
    } else if (!arg0.same_as(op->args[0]) || !arg1.same_as(op->args[1])) {
        expr = Call::make(op->type, op->name, {arg0, arg1}, op->call_type);
    } else {
        expr = self;
    }
} else if (op->call_type == Call::PureExtern &&
           (op->name == "floor_f32" || op->name == "ceil_f32" ||
            op->name == "round_f32" || op->name == "trunc_f32")) {
    internal_assert(op->args.size() == 1);
    Expr arg = mutate(op->args[0]);
    if (propagate_indeterminate_expression(arg, op->type, &expr)) {
        return;
    }
    const Call *call = arg.as<Call>();
    if (const double *f = as_const_float(arg)) {
        if (op->name == "floor_f32") {
            expr = FloatImm::make(arg.type(), std::floor(*f));

Is it a bug? @tqchen

tqchen · April 16, 2019, 12:57pm

This is intentional，we can go and fix it to use the new ceil convention in the new simplification infra