Write specific benchmarks for CodSpeed

tests/test_benchmarks.py

@@ -0,0 +1,113 @@
+"""
+Benchmark attrs using CodSpeed.
+"""
+
+from __future__ import annotations
+
+import os
+
+import pytest
+
+import attrs
+
+
+if os.environ.get("CODSPEED_ENV") is None:
+    pytest.skip("Not running in CodSpeed environment", allow_module_level=True)
+
+pytestmark = pytest.mark.benchmark()
+
+ROUNDS = 1_000
+
+
+def test_create_simple_class():
+    """
+    Benchmark creating and instantiating a simple class without any extras.
+    """
+    for _ in range(ROUNDS):
+
+        @attrs.define
+        class LocalC:
+            x: int
+            y: str
+            z: dict[str, int]
+
+        LocalC(1, "2", {})
+
+
+def test_create_simple_class_make_class():
+    """
+    Benchmark creating and instantiating a simple class using attrs.make_class().
+    """
+    for i in range(ROUNDS):
+        C = attrs.make_class(
+            f"C{i}",
+            {
+                "x": attrs.field(type=int),
+                "y": attrs.field(type=str),
+                "z": attrs.field(type=dict[str, int]),
+            },
+        )
+
+        C(1, "2", {})
+
+
+@attrs.define
+class C:
+    x: int = 0
+    y: str = "foo"
+    z: dict[str, int] = attrs.Factory(dict)
+
+
+def test_instantiate_no_defaults():
+    """
+    Benchmark instantiating a class without using any defaults.
+    """
+    for _ in range(ROUNDS):
+        C(1, "2", {})
+
+
+def test_instantiate_with_defaults():
+    """
+    Benchmark instantiating a class relying on defaults.
+    """
+    for _ in range(ROUNDS):
+        C()
+
+
+def test_eq_equal():
+    """
+    Benchmark comparing two equal instances for equality.
+    """
+    c1 = C()
+    c2 = C()
+
+    for _ in range(ROUNDS):
+        c1 == c2
+
+
+def test_eq_unequal():
+    """
+    Benchmark comparing two unequal instances for equality.
+    """
+    c1 = C()
+    c2 = C(1, "bar", {"baz": 42})
+
+    for _ in range(ROUNDS):
+        c1 == c2
+
+
+@attrs.frozen
+class HashableC:
+    x: int = 0
+    y: str = "foo"
+    z: tuple[str] = ("bar",)
+
+
+def test_hash():
+    """
+    Benchmark hashing an instance.
+    """
+    c = HashableC()
+
+    for _ in range(ROUNDS):
+        hash(c)

tests/test_functional.py

@@ -111,7 +111,6 @@ class TestFunctional:
     Functional tests.
     """
 
-    @pytest.mark.benchmark()
     @pytest.mark.parametrize("cls", [C2, C2Slots])
     def test_fields(self, cls):
         """
@@ -146,7 +145,6 @@ def test_fields(self, cls):
             ),
         ) == attr.fields(cls)
 
-    @pytest.mark.benchmark()
     @pytest.mark.parametrize("cls", [C1, C1Slots])
     def test_asdict(self, cls):
         """
@@ -182,7 +180,6 @@ class C3:
 
         assert "C3(_x=1)" == repr(C3(x=1))
 
-    @pytest.mark.benchmark()
     @given(booleans(), booleans())
     def test_programmatic(self, slots, frozen):
         """
@@ -340,7 +337,6 @@ def test_metaclass_preserved(self, cls):
         """
         assert Meta is type(cls)
 
-    @pytest.mark.benchmark()
     def test_default_decorator(self):
         """
         Default decorator sets the default and the respective method gets
@@ -544,7 +540,6 @@ class C:
         assert "itemgetter" == attr.fields(C).itemgetter.name
         assert "x" == attr.fields(C).x.name
 
-    @pytest.mark.benchmark()
     def test_auto_exc(self, slots, frozen):
         """
         Classes with auto_exc=True have a Exception-style __str__, compare and
@@ -739,7 +734,6 @@ class D(C):
         assert "_setattr('y', y)" in src
         assert object.__setattr__ != D.__setattr__
 
-    @pytest.mark.benchmark()
     def test_unsafe_hash(self, slots):
         """
         attr.s(unsafe_hash=True) makes a class hashable.

tox.ini

@@ -56,7 +56,7 @@ pass_env =
     ARCH
     PYTHONHASHSEED
     PYTHONMALLOC
-commands = pytest --codspeed -n auto
+commands = pytest --codspeed -n auto tests/test_benchmarks.py
 
 
 [testenv:docs]