Improve tests perf

Author: evhub

.gitignore

@@ -145,3 +145,5 @@ __coconut_cache__/
 vprof.json
 profile.svg
 profile.speedscope
+runtime_profile.svg
+runtime_profile.speedscope

Makefile

@@ -346,20 +346,27 @@ open-speedscope:
 pyspy-purepy: export COCONUT_PURE_PYTHON=TRUE
 pyspy-purepy:
 	py-spy record -o profile.speedscope --format speedscope --subprocesses -- python -m coconut ./coconut/tests/src/cocotest/agnostic ./coconut/tests/dest/cocotest --force
-	open-speedscope
+	make open-speedscope
 
 .PHONY: pyspy-native
 pyspy-native:
 	py-spy record -o profile.speedscope --format speedscope --native -- python -m coconut ./coconut/tests/src/cocotest/agnostic ./coconut/tests/dest/cocotest --force --jobs 0
-	open-speedscope
+	make open-speedscope
+
+.PHONY: pyspy-runtime
+pyspy-runtime:
+	py-spy record -o runtime_profile.speedscope --format speedscope --subprocesses -- python ./coconut/tests/dest/runner.py
+	speedscope ./runtime_profile.speedscope
 
 .PHONY: vprof-time
 vprof-time:
 	vprof -c h "./coconut ./coconut/tests/src/cocotest/agnostic ./coconut/tests/dest/cocotest --force --jobs 0 --stack-size 4096 --recursion-limit 4096" --output-file ./vprof.json
+	make view-vprof
 
 .PHONY: vprof-memory
 vprof-memory:
 	vprof -c m "./coconut ./coconut/tests/src/cocotest/agnostic ./coconut/tests/dest/cocotest --force --jobs 0 --stack-size 4096 --recursion-limit 4096" --output-file ./vprof.json
+	make view-vprof
 
 .PHONY: view-vprof
 view-vprof:

__coconut__/__init__.pyi

