benches: update benchmarks for pkgcraft dep changes

Author: radhermit

benches/atom_memory_usage.py

@@ -0,0 +1,54 @@
+# Script to roughly benchmark memory usage for package dependency object
+# instances between pkgcraft, pkgcore, and portage.
+
+import os
+import sys
+import time
+from random import randrange
+
+import humanize
+import psutil
+from pkgcore.ebuild.atom import atom as pkgcore_dep
+from portage.dep import Atom as portage_dep
+
+from pkgcraft.dep import PkgDep as pkgcraft_dep
+
+eprint = lambda x: print(x, file=sys.stderr)
+
+dep_funcs = [
+    ("pkgcraft", pkgcraft_dep),
+    ("pkgcraft-cached", pkgcraft_dep.cached),
+    ("pkgcore", pkgcore_dep),
+    ("portage", portage_dep),
+]
+
+
+def test(deps):
+    eprint("---------------------------------------")
+    eprint("{:<20} {:<10} time".format("implementation", "memory"))
+    eprint("---------------------------------------")
+    for impl, func in dep_funcs:
+        if _pid := os.fork():
+            os.wait()
+        else:
+            proc = psutil.Process()
+            base = proc.memory_info().rss
+            start = time.time()
+            _deps = [func(x) for x in deps]
+            elapsed = time.time() - start
+            size = humanize.naturalsize(proc.memory_info().rss - base)
+            eprint(f"{impl:<20} {size:<10} {elapsed:.{2}f}s")
+            os._exit(0)
+
+
+if __name__ == "__main__":
+    num_deps = 1000000
+
+    eprint(f"\nStatic deps ({num_deps})")
+    test(("cat/pkg" for _ in range(num_deps)))
+
+    eprint(f"\nDynamic deps ({num_deps})")
+    test((f"=cat/pkg-{x}-r1:2/3[a,b,c]" for x in range(num_deps)))
+
+    eprint(f"\nRandom deps ({num_deps})")
+    test((f"=cat/pkg-{randrange(9999)}-r1:2/3[a,b,c]" for _ in range(num_deps)))

benches/dep_memory_usage.py

@@ -0,0 +1,62 @@
+import pytest
+from pkgcore.ebuild.atom import atom as pkgcore_dep
+from portage.dep import Atom as portage_dep
+
+from pkgcraft.dep import PkgDep as pkgcraft_dep
+
+pytest_plugins = ("benchmark", "pkgcraft")
+
+
+def random_dep(func, random_str):
+    cat = random_str()
+    pkg = random_str()
+    s = f"=cat_{cat}/pkg_{pkg}-1-r2:3/4=[a,b,c]"
+    return func(s)
+
+
+dep_funcs = [
+    ("pkgcraft", pkgcraft_dep),
+    ("pkgcraft", pkgcraft_dep.cached),
+    ("pkgcore", pkgcore_dep),
+    ("portage", portage_dep),
+]
+
+
+@pytest.mark.parametrize("_lib,func", dep_funcs)
+def test_bench_dep_static(benchmark, _lib, func):
+    benchmark(func, "=cat/pkg-1-r2:3/4=[a,b,c]")
+
+
+@pytest.mark.parametrize("_lib,func", dep_funcs)
+def test_bench_dep_random(benchmark, random_str, _lib, func):
+    benchmark(random_dep, func, random_str)
+
+
+@pytest.mark.parametrize("_lib,func", dep_funcs)
+def test_bench_dep_property(benchmark, _lib, func):
+    dep = func("=cat/pkg-1-r2:3/4=[a,b,c]")
+    version = benchmark(getattr, dep, "version")
+    assert str(version).startswith("1")
+
+
+@pytest.mark.parametrize("_lib,func", dep_funcs)
+def test_bench_dep_property_none(benchmark, _lib, func):
+    dep = func("cat/pkg")
+    version = benchmark(getattr, dep, "version")
+    assert version is None
+
+
+# portage deps don't natively support comparisons
+@pytest.mark.parametrize("_lib,func", (("pkgcraft", pkgcraft_dep), ("pkgcore", pkgcore_dep)))
+def test_bench_dep_sorting_worst_case(benchmark, _lib, func):
+    deps = [func(f"=cat/pkg-{v}-r1:2/3=[a,b,c]") for v in reversed(range(100))]
+    result = benchmark(sorted, deps)
+    assert result == list(reversed(deps))
+
+
+# portage deps don't natively support comparisons
+@pytest.mark.parametrize("_lib,func", (("pkgcraft", pkgcraft_dep), ("pkgcore", pkgcore_dep)))
+def test_bench_dep_sorting_best_case(benchmark, _lib, func):
+    deps = [func(f"=cat/pkg-{v}-r1:2/3=[a,b,c]") for v in range(100)]
+    result = benchmark(sorted, deps)
+    assert result == deps

