update benchmark PyPy

Author: gesslerpd

README.md

@@ -10,8 +10,8 @@ pip install msgpack-streams
 
 ## Benchmarks
 
-Average of 50 iterations each on a 3.77 MB payload, pure Python
-(`MSGPACK_PUREPYTHON=1`).
+Average of 50 iterations each on a 3.77 MB payload, pure Python 3.14.3 (with
+`MSGPACK_PUREPYTHON=1`).
 
 | Implementation                  | Operation | Speedup vs msgpack |
 | ------------------------------- | --------- | ------------------ |
@@ -20,6 +20,14 @@ Average of 50 iterations each on a 3.77 MB payload, pure Python
 | msgpack-streams `pack`          | encode    | 1.84x              |
 | msgpack-streams `pack_stream`   | encode    | 1.69x              |
 
+For PyPy 3.11.15, the pure Python performance is comparable to the `msgpack` C
+extension.
+
+| Implementation           | Operation | Speedup vs msgpack (C) |
+| ------------------------ | --------- | ---------------------- |
+| msgpack-streams `unpack` | decode    | 0.95x                  |
+| msgpack-streams `pack`   | encode    | 1.96x                  |
+
 ## Usage
 
 ```python
@@ -99,9 +107,11 @@ Use `ext_hook` to pack custom types as extensions, and `ext_hook` to decode them
 back:
 
 ```python
+from dataclasses import dataclass
 from msgpack_streams import ExtType, pack, unpack
 from fmtspec import decode, encode, types  # https://pypi.org/project/fmtspec/
 
+@dataclass
 class Point:
     EXT_CODE = 10
 
@@ -110,23 +120,23 @@ class Point:
         "y": types.u32,
     }
 
-    def __init__(self, x: int, y: int):
-        self.x, self.y = x, y
+    x: int
+    y: int
 
 def unknown_type_hook(obj):
     if isinstance(obj, Point):
         return ExtType(Point.EXT_CODE, encode(obj))
-    return None  # unsupported type → TypeError
+    return None  # unsupported type -> TypeError
 
 def ext_hook(ext):
     if ext.code == Point.EXT_CODE:
         return decode(ext.data, shape=Point)
-    return None  # unknown → keep as ExtType
+    return None  # unknown -> keep as ExtType
 
 pt = Point(1, 2)
 packed = pack(pt, ext_hook=unknown_type_hook)
 result, _ = unpack(packed, ext_hook=ext_hook)
-assert result.x == pt.x and result.y == pt.y
+assert pt == result
 ```
 
 ## API reference

pyproject.toml

@@ -7,6 +7,8 @@ classifiers = [
     "Operating System :: OS Independent",
     "Typing :: Typed",
     "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
 ]
 keywords = [
     "msgpack",

scripts/bench.py

@@ -1,3 +1,4 @@
+import gc
 import os
 
 # set before importing `msgpack`
@@ -68,6 +69,9 @@ def serialize_other(obj, mapped):
             fd.write(packb(obj))
 
 
+RAW_OBJ = stream(False)
+RAW_DATA = pack(RAW_OBJ)
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("-n", "--number", type=int, default=25, help="Number of runs")
@@ -77,40 +81,73 @@ def serialize_other(obj, mapped):
     _globals = {
         "main": main,
         "stream": stream,
+        "raw": unpack,
         "other": other,
+        "other_raw": unpackb,
+        "data": RAW_DATA,
         "mapped": args.mapped,
     }
 
     _serialize = {
         "main": serialize_main,
         "stream": serialize_stream,
+        "raw": pack,
         "other": serialize_other,
-        "obj": stream(False),
+        "other_raw": packb,
+        "obj": RAW_OBJ,
         "mapped": args.mapped,
     }
 
+    gc.disable()
+
     t_main = timeit.timeit("main(mapped)", number=args.number, globals=_globals)
     t_stream = timeit.timeit("stream(mapped)", number=args.number, globals=_globals)
+    t_raw = timeit.timeit("raw(data)", number=args.number, globals=_globals)
     t_other = timeit.timeit("other(mapped)", number=args.number, globals=_globals)
+    t_other_raw = timeit.timeit(
+        "other_raw(data, strict_map_key=False)", number=args.number, globals=_globals
+    )
+
+    gc.enable()
+    gc.collect()
 
     print(
         f"main: {t_main:.6f}s total, {t_main / args.number:.6f}s per call ({t_other / t_main:.2f}x speedup vs msgpack)"
     )
     print(
         f"stream: {t_stream:.6f}s total, {t_stream / args.number:.6f}s per call ({t_other / t_stream:.2f}x speedup vs msgpack)"
     )
+    print(
+        f"raw (unpack bytes): {t_raw:.6f}s total, {t_raw / args.number:.6f}s per call ({t_other_raw / t_raw:.2f}x speedup vs msgpack raw)"
+    )
     print(f"other (msgpack): {t_other:.6f}s total, {t_other / args.number:.6f}s per call")
+    print(
+        f"other_raw (unpackb bytes): {t_other_raw:.6f}s total, {t_other_raw / args.number:.6f}s per call"
+    )
+
+    gc.disable()
 
     t_main_s = timeit.timeit("main(obj, mapped)", number=args.number, globals=_serialize)
     t_stream_s = timeit.timeit("stream(obj, mapped)", number=args.number, globals=_serialize)
+    t_raw_s = timeit.timeit("raw(obj)", number=args.number, globals=_serialize)
     t_other_s = timeit.timeit("other(obj, mapped)", number=args.number, globals=_serialize)
+    t_other_raw_s = timeit.timeit("other_raw(obj)", number=args.number, globals=_serialize)
+
+    gc.enable()
+    gc.collect()
 
     print(
         f"main serialize: {t_main_s:.6f}s total, {t_main_s / args.number:.6f}s per call ({t_other_s / t_main_s:.2f}x speedup vs msgpack)"
     )
     print(
         f"stream serialize: {t_stream_s:.6f}s total, {t_stream_s / args.number:.6f}s per call ({t_other_s / t_stream_s:.2f}x speedup vs msgpack)"
     )
+    print(
+        f"raw serialize (pack bytes): {t_raw_s:.6f}s total, {t_raw_s / args.number:.6f}s per call ({t_other_raw_s / t_raw_s:.2f}x speedup vs msgpack raw)"
+    )
     print(
         f"other serialize (msgpack): {t_other_s:.6f}s total, {t_other_s / args.number:.6f}s per call"
     )
+    print(
+        f"other_raw serialize (packb bytes): {t_other_raw_s:.6f}s total, {t_other_raw_s / args.number:.6f}s per call"
+    )