Add ctypes and ctypes_argtypes benchmarks

Author: mdboom

doc/benchmarks.rst

@@ -109,6 +109,16 @@ the AES block cipher algorithm and the common modes of operation (CBC, CFB,
 CTR, ECB and OFB).
 
 
+ctypes
+------
+
+Benchmark to measure the function call overhead of calling C functions using ctypes.
+
+The `ctypes` benchmark lets `ctypes` infer the argument types from the passed in
+values. The `ctypes_argtypes` benchmark `explicitly specifies the argument types
+<https://docs.python.org/3.10/library/ctypes.html?highlight=ctypes#specifying-the-required-argument-types-function-prototypes>`_,
+which is slower than inferred argument types.
+
 deltablue
 ---------
 

pyperformance/data-files/benchmarks/MANIFEST

@@ -5,6 +5,8 @@ name	metafile
 chameleon	<local>
 chaos	<local>
 crypto_pyaes	<local>
+ctypes	<local>
+ctypes_argtypes	<local:ctypes>
 deltablue	<local>
 django_template	<local>
 dulwich_log	<local>
@@ -62,6 +64,7 @@ xml_etree	<local>
 #apps
 #math
 #template
+#extension
 
 
 [group default]

pyperformance/data-files/benchmarks/bm_ctypes/bm_ctypes_argtypes.toml

@@ -0,0 +1,11 @@
+[project]
+name = "pyperformance_bm_ctypes_argtypes"
+requires-python = ">=3.8"
+dependencies = ["pyperf"]
+urls = {repository = "https://github.com/python/pyperformance"}
+dynamic = ["version"]
+
+[tool.pyperformance]
+name = "ctypes_argtypes"
+tags = "extension"
+runscript = "run_benchmark_argtypes.py"

pyperformance/data-files/benchmarks/bm_ctypes/cmodule.c

@@ -0,0 +1,28 @@
+void void_foo_void(void) {
+
+}
+
+int int_foo_int(int a) {
+    return a + 1;
+}
+
+void void_foo_int(int a) {
+
+}
+
+void void_foo_int_int(int a, int b) {
+
+}
+
+void void_foo_int_int_int(int a, int b, int c) {
+
+}
+
+void void_foo_int_int_int_int(int a, int b, int c, int d) {
+
+}
+
+void void_foo_constchar(const char* str) {
+
+}
+

pyperformance/data-files/benchmarks/bm_ctypes/pyproject.toml

@@ -0,0 +1,10 @@
+[project]
+name = "pyperformance_bm_ctypes"
+requires-python = ">=3.8"
+dependencies = ["pyperf"]
+urls = {repository = "https://github.com/python/pyperformance"}
+dynamic = ["version"]
+
+[tool.pyperformance]
+name = "ctypes"
+tags = "extension"

pyperformance/data-files/benchmarks/bm_ctypes/run_benchmark.py

@@ -0,0 +1,42 @@
+"""
+Test the function call overhead of ctypes.
+"""
+import pyperf
+
+
+import ctypes
+import importlib.util
+
+
+spec = importlib.util.find_spec("bm_ctypes.cmodule")
+if spec is None:
+    raise ImportError("Can't find bm_ctypes.cmodule shared object file")
+ext = ctypes.cdll.LoadLibrary(spec.origin)
+
+
+def benchmark(n):
+    void_foo_void = ext.void_foo_void
+    int_foo_int = ext.int_foo_int
+    void_foo_int = ext.void_foo_int
+    void_foo_int_int = ext.void_foo_int_int
+    void_foo_int_int_int = ext.void_foo_int_int_int
+    void_foo_int_int_int_int = ext.void_foo_int_int_int_int
+    void_foo_constchar = ext.void_foo_constchar
+
+    # Test calling the functions using the implied arguments mechanism
+
+    for i in range(n):
+        void_foo_void()
+        int_foo_int(1)
+        void_foo_int(1)
+        void_foo_int_int(1, 2)
+        void_foo_int_int_int(1, 2, 3)
+        void_foo_int_int_int_int(1, 2, 3, 4)
+        void_foo_constchar(b"bytes")
+
+
+if __name__ == "__main__":
+    runner = pyperf.Runner()
+    runner.metadata["description"] = "ctypes function call overhead benchmark"
+
+    runner.bench_func("ctypes", benchmark, 1000000)

pyperformance/data-files/benchmarks/bm_ctypes/run_benchmark_argtypes.py

@@ -0,0 +1,69 @@
+"""
+Test the function call overhead of ctypes with specified arguments.
+"""
+import pyperf
+
+
+import ctypes
+import importlib.util
+
+
+spec = importlib.util.find_spec("bm_ctypes.cmodule")
+if spec is None:
+    raise ImportError("Can't find bm_ctypes.cmodule shared object file")
+ext = ctypes.cdll.LoadLibrary(spec.origin)
+
+
+def benchmark(n):
+    void_foo_void = ext.void_foo_void
+    void_foo_void.argtypes = []
+    void_foo_void.restype = None
+
+    int_foo_int = ext.void_foo_int
+    int_foo_int.argtypes = [ctypes.c_int]
+    int_foo_int.restype = ctypes.c_int
+
+    void_foo_int = ext.void_foo_int
+    void_foo_int.argtypes = [ctypes.c_int]
+    void_foo_int.restype = None
+
+    void_foo_int_int = ext.void_foo_int_int
+    void_foo_int_int.argtypes = [ctypes.c_int, ctypes.c_int]
+    void_foo_int_int.restype = None
+
+    void_foo_int_int_int = ext.void_foo_int_int_int
+    void_foo_int_int_int.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.c_int]
+    void_foo_int_int_int.restype = None
+
+    void_foo_int_int_int_int = ext.void_foo_int_int_int_int
+    void_foo_int_int_int_int.argtypes = [
+        ctypes.c_int,
+        ctypes.c_int,
+        ctypes.c_int,
+        ctypes.c_int,
+    ]
+    void_foo_int_int_int_int.restype = None
+
+    void_foo_constchar = ext.void_foo_constchar
+    void_foo_constchar.argtypes = [ctypes.c_char_p]
+    void_foo_constchar.restype = None
+
+    # Test calling the functions using the specified arguments mechanism
+
+    for i in range(n):
+        void_foo_void()
+        int_foo_int(1)
+        void_foo_int(1)
+        void_foo_int_int(1, 2)
+        void_foo_int_int_int(1, 2, 3)
+        void_foo_int_int_int_int(1, 2, 3, 4)
+        void_foo_constchar(b"bytes")
+
+
+if __name__ == "__main__":
+    runner = pyperf.Runner()
+    runner.metadata[
+        "description"
+    ] = "ctypes function call overhead, with specified arguments, benchmark"
+
+    runner.bench_func("ctypes", benchmark, 1000000)

pyperformance/data-files/benchmarks/bm_ctypes/setup.py

@@ -0,0 +1,11 @@
+from distutils.core import setup, Extension
+
+# Compile the C shared object containing functions to call through ctypes. It
+# isn't technically a Python C extension, but this is the easiest way to build
+# it in a cross-platform way.
+
+setup(
+    name="pyperformance_bm_ctypes",
+    ext_modules=[Extension("bm_ctypes.cmodule", sources=["cmodule.c"])],
+    package_dir={"bm_ctypes": "src"},
+)