benches/test_atom.py

@@ -1,7 +1,7 @@
 import pytest
-from pkgcore.ebuild.atom import atom as pkgcore_atom
+from pkgcore.ebuild.atom import atom as pkgcore_dep
 
-from pkgcraft.atom import Atom
+from pkgcraft.dep import PkgDep as pkgcraft_dep
 from pkgcraft.repo import RepoSet
 
 pytest_plugins = ("benchmark", "pkgcraft")
@@ -27,14 +27,14 @@ def test_bench_ebuild_repo_iter(benchmark, lib, ebuild_repo):
     assert len(pkgs) == 100
 
 
-@pytest.mark.parametrize("lib,func", (("pkgcraft", Atom), ("pkgcore", pkgcore_atom)))
-def test_bench_ebuild_repo_iter_restrict_atom(benchmark, lib, func, ebuild_repo):
+@pytest.mark.parametrize("lib,func", (("pkgcraft", pkgcraft_dep), ("pkgcore", pkgcore_dep)))
+def test_bench_ebuild_repo_iter_restrict_dep(benchmark, lib, func, ebuild_repo):
     # create ebuilds
     for i in range(100):
         ebuild_repo.create_ebuild(f"cat/pkg-{i}")
 
-    # single atom restriction
-    atom = func("=cat/pkg-50")
+    # single dep restriction
+    dep = func("=cat/pkg-50")
 
     if lib == "pkgcore":
         from pkgcore.ebuild import repo_objs, repository
@@ -43,9 +43,9 @@ def test_bench_ebuild_repo_iter_restrict_atom(benchmark, lib, func, ebuild_repo)
             location=str(ebuild_repo.path), disable_inst_caching=True
         )
         r = repository.UnconfiguredTree(str(ebuild_repo.path), repo_config=repo_config)
-        pkgs = benchmark(lambda x: list(r.itermatch(x)), atom)
+        pkgs = benchmark(lambda x: list(r.itermatch(x)), dep)
     else:
-        pkgs = benchmark(lambda x: list(ebuild_repo.iter_restrict(x)), atom)
+        pkgs = benchmark(lambda x: list(ebuild_repo.iter_restrict(x)), dep)
 
     assert len(pkgs) == 1
     assert str(pkgs[0].version) == "50"
@@ -58,14 +58,14 @@ def test_bench_fake_repo_iter(benchmark, fake_repo):
     assert len(pkgs) == 100
 
 
-def test_bench_fake_repo_iter_restrict_atom(benchmark, fake_repo):
+def test_bench_fake_repo_iter_restrict_dep(benchmark, fake_repo):
     # create pkgs
     fake_repo.extend([f"cat/pkg-{i}" for i in range(100)])
 
-    # single atom restriction
-    atom = Atom("=cat/pkg-50")
+    # single dep restriction
+    dep = pkgcraft_dep("=cat/pkg-50")
 
-    pkgs = benchmark(lambda x: list(fake_repo.iter_restrict(x)), atom)
+    pkgs = benchmark(lambda x: list(fake_repo.iter_restrict(x)), dep)
     assert len(pkgs) == 1
     assert str(pkgs[0].version) == "50"
 
@@ -84,7 +84,7 @@ def test_bench_repo_set_iter(benchmark, make_ebuild_repo):
     assert len(pkgs) == 100
 
 
-def test_bench_repo_set_iter_restrict_atom(benchmark, make_ebuild_repo):
+def test_bench_repo_set_iter_restrict_dep(benchmark, make_ebuild_repo):
     r1 = make_ebuild_repo()
     r2 = make_ebuild_repo()
     # create ebuilds
@@ -93,11 +93,11 @@ def test_bench_repo_set_iter_restrict_atom(benchmark, make_ebuild_repo):
     for i in range(50, 100):
         r2.create_ebuild(f"cat/pkg-{i}")
 
-    # single atom restriction
-    atom = Atom("=cat/pkg-50")
+    # single dep restriction
+    dep = pkgcraft_dep("=cat/pkg-50")
 
     repos = RepoSet(r1, r2)
-    pkgs = benchmark(lambda x: list(repos.iter_restrict(x)), atom)
+    pkgs = benchmark(lambda x: list(repos.iter_restrict(x)), dep)
 
     assert len(pkgs) == 1
     assert str(pkgs[0].version) == "50"