[mypyc] Faster min (#10265)

ChetanKhanna · 97littleleaf11 · web-flow · commit 0b4cb1e52137 · 2021-11-12T13:51:36.000+08:00
Speeds up `min(x, y)` using a specializer. 

Co-authored-by: 97littleleaf11 &lt;97littleleaf11@gmail.com&gt;
diff --git a/mypyc/irbuild/specialize.py b/mypyc/irbuild/specialize.py
@@ -185,6 +185,32 @@ def translate_set_from_generator_call(
     return None
 
 
+@specialize_function('builtins.min')
+def faster_min(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Optional[Value]:
+    if expr.arg_kinds == [ARG_POS, ARG_POS]:
+        x, y = builder.accept(expr.args[0]), builder.accept(expr.args[1])
+        result = Register(builder.node_type(expr))
+        comparison = builder.binary_op(y, x, '<', expr.line)
+        true = BasicBlock()
+        false = BasicBlock()
+        next_block = BasicBlock()
+
+        builder.add_bool_branch(comparison, true, false)
+
+        builder.activate_block(true)
+        builder.assign(result, builder.coerce(y, result.type, expr.line), expr.line)
+        builder.goto(next_block)
+
+        builder.activate_block(false)
+        builder.assign(result, builder.coerce(x, result.type, expr.line), expr.line)
+        builder.goto(next_block)
+
+        builder.activate_block(next_block)
+
+        return result
+    return None
+
+
 @specialize_function('builtins.tuple')
 @specialize_function('builtins.frozenset')
 @specialize_function('builtins.dict')
diff --git a/mypyc/test-data/fixtures/ir.py b/mypyc/test-data/fixtures/ir.py
@@ -302,6 +302,7 @@ def zip(x: Iterable[T], y: Iterable[S], z: Iterable[V]) -> Iterator[Tuple[T, S,
 def eval(e: str) -> Any: ...
 def abs(x: float) -> float: ...
 def exit() -> None: ...
+def min(x: T, y: T) -> T: ...
 def repr(o: object) -> str: ...
 def ascii(o: object) -> str: ...
 def ord(o: object) -> int: ...
diff --git a/mypyc/test-data/irbuild-int.test b/mypyc/test-data/irbuild-int.test
@@ -80,3 +80,40 @@ L14:
 L15:
 L16:
     return 12
+
+[case testIntMin]
+def f(x: int, y: int) -> int:
+    return min(x, y)
+[out]
+def f(x, y):
+    x, y :: int
+    r0 :: native_int
+    r1 :: bit
+    r2 :: native_int
+    r3, r4, r5 :: bit
+    r6 :: bool
+    r7 :: bit
+    r8 :: int
+L0:
+    r0 = y & 1
+    r1 = r0 == 0
+    r2 = x & 1
+    r3 = r2 == 0
+    r4 = r1 & r3
+    if r4 goto L1 else goto L2 :: bool
+L1:
+    r5 = y < x :: signed
+    r6 = r5
+    goto L3
+L2:
+    r7 = CPyTagged_IsLt_(y, x)
+    r6 = r7
+L3:
+    if r6 goto L4 else goto L5 :: bool
+L4:
+    r8 = y
+    goto L6
+L5:
+    r8 = x
+L6:
+    return r8
diff --git a/mypyc/test-data/run-dunders.test b/mypyc/test-data/run-dunders.test
@@ -757,3 +757,30 @@ def test_in_place_operator_returns_none() -> None:
     o = BadInplaceAdd()
     with assertRaises(TypeError, "native.BadInplaceAdd object expected; got None"):
         o += 5
+
+[case testDunderMin]
+class SomeItem:
+    def __init__(self, val: int) -> None:
+        self.val = val
+
+    def __lt__(self, x: 'SomeItem') -> bool:
+        return self.val < x.val
+
+class AnotherItem:
+    def __init__(self, val: str) -> None:
+        self.val = val
+
+    def __lt__(self, x: 'AnotherItem') -> bool:
+        return True
+
+def test_dunder_min() -> None:
+    x = SomeItem(5)
+    y = SomeItem(10)
+    z = SomeItem(15)
+    assert min(x, y).val == 5
+    assert min(y, z).val == 10
+    x2 = AnotherItem('xxx')
+    y2 = AnotherItem('yyy')
+    z2 = AnotherItem('zzz')
+    assert min(x2, y2).val == 'yyy'
+    assert min(y2, x2).val == 'xxx'
diff --git a/mypyc/test-data/run-floats.test b/mypyc/test-data/run-floats.test
@@ -13,10 +13,16 @@ assert str_to_float("44324") == 44324.0
 assert str_to_float("23.4") == 23.4
 assert str_to_float("-43.44e-4") == -43.44e-4
 
-[case testFloatAbs]
+[case testFloatArithmetic]
 def test_abs() -> None:
     assert abs(0.0) == 0.0
     assert abs(-1.234567) == 1.234567
     assert abs(44324.732) == 44324.732
     assert abs(-23.4) == 23.4
     assert abs(-43.44e-4) == 43.44e-4
+
+def test_float_min() -> None:
+    x: float = 20.0
+    y: float = 30.0
+    assert min(x, y) == 20.0
+    assert min(y, x) == 20.0
diff --git a/mypyc/test-data/run-integers.test b/mypyc/test-data/run-integers.test
@@ -427,3 +427,44 @@ def test_constant_fold() -> None:
     assert n63 == -(1 << 63)
     n64 = -(1 << 64) + int()
     assert n64 == -(1 << 64)
+
+[case testIntMin]
+def test_int_min() -> None:
+    x: int = 200
+    y: int = 30
+    assert min(x, y) == 30
+
+def test_int_min_2() -> None:
+    x: int = 30
+    y: int = 200
+    assert min(x, y) == 30
+
+def test_int_hybrid_min() -> None:
+    from typing import Any
+
+    x: object = 30
+    y: Any = 20.0
+    assert min(x, y) == 20.0
+
+    u: object = 20
+    v: float = 30.0
+    assert min(u, v) == 20
+
+def test_int_incompatible_min() -> None:
+    x: int = 2
+    y: str = 'aaa'
+    try:
+        print(min(x, y))
+    except TypeError as e:
+        assert str(e) == "'<' not supported between instances of 'str' and 'int'"
+
+def test_int_bool_min() -> None:
+    x: int = 2
+    y: bool = False
+    z: bool = True
+    assert min(x, y) == False
+    assert min(x, z) == True
+
+    u: int = -10
+    assert min(u, y) == -10
+    assert min(u, z) == -10
diff --git a/mypyc/test-data/run-strings.test b/mypyc/test-data/run-strings.test
@@ -149,6 +149,13 @@ def test_str_to_bool() -> None:
         assert is_true(x)
         assert not is_false(x)
 
+def test_str_min() -> None:
+    x: str = 'aaa'
+    y: str = 'bbb'
+    z: str = 'aa'
+    assert min(x, y) == 'aaa'
+    assert min(x, z) == 'aa'
+
 [case testStringFormattingCStyle]
 [typing fixtures/typing-full.pyi]
 from typing import Tuple
