From 1a8ea6187474fcc5896cf4b7f47074673e07ad42 Mon Sep 17 00:00:00 2001 From: Jukka Lehtosalo Date: Mon, 20 Mar 2023 13:55:13 +0000 Subject: [PATCH] [mypyc] Avoid boxing/unboxing when coercing between tuple types (#14899) Instead, coerce each tuple item individually. This makes some coercions between tuple types much faster, primarily because there is less (or no) allocation and deallocation going on. This speeds up the raytrace benchmark by about 7% (when using native floats). Related to mypyc/mypyc#99. --- mypyc/irbuild/ll_builder.py | 33 ++++++++++-- mypyc/test-data/irbuild-float.test | 20 +++++++ mypyc/test-data/irbuild-i64.test | 84 +++++++++++++++++++++++++++--- mypyc/test-data/run-floats.test | 8 +++ 4 files changed, 134 insertions(+), 11 deletions(-) diff --git a/mypyc/irbuild/ll_builder.py b/mypyc/irbuild/ll_builder.py index d41b532f9228..6a4599a324d4 100644 --- a/mypyc/irbuild/ll_builder.py +++ b/mypyc/irbuild/ll_builder.py @@ -68,6 +68,7 @@ SetMem, Truncate, TupleGet, + TupleSet, Unbox, Unreachable, Value, @@ -354,11 +355,33 @@ def coerce( return Float(float(src.value)) elif is_tagged(src_type) and is_float_rprimitive(target_type): return self.int_to_float(src, line) - else: - # To go from one unboxed type to another, we go through a boxed - # in-between value, for simplicity. - tmp = self.box(src) - return self.unbox_or_cast(tmp, target_type, line) + elif ( + isinstance(src_type, RTuple) + and isinstance(target_type, RTuple) + and len(src_type.types) == len(target_type.types) + ): + # Coerce between two tuple types by coercing each item separately + values = [] + for i in range(len(src_type.types)): + v = None + if isinstance(src, TupleSet): + item = src.items[i] + # We can't reuse register values, since they can be modified. + if not isinstance(item, Register): + v = item + if v is None: + v = TupleGet(src, i) + self.add(v) + values.append(v) + return self.add( + TupleSet( + [self.coerce(v, t, line) for v, t in zip(values, target_type.types)], line + ) + ) + # To go between any other unboxed types, we go through a boxed + # in-between value, for simplicity. + tmp = self.box(src) + return self.unbox_or_cast(tmp, target_type, line) if (not src_type.is_unboxed and target_type.is_unboxed) or not is_subtype( src_type, target_type ): diff --git a/mypyc/test-data/irbuild-float.test b/mypyc/test-data/irbuild-float.test index fa9bf1da4800..e3a60852574b 100644 --- a/mypyc/test-data/irbuild-float.test +++ b/mypyc/test-data/irbuild-float.test @@ -475,3 +475,23 @@ def init(n: int) -> None: # narrowing assignments, generate errors here x: float = n # E: Incompatible value representations in assignment (expression has type "int", variable has type "float") y: float = 5 # E: Incompatible value representations in assignment (expression has type "int", variable has type "float") + +[case testFloatCoerceTupleFromIntValues] +from __future__ import annotations + +def f(x: int) -> None: + t: tuple[float, float, float] = (x, 2.5, -7) +[out] +def f(x): + x :: int + r0 :: tuple[int, float, int] + r1 :: int + r2 :: float + r3, t :: tuple[float, float, float] +L0: + r0 = (x, 2.5, -14) + r1 = r0[0] + r2 = CPyFloat_FromTagged(r1) + r3 = (r2, 2.5, -7.0) + t = r3 + return 1 diff --git a/mypyc/test-data/irbuild-i64.test b/mypyc/test-data/irbuild-i64.test index 74eb126b937d..a18171c41d57 100644 --- a/mypyc/test-data/irbuild-i64.test +++ b/mypyc/test-data/irbuild-i64.test @@ -650,7 +650,6 @@ def f(x: i64, y: i64) -> Tuple[i64, i64]: return x, y def g() -> Tuple[i64, i64]: - # TODO: Avoid boxing and unboxing return 1, 2 def h() -> i64: @@ -666,13 +665,11 @@ L0: return r0 def g(): r0 :: tuple[int, int] - r1 :: object - r2 :: tuple[int64, int64] + r1 :: tuple[int64, int64] L0: r0 = (2, 4) - r1 = box(tuple[int, int], r0) - r2 = unbox(tuple[int64, int64], r1) - return r2 + r1 = (1, 2) + return r1 def h(): r0 :: tuple[int64, int64] r1, x, r2, y :: int64 @@ -2081,3 +2078,78 @@ L2: r6 = r5.a keep_alive x return r6 + +[case testI64ConvertBetweenTuples_64bit] +from __future__ import annotations +from mypy_extensions import i64 + +def f(t: tuple[int, i64, int]) -> None: + tt: tuple[int, i64, i64] = t + +def g(n: int) -> None: + t: tuple[i64, i64] = (1, n) +[out] +def f(t): + t :: tuple[int, int64, int] + r0 :: int + r1 :: int64 + r2 :: int + r3 :: native_int + r4 :: bit + r5, r6 :: int64 + r7 :: ptr + r8 :: c_ptr + r9 :: int64 + r10, tt :: tuple[int, int64, int64] +L0: + r0 = t[0] + r1 = t[1] + r2 = t[2] + r3 = r2 & 1 + r4 = r3 == 0 + if r4 goto L1 else goto L2 :: bool +L1: + r5 = r2 >> 1 + r6 = r5 + goto L3 +L2: + r7 = r2 ^ 1 + r8 = r7 + r9 = CPyLong_AsInt64(r8) + r6 = r9 + keep_alive r2 +L3: + r10 = (r0, r1, r6) + tt = r10 + return 1 +def g(n): + n :: int + r0 :: tuple[int, int] + r1 :: int + r2 :: native_int + r3 :: bit + r4, r5 :: int64 + r6 :: ptr + r7 :: c_ptr + r8 :: int64 + r9, t :: tuple[int64, int64] +L0: + r0 = (2, n) + r1 = r0[1] + r2 = r1 & 1 + r3 = r2 == 0 + if r3 goto L1 else goto L2 :: bool +L1: + r4 = r1 >> 1 + r5 = r4 + goto L3 +L2: + r6 = r1 ^ 1 + r7 = r6 + r8 = CPyLong_AsInt64(r7) + r5 = r8 + keep_alive r1 +L3: + r9 = (1, r5) + t = r9 + return 1 diff --git a/mypyc/test-data/run-floats.test b/mypyc/test-data/run-floats.test index cd36be7b2033..d84681ec658e 100644 --- a/mypyc/test-data/run-floats.test +++ b/mypyc/test-data/run-floats.test @@ -1,6 +1,7 @@ # Test cases for floats (compile and run) [case testFloatOps] +from __future__ import annotations from typing import Any, cast from typing_extensions import Final from testutil import assertRaises, float_vals, FLOAT_MAGIC @@ -329,6 +330,13 @@ def test_undefined_local_var() -> None: with assertRaises(UnboundLocalError, 'local variable "y2" referenced before assignment'): print(y2) +def test_tuples() -> None: + t1: tuple[float, float] = (1.5, 2.5) + assert t1 == tuple([1.5, 2.5]) + n = int() + 5 + t2: tuple[float, float, float, float] = (n, 1.5, -7, -113) + assert t2 == tuple([5.0, 1.5, -7.0, -113.0]) + [case testFloatGlueMethodsAndInheritance] from typing import Any from typing_extensions import Final