@@ -1750,7 +1750,8 @@ def mapreduce(
     """
     ...
 
-_coconut_mapreduce = mapreduce.using_processes = mapreduce.using_threads = mapreduce  # type: ignore
+mapreduce.using_processes = mapreduce.using_threads = mapreduce  # type: ignore
+_coconut_mapreduce = mapreduce
 
 
 @_t.overload

coconut/command/command.py

@@ -134,14 +134,7 @@ class Command(object):
     stack_size = 0  # corresponds to --stack-size flag
     incremental = False  # corresponds to --incremental flag
 
-    _prompt = None
-
-    @property
-    def prompt(self):
-        """Delay creation of a Prompt() until it's needed."""
-        if self._prompt is None:
-            self._prompt = Prompt()
-        return self._prompt
+    prompt = Prompt()
 
     def start(self, run=False):
         """Endpoint for coconut and coconut-run."""

coconut/command/util.py

@@ -495,14 +495,24 @@ class Prompt(object):
     session = None
     style = None
     runner = None
+    lexer = None
+    suggester = None if prompt_use_suggester else False
 
-    def __init__(self, use_suggester=prompt_use_suggester):
+    def __init__(self, setup_now=False):
         """Set up the prompt."""
         if prompt_toolkit is not None:
             self.set_style(os.getenv(style_env_var, default_style))
             self.set_history_file(prompt_histfile)
+            if setup_now:
+                self.setup()
+
+    def setup(self):
+        """Actually initialize the underlying Prompt.
+        We do this lazily since it's expensive."""
+        if self.lexer is None:
             self.lexer = PygmentsLexer(CoconutLexer)
-            self.suggester = AutoSuggestFromHistory() if use_suggester else None
+        if self.suggester is None:
+            self.suggester = AutoSuggestFromHistory()
 
     def set_style(self, style):
         """Set pygments syntax highlighting style."""
@@ -555,6 +565,7 @@ def input(self, more=False):
 
     def prompt(self, msg):
         """Get input using prompt_toolkit."""
+        self.setup()
         try:
             # prompt_toolkit v2
             if self.session is None:

coconut/compiler/header.py

@@ -840,6 +840,7 @@ def async_map(*args, **kwargs):
 # -----------------------------------------------------------------------------------------------------------------------
 
 
+@memoize()
 def getheader(which, use_hash, target, no_tco, strict, no_wrap):
     """Generate the specified header.
 

coconut/constants.py

@@ -82,10 +82,9 @@ def get_path_env_var(env_var, default):
 PY310 = sys.version_info >= (3, 10)
 PY311 = sys.version_info >= (3, 11)
 IPY = (
-    ((PY2 and not PY26) or PY35)
+    PY35
     and (PY37 or not PYPY)
     and not (PYPY and WINDOWS)
-    and not (PY2 and WINDOWS)
     and sys.version_info[:2] != (3, 7)
 )
 MYPY = (

coconut/tests/main_test.py

@@ -91,9 +91,12 @@
 
 default_recursion_limit = "6144"
 default_stack_size = "6144"
-
-# fix EOM on GitHub actions
-default_jobs = None if PY36 and not PYPY else "4"
+default_jobs = (
+    # fix EOMs on GitHub actions
+    "2" if PYPY
+    else "4" if not PY36
+    else None
+)
 
 jupyter_timeout = 120
 

coconut/tests/src/cocotest/agnostic/primary_1.coco

@@ -211,13 +211,6 @@ def primary_test_1() -> bool:
     assert map((-), range(5)).iters[0] |> tuple == range(5) |> tuple == zip(range(5), range(6)).iters[0] |> tuple  # type: ignore
     assert repr(zip((0,1), (1,2))) == "zip((0, 1), (1, 2))"
     assert repr(map((-), range(5))).startswith("map(")  # type: ignore
-    assert repr(process_map((-), range(5))).startswith("process_map(")  # type: ignore
-    assert process_map((-), range(5)) |> tuple == (0, -1, -2, -3, -4) == process_map(map$((-)), (range(5),))$[0] |> tuple  # type: ignore
-    assert process_map(zip, (range(2),), (range(2),)) |> map$(tuple) |> tuple == (((0,0), (1,1)),)  # type: ignore
-    assert process_map(zip_longest$(fillvalue=10), (range(1),), (range(2),)) |> map$(tuple) |> tuple == (((0,0), (10,1)),)  # type: ignore
-    assert (range(0, 5), range(5, 10)) |*> map$(+) |> tuple == (5, 7, 9, 11, 13)
-    assert process_map((*)$(2)..(+)$(1), range(5)) |> tuple == (2, 4, 6, 8, 10)
-    assert process_map((+), range(5), range(5), chunksize=2) |> list == map((*)$(2), range(5)) |> list == thread_map((+), range(5), range(5), chunksize=2) |> list  # type: ignore
     assert repr(thread_map((-), range(5))).startswith("thread_map(")  # type: ignore
     with thread_map.multiple_sequential_calls(max_workers=4):  # type: ignore
         assert thread_map((-), range(5), stream=True) |> tuple == (0, -1, -2, -3, -4) == thread_map(map$((-)), (range(5),))$[0] |> tuple  # type: ignore
@@ -319,7 +312,6 @@ def primary_test_1() -> bool:
     assert pow$(?, 2)(3) == 9
     assert [] |> reduce$((+), ?, ()) == ()
     assert pow$(?, 2) |> repr == "<built-in function pow>$(?, 2)"
-    assert process_map(pow$(?, 2), range(10)) |> tuple == (0, 1, 4, 9, 16, 25, 36, 49, 64, 81)
     assert pow$(?, 2).args == (None, 2)
     assert range(20) |> filter$((x) -> x < 5) |> reversed |> tuple == (4,3,2,1,0) == (0,1,2,3,4,5,6,7,8,9) |> filter$((x) -> x < 5) |> reversed |> tuple  # type: ignore
     assert (range(10) |> map$((x) -> x) |> reversed) `isinstance` map  # type: ignore
@@ -1149,10 +1141,6 @@ def primary_test_1() -> bool:
                 def __call__(self) = super().__call__()
             HasSuper
     assert HasSuper5.HasHasSuper.HasSuper()() == 10 == HasSuper6().get_HasSuper()()()
-    assert process_map((.+(10,)), [
-        (a=1, b=2),
-        (x=3, y=4),
-    ]) |> list == [(1, 2, 10), (3, 4, 10)]
     assert f"{'a' + 'b'}" == "ab"
     int_str_tup: (int; str) = (1, "a")
     key = "abc"
@@ -1303,4 +1291,18 @@ def primary_test_1() -> bool:
     assert err is some_err
     assert Expected(error=TypeError()).map_error(const some_err) == Expected(error=some_err)
     assert Expected(10).map_error(const some_err) == Expected(10)
+    assert repr(process_map((-), range(5))).startswith("process_map(")  # type: ignore
+
+    with process_map.multiple_sequential_calls():  # type: ignore
+        assert process_map((-), range(5)) |> tuple == (0, -1, -2, -3, -4) == process_map(map$((-)), (range(5),))$[0] |> tuple  # type: ignore
+        assert process_map(zip, (range(2),), (range(2),)) |> map$(tuple) |> tuple == (((0,0), (1,1)),)  # type: ignore
+        assert process_map(zip_longest$(fillvalue=10), (range(1),), (range(2),)) |> map$(tuple) |> tuple == (((0,0), (10,1)),)  # type: ignore
+        assert (range(0, 5), range(5, 10)) |*> map$(+) |> tuple == (5, 7, 9, 11, 13)
+        assert process_map((*)$(2)..(+)$(1), range(5)) |> tuple == (2, 4, 6, 8, 10)
+        assert process_map((+), range(5), range(5), chunksize=2) |> list == map((*)$(2), range(5)) |> list == thread_map((+), range(5), range(5), chunksize=2) |> list  # type: ignore
+        assert process_map(pow$(?, 2), range(10)) |> tuple == (0, 1, 4, 9, 16, 25, 36, 49, 64, 81)
+        assert process_map((.+(10,)), [
+            (a=1, b=2),
+            (x=3, y=4),
+        ]) |> list == [(1, 2, 10), (3, 4, 10)]
     return True

coconut/tests/src/cocotest/agnostic/primary_2.coco

@@ -121,18 +121,12 @@ def primary_test_2() -> bool:
     assert flatten([[[1,2]], [[3], [4]]], 2) |> list == [1, 2, 3, 4]
     assert flatten([[[1,2]], [[3], [4]]], 2) |> reversed |> list == [4, 3, 2, 1]
     assert_raises(-> map((+), range(3), range(4), strict=True) |> list, ValueError)  # type: ignore
-    assert map((+), range(3), range(4)$[:-1], strict=True) |> list == [0, 2, 4] == process_map((+), range(3), range(4)$[:-1], strict=True) |> list  # type: ignore
-    assert range(3) |> map$((.+1), strict=True) |> list == [1, 2, 3] == range(3) |> process_map$((.+1), strict=True) |> list  # type: ignore
     assert cartesian_product((1, 2), (3, 4), repeat=0) |> list == [()]
     assert (a=1, b=2)[1] == 2
     obj = object()
     assert_raises((def -> obj.abc = 123), AttributeError)  # type: ignore
     hardref = map((.+1), [1,2,3])
     assert weakref.ref(hardref)() |> list == [2, 3, 4]  # type: ignore
-    my_match_err = MatchError("my match error", 123)
-    assert process_map(ident, [my_match_err]) |> list |> str == str([my_match_err])  # type: ignore
-    # repeat the same thing again now that my_match_err.str has been called
-    assert process_map(ident, [my_match_err]) |> list |> str == str([my_match_err])  # type: ignore
     match data tuple(1, 2) in (1, 2, 3):
         assert False
     data TestDefaultMatching(x="x default", y="y default")
@@ -409,4 +403,13 @@ def primary_test_2() -> bool:
         assert some_data |> mapreducer == {"a": ["123"], "b": ["567"]}
     assert_raises(-> collectby(.[0], [(0, 1), (0, 2)], reduce_func=False), ValueError)  # type: ignore
     assert ident$(x=?).__name__ == "ident" == ident$(1).__name__  # type: ignore
+
+    with process_map.multiple_sequential_calls():  # type: ignore
+        assert map((+), range(3), range(4)$[:-1], strict=True) |> list == [0, 2, 4] == process_map((+), range(3), range(4)$[:-1], strict=True) |> list  # type: ignore
+        assert range(3) |> map$((.+1), strict=True) |> list == [1, 2, 3] == range(3) |> process_map$((.+1), strict=True) |> list  # type: ignore
+        my_match_err = MatchError("my match error", 123)
+        assert process_map(ident, [my_match_err]) |> list |> str == str([my_match_err])  # type: ignore
+        # repeat the same thing again now that my_match_err.str has been called
+        assert process_map(ident, [my_match_err]) |> list |> str == str([my_match_err])  # type: ignore
+
     return True

coconut/tests/src/cocotest/agnostic/suite.coco

@@ -67,7 +67,6 @@ def suite_test() -> bool:
         to_sort = rand_list(10)
         assert to_sort |> qsort |> tuple == to_sort |> sorted |> tuple, qsort  # type: ignore
     to_sort = rand_list(10)
-    assert process_map(tuple <.. (|>)$(to_sort), qsorts) |> list == [to_sort |> sorted |> tuple] * len(qsorts)
     assert repeat(3)$[2] == 3 == repeat_(3)$[2]
     assert sum_(repeat(1)$[:5]) == 5 == sum_(repeat_(1)$[:5])
     assert (sum_(takewhile((x)-> x<5, N()))
@@ -279,7 +278,6 @@ def suite_test() -> bool:
     assert fibs()$[:10] |> list == [1,1,2,3,5,8,13,21,34,55] == fibs_()$[:10] |> list
     assert fibs() |> takewhile$((i) -> i < 4000000 ) |> filter$((i) -> i % 2 == 0 ) |> sum == 4613732 == fibs_() |> takewhile$((i) -> i < 4000000 ) |> filter$((i) -> i % 2 == 0 ) |> sum  # type: ignore
     assert loop([1,2])$[:4] |> list == [1, 2] * 2
-    assert process_map(list .. .$[:2] .. loop, ([1], [2]))$[:2] |> tuple == ([1, 1], [2, 2])
     assert nest("a") |> .$[1] |> .$[1] |> .$[0] == "a"
     assert (def -> mod)()(5, 3) == 2
     assert sieve((2, 3, 4, 5)) |> list == [2, 3, 5]
@@ -748,7 +746,6 @@ def suite_test() -> bool:
     class inh_A() `isinstance` clsA `isinstance` object = inh_A()
     for maxdiff in (maxdiff1, maxdiff2, maxdiff3, maxdiff_):
         assert maxdiff([7,1,4,5]) == 4, "failed for " + repr(maxdiff)
-    assert all(r == 4 for r in process_map(call$(?, [7,1,4,5]), [maxdiff1, maxdiff2, maxdiff3]))
     assert ret_ret_func(1) == ((), {"func": 1}) == ret_args_kwargs$(func=1)()  # type: ignore
     assert ret_args_kwargs$(?, func=2)(1) == ((1,), {"func": 2})
     assert lift(ret_args_kwargs)(ident, plus1, times2, sq=square)(3) == ((3, 4, 6), {"sq": 9})
@@ -1069,6 +1066,11 @@ forward 2""") == 900
     assert safe_raise_exc(IOError).handle(IOError, const 10).unwrap() == 10 == safe_raise_exc(IOError).expect_error(IOError).result_or(10)
     assert pickle_round_trip(ident$(1))() == 1 == pickle_round_trip(ident$(x=?))(1)
 
