I came across the following rewrite rule in the simplifier:
```cpp
// In RewriteSimplifier::Impl::VisitExpr_(const DivNode* op)
if (const FloatImmNode* ptr = op->b.as<FloatImmNode>()) {
ICHECK(op->dtype.is_float() || op->dtype.is_bfloat16() ||
datatype::Registry::Global()->GetTypeRegistered(op->dtype.code()));
return op->a * make_const(op->b.dtype(), 1.0 / ptr->value);
}
```
>From my understanding, this transforms a floating‑point constant division
```
a / const
```
into a multiplication by its reciprocal:
```
a * (1.0 / const)
```
presumably for performance reasons.
---
### Question
For floating‑point computations, this rewrite is not always **bit‑wise
identical**, since multiplication and division may follow different rounding
paths and use different intermediate representations.
This means that, for certain workloads, developers may find that the program’s
output is not bit‑identical to what they expected.
Should we consider adding a flag to disable such simplifications? Or is this
generally not a significant issue, as long as a kernel’s output remains
deterministic?
---
[Visit
Topic](https://discuss.tvm.apache.org/t/discuss-is-constant-division-to-multiplication-rewrite-in-tvm-necessary/18615/1)
to respond.
You are receiving this because you enabled mailing list mode.
To unsubscribe from these emails, [click
here](https://discuss.tvm.apache.org/email/unsubscribe/ab161b36f0685f3cfa29819c1bdb4d321a03458814b171604bc852b8fb5f4409).
