I think it'sprobably worth trying to do the "smart" thing here, since exponents with at least one constant part are reasonably common. But if others think the additional logic in the optimizer is too much, we can just say that the result of** an**= is unknown (even when it may technically be knowable):

if (oparg==NB_POWER||oparg==NB_INPLACE_POWER) {res=sym_new_unknown(ctx);        }elseif (oparg==NB_TRUE_DIVIDE||oparg==NB_INPLACE_TRUE_DIVIDE) {res=sym_new_type(ctx,&PyFloat_Type);        }elseif (sym_matches_type(left,&PyLong_Type)&&sym_matches_type(left,&PyLong_Type)) {res=sym_new_type(ctx,&PyLong_Type);        }else {res=sym_new_type(ctx,&PyFloat_Type);        }

The runtime cost would be an additional guard in JIT code following a** or**=.

Issue:The JIT's understanding of** is wrong #127809

brandtbucher added4 commits

December 11, 2024 14:27

Add failing regression tests

a082766

Add some new asserts to specialized math

43d8a3d

Fix the optimizer's understanding of exponentiation

5e6088e

blurb add

222b2c8

brandtbucher added interpreter-core

(Objects, Python, Grammar, and Parser dirs)

type-crash

A hard crash of the interpreter, possibly with a core dump

topic-JIT labels

Dec 11, 2024

brandtbucher self-assigned this

Dec 11, 2024

brandtbucher requested review fromFidget-Spinner andmarkshannon ascode owners

December 11, 2024 22:44

bedevere-appbot mentioned this pull request

Dec 11, 2024

The JIT's understanding of** is wrong#127809

Closed

bedevere-appbot added the awaiting core review label

Dec 11, 2024

Fidget-Spinner reviewed

Dec 12, 2024

View reviewed changes

Python/optimizer_bytecodes.cShow resolvedHide resolved

markshannon reviewed

Dec 12, 2024

View reviewed changes

Python/optimizer_bytecodes.c Outdated

		gotobinary_op_done;
		}
		if (oparg==NB_POWER\|\|oparg==NB_INPLACE_POWER) {
		// This one's fun: the type of the result depends on the values

Copy link

Member

markshannonDec 12, 2024•
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others.Learn more.

I'm not convinced that this is worth the complexity for anything other than integer constant right hand sides.
It the rhs is an int constant, then the result is the type of the lhs (for ints and floats) otherwise, "not known".
Calculating any other result is so slow that the cost of the guard we could potentially remove is negligible.

Copy link

Contributor

mdboomDec 12, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others.Learn more.

Doesn't a negative int rhs produce a float?

>>> 3 ** -10.3333333333333333

Your point may still stand that it's too expensive, but unfortunately the assumption that if rhs is an int we can determine the result without looking at the value doesn't hold.