+    with process_map.multiple_sequential_calls():  # type: ignore
+        assert process_map(tuple <.. (|>)$(to_sort), qsorts) |> list == [to_sort |> sorted |> tuple] * len(qsorts)
+        assert process_map(list .. .$[:2] .. loop, ([1], [2]))$[:2] |> tuple == ([1, 1], [2, 2])
+        assert all(r == 4 for r in process_map(call$(?, [7,1,4,5]), [maxdiff1, maxdiff2, maxdiff3]))
+
     # must come at end
     assert fibs_calls[0] == 1
     assert lols[0] == 5

coconut/tests/src/cocotest/target_sys/target_sys_test.coco

@@ -47,11 +47,11 @@ def asyncio_test() -> bool:
     def toa(f) = async def (*args, **kwargs) -> f(*args, **kwargs)
 
     async def async_map_0(args):
-        return process_map(args[0], *args[1:])
-    async def async_map_1(args) = process_map(args[0], *args[1:])
-    async def async_map_2([func] + iters) = process_map(func, *iters)
-    async match def async_map_3([func] + iters) = process_map(func, *iters)
-    match async def async_map_4([func] + iters) = process_map(func, *iters)
+        return thread_map(args[0], *args[1:])
+    async def async_map_1(args) = thread_map(args[0], *args[1:])
+    async def async_map_2([func] + iters) = thread_map(func, *iters)
+    async match def async_map_3([func] + iters) = thread_map(func, *iters)
+    match async def async_map_4([func] + iters) = thread_map(func, *iters)
     async def async_map_test() =
         for async_map_ in (async_map_0, async_map_1, async_map_2, async_map_3, async_map_4):
             assert (await ((pow$(2), range(5)) |> async_map_)) |> tuple == (1, 2, 4, 8, 16)